diff --git a/.agents/skills/d2mcpp-authoring/SKILL.md b/.agents/skills/d2mcpp-authoring/SKILL.md
new file mode 100644
index 0000000..67abbfb
--- /dev/null
+++ b/.agents/skills/d2mcpp-authoring/SKILL.md
@@ -0,0 +1,182 @@
+---
+name: d2mcpp-authoring
+description: >-
+  Authoring conventions, design principles, and file formats for the d2mcpp
+  (D2X) Modern C++ tutorial project. Use this whenever you add or edit a C++
+  language-feature lesson — a book chapter, a dslings exercise, a reference
+  solution, or when registering them in SUMMARY/xmake/changelog. Trigger it for
+  any request like "add a chapter for X", "write a dslings exercise for fold
+  expressions", "add the constexpr lesson", "fill the cpp14 section", or
+  anything touching book/src, book/en/src, dslings/, or solutions/. Even small
+  edits should follow these conventions so the bilingual + book/code/checker
+  artifacts stay in sync.
+---
+
+# d2mcpp (D2X) Authoring Conventions
+
+d2mcpp teaches **Modern C++ core language features** through a tightly coupled
+quartet: **Book (mdBook) + Code (dslings exercises) + Solution + Auto-checker
+(`d2x checker`)**, all of it **bilingual (zh + en)**. A "lesson" is never one
+file — it is a coordinated set across several directories. The cardinal sin here
+is producing a half-set (a chapter with no exercise, a zh file with no en
+counterpart, an exercise not registered in xmake). This skill exists so every
+lesson lands complete and consistent.
+
+Read `references/anatomy.md` for the full directory map and the exact list of
+files every lesson must touch. Use the ready-made scaffolds in `assets/` rather
+than reconstructing format from memory.
+
+## The design principle (decide this BEFORE writing)
+
+The project is organized **by standard** (`cpp11/ cpp14/ cpp17/ cpp20/ cpp23/`).
+Honor that axis:
+
+- **Teach each feature as the standard that introduced it actually delivered
+  it** — the historical state, compiled at its introduction standard. The
+  compiler-driven (dslings) format is at its best when the learner feels the
+  C++11-era restriction first (e.g. `constexpr` single-return, `std::is_pod`,
+  copy-elision behavior). Folding every later refinement back into the
+  introduction chapter erases that, and empties out the later-standard sections.
+- **Independent later capabilities become their own chapter under the later
+  standard's section** — this is what fills `cpp14/17/20`. Examples: fold
+  expressions → cpp17, `using enum` → cpp20, designated initializers → cpp20,
+  `if constexpr` → cpp17, `decltype(auto)` → cpp14, `consteval`/`constinit` → cpp20.
+- **Pure refinements / rule-tweaks / deprecations stay in the introduction
+  chapter as a short "特性演进 / Feature Evolution" note** with a cross-link
+  forward — they are not chapter-worthy on their own. Examples: `auto x{1}`
+  deduction change, `std::is_pod` deprecation pointer, guaranteed copy elision
+  remark, P0136 inheriting-constructor semantics fix.
+- **Compile each chapter at its introduction standard.** Do not globally pin a
+  newer standard. If one exercise genuinely needs a later standard, make it an
+  **explicit, commented exception** in xmake — never a bare `-- TODO` hack.
+
+Background and the full per-feature evolution analysis live in
+`.agents/docs/2026-06-08-cpp11-feature-evolution-and-cxx20-baseline.md`. Consult
+it when deciding where a feature's later improvements should go.
+
+The decision rule, compactly:
+
+| Kind of later change | Where it goes |
+|---|---|
+| New independent syntax/ability | New chapter in the later standard's section |
+| Relaxation/tweak/deprecation | "Feature Evolution" note in the intro chapter + forward link |
+
+## The unit of work: one lesson = these files, all bilingual
+
+When adding a feature numbered `NN` with slug `topic` (e.g. `06-scoped-enums`):
+
+1. `book/src/<std>/NN-topic.md` — zh chapter
+2. `book/en/src/<std>/NN-topic.md` — en chapter (translate prose, keep code identical)
+3. `dslings/<std>/NN-topic-K.cpp` — one or more exercises (`K` = 0,1,2…), zh comments
+4. `dslings/en/<std>/NN-topic-K.cpp` — en exercises (translate comments only)
+5. `solutions/<std>/NN-topic-K.cpp` — reference solution per exercise
+6. Register each exercise target in `dslings/<std>/xmake.lua`
+7. Register each solution target in `solutions/xmake.lua`
+8. Add the chapter line to **both** `book/src/SUMMARY.md` and `book/en/src/SUMMARY.md`
+9. Add a changelog entry to **both** `book/src/changelog.md` and `book/en/src/changelog.md`
+
+Missing any of these = an incomplete lesson. `references/anatomy.md` has the
+exact registration snippets and SUMMARY/changelog line formats.
+
+## Naming and numbering
+
+- Chapter/exercise prefix is a **two-digit** sequence `NN` within the standard
+  section; slug is **kebab-case** and matches book + dslings + solutions.
+- Exercises split into `-0`, `-1`, … by sub-topic; a single-exercise chapter has
+  no numeric suffix on the dslings target name but the file is still `NN-topic.cpp`.
+- The **`d2x checker <name>`** name is the slug (and `<slug>-1`, `<slug>-2` for
+  later exercises) — it omits the `NN-` prefix. Keep checker names, file names,
+  and book references mutually consistent.
+
+## Book chapter format
+
+Use `assets/chapter.zh.md` / `assets/chapter.en.md`. Required structure, in order:
+
+1. Language-switch header `<div align=right> 🌎 [中文] | [English]` + link defs.
+   - zh links: `[中文]: ./NN-topic.html` and `[English]: ../en/<std>/NN-topic.html`
+   - en links: `[中文]: ../../<std>/NN-topic.html` and `[English]: ./NN-topic.html`
+2. `# 标题 - english name` (zh) / `# English Title` (en), then a one-paragraph
+   intro that states the feature **was introduced in C++NN** and what problem it solves.
+3. Resource table `| Book | Video | Code | X |` — cppreference link + markdown
+   permalink + video link + first practice-code permalink.
+4. Bold motivation blocks: `**为什么引入?**`, `**和……的区别?**`.
+5. Numbered Chinese-numeral sections, in order: `## 一、基础用法和场景`,
+   `## 二、真实案例 - STL 中的 <feature>`, `## 三、注意事项`,
+   `## 四、练习代码`, `## 五、其他`.
+6. `## 二、真实案例` corroborates the feature with **real, verbatim STL code**
+   quoted from the in-repo `msvc-stl/` basis — see "The 真实案例 section" below.
+7. `## 四、练习代码` lists **every** exercise topic of the chapter (`-0`, `-1`, …,
+   matching the dslings/xmake count) with dslings links as an index, but the checker
+   block shows only the **single entry** command `d2x checker <name>` — `d2x` auto-
+   advances through the remaining exercises, so do NOT list one command per exercise.
+   Then a `### 练习交流讨论` link to the chapter's forum thread. Each exercise's own
+   `d2x checker <name>-K` name and a Tips line **specific to that exercise** belong in
+   that exercise file's header, not in the book.
+8. `## 五、其他` is the fixed footer (forum / repo / video list / xlings links).
+9. If the feature evolved later, add a **`## 特性演进 / Feature Evolution`**
+   block before `## 五、其他` — introduced standard + bullet list of later
+   refinements + forward links to the later-standard chapters.
+
+Keep prose tone consistent with existing chapters: explanatory, example-driven,
+short code blocks with inline comments showing the failure and the fix.
+
+### The 真实案例 / Real-World Case section (msvc-stl basis)
+
+`## 二、真实案例` exists to prove the feature earns its place by showing **real
+production code, quoted verbatim** — never invented, never paraphrased. The single
+source of truth is the in-repo vendored MSVC STL basis at the top-level
+**`msvc-stl/`** (the complete upstream `stl/` subtree; `msvc-stl/SOURCE.md` records
+the pinned upstream commit and how to refresh it). Rules:
+
+- Quote from `msvc-stl/stl/inc/<header>` (or `src/`) **byte-for-byte**; mark any
+  elision with `(有删节)` / `(abridged)`. Do not reconstruct from memory.
+- Keep internal macros (`_NODISCARD`, `_CONSTEXPR17`, `_STD`, …) as written and add
+  one line telling the reader they are library-internal and ignorable.
+- Pick a usage that **echoes a syntax point from `## 一`** (e.g. `std::begin`'s
+  `auto … -> decltype(...)` for the auto/decltype chapter), so the section reads as
+  "you use it this way → the standard library does too".
+- **Scope-lock to the chapter's standard**: a `cpp11` chapter quotes C++11-era
+  usage only; do not show later forms (e.g. `decltype(auto)`).
+- Link to the **local `msvc-stl/` path**, not the upstream GitHub repo, so the
+  citation stays pinned to the vendored snapshot.
+- Every chapter should carry this section. If a feature genuinely has no
+  representative usage in the STL implementation, omit it and state why in the PR.
+
+## dslings exercise format
+
+Use `assets/exercise.cpp`. Essentials:
+
+- Header comment block: `d2mcpp` URL, `license: Apache-2.0`, `file:` path,
+  `Exercise/练习:` line (`<std> | NN - topic | 中文小标题`), `Tips/提示:`,
+  `Docs/文档:` (cppreference), and the `Auto-Checker/自动检测命令:` with
+  `d2x checker <name>`.
+- `#include <d2x/cpp/common.hpp>` then any std headers.
+- `main()` seeded with **intentional errors** the learner fixes, each flagged by
+  a numbered inline comment (`// 1.…`, `// 2.…`) telling them what to do.
+- Checkpoint macros from `d2x/cpp/common.hpp`:
+  - `d2x_assert(cond)` / `d2x_assert_eq(a, b)` — runtime checkpoints; learners
+    must make them pass by fixing code, **not** by deleting the checkpoint.
+  - `D2X_YOUR_ANSWER` — a fill-in placeholder the learner replaces.
+  - `D2X_WAIT` — separates exercises; learner deletes/comments it to advance.
+    Put exactly one at the end of each exercise's checkpoints.
+  - `D2X_DONT_DELETE_THIS` — guards lines that must not be removed.
+- The **en exercise translates only the comment prose**; the code stays byte-for-byte
+  identical to the zh exercise so checker behavior matches.
+
+## Reference solution format
+
+Use `assets/solution.cpp`. It is the corrected exercise with:
+
+- A solution header: `reference solution for: <exercise path>`, plus the note
+  that it is **for CI/maintainers only, not a tutorial entry**, and a pointer
+  back to the exercise file.
+- `D2X_WAIT` removed; all checkpoints passing; unused locals silenced with
+  `(void)var;` rather than left to warn.
+- Same `#include`s and structure as the exercise.
+
+## Definition of done
+
+Before claiming a lesson complete, verify the whole set exists and is wired up,
+and that the exercise/solution actually build & check. See
+`references/anatomy.md` for the verification commands (`d2x checker <name>` and
+the xmake build) — run them; do not assert success without the output.
diff --git a/.agents/skills/d2mcpp-authoring/assets/chapter.en.md b/.agents/skills/d2mcpp-authoring/assets/chapter.en.md
new file mode 100644
index 0000000..35ec161
--- /dev/null
+++ b/.agents/skills/d2mcpp-authoring/assets/chapter.en.md
@@ -0,0 +1,129 @@
+<div align=right>
+
+  🌎 [中文] | [English]
+</div>
+
+[中文]: ../../<std>/NN-topic.html
+[English]: ./NN-topic.html
+
+# English Title
+
+<One-paragraph intro: this feature was introduced in C++NN to solve …, making …>
+
+| Book | Video | Code | X |
+| --- | --- | --- | --- |
+| [cppreference](https://en.cppreference.com/w/cpp/language/...) / [markdown](https://github.com/mcpp-community/d2mcpp/blob/main/book/en/src/<std>/NN-topic.md) | [Video Explanation]() | [Practice Code](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/<std>/NN-topic-0.cpp) |  |
+
+
+**Why was it introduced?**
+
+- <motivation 1>
+- <motivation 2>
+
+**How does it differ from …?**
+
+- <contrast 1>
+- <contrast 2>
+
+## I. Basic Usage and Scenarios
+
+### <subsection title>
+
+<explanation + short code blocks; comment the wrong vs. correct form inline>
+
+```cpp
+// example code
+```
+
+<!-- Every chapter should include this section; the code must be quoted verbatim
+     from the in-repo msvc-stl/ basis (see the "Real-world case / msvc-stl"
+     convention in SKILL.md). If a feature has no representative usage in the STL
+     implementation, this section may be omitted with a reason noted in the PR. -->
+## II. Real-World Case - <feature> in the STL
+
+> Corroborates how the feature is actually used in production-grade code. The snippet is taken from the in-repo MSVC STL reference basis [`msvc-stl/`](https://github.com/mcpp-community/d2mcpp/tree/main/msvc-stl) (source file [`stl/inc/<header>`](https://github.com/mcpp-community/d2mcpp/blob/main/msvc-stl/stl/inc/<header>)); `_NODISCARD` / `_CONSTEXPR17` / `_STD` are internal library macros — ignore them when reading
+
+### <real-usage heading echoing a syntax point from section I>
+
+<one line: why the standard library must use the feature here — un-writable / awkward by hand>
+
+```cpp
+// MSVC STL · stl/inc/<header> (abridged)
+// <verbatim excerpt of the real code; mark omissions with (abridged), never paraphrase from memory>
+```
+
+<tie it back to the toy example in section I: you write it this way → the standard library writes it this way too — one of the core motivations for introducing the feature>
+
+## III. Notes and Caveats
+
+### <pitfall / migration advice>
+
+<explanation>
+
+<!-- Practice Topics list ALL exercises (-0, -1, …, matching the dslings/xmake count)
+     as an index; but the checker block shows only the SINGLE entry command
+     `d2x checker <name>` — d2x auto-advances through the rest, no need to list each.
+     Each exercise's own checker name + a Tips line specific to that exercise live in
+     that exercise file's header. The discussion link comes from the exercises'
+     "练习交流讨论" header (usually one shared thread per chapter). -->
+## IV. Practice Code
+
+### Practice Topics
+
+- 0 - [<exercise 0 topic>](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/<std>/NN-topic-0.cpp)
+- 1 - [<exercise 1 topic>](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/<std>/NN-topic-1.cpp)
+
+### Auto-Checker Commands
+
+<!-- The tool-setup commands are fixed — copy this block verbatim. Put the <details>
+     BEFORE the checker command (setup first, then the run command). Blank lines
+     around the inner code fence are REQUIRED for mdBook to render it. -->
+<details>
+<summary>Don't have d2x yet? Click to expand setup</summary>
+
+```bash
+# 1. Install xlings (Linux / macOS)
+curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash
+# Windows PowerShell:
+# irm https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.ps1 | iex
+
+# 2. Install d2x and fetch this tutorial
+xlings install d2x -y
+d2x install d2mcpp
+
+# 3. Enter the project directory & run the checker
+cd d2mcpp
+```
+
+</details>
+
+```
+d2x checker <name>
+```
+
+### Exercise Discussion
+
+- [<this chapter's exercise thread>](https://forum.d2learn.org/post/NNN)
+
+<!-- Optional: include only if the feature evolved in later standards. Pure
+     refinements/deprecations belong here; independent new capabilities get
+     their own chapter in the later standard's section, linked forward here.
+     Placement: immediately before ## V. Additional Resources. -->
+## Feature Evolution
+
+> **Introduced in**: C++NN
+> **Later improvements**:
+> - **C++14**: <...>
+> - **C++17**: <...> (see [the dedicated chapter](../<later-std>/MM-xxx.md))
+> - **C++20**: <...>
+>
+> **Teaching note**: <cross-standard behavior differences / deprecation / why this exercise uses an exception standard>
+
+## V. Additional Resources
+
+- [Discussion Forum](https://forum.d2learn.org/category/20)
+- [d2mcpp Tutorial Repo](https://github.com/mcpp-community/d2mcpp)
+- [mcpp-community Organization](https://github.com/mcpp-community)
+- [Tutorial Video List](https://space.bilibili.com/65858958/lists/5208246)
+- [Tutorial Tooling - xlings](https://github.com/openxlings/xlings)
+- [Exercise Checker - d2x](https://github.com/d2learn/d2x)
diff --git a/.agents/skills/d2mcpp-authoring/assets/chapter.zh.md b/.agents/skills/d2mcpp-authoring/assets/chapter.zh.md
new file mode 100644
index 0000000..552e543
--- /dev/null
+++ b/.agents/skills/d2mcpp-authoring/assets/chapter.zh.md
@@ -0,0 +1,124 @@
+<div align=right>
+
+  🌎 [中文] | [English]
+</div>
+
+[中文]: ./NN-topic.html
+[English]: ../en/<std>/NN-topic.html
+
+# 标题 - english name
+
+<一段话简介:该特性由 C++NN 引入,用于解决……,让……>
+
+| Book | Video | Code | X |
+| --- | --- | --- | --- |
+| [cppreference](https://en.cppreference.com/w/cpp/language/...) / [markdown](https://github.com/mcpp-community/d2mcpp/blob/main/book/src/<std>/NN-topic.md) | [视频解读]() | [练习代码](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/<std>/NN-topic-0.cpp) |  |
+
+
+**为什么引入?**
+
+- <动机 1>
+- <动机 2>
+
+**和……的区别?**
+
+- <对比点 1>
+- <对比点 2>
+
+## 一、基础用法和场景
+
+### <小节标题>
+
+<讲解 + 短代码块,代码内用注释标出"错误写法"与"正确写法">
+
+```cpp
+// 示例代码
+```
+
+<!-- 每章应有本节;代码必须取自仓库内 msvc-stl/ 并逐字摘录(见 SKILL.md 的
+     「真实案例 / msvc-stl」约定)。若该特性在 STL 实现中确无代表性用例,
+     可省略本节并在 PR 说明原因。 -->
+## 二、真实案例 - STL 中的 <特性>
+
+> 印证该特性在生产级代码中的真实用法。代码取自仓库内置的 MSVC STL 引用基底 [`msvc-stl/`](https://github.com/mcpp-community/d2mcpp/tree/main/msvc-stl)(源文件 [`stl/inc/<header>`](https://github.com/mcpp-community/d2mcpp/blob/main/msvc-stl/stl/inc/<header>));`_NODISCARD` / `_CONSTEXPR17` / `_STD` 等为库内部宏,阅读时可忽略
+
+### <真实用法小标题,呼应「一」中的某个语法点>
+
+<一句话:标准库为什么必须这样用该特性,人手写不出 / 写不优雅>
+
+```cpp
+// MSVC STL · stl/inc/<header> (有删节)
+// <逐字摘录真实代码;删减处保留 (有删节) 标注,切勿凭记忆改写>
+```
+
+<把它和「一」里的玩具示例对应起来:你这样用 → 标准库自己也这样写。这也是该特性被引入的核心动机之一>
+
+## 三、注意事项
+
+### <易错点 / 迁移建议>
+
+<讲解>
+
+<!-- 练习主题列出本章【全部】练习(-0、-1、…,与 dslings/xmake 注册数一致),作为索引;
+     但检测命令只放【入口一条】 d2x checker <name> —— d2x 会自动逐个往下推进,无需逐条列出。
+     各练习自己的 checker 名 + 针对本练习的 Tips 放在对应练习文件的头注释里。
+     讨论帖取各练习头注释里的「练习交流讨论」链接(全章通常同一帖)。 -->
+## 四、练习代码
+
+### 练习代码主题
+
+- 0 - [<练习 0 主题>](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/<std>/NN-topic-0.cpp)
+- 1 - [<练习 1 主题>](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/<std>/NN-topic-1.cpp)
+
+### 练习代码自动检测命令
+
+<!-- 获取工具命令固定不变,可整段照抄;<details> 放在检测命令【之前】(先给获取方式、再给运行命令);
+     <details> 内代码块前后必须留空行才会被 mdBook 渲染 -->
+<details>
+<summary>还没有 d2x?点击展开获取方式</summary>
+
+```bash
+# 1. 安装 xlings(Linux / macOS)
+curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash
+# Windows PowerShell:
+# irm https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.ps1 | iex
+
+# 2. 安装 d2x 并拉取本教程
+xlings install d2x -y
+d2x install d2mcpp
+
+# 3. 进入项目目录 & 运行检查命令
+cd d2mcpp
+```
+
+</details>
+
+```
+d2x checker <name>
+```
+
+### 练习交流讨论
+
+- [<本章练习讨论帖>](https://forum.d2learn.org/post/NNN)
+
+<!-- 可选:仅当该特性在后续标准有演进时加入。纯细化/弃用写在这里;
+     可独立成章的新能力应在对应标准章节单独成篇并在此前向链接。
+     位置:置于 ## 五、其他 之前。 -->
+## 特性演进 / Feature Evolution
+
+> **引入标准**:C++NN
+> **后续优化**:
+> - **C++14**:<...>
+> - **C++17**:<...>(详见 [对应章节](../<later-std>/MM-xxx.md))
+> - **C++20**:<...>
+>
+> **教学提示**:<跨标准行为差异 / 弃用 / 本练习为何用例外标准>
+
+## 五、其他
+
+- [交流讨论](https://forum.d2learn.org/category/20)
+- [d2mcpp教程仓库](https://github.com/mcpp-community/d2mcpp)
+- [mcpp-community 社区](https://github.com/mcpp-community)
+- [教程视频列表](https://space.bilibili.com/65858958/lists/5208246)
+- [教程支持工具-xlings](https://github.com/openxlings/xlings)
+- [教程检测工具-d2x](https://github.com/d2learn/d2x)
diff --git a/.agents/skills/d2mcpp-authoring/assets/exercise.cpp b/.agents/skills/d2mcpp-authoring/assets/exercise.cpp
new file mode 100644
index 0000000..0ca3d10
--- /dev/null
+++ b/.agents/skills/d2mcpp-authoring/assets/exercise.cpp
@@ -0,0 +1,36 @@
+// d2mcpp: https://github.com/mcpp-community/d2mcpp
+// license: Apache-2.0
+// file: dslings/<std>/NN-topic-K.cpp
+//
+// Exercise/练习: <std> | NN - topic | <中文小标题>
+//
+// Tips/提示: <针对【本练习子主题】的一句话提示,需与本文件内容对应,避免「修复代码中的错误」这类通用话术>
+//
+// Docs/文档:
+//   - https://en.cppreference.com/w/cpp/language/...
+//
+// Auto-Checker/自动检测命令:
+//
+//   d2x checker <name>
+//
+
+#include <d2x/cpp/common.hpp>
+
+#include <iostream>
+
+int main() {
+
+    // 1.<要修复的点>: <说明,例如:修复这个编译错误 / 改成正确类型>
+    int a = 1.1; // <提示>
+
+    d2x_assert_eq(a, 1.1); // 运行时检查点:需修复代码使其通过(不要删除检查点)
+
+    // 2.<填空点>: 用正确的代码替换 D2X_YOUR_ANSWER
+    D2X_YOUR_ANSWER b = a; // <提示:给 b 一个合适的类型>
+
+    d2x_assert_eq(b, 1);
+
+    D2X_WAIT // 删除或注释掉本宏进入下一个练习
+
+    return 0;
+}
diff --git a/.agents/skills/d2mcpp-authoring/assets/solution.cpp b/.agents/skills/d2mcpp-authoring/assets/solution.cpp
new file mode 100644
index 0000000..65857f3
--- /dev/null
+++ b/.agents/skills/d2mcpp-authoring/assets/solution.cpp
@@ -0,0 +1,29 @@
+// d2mcpp: https://github.com/mcpp-community/d2mcpp
+// license: Apache-2.0
+// reference solution for: dslings/<std>/NN-topic-K.cpp
+//
+// 用途: 仅给 CI 与维护者参考使用，不是教程入口。
+// 教程练习入口: dslings/<std>/NN-topic-K.cpp
+//
+
+#include <d2x/cpp/common.hpp>
+
+#include <iostream>
+
+int main() {
+
+    // 1.<已修复>: 说明保持与练习一致,但代码为正确版本
+    double a = 1.1;
+
+    d2x_assert_eq(a, 1.1);
+
+    // 2.<已填空>
+    double b = a;
+    (void)b; // 用 (void) 抑制未使用告警,不要留下会触发 warning 的代码
+
+    d2x_assert_eq(b, 1.1);
+
+    // 注意: 参考答案中删除 D2X_WAIT,且所有检查点均通过
+
+    return 0;
+}
diff --git a/.agents/skills/d2mcpp-authoring/references/anatomy.md b/.agents/skills/d2mcpp-authoring/references/anatomy.md
new file mode 100644
index 0000000..cdd4dee
--- /dev/null
+++ b/.agents/skills/d2mcpp-authoring/references/anatomy.md
@@ -0,0 +1,126 @@
+# Lesson Anatomy & Registration
+
+The exact directory map, registration snippets, and verification commands for a
+d2mcpp lesson. `<std>` is the standard section (`cpp11`, `cpp14`, …); `NN` is the
+two-digit chapter number; `topic` is the kebab-case slug; `K` is the
+sub-exercise index (`0`, `1`, …); `<name>` is the `d2x checker` name (the slug,
+or `slug-1`, `slug-2` for later exercises).
+
+## Directory map
+
+```
+book/src/<std>/NN-topic.md            # zh chapter
+book/en/src/<std>/NN-topic.md         # en chapter
+book/src/SUMMARY.md                   # zh TOC  (register here)
+book/en/src/SUMMARY.md                # en TOC  (register here)
+book/src/changelog.md                 # zh changelog (add entry)
+book/en/src/changelog.md              # en changelog (add entry)
+
+dslings/<std>/NN-topic-K.cpp          # zh exercise(s)
+dslings/en/<std>/NN-topic-K.cpp       # en exercise(s)
+dslings/<std>/xmake.lua               # register exercise target(s)
+
+solutions/<std>/NN-topic-K.cpp        # reference solution(s)
+solutions/xmake.lua                   # register solution target(s) (includes <std>)
+```
+
+Repo-level shared basis (NOT per-lesson, created once, never edited by hand):
+
+```
+msvc-stl/                             # vendored MSVC STL `stl/` subtree (read-only)
+msvc-stl/stl/inc/<header>             # what the chapter's `## 二、真实案例` quotes from
+msvc-stl/SOURCE.md                    # pinned upstream commit + refresh steps
+msvc-stl/LICENSE.txt, NOTICE.txt      # upstream license, kept verbatim
+```
+
+The `## 二、真实案例` section of every chapter links into `msvc-stl/` for its
+verbatim STL excerpt; you do not add files here per lesson — only refresh the
+snapshot via `msvc-stl/SOURCE.md` when needed.
+
+A new `<std>` section that does not exist yet also needs: an `includes("<std>")`
+line wired from `dslings/xmake.lua` and `solutions/xmake.lua`, a `dslings/<std>/`
+and `dslings/en/<std>/` directory, a `solutions/<std>/` directory, and the
+section heading in both `SUMMARY.md` files (e.g. `# C++14核心语言特性` /
+`# C++14 Core Language Features`).
+
+## xmake registration — exercises (`dslings/<std>/xmake.lua`)
+
+Append one target per exercise file. Binary kind is the default; only set it
+where existing siblings do. Example for a two-exercise chapter:
+
+```lua
+-- target: <std>-NN-topic
+
+target("<std>-NN-topic-0")
+    add_files("NN-topic-0.cpp")
+
+target("<std>-NN-topic-1")
+    add_files("NN-topic-1.cpp")
+```
+
+Per-target options seen in the repo, use only when the lesson needs them:
+
+```lua
+target("cpp11-04-rvalue-references")
+    set_optimize("none")
+    add_cxxflags("-fno-elide-constructors")   -- observe moves; note C++17 guaranteed elision can't be disabled
+    add_files("04-rvalue-references.cpp")
+```
+
+If an exercise needs a non-default standard, make it an **explicit, commented
+exception** — never a bare TODO:
+
+```lua
+target("cppNN-NN-topic-0")
+    set_languages("c++17")   -- exception: <one-line reason this lesson needs c++17>
+    add_files("NN-topic-0.cpp")
+```
+
+The default standard is set at the top of `dslings/<std>/xmake.lua`. Per the
+design principle, that should be the **introduction standard** of the section
+(e.g. `set_languages("c++11")` for `cpp11`). Avoid per-host standard forks; if
+one is unavoidable, comment why.
+
+## xmake registration — solutions (`solutions/xmake.lua` + `solutions/<std>/xmake.lua`)
+
+Mirror the exercise targets so CI builds the reference solutions too. Follow the
+existing pattern in `solutions/<std>/xmake.lua`.
+
+## SUMMARY registration
+
+Add the chapter under the correct standard heading, keeping numeric order.
+
+zh — `book/src/SUMMARY.md`:
+```markdown
+- [标题 - english name](./<std>/NN-topic.md)
+```
+
+en — `book/en/src/SUMMARY.md`:
+```markdown
+- [English Title](./<std>/NN-topic.md)
+```
+
+## Changelog entry
+
+Add a dated entry to both `book/src/changelog.md` and `book/en/src/changelog.md`
+under the current `## YYYY/MM` heading (create the month heading if missing).
+Follow the existing entry shape — feature title, then `Book` / `Code` (and
+`video` when available) links with per-artifact dates. Convert any relative date
+to an absolute `YYYY/MM/DD`.
+
+## Verification (definition of done)
+
+Run from the project root; report real output, do not assert success blind:
+
+```bash
+# build the exercise + solution targets (lang defaults come from xmake)
+xmake f -c >/dev/null && xmake build cppNN-NN-topic-0
+
+# drive the auto-checker against the exercise (expects the unsolved exercise to fail,
+# the solution to pass) — name omits the NN- prefix
+d2x checker <name>
+```
+
+Bilingual sync check: every file in the zh column has its en counterpart, code
+bodies are identical between zh/en exercises, and both SUMMARY + both changelog
+files were updated.
diff --git a/.gitignore b/.gitignore
index caa2e79..683495e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,6 +34,9 @@
 # Python
 __pycache__
 
+# temporary upstream STL clone (vendored subset lives in /msvc-stl)
+/STL/
+
 # d2x project files
 .xlings
 .vscode
diff --git a/book/en/src/cpp11/00-auto-and-decltype.md b/book/en/src/cpp11/00-auto-and-decltype.md
index 6993249..eebb1f4 100644
--- a/book/en/src/cpp11/00-auto-and-decltype.md
+++ b/book/en/src/cpp11/00-auto-and-decltype.md
@@ -44,7 +44,7 @@ decltype(b) b3; // Can be used without initialization
 
 > Often used for complex expression type deduction to ensure calculation precision
 
-```c++
+```cpp
 int a = 1;
 
 auto b1 = a + 2;
@@ -58,7 +58,7 @@ decltype(2 + 'a') c2 = 2 + 'a';
 
 **Iterator Type Deduction**
 
-```c++
+```cpp
 std::vector<int> v = {1, 2, 3};
 
 auto it = v.begin(); // Automatically deduce iterator type
@@ -72,7 +72,7 @@ for (; it != v.end(); ++it) {
 
 > For complex types like functions or lambda expressions, auto and decltype are commonly used. Generally, lambda definitions use auto, while template type parameters use decltype.
 
-```c++
+```cpp
 int add_func(int a, int b) {
     return a + b;
 }
@@ -135,7 +135,65 @@ int main() {
 }
 ```
 
-## II. Important Notes - The Impact of Parentheses
+## II. Real-World Case - auto/decltype in the STL
+
+> The examples above illustrate syntax; the real value of auto/decltype shows up most directly in the standard library's own implementation. Below we use the in-repo [MSVC STL](https://github.com/mcpp-community/d2mcpp/tree/main/msvc-stl) as the source ([`msvc-stl/stl/inc/xutility`](https://github.com/mcpp-community/d2mcpp/blob/main/msvc-stl/stl/inc/xutility#L2200-L2235)); `_EXPORT_STD` / `_NODISCARD` / `_CONSTEXPR17` / `_STD` are internal library macros — ignore them when reading.
+
+### Trailing return type + decltype: std::begin / std::end
+
+`std::begin` / `std::end` (added in C++11) must adapt to any container; their return type depends entirely on `_Cont.begin()` and cannot be written ahead of time, so they "borrow" it via `auto ... -> decltype(...)`
+
+```cpp
+// MSVC STL · msvc-stl/stl/inc/xutility (abridged)
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto begin(_Container& _Cont) noexcept(noexcept(_Cont.begin())) -> decltype(_Cont.begin()) {
+    return _Cont.begin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto end(_Container& _Cont) noexcept(noexcept(_Cont.end())) -> decltype(_Cont.end()) {
+    return _Cont.end();
+}
+```
+
+This is exactly the trailing-return form from the "Function Return Type Deduction" section, living inside the standard library itself: `auto` as the placeholder + `decltype(_Cont.begin())` precisely deducing the differing iterator types of `vector<int>`, `list<T>`, and so on.
+
+### Reusing another function's return type with decltype: std::cbegin / std::cend
+
+Going further, `std::cbegin` simply reuses `begin`'s return type via `decltype(_STD begin(_Cont))` — it doesn't care what that type is, only that it "matches what begin returns"
+
+```cpp
+// MSVC STL · msvc-stl/stl/inc/xutility (abridged)
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD begin(_Cont)))
+    -> decltype(_STD begin(_Cont)) {
+    return _STD begin(_Cont);
+}
+```
+
+> Takeaway: when a type "is decided by template parameters and simply cannot be written by hand", the standard library reaches for exactly the auto + decltype toolkit taught in this chapter — one of the core motivations for introducing them in C++11.
+
+## III. Important Notes
+
+### auto and const / reference stripping
+
+> auto deduction **strips top-level const and references**; to keep them you must write `const auto&` / `auto&` explicitly, whereas decltype preserves the declared type exactly
+
+```cpp
+const int ci = 1;
+int n = 2;
+int& ri = n;
+
+auto a = ci;          // int — top-level const stripped
+auto b = ri;          // int — reference stripped (b is an independent copy of n)
+
+const auto& r1 = ci;  // const int& — preserved via const auto&
+auto&& r2 = ci;       // const int& — forwarding reference keeps it
+
+decltype(ci) d = ci;  // const int — decltype preserves exactly
+```
+
+This is also why `auto a = obj.a;` in "Class/Struct Member Type Deduction" yields `int` rather than `const int` — auto stripped the top-level const.
 
 ### Difference between decltype(obj) and decltype( (obj) )
 
@@ -181,9 +239,51 @@ decltype(b) // Deduction result is declared type int &&
 decltype( (b) ) // Deduction result is int &
 ```
 
-## III. Additional Resources
+## IV. Practice Code
+
+### Practice Topics
+
+- 0 - [Declaration & Definition](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-0.cpp)
+- 1 - [Expression Type Deduction](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-1.cpp)
+- 2 - [Complex Type Deduction - Iterator / Function](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-2.cpp)
+- 3 - [Function Return Type Deduction](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-3.cpp)
+- 4 - [Class/Struct Member Type Deduction](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-4.cpp)
+- 5 - [const & Reference Stripping and Preservation](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-5.cpp)
+
+### Auto-Checker Commands
+
+<details>
+<summary>Don't have d2x yet? Click to expand setup</summary>
+
+```bash
+# 1. Install xlings (Linux / macOS)
+curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash
+# Windows PowerShell:
+# irm https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.ps1 | iex
+
+# 2. Install d2x and fetch this tutorial
+xlings install d2x -y
+d2x install d2mcpp
+
+# 3. Enter the project directory & run the checker
+cd d2mcpp
+```
+
+</details>
+
+```
+d2x checker auto-and-decltype
+```
+
+### Exercise Discussion
+
+- [auto/decltype exercise thread](https://forum.d2learn.org/post/357)
+
+## V. Additional Resources
 
 - [Discussion Forum](https://forum.d2learn.org/category/20)
 - [d2mcpp Tutorial Repository](https://github.com/mcpp-community/d2mcpp)
+- [mcpp-community Organization](https://github.com/mcpp-community)
 - [Tutorial Video List](https://space.bilibili.com/65858958/lists/5208246)
 - [Tutorial Support Tool - xlings](https://github.com/openxlings/xlings)
+- [Exercise Checker - d2x](https://github.com/d2learn/d2x)
diff --git a/book/src/cpp11/00-auto-and-decltype.md b/book/src/cpp11/00-auto-and-decltype.md
index 9162bea..7384c6f 100644
--- a/book/src/cpp11/00-auto-and-decltype.md
+++ b/book/src/cpp11/00-auto-and-decltype.md
@@ -8,7 +8,7 @@
 
 # 类型自动推导 - auto和decltype
 
-auto 和 decltype 是C++11引入的强有力的**类型自动推导**工具. 不仅让代码变的更加简洁, 还增强了模板和泛型的表达能力
+auto 和 decltype 是C++11引入的强有力的**类型自动推导**工具. 不仅让代码变得更加简洁, 还增强了模板和泛型的表达能力
 
 | Book | Video | Code | X |
 | --- | --- | --- | --- |
@@ -23,7 +23,7 @@ auto 和 decltype 是C++11引入的强有力的**类型自动推导**工具. 不
 
 **auto和decltype有什么区别?**
 
-- auto常常用于变量定义, 推导的类型可能丢失const或引用(可显示指定进行保留auto &)
+- auto常常用于变量定义, 推导的类型可能丢失const或引用(可显式指定进行保留auto &)
 - decltype获取表达式的**精确类型**
 - auto通常无法作为模板类型参数使用
 
@@ -31,7 +31,7 @@ auto 和 decltype 是C++11引入的强有力的**类型自动推导**工具. 不
 
 ### 声明定义
 
-> 充当类型站位符, 辅助变量的定义或声明。使用auto时变量必须要初始化, decltype可以不用初始化
+> 充当类型占位符, 辅助变量的定义或声明。使用auto时变量必须要初始化, decltype可以不用初始化
 
 ```cpp
 int b = 2;
@@ -44,7 +44,7 @@ decltype(b) b3; // 可以不用初始化
 
 > 常常用于复杂表达式的类型推导, 确保计算精度
 
-```c++
+```cpp
 int a = 1;
 
 auto b1 = a + 2;
@@ -58,7 +58,7 @@ decltype(2 + 'a') c2 = 2 + 'a';
 
 **迭代器类型推导**
 
-```c++
+```cpp
 std::vector<int> v = {1, 2, 3};
 
 auto it = v.begin(); // 自动推导it类型
@@ -72,7 +72,7 @@ for (; it != v.end(); ++it) {
 
 > 对于函数或lambda表达式这种复杂类型, 常常使用auto和decltype. 一般, lambda定义用auto,  模板类型参数用decltype
 
-```c++
+```cpp
 int add_func(int a, int b) {
     return a + b;
 }
@@ -135,11 +135,69 @@ int main() {
 }
 ```
 
-## 二、注意事项 - 括号带来的影响
+## 二、真实案例 - STL 中的 auto/decltype
+
+> 前面的例子是为了讲语法, 而 auto/decltype 真正的价值, 在标准库自己的实现里体现得最直接。下面以仓库内置的 [MSVC STL](https://github.com/mcpp-community/d2mcpp/tree/main/msvc-stl) 为例 (源码: [`msvc-stl/stl/inc/xutility`](https://github.com/mcpp-community/d2mcpp/blob/main/msvc-stl/stl/inc/xutility#L2200-L2235)); `_EXPORT_STD` / `_NODISCARD` / `_CONSTEXPR17` / `_STD` 是库内部宏, 阅读时可忽略
+
+### 后置返回类型 + decltype:std::begin / std::end
+
+`std::begin` / `std::end` (C++11 新增) 要适配任意容器, 返回类型完全取决于 `_Cont.begin()`, 没法提前写死, 于是直接用 `auto ... -> decltype(...)` 把返回类型"借"过来
+
+```cpp
+// MSVC STL · msvc-stl/stl/inc/xutility (有删节)
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto begin(_Container& _Cont) noexcept(noexcept(_Cont.begin())) -> decltype(_Cont.begin()) {
+    return _Cont.begin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto end(_Container& _Cont) noexcept(noexcept(_Cont.end())) -> decltype(_Cont.end()) {
+    return _Cont.end();
+}
+```
+
+这正是本章「函数返回值类型推导」一节讲的后置返回写法在标准库里的真身: `auto` 占位 + `decltype(_Cont.begin())` 精确推导出 `vector<int>::iterator`、`list<T>::iterator` 等各不相同的迭代器类型
+
+### 用 decltype 复用另一个函数的返回类型:std::cbegin / std::cend
+
+更进一步, `std::cbegin` 干脆用 `decltype(_STD begin(_Cont))` 直接复用了 `begin` 的返回类型 —— 不必关心它到底是什么, 只要"和 begin 返回的一样"就行
+
+```cpp
+// MSVC STL · msvc-stl/stl/inc/xutility (有删节)
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD begin(_Cont)))
+    -> decltype(_STD begin(_Cont)) {
+    return _STD begin(_Cont);
+}
+```
+
+> 小结: 面对"类型由模板参数决定、人手根本写不出来"的场景, 标准库用的正是本章这套 auto + decltype 工具。这也是 C++11 当初引入它们的核心动机之一
+
+## 三、注意事项
+
+### auto 的 const / 引用剥离
+
+> auto 推导会**剥离顶层 const 和引用**, 想保留得显式写 `const auto&` / `auto&`; decltype 则精确保留声明类型
+
+```cpp
+const int ci = 1;
+int n = 2;
+int& ri = n;
+
+auto a = ci;          // int —— 顶层 const 被剥离
+auto b = ri;          // int —— 引用被剥离, b 是 n 的独立副本
+
+const auto& r1 = ci;  // const int& —— 用 const auto& 保留
+auto&& r2 = ci;       // const int& —— 万能引用按需保留
+
+decltype(ci) d = ci;  // const int —— decltype 精确保留
+```
+
+这也解释了前面「类/结构体成员类型推导」里 `auto a = obj.a;` 为什么得到的是 `int` 而非 `const int` —— 顶层 const 被 auto 剥离了
 
 ### decltype(obj) 和 decltype( (obj) )的区别
 
-- 一般`decltype(obj)`获取的时其声明类型
+- 一般`decltype(obj)`获取的是其声明类型
 - 而`decltype( (obj) )` 获取的是 `(obj)` 这个表达式的类型(左值表达式)
 
 ```cpp
@@ -181,9 +239,51 @@ decltype(b) // 推导结果是声明类型 int &&
 decltype( (b) ) // 推导结果是 int &
 ```
 
-## 三、其他
+## 四、练习代码
+
+### 练习代码主题
+
+- 0 - [声明定义](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-0.cpp)
+- 1 - [表达式类型推导](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-1.cpp)
+- 2 - [复杂类型推导 - 迭代器 / 函数](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-2.cpp)
+- 3 - [函数返回值类型推导](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-3.cpp)
+- 4 - [类/结构体成员类型推导](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-4.cpp)
+- 5 - [const 与引用的剥离和保留](https://github.com/mcpp-community/d2mcpp/blob/main/dslings/cpp11/00-auto-and-decltype-5.cpp)
+
+### 练习代码自动检测命令
+
+<details>
+<summary>还没有 d2x?点击展开获取方式</summary>
+
+```bash
+# 1. 安装 xlings(Linux / macOS)
+curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash
+# Windows PowerShell:
+# irm https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.ps1 | iex
+
+# 2. 安装 d2x 并拉取本教程
+xlings install d2x -y
+d2x install d2mcpp
+
+# 3. 进入项目目录 & 运行检查命令
+cd d2mcpp
+```
+
+</details>
+
+```
+d2x checker auto-and-decltype
+```
+
+### 练习交流讨论
+
+- [auto/decltype 练习讨论帖](https://forum.d2learn.org/post/357)
+
+## 五、其他
 
 - [交流讨论](https://forum.d2learn.org/category/20)
 - [d2mcpp教程仓库](https://github.com/mcpp-community/d2mcpp)
+- [mcpp-community 社区](https://github.com/mcpp-community)
 - [教程视频列表](https://space.bilibili.com/65858958/lists/5208246)
-- [教程支持工具-xlings](https://github.com/openxlings/xlings)
\ No newline at end of file
+- [教程支持工具-xlings](https://github.com/openxlings/xlings)
+- [教程检测工具-d2x](https://github.com/d2learn/d2x)
\ No newline at end of file
diff --git a/dslings/cpp11/00-auto-and-decltype-0.cpp b/dslings/cpp11/00-auto-and-decltype-0.cpp
index 8172b9c..3e8e3a4 100644
--- a/dslings/cpp11/00-auto-and-decltype-0.cpp
+++ b/dslings/cpp11/00-auto-and-decltype-0.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise/练习: cpp11 | 00 - auto and decltype | 自动类型推导
 //
-// Tips/提示: 使用 auto 和 decltype 修复代码中的错误
+// Tips/提示: 用 auto 从初始值推导类型, 用 decltype 取已声明变量的类型
 //
 // Docs/文档:
 //   - https://en.cppreference.com/w/cpp/language/auto
@@ -39,6 +39,8 @@ int main() {
     d2x_assert_eq(a1, a2);
     d2x_assert_eq(b, b1);
     d2x_assert_eq(b1, b2);
+    d2x_assert_eq(c, c1);
+    d2x_assert_eq(c1, c2);
 
     D2X_WAIT
 
diff --git a/dslings/cpp11/00-auto-and-decltype-1.cpp b/dslings/cpp11/00-auto-and-decltype-1.cpp
index e78a921..29d76f9 100644
--- a/dslings/cpp11/00-auto-and-decltype-1.cpp
+++ b/dslings/cpp11/00-auto-and-decltype-1.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise/练习: cpp11 | 00 - auto and decltype | 表达式类型推导
 //
-// Tips/提示: 使用 auto 和 decltype 修复代码中的错误
+// Tips/提示: 含浮点的表达式要推导成 double, 别用 int 截断了精度
 //
 // Docs/文档:
 //   - https://en.cppreference.com/w/cpp/language/auto
diff --git a/dslings/cpp11/00-auto-and-decltype-2.cpp b/dslings/cpp11/00-auto-and-decltype-2.cpp
index ef51d99..8b3fa4c 100644
--- a/dslings/cpp11/00-auto-and-decltype-2.cpp
+++ b/dslings/cpp11/00-auto-and-decltype-2.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise/练习: cpp11 | 00 - auto and decltype | 复杂类型推导
 //
-// Tips/提示: 使用 auto 和 decltype 修复代码中的错误
+// Tips/提示: 迭代器用 auto, std::function 的模板参数用 decltype(函数名), 替代手写长类型
 //
 // Docs/文档:
 //   - https://en.cppreference.com/w/cpp/language/auto
diff --git a/dslings/cpp11/00-auto-and-decltype-3.cpp b/dslings/cpp11/00-auto-and-decltype-3.cpp
index 1fa8d48..a75fc96 100644
--- a/dslings/cpp11/00-auto-and-decltype-3.cpp
+++ b/dslings/cpp11/00-auto-and-decltype-3.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise/练习: cpp11 | 00 - auto and decltype | 函数返回值类型推导
 //
-// Tips/提示: 使用 auto 和 decltype 修复代码中的错误
+// Tips/提示: 用后置返回 auto ... -> decltype(a - b) 让模板函数自动推导返回类型
 //
 // Docs/文档:
 //   - https://en.cppreference.com/w/cpp/language/auto
diff --git a/dslings/cpp11/00-auto-and-decltype-4.cpp b/dslings/cpp11/00-auto-and-decltype-4.cpp
index 262588d..aadb47f 100644
--- a/dslings/cpp11/00-auto-and-decltype-4.cpp
+++ b/dslings/cpp11/00-auto-and-decltype-4.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise/练习: cpp11 | 00 - auto and decltype | 类/结构体成员类型推导
 //
-// Tips/提示: 在D2X_YOUR_ANSWER处填写正确的推导类型
+// Tips/提示: 区分 decltype(obj) 与 decltype((obj)), 带括号是表达式会推导出引用类型
 //
 // Docs/文档:
 //   - https://en.cppreference.com/w/cpp/language/auto
diff --git a/dslings/cpp11/00-auto-and-decltype-5.cpp b/dslings/cpp11/00-auto-and-decltype-5.cpp
new file mode 100644
index 0000000..0cd35bd
--- /dev/null
+++ b/dslings/cpp11/00-auto-and-decltype-5.cpp
@@ -0,0 +1,58 @@
+// d2mcpp: https://github.com/mcpp-community/d2mcpp
+// license: Apache-2.0
+// file: dslings/cpp11/00-auto-and-decltype-5.cpp
+//
+// Exercise/练习: cpp11 | 00 - auto and decltype | const 与引用的剥离和保留
+//
+// Tips/提示: auto 会剥离顶层 const 和引用, 用 const auto& / auto& 保留, decltype 精确保留
+//
+// Docs/文档:
+//   - https://en.cppreference.com/w/cpp/language/auto
+//   - https://en.cppreference.com/w/cpp/language/decltype
+//   - https://github.com/mcpp-community/d2mcpp/blob/main/book/src/cpp11/00-auto-and-decltype.md
+//
+// 练习交流讨论: http://forum.d2learn.org/post/357
+//
+// Auto-Checker/自动检测命令:
+//
+//   d2x checker auto-and-decltype-5
+//
+
+#include <d2x/cpp/common.hpp>
+
+#include <type_traits>
+
+
+// 5. const 与引用的剥离和保留
+
+int main() {
+    const int ci = 1;
+    int n = 2;
+    int& ri = n;
+
+    bool type_check = false;
+
+    // auto 剥离顶层 const: a 推导成什么?
+    auto a = ci;
+    type_check = std::is_same<decltype(a), D2X_YOUR_ANSWER>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // auto 剥离引用: b 推导成什么?(b 是 n 的独立副本)
+    auto b = ri;
+    type_check = std::is_same<decltype(b), D2X_YOUR_ANSWER>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // 想保留 const 引用 const int&: cr 该怎么声明?
+    D2X_YOUR_ANSWER cr = ci;
+    type_check = std::is_same<decltype(cr), const int &>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // 想精确保留声明类型 const int: d 该怎么声明?
+    D2X_YOUR_ANSWER d = ci;
+    type_check = std::is_same<decltype(d), const int>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    D2X_WAIT
+
+    return 0;
+}
diff --git a/dslings/cpp11/xmake.lua b/dslings/cpp11/xmake.lua
index 3f60434..3f7d247 100644
--- a/dslings/cpp11/xmake.lua
+++ b/dslings/cpp11/xmake.lua
@@ -21,6 +21,9 @@ target("cpp11-00-auto-and-decltype-3")
 target("cpp11-00-auto-and-decltype-4")
     set_kind("binary")
     add_files("00-auto-and-decltype-4.cpp")
+target("cpp11-00-auto-and-decltype-5")
+    set_kind("binary")
+    add_files("00-auto-and-decltype-5.cpp")
 
 -- target: cpp11-01-default-and-delete
 
diff --git a/dslings/en/cpp11/00-auto-and-decltype-0.cpp b/dslings/en/cpp11/00-auto-and-decltype-0.cpp
index bac48ac..8f2896d 100644
--- a/dslings/en/cpp11/00-auto-and-decltype-0.cpp
+++ b/dslings/en/cpp11/00-auto-and-decltype-0.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise: cpp11 | 00 - auto and decltype | Automatic Type Deduction
 //
-// Tips: Use auto and decltype to fix errors in the code
+// Tips: Use auto to deduce from the initializer, and decltype to take an already-declared variable's type
 //
 // Docs:
 //   - https://en.cppreference.com/w/cpp/language/auto
@@ -39,6 +39,8 @@ int main() {
     d2x_assert_eq(a1, a2);
     d2x_assert_eq(b, b1);
     d2x_assert_eq(b1, b2);
+    d2x_assert_eq(c, c1);
+    d2x_assert_eq(c1, c2);
 
     D2X_WAIT
 
diff --git a/dslings/en/cpp11/00-auto-and-decltype-1.cpp b/dslings/en/cpp11/00-auto-and-decltype-1.cpp
index 59b1fb9..a3b9a01 100644
--- a/dslings/en/cpp11/00-auto-and-decltype-1.cpp
+++ b/dslings/en/cpp11/00-auto-and-decltype-1.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise: cpp11 | 00 - auto and decltype | Expression Type Deduction
 //
-// Tips: Use auto and decltype to fix errors in the code
+// Tips: A float-containing expression should deduce to double — don't let int truncate the precision
 //
 // Docs:
 //   - https://en.cppreference.com/w/cpp/language/auto
diff --git a/dslings/en/cpp11/00-auto-and-decltype-2.cpp b/dslings/en/cpp11/00-auto-and-decltype-2.cpp
index ea0fb48..fb1cffd 100644
--- a/dslings/en/cpp11/00-auto-and-decltype-2.cpp
+++ b/dslings/en/cpp11/00-auto-and-decltype-2.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise: cpp11 | 00 - auto and decltype | Complex Type Deduction
 //
-// Tips: Use auto and decltype to fix errors in the code
+// Tips: Use auto for the iterator and decltype(func) for the std::function template argument, instead of spelling the long type
 //
 // Docs:
 //   - https://en.cppreference.com/w/cpp/language/auto
diff --git a/dslings/en/cpp11/00-auto-and-decltype-3.cpp b/dslings/en/cpp11/00-auto-and-decltype-3.cpp
index d0a7a97..fb7d426 100644
--- a/dslings/en/cpp11/00-auto-and-decltype-3.cpp
+++ b/dslings/en/cpp11/00-auto-and-decltype-3.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise: cpp11 | 00 - auto and decltype | Function Return Type Deduction
 //
-// Tips: Use auto and decltype to fix errors in the code
+// Tips: Use a trailing return auto ... -> decltype(a - b) so the template function deduces its return type
 //
 // Docs:
 //   - https://en.cppreference.com/w/cpp/language/auto
diff --git a/dslings/en/cpp11/00-auto-and-decltype-4.cpp b/dslings/en/cpp11/00-auto-and-decltype-4.cpp
index 1f68531..f56a15e 100644
--- a/dslings/en/cpp11/00-auto-and-decltype-4.cpp
+++ b/dslings/en/cpp11/00-auto-and-decltype-4.cpp
@@ -4,7 +4,7 @@
 //
 // Exercise: cpp11 | 00 - auto and decltype | Class/Struct Member Type Deduction
 //
-// Tips: Fill in the correct deduced type at D2X_YOUR_ANSWER
+// Tips: Distinguish decltype(obj) from decltype((obj)) — the parenthesized form is an expression and deduces a reference type
 //
 // Docs:
 //   - https://en.cppreference.com/w/cpp/language/auto
diff --git a/dslings/en/cpp11/00-auto-and-decltype-5.cpp b/dslings/en/cpp11/00-auto-and-decltype-5.cpp
new file mode 100644
index 0000000..90d1664
--- /dev/null
+++ b/dslings/en/cpp11/00-auto-and-decltype-5.cpp
@@ -0,0 +1,58 @@
+// d2mcpp: https://github.com/mcpp-community/d2mcpp
+// license: Apache-2.0
+// file: dslings/cpp11/00-auto-and-decltype-5.cpp
+//
+// Exercise: cpp11 | 00 - auto and decltype | const & reference stripping and preservation
+//
+// Tips: auto strips top-level const and references; use const auto& / auto& to keep them, decltype preserves exactly
+//
+// Docs:
+//   - https://en.cppreference.com/w/cpp/language/auto
+//   - https://en.cppreference.com/w/cpp/language/decltype
+//   - https://github.com/mcpp-community/d2mcpp/blob/main/book/src/cpp11/00-auto-and-decltype.md
+//
+// Forum: https://forum.d2learn.org/category/20
+//
+// Auto-Checker command:
+//
+//   d2x checker auto-and-decltype-5
+//
+
+#include <d2x/cpp/common.hpp>
+
+#include <type_traits>
+
+
+// 5. const & reference stripping and preservation
+
+int main() {
+    const int ci = 1;
+    int n = 2;
+    int& ri = n;
+
+    bool type_check = false;
+
+    // auto strips top-level const: what does a deduce to?
+    auto a = ci;
+    type_check = std::is_same<decltype(a), D2X_YOUR_ANSWER>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // auto strips the reference: what does b deduce to? (b is an independent copy of n)
+    auto b = ri;
+    type_check = std::is_same<decltype(b), D2X_YOUR_ANSWER>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // To keep a const reference const int&: how should cr be declared?
+    D2X_YOUR_ANSWER cr = ci;
+    type_check = std::is_same<decltype(cr), const int &>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // To preserve the declared type const int exactly: how should d be declared?
+    D2X_YOUR_ANSWER d = ci;
+    type_check = std::is_same<decltype(d), const int>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    D2X_WAIT
+
+    return 0;
+}
diff --git a/msvc-stl/LICENSE.txt b/msvc-stl/LICENSE.txt
new file mode 100644
index 0000000..487531f
--- /dev/null
+++ b/msvc-stl/LICENSE.txt
@@ -0,0 +1,219 @@
+The Microsoft C++ Standard Library is under the Apache License v2.0 with LLVM Exception:
+
+                                 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.
+
+---- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
diff --git a/msvc-stl/NOTICE.txt b/msvc-stl/NOTICE.txt
new file mode 100644
index 0000000..8c846a8
--- /dev/null
+++ b/msvc-stl/NOTICE.txt
@@ -0,0 +1,218 @@
+Microsoft C++ Standard Library
+
+Copyright (c) Microsoft Corporation
+
+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.
+
+
+---- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
+
+----------------------------------------------------
+
+In addition, certain files include the notices provided below.
+
+
+
+// Copyright 2018 Ulf Adams
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// 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.
+
+----------------------
+
+/*
+* This file is derived from software bearing the following
+* restrictions:
+*
+* (c) Copyright William E. Kempf 2001
+*
+* Permission to use, copy, modify, distribute and sell this
+* software and its documentation for any purpose is hereby
+* granted without fee, provided that the above copyright
+* notice appear in all copies and that both that copyright
+* notice and this permission notice appear in supporting
+* documentation. William E. Kempf makes no representations
+* about the suitability of this software for any purpose.
+* It is provided "as is" without express or implied warranty.
+*/
+
+----------------------
+
+// NOTE:
+//  The conversion data in this header has been derived by Dinkumware
+//  from a Unicode, Inc. file with the preamble reproduced below, under
+//  the grant of right described in that preamble. This header contains
+//  no other material from that file.
+//
+// Copyright (c) 1994-2011 Unicode, Inc.  All Rights reserved.
+//
+// This file is provided as-is by Unicode, Inc. (The Unicode Consortium).
+// No claims are made as to fitness for any particular purpose.  No
+// warranties of any kind are expressed or implied.  The recipient
+// agrees to determine applicability of information provided.  If this
+// file has been provided on magnetic media by Unicode, Inc., the sole
+// remedy for any claim will be exchange of defective media within 90
+// days of receipt.
+//
+//  Unicode, Inc. hereby grants the right to freely use the information
+//  supplied in this file in the creation of products supporting the
+//  Unicode Standard, and to make copies of this file in any form for
+//  internal or external distribution as long as this notice remains
+//  attached.
+
+----------------------
+
+/// NOTE:
+//  The conversion data in this header has been derived by Dinkumware
+//  from a Unicode, Inc. file with the preamble reproduced below, under
+//  the grant of right described in that preamble. This header contains
+//  no other material from that file.
+//
+//  Copyright (c) 1991-1994 Unicode, Inc.  All Rights reserved.
+//
+//  This file is provided as-is by Unicode, Inc. (The Unicode Consortium).
+//  No claims are made as to fitness for any particular purpose.  No
+//  warranties of any kind are expressed or implied.  The recipient
+//  agrees to determine applicability of information provided.  If this
+//  file has been provided on magnetic media by Unicode, Inc., the sole
+//  remedy for any claim will be exchange of defective media within 90
+//  days of receipt.
+//
+//  Recipient is granted the right to make copies in any form for
+//  internal distribution and to freely use the information supplied
+//  in the creation of products supporting Unicode.
+
+----------------------
+
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+----------------------
+
+// Copyright (c) 2012 - present, Victor Zverovich
+//
+// 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.
+//
+// --- Optional exception to the license ---
+//
+// As an exception, if, as a result of your compiling your source code, portions
+// of this Software are embedded into a machine-executable object form of such
+// source code, you may redistribute such embedded portions in such object form
+// without including the above copyright and permission notices.
+
+----------------------
+
+// UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
+//
+// See Terms of Use <https://www.unicode.org/copyright.html>
+// for definitions of Unicode Inc.'s Data Files and Software.
+//
+// NOTICE TO USER: Carefully read the following legal agreement.
+// BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
+// DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
+// YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+// TERMS AND CONDITIONS OF THIS AGREEMENT.
+// IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
+// THE DATA FILES OR SOFTWARE.
+//
+// COPYRIGHT AND PERMISSION NOTICE
+//
+// Copyright (c) 1991-2022 Unicode, Inc. All rights reserved.
+// Distributed under the Terms of Use in https://www.unicode.org/copyright.html.
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of the Unicode data files and any associated documentation
+// (the "Data Files") or Unicode software and any associated documentation
+// (the "Software") to deal in the Data Files or Software
+// without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, and/or sell copies of
+// the Data Files or Software, and to permit persons to whom the Data Files
+// or Software are furnished to do so, provided that either
+// (a) this copyright and permission notice appear with all copies
+// of the Data Files or Software, or
+// (b) this copyright and permission notice appear in associated
+// Documentation.
+//
+// THE DATA FILES AND SOFTWARE ARE 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 OF THIRD PARTY RIGHTS.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+// NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+// DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+// DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+//
+// Except as contained in this notice, the name of a copyright holder
+// shall not be used in advertising or otherwise to promote the sale,
+// use or other dealings in these Data Files or Software without prior
+// written authorization of the copyright holder.
diff --git a/msvc-stl/SOURCE.md b/msvc-stl/SOURCE.md
new file mode 100644
index 0000000..da037a4
--- /dev/null
+++ b/msvc-stl/SOURCE.md
@@ -0,0 +1,76 @@
+# msvc-stl
+
+> 🌎 [English](#english) | [中文](#中文)
+
+---
+
+## English
+
+A **read-only reference copy** of Microsoft's open-source STL implementation. It backs the *"Real-world Case"* sections across the d2mcpp chapters, used to corroborate how language features are actually used in production-grade code. **This is NOT this repository's own code — do not modify it.**
+
+### Upstream
+
+- Repository: <https://github.com/microsoft/STL>
+- License: Apache-2.0 WITH LLVM-exception (see `LICENSE.txt` / `NOTICE.txt`, kept verbatim)
+- Snapshot commit: `926d9b2b1f75c6b0cdc7fe2d65630f9a81825c05`
+- Commit date: 2026-05-28
+
+### Scope
+
+Only the complete library subtree `stl/` is kept (`inc/` + `src/` + `modules/` + its own build files). Excluded:
+
+- `tests/`, `benchmarks/`, `tools/` — tests / benchmarks / tooling, not the library implementation
+- `.git/` — upstream history
+- `llvm-project`, `boost-math`, `benchmarks/google-benchmark` — submodules that only serve testing
+
+### Refresh
+
+```sh
+# 1. Clone upstream (shallow is fine)
+git clone --depth 1 https://github.com/microsoft/STL.git /tmp/STL
+
+# 2. Replace the stl/ subtree and sync the licenses
+rm -rf msvc-stl/stl
+cp -r /tmp/STL/stl        msvc-stl/stl
+cp    /tmp/STL/LICENSE.txt msvc-stl/LICENSE.txt
+cp    /tmp/STL/NOTICE.txt  msvc-stl/NOTICE.txt
+
+# 3. Update the commit / date in this file, and re-check that line
+#    numbers referenced by each chapter still match
+```
+
+---
+
+## 中文
+
+微软开源 STL 实现的**只读引用基底**,供 d2mcpp 各章「真实案例」节链接、印证语言特性在生产级代码中的真实用法。**非本仓库自有代码,请勿修改。**
+
+### 上游来源
+
+- 仓库:<https://github.com/microsoft/STL>
+- 许可:Apache-2.0 WITH LLVM-exception(见 `LICENSE.txt` / `NOTICE.txt`,原样保留)
+- 快照 commit:`926d9b2b1f75c6b0cdc7fe2d65630f9a81825c05`
+- commit 日期:2026-05-28
+
+### 包含范围
+
+仅保留完整的库子树 `stl/`(`inc/` + `src/` + `modules/` + 其自带构建文件),已排除:
+
+- `tests/`、`benchmarks/`、`tools/`(测试 / 基准 / 工具,非库实现)
+- `.git/`(上游历史)
+- `llvm-project`、`boost-math`、`benchmarks/google-benchmark`(仅服务测试的子模块)
+
+### 刷新方式
+
+```sh
+# 1. 克隆上游(浅克隆即可)
+git clone --depth 1 https://github.com/microsoft/STL.git /tmp/STL
+
+# 2. 用新的 stl/ 子树覆盖,并同步 license
+rm -rf msvc-stl/stl
+cp -r /tmp/STL/stl        msvc-stl/stl
+cp    /tmp/STL/LICENSE.txt msvc-stl/LICENSE.txt
+cp    /tmp/STL/NOTICE.txt  msvc-stl/NOTICE.txt
+
+# 3. 更新本文件的 commit / 日期,并核对各章引用的行号是否仍对应
+```
diff --git a/msvc-stl/stl/CMakeLists.txt b/msvc-stl/stl/CMakeLists.txt
new file mode 100644
index 0000000..a8dbd70
--- /dev/null
+++ b/msvc-stl/stl/CMakeLists.txt
@@ -0,0 +1,591 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+##################################################
+# Lists of files. (We can also copy files here.) #
+##################################################
+
+set(HEADERS
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_all_public_headers.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_bit_utils.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_chrono.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_cxx_stdatomic.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_doom_core.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_filebuf.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_format_ucd_tables.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_formatter.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_heap_algorithms.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_int128.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_iter_core.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_minmax.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_ostream.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_print.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_ranges_to.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_ranges_tuple_formatter.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_sanitizer_annotate_container.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_string_view.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_system_error_abi.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_threads_core.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_tzdb.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/__msvc_xlocinfo_types.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/algorithm
+    ${CMAKE_CURRENT_LIST_DIR}/inc/any
+    ${CMAKE_CURRENT_LIST_DIR}/inc/array
+    ${CMAKE_CURRENT_LIST_DIR}/inc/atomic
+    ${CMAKE_CURRENT_LIST_DIR}/inc/barrier
+    ${CMAKE_CURRENT_LIST_DIR}/inc/bit
+    ${CMAKE_CURRENT_LIST_DIR}/inc/bitset
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cassert
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ccomplex
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cctype
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cerrno
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cfenv
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cfloat
+    ${CMAKE_CURRENT_LIST_DIR}/inc/charconv
+    ${CMAKE_CURRENT_LIST_DIR}/inc/chrono
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cinttypes
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ciso646
+    ${CMAKE_CURRENT_LIST_DIR}/inc/climits
+    ${CMAKE_CURRENT_LIST_DIR}/inc/clocale
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cmath
+    ${CMAKE_CURRENT_LIST_DIR}/inc/codecvt
+    ${CMAKE_CURRENT_LIST_DIR}/inc/compare
+    ${CMAKE_CURRENT_LIST_DIR}/inc/complex
+    ${CMAKE_CURRENT_LIST_DIR}/inc/concepts
+    ${CMAKE_CURRENT_LIST_DIR}/inc/condition_variable
+    ${CMAKE_CURRENT_LIST_DIR}/inc/coroutine
+    ${CMAKE_CURRENT_LIST_DIR}/inc/csetjmp
+    ${CMAKE_CURRENT_LIST_DIR}/inc/csignal
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cstdalign
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cstdarg
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cstdbool
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cstddef
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cstdint
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cstdio
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cstdlib
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cstring
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ctgmath
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ctime
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cuchar
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cwchar
+    ${CMAKE_CURRENT_LIST_DIR}/inc/cwctype
+    ${CMAKE_CURRENT_LIST_DIR}/inc/deque
+    ${CMAKE_CURRENT_LIST_DIR}/inc/exception
+    ${CMAKE_CURRENT_LIST_DIR}/inc/execution
+    ${CMAKE_CURRENT_LIST_DIR}/inc/expected
+    ${CMAKE_CURRENT_LIST_DIR}/inc/experimental/coroutine
+    ${CMAKE_CURRENT_LIST_DIR}/inc/experimental/generator
+    ${CMAKE_CURRENT_LIST_DIR}/inc/experimental/resumable
+    ${CMAKE_CURRENT_LIST_DIR}/inc/filesystem
+    ${CMAKE_CURRENT_LIST_DIR}/inc/flat_map
+    ${CMAKE_CURRENT_LIST_DIR}/inc/flat_set
+    ${CMAKE_CURRENT_LIST_DIR}/inc/format
+    ${CMAKE_CURRENT_LIST_DIR}/inc/forward_list
+    ${CMAKE_CURRENT_LIST_DIR}/inc/fstream
+    ${CMAKE_CURRENT_LIST_DIR}/inc/functional
+    ${CMAKE_CURRENT_LIST_DIR}/inc/future
+    ${CMAKE_CURRENT_LIST_DIR}/inc/generator
+    ${CMAKE_CURRENT_LIST_DIR}/inc/header-units.json
+    ${CMAKE_CURRENT_LIST_DIR}/inc/initializer_list
+    ${CMAKE_CURRENT_LIST_DIR}/inc/iomanip
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ios
+    ${CMAKE_CURRENT_LIST_DIR}/inc/iosfwd
+    ${CMAKE_CURRENT_LIST_DIR}/inc/iostream
+    ${CMAKE_CURRENT_LIST_DIR}/inc/iso646.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/istream
+    ${CMAKE_CURRENT_LIST_DIR}/inc/iterator
+    ${CMAKE_CURRENT_LIST_DIR}/inc/latch
+    ${CMAKE_CURRENT_LIST_DIR}/inc/limits
+    ${CMAKE_CURRENT_LIST_DIR}/inc/list
+    ${CMAKE_CURRENT_LIST_DIR}/inc/locale
+    ${CMAKE_CURRENT_LIST_DIR}/inc/map
+    ${CMAKE_CURRENT_LIST_DIR}/inc/mdspan
+    ${CMAKE_CURRENT_LIST_DIR}/inc/memory
+    ${CMAKE_CURRENT_LIST_DIR}/inc/memory_resource
+    ${CMAKE_CURRENT_LIST_DIR}/inc/mutex
+    ${CMAKE_CURRENT_LIST_DIR}/inc/new
+    ${CMAKE_CURRENT_LIST_DIR}/inc/numbers
+    ${CMAKE_CURRENT_LIST_DIR}/inc/numeric
+    ${CMAKE_CURRENT_LIST_DIR}/inc/optional
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ostream
+    ${CMAKE_CURRENT_LIST_DIR}/inc/print
+    ${CMAKE_CURRENT_LIST_DIR}/inc/queue
+    ${CMAKE_CURRENT_LIST_DIR}/inc/random
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ranges
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ratio
+    ${CMAKE_CURRENT_LIST_DIR}/inc/regex
+    ${CMAKE_CURRENT_LIST_DIR}/inc/scoped_allocator
+    ${CMAKE_CURRENT_LIST_DIR}/inc/semaphore
+    ${CMAKE_CURRENT_LIST_DIR}/inc/set
+    ${CMAKE_CURRENT_LIST_DIR}/inc/shared_mutex
+    ${CMAKE_CURRENT_LIST_DIR}/inc/source_location
+    ${CMAKE_CURRENT_LIST_DIR}/inc/span
+    ${CMAKE_CURRENT_LIST_DIR}/inc/spanstream
+    ${CMAKE_CURRENT_LIST_DIR}/inc/sstream
+    ${CMAKE_CURRENT_LIST_DIR}/inc/stack
+    ${CMAKE_CURRENT_LIST_DIR}/inc/stacktrace
+    ${CMAKE_CURRENT_LIST_DIR}/inc/stdexcept
+    ${CMAKE_CURRENT_LIST_DIR}/inc/stdfloat
+    ${CMAKE_CURRENT_LIST_DIR}/inc/stop_token
+    ${CMAKE_CURRENT_LIST_DIR}/inc/streambuf
+    ${CMAKE_CURRENT_LIST_DIR}/inc/string
+    ${CMAKE_CURRENT_LIST_DIR}/inc/string_view
+    ${CMAKE_CURRENT_LIST_DIR}/inc/strstream
+    ${CMAKE_CURRENT_LIST_DIR}/inc/syncstream
+    ${CMAKE_CURRENT_LIST_DIR}/inc/system_error
+    ${CMAKE_CURRENT_LIST_DIR}/inc/thread
+    ${CMAKE_CURRENT_LIST_DIR}/inc/tuple
+    ${CMAKE_CURRENT_LIST_DIR}/inc/type_traits
+    ${CMAKE_CURRENT_LIST_DIR}/inc/typeindex
+    ${CMAKE_CURRENT_LIST_DIR}/inc/typeinfo
+    ${CMAKE_CURRENT_LIST_DIR}/inc/unordered_map
+    ${CMAKE_CURRENT_LIST_DIR}/inc/unordered_set
+    ${CMAKE_CURRENT_LIST_DIR}/inc/use_ansi.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/utility
+    ${CMAKE_CURRENT_LIST_DIR}/inc/valarray
+    ${CMAKE_CURRENT_LIST_DIR}/inc/variant
+    ${CMAKE_CURRENT_LIST_DIR}/inc/vector
+    ${CMAKE_CURRENT_LIST_DIR}/inc/version
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xatomic.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xatomic_wait.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xbit_ops.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xcall_once.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xcharconv.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xcharconv_ryu.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xcharconv_ryu_tables.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xcharconv_tables.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xerrc.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xfacet
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xfilesystem_abi.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xhash
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xiosbase
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xkeycheck.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xlocale
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xlocbuf
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xlocinfo
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xlocmes
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xlocmon
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xlocnum
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xloctime
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xmemory
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xnode_handle.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xpolymorphic_allocator.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xsmf_control.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xstring
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xthreads.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xtimec.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xtr1common
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xtree
+    ${CMAKE_CURRENT_LIST_DIR}/inc/xutility
+    ${CMAKE_CURRENT_LIST_DIR}/inc/ymath.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/yvals.h
+    ${CMAKE_CURRENT_LIST_DIR}/inc/yvals_core.h
+)
+
+foreach(header ${HEADERS})
+    file(RELATIVE_PATH _header_path "${CMAKE_CURRENT_LIST_DIR}/inc" "${header}")
+    configure_file("${header}" "${PROJECT_BINARY_DIR}/out/inc/${_header_path}" COPYONLY)
+endforeach()
+
+set(MODULE_FILES
+    ${CMAKE_CURRENT_LIST_DIR}/modules/modules.json
+    ${CMAKE_CURRENT_LIST_DIR}/modules/std.ixx
+    ${CMAKE_CURRENT_LIST_DIR}/modules/std.compat.ixx
+)
+
+foreach(module_file ${MODULE_FILES})
+    file(RELATIVE_PATH _module_file_path "${CMAKE_CURRENT_LIST_DIR}/modules" "${module_file}")
+    configure_file("${module_file}" "${PROJECT_BINARY_DIR}/out/modules/${_module_file_path}" COPYONLY)
+endforeach()
+
+# Objs that implement aliases; these are completely independent of the configuration
+set(ALIAS_SOURCES_X86_X64
+    ${CMAKE_CURRENT_LIST_DIR}/src/alias_init_once_begin_initialize.asm
+    ${CMAKE_CURRENT_LIST_DIR}/src/alias_init_once_complete.asm
+)
+
+# Objs that exist in both libcpmt[d][01].lib and msvcprt[d].lib.
+set(IMPLIB_SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/src/asan_noop.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/charconv.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/filesystem.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/format.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/locale0_implib.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/nothrow.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/print.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/regex.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/sharedmutex.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/stacktrace.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/syserror_import_lib.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/vector_algorithms.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xcharconv_ryu_tables.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xcharconv_tables_double.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xcharconv_tables_float.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xonce2.cpp
+)
+
+# The following files are linked in msvcp140[d][_clr].dll.
+set(DLL_SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/src/dllmain.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/instances.cpp
+)
+
+# Sources that must not be compiled with /GL, since they contain CRT initializers.
+set(INITIALIZER_SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/src/winapisupp.cpp
+)
+
+set(SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/src/StlCompareStringA.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/StlCompareStringW.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/StlLCMapStringA.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/StlLCMapStringW.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/_tolower.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/_toupper.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/atomic.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/cerr.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/cin.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/clog.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/cond.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/cout.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/cthread.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/filesys.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/fiopen.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/future.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/iomanip.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ios.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/iosptrs.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/iostream.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/locale.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/locale0.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/multprec.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/mutex.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/pplerror.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ppltasks.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/raisehan.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/stdhndlr.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/stdthrow.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/syserror.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/taskscheduler.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/thread0.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/uncaught_exception.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/uncaught_exceptions.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ushcerr.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ushcin.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ushclog.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ushcout.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ushiostr.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/wcerr.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/wcin.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/wclog.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/wcout.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/winapinls.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/wiostrea.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/wlocale.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xalloc.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xcosh.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xdateord.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xdtest.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xexp.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xgetwctype.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xlgamma.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xlocale.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xlock.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xmbtowc.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xmtx.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xnotify.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xonce.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xrngabort.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xrngdev.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xsinh.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xstod.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xstof.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xstol.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xstoll.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xstoul.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xstoull.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xstrcoll.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xstrxfrm.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xthrow.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xtime.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xtowlower.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xtowupper.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xvalues.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xwcscoll.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xwcsxfrm.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xwctomb.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xwstod.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/xwstof.cpp
+)
+
+set(ASAN_SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/src/asan.cpp
+)
+
+set(EHA_SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/src/excptptr.cpp
+)
+
+set(SOURCES_SATELLITE_1
+    ${CMAKE_CURRENT_LIST_DIR}/src/memory_resource.cpp
+)
+
+set(SOURCES_SATELLITE_2
+    ${CMAKE_CURRENT_LIST_DIR}/src/special_math.cpp
+)
+
+set(SOURCES_SATELLITE_ATOMIC_WAIT
+    ${CMAKE_CURRENT_LIST_DIR}/src/atomic_wait.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/parallel_algorithms.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/syncstream.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/tzdb.cpp
+)
+
+set(SOURCES_SATELLITE_CODECVT_IDS
+    ${CMAKE_CURRENT_LIST_DIR}/src/ulocale.cpp
+)
+
+# Objs that exist only in libcpmt[d][01].lib.
+set(STATIC_SOURCES
+    ${SOURCES_SATELLITE_1}
+    ${SOURCES_SATELLITE_2}
+    ${SOURCES_SATELLITE_ATOMIC_WAIT}
+    ${SOURCES_SATELLITE_CODECVT_IDS}
+)
+
+# Objs that exist in all satellite DLLs
+set(SATELLITE_DLL_SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/src/dllmain_satellite.cpp
+)
+
+####################
+# Toolset options. #
+####################
+
+set(CMAKE_CXX_FLAGS "")
+set(CMAKE_CXX_FLAGS_DEBUG "")
+set(CMAKE_CXX_FLAGS_RELEASE "")
+set(CMAKE_MSVC_RUNTIME_CHECKS "")
+set(CMAKE_CXX_STANDARD_LIBRARIES "kernel32.lib")
+set(CMAKE_CXX_STANDARD_LIBRARIES_INIT "kernel32.lib")
+set(CMAKE_MSVC_RUNTIME_LIBRARY "")
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${STL_ARCHIVE_OUTPUT_DIRECTORY}")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${STL_LIBRARY_OUTPUT_DIRECTORY}")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${STL_RUNTIME_OUTPUT_DIRECTORY}")
+
+set(CMAKE_STATIC_LINKER_FLAGS "/WX")
+set(CMAKE_STATIC_LINKER_FLAGS_DEBUG "")
+set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "")
+set(CMAKE_SHARED_LINKER_FLAGS "/DEBUG:FULL /WX /RELEASE /SUBSYSTEM:Console /NODEFAULTLIB /INCREMENTAL:NO /MANIFEST:NO /DLL /profile /guard:cf /DEBUGTYPE:cv,fixup /LARGEADDRESSAWARE")
+if(VCLIBS_TARGET_ARCHITECTURE STREQUAL "x64")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /CETCOMPAT")
+endif()
+if(VCLIBS_TARGET_ARCHITECTURE MATCHES "^(x64|arm64|arm64ec)$")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /guard:ehcont")
+endif()
+if(VCLIBS_TARGET_ARCHITECTURE MATCHES "^(arm64|arm64ec)$")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /guard:delayloadsignret")
+endif()
+set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "")
+set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "")
+
+# Toolset options must appear before add_library() for the options to take effect.
+add_compile_definitions(_CRTBLD _HAS_OLD_IOSTREAMS_MEMBERS=1)
+
+# /Z7 for MSVC, /Zi for MASM
+set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "Embedded")
+
+add_compile_options(/nologo /WX /Gy
+    "$<$<COMPILE_LANGUAGE:CXX>:/diagnostics:caret;/W4;/w14265;/w15038;/fastfail;/guard:cf;/Zp8;/std:c++latest;/permissive-;/Zc:preprocessor;/Zc:threadSafeInit-;/Zl>"
+    "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<IN_LIST:${VCLIBS_TARGET_ARCHITECTURE},x64;arm64;arm64ec>>:/guard:ehcont>"
+    "$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<IN_LIST:${VCLIBS_TARGET_ARCHITECTURE},arm64;arm64ec>>:/guard:signret>"
+    "$<$<COMPILE_LANGUAGE:ASM_MASM>:/W3;/quiet>"
+)
+
+include_directories(BEFORE
+    "${CMAKE_CURRENT_LIST_DIR}/inc"
+    "${TOOLSET_ROOT_DIR}/crt/src/vcruntime"
+)
+
+###########################
+# End of toolset options. #
+###########################
+
+if(VCLIBS_TARGET_ARCHITECTURE MATCHES "^(x86|x64)$")
+    add_library(stl_alias_objects OBJECT ${ALIAS_SOURCES_X86_X64})
+else()
+    add_library(stl_alias_objects INTERFACE)
+endif()
+
+if(STL_ASAN_BUILD)
+    set(DLL_ASAN_SOURCES ${ASAN_SOURCES})
+else()
+    set(DLL_ASAN_SOURCES "")
+endif()
+
+function(target_stl_compile_options tgt rel_or_dbg)
+    if(rel_or_dbg STREQUAL "Release")
+        target_compile_options(${tgt} PRIVATE ${VCLIBS_RELEASE_OPTIONS})
+    elseif(rel_or_dbg STREQUAL "Debug")
+        target_compile_options(${tgt} PRIVATE ${VCLIBS_DEBUG_OPTIONS})
+        target_compile_definitions(${tgt} PRIVATE "_DEBUG")
+    else()
+        message(FATAL_ERROR "INTERNAL ERROR: unexpected value for rel_or_dbg: '${rel_or_dbg}'")
+    endif()
+endfunction()
+
+function(generate_satellite_def SATELLITE_NAME D_SUFFIX)
+    set(full_satellite_name "msvcp140${D_SUFFIX}_${SATELLITE_NAME}${VCLIBS_SUFFIX}")
+    string(TOUPPER "${full_satellite_name}" upper_full_satellite_name)
+    set(satellite_input_src_file_path "${CMAKE_CURRENT_LIST_DIR}/src/msvcp_${SATELLITE_NAME}.src")
+    set(satellite_output_def_file_path "${CMAKE_BINARY_DIR}/msvcp_${SATELLITE_NAME}${D_SUFFIX}.def")
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${satellite_input_src_file_path}")
+
+    # We use the placeholder name "LIBRARYNAME" in the corresponding .src file of a satellite DLL
+    # (i.e., we write "LIBRARY LIBRARYNAME" as the first non-commented line in the file).
+    #
+    # Here, we dynamically replace this placeholder name with the name of the satellite DLL for
+    # the current build configuration. Then, we write out the new .def file to the binary output
+    # directory.
+    file(READ "${satellite_input_src_file_path}" satellite_def_file_contents)
+    string(REPLACE "LIBRARYNAME" "${upper_full_satellite_name}" satellite_def_file_contents "${satellite_def_file_contents}")
+    file(GENERATE OUTPUT "${satellite_output_def_file_path}" CONTENT "${satellite_def_file_contents}")
+endfunction()
+
+function(add_stl_dlls D_SUFFIX REL_OR_DBG)
+    set(link_options_Release "/LTCG;/opt:ref,icf;${VCLIBS_EXPLICIT_MACHINE}")
+    set(link_options_Debug "/opt:ref,noicf;${VCLIBS_EXPLICIT_MACHINE}")
+
+    set(gl_flag_Release "/GL")
+    set(gl_flag_Debug "")
+
+    # msvcp140.dll
+    add_library(msvcp${D_SUFFIX}_objects OBJECT ${DLL_SOURCES} ${SOURCES} ${DLL_ASAN_SOURCES})
+    target_compile_definitions(msvcp${D_SUFFIX}_objects PRIVATE CRTDLL2 _DLL)
+    target_compile_options(msvcp${D_SUFFIX}_objects PRIVATE ${gl_flag_${REL_OR_DBG}} /EHsc)
+    target_stl_compile_options(msvcp${D_SUFFIX}_objects ${REL_OR_DBG})
+
+    add_library(msvcp${D_SUFFIX}_init_objects OBJECT ${INITIALIZER_SOURCES})
+    target_compile_definitions(msvcp${D_SUFFIX}_init_objects PRIVATE CRTDLL2 _DLL)
+    target_compile_options(msvcp${D_SUFFIX}_init_objects PRIVATE /EHsc)
+    target_stl_compile_options(msvcp${D_SUFFIX}_init_objects ${REL_OR_DBG})
+
+    add_library(msvcp${D_SUFFIX}_eha_objects OBJECT ${EHA_SOURCES})
+    target_compile_definitions(msvcp${D_SUFFIX}_eha_objects PRIVATE CRTDLL2 _DLL)
+    target_compile_options(msvcp${D_SUFFIX}_eha_objects PRIVATE ${gl_flag_${REL_OR_DBG}} /EHa)
+    target_stl_compile_options(msvcp${D_SUFFIX}_eha_objects ${REL_OR_DBG})
+
+    add_library(msvcp${D_SUFFIX} SHARED)
+    target_link_libraries(msvcp${D_SUFFIX} PRIVATE msvcp${D_SUFFIX}_eha_objects msvcp${D_SUFFIX}_objects msvcp${D_SUFFIX}_init_objects "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib")
+    if(VCLIBS_TARGET_ARCHITECTURE MATCHES "^(arm64|arm64ec)$")
+        target_link_libraries(msvcp${D_SUFFIX} PRIVATE "softintrin.lib")
+    endif()
+    set_target_properties(msvcp${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_base${D_SUFFIX}${VCLIBS_SUFFIX}")
+    set_target_properties(msvcp${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+    set_target_properties(msvcp${D_SUFFIX} PROPERTIES OUTPUT_NAME "msvcp140${D_SUFFIX}${VCLIBS_SUFFIX}")
+    target_link_options(msvcp${D_SUFFIX} PRIVATE ${link_options_${REL_OR_DBG}})
+
+    # import library 'statics'
+    add_library(msvcp${D_SUFFIX}_implib_objects OBJECT ${IMPLIB_SOURCES})
+    target_compile_definitions(msvcp${D_SUFFIX}_implib_objects PRIVATE _DLL _ENFORCE_ONLY_CORE_HEADERS)
+    target_compile_options(msvcp${D_SUFFIX}_implib_objects PRIVATE /EHsc) # No /GL!
+    target_stl_compile_options(msvcp${D_SUFFIX}_implib_objects ${REL_OR_DBG})
+
+    add_library(msvcp${D_SUFFIX}_satellite_objects OBJECT ${SATELLITE_DLL_SOURCES})
+    target_compile_definitions(msvcp${D_SUFFIX}_satellite_objects PRIVATE _DLL)
+    target_compile_options(msvcp${D_SUFFIX}_satellite_objects PRIVATE ${gl_flag_${REL_OR_DBG}} /EHsc)
+    target_stl_compile_options(msvcp${D_SUFFIX}_satellite_objects ${REL_OR_DBG})
+
+    # msvcp140_1.dll (the memory_resource satellite)
+    add_library(msvcp_1${D_SUFFIX}_objects OBJECT ${SOURCES_SATELLITE_1})
+    target_compile_definitions(msvcp_1${D_SUFFIX}_objects PRIVATE _BUILDING_SATELLITE_1 _DLL)
+    target_compile_options(msvcp_1${D_SUFFIX}_objects PRIVATE ${gl_flag_${REL_OR_DBG}} /EHsc)
+    target_stl_compile_options(msvcp_1${D_SUFFIX}_objects ${REL_OR_DBG})
+
+    add_library(msvcp_1${D_SUFFIX} SHARED)
+    target_link_libraries(msvcp_1${D_SUFFIX} PRIVATE msvcp_1${D_SUFFIX}_objects msvcp${D_SUFFIX}_satellite_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib")
+    set_target_properties(msvcp_1${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_1${D_SUFFIX}${VCLIBS_SUFFIX}")
+    set_target_properties(msvcp_1${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+    set_target_properties(msvcp_1${D_SUFFIX} PROPERTIES OUTPUT_NAME "msvcp140_1${D_SUFFIX}${VCLIBS_SUFFIX}")
+    target_link_options(msvcp_1${D_SUFFIX} PRIVATE ${link_options_${REL_OR_DBG}})
+
+    # msvcp140_2.dll (the special math satellite)
+    add_library(msvcp_2${D_SUFFIX}_objects OBJECT ${SOURCES_SATELLITE_2})
+    target_compile_definitions(msvcp_2${D_SUFFIX}_objects PRIVATE _BUILDING_SATELLITE_2 _DLL)
+    target_compile_options(msvcp_2${D_SUFFIX}_objects PRIVATE ${gl_flag_${REL_OR_DBG}} /EHsc)
+    target_link_libraries(msvcp_2${D_SUFFIX}_objects PRIVATE Boost::math)
+    target_stl_compile_options(msvcp_2${D_SUFFIX}_objects ${REL_OR_DBG})
+
+    add_library(msvcp_2${D_SUFFIX} SHARED)
+    target_link_libraries(msvcp_2${D_SUFFIX} PRIVATE msvcp_2${D_SUFFIX}_objects msvcp${D_SUFFIX}_satellite_objects msvcp${D_SUFFIX}_implib_objects msvcp${D_SUFFIX} "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib")
+    set_target_properties(msvcp_2${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_2${D_SUFFIX}${VCLIBS_SUFFIX}")
+    set_target_properties(msvcp_2${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+    set_target_properties(msvcp_2${D_SUFFIX} PROPERTIES OUTPUT_NAME "msvcp140_2${D_SUFFIX}${VCLIBS_SUFFIX}")
+    target_link_options(msvcp_2${D_SUFFIX} PRIVATE ${link_options_${REL_OR_DBG}})
+
+    # msvcp140_atomic_wait.dll (the atomic wait satellite)
+    add_library(msvcp${D_SUFFIX}_atomic_wait_objects OBJECT ${SOURCES_SATELLITE_ATOMIC_WAIT})
+    target_compile_definitions(msvcp${D_SUFFIX}_atomic_wait_objects PRIVATE _BUILDING_SATELLITE_ATOMIC_WAIT _DLL)
+    target_compile_options(msvcp${D_SUFFIX}_atomic_wait_objects PRIVATE ${gl_flag_${REL_OR_DBG}} /EHsc)
+    target_stl_compile_options(msvcp${D_SUFFIX}_atomic_wait_objects ${REL_OR_DBG})
+
+    # generate the .def for msvcp140_atomic_wait.dll
+    generate_satellite_def("atomic_wait" "${D_SUFFIX}")
+
+    add_library(msvcp${D_SUFFIX}_atomic_wait SHARED "${CMAKE_BINARY_DIR}/msvcp_atomic_wait${D_SUFFIX}.def")
+    target_link_libraries(msvcp${D_SUFFIX}_atomic_wait PRIVATE msvcp${D_SUFFIX}_atomic_wait_objects msvcp${D_SUFFIX}_satellite_objects msvcp${D_SUFFIX}_implib_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "advapi32.lib" "synchronization.lib")
+    set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_atomic_wait${D_SUFFIX}${VCLIBS_SUFFIX}")
+    set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+    set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES OUTPUT_NAME "msvcp140${D_SUFFIX}_atomic_wait${VCLIBS_SUFFIX}")
+    target_link_options(msvcp${D_SUFFIX}_atomic_wait PRIVATE ${link_options_${REL_OR_DBG}})
+
+    # msvcp140_codecvt_ids.dll
+    add_library(msvcp${D_SUFFIX}_codecvt_ids_objects OBJECT ${SOURCES_SATELLITE_CODECVT_IDS})
+    target_compile_definitions(msvcp${D_SUFFIX}_codecvt_ids_objects PRIVATE _BUILDING_SATELLITE_CODECVT_IDS _DLL)
+    target_compile_options(msvcp${D_SUFFIX}_codecvt_ids_objects PRIVATE ${gl_flag_${REL_OR_DBG}} /EHsc)
+    target_stl_compile_options(msvcp${D_SUFFIX}_codecvt_ids_objects ${REL_OR_DBG})
+
+    add_library(msvcp${D_SUFFIX}_codecvt_ids SHARED)
+    target_link_libraries(msvcp${D_SUFFIX}_codecvt_ids PRIVATE msvcp${D_SUFFIX}_codecvt_ids_objects msvcp${D_SUFFIX}_satellite_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib")
+    set_target_properties(msvcp${D_SUFFIX}_codecvt_ids PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_codecvt_ids${D_SUFFIX}${VCLIBS_SUFFIX}")
+    set_target_properties(msvcp${D_SUFFIX}_codecvt_ids PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+    set_target_properties(msvcp${D_SUFFIX}_codecvt_ids PROPERTIES OUTPUT_NAME "msvcp140${D_SUFFIX}_codecvt_ids${VCLIBS_SUFFIX}")
+    target_link_options(msvcp${D_SUFFIX}_codecvt_ids PRIVATE ${link_options_${REL_OR_DBG}})
+
+    # import library
+    add_library(msvcp${D_SUFFIX}_implib STATIC ${HEADERS})
+    target_link_libraries(msvcp${D_SUFFIX}_implib stl_alias_objects msvcp${D_SUFFIX}_implib_objects)
+    add_dependencies(msvcp${D_SUFFIX}_implib msvcp${D_SUFFIX} msvcp_1${D_SUFFIX} msvcp_2${D_SUFFIX} msvcp${D_SUFFIX}_atomic_wait msvcp${D_SUFFIX}_codecvt_ids)
+    set_target_properties(msvcp${D_SUFFIX}_implib PROPERTIES STATIC_LIBRARY_OPTIONS "/NOLOGO;/NODEFAULTLIB;/IGNORE:4006;$<TARGET_LINKER_FILE:msvcp${D_SUFFIX}>;$<TARGET_LINKER_FILE:msvcp_1${D_SUFFIX}>;$<TARGET_LINKER_FILE:msvcp_2${D_SUFFIX}>;$<TARGET_LINKER_FILE:msvcp${D_SUFFIX}_codecvt_ids>;$<TARGET_LINKER_FILE:msvcp${D_SUFFIX}_atomic_wait>;${VCLIBS_EXPLICIT_MACHINE}")
+    set_target_properties(msvcp${D_SUFFIX}_implib PROPERTIES ARCHIVE_OUTPUT_NAME "msvcprt${D_SUFFIX}")
+endfunction()
+
+add_stl_dlls("" Release)
+add_stl_dlls("d" Debug)
+
+function(add_stl_statics FLAVOR_SUFFIX REL_OR_DBG IDL_VALUE)
+    add_library(libcpmt${FLAVOR_SUFFIX}_eha OBJECT ${EHA_SOURCES})
+    target_compile_definitions(libcpmt${FLAVOR_SUFFIX}_eha PRIVATE _ANNOTATE_STL "_ITERATOR_DEBUG_LEVEL=${IDL_VALUE}")
+    target_compile_options(libcpmt${FLAVOR_SUFFIX}_eha PRIVATE /EHa)
+    target_stl_compile_options(libcpmt${FLAVOR_SUFFIX}_eha ${REL_OR_DBG})
+
+    add_library(libcpmt${FLAVOR_SUFFIX} STATIC ${HEADERS} ${IMPLIB_SOURCES} ${SOURCES} ${INITIALIZER_SOURCES} ${STATIC_SOURCES})
+    target_compile_definitions(libcpmt${FLAVOR_SUFFIX} PRIVATE _ANNOTATE_STL "_ITERATOR_DEBUG_LEVEL=${IDL_VALUE}")
+    target_compile_options(libcpmt${FLAVOR_SUFFIX} PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:/EHsc>")
+    target_link_libraries(libcpmt${FLAVOR_SUFFIX} PRIVATE Boost::math stl_alias_objects libcpmt${FLAVOR_SUFFIX}_eha)
+    target_stl_compile_options(libcpmt${FLAVOR_SUFFIX} ${REL_OR_DBG})
+    set_target_properties(libcpmt${FLAVOR_SUFFIX} PROPERTIES STATIC_LIBRARY_OPTIONS "${VCLIBS_EXPLICIT_MACHINE}")
+endfunction()
+
+add_stl_statics("" Release 0)
+add_stl_statics("1" Release 1)
+add_stl_statics("d" Debug 2)
+add_stl_statics("d1" Debug 1)
+add_stl_statics("d0" Debug 0)
+
+add_library(stl_asan STATIC ${ASAN_SOURCES})
+set_target_properties(stl_asan PROPERTIES STATIC_LIBRARY_OPTIONS "${VCLIBS_EXPLICIT_MACHINE}")
+
+configure_file(set_environment.bat.in "${PROJECT_BINARY_DIR}/set_environment.bat" @ONLY)
+configure_file(set_environment.ps1.in "${PROJECT_BINARY_DIR}/set_environment.ps1" @ONLY)
diff --git a/msvc-stl/stl/debugger/STL.natvis b/msvc-stl/stl/debugger/STL.natvis
new file mode 100644
index 0000000..6c83247
--- /dev/null
+++ b/msvc-stl/stl/debugger/STL.natvis
@@ -0,0 +1,2357 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+  <!-- VC 2015 -->
+  <Type Name="std::_Compressed_pair&lt;*,*,1&gt;">
+      <DisplayString>{*($T1 *)this}</DisplayString>
+      <Expand>
+          <ExpandedItem>*($T1 *)this</ExpandedItem>
+      </Expand>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::_Compressed_pair&lt;*,*,0&gt;">
+      <DisplayString>{_Myval1}</DisplayString>
+      <Expand>
+          <ExpandedItem>_Myval1</ExpandedItem>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::error_category">
+      <DisplayString>[{name(),sb}]</DisplayString>
+      <Expand>
+      <Synthetic Name="hint">
+          <DisplayString>Enable "Allow Function Calls In Value Formatting" if you see "???" here</DisplayString>
+      </Synthetic>
+      </Expand>
+  </Type>
+
+  <Type Name="std::error_code">
+    <DisplayString>{{ value={_Myval}, category={*_Mycat} }}</DisplayString>
+    <Expand>
+      <Synthetic Name="hint">
+        <DisplayString>Enable "Allow Function Calls In Value Formatting" if you see "???" here</DisplayString>
+      </Synthetic>
+      <Item Name="[value]">_Myval</Item>
+      <Item Name="[category]">_Mycat</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::exception_ptr">
+      <CustomVisualizer Condition="_Data1 != 0" VisualizerId="CEB58A03-E78D-4D19-9AE7-4738E200649E" />
+      <DisplayString Condition="_Data1 == 0">null</DisplayString>
+      <Expand/>
+  </Type>
+
+
+  <Type Name="std::initializer_list&lt;*&gt;">
+      <DisplayString>{{ size={_Last - _First} }}</DisplayString>
+      <Expand>
+          <ArrayItems>
+              <Size>_Last - _First</Size>
+              <ValuePointer>_First</ValuePointer>
+          </ArrayItems>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::pair&lt;*&gt;">
+      <DisplayString IncludeView="noparens">{first}, {second}</DisplayString>
+      <DisplayString ExcludeView="noparens">({first}, {second})</DisplayString>
+      <Expand>
+          <Item Name="first">first</Item>
+          <Item Name="second">second</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::tuple&lt;&gt;">
+    <DisplayString IncludeView="noparens;noparensasptr"></DisplayString>
+    <DisplayString>({*this,view(noparens)})</DisplayString>
+    <Expand/>
+  </Type>
+
+  <!--
+    Tuple uses a bit of a SFINAE-style technique in order to allow us to write less code.
+    It uses Condition="(void)<expr>, true", along with Optional="true".
+    This allows us to check if <expr> compiles, and if so, use that "branch".
+  -->
+
+  <Type Name="std::tuple&lt;*&gt;">
+    <DisplayString IncludeView="noparens" Optional="true" Condition="(void)((_Mybase *)this)->_Myfirst._Val, true">
+      {_Myfirst._Val}, {*((_Mybase *) this),view(noparens)}
+    </DisplayString>
+    <DisplayString IncludeView="noparens">{_Myfirst._Val}</DisplayString>
+    <DisplayString>({*this,view(noparens)})</DisplayString>
+    <Expand>
+      <Item Name="[0]">_Myfirst._Val</Item>
+      <Item Name="[1]" Optional="true">((_Mybase *) this)->_Myfirst._Val</Item>
+      <Item Name="[2]" Optional="true">((_Mybase::_Mybase *) this)->_Myfirst._Val</Item>
+      <Item Name="[3]" Optional="true">((_Mybase::_Mybase::_Mybase *) this)->_Myfirst._Val</Item>
+      <Item Name="[4]" Optional="true">((_Mybase::_Mybase::_Mybase::_Mybase *) this)->_Myfirst._Val</Item>
+      <Synthetic Name="[...]" Optional="true" Condition="(void)((_Mybase::_Mybase::_Mybase::_Mybase::_Mybase *) this)->_Myfirst._Val, true">
+        <DisplayString>Next five elements:</DisplayString>
+      </Synthetic>
+      <ExpandedItem Optional="true">*((_Mybase::_Mybase::_Mybase::_Mybase::_Mybase *) this)</ExpandedItem>
+    </Expand>
+  </Type>
+
+  <Type Name="std::tuple&lt;*&gt;" IncludeView="asptr;noparensasptr">
+    <DisplayString IncludeView="noparensasptr" Optional="true" Condition="(void)((_Mybase *)this)->_Myfirst._Val, true">
+      {_Myfirst._Val}, {*((_Mybase *) this),view(noparensasptr)}
+    </DisplayString>
+    <DisplayString IncludeView="noparensasptr">{&amp;_Myfirst._Val}</DisplayString>
+    <DisplayString>({*this,view(noparensasptr)})</DisplayString>
+    <Expand>
+      <Item Name="[0]">&amp;_Myfirst._Val</Item>
+      <Item Name="[1]">&amp;((_Mybase *) this)->_Myfirst._Val</Item>
+      <Item Name="[2]" Optional="true">&amp;((_Mybase::_Mybase *) this)->_Myfirst._Val</Item>
+      <Item Name="[3]" Optional="true">&amp;((_Mybase::_Mybase::_Mybase *) this)->_Myfirst._Val</Item>
+      <Item Name="[4]" Optional="true">&amp;((_Mybase::_Mybase::_Mybase::_Mybase *) this)->_Myfirst._Val</Item>
+      <Synthetic Name="[...]" Optional="true" Condition="(void)((_Mybase::_Mybase::_Mybase::_Mybase::_Mybase *) this)->_Myfirst._Val, true">
+        <DisplayString>Next five elements:</DisplayString>
+      </Synthetic>
+      <ExpandedItem Optional="true">*((_Mybase::_Mybase::_Mybase::_Mybase::_Mybase *) this),view(asptr)</ExpandedItem>
+    </Expand>
+  </Type>
+
+  <Type Name="std::nullopt_t">
+      <DisplayString>nullopt</DisplayString>
+  </Type>
+
+  <Type Name="std::optional&lt;*&gt;">
+      <DisplayString Condition="!_Has_value">nullopt</DisplayString>
+      <DisplayString Condition="_Has_value">{_Value}</DisplayString>
+      <Expand>
+          <Item Condition="_Has_value" Name="value">_Value</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::_Variant_item&lt;*&gt;">
+      <DisplayString>{_Elem}</DisplayString>
+  </Type>
+
+  <Type Name="std::variant&lt;*&gt;">
+      <Intrinsic Name="index" Expression="(int)_Which"/>
+      <DisplayString Condition="index() &lt; 0">[valueless_by_exception]</DisplayString>
+      <DisplayString Condition="index() ==  0" Optional="true">{{ index=0, value={_Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  1" Optional="true">{{ index=1, value={_Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  2" Optional="true">{{ index=2, value={_Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  3" Optional="true">{{ index=3, value={_Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  4" Optional="true">{{ index=4, value={_Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  5" Optional="true">{{ index=5, value={_Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  6" Optional="true">{{ index=6, value={_Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  7" Optional="true">{{ index=7, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  8" Optional="true">{{ index=8, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() ==  9" Optional="true">{{ index=9, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 10" Optional="true">{{ index=10, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 11" Optional="true">{{ index=11, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 12" Optional="true">{{ index=12, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 13" Optional="true">{{ index=13, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 14" Optional="true">{{ index=14, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 15" Optional="true">{{ index=15, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 16" Optional="true">{{ index=16, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 17" Optional="true">{{ index=17, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 18" Optional="true">{{ index=18, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 19" Optional="true">{{ index=19, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 20" Optional="true">{{ index=20, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 21" Optional="true">{{ index=21, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 22" Optional="true">{{ index=22, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 23" Optional="true">{{ index=23, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 24" Optional="true">{{ index=24, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 25" Optional="true">{{ index=25, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 26" Optional="true">{{ index=26, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 27" Optional="true">{{ index=27, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 28" Optional="true">{{ index=28, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 29" Optional="true">{{ index=29, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 30" Optional="true">{{ index=30, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <DisplayString Condition="index() == 31" Optional="true">{{ index=31, value={_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head} }}</DisplayString>
+      <Expand>
+          <Item Name="index">index()</Item>
+          <Item Name="[value]" Condition="index() ==  0" Optional="true">_Head</Item>
+          <Item Name="[value]" Condition="index() ==  1" Optional="true">_Tail._Head</Item>
+          <Item Name="[value]" Condition="index() ==  2" Optional="true">_Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() ==  3" Optional="true">_Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() ==  4" Optional="true">_Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() ==  5" Optional="true">_Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() ==  6" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() ==  7" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() ==  8" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() ==  9" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 10" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 11" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 12" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 13" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 14" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 15" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 16" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 17" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 18" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 19" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 20" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 21" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 22" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 23" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 24" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 25" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 26" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 27" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 28" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 29" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 30" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+          <Item Name="[value]" Condition="index() == 31" Optional="true">_Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Head</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::monostate">
+      <DisplayString>monostate</DisplayString>
+  </Type>
+
+  <Type Name="std::unexpected&lt;*&gt;">
+      <Intrinsic Name="unex" Expression="_Unexpected"/>
+      <DisplayString>{unex()}</DisplayString>
+      <Expand>
+          <Item Name="unex">unex()</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::bad_expected_access&lt;*&gt;">
+      <Intrinsic Name="unex" Expression="_Unexpected"/>
+      <DisplayString>{unex()}</DisplayString>
+      <Expand>
+          <Item Name="unex">unex()</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::expected&lt;*,*&gt;">
+      <Intrinsic Name="has_value" Expression="_Has_value"/>
+      <Intrinsic Name="value" Expression="_Value"/>
+      <Intrinsic Name="unex" Expression="_Unexpected"/>
+      <DisplayString Condition="has_value()">{value()}</DisplayString>
+      <DisplayString Condition="!has_value()">{unex()}</DisplayString>
+      <Expand>
+          <Item Condition="has_value()" Name="value">value()</Item>
+          <Item Condition="!has_value()" Name="unex">unex()</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::expected&lt;void,*&gt;">
+      <Intrinsic Name="has_value" Expression="_Has_value"/>
+      <Intrinsic Name="unex" Expression="_Unexpected"/>
+      <DisplayString Condition="has_value()">void</DisplayString>
+      <DisplayString Condition="!has_value()">{unex()}</DisplayString>
+      <Expand>
+          <Item Condition="!has_value()" Name="unex">unex()</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::bitset&lt;*&gt;">
+      <DisplayString>{{ size={$T1} }}</DisplayString>
+      <Expand>
+          <IndexListItems>
+              <Size>$T1</Size>
+              <ValueNode>(_Array[$i / _Bitsperword] &gt;&gt; ($i % _Bitsperword)) &amp; 1,d</ValueNode>
+          </IndexListItems>
+      </Expand>
+  </Type>
+
+  <Type Name="std::bitset&lt;*&gt;::reference">
+      <DisplayString>{(_Pbitset-&gt;_Array[_Mypos / _Pbitset-&gt;_Bitsperword] &gt;&gt; (_Mypos % _Pbitset-&gt;_Bitsperword)) &amp; 1,d}</DisplayString>
+      <Expand>
+          <Item Name="[bitset]">_Pbitset</Item>
+          <Item Name="[pos]">_Mypos</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::allocator&lt;*&gt;">
+      <DisplayString>allocator</DisplayString>
+      <Expand/>
+  </Type>
+
+
+  <Type Name="std::default_delete&lt;*&gt;">
+      <DisplayString>default_delete</DisplayString>
+      <Expand/>
+  </Type>
+
+  <!-- VC 2015 -->
+   <Type Name="std::unique_ptr&lt;void, *&gt;">
+      <SmartPointer Usage="Minimal">_Mypair._Myval2</SmartPointer>
+      <DisplayString Condition="_Mypair._Myval2 == 0">empty</DisplayString>
+      <DisplayString Condition="_Mypair._Myval2 != 0">unique_ptr void</DisplayString>
+      <Expand>
+          <Item Condition="_Mypair._Myval2 != 0" Name="[ptr]">_Mypair._Myval2</Item>
+          <Item Condition="_Mypair._Myval2 != 0" Name="[deleter]">_Mypair</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::unique_ptr&lt;*&gt;">
+      <SmartPointer Usage="Minimal">_Mypair._Myval2</SmartPointer>
+      <DisplayString Condition="_Mypair._Myval2 == 0">empty</DisplayString>
+      <DisplayString Condition="_Mypair._Myval2 != 0">unique_ptr {*_Mypair._Myval2}</DisplayString>
+      <Expand>
+          <Item Condition="_Mypair._Myval2 != 0" Name="[ptr]">_Mypair._Myval2</Item>
+          <Item Condition="_Mypair._Myval2 != 0" Name="[deleter]">_Mypair</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::unique_ptr&lt;wchar_t [0],*&gt;">
+    <AlternativeType Name="std::unique_ptr&lt;char [0],*&gt;"/>
+    <AlternativeType Name="std::unique_ptr&lt;char8_t [0],*&gt;"/>
+    <AlternativeType Name="std::unique_ptr&lt;char16_t [0],*&gt;"/>
+    <AlternativeType Name="std::unique_ptr&lt;char32_t [0],*&gt;"/>
+    <AlternativeType Name="std::unique_ptr&lt;wchar_t const [0],*&gt;"/>
+    <AlternativeType Name="std::unique_ptr&lt;char const [0],*&gt;"/>
+    <AlternativeType Name="std::unique_ptr&lt;char8_t const [0],*&gt;"/>
+    <AlternativeType Name="std::unique_ptr&lt;char16_t const [0],*&gt;"/>
+    <AlternativeType Name="std::unique_ptr&lt;char32_t const [0],*&gt;"/>
+    <DisplayString Condition="_Mypair._Myval2 == nullptr">{{empty}}</DisplayString>
+    <DisplayString Condition="_Mypair._Myval2 != nullptr">{_Mypair._Myval2}</DisplayString>
+    <StringView>_Mypair._Myval2</StringView>
+    <Expand>
+      <Item Condition="_Mypair._Myval2 != nullptr" Name="[deleter]">_Mypair</Item>
+      <ExpandedItem Condition="_Mypair._Myval2 != nullptr">_Mypair._Myval2,hv</ExpandedItem>
+    </Expand>
+  </Type>
+
+  <Type Name="std::_Ref_count&lt;*&gt;">
+      <DisplayString>default</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">_Ptr</Item>
+      </Expand>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::_Ref_count_del&lt;*&gt;">
+      <DisplayString>custom deleter</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">_Mypair._Myval2</Item>
+          <Item Name="[deleter]">_Mypair</Item>
+      </Expand>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::_Ref_count_del_alloc&lt;*&gt;">
+      <DisplayString>custom deleter, custom allocator</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">_Mypair._Myval2._Myval2</Item>
+          <Item Name="[deleter]">_Mypair</Item>
+          <Item Name="[allocator]">_Mypair._Myval2</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::_Ref_count_obj&lt;*&gt;">
+      <DisplayString>make_shared</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">($T1 *) &amp;_Storage</Item>
+      </Expand>
+  </Type>
+
+  <!-- VS 2019 16.3 -->
+  <Type Name="std::_Ref_count_obj2&lt;*&gt;">
+      <DisplayString>make_shared</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">($T1 *) &amp;_Storage</Item>
+      </Expand>
+  </Type>
+
+  <!-- VS 2022 17.10 -->
+  <Type Name="std::_Ref_count_bounded_array&lt;*&gt;">
+    <DisplayString>make_shared&lt;T[N]&gt;</DisplayString>
+    <Expand>
+      <Item Condition="_Uses != 0" Name="[allocated array]">_Storage._Value</Item>
+    </Expand>
+  </Type>
+
+  <!-- VS 2022 17.10 -->
+  <Type Name="std::_Ref_count_unbounded_array&lt;*,0&gt;">
+    <Intrinsic Name="data" Expression="&amp;(_Storage._Value)" />
+    <Intrinsic Name="size" Expression="_Size" />
+    <DisplayString>make_shared&lt;T[]&gt;</DisplayString>
+    <Expand>
+      <ArrayItems>
+        <Size>size()</Size>
+        <ValuePointer>data()</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <!-- VS 2022 17.10 -->
+  <Type Name="std::_Ref_count_unbounded_array&lt;*,1&gt;">
+    <DisplayString>make_shared&lt;T[]&gt;</DisplayString>
+    <Expand>
+      <Item Condition="_Uses != 0" Name="[original ptr]">_Storage._Value</Item>
+    </Expand>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::_Ref_count_obj_alloc&lt;*&gt;">
+      <DisplayString>allocate_shared</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">($T1 *) &amp;_Mypair._Myval2</Item>
+          <Item Name="[allocator]">_Mypair</Item>
+      </Expand>
+  </Type>
+
+  <!-- VS 2019 16.7: _Ref_count_obj_alloc3 -->
+  <!-- VS 2019 16.3: _Ref_count_obj_alloc2 -->
+  <Type Name="std::_Ref_count_obj_alloc3&lt;*&gt;">
+      <AlternativeType Name="std::_Ref_count_obj_alloc2&lt;*&gt;" />
+      <!-- stateless allocator -->
+      <Intrinsic Optional="true" Name="allocator" Expression="*((_Mybase *) this)"/>
+      <!-- stateful allocator -->
+      <Intrinsic Optional="true" Name="allocator" Expression="_Myval"/>
+      <DisplayString>allocate_shared</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">($T1 *) &amp;_Storage</Item>
+          <Item Name="[allocator]">allocator()</Item>
+      </Expand>
+  </Type>
+
+  <!-- VS 2022 17.10 -->
+  <Type Name="std::_Ref_count_bounded_array_alloc&lt;*&gt;">
+    <!-- stateless allocator -->
+    <Intrinsic Optional="true" Name="allocator" Expression="*((_Mybase *) this)"/>
+    <!-- stateful allocator -->
+    <Intrinsic Optional="true" Name="allocator" Expression="_Myval"/>
+    <DisplayString>allocate_shared&lt;T[N]&gt;</DisplayString>
+    <Expand>
+      <Item Condition="_Uses != 0" Name="[allocated array]">_Storage._Value</Item>
+      <Item Name="[allocator]">allocator()</Item>
+    </Expand>
+  </Type>
+
+  <!-- VS 2022 17.10 -->
+  <Type Name="std::_Ref_count_unbounded_array_alloc&lt;*&gt;">
+    <!-- stateless allocator -->
+    <Intrinsic Optional="true" Name="allocator" Expression="*((_Mybase *) this)"/>
+    <!-- stateful allocator -->
+    <Intrinsic Optional="true" Name="allocator" Expression="_Myval"/>
+    <Intrinsic Name="data" Expression="&amp;(_Storage._Value)" />
+    <Intrinsic Name="size" Expression="_Size" />
+    <DisplayString>allocate_shared&lt;T[]&gt;</DisplayString>
+    <Expand>
+      <Item Name="[allocator]">allocator()</Item>
+      <ArrayItems>
+        <Size>size()</Size>
+        <ValuePointer>data()</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <!-- VS 2022 17.10 -->
+  <Type Name="std::_Ref_count_obj_alloc_for_overwrite&lt;*&gt;">
+      <!-- stateless allocator -->
+      <Intrinsic Optional="true" Name="allocator" Expression="*((_Mybase *) this)"/>
+      <!-- stateful allocator -->
+      <Intrinsic Optional="true" Name="allocator" Expression="_Myval"/>
+      <DisplayString>allocate_shared_for_overwrite</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">($T1 *) &amp;_Storage</Item>
+          <Item Name="[allocator]">allocator()</Item>
+      </Expand>
+  </Type>
+
+  <!-- VS 2022 17.10 -->
+  <Type Name="std::_Ref_count_bounded_array_alloc_for_overwrite&lt;*&gt;">
+    <!-- stateless allocator -->
+    <Intrinsic Optional="true" Name="allocator" Expression="*((_Mybase *) this)"/>
+    <!-- stateful allocator -->
+    <Intrinsic Optional="true" Name="allocator" Expression="_Myval"/>
+    <DisplayString>allocate_shared_for_overwrite&lt;T[N]&gt;</DisplayString>
+    <Expand>
+      <Item Condition="_Uses != 0" Name="[allocated array]">_Storage._Value</Item>
+      <Item Name="[allocator]">allocator()</Item>
+    </Expand>
+  </Type>
+
+  <!-- VS 2022 17.10 -->
+  <Type Name="std::_Ref_count_unbounded_array_alloc_for_overwrite&lt;*&gt;">
+    <!-- stateless allocator -->
+    <Intrinsic Optional="true" Name="allocator" Expression="*((_Mybase *) this)"/>
+    <!-- stateful allocator -->
+    <Intrinsic Optional="true" Name="allocator" Expression="_Myval"/>
+    <Intrinsic Name="data" Expression="&amp;(_Storage._Value)" />
+    <Intrinsic Name="size" Expression="_Size" />
+    <DisplayString>allocate_shared_for_overwrite&lt;T[]&gt;</DisplayString>
+    <Expand>
+      <Item Name="[allocator]">allocator()</Item>
+      <ArrayItems>
+        <Size>size()</Size>
+        <ValuePointer>data()</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <!-- VC 2017, second toolset update -->
+  <Type Name="std::_Ref_count_resource&lt;*&gt;">
+      <DisplayString>custom deleter</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">_Mypair._Myval2</Item>
+          <Item Name="[deleter]">_Mypair</Item>
+      </Expand>
+  </Type>
+
+  <!-- VC 2017, second toolset update -->
+  <Type Name="std::_Ref_count_resource_alloc&lt;*&gt;">
+      <DisplayString>custom deleter, custom allocator</DisplayString>
+      <Expand>
+          <Item Condition="_Uses != 0" Name="[original ptr]">_Mypair._Myval2._Myval2</Item>
+          <Item Name="[deleter]">_Mypair</Item>
+          <Item Name="[allocator]">_Mypair._Myval2</Item>
+      </Expand>
+  </Type>
+
+  <!-- Do not dereference _Ptr when type is void -->
+  <Type Name="std::shared_ptr&lt;void&gt;">
+    <SmartPointer Usage="Minimal">_Ptr</SmartPointer>
+      <DisplayString Condition="_Rep == 0">empty</DisplayString>
+      <DisplayString IncludeView="ptr" Condition="_Ptr == 0">nullptr</DisplayString>
+      <DisplayString IncludeView="ptr" Condition="_Ptr != 0">void</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks == 1)"  >shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks == 2)"  >shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref, {_Rep-&gt;_Weaks - 1} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks &gt; 2)">shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref, {_Rep-&gt;_Weaks - 1} weak refs] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks == 1)"  >shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks == 2)"  >shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs, {_Rep-&gt;_Weaks - 1} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks &gt; 2)">shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs, {_Rep-&gt;_Weaks - 1} weak refs] [{*_Rep}]</DisplayString>
+      <Expand>
+          <Item Condition="_Rep != 0" Name="[ptr]">_Ptr</Item>
+          <Item Condition="_Rep != 0" Name="[control block]">*_Rep</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::shared_ptr&lt;*&gt;">
+      <SmartPointer Usage="Minimal">_Ptr</SmartPointer>
+      <DisplayString Condition="_Rep == 0">empty</DisplayString>
+      <DisplayString IncludeView="ptr" Condition="_Ptr == 0">nullptr</DisplayString>
+      <DisplayString IncludeView="ptr" Condition="_Ptr != 0">{*_Ptr}</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks == 1)"  >shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks == 2)"  >shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref, {_Rep-&gt;_Weaks - 1} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks &gt; 2)">shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref, {_Rep-&gt;_Weaks - 1} weak refs] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks == 1)"  >shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks == 2)"  >shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs, {_Rep-&gt;_Weaks - 1} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks &gt; 2)">shared_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs, {_Rep-&gt;_Weaks - 1} weak refs] [{*_Rep}]</DisplayString>
+      <Expand>
+          <Item Condition="_Rep != 0" Name="[ptr]">_Ptr</Item>
+          <Item Condition="_Rep != 0" Name="[control block]">*_Rep</Item>
+      </Expand>
+  </Type>
+
+  <!-- Do not dereference _Ptr when type is void -->
+  <Type Name="std::weak_ptr&lt;void&gt;">
+      <DisplayString Condition="_Rep == 0">empty</DisplayString>
+      <DisplayString IncludeView="ptr" Condition="_Ptr == 0">nullptr</DisplayString>
+      <DisplayString IncludeView="ptr" Condition="_Ptr != 0">void</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 0)   &amp;&amp; (_Rep-&gt;_Weaks == 1)"  >expired [{_Rep-&gt;_Weaks} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 0)   &amp;&amp; (_Rep-&gt;_Weaks &gt; 1)">expired [{_Rep-&gt;_Weaks} weak refs] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks == 2)"  >weak_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref, {_Rep-&gt;_Weaks - 1} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks &gt; 2)">weak_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref, {_Rep-&gt;_Weaks - 1} weak refs] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks == 2)"  >weak_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs, {_Rep-&gt;_Weaks - 1} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks &gt; 2)">weak_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs, {_Rep-&gt;_Weaks - 1} weak refs] [{*_Rep}]</DisplayString>
+      <Expand>
+          <Item Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 0)" Name="[ptr]">_Ptr</Item>
+          <Item Condition="_Rep != 0" Name="[control block]">*_Rep</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::weak_ptr&lt;*&gt;">
+      <DisplayString Condition="_Rep == 0">empty</DisplayString>
+      <DisplayString IncludeView="ptr" Condition="_Ptr == 0">nullptr</DisplayString>
+      <DisplayString IncludeView="ptr" Condition="_Ptr != 0">{*_Ptr}</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 0)   &amp;&amp; (_Rep-&gt;_Weaks == 1)"  >expired [{_Rep-&gt;_Weaks} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 0)   &amp;&amp; (_Rep-&gt;_Weaks &gt; 1)">expired [{_Rep-&gt;_Weaks} weak refs] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks == 2)"  >weak_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref, {_Rep-&gt;_Weaks - 1} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses == 1)   &amp;&amp; (_Rep-&gt;_Weaks &gt; 2)">weak_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong ref, {_Rep-&gt;_Weaks - 1} weak refs] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks == 2)"  >weak_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs, {_Rep-&gt;_Weaks - 1} weak ref] [{*_Rep}]</DisplayString>
+      <DisplayString Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 1) &amp;&amp; (_Rep-&gt;_Weaks &gt; 2)">weak_ptr {*this,view(ptr)} [{_Rep-&gt;_Uses} strong refs, {_Rep-&gt;_Weaks - 1} weak refs] [{*_Rep}]</DisplayString>
+      <Expand>
+          <Item Condition="(_Rep != 0) &amp;&amp; (_Rep-&gt;_Uses &gt; 0)" Name="[ptr]">_Ptr</Item>
+          <Item Condition="_Rep != 0" Name="[control block]">*_Rep</Item>
+      </Expand>
+  </Type>
+
+
+  <!-- VC 2015 -->
+  <Type Name="std::reference_wrapper&lt;*&gt;">
+      <DisplayString>{*_Ptr}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">_Ptr</Item>
+      </Expand>
+  </Type>
+
+  <!-- std::compare_three_way, std::ranges::less and similar -->
+  <Type Name="std::ranges::equal_to"><DisplayString>ranges::equal_to</DisplayString><Expand/></Type>
+  <Type Name="std::ranges::not_equal_to"><DisplayString>ranges::not_equal_to</DisplayString><Expand/></Type>
+  <Type Name="std::ranges::greater"><DisplayString>ranges::greater</DisplayString><Expand/></Type>
+  <Type Name="std::ranges::less"><DisplayString>ranges::less</DisplayString><Expand/></Type>
+  <Type Name="std::ranges::greater_equal"><DisplayString>ranges::greater_equal</DisplayString><Expand/></Type>
+  <Type Name="std::ranges::less_equal"><DisplayString>ranges::less_equal</DisplayString><Expand/></Type>
+  <Type Name="std::compare_three_way"><DisplayString>compare_three_way</DisplayString><Expand/></Type>
+
+  <!-- std::less<> and similar -->
+  <Type Name="std::plus&lt;void&gt;"><DisplayString>plus&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::minus&lt;void&gt;"><DisplayString>minus&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::multiplies&lt;void&gt;"><DisplayString>multiplies&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::divides&lt;void&gt;"><DisplayString>divides&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::modulus&lt;void&gt;"><DisplayString>modulus&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::negate&lt;void&gt;"><DisplayString>negate&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::equal_to&lt;void&gt;"><DisplayString>equal_to&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::not_equal_to&lt;void&gt;"><DisplayString>not_equal_to&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::greater&lt;void&gt;"><DisplayString>greater&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::less&lt;void&gt;"><DisplayString>less&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::greater_equal&lt;void&gt;"><DisplayString>greater_equal&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::less_equal&lt;void&gt;"><DisplayString>less_equal&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::logical_and&lt;void&gt;"><DisplayString>logical_and&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::logical_or&lt;void&gt;"><DisplayString>logical_or&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::logical_not&lt;void&gt;"><DisplayString>logical_not&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::bit_and&lt;void&gt;"><DisplayString>bit_and&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::bit_or&lt;void&gt;"><DisplayString>bit_or&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::bit_xor&lt;void&gt;"><DisplayString>bit_xor&lt;&gt;</DisplayString><Expand/></Type>
+  <Type Name="std::bit_not&lt;void&gt;"><DisplayString>bit_not&lt;&gt;</DisplayString><Expand/></Type>
+
+  <!-- std::less<T> and similar -->
+  <Type Name="std::plus&lt;*&gt;"><DisplayString>plus</DisplayString><Expand/></Type>
+  <Type Name="std::minus&lt;*&gt;"><DisplayString>minus</DisplayString><Expand/></Type>
+  <Type Name="std::multiplies&lt;*&gt;"><DisplayString>multiplies</DisplayString><Expand/></Type>
+  <Type Name="std::divides&lt;*&gt;"><DisplayString>divides</DisplayString><Expand/></Type>
+  <Type Name="std::modulus&lt;*&gt;"><DisplayString>modulus</DisplayString><Expand/></Type>
+  <Type Name="std::negate&lt;*&gt;"><DisplayString>negate</DisplayString><Expand/></Type>
+  <Type Name="std::equal_to&lt;*&gt;"><DisplayString>equal_to</DisplayString><Expand/></Type>
+  <Type Name="std::not_equal_to&lt;*&gt;"><DisplayString>not_equal_to</DisplayString><Expand/></Type>
+  <Type Name="std::greater&lt;*&gt;"><DisplayString>greater</DisplayString><Expand/></Type>
+  <Type Name="std::less&lt;*&gt;"><DisplayString>less</DisplayString><Expand/></Type>
+  <Type Name="std::greater_equal&lt;*&gt;"><DisplayString>greater_equal</DisplayString><Expand/></Type>
+  <Type Name="std::less_equal&lt;*&gt;"><DisplayString>less_equal</DisplayString><Expand/></Type>
+  <Type Name="std::logical_and&lt;*&gt;"><DisplayString>logical_and</DisplayString><Expand/></Type>
+  <Type Name="std::logical_or&lt;*&gt;"><DisplayString>logical_or</DisplayString><Expand/></Type>
+  <Type Name="std::logical_not&lt;*&gt;"><DisplayString>logical_not</DisplayString><Expand/></Type>
+  <Type Name="std::bit_and&lt;*&gt;"><DisplayString>bit_and</DisplayString><Expand/></Type>
+  <Type Name="std::bit_or&lt;*&gt;"><DisplayString>bit_or</DisplayString><Expand/></Type>
+  <Type Name="std::bit_xor&lt;*&gt;"><DisplayString>bit_xor</DisplayString><Expand/></Type>
+  <Type Name="std::bit_not&lt;*&gt;"><DisplayString>bit_not</DisplayString><Expand/></Type>
+
+
+  <Type Name="std::unary_negate&lt;*&gt;">
+      <DisplayString>not1({_Functor})</DisplayString>
+      <Expand>
+          <Item Name="[pred]">_Functor</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::binary_negate&lt;*&gt;">
+      <DisplayString>not2({_Functor})</DisplayString>
+      <Expand>
+          <Item Name="[pred]">_Functor</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::_Ph&lt;*&gt;">
+      <DisplayString>_{$T1,d}</DisplayString>
+      <Expand/>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::_Binder&lt;*&gt;">
+      <DisplayString>bind({_Mypair}, {_Mypair._Myval2,view(noparens)})</DisplayString>
+      <Expand>
+          <Item Name="[f]">_Mypair</Item>
+          <Item Name="[bound_args]">_Mypair._Myval2</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::_Front_binder&lt;*&gt;">
+      <DisplayString>bind_front({_Mypair}, {_Mypair._Myval2,view(noparens)})</DisplayString>
+      <Expand>
+          <Item Name="[f]">_Mypair</Item>
+          <Item Name="[bound_args]">_Mypair._Myval2</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::_Back_binder&lt;*&gt;">
+    <DisplayString>bind_back({_Mypair}, {_Mypair._Myval2,view(noparens)})</DisplayString>
+    <Expand>
+      <Item Name="[f]">_Mypair</Item>
+      <Item Name="[bound_args]">_Mypair._Myval2</Item>
+    </Expand>
+  </Type>
+
+
+  <!-- VC 2015 -->
+  <Type Name="std::_Mem_fn&lt;*&gt;">
+      <DisplayString>mem_fn({_Pm})</DisplayString>
+      <Expand/>
+  </Type>
+
+
+  <!-- VC 2015 -->
+  <Type Name="std::_Func_impl&lt;*&gt;">
+      <DisplayString>{_Mypair._Myval2}</DisplayString>
+      <Expand>
+          <Item Name="[functor]">_Mypair._Myval2</Item>
+          <Item Name="[allocator]">_Mypair</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::_Func_impl_no_alloc&lt;*&gt;">
+      <DisplayString>{_Callee}</DisplayString>
+      <Expand>
+          <Item Name="[functor]">_Callee</Item>
+      </Expand>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::function&lt;*&gt;">
+      <DisplayString Condition="_Mystorage._Ptrs[_EEN_IMPL] == 0">empty</DisplayString>
+      <DisplayString Condition="_Mystorage._Ptrs[_EEN_IMPL] != 0">{*_Mystorage._Ptrs[_EEN_IMPL]}</DisplayString>
+      <Expand>
+          <ExpandedItem Condition="_Mystorage._Ptrs[_EEN_IMPL] != 0">*_Mystorage._Ptrs[_EEN_IMPL]</ExpandedItem>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::hash&lt;*&gt;">
+      <DisplayString>hash</DisplayString>
+      <Expand/>
+  </Type>
+
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;1,1000000000&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} nanosecond</DisplayString>
+      <DisplayString>{_MyRep} nanoseconds</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;1,1000000&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} microsecond</DisplayString>
+      <DisplayString>{_MyRep} microseconds</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;1,1000&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} millisecond</DisplayString>
+      <DisplayString>{_MyRep} milliseconds</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;1,1&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} second</DisplayString>
+      <DisplayString>{_MyRep} seconds</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;60,1&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} minute</DisplayString>
+      <DisplayString>{_MyRep} minutes</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;3600,1&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} hour</DisplayString>
+      <DisplayString>{_MyRep} hours</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;86400,1&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} day</DisplayString>
+      <DisplayString>{_MyRep} days</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;604800,1&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} week</DisplayString>
+      <DisplayString>{_MyRep} weeks</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;2629746,1&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} month</DisplayString>
+      <DisplayString>{_MyRep} months</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::duration&lt;*,std::ratio&lt;31556952,1&gt; &gt;">
+      <DisplayString Condition="_MyRep == 1">{_MyRep} year</DisplayString>
+      <DisplayString>{_MyRep} years</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::day">
+      <DisplayString Condition="_Day % 10 == 1 &amp;&amp; _Day % 100 != 11">{(int)_Day}st</DisplayString>
+      <DisplayString Condition="_Day % 10 == 2 &amp;&amp; _Day % 100 != 12">{(int)_Day}nd</DisplayString>
+      <DisplayString Condition="_Day % 10 == 3 &amp;&amp; _Day % 100 != 13">{(int)_Day}rd</DisplayString>
+      <DisplayString>{(int)_Day}th</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::month">
+      <DisplayString Condition="_Month == 1">January</DisplayString>
+      <DisplayString Condition="_Month == 2">February</DisplayString>
+      <DisplayString Condition="_Month == 3">March</DisplayString>
+      <DisplayString Condition="_Month == 4">April</DisplayString>
+      <DisplayString Condition="_Month == 5">May</DisplayString>
+      <DisplayString Condition="_Month == 6">June</DisplayString>
+      <DisplayString Condition="_Month == 7">July</DisplayString>
+      <DisplayString Condition="_Month == 8">August</DisplayString>
+      <DisplayString Condition="_Month == 9">September</DisplayString>
+      <DisplayString Condition="_Month == 10">October</DisplayString>
+      <DisplayString Condition="_Month == 11">November</DisplayString>
+      <DisplayString Condition="_Month == 12">December</DisplayString>
+      <DisplayString>{_Month}</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::year">
+      <DisplayString>{_Year}</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::weekday">
+      <DisplayString Condition="_Weekday == 0">Sunday</DisplayString>
+      <DisplayString Condition="_Weekday == 1">Monday</DisplayString>
+      <DisplayString Condition="_Weekday == 2">Tuesday</DisplayString>
+      <DisplayString Condition="_Weekday == 3">Wednesday</DisplayString>
+      <DisplayString Condition="_Weekday == 4">Thursday</DisplayString>
+      <DisplayString Condition="_Weekday == 5">Friday</DisplayString>
+      <DisplayString Condition="_Weekday == 6">Saturday</DisplayString>
+      <DisplayString>{_Weekday}</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::chrono::weekday_indexed">
+      <DisplayString Condition="_Index == 1">{(int)_Index}st {_Weekday}</DisplayString>
+      <DisplayString Condition="_Index == 2">{(int)_Index}nd {_Weekday}</DisplayString>
+      <DisplayString Condition="_Index == 3">{(int)_Index}rd {_Weekday}</DisplayString>
+      <DisplayString Condition="_Index == 4 || _Index == 5">{(int)_Index}th {_Weekday}</DisplayString>
+      <DisplayString>{(int)_Index}, {_Weekday}</DisplayString>
+      <Expand>
+        <Item Name="[weekday]">_Weekday</Item>
+        <Item Name="[index]">(int)_Index</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::weekday_last">
+      <DisplayString>Last {_Weekday}</DisplayString>
+      <Expand>
+        <Item Name="[weekday]">_Weekday</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::month_day">
+      <DisplayString>{_Month} {_Day}</DisplayString>
+        <Expand>
+          <Item Name="[month]">_Month</Item>
+          <Item Name="[day]">_Day</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::month_day_last">
+      <DisplayString>Last day of {_Month}</DisplayString>
+      <Expand>
+        <Item Name="[month]">_Month</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::month_weekday">
+      <DisplayString>{_Weekday_index} of {_Month}</DisplayString>
+        <Expand>
+          <Item Name="[month]">_Month</Item>
+          <Item Name="[weekday_indexed]">_Weekday_index</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::month_weekday_last">
+      <DisplayString>Last {_Weekday_last._Weekday} of {_Month}</DisplayString>
+      <Expand>
+        <Item Name="[month]">_Month</Item>
+        <Item Name="[weekday]">_Weekday_last._Weekday</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::year_month">
+      <DisplayString>{_Year} {_Month}</DisplayString>
+        <Expand>
+          <Item Name="[year]">_Year</Item>
+          <Item Name="[month]">_Month</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::year_month_day">
+      <DisplayString>{_Year} {_Month} {_Day}</DisplayString>
+        <Expand>
+          <Item Name="[year]">_Year</Item>
+          <Item Name="[month]">_Month</Item>
+          <Item Name="[day]">_Day</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::year_month_day_last">
+      <DisplayString>{_Month_day_last}, {_Year}</DisplayString>
+      <Expand>
+        <Item Name="[year]">_Year</Item>
+        <Item Name="[month]">_Month_day_last._Month</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::year_month_weekday">
+      <DisplayString>{_Weekday_index} of {_Month}, {_Year}</DisplayString>
+        <Expand>
+          <Item Name="[year]">_Year</Item>
+          <Item Name="[month]">_Month</Item>
+          <Item Name="[weekday_indexed]">_Weekday_index</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::year_month_weekday_last">
+      <DisplayString>{_Weekday_last} of {_Month}, {_Year}</DisplayString>
+      <Expand>
+        <Item Name="[year]">_Year</Item>
+        <Item Name="[month]">_Month</Item>
+        <Item Name="[weekday]">_Weekday_last._Weekday</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::chrono::hh_mm_ss&lt;*&gt;">
+      <DisplayString Condition="_Is_neg">-{_Hours._MyRep}h {_Mins._MyRep}m {_Secs._MyRep}s {_Sub_secs._MyRep}ss</DisplayString>
+      <DisplayString>{_Hours._MyRep}h {_Mins._MyRep}m {_Secs._MyRep}s {_Sub_secs._MyRep}ss</DisplayString>
+      <Expand>
+        <Item Name="[is_negative]">_Is_neg</Item>
+        <Item Name="[hours]">_Hours</Item>
+        <Item Name="[minutes]">_Mins</Item>
+        <Item Name="[seconds]">_Secs</Item>
+        <Item Name="[subseconds]">_Sub_secs</Item>
+      </Expand>
+  </Type>
+
+  <!--
+   * VC 2015+ ABI basic_string
+   * Notes:
+   * Hard coding _BUF_SIZE for clang-cl compatibility; clang-cl as of 7.0.1 does not emit S_CONSTANT to get _BUF_SIZE
+   *
+   * The `na` format specifier means "no address". For more info, see:
+   * https://learn.microsoft.com/visualstudio/debugger/format-specifiers-in-cpp
+   -->
+  <Type Name="std::basic_string&lt;*&gt;">
+    <Intrinsic Name="size" Expression="_Mypair._Myval2._Mysize" />
+    <Intrinsic Name="capacity" Expression="_Mypair._Myval2._Myres" />
+    <!-- _BUF_SIZE = 16 / sizeof($T1) &lt; 1 ? 1 : 16 / sizeof($T1) -->
+    <Intrinsic Name="bufSize" Expression="16 / sizeof($T1) &lt; 1 ? 1 : 16 / sizeof($T1)" />
+    <Intrinsic Name="isShortString" Expression="capacity() &lt; bufSize()" />
+    <Intrinsic Name="isLongString" Expression="capacity() &gt;= bufSize()" />
+    <Intrinsic Name="c_str" Expression="const_cast&lt;const $T1*&gt;(isShortString() ? _Mypair._Myval2._Bx._Buf : _Mypair._Myval2._Bx._Ptr)" />
+    <DisplayString Condition="isShortString()">{_Mypair._Myval2._Bx._Buf,na}</DisplayString>
+    <DisplayString Condition="isLongString()">{_Mypair._Myval2._Bx._Ptr,na}</DisplayString>
+    <StringView Condition="isShortString()">_Mypair._Myval2._Bx._Buf,na</StringView>
+    <StringView Condition="isLongString()">_Mypair._Myval2._Bx._Ptr,na</StringView>
+    <Expand>
+      <Item Name="[size]" ExcludeView="simple">size()</Item>
+      <Item Name="[capacity]" ExcludeView="simple">capacity()</Item>
+      <Item Name="[allocator]" ExcludeView="simple">_Mypair</Item>
+      <ArrayItems>
+        <Size>_Mypair._Myval2._Mysize</Size>
+        <ValuePointer Condition="isShortString()">_Mypair._Myval2._Bx._Buf</ValuePointer>
+        <ValuePointer Condition="isLongString()">_Mypair._Myval2._Bx._Ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <Type Name="std::_String_iterator&lt;*&gt;">
+      <AlternativeType Name="std::_String_const_iterator&lt;*&gt;" />
+      <SmartPointer Usage="Indexable">_Ptr,na</SmartPointer>
+      <Expand>
+          <Item Name="[ptr]">_Ptr</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::basic_string_view&lt;*,*&gt;">
+    <Intrinsic Name="size" Expression="_Mysize" />
+    <Intrinsic Name="data" Expression="_Mydata" />
+    <DisplayString>{_Mydata,[_Mysize]na}</DisplayString>
+    <StringView>_Mydata,[_Mysize]na</StringView>
+    <Expand>
+      <Item Name="[size]" ExcludeView="simple">size()</Item>
+      <ArrayItems>
+        <Size>size()</Size>
+        <ValuePointer>data()</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL == 0 and must have lower priority. -->
+  <Type Name="std::_String_view_iterator&lt;*&gt;" Priority="MediumLow">
+    <SmartPointer Usage="Indexable">_Myptr,na</SmartPointer>
+    <Expand>
+      <Item Name="[ptr]">_Myptr</Item>
+    </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL != 0 and must have higher priority. -->
+  <Type Name="std::_String_view_iterator&lt;*&gt;" Priority="Medium">
+    <DisplayString>{_Mydata + _Myoff,[_Mysize - _Myoff]na}</DisplayString>
+    <StringView>_Mydata + _Myoff,[_Mysize - _Myoff]na</StringView>
+    <Expand>
+      <Item Name="[ptr]">_Mydata + _Myoff</Item>
+      <Item Name="[offset]">_Myoff</Item>
+      <Item Name="[string_view]">_Mydata,[_Mysize]na</Item>
+    </Expand>
+  </Type>
+
+
+  <Type Name="std::array&lt;*,*&gt;">
+      <DisplayString>{{ size={$T2} }}</DisplayString>
+      <Expand>
+          <ArrayItems>
+              <Size>$T2</Size>
+              <ValuePointer>_Elems</ValuePointer>
+          </ArrayItems>
+      </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL == 0 and must have lower priority. -->
+  <Type Name="std::_Array_iterator&lt;*&gt;" Priority="MediumLow">
+      <AlternativeType Name="std::_Array_const_iterator&lt;*&gt;" />
+      <SmartPointer Usage="Indexable">_Ptr,na</SmartPointer>
+      <DisplayString>{*_Ptr}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">_Ptr</Item>
+      </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL != 0 and must have higher priority. -->
+  <Type Name="std::_Array_iterator&lt;*&gt;" Priority="Medium">
+      <AlternativeType Name="std::_Array_const_iterator&lt;*&gt;" />
+      <SmartPointer Usage="Indexable">_Ptr + _Idx</SmartPointer>
+      <DisplayString Condition="_Idx != _EEN_SIZE">{_Ptr[_Idx]}</DisplayString>
+      <DisplayString Condition="_Idx == _EEN_SIZE">end</DisplayString>
+      <Expand>
+          <Item Condition="_Idx != _EEN_SIZE" Name="[ptr]">_Ptr + _Idx</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::deque&lt;*&gt;">
+      <Intrinsic Name="size" Expression="_Mypair._Myval2._Mysize" />
+      <DisplayString>{{ size={size()} }}</DisplayString>
+      <Expand>
+          <Item Name="[allocator]" ExcludeView="simple">_Mypair</Item>
+          <IndexListItems>
+              <Size>size()</Size>
+              <ValueNode>_Mypair._Myval2._Map[(($i + _Mypair._Myval2._Myoff) / _EEN_DS) % _Mypair._Myval2._Mapsize][($i + _Mypair._Myval2._Myoff) % _EEN_DS]</ValueNode>
+          </IndexListItems>
+      </Expand>
+  </Type>
+
+  <Type Name="std::_Deque_iterator&lt;*&gt;">
+      <AlternativeType Name="std::_Deque_const_iterator&lt;*&gt;" />
+      <DisplayString Condition="_Myoff &lt; ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Myoff + ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Mysize">{((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Map[(_Myoff / _EEN_DS) % ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Mapsize][_Myoff % _EEN_DS]}</DisplayString>
+      <DisplayString Condition="_Myoff &gt;= ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Myoff + ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Mysize">end</DisplayString>
+      <Expand>
+          <Item Condition="_Myoff &lt; ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Myoff + ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Mysize" Name="[index]">_Myoff - ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Myoff</Item>
+          <Item Condition="_Myoff &lt; ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Myoff + ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Mysize" Name="[ptr]">&amp;((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Map[(_Myoff / _EEN_DS) % ((_Mydeque_t *)_Myproxy-&gt;_Mycont)-&gt;_Mapsize][_Myoff % _EEN_DS]</Item>
+      </Expand>
+  </Type>
+
+
+  <!-- VC 2015 -->
+  <Type Name="std::forward_list&lt;*&gt;">
+      <DisplayString Condition="_Mypair._Myval2._Myhead == 0">empty</DisplayString>
+      <DisplayString Condition="_Mypair._Myval2._Myhead != 0">non-empty</DisplayString>
+      <Expand>
+          <Item Name="[allocator]" ExcludeView="simple">_Mypair</Item>
+          <LinkedListItems>
+              <HeadPointer>_Mypair._Myval2._Myhead</HeadPointer>
+              <NextPointer>_Next</NextPointer>
+              <ValueNode>_Myval</ValueNode>
+          </LinkedListItems>
+      </Expand>
+  </Type>
+
+  <Type Name="std::_Flist_iterator&lt;*&gt;">
+      <AlternativeType Name="std::_Flist_const_iterator&lt;*&gt;" />
+      <SmartPointer Usage="Minimal">&amp;_Ptr-&gt;_Myval,na</SmartPointer>
+      <DisplayString Condition="_Ptr == 0">end</DisplayString>
+      <DisplayString Condition="_Ptr != 0">{**this}</DisplayString>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::list&lt;*&gt;">
+      <DisplayString>{{ size={_Mypair._Myval2._Mysize} }}</DisplayString>
+      <Expand>
+          <Item Name="[allocator]" ExcludeView="simple">_Mypair</Item>
+          <LinkedListItems>
+              <Size>_Mypair._Myval2._Mysize</Size>
+              <HeadPointer>_Mypair._Myval2._Myhead-&gt;_Next</HeadPointer>
+              <NextPointer>_Next</NextPointer>
+              <ValueNode>_Myval</ValueNode>
+          </LinkedListItems>
+      </Expand>
+  </Type>
+
+  <Type Name="std::_List_iterator&lt;*&gt;">
+      <AlternativeType Name="std::_List_const_iterator&lt;*&gt;" />
+      <SmartPointer Usage="Minimal">&amp;_Ptr-&gt;_Myval,na</SmartPointer>
+  </Type>
+
+
+  <!-- VC 2015 -->
+  <Type Name="std::vector&lt;bool,*&gt;">
+    <Intrinsic Name="size" Expression="_Mysize" />
+    <Intrinsic Name="capacity" Expression="_Myvec.capacity() * _EEN_VBITS" />
+      <DisplayString>{{ size={size()} }}</DisplayString>
+      <Expand>
+          <Item Name="[capacity]" ExcludeView="simple">capacity()</Item>
+          <Item Name="[allocator]" ExcludeView="simple">_Myvec._Mypair</Item>
+          <IndexListItems>
+              <Size>_Mysize</Size>
+              <ValueNode>(bool)((_Myvec._Mypair._Myval2._Myfirst[$i / _EEN_VBITS] &gt;&gt; ($i % _EEN_VBITS)) &amp; 1)</ValueNode>
+          </IndexListItems>
+      </Expand>
+  </Type>
+
+  <Type Name="std::_Vb_reference&lt;*&gt;">
+      <AlternativeType Name="std::_Vb_iterator&lt;*&gt;" />
+      <AlternativeType Name="std::_Vb_const_iterator&lt;*&gt;" />
+      <DisplayString>{(bool)((*_Myptr &gt;&gt; _Myoff) &amp; 1)}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">_Myptr</Item>
+          <Item Name="[offset]">_Myoff</Item>
+      </Expand>
+  </Type>
+
+
+  <!-- VC 2015 -->
+  <Type Name="std::vector&lt;*&gt;">
+    <Intrinsic Name="size" Expression="(size_t)(_Mypair._Myval2._Mylast - _Mypair._Myval2._Myfirst)" />
+    <Intrinsic Name="capacity" Expression="(size_t)(_Mypair._Myval2._Myend - _Mypair._Myval2._Myfirst)" />
+    <DisplayString>{{ size={size()} }}</DisplayString>
+    <Expand>
+      <Item Name="[capacity]" ExcludeView="simple">capacity()</Item>
+      <Item Name="[allocator]" ExcludeView="simple">_Mypair</Item>
+      <ArrayItems>
+        <Size>size()</Size>
+        <ValuePointer>_Mypair._Myval2._Myfirst</ValuePointer>
+        </ArrayItems>
+    </Expand>
+  </Type>
+
+  <Type Name="std::vector&lt;wchar_t,*&gt;">
+    <AlternativeType Name="std::vector&lt;char,*&gt;" />
+    <AlternativeType Name="std::vector&lt;char8_t,*&gt;" />
+    <AlternativeType Name="std::vector&lt;char16_t,*&gt;" />
+    <AlternativeType Name="std::vector&lt;char32_t,*&gt;" />
+    <Intrinsic Name="data" Expression="_Mypair._Myval2._Myfirst" />
+    <Intrinsic Name="size" Expression="(size_t)(_Mypair._Myval2._Mylast - _Mypair._Myval2._Myfirst)" />
+    <Intrinsic Name="capacity" Expression="(size_t)(_Mypair._Myval2._Myend - _Mypair._Myval2._Myfirst)" />
+    <SmartPointer Usage="Indexable" DefaultExpansion="false">data()</SmartPointer>
+    <DisplayString Condition="size() > 0">{data(),[size()]na}</DisplayString>
+    <DisplayString Condition="size() == 0">{{empty}}</DisplayString>
+    <Expand>
+      <Item Name="[size]" ExcludeView="simple">size()</Item>
+      <Item Name="[capacity]" ExcludeView="simple">capacity()</Item>
+      <Item Name="[allocator]" ExcludeView="simple">_Mypair</Item>
+      <ArrayItems>
+        <Size>size()</Size>
+        <ValuePointer>data()</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL == 0 and must have lower priority. -->
+  <Type Name="std::_Vector_iterator&lt;*&gt;" Priority="MediumLow">
+      <AlternativeType Name="std::_Vector_const_iterator&lt;*&gt;" />
+      <SmartPointer Usage="Indexable">_Ptr,na</SmartPointer>
+      <DisplayString>{*_Ptr}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">_Ptr</Item>
+      </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL != 0 and must have higher priority. -->
+  <Type Name="std::_Vector_iterator&lt;*&gt;" Priority="Medium">
+      <AlternativeType Name="std::_Vector_const_iterator&lt;*&gt;" />
+      <Intrinsic Name="my_cont_end" Expression="((_Myvec_t *)_Myproxy-&gt;_Mycont)-&gt;_Mylast" />
+      <SmartPointer Usage="Indexable">_Ptr,na</SmartPointer>
+      <DisplayString Condition="_Ptr == my_cont_end()">end</DisplayString>
+      <DisplayString Condition="_Ptr != my_cont_end()">{*_Ptr}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">_Ptr</Item>
+      </Expand>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::map&lt;*&gt;" Priority="Medium">
+    <AlternativeType Name="std::multimap&lt;*&gt;" />
+    <AlternativeType Name="std::set&lt;*&gt;" />
+    <AlternativeType Name="std::multiset&lt;*&gt;" />
+    <DisplayString>{{ size={_Mypair._Myval2._Myval2._Mysize} }}</DisplayString>
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Mypair</Item>
+      <Item Name="[allocator]" ExcludeView="simple">_Mypair._Myval2</Item>
+      <TreeItems>
+        <Size>_Mypair._Myval2._Myval2._Mysize</Size>
+        <HeadPointer>_Mypair._Myval2._Myval2._Myhead-&gt;_Parent</HeadPointer>
+        <LeftPointer>_Left</LeftPointer>
+        <RightPointer>_Right</RightPointer>
+        <ValueNode Condition="_Isnil == 0">_Myval</ValueNode>
+      </TreeItems>
+    </Expand>
+  </Type>
+
+  <!-- Starting in VS 2015, Update 2, we added a new visualization for std::map that shows the key in the name column,
+       and the value in the value column.  If desired, the "ShowElementsByIndex" view can be used to fall back to the prior
+       behavior and show the index in the name column and the key-value pair in the value column. -->
+  <Type Name="std::map&lt;*&gt;" ExcludeView="ShowElementsByIndex" Priority="MediumHigh">
+    <AlternativeType Name="std::multimap&lt;*&gt;" />
+    <DisplayString>{{ size={_Mypair._Myval2._Myval2._Mysize} }}</DisplayString>
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Mypair</Item>
+      <Item Name="[allocator]" ExcludeView="simple">_Mypair._Myval2</Item>
+      <TreeItems>
+        <Size>_Mypair._Myval2._Myval2._Mysize</Size>
+        <HeadPointer>_Mypair._Myval2._Myval2._Myhead-&gt;_Parent</HeadPointer>
+        <LeftPointer>_Left</LeftPointer>
+        <RightPointer>_Right</RightPointer>
+        <ValueNode Condition="_Isnil == 0" Name="[{_Myval.first}]">_Myval,view(MapHelper)</ValueNode>
+      </TreeItems>
+    </Expand>
+  </Type>
+
+  <Type Name="std::pair&lt;*, *&gt;" IncludeView="MapHelper">
+    <DisplayString>{second}</DisplayString>
+  </Type>
+
+  <Type Name="std::_Tree_iterator&lt;*&gt;">
+      <AlternativeType Name="std::_Tree_const_iterator&lt;*&gt;" />
+      <SmartPointer Usage="Minimal">_Ptr-&gt;_Isnil ? nullptr : &amp;_Ptr-&gt;_Myval</SmartPointer>
+      <DisplayString Condition="_Ptr-&gt;_Isnil == 0">{_Ptr-&gt;_Myval}</DisplayString>
+      <DisplayString Condition="_Ptr-&gt;_Isnil != 0">end</DisplayString>
+      <Expand>
+          <Item Condition="_Ptr-&gt;_Isnil == 0" Name="[ptr]">&amp;_Ptr-&gt;_Myval</Item>
+      </Expand>
+  </Type>
+
+
+  <!-- VC 2015 - must have higher priority -->
+  <Type Name="stdext::hash_map&lt;*&gt;" Priority="Medium">
+      <AlternativeType Name="stdext::hash_multimap&lt;*&gt;" />
+      <AlternativeType Name="stdext::hash_set&lt;*&gt;" />
+      <AlternativeType Name="stdext::hash_multiset&lt;*&gt;" />
+      <DisplayString>{_List}</DisplayString>
+      <Expand>
+          <Item Name="[bucket_count]" IncludeView="detailed">_Maxidx</Item>
+          <Item Name="[load_factor]" IncludeView="detailed">((float)_List._Mypair._Myval2._Mysize) / ((float)_Maxidx)</Item>
+          <Item Name="[max_load_factor]" IncludeView="detailed">_Traitsobj._Max_buckets</Item>
+          <Item Name="[allocator]" ExcludeView="simple">_List._Mypair</Item>
+          <ExpandedItem>_List,view(simple)</ExpandedItem>
+      </Expand>
+  </Type>
+
+  <!-- VC 2015 - must have higher priority -->
+  <Type Name="std::unordered_map&lt;*&gt;" Priority="Medium">
+      <AlternativeType Name="std::unordered_multimap&lt;*&gt;" />
+      <AlternativeType Name="std::unordered_set&lt;*&gt;" />
+      <AlternativeType Name="std::unordered_multiset&lt;*&gt;" />
+      <DisplayString>{_List}</DisplayString>
+      <Expand>
+          <Item Name="[bucket_count]" IncludeView="detailed">_Maxidx</Item>
+          <Item Name="[load_factor]" IncludeView="detailed">((float)_List._Mypair._Myval2._Mysize) / ((float)_Maxidx)</Item>
+          <Item Name="[max_load_factor]" IncludeView="detailed">_Traitsobj._Mypair._Myval2._Myval2</Item>
+          <Item Name="[hash_function]" ExcludeView="simple">_Traitsobj._Mypair</Item>
+          <Item Name="[key_eq]" ExcludeView="simple">_Traitsobj._Mypair._Myval2</Item>
+          <Item Name="[allocator]" ExcludeView="simple">_List._Mypair</Item>
+          <ExpandedItem>_List,view(simple)</ExpandedItem>
+      </Expand>
+  </Type>
+
+  <Type Name="std::unordered_map&lt;*&gt;" Priority="MediumHigh" ExcludeView="ShowElementsByIndex">
+    <AlternativeType Name="std::unordered_multimap&lt;*&gt;" />
+    <DisplayString>{_List}</DisplayString>
+    <Expand>
+      <Item Name="[bucket_count]" IncludeView="detailed">_Maxidx</Item>
+      <Item Name="[load_factor]" IncludeView="detailed">((float)_List._Mypair._Myval2._Mysize) / ((float)_Maxidx)</Item>
+      <Item Name="[max_load_factor]" IncludeView="detailed">_Traitsobj._Mypair._Myval2._Myval2</Item>
+      <Item Name="[hash_function]" ExcludeView="simple">_Traitsobj._Mypair</Item>
+      <Item Name="[key_eq]" ExcludeView="simple">_Traitsobj._Mypair._Myval2</Item>
+      <Item Name="[allocator]" ExcludeView="simple">_List._Mypair</Item>
+      <ExpandedItem>_List,view(MapHelper)</ExpandedItem>
+    </Expand>
+  </Type>
+
+  <!-- Alternate view of std::list for internal list contained within an std::unordered_map.-->
+  <Type Name="std::list&lt;std::pair&lt;*,*&gt;,*&gt;" IncludeView="MapHelper">
+    <DisplayString>Test</DisplayString>
+    <Expand>
+      <LinkedListItems>
+        <Size>_Mypair._Myval2._Mysize</Size>
+        <HeadPointer>_Mypair._Myval2._Myhead-&gt;_Next</HeadPointer>
+        <NextPointer>_Next</NextPointer>
+        <ValueNode Name="[{_Myval.first}]">_Myval</ValueNode>
+      </LinkedListItems>
+    </Expand>
+  </Type>
+
+
+  <Type Name="std::queue&lt;*&gt;">
+      <AlternativeType Name="std::stack&lt;*&gt;" />
+      <DisplayString>{c}</DisplayString>
+      <Expand>
+          <Item Name="c">c</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::priority_queue&lt;*&gt;">
+      <DisplayString>{c}</DisplayString>
+      <Expand>
+          <Item Name="c [heap]">c</Item>
+          <Item Name="comp">comp</Item>
+      </Expand>
+  </Type>
+
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL == 0 and must have lower priority. -->
+  <Type Name="std::reverse_iterator&lt;std::_Array_iterator&lt;*&gt; &gt;" Priority="MediumLow">
+      <AlternativeType Name="std::reverse_iterator&lt;std::_Array_const_iterator&lt;*&gt; &gt;" />
+      <SmartPointer Usage="Minimal">current._Ptr - 1,na</SmartPointer>
+      <DisplayString>reverse_iterator {current._Ptr[-1]}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">current._Ptr - 1</Item>
+      </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL != 0 and must have higher priority. -->
+  <Type Name="std::reverse_iterator&lt;std::_Array_iterator&lt;*&gt; &gt;" Priority="Medium">
+      <AlternativeType Name="std::reverse_iterator&lt;std::_Array_const_iterator&lt;*&gt; &gt;" />
+      <SmartPointer Usage="Minimal">current._Ptr + current._Idx - 1,na</SmartPointer>
+      <DisplayString Condition="current._Idx != 0">reverse_iterator {current._Ptr[current._Idx - 1]}</DisplayString>
+      <DisplayString Condition="current._Idx == 0">reverse_iterator rend</DisplayString>
+      <Expand>
+          <Item Condition="current._Idx != 0" Name="[ptr]">current._Ptr + current._Idx - 1</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::reverse_iterator&lt;std::_List_iterator&lt;*&gt; &gt;">
+      <AlternativeType Name="std::reverse_iterator&lt;std::_List_const_iterator&lt;*&gt; &gt;" />
+      <SmartPointer Usage="Minimal">&amp;current._Ptr-&gt;_Prev-&gt;_Myval,na</SmartPointer>
+      <DisplayString>reverse_iterator {**this}</DisplayString>
+  </Type>
+
+  <Type Name="std::reverse_iterator&lt;std::_Vector_iterator&lt;*&gt; &gt;">
+      <AlternativeType Name="std::reverse_iterator&lt;std::_Vector_const_iterator&lt;*&gt; &gt;" />
+      <SmartPointer Usage="Minimal">current._Ptr - 1,na</SmartPointer>
+      <DisplayString>reverse_iterator {**this}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">current._Ptr - 1</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::reverse_iterator&lt;*&gt;" Priority="Medium">
+      <DisplayString>reverse_iterator base() {current}</DisplayString>
+      <Expand>
+          <Synthetic Name="[NOTE]"><DisplayString>NOTE: *ri is equivalent to *prev(ri.base())</DisplayString></Synthetic>
+          <Item Name="base()">current</Item>
+      </Expand>
+  </Type>
+
+  <!-- This "partial specialization" for raw pointers or iterators marked as <SmartPointer Usage="Indexable">.
+       Must have higher priority than the "primary template" for arbitrary iterators. -->
+  <Type Name="std::reverse_iterator&lt;*&gt;" Priority="MediumHigh">
+      <SmartPointer Usage="Minimal">current - 1</SmartPointer>
+      <DisplayString>reverse_iterator {current[-1]}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">current - 1</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::back_insert_iterator&lt;*&gt;">
+      <DisplayString>back_insert_iterator into {container}</DisplayString>
+      <Expand>
+          <Item Name="container">container</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::front_insert_iterator&lt;*&gt;">
+      <DisplayString>front_insert_iterator into {container}</DisplayString>
+      <Expand>
+          <Item Name="container">container</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::insert_iterator&lt;*&gt;">
+      <DisplayString>insert_iterator into {container} at {iter}</DisplayString>
+      <Expand>
+          <Item Name="container">container</Item>
+          <Item Name="iter">iter</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::move_iterator&lt;*&gt;">
+      <DisplayString>move_iterator {_Current}</DisplayString>
+      <Expand>
+          <Item Name="[current]">_Current</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::basic_const_iterator&lt;*&gt;">
+      <DisplayString>basic_const_iterator {_Current}</DisplayString>
+      <Expand>
+        <Item Name="current">_Current</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::complex&lt;*&gt;">
+      <DisplayString Condition="(_Val[1] &lt; 0) &amp;&amp; (_Val[0] == 0)">-i*{-_Val[1]}</DisplayString>
+      <DisplayString Condition="(_Val[1] &lt; 0) &amp;&amp; (_Val[0] != 0)">{_Val[0]}-i*{-_Val[1]}</DisplayString>
+      <DisplayString Condition="_Val[1] == 0">{_Val[0]}</DisplayString>
+      <DisplayString Condition="(_Val[1] &gt; 0) &amp;&amp; (_Val[0] == 0)">i*{_Val[1]}</DisplayString>
+      <DisplayString Condition="(_Val[1] &gt; 0) &amp;&amp; (_Val[0] != 0)">{_Val[0]}+i*{_Val[1]}</DisplayString>
+      <Expand>
+          <Item Name="real">_Val[0]</Item>
+          <Item Name="imag">_Val[1]</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::valarray&lt;*&gt;">
+      <DisplayString>{{ size={_Mysize} }}</DisplayString>
+      <Expand>
+          <ArrayItems>
+              <Size>_Mysize</Size>
+              <ValuePointer>_Myptr</ValuePointer>
+          </ArrayItems>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::basic_stringbuf&lt;*,*,*&gt;">
+      <Intrinsic Name="data" Expression="((!(_Mystate &amp; _Constant) &amp;&amp; (*_IPnext) != 0)
+        ? (*_IPfirst)
+        : (!(_Mystate &amp; _Noread) &amp;&amp; (*_IGnext) != 0)
+          ? (*_IGfirst)
+          : 0)" />
+      <Intrinsic Name="size" Expression="((!(_Mystate &amp; _Constant) &amp;&amp; (*_IPnext) != 0)
+        ? ((_Seekhigh &lt; (*_IPnext) ? (*_IPnext) : _Seekhigh) - (*_IPfirst))
+        : (!(_Mystate &amp; _Noread) &amp;&amp; (*_IGnext) != 0)
+          ? ((*_IGnext + *_IGcount) - (*_IGfirst))
+          : 0)" />
+      <DisplayString>{data(),[size()]}</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::basic_istringstream&lt;*,*,*&gt;">
+      <DisplayString>{_Stringbuffer}</DisplayString>
+      <Expand>
+        <Item Name="stringbuf">_Stringbuffer</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::basic_ostringstream&lt;*,*,*&gt;">
+      <DisplayString>{_Stringbuffer}</DisplayString>
+      <Expand>
+        <Item Name="stringbuf">_Stringbuffer</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::basic_stringstream&lt;*,*,*&gt;">
+      <DisplayString>{_Stringbuffer}</DisplayString>
+      <Expand>
+        <Item Name="stringbuf">_Stringbuffer</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::basic_regex&lt;*&gt;">
+      <DisplayString Condition="_Rep == 0">empty</DisplayString>
+      <DisplayString Condition="_Rep != 0">{_Visualization}</DisplayString>
+      <StringView Condition="_Rep != 0">_Visualization</StringView>
+      <Expand/>
+  </Type>
+
+
+  <Type Name="std::sub_match&lt;*&gt;">
+      <DisplayString Condition="matched">{first,[second - first]na}</DisplayString>
+      <DisplayString Condition="!matched">false</DisplayString>
+      <Expand>
+          <Item Name="matched">matched</Item>
+          <Item Name="first">first</Item>
+          <Item Name="second">second</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::sub_match&lt;std::_String_const_iterator&lt;*&gt; &gt;">
+      <AlternativeType Name="std::sub_match&lt;std::_String_iterator&lt;*&gt; &gt;" />
+      <DisplayString Condition="matched">{first._Ptr,[second._Ptr - first._Ptr]na}</DisplayString>
+      <DisplayString Condition="!matched">false</DisplayString>
+      <Expand>
+          <Item Name="matched">matched</Item>
+          <Item Name="first">first</Item>
+          <Item Name="second">second</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::match_results&lt;*&gt;">
+      <DisplayString Condition="!_Ready">not ready</DisplayString>
+      <DisplayString Condition="_Ready">{_Matches}</DisplayString>
+      <Expand>
+          <ExpandedItem Condition="_Ready">_Matches,view(simple)</ExpandedItem>
+          <Item Condition="_Ready" Name="[prefix]">_Prefix</Item>
+          <Item Condition="_Ready" Name="[suffix]">_Suffix</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::regex_iterator&lt;*&gt;">
+    <SmartPointer Usage="Minimal">&amp;_MyVal</SmartPointer>
+    <DisplayString Condition="_MyRe == 0">end</DisplayString>
+    <DisplayString Condition="_MyRe != 0">{_MyVal}</DisplayString>
+    <Expand>
+      <Item Condition="_MyRe != 0" Name="[begin]">_Begin</Item>
+      <Item Condition="_MyRe != 0" Name="[end]">_End</Item>
+      <Item Condition="_MyRe != 0" Name="[pregex]">_MyRe</Item>
+      <Item Condition="_MyRe != 0" Name="[flags]">_Flags</Item>
+      <Item Condition="_MyRe != 0" Name="[match]">_MyVal</Item>
+    </Expand>
+  </Type>
+
+
+  <Type Name="std::regex_token_iterator&lt;*&gt;">
+    <SmartPointer Usage="Minimal">_Res</SmartPointer>
+    <DisplayString Condition="_Res == 0">end</DisplayString>
+    <DisplayString Condition="_Res != 0">{*_Res}</DisplayString>
+    <Expand>
+      <Item Condition="_Res != 0" Name="[position]">_Pos</Item>
+      <Item Condition="_Res != 0" Name="[result]">_Res</Item>
+      <Item Condition="_Res != 0" Name="[suffix]">_Suffix</Item>
+      <Item Condition="_Res != 0" Name="[N]">_Cur</Item>
+      <Item Condition="_Res != 0" Name="[subs]">_Subs</Item>
+    </Expand>
+  </Type>
+
+
+  <Type Name="std::atomic&lt;*&gt;">
+      <!-- VS 2019 16.0 or earlier -->
+      <Intrinsic Optional="true" Name="value" Expression="*($T1*)&amp;_My_val"/>
+      <!-- VS 2019 16.1 or later -->
+      <Intrinsic Optional="true" Name="value" Expression="*($T1*)&amp;_Storage"/>
+      <DisplayString>{value()}</DisplayString>
+      <Expand>
+          <Item Name="[value]">value()</Item>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::atomic_flag">
+      <!-- VS 2019 16.0 or earlier -->
+      <Intrinsic Optional="true" Name="value" Expression="(_My_flag &amp; 1) != 0"/>
+      <!-- VS 2019 16.1 or later -->
+      <Intrinsic Optional="true" Name="value" Expression="_Storage._Storage._Value != 0"/>
+      <DisplayString>{value()}</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::mutex">
+      <AlternativeType Name="std::recursive_mutex"/>
+      <DisplayString Condition="_Mtx_storage._Count == 0">unlocked</DisplayString>
+      <DisplayString Condition="_Mtx_storage._Count != 0">locked</DisplayString>
+      <Expand>
+          <Item Name="[locking_thread_id]" Condition="_Mtx_storage._Count != 0">_Mtx_storage._Thread_id</Item>
+          <Item Name="[ownership_levels]" Condition="_Mtx_storage._Count != 0">_Mtx_storage._Count</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::timed_mutex">
+    <AlternativeType Name="std::recursive_timed_mutex"/>
+    <DisplayString Condition="_My_locked == 0">unlocked</DisplayString>
+    <DisplayString Condition="_My_locked != 0">locked</DisplayString>
+    <Expand>
+      <Item Name="[locking_thread_id]" Optional="true">_My_owner</Item>
+      <Item Name="[ownership_levels]">_My_locked</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::lock_guard&lt;*&gt;">
+    <DisplayString>{&amp;_MyMutex}</DisplayString>
+    <Expand>
+      <Item Name="mutex">&amp;_MyMutex</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::unique_lock&lt;*&gt;">
+    <DisplayString Condition="_Pmtx == nullptr">empty</DisplayString>
+    <DisplayString Condition="_Pmtx != nullptr &amp;&amp; !_Owns">{*_Pmtx} - unowned</DisplayString>
+    <DisplayString Condition="_Pmtx != nullptr &amp;&amp; _Owns">{*_Pmtx} - owned</DisplayString>
+    <Expand>
+      <Item Name="mutex">_Pmtx</Item>
+      <Item Name="owned">_Owns</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::scoped_lock&lt;&gt;">
+    <DisplayString>()</DisplayString>
+  </Type>
+
+  <Type Name="std::scoped_lock&lt;*&gt;">
+    <DisplayString>({&amp;_MyMutex})</DisplayString>
+    <Expand>
+      <Item Name="[0]">&amp;_MyMutex</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::scoped_lock&lt;*,*&gt;">
+    <DisplayString>{_MyMutexes,view(asptr)}</DisplayString>
+    <Expand>
+      <ExpandedItem>_MyMutexes,view(asptr)</ExpandedItem>
+    </Expand>
+  </Type>
+
+  <Type Name="std::defer_lock_t">
+    <DisplayString>std::defer_lock</DisplayString>
+  </Type>
+
+  <Type Name="std::try_to_lock_t">
+    <DisplayString>std::try_to_lock</DisplayString>
+  </Type>
+
+  <Type Name="std::adopt_lock_t">
+    <DisplayString>std::adopt_lock</DisplayString>
+  </Type>
+
+  <Type Name="std::once_flag">
+    <DisplayString Condition="!_Opaque">incomplete</DisplayString>
+    <DisplayString Condition="_Opaque">complete</DisplayString>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::_Associated_state&lt;*&gt;">
+      <Expand>
+          <Item Name="[retrieved]">_Retrieved</Item>
+          <Item Name="[result]">_Result</Item>
+          <Item Name="[exception]">_Exception</Item>
+      </Expand>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::promise&lt;*&gt;">
+      <AlternativeType Name="std::packaged_task&lt;*&gt;"/>
+      <DisplayString Condition="_MyPromise._State._Assoc_state == nullptr">empty</DisplayString>
+      <DisplayString Condition="_MyPromise._State._Assoc_state != nullptr &amp;&amp; (*_MyPromise._State._Assoc_state)._Ready == 0">pending</DisplayString>
+      <DisplayString Condition="_MyPromise._State._Assoc_state != nullptr &amp;&amp; (*_MyPromise._State._Assoc_state)._Ready == 1">has_result</DisplayString>
+      <Expand>
+          <ExpandedItem Condition="_MyPromise._State._Assoc_state != nullptr &amp;&amp; (*_MyPromise._State._Assoc_state)._Ready == 1">*_MyPromise._State._Assoc_state</ExpandedItem>
+          <Item Name="[future_retrieved]" Condition="_MyPromise._State._Assoc_state != nullptr">_MyPromise._Future_retrieved</Item>
+      </Expand>
+  </Type>
+
+  <!-- VC 2015 -->
+  <Type Name="std::future&lt;*&gt;">
+      <AlternativeType Name="std::shared_future&lt;*&gt;"/>
+      <DisplayString Condition="_Assoc_state == nullptr">empty</DisplayString>
+      <DisplayString Condition="_Assoc_state != nullptr &amp;&amp; (*_Assoc_state)._Ready == 0">pending</DisplayString>
+      <DisplayString Condition="_Assoc_state != nullptr &amp;&amp; (*_Assoc_state)._Ready == 1">has_result</DisplayString>
+      <Expand>
+          <ExpandedItem Condition="_Assoc_state != nullptr &amp;&amp; (*_Assoc_state)._Ready == 1">*_Assoc_state</ExpandedItem>
+      </Expand>
+  </Type>
+
+
+  <Type Name="std::pointer_to_unary_function&lt;*&gt;">
+      <AlternativeType Name="std::pointer_to_binary_function&lt;*&gt;" />
+      <DisplayString>ptr_fun({_Pfun})</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::mem_fun_t&lt;*&gt;">
+      <AlternativeType Name="std::mem_fun1_t&lt;*&gt;" />
+      <AlternativeType Name="std::const_mem_fun_t&lt;*&gt;" />
+      <AlternativeType Name="std::const_mem_fun1_t&lt;*&gt;" />
+      <DisplayString>mem_fun({_Pmemfun})</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::mem_fun_ref_t&lt;*&gt;">
+      <AlternativeType Name="std::mem_fun1_ref_t&lt;*&gt;" />
+      <AlternativeType Name="std::const_mem_fun_ref_t&lt;*&gt;" />
+      <AlternativeType Name="std::const_mem_fun1_ref_t&lt;*&gt;" />
+      <DisplayString>mem_fun_ref({_Pmemfun})</DisplayString>
+      <Expand/>
+  </Type>
+
+  <Type Name="std::binder1st&lt;*&gt;">
+      <DisplayString>bind1st({op}, {value})</DisplayString>
+      <Expand>
+          <Item Name="op">op</Item>
+          <Item Name="value">value</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::binder2nd&lt;*&gt;">
+      <DisplayString>bind2nd({op}, {value})</DisplayString>
+      <Expand>
+          <Item Name="op">op</Item>
+          <Item Name="value">value</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::auto_ptr&lt;*&gt;">
+      <DisplayString Condition="_Myptr == 0">empty</DisplayString>
+      <DisplayString Condition="_Myptr != 0">auto_ptr {*_Myptr}</DisplayString>
+      <Expand>
+          <Item Condition="_Myptr != 0" Name="[ptr]">_Myptr</Item>
+      </Expand>
+  </Type>
+
+
+  <!-- Visualizer for experimental coroutines (/await) -->
+  <Type Name="std::experimental::coroutine_handle&lt;*&gt;">
+    <DisplayString Condition="_Ptr-&gt;_Index == 2">{_Ptr-&gt;_Fn,na}, #initial suspend</DisplayString>
+    <DisplayString Condition="_Ptr-&gt;_Index == 0">{_Ptr-&gt;_Fn,na}, #final suspend</DisplayString>
+    <DisplayString Condition="_Ptr-&gt;_Index != 2 &amp;&amp; _Ptr-&gt;_Index != 0">{_Ptr-&gt;_Fn,na}, suspend point #{(_Ptr-&gt;_Index)/2 - 1}</DisplayString>
+    <DisplayString>{_Ptr-&gt;_Fn,na}</DisplayString>
+    <Expand>
+      <Item Condition="_Ptr-&gt;_Index == 2" Name="Suspend Point">"initial suspend"</Item>
+      <Item Condition="_Ptr-&gt;_Index == 0" Name="Suspend Point">"final suspend"</Item>
+      <Item Condition="_Ptr-&gt;_Index != 2 &amp;&amp; _Ptr-&gt;_Index != 0" Name="Suspend Point">(_Ptr-&gt;_Index)/2 - 1</Item>
+      <ExpandedItem>this,view(ViewPromise)</ExpandedItem>
+    </Expand>
+  </Type>
+
+  <!-- Do not display the promise when promise type is void -->
+  <Type Name="std::experimental::coroutine_handle&lt;void&gt;" IncludeView="ViewPromise">
+    <Expand/>
+  </Type>
+
+  <!-- Evaluate and display the promise -->
+  <Type Name="std::experimental::coroutine_handle&lt;*&gt;" IncludeView="ViewPromise">
+    <Expand>
+      <Item Name="Promise">*reinterpret_cast&lt;$T1 *&gt;(reinterpret_cast&lt;char*&gt;(_Ptr) - _ALIGNED_SIZE)</Item>
+    </Expand>
+  </Type>
+
+  <!-- Visualizer for standard coroutines (/std:c++20, /await:strict) -->
+  <Type Name="std::coroutine_handle&lt;*&gt;" IncludeView="ViewPromise">
+    <Expand>
+      <Item Name="Promise">*reinterpret_cast&lt;$T1 *&gt;(reinterpret_cast&lt;char*&gt;(_Ptr) + 2*sizeof(void*))</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::coroutine_handle&lt;*&gt;">
+    <Intrinsic Name="suspend_point" SourceId="FA88A41F-A641-47C8-8373-4889B7564FCF" LanguageId="3A12D0B7-C26C-11D0-B442-00A0244A1DD2" Id="1" ReturnType="int">
+        <Parameter Type="void*" />
+    </Intrinsic>
+    <Intrinsic Name="suspend_point_line" SourceId="FA88A41F-A641-47C8-8373-4889B7564FCF" LanguageId="3A12D0B7-C26C-11D0-B442-00A0244A1DD2" Id="2" ReturnType="unsigned int">
+        <Parameter Type="void*" />
+    </Intrinsic>
+    <Intrinsic Name="primary_function" SourceId="FA88A41F-A641-47C8-8373-4889B7564FCF" LanguageId="3A12D0B7-C26C-11D0-B442-00A0244A1DD2" Id="3" ReturnType="void*">
+        <Parameter Type="void*" />
+    </Intrinsic>
+    <DisplayString Condition="_Ptr == nullptr">empty</DisplayString>
+    <DisplayString Condition="_Ptr != nullptr &amp;&amp; suspend_point(_Ptr) &lt; 1">{primary_function(_Ptr),na} #final suspend</DisplayString>
+    <DisplayString Condition="_Ptr != nullptr &amp;&amp; suspend_point(_Ptr) == 1">{primary_function(_Ptr),na} #initial suspend</DisplayString>
+    <DisplayString Condition="_Ptr != nullptr &amp;&amp; suspend_point(_Ptr) &gt; 1 &amp;&amp; suspend_point_line(_Ptr) == 0">{primary_function(_Ptr),na} #suspend point {suspend_point(_Ptr)}</DisplayString>
+    <DisplayString Condition="_Ptr != nullptr &amp;&amp; suspend_point(_Ptr) &gt; 1 &amp;&amp; suspend_point_line(_Ptr) != 0">{primary_function(_Ptr),na} #suspend point {suspend_point(_Ptr)}, line {suspend_point_line(_Ptr)}</DisplayString>
+    <Expand>
+      <ExpandedItem>this,view(ViewPromise)</ExpandedItem>
+    </Expand>
+  </Type>
+
+  <!-- Do not display the promise when promise type is void -->
+  <Type Name="std::coroutine_handle&lt;void&gt;" IncludeView="ViewPromise">
+    <Expand/>
+  </Type>
+
+  <Type Name="std::span&lt;*&gt;">
+    <Intrinsic Name="data" Expression="_Mydata" />
+    <Intrinsic Name="size" Expression="_Mysize" />
+    <Intrinsic Name="size_bytes" Expression="_Mysize * sizeof(element_type)" />
+    <DisplayString>{{ size={size()} }}</DisplayString>
+    <Expand>
+      <ArrayItems>
+        <Size>size()</Size>
+        <ValuePointer>data()</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL == 0 and must have lower priority. -->
+  <Type Name="std::_Span_iterator&lt;*&gt;" Priority="MediumLow">
+    <SmartPointer Usage="Indexable">_Myptr,na</SmartPointer>
+    <DisplayString>{*_Myptr}</DisplayString>
+    <Expand>
+      <Item Name="[ptr]">_Myptr</Item>
+    </Expand>
+  </Type>
+
+  <!-- This is for _ITERATOR_DEBUG_LEVEL != 0 and must have higher priority. -->
+  <Type Name="std::_Span_iterator&lt;*&gt;" Priority="Medium">
+      <SmartPointer Usage="Indexable">_Myptr,na</SmartPointer>
+      <DisplayString Condition="_Myptr == _Myend">end</DisplayString>
+      <DisplayString Condition="_Myptr != _Myend">{*_Myptr}</DisplayString>
+      <Expand>
+          <Item Name="[ptr]">_Myptr</Item>
+      </Expand>
+  </Type>
+
+  <Type Name="std::default_sentinel_t">
+    <DisplayString>default sentinel</DisplayString>
+  </Type>
+
+  <Type Name="std::unreachable_sentinel_t">
+    <DisplayString>unreachable</DisplayString>
+  </Type>
+
+  <Type Name="std::ranges::empty_view&lt;*&gt;">
+    <DisplayString>{{}}</DisplayString>
+  </Type>
+
+  <Type Name="std::ranges::single_view&lt;*&gt;">
+    <DisplayString>[{ _Val._Val }]</DisplayString>
+    <Expand>
+      <ArrayItems>
+        <Size>1</Size>
+        <ValuePointer>&amp;_Val._Val</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::iota_view&lt;*,*&gt;">
+    <Intrinsic Optional="true" Name="size" Expression="(size_t)(_Bound - _Value)" />
+    <DisplayString Optional="true">[{_Value}; {_Bound})</DisplayString>
+    <Expand>
+      <Item Optional="true" Name="[size]">size()</Item>
+      <CustomListItems Optional="true">
+        <Variable Name="val" InitialValue="_Value" />
+
+        <Size>size()</Size>
+        <Loop>
+          <Break Condition="val == _Bound" />
+          <Item>val</Item>
+          <Exec>++val</Exec>
+        </Loop>
+      </CustomListItems>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::iota_view&lt;*,std::unreachable_sentinel_t&gt;">
+    <DisplayString>[{_Value}; +&#8734;)</DisplayString>
+    <Expand>
+      <Item Name="[begin]">_Value</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::repeat_view&lt;*,*&gt;">
+    <DisplayString>[{_Value._Val} x {_Bound}]</DisplayString>
+    <Expand>
+      <Item Name="[size]">_Bound</Item>
+      <CustomListItems Optional="true">
+        <Variable Name="idx" InitialValue="0" />
+
+        <Loop>
+          <Break Condition="idx == _Bound"/>
+          <Item>_Value._Val</Item>
+          <Exec>++idx</Exec>
+        </Loop>
+      </CustomListItems>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::repeat_view&lt;*,std::unreachable_sentinel_t&gt;">
+    <DisplayString>[{_Value._Val} x +&#8734;]</DisplayString>
+    <Expand>
+      <Item Name="[+&#8734;]">_Value._Val</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::repeat_view&lt;*,*&gt;::_Iterator">
+    <DisplayString>{*_Value}</DisplayString>
+    <Expand>
+      <Item Name="[ptr]">_Value</Item>
+      <Item Name="[index]">_Current</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::repeat_view&lt;*,std::unreachable_sentinel_t&gt;::_Iterator">
+    <DisplayString>{*_Value}</DisplayString>
+    <Expand>
+      <Item Name="[ptr]">_Value</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::dangling">
+    <DisplayString>dangling</DisplayString>
+  </Type>
+
+  <Type Name="std::ranges::common_view&lt;*&gt;">
+    <DisplayString>{_Base}</DisplayString>
+  </Type>
+
+  <Type Name="std::ranges::basic_istream_view&lt;*&gt;">
+    <DisplayString>{_Stream}</DisplayString>
+    <Expand>
+      <Item Name="value">_Val</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::_Ioterator&lt;*&gt;">
+    <SmartPointer Usage="Minimal">&amp;_Current,na</SmartPointer>
+    <Expand>
+      <Item Name="[value]">_Current</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::_Iotinel&lt;*&gt;">
+    <DisplayString>{&amp;_Last,na}</DisplayString>
+    <Expand>
+      <Item Name="[bound]">_Last</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::ranges::take_while_view&lt;*&gt;">
+    <AlternativeType Name="std::ranges::drop_while_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::drop_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::join_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::transform_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::split_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::lazy_split_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::reverse_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::elements_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::take_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::ref_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::filter_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::owning_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::chunk_by_view&lt;*&gt;"/>
+    <AlternativeType Name="std::ranges::stride_view&lt;*&gt;"/>
+    <DisplayString>{_Range}</DisplayString>
+    <Expand>
+      <Item Optional="true" Name="pred">_Pred</Item>
+      <Item Optional="true" Name="next">_Next</Item>
+      <Item Optional="true" Name="count">_Count</Item>
+      <Item Optional="true" Name="function">_Fun</Item>
+      <Item Optional="true" Name="pattern">_Pattern</Item>
+      <Item Optional="true" Name="stride">_Stride</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::thread">
+    <DisplayString>{{ id={_Thr._Id} }}</DisplayString>
+  </Type>
+
+  <Type Name="std::thread::id">
+    <DisplayString>{_Id}</DisplayString>
+  </Type>
+
+  <Type Name="std::jthread">
+    <DisplayString>{_Impl}</DisplayString>
+  </Type>
+
+  <Type Name="std::filesystem::path">
+    <DisplayString>{_Text}</DisplayString>
+  </Type>
+
+  <Type Name="std::source_location">
+    <DisplayString>{_Function,sb}: ({_Line}, {_Column})</DisplayString>
+    <Expand>
+      <Item Name="[line]">_Line</Item>
+      <Item Name="[column]">_Column</Item>
+      <Item Name="[file]">_File,s</Item>
+      <Item Name="[function]">_Function,s</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::strong_ordering">
+    <DisplayString Condition="_Value == -1">less</DisplayString>
+    <DisplayString Condition="_Value == 0">equal</DisplayString>
+    <DisplayString Condition="_Value == 1">greater</DisplayString>
+    <Expand/>
+  </Type>
+
+  <Type Name="std::weak_ordering">
+    <DisplayString Condition="_Value == -1">less</DisplayString>
+    <DisplayString Condition="_Value == 0">equivalent</DisplayString>
+    <DisplayString Condition="_Value == 1">greater</DisplayString>
+    <Expand/>
+  </Type>
+
+  <Type Name="std::partial_ordering">
+    <DisplayString Condition="_Value == -1">less</DisplayString>
+    <DisplayString Condition="_Value == 0">equivalent</DisplayString>
+    <DisplayString Condition="_Value == 1">greater</DisplayString>
+    <DisplayString Condition="_Value == -128">unordered</DisplayString>
+    <Expand/>
+  </Type>
+
+  <Type Name="std::basic_format_parse_context&lt;*&gt;">
+    <DisplayString>{_Format_string}</DisplayString>
+    <Expand>
+      <Item Name="Arguments">_Num_args</Item>
+      <Item Name="Next arg id">_Next_arg_id</Item>
+    </Expand>
+  </Type>
+
+  <!-- std::format_args -->
+  <Type Name="std::basic_format_args&lt;std::basic_format_context&lt;std::back_insert_iterator&lt;std::_Fmt_buffer&lt;char&gt;&gt;, char&gt;&gt;">
+    <!-- decltype(std::make_format_args(...))-->
+    <AlternativeType Name="std::_Format_arg_store&lt;std::basic_format_context&lt;std::back_insert_iterator&lt;std::_Fmt_buffer&lt;char&gt;&gt;, char&gt;, *&gt;" />
+    <Intrinsic Name="storage" Expression="(char*)(&amp;_Index_array[_Num_args])" />
+    <DisplayString>{{ size={_Num_args} }}</DisplayString>
+    <Expand>
+      <IndexListItems>
+        <Size>_Num_args</Size>
+        <ValueNode Condition="_Index_array[$i]._Type_ == 0">"None"</ValueNode>
+        <!-- _Basic_format_arg_type::_Int_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 1">
+          *(int*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_UInt_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 2">
+          *(unsigned int*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Long_long_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 3">
+          *(long long*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_ULong_long_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 4">
+          *(unsigned long long*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Bool_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 5">
+          *(bool*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Char_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 6">
+          *(char*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Float_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 7">
+          *(float*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Double_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 8">
+          *(double*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Long_double_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 9">
+          *(long double*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Pointer_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 10">
+          *(void**)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_CString_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 11">
+          *(char**)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_String_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 12">
+          *(std::string_view*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Custom_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 13">
+          *(void**)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+      </IndexListItems>
+    </Expand>
+  </Type>
+
+  <!-- std::wformat_args -->
+  <Type Name="std::basic_format_args&lt;std::basic_format_context&lt;std::back_insert_iterator&lt;std::_Fmt_buffer&lt;wchar_t&gt;&gt;, wchar_t&gt;&gt;">
+    <!-- decltype(std::make_wformat_args(...))-->
+    <AlternativeType Name="std::_Format_arg_store&lt;std::basic_format_context&lt;std::back_insert_iterator&lt;std::_Fmt_buffer&lt;wchar_t&gt;&gt;, wchar_t&gt;, *&gt;" />
+    <Intrinsic Name="storage" Expression="(char*)(&amp;_Index_array[_Num_args])" />
+    <DisplayString>{{ size={_Num_args} }}</DisplayString>
+    <Expand>
+      <IndexListItems>
+        <Size>_Num_args</Size>
+        <!-- _Basic_format_arg_type::_Int_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 1">
+          *(int*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_UInt_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 2">
+          *(unsigned int*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Long_long_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 3">
+          *(long long*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_ULong_long_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 4">
+          *(unsigned long long*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Bool_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 5">
+          *(bool*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Char_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 6">
+          *(wchar_t*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Float_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 7">
+          *(float*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Double_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 8">
+          *(double*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Long_double_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 9">
+          *(long double*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Pointer_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 10">
+          *(void**)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_CString_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 11">
+          *(wchar_t**)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_String_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 12">
+          *(std::wstring_view*)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+        <!-- _Basic_format_arg_type::_Custom_type -->
+        <ValueNode Condition="_Index_array[$i]._Type_ == 13">
+          *(void**)(&amp;storage()[_Index_array[$i]._Index])
+        </ValueNode>
+      </IndexListItems>
+    </Expand>
+  </Type>
+
+  <Type Name="std::basic_format_arg&lt;*&gt;">
+    <DisplayString Condition="_Active_state == 0">No state: {_No_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 1">Int state: {_Int_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 2">UInt state: {_UInt_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 3">Long long state: {_Long_long_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 4">ULong long state: {_ULong_long_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 5">Bool state: {_Bool_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 6">Char state: {_Char_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 7">Float state: {_Float_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 8">Double state: {_Double_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 9">Long double state: {_Long_double_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 10">Pointer state: {_Pointer_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 11">CString state: {_CString_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 12">String state: {_String_state}</DisplayString>
+    <DisplayString Condition="_Active_state == 13">Custom state: {_Custom_state}</DisplayString>
+    <DisplayString Condition="_Active_state >= 14">Invalid state: {_Active_state}</DisplayString>
+  </Type>
+
+  <Type Name="std::basic_format_context&lt;*&gt;">
+    <DisplayString>{_Args}</DisplayString>
+    <Expand>
+      <Item Name="Iterator">_OutputIt</Item>
+      <Item Name="Loc">_Loc</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::exception">
+    <DisplayString>{what()}</DisplayString>
+  </Type>
+
+  <Type Name="std::default_searcher&lt;*&gt;">
+    <AlternativeType Name="std::boyer_moore_searcher&lt;*&gt;" />
+    <AlternativeType Name="std::boyer_moore_horspool_searcher&lt;*&gt;" />
+    <DisplayString>{_Data}</DisplayString>
+  </Type>
+
+  <Type Name="std::any">
+    <Intrinsic Name="has_value"   Expression="_Storage._TypeData != 0"/>
+    <Intrinsic Name="_Rep"        Expression="_Storage._TypeData &amp; _Rep_mask"/>
+    <Intrinsic Name="type"        Expression="(const type_info*)(_Storage._TypeData &amp; ~_Rep_mask)"/>
+    <Intrinsic Name="_Is_trivial" Expression="has_value() &amp;&amp; _Rep() == 0"/>
+    <Intrinsic Name="_Is_big"     Expression="has_value() &amp;&amp; _Rep() == 1"/>
+    <Intrinsic Name="_Is_small"   Expression="has_value() &amp;&amp; _Rep() == 2"/>
+    <DisplayString Condition="!has_value()">[empty]</DisplayString>
+    <DisplayString Condition="_Is_trivial()">[not empty (trivial)]</DisplayString>
+    <DisplayString Condition="_Is_small()">[not empty (small)]</DisplayString>
+    <DisplayString Condition="_Is_big()">[not empty (large)]</DisplayString>
+    <Expand>
+      <Item Name="[castable_ptr]" Condition="_Is_trivial()">(void*)(&amp;_Storage._TrivialData)</Item>
+      <Item Name="[castable_ptr]" Condition="_Is_small()">(void*)(&amp;_Storage._SmallStorage._Data)</Item>
+      <Item Name="[castable_ptr]" Condition="_Is_big()">_Storage._BigStorage._Ptr</Item>
+      <Synthetic Name="has_value">
+        <DisplayString>{has_value()}</DisplayString>
+      </Synthetic>
+      <Synthetic Name="type" Condition="has_value()">
+        <DisplayString>{type()}</DisplayString>
+      </Synthetic>
+      <Synthetic Name="[representation]" Condition="_Is_trivial()">
+        <DisplayString>(Small and Trivial Object)</DisplayString>
+      </Synthetic>
+      <Synthetic Name="[representation]" Condition="_Is_small()">
+        <DisplayString>(Small Object)</DisplayString>
+      </Synthetic>
+      <Synthetic Name="[representation]" Condition="_Is_big()">
+        <DisplayString>(Dynamic Allocation)</DisplayString>
+      </Synthetic>
+    </Expand>
+  </Type>
+
+  <Type Name="std::chrono::time_point&lt;std::chrono::system_clock,std::chrono::duration&lt;__int64,std::ratio&lt;1,10000000&gt; &gt; &gt;">
+    <!-- clang-cl -->
+    <AlternativeType Name="std::chrono::time_point&lt;std::chrono::system_clock,std::chrono::duration&lt;long long,std::ratio&lt;1,10000000&gt; &gt; &gt;" />
+
+    <!--
+      Same computation as in std::chrono::year_month_day::_Civil_from_days
+      and https://howardhinnant.github.io/date_algorithms.html#civil_from_days.
+    -->
+    <Intrinsic Name="z"     Expression="(_MyDur._MyRep / (24 * 60 * 60 * 10000000ull)) + 719468"/>
+    <Intrinsic Name="era"   Expression="(z() &gt;= 0 ? z() : z() - 146096) / 146097"/>
+    <Intrinsic Name="doe"   Expression="(unsigned)(z() - era() * 146097)"/>
+    <Intrinsic Name="yoe"   Expression="(doe() - doe()/1460 + doe()/36524 - doe()/146096) / 365"/>
+    <Intrinsic Name="doy"   Expression="doe() - (365*yoe() + yoe()/4 - yoe()/100)"/>
+    <Intrinsic Name="mp"    Expression="(5*doy() + 2)/153"/>
+    <Intrinsic Name="day"   Expression="doy() - (153*mp()+2)/5 + 1"/>
+    <Intrinsic Name="month" Expression="mp() &lt; 10 ? mp()+3 : mp()-9"/>
+    <Intrinsic Name="year"  Expression="((long long)yoe()) + era() * 400 + (month() &lt;= 2)"/>
+
+    <DisplayString Condition="_MyDur._MyRep &gt;= 0">
+      {year(),d}-{month()/10,d}{month()%10,d}-{day()/10,d}{day()%10,d} {
+        (_MyDur._MyRep % (24 * 60 * 60 * 10000000ull))/(10 * 60 * 60 * 10000000ull),d
+      }{
+        ((_MyDur._MyRep % (24 * 60 * 60 * 10000000ull))/(60 * 60 * 10000000ull)) % 10,d
+      }:{
+        (_MyDur._MyRep % (60 * 60 * 10000000ull))/(10 * 60 * 10000000ull),d
+      }{
+        (_MyDur._MyRep % (10 * 60 * 10000000ull)) / (60 * 10000000ull),d
+      }:{
+        (_MyDur._MyRep % (60 * 10000000ull)) / (10 * 10000000ull),d
+      }{
+        (_MyDur._MyRep % (10 * 10000000ull)) / 10000000ull,d
+      }.{
+        (_MyDur._MyRep % 10000000) / 1000000,d
+      }{
+        (_MyDur._MyRep % 1000000) / 100000,d
+      }{
+        (_MyDur._MyRep % 100000) / 10000,d
+      }{
+        (_MyDur._MyRep % 10000) / 1000,d
+      }{
+        (_MyDur._MyRep % 1000) / 100,d
+      }{
+        (_MyDur._MyRep % 100) / 10,d
+      }{
+        _MyDur._MyRep % 10,d
+      }
+    </DisplayString>
+    <Expand>
+      <Item Name="[ns/100]">_MyDur._MyRep</Item>
+      <Item Name="[us]">_MyDur._MyRep/10</Item>
+      <Item Name="[ms]">_MyDur._MyRep/(10 * 1000)</Item>
+      <Item Name="[s]">_MyDur._MyRep/(10 * 1000 * 1000)</Item>
+      <Synthetic Name="[clock]"><DisplayString>UTC</DisplayString></Synthetic>
+    </Expand>
+  </Type>
+
+  <Type Name="std::extents&lt;*&gt;">
+    <DisplayString>{{ rank={_Rank}, rank_dynamic={_Rank_dynamic} }}</DisplayString>
+    <Expand>
+      <!-- Mixed static and dynamic extents -->
+      <CustomListItems Condition="_Rank != _Rank_dynamic" Optional="true">
+        <Variable Name="idx" InitialValue="0" />
+        <Variable Name="statptr" InitialValue="(const rank_type*) _Static_extents._Elems" />
+        <Variable Name="dynptr" InitialValue="($T1*) _Array._Elems" />
+        <Loop>
+          <Break Condition="idx == _Rank" />
+          <If Condition="*statptr == -1">
+            <Item Name="[{idx}] dynamic extent">*dynptr</Item>
+            <Exec>++dynptr</Exec>
+          </If>
+          <Item Condition="*statptr != -1" Name="[{idx}] static extent">($T1) *statptr</Item>
+          <Exec>++idx, ++statptr</Exec>
+        </Loop>
+      </CustomListItems>
+
+    <!-- Fully dynamic extents -->
+    <CustomListItems Condition="_Rank == _Rank_dynamic" Optional="true">
+      <Variable Name="idx" InitialValue="0" />
+      <Variable Name="dynptr" InitialValue="($T1*) _Array._Elems" />
+      <Loop>
+        <Break Condition="idx == _Rank_dynamic" />
+        <Item Name="[{idx}] dynamic extent">*dynptr</Item>
+        <Exec>++idx, ++dynptr</Exec>
+      </Loop>
+    </CustomListItems>
+
+    <!-- Fully static extents -->
+    <CustomListItems Condition="_Rank_dynamic == 0" Optional="true">
+      <Variable Name="idx" InitialValue="0" />
+      <Variable Name="statptr" InitialValue="(const rank_type*) _Static_extents._Elems" />
+      <Loop>
+        <Break Condition="idx == _Rank" />
+        <Item Name="[{idx}] static extent">($T1) *statptr</Item>
+        <Exec>++idx, ++statptr</Exec>
+      </Loop>
+    </CustomListItems>
+    </Expand>
+  </Type>
+
+  <Type Name="std::flat_map&lt;*&gt;">
+   <AlternativeType Name="std::flat_multimap&lt;*&gt;"/>
+    <Intrinsic Name="size" Expression="_Data.keys.size()"/>
+    <Intrinsic Name="key_at" Expression="&amp;_Data.keys[index]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+    <Intrinsic Name="value_at" Expression="&amp;_Data.values[index]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+
+    <DisplayString>{{ size={size()} }}</DisplayString>
+
+    <Expand>
+      <Item Name="[size]">size()</Item>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <CustomListItems>
+        <Variable Name="i" InitialValue="0" />
+        <Size>size()</Size>
+        <Loop>
+          <Item Name="[{*key_at(i)}]">*value_at(i)</Item>
+          <Exec>++i</Exec>
+        </Loop>
+      </CustomListItems>
+    </Expand>
+  </Type>
+
+  <!-- fallback when the primary visualization (above) fails to parse, e.g. some custom containers -->
+  <Type Name="std::flat_map&lt;*&gt;" Priority="MediumLow">
+    <AlternativeType Name="std::flat_multimap&lt;*&gt;"/>
+    <Intrinsic Name="size" Expression="_Data.keys.size()"/>
+    <DisplayString>{{ size={size()} }}</DisplayString>
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <Item Name="[keys]">_Data.keys</Item>
+      <Item Name="[values]">_Data.values</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::_Pairing_iterator_provider&lt;*&gt;::_Iterator">
+    <DisplayString>({_Key_it}, {_Mapped_it})</DisplayString>
+    <Expand>
+      <Item Name="[key]">_Key_it</Item>
+      <Item Name="[value]">_Mapped_it</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::flat_set&lt;*&gt;">
+    <AlternativeType Name="std::flat_multiset&lt;*&gt;"/>
+    <DisplayString>{_Data}</DisplayString>
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <ExpandedItem>_Data</ExpandedItem>
+    </Expand>
+  </Type>
+
+</AutoVisualizer>
diff --git a/msvc-stl/stl/inc/__msvc_all_public_headers.hpp b/msvc-stl/stl/inc/__msvc_all_public_headers.hpp
new file mode 100644
index 0000000..da0e110
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_all_public_headers.hpp
@@ -0,0 +1,225 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This file is intended as a test resource for tools that want to verify that they can parse all MSVC standard
+// library headers without warnings. This file disables deprecations, so it should not be included in programs directly.
+//
+// This file may be changed, renamed, or removed at any time.
+
+#ifndef __MSVC_ALL_PUBLIC_HEADERS_HPP
+#define __MSVC_ALL_PUBLIC_HEADERS_HPP
+
+#pragma warning(push)
+#pragma warning(1 : 4668) // 'MEOW' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
+
+// All STL headers should protect themselves from macroized new.
+#if !(defined(__CUDACC__) && defined(__clang__))
+#pragma push_macro("new")
+#undef new
+#define new WILL NOT COMPILE
+#endif // !(defined(__CUDACC__) && defined(__clang__))
+
+// VSO-768746: mbctype.h macroizes _MS, _MP, _M1, and _M2. Include it first for test coverage.
+#ifndef _MSVC_TESTING_NVCC
+#include <mbctype.h>
+#endif // !defined(_MSVC_TESTING_NVCC)
+
+#ifndef _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
+#define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING
+#endif // !defined(_SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING)
+
+#define _SILENCE_CXX20_CISO646_REMOVED_WARNING
+
+// Core STL Headers
+#include <bit>
+#include <compare>
+#include <concepts>
+#include <coroutine>
+#include <initializer_list>
+#include <limits>
+#include <numbers>
+#include <ratio>
+#include <source_location>
+#include <stdfloat>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <version>
+
+// Core C Wrapper Headers
+#include <cassert>
+#include <cctype>
+#include <cerrno>
+#include <cfenv>
+#include <cfloat>
+#include <cinttypes>
+#include <climits>
+#include <clocale>
+#include <csetjmp>
+#include <csignal>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <cuchar>
+#include <cwchar>
+#include <cwctype>
+
+#ifndef _CORE_HEADERS_ONLY
+
+// Non-Core STL Headers
+#include <algorithm>
+#include <any>
+#include <array>
+#include <bitset>
+#include <charconv>
+#include <chrono>
+#include <codecvt>
+#include <complex>
+#include <deque>
+#include <exception>
+#include <expected>
+#include <filesystem>
+#include <flat_map>
+#include <flat_set>
+#include <format>
+#include <forward_list>
+#include <fstream>
+#include <functional>
+#include <generator>
+#include <iomanip>
+#include <ios>
+#include <iosfwd>
+#include <iostream>
+#include <istream>
+#include <iterator>
+#include <list>
+#include <locale>
+#include <map>
+#include <mdspan>
+#include <memory>
+#include <memory_resource>
+#include <new>
+#include <numeric>
+#include <optional>
+#include <ostream>
+#include <print>
+#include <queue>
+#include <random>
+#include <ranges>
+#include <regex>
+#include <scoped_allocator>
+#include <set>
+#include <span>
+#include <spanstream>
+#include <sstream>
+#include <stack>
+#include <stacktrace>
+#include <stdexcept>
+#include <streambuf>
+#include <string>
+#include <string_view>
+#include <strstream>
+#include <syncstream>
+#include <system_error>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <unordered_set>
+#include <valarray>
+#include <variant>
+#include <vector>
+
+#ifndef _M_CEE_PURE
+#include <__msvc_cxx_stdatomic.hpp>
+#include <atomic>
+#include <barrier>
+#include <condition_variable>
+#include <execution>
+#include <future>
+#include <latch>
+#include <mutex>
+#include <semaphore>
+#include <shared_mutex>
+#include <stop_token>
+#include <thread>
+#endif // !defined(_M_CEE_PURE)
+
+// Non-Core C Wrapper Headers
+#include <ccomplex>
+#include <ciso646>
+#include <cmath>
+#include <cstdalign>
+#include <cstdbool>
+#include <ctgmath>
+
+#endif // !defined(_CORE_HEADERS_ONLY)
+
+#ifndef _MSVC_TESTING_NVCC
+#include <assert.h>
+#include <conio.h>
+#include <crtdbg.h>
+#include <ctype.h>
+#include <direct.h>
+#include <dos.h>
+#include <errno.h>
+#include <excpt.h>
+#include <fcntl.h>
+#include <fenv.h>
+#include <float.h>
+#include <intrin.h>
+#include <inttypes.h>
+#include <io.h>
+#include <iso646.h>
+#include <limits.h>
+#include <locale.h>
+#include <malloc.h>
+#include <math.h>
+#include <mbstring.h>
+#include <memory.h>
+#include <minmax.h>
+#include <process.h>
+#include <safeint.h>
+#include <sal.h>
+#include <search.h>
+#include <setjmp.h>
+#include <share.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/locking.h>
+#include <sys/stat.h>
+#include <sys/timeb.h>
+#include <sys/types.h>
+#include <sys/utime.h>
+#include <tchar.h>
+#include <time.h>
+#include <uchar.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#ifndef _CORE_HEADERS_ONLY
+#include <complex.h>
+#include <new.h>
+#endif // !defined(_CORE_HEADERS_ONLY)
+
+#ifndef _M_CEE_PURE
+#include <fpieee.h>
+#endif // !defined(_M_CEE_PURE)
+#endif // !defined(_MSVC_TESTING_NVCC)
+
+#if !(defined(__CUDACC__) && defined(__clang__))
+#pragma pop_macro("new")
+#endif // !(defined(__CUDACC__) && defined(__clang__))
+
+#pragma warning(pop)
+
+#endif // __MSVC_ALL_PUBLIC_HEADERS_HPP
diff --git a/msvc-stl/stl/inc/__msvc_bit_utils.hpp b/msvc-stl/stl/inc/__msvc_bit_utils.hpp
new file mode 100644
index 0000000..5b4ae34
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_bit_utils.hpp
@@ -0,0 +1,406 @@
+// __msvc_bit_utils.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_BIT_UTILS_HPP
+#define __MSVC_BIT_UTILS_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <climits>
+#include <xtr1common>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+extern "C" {
+extern int __isa_available;
+}
+
+_INLINE_VAR constexpr int _Stl_isa_available_sse42 = 2; // equal to __ISA_AVAILABLE_SSE42
+_INLINE_VAR constexpr int _Stl_isa_available_avx2  = 5; // equal to __ISA_AVAILABLE_AVX2
+
+template <class _UInt>
+constexpr int _Unsigned_integer_digits = sizeof(_UInt) * CHAR_BIT;
+
+// Implementation of countl_zero without using specialized CPU instructions.
+// Used at compile time and when said instructions are not supported.
+// see "Hacker's Delight" section 5-3
+template <class _Ty>
+_NODISCARD constexpr int _Countl_zero_fallback(_Ty _Val) noexcept {
+    _Ty _Yx = 0;
+
+    unsigned int _Nx = _Unsigned_integer_digits<_Ty>;
+    unsigned int _Cx = _Unsigned_integer_digits<_Ty> / 2;
+    do {
+        _Yx = static_cast<_Ty>(_Val >> _Cx);
+        if (_Yx != 0) {
+            _Nx -= _Cx;
+            _Val = _Yx;
+        }
+        _Cx >>= 1;
+    } while (_Cx != 0);
+    return static_cast<int>(_Nx) - static_cast<int>(_Val);
+}
+
+#if !defined(_M_CEE_PURE)
+#define _HAS_COUNTL_ZERO_INTRINSICS 1
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_COUNTL_ZERO_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_COUNTL_ZERO_INTRINSICS
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+template <class _Ty>
+_NODISCARD int _Countl_zero_lzcnt(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+
+    if constexpr (_Digits <= 16) {
+        return static_cast<int>(__lzcnt16(_Val) - (16 - _Digits));
+    } else if constexpr (_Digits == 32) {
+        return static_cast<int>(__lzcnt(_Val));
+    } else {
+#ifdef _WIN64
+        return static_cast<int>(__lzcnt64(_Val));
+#else // ^^^ 64-bit / 32-bit vvv
+        const unsigned int _High = _Val >> 32;
+        const auto _Low          = static_cast<unsigned int>(_Val);
+        if (_High == 0) {
+            return 32 + _Countl_zero_lzcnt(_Low);
+        } else {
+            return _Countl_zero_lzcnt(_High);
+        }
+#endif // ^^^ 32-bit ^^^
+    }
+}
+
+template <class _Ty>
+_NODISCARD int _Countl_zero_bsr(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+
+    unsigned long _Result;
+    if constexpr (_Digits <= 32) {
+        if (!_BitScanReverse(&_Result, _Val)) {
+            return _Digits;
+        }
+    } else {
+#ifdef _WIN64
+        if (!_BitScanReverse64(&_Result, _Val)) {
+            return _Digits;
+        }
+#else // ^^^ 64-bit / 32-bit vvv
+        const unsigned int _High = _Val >> 32;
+        if (_BitScanReverse(&_Result, _High)) {
+            return static_cast<int>(31 - _Result);
+        }
+
+        const auto _Low = static_cast<unsigned int>(_Val);
+        if (!_BitScanReverse(&_Result, _Low)) {
+            return _Digits;
+        }
+#endif // ^^^ 32-bit ^^^
+    }
+    return static_cast<int>(_Digits - 1 - _Result);
+}
+
+template <class _Ty>
+_NODISCARD int _Checked_x86_x64_countl_zero(const _Ty _Val) noexcept {
+#ifndef __AVX2__
+    const bool _Definitely_have_lzcnt = __isa_available >= _Stl_isa_available_avx2;
+    if (!_Definitely_have_lzcnt) {
+        return _Countl_zero_bsr(_Val);
+    }
+#endif // ^^^ !defined(__AVX2__) ^^^
+    return _Countl_zero_lzcnt(_Val);
+}
+#endif // (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+template <class _Ty>
+_NODISCARD int _Checked_arm64_countl_zero(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    if (_Val == 0) {
+        return _Digits;
+    }
+
+    if constexpr (_Digits <= 32) {
+        return static_cast<int>(_CountLeadingZeros(_Val)) - (_Unsigned_integer_digits<unsigned long> - _Digits);
+    } else {
+        return static_cast<int>(_CountLeadingZeros64(_Val));
+    }
+}
+#endif // defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#endif // _HAS_COUNTL_ZERO_INTRINSICS
+
+// Implementation of countr_zero without using specialized CPU instructions.
+// Used at compile time and when said instructions are not supported.
+// see "Hacker's Delight" section 5-4
+template <class _Ty>
+_NODISCARD constexpr int _Countr_zero_fallback(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    return _Digits - _Countl_zero_fallback(static_cast<_Ty>(static_cast<_Ty>(~_Val) & static_cast<_Ty>(_Val - 1)));
+}
+
+// Implementation of popcount without using specialized CPU instructions.
+// Used at compile time and when said instructions are not supported.
+template <class _Ty>
+_NODISCARD constexpr int _Popcount_fallback(_Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+#if defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    if constexpr (_Digits == 64) {
+        // 64-bit bit operations on architectures without 64-bit registers are less efficient,
+        // hence we split the value so that it fits in 32-bit registers
+        return _Popcount_fallback(static_cast<unsigned long>(_Val))
+             + _Popcount_fallback(static_cast<unsigned long>(_Val >> 32));
+    } else
+#endif // defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)
+    {
+        // we static_cast these bit patterns in order to truncate them to the correct size
+        _Val = static_cast<_Ty>(_Val - ((_Val >> 1) & static_cast<_Ty>(0x5555'5555'5555'5555ull)));
+        _Val = static_cast<_Ty>((_Val & static_cast<_Ty>(0x3333'3333'3333'3333ull))
+                                + ((_Val >> 2) & static_cast<_Ty>(0x3333'3333'3333'3333ull)));
+        _Val = static_cast<_Ty>((_Val + (_Val >> 4)) & static_cast<_Ty>(0x0F0F'0F0F'0F0F'0F0Full));
+        // Multiply by one in each byte, so that it will have the sum of all source bytes in the highest byte
+        _Val = static_cast<_Ty>(_Val * static_cast<_Ty>(0x0101'0101'0101'0101ull));
+        // Extract highest byte
+        return static_cast<int>(_Val >> (_Digits - 8));
+    }
+}
+
+#if ((defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))) \
+    && !defined(_M_CEE_PURE)
+#define _HAS_TZCNT_BSF_INTRINSICS 1
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_TZCNT_BSF_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_TZCNT_BSF_INTRINSICS
+#ifdef __clang__
+#define _TZCNT_U32 __builtin_ia32_tzcnt_u32
+#define _TZCNT_U64 __builtin_ia32_tzcnt_u64
+#else // ^^^ __clang__ / !__clang__ vvv
+#define _TZCNT_U32 _tzcnt_u32
+#define _TZCNT_U64 _tzcnt_u64
+#endif // __clang__
+
+template <class _Ty>
+_NODISCARD int _Countr_zero_tzcnt(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    constexpr _Ty _Max    = static_cast<_Ty>(-1); // equal to (numeric_limits<_Ty>::max)()
+
+    if constexpr (_Digits <= 32) {
+        // Intended widening to int. This operation means that a narrow 0 will widen
+        // to 0xFFFF....FFFF0... instead of 0. We need this to avoid counting all the zeros
+        // of the wider type.
+        return static_cast<int>(_TZCNT_U32(static_cast<unsigned int>(~_Max | _Val)));
+    } else {
+#ifdef _WIN64
+        return static_cast<int>(_TZCNT_U64(_Val));
+#else // ^^^ 64-bit / 32-bit vvv
+        const auto _Low = static_cast<unsigned int>(_Val);
+        if (_Low == 0) {
+            const unsigned int _High = _Val >> 32;
+            return static_cast<int>(32 + _TZCNT_U32(_High));
+        } else {
+            return static_cast<int>(_TZCNT_U32(_Low));
+        }
+#endif // ^^^ 32-bit ^^^
+    }
+}
+
+#undef _TZCNT_U32
+#undef _TZCNT_U64
+
+template <class _Ty>
+_NODISCARD int _Countr_zero_bsf(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    constexpr _Ty _Max    = static_cast<_Ty>(-1); // equal to (numeric_limits<_Ty>::max)()
+
+    unsigned long _Result;
+    if constexpr (_Digits <= 32) {
+        // Intended widening to int. This operation means that a narrow 0 will widen
+        // to 0xFFFF....FFFF0... instead of 0. We need this to avoid counting all the zeros
+        // of the wider type.
+        if (!_BitScanForward(&_Result, static_cast<unsigned int>(~_Max | _Val))) {
+            return _Digits;
+        }
+    } else {
+#ifdef _WIN64
+        if (!_BitScanForward64(&_Result, _Val)) {
+            return _Digits;
+        }
+#else // ^^^ 64-bit / 32-bit vvv
+        const auto _Low = static_cast<unsigned int>(_Val);
+        if (_BitScanForward(&_Result, _Low)) {
+            return static_cast<int>(_Result);
+        }
+
+        const unsigned int _High = _Val >> 32;
+        if (!_BitScanForward(&_Result, _High)) {
+            return _Digits;
+        } else {
+            return static_cast<int>(_Result + 32);
+        }
+#endif // ^^^ 32-bit ^^^
+    }
+    return static_cast<int>(_Result);
+}
+
+template <class _Ty>
+_NODISCARD int _Checked_x86_x64_countr_zero(const _Ty _Val) noexcept {
+#ifndef __AVX2__
+    const bool _Definitely_have_tzcnt = __isa_available >= _Stl_isa_available_avx2;
+    if (!_Definitely_have_tzcnt) {
+        return _Countr_zero_bsf(_Val);
+    }
+#endif // ^^^ !defined(__AVX2__) ^^^
+    return _Countr_zero_tzcnt(_Val);
+}
+
+#endif // _HAS_TZCNT_BSF_INTRINSICS
+
+#if !defined(_M_CEE_PURE)
+#define _HAS_POPCNT_INTRINSICS 1
+#if defined(__AVX__) || defined(_M_ARM64) || defined(_M_ARM64EC)
+#define _POPCNT_INTRINSICS_ALWAYS_AVAILABLE 1
+#else // ^^^ intrinsics always available / intrinsics not always available vvv
+#define _POPCNT_INTRINSICS_ALWAYS_AVAILABLE 0
+#endif // ^^^ intrinsics not always available ^^^
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_POPCNT_INTRINSICS              0
+#define _POPCNT_INTRINSICS_ALWAYS_AVAILABLE 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_POPCNT_INTRINSICS
+template <class _Ty>
+_NODISCARD int _Unchecked_popcount(const _Ty _Val) noexcept {
+    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
+    if constexpr (_Digits <= 16) {
+        return static_cast<int>(__popcnt16(_Val));
+    } else if constexpr (_Digits == 32) {
+        return static_cast<int>(__popcnt(_Val));
+    } else {
+#ifdef _WIN64
+        return static_cast<int>(__popcnt64(_Val));
+#else // ^^^ 64-bit / 32-bit vvv
+        return static_cast<int>(__popcnt(_Val >> 32) + __popcnt(static_cast<unsigned int>(_Val)));
+#endif // ^^^ 32-bit ^^^
+    }
+}
+
+template <class _Ty>
+_NODISCARD int _Checked_popcount(const _Ty _Val) noexcept {
+#if !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE
+    const bool _Definitely_have_popcnt = __isa_available >= _Stl_isa_available_sse42;
+    if (!_Definitely_have_popcnt) {
+        return _Popcount_fallback(_Val);
+    }
+#endif // ^^^ !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE ^^^
+    return _Unchecked_popcount(_Val);
+}
+#endif // ^^^ _HAS_POPCNT_INTRINSICS ^^^
+
+template <class _Ty>
+constexpr bool _Is_standard_unsigned_integer =
+    _Is_any_of_v<_Ty, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>;
+
+template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_NODISCARD _CONSTEXPR20 int _Countr_zero(const _Ty _Val) noexcept {
+#if _HAS_TZCNT_BSF_INTRINSICS
+#if _HAS_CXX20
+    if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+    {
+        return _Checked_x86_x64_countr_zero(_Val);
+    }
+#endif // _HAS_TZCNT_BSF_INTRINSICS
+    return _Countr_zero_fallback(_Val);
+}
+
+template <class _Ty, class _Fn>
+constexpr decltype(auto) _Select_countr_zero_impl(_Fn _Callback) {
+    // TRANSITION, DevCom-1527995: Lambdas in this function ensure inlining
+#if _HAS_TZCNT_BSF_INTRINSICS && _HAS_CXX20
+    if (!_STD is_constant_evaluated()) {
+#ifndef __AVX2__
+        const bool _Definitely_have_tzcnt = __isa_available >= _Stl_isa_available_avx2;
+        if (!_Definitely_have_tzcnt) {
+            return _Callback([](_Ty _Val) static { return _Countr_zero_bsf(_Val); });
+        }
+#endif // ^^^ !defined(__AVX2__) ^^^
+        return _Callback([](_Ty _Val) static { return _Countr_zero_tzcnt(_Val); });
+    }
+#endif // ^^^ _HAS_TZCNT_BSF_INTRINSICS && _HAS_CXX20 ^^^
+    // C++17 constexpr gcd() calls this function, so it should be constexpr unless we detect runtime evaluation.
+    return _Callback([](_Ty _Val) static { return _Countr_zero_fallback(_Val); });
+}
+
+template <class _Ty>
+_NODISCARD constexpr int _Countl_zero(const _Ty _Val) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_standard_unsigned_integer<_Ty>);
+#if _HAS_COUNTL_ZERO_INTRINSICS
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+    if (!_Is_constant_evaluated()) {
+        return _Checked_x86_x64_countl_zero(_Val);
+    }
+#elif defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    if (!_Is_constant_evaluated()) {
+        return _Checked_arm64_countl_zero(_Val);
+    }
+#endif // defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#endif // _HAS_COUNTL_ZERO_INTRINSICS
+
+    return _Countl_zero_fallback(_Val);
+}
+
+template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
+_NODISCARD _CONSTEXPR20 int _Popcount(const _Ty _Val) noexcept {
+#if _HAS_POPCNT_INTRINSICS
+#if _HAS_CXX20
+    if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+    {
+        return _Checked_popcount(_Val);
+    }
+#endif // ^^^ _HAS_POPCNT_INTRINSICS ^^^
+    return _Popcount_fallback(_Val);
+}
+
+template <class _Ty, class _Fn>
+_CONSTEXPR20 decltype(auto) _Select_popcount_impl(_Fn _Callback) {
+    // TRANSITION, DevCom-1527995: Lambdas in this function ensure inlining
+#if _HAS_POPCNT_INTRINSICS
+#if _HAS_CXX20
+    if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+    {
+#if !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE
+        const bool _Definitely_have_popcnt = __isa_available >= _Stl_isa_available_sse42;
+        if (!_Definitely_have_popcnt) {
+            return _Callback([](_Ty _Val) static { return _Popcount_fallback(_Val); });
+        }
+#endif // ^^^ !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE ^^^
+        return _Callback([](_Ty _Val) static { return _Unchecked_popcount(_Val); });
+    }
+#endif // ^^^ _HAS_POPCNT_INTRINSICS ^^^
+    return _Callback([](_Ty _Val) static { return _Popcount_fallback(_Val); });
+}
+
+#undef _HAS_TZCNT_BSF_INTRINSICS
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_BIT_UTILS_HPP
diff --git a/msvc-stl/stl/inc/__msvc_chrono.hpp b/msvc-stl/stl/inc/__msvc_chrono.hpp
new file mode 100644
index 0000000..0dbf810
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_chrono.hpp
@@ -0,0 +1,731 @@
+// __msvc_chrono.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_CHRONO_HPP
+#define __MSVC_CHRONO_HPP
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <ctime>
+#include <limits>
+#include <ratio>
+#include <type_traits>
+#include <utility>
+#include <xtimec.h>
+
+#if _HAS_CXX20
+#include <compare>
+#endif
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+namespace chrono {
+    _EXPORT_STD template <class _Rep>
+    struct treat_as_floating_point : is_floating_point<_Rep> {}; // tests for floating-point type
+
+    _EXPORT_STD template <class _Rep>
+    _NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool treat_as_floating_point_v =
+        treat_as_floating_point<_Rep>::value;
+
+    _EXPORT_STD template <class _Rep>
+    struct duration_values { // gets arithmetic properties of a type
+        _NODISCARD static constexpr _Rep zero() noexcept {
+            // get zero value
+            return _Rep(0);
+        }
+
+        _NODISCARD static constexpr _Rep(min)() noexcept {
+            // get smallest value
+            return numeric_limits<_Rep>::lowest();
+        }
+
+        _NODISCARD static constexpr _Rep(max)() noexcept {
+            // get largest value
+            return (numeric_limits<_Rep>::max)();
+        }
+    };
+
+    _EXPORT_STD template <class _Rep, class _Period = ratio<1>>
+    class duration;
+
+    _EXPORT_STD template <class _Clock, class _Duration = typename _Clock::duration>
+    class time_point;
+
+#if _HAS_CXX20
+    _EXPORT_STD template <class _Clock>
+    _NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool is_clock_v = requires {
+        // Basic checks from N5014 [time.traits.is.clock]/1
+        typename _Clock::rep;
+        typename _Clock::period;
+        typename _Clock::duration;
+        typename _Clock::time_point;
+        _Clock::is_steady;
+        _Clock::now();
+
+        // Additional stricter checks from N5014 [time.clock.req]/2
+        // "An arithmetic type or a class emulating an arithmetic type" is not checked
+        requires _Is_ratio_v<typename _Clock::period>;
+        requires same_as<typename _Clock::duration, duration<typename _Clock::rep, typename _Clock::period>>;
+        requires same_as<typename _Clock::time_point, time_point<_Clock>>
+                     || same_as<typename _Clock::time_point,
+                         time_point<typename _Clock::time_point::clock, typename _Clock::duration>>;
+        { _Clock::is_steady } -> std::same_as<const bool&>;
+        { _Clock::now() } -> std::same_as<typename _Clock::time_point>;
+    };
+    _EXPORT_STD template <class _Clock>
+    struct _NO_SPECIALIZATIONS_CITING("N5014 [time.traits.is.clock]/2") is_clock : bool_constant<is_clock_v<_Clock>> {};
+
+    template <class _Clock>
+    constexpr bool _Is_clock_v = is_clock_v<_Clock>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    template <class _Clock, class = void>
+    constexpr bool _Is_clock_v = false;
+
+    template <class _Clock>
+    constexpr bool
+        _Is_clock_v<_Clock, void_t<typename _Clock::rep, typename _Clock::period, typename _Clock::duration,
+                                typename _Clock::time_point, decltype(_Clock::is_steady), decltype(_Clock::now())>> =
+            true;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    template <class _Ty>
+    constexpr bool _Is_duration_v = _Is_specialization_v<_Ty, duration>;
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    constexpr _To duration_cast(const duration<_Rep, _Period>&)
+        noexcept(is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>); // strengthened
+
+    _EXPORT_STD template <class _Rep, class _Period>
+    class duration { // represents a time duration
+    public:
+        using rep    = _Rep;
+        using period = typename _Period::type;
+
+        static_assert(!is_const_v<_Rep>, "rep type of duration must not be a const type");
+        static_assert(!is_volatile_v<_Rep>, "rep type of duration must not be a volatile type");
+        static_assert(!_Is_duration_v<_Rep>, "duration can't have duration as first template argument");
+        static_assert(_Is_ratio_v<_Period>, "period not an instance of std::ratio");
+        static_assert(0 < _Period::num, "period negative or zero");
+
+        constexpr duration() = default;
+
+        template <class _Rep2,
+            enable_if_t<is_convertible_v<const _Rep2&, _Rep>
+                            && (treat_as_floating_point_v<_Rep> || !treat_as_floating_point_v<_Rep2>),
+                int> = 0>
+        constexpr explicit duration(const _Rep2& _Val)
+            noexcept(is_arithmetic_v<_Rep> && is_arithmetic_v<_Rep2>) // strengthened
+            : _MyRep(static_cast<_Rep>(_Val)) {}
+
+        template <class _Rep2, class _Period2,
+            enable_if_t<is_convertible_v<const _Rep2&, _Rep>
+                            && (treat_as_floating_point_v<_Rep>
+                                || (_Ratio_divide_sfinae<_Period2, _Period>::den == 1
+                                    && !treat_as_floating_point_v<_Rep2>) ),
+                int> = 0>
+        constexpr duration(const duration<_Rep2, _Period2>& _Dur)
+            noexcept(is_arithmetic_v<_Rep> && is_arithmetic_v<_Rep2>) // strengthened
+            : _MyRep(_CHRONO duration_cast<duration>(_Dur).count()) {}
+
+        _NODISCARD constexpr _Rep count() const noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return _MyRep;
+        }
+
+        _NODISCARD constexpr common_type_t<duration> operator+() const
+            noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return common_type_t<duration>(*this);
+        }
+
+        _NODISCARD constexpr common_type_t<duration> operator-() const
+            noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return common_type_t<duration>(-_MyRep);
+        }
+
+        _CONSTEXPR17 duration& operator++() noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            ++_MyRep;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration operator++(int) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return duration(_MyRep++);
+        }
+
+        _CONSTEXPR17 duration& operator--() noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            --_MyRep;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration operator--(int) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            return duration(_MyRep--);
+        }
+
+        _CONSTEXPR17 duration& operator+=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep += _Right._MyRep;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator-=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep -= _Right._MyRep;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator*=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep *= _Right;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator/=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep /= _Right;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator%=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep %= _Right;
+            return *this;
+        }
+
+        _CONSTEXPR17 duration& operator%=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+            _MyRep %= _Right.count();
+            return *this;
+        }
+
+        _NODISCARD static constexpr duration zero() noexcept {
+            // get zero value
+            return duration(duration_values<_Rep>::zero());
+        }
+
+        _NODISCARD static constexpr duration(min)() noexcept {
+            // get minimum value
+            return duration((duration_values<_Rep>::min)());
+        }
+
+        _NODISCARD static constexpr duration(max)() noexcept {
+            // get maximum value
+            return duration((duration_values<_Rep>::max)());
+        }
+
+    private:
+        _Rep _MyRep; // the stored rep
+    };
+
+    _EXPORT_STD template <class _Clock, class _Duration>
+    class time_point { // represents a point in time
+    public:
+        using clock    = _Clock;
+        using duration = _Duration;
+        using rep      = typename _Duration::rep;
+        using period   = typename _Duration::period;
+
+        static_assert(_Is_duration_v<_Duration>,
+            "N4950 [time.point.general]/1 mandates Duration to be a specialization of chrono::duration.");
+
+        constexpr time_point() = default;
+
+        constexpr explicit time_point(const _Duration& _Other) noexcept(is_arithmetic_v<rep>) // strengthened
+            : _MyDur(_Other) {}
+
+        template <class _Duration2, enable_if_t<is_convertible_v<_Duration2, _Duration>, int> = 0>
+        constexpr time_point(const time_point<_Clock, _Duration2>& _Tp)
+            noexcept(is_arithmetic_v<rep> && is_arithmetic_v<typename _Duration2::rep>) // strengthened
+            : _MyDur(_Tp.time_since_epoch()) {}
+
+        _NODISCARD constexpr _Duration time_since_epoch() const noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            return _MyDur;
+        }
+
+#if _HAS_CXX20
+        constexpr time_point& operator++() noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            ++_MyDur;
+            return *this;
+        }
+        constexpr time_point operator++(int) noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            return time_point{_MyDur++};
+        }
+        constexpr time_point& operator--() noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            --_MyDur;
+            return *this;
+        }
+        constexpr time_point operator--(int) noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            return time_point{_MyDur--};
+        }
+#endif // _HAS_CXX20
+
+        _CONSTEXPR17 time_point& operator+=(const _Duration& _Dur) noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            _MyDur += _Dur;
+            return *this;
+        }
+
+        _CONSTEXPR17 time_point& operator-=(const _Duration& _Dur) noexcept(is_arithmetic_v<rep>) /* strengthened */ {
+            _MyDur -= _Dur;
+            return *this;
+        }
+
+        _NODISCARD static constexpr time_point(min)() noexcept {
+            return time_point((_Duration::min) ());
+        }
+
+        _NODISCARD static constexpr time_point(max)() noexcept {
+            return time_point((_Duration::max) ());
+        }
+
+    private:
+        _Duration _MyDur{duration::zero()}; // duration since the epoch
+    };
+} // namespace chrono
+
+template <class _Rep, class _Period>
+constexpr bool _Is_trivially_swappable_v<chrono::duration<_Rep, _Period>> = _Is_trivially_swappable_v<_Rep>;
+
+template <class _Clock, class _Duration>
+constexpr bool _Is_trivially_swappable_v<chrono::time_point<_Clock, _Duration>> = _Is_trivially_swappable_v<_Duration>;
+
+_NODISCARD constexpr intmax_t _Lcm(const intmax_t _Ax, const intmax_t _Bx) noexcept {
+    return (_Ax / _Gcd(_Ax, _Bx)) * _Bx;
+}
+
+template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+struct common_type<_CHRONO duration<_Rep1, _Period1>, _CHRONO duration<_Rep2, _Period2>> {
+    using type = _CHRONO duration<common_type_t<_Rep1, _Rep2>,
+        ratio<_Gcd(_Period1::num, _Period2::num), _Lcm(_Period1::den, _Period2::den)>>;
+};
+
+template <class _Clock, class _Duration1, class _Duration2>
+struct common_type<_CHRONO time_point<_Clock, _Duration1>,
+    _CHRONO time_point<_Clock, _Duration2>> { // common type of two time points
+    using type = _CHRONO time_point<_Clock, common_type_t<_Duration1, _Duration2>>;
+};
+
+namespace chrono {
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator+(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CD(_CD(_Left).count() + _CD(_Right).count());
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator-(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CD(_CD(_Left).count() - _CD(_Right).count());
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2,
+        enable_if_t<is_convertible_v<const _Rep2&, common_type_t<_Rep1, _Rep2>>, int> = 0>
+    _NODISCARD constexpr duration<common_type_t<_Rep1, _Rep2>, _Period1> operator*(
+        const duration<_Rep1, _Period1>& _Left, const _Rep2& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CR = common_type_t<_Rep1, _Rep2>;
+        using _CD = duration<_CR, _Period1>;
+        return _CD(_CD(_Left).count() * _Right);
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Rep2, class _Period2,
+        enable_if_t<is_convertible_v<const _Rep1&, common_type_t<_Rep1, _Rep2>>, int> = 0>
+    _NODISCARD constexpr duration<common_type_t<_Rep1, _Rep2>, _Period2> operator*(
+        const _Rep1& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return _Right * _Left;
+    }
+
+    template <class _CR, class _Period1, class _Rep2, bool = is_convertible_v<const _Rep2&, _CR>>
+    struct _Duration_div_mod1 { // return type for duration / rep and duration % rep
+        using type = duration<_CR, _Period1>;
+    };
+
+    template <class _CR, class _Period1, class _Rep2>
+    struct _Duration_div_mod1<_CR, _Period1, _Rep2, false> {}; // no return type
+
+    template <class _CR, class _Period1, class _Rep2, bool = _Is_duration_v<_Rep2>>
+    struct _Duration_div_mod {}; // no return type
+
+    template <class _CR, class _Period1, class _Rep2>
+    struct _Duration_div_mod<_CR, _Period1, _Rep2, false> : _Duration_div_mod1<_CR, _Period1, _Rep2> {
+        // return type for duration / rep and duration % rep
+    };
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2>
+    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator/(
+        const duration<_Rep1, _Period1>& _Left, const _Rep2& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CR = common_type_t<_Rep1, _Rep2>;
+        using _CD = duration<_CR, _Period1>;
+        return _CD(_CD(_Left).count() / _Right);
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr common_type_t<_Rep1, _Rep2> operator/(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CD(_Left).count() / _CD(_Right).count();
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2>
+    _NODISCARD constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator%(
+        const duration<_Rep1, _Period1>& _Left, const _Rep2& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CR = common_type_t<_Rep1, _Rep2>;
+        using _CD = duration<_CR, _Period1>;
+        return _CD(_CD(_Left).count() % _Right);
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>> operator%(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CD(_CD(_Left).count() % _CD(_Right).count());
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator==(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CT(_Left).count() == _CT(_Right).count();
+    }
+
+#if !_HAS_CXX20
+    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator!=(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator<(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CT(_Left).count() < _CT(_Right).count();
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator<=(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return !(_Right < _Left);
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator>(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return _Right < _Left;
+    }
+
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+    _NODISCARD constexpr bool operator>=(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        return !(_Left < _Right);
+    }
+
+#if _HAS_CXX20
+    _EXPORT_STD template <class _Rep1, class _Period1, class _Rep2, class _Period2>
+        requires three_way_comparable<typename common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>::rep>
+    _NODISCARD constexpr auto operator<=>(
+        const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right)
+        noexcept(is_arithmetic_v<_Rep1> && is_arithmetic_v<_Rep2>) /* strengthened */ {
+        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+        return _CT(_Left).count() <=> _CT(_Right).count();
+    }
+#endif // _HAS_CXX20
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> /* = 0 */>
+    _NODISCARD constexpr _To duration_cast(const duration<_Rep, _Period>& _Dur)
+        noexcept(is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // convert duration to another duration; truncate
+        using _CF = ratio_divide<_Period, typename _To::period>;
+
+        using _ToRep = typename _To::rep;
+        using _CR    = common_type_t<_ToRep, _Rep, intmax_t>;
+
+        constexpr bool _Num_is_one = _CF::num == 1;
+        constexpr bool _Den_is_one = _CF::den == 1;
+
+        if constexpr (_Den_is_one) {
+            if constexpr (_Num_is_one) {
+                return static_cast<_To>(static_cast<_ToRep>(_Dur.count()));
+            } else {
+                return static_cast<_To>(
+                    static_cast<_ToRep>(static_cast<_CR>(_Dur.count()) * static_cast<_CR>(_CF::num)));
+            }
+        } else {
+            if constexpr (_Num_is_one) {
+                return static_cast<_To>(
+                    static_cast<_ToRep>(static_cast<_CR>(_Dur.count()) / static_cast<_CR>(_CF::den)));
+            } else {
+                return static_cast<_To>(static_cast<_ToRep>(
+                    static_cast<_CR>(_Dur.count()) * static_cast<_CR>(_CF::num) / static_cast<_CR>(_CF::den)));
+            }
+        }
+    }
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr _To floor(const duration<_Rep, _Period>& _Dur)
+        noexcept(is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // convert duration to another duration; round towards negative infinity
+        // i.e. the greatest integral result such that the result <= _Dur
+        const _To _Casted{_CHRONO duration_cast<_To>(_Dur)};
+        if (_Casted > _Dur) {
+            return _To{_Casted.count() - static_cast<typename _To::rep>(1)};
+        }
+
+        return _Casted;
+    }
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr _To ceil(const duration<_Rep, _Period>& _Dur)
+        noexcept(is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // convert duration to another duration; round towards positive infinity
+        // i.e. the least integral result such that _Dur <= the result
+        const _To _Casted{_CHRONO duration_cast<_To>(_Dur)};
+        if (_Casted < _Dur) {
+            return _To{_Casted.count() + static_cast<typename _To::rep>(1)};
+        }
+
+        return _Casted;
+    }
+
+    template <class _Rep>
+    constexpr bool _Is_even(_Rep _Val) noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+        // Tests whether _Val is even
+        return _Val % 2 == 0;
+    }
+
+    _EXPORT_STD template <class _To, class _Rep, class _Period,
+        enable_if_t<_Is_duration_v<_To> && !treat_as_floating_point_v<typename _To::rep>, int> = 0>
+    _NODISCARD constexpr _To round(const duration<_Rep, _Period>& _Dur)
+        noexcept(is_arithmetic_v<_Rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // convert duration to another duration, round to nearest, ties to even
+        const _To _Floored{_CHRONO floor<_To>(_Dur)};
+        const _To _Ceiled{_Floored + _To{1}};
+        const auto _Floor_adjustment = _Dur - _Floored;
+        const auto _Ceil_adjustment  = _Ceiled - _Dur;
+        if (_Floor_adjustment < _Ceil_adjustment
+            || (_Floor_adjustment == _Ceil_adjustment && _Is_even(_Floored.count()))) {
+            return _Floored;
+        }
+
+        return _Ceiled;
+    }
+
+    _EXPORT_STD template <class _Rep, class _Period, enable_if_t<numeric_limits<_Rep>::is_signed, int> = 0>
+    _NODISCARD constexpr duration<_Rep, _Period> abs(const duration<_Rep, _Period> _Dur)
+        noexcept(is_arithmetic_v<_Rep>) /* strengthened */ {
+        // create a duration whose count() is the absolute value of _Dur.count()
+        if (_Dur < duration<_Rep, _Period>::zero()) {
+            return -_Dur;
+        } else {
+            return _Dur;
+        }
+    }
+
+    _EXPORT_STD using nanoseconds  = duration<long long, nano>;
+    _EXPORT_STD using microseconds = duration<long long, micro>;
+    _EXPORT_STD using milliseconds = duration<long long, milli>;
+    _EXPORT_STD using seconds      = duration<long long>;
+    _EXPORT_STD using minutes      = duration<int, ratio<60>>;
+    _EXPORT_STD using hours        = duration<int, ratio<3600>>;
+#if _HAS_CXX20
+    _EXPORT_STD using days   = duration<int, ratio_multiply<ratio<24>, hours::period>>;
+    _EXPORT_STD using weeks  = duration<int, ratio_multiply<ratio<7>, days::period>>;
+    _EXPORT_STD using years  = duration<int, ratio_multiply<ratio<146097, 400>, days::period>>;
+    _EXPORT_STD using months = duration<int, ratio_divide<years::period, ratio<12>>>;
+#endif // _HAS_CXX20
+
+    _EXPORT_STD template <class _Clock, class _Duration, class _Rep, class _Period>
+    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>> operator+(
+        const time_point<_Clock, _Duration>& _Left, const duration<_Rep, _Period>& _Right)
+        noexcept(is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<_Rep>) /* strengthened */ {
+        using _RT = time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>;
+        return _RT(_Left.time_since_epoch() + _Right);
+    }
+
+    _EXPORT_STD template <class _Rep, class _Period, class _Clock, class _Duration>
+    _NODISCARD constexpr time_point<_Clock, common_type_t<duration<_Rep, _Period>, _Duration>> operator+(
+        const duration<_Rep, _Period>& _Left, const time_point<_Clock, _Duration>& _Right)
+        noexcept(is_arithmetic_v<_Rep> && is_arithmetic_v<typename _Duration::rep>) /* strengthened */ {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration, class _Rep, class _Period>
+    _NODISCARD constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>> operator-(
+        const time_point<_Clock, _Duration>& _Left, const duration<_Rep, _Period>& _Right)
+        noexcept(is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<_Rep>) /* strengthened */ {
+        using _RT = time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>;
+        return _RT(_Left.time_since_epoch() - _Right);
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr common_type_t<_Duration1, _Duration2> operator-(
+        const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right)
+        noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Left.time_since_epoch() - _Right.time_since_epoch();
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool operator==(
+        const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right)
+        noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Left.time_since_epoch() == _Right.time_since_epoch();
+    }
+
+#if !_HAS_CXX20
+    template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool operator!=(
+        const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right)
+        noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool operator<(
+        const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right)
+        noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Left.time_since_epoch() < _Right.time_since_epoch();
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool operator<=(
+        const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right)
+        noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return !(_Right < _Left);
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool operator>(
+        const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right)
+        noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Right < _Left;
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration1, class _Duration2>
+    _NODISCARD constexpr bool operator>=(
+        const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right)
+        noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return !(_Left < _Right);
+    }
+
+#if _HAS_CXX20
+    _EXPORT_STD template <class _Clock, class _Duration1, three_way_comparable_with<_Duration1> _Duration2>
+    _NODISCARD constexpr auto operator<=>(
+        const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right)
+        noexcept(
+            is_arithmetic_v<typename _Duration1::rep> && is_arithmetic_v<typename _Duration2::rep>) /* strengthened */ {
+        return _Left.time_since_epoch() <=> _Right.time_since_epoch();
+    }
+#endif // _HAS_CXX20
+
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr time_point<_Clock, _To> time_point_cast(const time_point<_Clock, _Duration>& _Time)
+        noexcept(is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // change the duration type of a time_point; truncate
+        return time_point<_Clock, _To>(_CHRONO duration_cast<_To>(_Time.time_since_epoch()));
+    }
+
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr time_point<_Clock, _To> floor(const time_point<_Clock, _Duration>& _Time)
+        noexcept(is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // change the duration type of a time_point; round towards negative infinity
+        return time_point<_Clock, _To>(_CHRONO floor<_To>(_Time.time_since_epoch()));
+    }
+
+    _EXPORT_STD template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
+    _NODISCARD constexpr time_point<_Clock, _To> ceil(const time_point<_Clock, _Duration>& _Time)
+        noexcept(is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // change the duration type of a time_point; round towards positive infinity
+        return time_point<_Clock, _To>(_CHRONO ceil<_To>(_Time.time_since_epoch()));
+    }
+
+    _EXPORT_STD template <class _To, class _Clock, class _Duration,
+        enable_if_t<_Is_duration_v<_To> && !treat_as_floating_point_v<typename _To::rep>, int> = 0>
+    _NODISCARD constexpr time_point<_Clock, _To> round(const time_point<_Clock, _Duration>& _Time)
+        noexcept(is_arithmetic_v<typename _Duration::rep> && is_arithmetic_v<typename _To::rep>) /* strengthened */ {
+        // change the duration type of a time_point; round to nearest, ties to even
+        return time_point<_Clock, _To>(_CHRONO round<_To>(_Time.time_since_epoch()));
+    }
+
+    _EXPORT_STD struct steady_clock { // wraps QueryPerformanceCounter
+        using rep                       = long long;
+        using period                    = nano;
+        using duration                  = nanoseconds;
+        using time_point                = _CHRONO time_point<steady_clock>;
+        static constexpr bool is_steady = true;
+
+        _NODISCARD static time_point now() noexcept { // get current time
+            const long long _Freq = _Query_perf_frequency(); // doesn't change after system boot
+            const long long _Ctr  = _Query_perf_counter();
+            _STL_INTERNAL_STATIC_ASSERT(period::num == 1);
+            // The compiler recognizes the constants for frequency and time period and uses shifts and
+            // multiplies instead of divides to calculate the nanosecond value.
+            constexpr long long _TenMHz        = 10'000'000;
+            constexpr long long _TwentyFourMHz = 24'000'000;
+            if (_Freq == _TenMHz) {
+                // 10 MHz is a very common QPC frequency on modern x86/x64 PCs. Optimizing for
+                // this specific frequency can double the performance of this function by
+                // avoiding the expensive frequency conversion path.
+                _STL_INTERNAL_STATIC_ASSERT(period::den % _TenMHz == 0);
+                constexpr long long _Multiplier = period::den / _TenMHz;
+                return time_point(duration(_Ctr * _Multiplier));
+            } else if (_Freq == _TwentyFourMHz) {
+                // 24 MHz is a common frequency on ARM64, including cases where it emulates x86/x64.
+                constexpr long long _Multiplier_whole = period::den / _TwentyFourMHz;
+                using _Multiplier_part                = ratio<period::den % _TwentyFourMHz, _TwentyFourMHz>;
+                constexpr long long _Multiplier_num   = _Multiplier_part::num;
+                constexpr long long _Multiplier_den   = _Multiplier_part::den;
+                // This assumes that _Ctr * _Multiplier_num doesn't overflow.
+                _STL_INTERNAL_STATIC_ASSERT(_Multiplier_num <= _Multiplier_whole);
+                const long long _Whole = _Ctr * _Multiplier_whole;
+                const long long _Part  = _Ctr * _Multiplier_num / _Multiplier_den;
+                return time_point(duration(_Whole + _Part));
+            } else {
+                // Instead of just having "(_Ctr * period::den) / _Freq",
+                // the algorithm below prevents overflow when _Ctr is sufficiently large.
+                // It assumes that _Freq * period::den does not overflow, which is currently true for nano period.
+                // It is not realistic for _Ctr to accumulate to large values from zero with this assumption,
+                // but the initial value of _Ctr could be large.
+                const long long _Whole = (_Ctr / _Freq) * period::den;
+                const long long _Part  = (_Ctr % _Freq) * period::den / _Freq;
+                return time_point(duration(_Whole + _Part));
+            }
+        }
+    };
+} // namespace chrono
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_CHRONO_HPP
diff --git a/msvc-stl/stl/inc/__msvc_cxx_stdatomic.hpp b/msvc-stl/stl/inc/__msvc_cxx_stdatomic.hpp
new file mode 100644
index 0000000..f6874f7
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_cxx_stdatomic.hpp
@@ -0,0 +1,138 @@
+// __msvc_cxx_stdatomic.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_CXX_STDATOMIC_HPP
+#define __MSVC_CXX_STDATOMIC_HPP
+
+// see _STL_COMPILER_PREPROCESSOR in yvals_core.h
+#if !defined(RC_INVOKED) && !defined(Q_MOC_RUN) && !defined(__midl)
+
+// provide a specific error message for C compilers, before the general error message in yvals_core.h
+#ifndef __cplusplus
+#error <__msvc_cxx_stdatomic.hpp> is an internal header. It is incompatible with C and should not be directly included.
+#endif // !defined(__cplusplus)
+
+#include <yvals.h>
+
+#ifdef _M_CEE_PURE
+#error <stdatomic.h> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <stdatomic.h> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+
+#include <atomic>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+template <class _Ty>
+using _Std_atomic = _STD atomic<_Ty>;
+
+#define _Atomic(T) _Std_atomic<T>
+
+using _STD memory_order;
+using _STD memory_order_relaxed;
+using _STD memory_order_consume;
+using _STD memory_order_acquire;
+using _STD memory_order_release;
+using _STD memory_order_acq_rel;
+using _STD memory_order_seq_cst;
+
+using _STD atomic_flag;
+
+using _STD atomic_bool;
+using _STD atomic_char;
+using _STD atomic_schar;
+using _STD atomic_uchar;
+using _STD atomic_short;
+using _STD atomic_ushort;
+using _STD atomic_int;
+using _STD atomic_uint;
+using _STD atomic_long;
+using _STD atomic_ulong;
+using _STD atomic_llong;
+using _STD atomic_ullong;
+
+#ifdef __cpp_lib_char8_t
+using _STD atomic_char8_t;
+#endif // defined(__cpp_lib_char8_t)
+
+using _STD atomic_char16_t;
+using _STD atomic_char32_t;
+using _STD atomic_wchar_t;
+using _STD atomic_int8_t;
+using _STD atomic_uint8_t;
+using _STD atomic_int16_t;
+using _STD atomic_uint16_t;
+using _STD atomic_int32_t;
+using _STD atomic_uint32_t;
+using _STD atomic_int64_t;
+using _STD atomic_uint64_t;
+using _STD atomic_int_least8_t;
+using _STD atomic_uint_least8_t;
+using _STD atomic_int_least16_t;
+using _STD atomic_uint_least16_t;
+using _STD atomic_int_least32_t;
+using _STD atomic_uint_least32_t;
+using _STD atomic_int_least64_t;
+using _STD atomic_uint_least64_t;
+using _STD atomic_int_fast8_t;
+using _STD atomic_uint_fast8_t;
+using _STD atomic_int_fast16_t;
+using _STD atomic_uint_fast16_t;
+using _STD atomic_int_fast32_t;
+using _STD atomic_uint_fast32_t;
+using _STD atomic_int_fast64_t;
+using _STD atomic_uint_fast64_t;
+using _STD atomic_intptr_t;
+using _STD atomic_uintptr_t;
+using _STD atomic_size_t;
+using _STD atomic_ptrdiff_t;
+using _STD atomic_intmax_t;
+using _STD atomic_uintmax_t;
+
+using _STD atomic_is_lock_free;
+using _STD atomic_load;
+using _STD atomic_load_explicit;
+using _STD atomic_store;
+using _STD atomic_store_explicit;
+using _STD atomic_exchange;
+using _STD atomic_exchange_explicit;
+using _STD atomic_compare_exchange_strong;
+using _STD atomic_compare_exchange_strong_explicit;
+using _STD atomic_compare_exchange_weak;
+using _STD atomic_compare_exchange_weak_explicit;
+using _STD atomic_fetch_add;
+using _STD atomic_fetch_add_explicit;
+using _STD atomic_fetch_sub;
+using _STD atomic_fetch_sub_explicit;
+using _STD atomic_fetch_or;
+using _STD atomic_fetch_or_explicit;
+using _STD atomic_fetch_xor;
+using _STD atomic_fetch_xor_explicit;
+using _STD atomic_fetch_and;
+using _STD atomic_fetch_and_explicit;
+using _STD atomic_flag_test_and_set;
+using _STD atomic_flag_test_and_set_explicit;
+using _STD atomic_flag_clear;
+using _STD atomic_flag_clear_explicit;
+
+using _STD atomic_thread_fence;
+using _STD atomic_signal_fence;
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX23 ^^^
+
+#endif // !defined(RC_INVOKED) && !defined(Q_MOC_RUN) && !defined(__midl)
+#endif // __MSVC_CXX_STDATOMIC_HPP
diff --git a/msvc-stl/stl/inc/__msvc_doom_core.hpp b/msvc-stl/stl/inc/__msvc_doom_core.hpp
new file mode 100644
index 0000000..1300f80
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_doom_core.hpp
@@ -0,0 +1,54 @@
+// __msvc_doom_core.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_DOOM_CORE_HPP
+#define __MSVC_DOOM_CORE_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _MSVC_STL_USE_ABORT_AS_DOOM_FUNCTION
+#include <cstdlib>
+#elif defined(_M_CEE)
+#include <corecrt.h>
+#endif // ^^^ defined(_M_CEE) ^^^
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// The STL's "doom function" can be replaced. Notes:
+// * It must not throw. (Attempting to throw would slam into noexcept.)
+// * Common case: If it doesn't return, it should be marked as `[[noreturn]]`.
+// * Uncommon case: If it returns, the STL will attempt to "continue on error", behaving as if no checking was done.
+//   + For example, a legacy codebase with a long startup time might want to log errors for investigation later.
+//   + WARNING: If you replace the STL's "doom function" to "continue on error", you do so at your own risk!
+//     After the STL has detected a precondition violation, undefined behavior is imminent. The STL will support
+//     "continue on error" by proceeding to do what it would have done anyways (instead of falling off the end of
+//     a non-void function, etc.), but it will not attempt to replace undefined behavior with implementation-defined
+//     behavior. (For example, we will not transform `pop_back()` of an empty `vector` to be a no-op.)
+#ifndef _MSVC_STL_DOOM_FUNCTION
+#ifdef _MSVC_STL_USE_ABORT_AS_DOOM_FUNCTION // The user wants to use abort():
+#define _MSVC_STL_DOOM_FUNCTION(mesg) _CSTD abort()
+#elif defined(__clang__) // Use the Clang intrinsic:
+#define _MSVC_STL_DOOM_FUNCTION(mesg) __builtin_verbose_trap("MSVC STL error", mesg)
+#elif defined(_M_CEE) // TRANSITION, VSO-2457624 (/clr silent bad codegen for __fastfail); /clr:pure lacks __fastfail
+#define _MSVC_STL_DOOM_FUNCTION(mesg) ::_invoke_watson(nullptr, nullptr, nullptr, 0, 0)
+#else // Use the MSVC __fastfail intrinsic:
+extern "C" __declspec(noreturn) void __fastfail(unsigned int); // declared by <intrin.h>
+#define _MSVC_STL_DOOM_FUNCTION(mesg)                                                  \
+    __fastfail(5); /* __fastfail(FAST_FAIL_INVALID_ARG), value defined by <winnt.h> */ \
+    _STL_UNREACHABLE /* TRANSITION, DevCom-10914110 */
+#endif // choose "doom function"
+#endif // ^^^ !defined(_MSVC_STL_DOOM_FUNCTION) ^^^
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_DOOM_CORE_HPP
diff --git a/msvc-stl/stl/inc/__msvc_filebuf.hpp b/msvc-stl/stl/inc/__msvc_filebuf.hpp
new file mode 100644
index 0000000..fd6069d
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_filebuf.hpp
@@ -0,0 +1,751 @@
+// __msvc_filebuf.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_FILEBUF_HPP
+#define __MSVC_FILEBUF_HPP
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdio>
+#include <streambuf>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, ABI: The _Path_ish functions accepting filesystem::path are templates
+// which always use the same types as a workaround for user code deriving from iostreams types and
+// __declspec(dllexport)ing the derived types. Adding member functions to iostreams broke the ABI of such DLLs.
+// Deriving and __declspec(dllexport)ing standard library types is not supported, but in this particular case
+// the workaround was inexpensive. The workaround will be removed in the next ABI breaking release of the
+// Visual C++ Libraries.
+_STD_BEGIN
+#if _HAS_CXX17
+namespace filesystem {
+    _EXPORT_STD class path;
+}
+#endif // _HAS_CXX17
+
+extern "C++" _CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const char*, ios_base::openmode, int);
+extern "C++" _CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(const wchar_t*, ios_base::openmode, int);
+
+template <class _Elem>
+bool _Fgetc(_Elem& _Ch, FILE* _File) { // get an element from a C stream
+    return _CSTD fread(&_Ch, sizeof(_Elem), 1, _File) == 1;
+}
+
+template <>
+inline bool _Fgetc(char& _Byte, FILE* _File) { // get a char element from a C stream
+    int _Meta;
+    if ((_Meta = _CSTD fgetc(_File)) == EOF) {
+        return false;
+    } else { // got one, convert to char
+        _Byte = static_cast<char>(_Meta);
+        return true;
+    }
+}
+
+template <>
+inline bool _Fgetc(wchar_t& _Wchar, FILE* _File) { // get a wchar_t element from a C stream
+    wint_t _Meta;
+    if ((_Meta = _CSTD fgetwc(_File)) == WEOF) {
+        return false;
+    } else { // got one, convert to wchar_t
+        _Wchar = static_cast<wchar_t>(_Meta);
+        return true;
+    }
+}
+
+#ifdef _CRTBLD
+template <>
+inline bool _Fgetc(unsigned short& _Wchar, FILE* _File) { // get an unsigned short element from a C stream
+    wint_t _Meta;
+    if ((_Meta = _CSTD fgetwc(_File)) == WEOF) {
+        return false;
+    } else { // got one, convert to unsigned short
+        _Wchar = static_cast<unsigned short>(_Meta);
+        return true;
+    }
+}
+#endif // defined(_CRTBLD)
+
+template <class _Elem>
+bool _Fputc(_Elem _Ch, FILE* _File) { // put an element to a C stream
+    return _CSTD fwrite(&_Ch, 1, sizeof(_Elem), _File) == sizeof(_Elem);
+}
+
+template <>
+inline bool _Fputc(char _Byte, FILE* _File) { // put a char element to a C stream
+    return _CSTD fputc(_Byte, _File) != EOF;
+}
+
+template <>
+inline bool _Fputc(wchar_t _Wchar, FILE* _File) { // put a wchar_t element to a C stream
+    return _CSTD fputwc(_Wchar, _File) != WEOF;
+}
+
+#ifdef _CRTBLD
+template <>
+inline bool _Fputc(unsigned short _Wchar, FILE* _File) { // put an unsigned short element to a C stream
+    return _CSTD fputwc(_Wchar, _File) != WEOF;
+}
+#endif // defined(_CRTBLD)
+
+template <class _Elem>
+bool _Ungetc(const _Elem&, FILE*) { // put back an arbitrary element to a C stream (always fail)
+    return false;
+}
+
+template <>
+inline bool _Ungetc(const char& _Byte, FILE* _File) { // put back a char element to a C stream
+    return _CSTD ungetc(static_cast<unsigned char>(_Byte), _File) != EOF;
+}
+
+template <>
+inline bool _Ungetc(const signed char& _Byte, FILE* _File) { // put back a signed char element to a C stream
+    return _CSTD ungetc(static_cast<unsigned char>(_Byte), _File) != EOF;
+}
+
+template <>
+inline bool _Ungetc(const unsigned char& _Byte, FILE* _File) { // put back an unsigned char element to a C stream
+    return _CSTD ungetc(_Byte, _File) != EOF;
+}
+
+template <>
+inline bool _Ungetc(const wchar_t& _Wchar, FILE* _File) { // put back a wchar_t element to a C stream
+    return _CSTD ungetwc(_Wchar, _File) != WEOF;
+}
+
+#ifdef _CRTBLD
+template <>
+inline bool _Ungetc(const unsigned short& _Wchar, FILE* _File) { // put back an unsigned short element to a C stream
+    return _CSTD ungetwc(_Wchar, _File) != WEOF;
+}
+#endif // defined(_CRTBLD)
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_filebuf : public basic_streambuf<_Elem, _Traits> { // stream buffer associated with a C stream
+public:
+    using _Mysb = basic_streambuf<_Elem, _Traits>;
+    using _Cvt  = codecvt<_Elem, char, typename _Traits::state_type>;
+
+    basic_filebuf() : _Mysb() {
+        _Init(nullptr, _Newfl);
+    }
+
+    explicit basic_filebuf(FILE* const _File) : _Mysb() { // extension, no ownership taking
+        _Init(_File, _Newfl);
+    }
+
+    __CLR_OR_THIS_CALL ~basic_filebuf() noexcept override {
+        if (_Myfile) {
+            _Reset_back(); // revert from _Mychar buffer
+        }
+
+        if (_Closef) {
+            close();
+        }
+    }
+
+    using int_type = typename _Traits::int_type;
+    using pos_type = typename _Traits::pos_type;
+    using off_type = typename _Traits::off_type;
+
+    basic_filebuf(_Uninitialized) noexcept : _Mysb(_Noinit) {}
+
+    basic_filebuf(basic_filebuf&& _Right) {
+        _Init(_Right._Myfile, _Newfl); // match buffering styles
+        _Init(static_cast<FILE*>(nullptr), _Closefl); // then make *this look closed
+        _Assign_rv(_STD move(_Right));
+    }
+
+    basic_filebuf& operator=(basic_filebuf&& _Right) {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void _Assign_rv(basic_filebuf&& _Right) {
+        if (this != _STD addressof(_Right)) {
+            close();
+            this->swap(_Right);
+        }
+    }
+
+    void swap(basic_filebuf& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            FILE* _Myfile_sav                       = _Myfile;
+            const _Cvt* _Pcvt_sav                   = _Pcvt;
+            typename _Traits::state_type _State_sav = _State;
+            bool _Wrotesome_sav                     = _Wrotesome;
+            bool _Closef_sav                        = _Closef;
+            bool _Set_eback_sav                     = _Mysb::eback() == &_Mychar;
+            bool _Set_eback_live                    = _Mysb::gptr() == &_Mychar;
+
+            _Elem* _Pfirst0 = _Mysb::pbase();
+            _Elem* _Pnext0  = _Mysb::pptr();
+            _Elem* _Pend    = _Mysb::epptr();
+            _Elem* _Gfirst0 = _Mysb::eback();
+            _Elem* _Gnext0  = _Mysb::gptr();
+            _Elem* _Gend    = _Mysb::egptr();
+
+            // reinitialize *this
+            _Init(_Right._Myfile, _Right._Myfile ? _Openfl : _Newfl);
+            _Mysb::setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
+            if (_Right.eback() != &_Right._Mychar) {
+                _Mysb::setg(_Right.eback(), _Right.gptr(), _Right.egptr());
+            } else if (_Right.gptr() != &_Right._Mychar) {
+                _Mysb::setg(&_Mychar, &_Mychar + 1, &_Mychar + 1);
+            } else {
+                _Mysb::setg(&_Mychar, &_Mychar, &_Mychar + 1);
+            }
+
+            _Pcvt      = _Right._Pcvt;
+            _State     = _Right._State;
+            _Wrotesome = _Right._Wrotesome;
+            _Closef    = _Right._Closef;
+
+            // reinitialize _Right
+            _Right._Init(_Myfile_sav, _Myfile_sav ? _Openfl : _Newfl);
+            _Right.setp(_Pfirst0, _Pnext0, _Pend);
+            if (!_Set_eback_sav) {
+                _Right.setg(_Gfirst0, _Gnext0, _Gend);
+            } else if (!_Set_eback_live) {
+                _Right.setg(&_Right._Mychar, &_Right._Mychar + 1, &_Right._Mychar + 1);
+            } else {
+                _Right.setg(&_Right._Mychar, &_Right._Mychar, &_Right._Mychar + 1);
+            }
+
+            _Right._Pcvt      = _Pcvt_sav;
+            _Right._State     = _State_sav;
+            _Right._Wrotesome = _Wrotesome_sav;
+            _Right._Closef    = _Closef_sav;
+
+            // swap ancillary data
+            _STD swap(_Set_eback, _Right._Set_eback);
+            _STD swap(_Set_egptr, _Right._Set_egptr);
+
+            _STD swap(_Mychar, _Right._Mychar);
+            _STD swap(_Mysb::_Plocale, _Right._Plocale);
+        }
+    }
+
+    basic_filebuf(const basic_filebuf&)            = delete;
+    basic_filebuf& operator=(const basic_filebuf&) = delete;
+
+    enum _Initfl { // reasons for a call to _Init
+        _Newfl,
+        _Openfl,
+        _Closefl
+    };
+
+    _NODISCARD bool is_open() const noexcept /* strengthened */ {
+        return static_cast<bool>(_Myfile);
+    }
+
+    basic_filebuf* open(const char* _Filename, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        if (_Myfile) {
+            return nullptr;
+        }
+
+        const auto _File = _Fiopen(_Filename, _Mode, _Prot);
+        if (!_File) {
+            return nullptr; // open failed
+        }
+
+        _Init(_File, _Openfl);
+        _Initcvt(_STD use_facet<_Cvt>(_Mysb::getloc()));
+        return this; // open succeeded
+    }
+
+    basic_filebuf* open(const string& _Str, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        return open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    basic_filebuf* open(const char* _Filename, ios_base::open_mode _Mode) {
+        return open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    basic_filebuf* open(const wchar_t* _Filename, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // in standard as const std::filesystem::path::value_type *; _Prot is an extension
+        if (_Myfile) {
+            return nullptr;
+        }
+
+        const auto _File = _Fiopen(_Filename, _Mode, _Prot);
+        if (!_File) {
+            return nullptr; // open failed
+        }
+
+        _Init(_File, _Openfl);
+        _Initcvt(_STD use_facet<_Cvt>(_Mysb::getloc()));
+        return this; // open succeeded
+    }
+
+    basic_filebuf* open(const wstring& _Str, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // extension
+        return open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_CXX17
+    template <int = 0, class _Path_ish = filesystem::path>
+    basic_filebuf* open(
+        const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        return open(_Path.c_str(), _Mode, _Prot);
+    }
+#endif // _HAS_CXX17
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    basic_filebuf* open(const wchar_t* _Filename, ios_base::open_mode _Mode) {
+        // in standard as const std::filesystem::path::value_type *
+        return open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    basic_filebuf* close() {
+        basic_filebuf* _Ans;
+        if (_Myfile) { // put any homing sequence and close file
+            _Reset_back(); // revert from _Mychar buffer
+
+            _Ans = this;
+            if (!_Endwrite()) {
+                _Ans = nullptr;
+            }
+
+            if (_CSTD fclose(_Myfile) != 0) {
+                _Ans = nullptr;
+            }
+        } else {
+            _Ans = nullptr;
+        }
+
+        _Init(nullptr, _Closefl);
+        return _Ans;
+    }
+
+    void __CLR_OR_THIS_CALL _Lock() override { // lock file instead of stream buffer
+        if (_Myfile) {
+            _CSTD _lock_file(_Myfile);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL _Unlock() override { // unlock file instead of stream buffer
+        if (_Myfile) {
+            _CSTD _unlock_file(_Myfile);
+        }
+    }
+
+#if _HAS_CXX23 && defined(_CPPRTTI)
+    template <class _UnicodeConsoleFn, class _FallbackFn, class _Filebuf_type>
+    friend ios_base::iostate _Do_on_maybe_unicode_console(ostream&, _UnicodeConsoleFn, _FallbackFn);
+#endif // ^^^ _HAS_CXX23 && defined(_CPPRTTI) ^^^
+
+protected:
+    int_type __CLR_OR_THIS_CALL overflow(int_type _Meta = _Traits::eof()) override { // put an element to stream
+        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            return _Traits::not_eof(_Meta); // EOF, return success code
+        }
+
+        if (_Mysb::pptr() && _Mysb::pptr() < _Mysb::epptr()) { // room in buffer, store it
+            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
+            return _Meta;
+        }
+
+        if (!_Myfile) {
+            return _Traits::eof(); // no open C stream, fail
+        }
+
+        _Reset_back(); // revert from _Mychar buffer
+        if (!_Pcvt) { // no codecvt facet, put as is
+            return _Fputc(_Traits::to_char_type(_Meta), _Myfile) ? _Meta : _Traits::eof();
+        }
+
+        // put using codecvt facet
+        constexpr size_t _Codecvt_temp_buf = 32;
+        char _Str[_Codecvt_temp_buf];
+        const _Elem _Ch = _Traits::to_char_type(_Meta);
+        const _Elem* _Src;
+        char* _Dest;
+
+        // test result of converting one element
+        switch (_Pcvt->out(_State, &_Ch, &_Ch + 1, _Src, _Str, _Str + _Codecvt_temp_buf, _Dest)) {
+        case codecvt_base::partial:
+        case codecvt_base::ok:
+            { // converted something, try to put it out
+                const auto _Count = static_cast<size_t>(_Dest - _Str);
+                if (0 < _Count && _Count != static_cast<size_t>(_CSTD fwrite(_Str, 1, _Count, _Myfile))) {
+                    return _Traits::eof(); // write failed
+                }
+
+                _Wrotesome = true; // write succeeded
+                if (_Src != &_Ch) {
+                    return _Meta; // converted whole element
+                }
+
+                return _Traits::eof(); // conversion failed
+            }
+
+        case codecvt_base::noconv:
+            // no conversion, put as is
+            return _Fputc(_Ch, _Myfile) ? _Meta : _Traits::eof();
+
+        default:
+            return _Traits::eof(); // conversion failed
+        }
+    }
+
+    int_type __CLR_OR_THIS_CALL pbackfail(int_type _Meta = _Traits::eof()) override {
+        // put an element back to stream
+        if (_Mysb::gptr() && _Mysb::eback() < _Mysb::gptr()
+            && (_Traits::eq_int_type(_Traits::eof(), _Meta)
+                || _Traits::eq_int_type(_Traits::to_int_type(_Mysb::gptr()[-1]),
+                    _Meta))) { // just back up position
+            _Mysb::_Gndec();
+            return _Traits::not_eof(_Meta);
+        } else if (!_Myfile || _Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            return _Traits::eof(); // no open C stream or EOF, fail
+        } else if (!_Pcvt && _Ungetc(_Traits::to_char_type(_Meta), _Myfile)) {
+            return _Meta; // no facet and unget succeeded, return
+        } else if (_Mysb::gptr() != &_Mychar) { // putback to _Mychar
+            _Mychar = _Traits::to_char_type(_Meta);
+            _Set_back(); // switch to _Mychar buffer
+            return _Meta;
+        } else {
+            return _Traits::eof(); // nowhere to put back
+        }
+    }
+
+    int_type __CLR_OR_THIS_CALL underflow() override { // get an element from stream, but don't point past it
+        int_type _Meta;
+        if (_Mysb::gptr() && _Mysb::gptr() < _Mysb::egptr()) {
+            return _Traits::to_int_type(*_Mysb::gptr()); // return buffered
+        } else if (_Traits::eq_int_type(_Traits::eof(), _Meta = uflow())) {
+            return _Meta; // uflow failed, return EOF
+        } else { // get a char, don't point past it
+            pbackfail(_Meta);
+            return _Meta;
+        }
+    }
+
+    int_type __CLR_OR_THIS_CALL uflow() override { // get an element from stream, point past it
+        if (_Mysb::gptr() && _Mysb::gptr() < _Mysb::egptr()) {
+            return _Traits::to_int_type(*_Mysb::_Gninc()); // return buffered
+        }
+
+        if (!_Myfile) {
+            return _Traits::eof(); // no open C stream, fail
+        }
+
+        _Reset_back(); // revert from _Mychar buffer
+        if (!_Pcvt) { // no codecvt facet, just get it
+            _Elem _Ch;
+            return _Fgetc(_Ch, _Myfile) ? _Traits::to_int_type(_Ch) : _Traits::eof();
+        }
+
+        // build string until codecvt succeeds
+        string _Str;
+
+        for (;;) { // get using codecvt facet
+            const char* _Src;
+            int _Meta = _CSTD fgetc(_Myfile);
+
+            if (_Meta == EOF) {
+                return _Traits::eof(); // partial char?
+            }
+
+            _Str.push_back(static_cast<char>(_Meta)); // append byte and convert
+
+            _Elem _Ch;
+            _Elem* _Dest;
+
+            // test result of converting one element
+            switch (_Pcvt->in(_State, _Str.data(), _Str.data() + _Str.size(), _Src, &_Ch, &_Ch + 1, _Dest)) {
+            case codecvt_base::partial:
+            case codecvt_base::ok:
+                if (_Dest != &_Ch) { // got an element, put back excess and deliver it
+                    auto _Nleft = _Str.data() + _Str.size() - _Src;
+                    while (0 < _Nleft) {
+                        _CSTD ungetc(_Src[--_Nleft], _Myfile);
+                    }
+
+                    return _Traits::to_int_type(_Ch);
+                }
+
+                _Str.erase(0, static_cast<size_t>(_Src - _Str.data())); // partial, discard used input
+                break;
+
+            case codecvt_base::noconv:
+                // noconv is only possible if _Elem is char, so we can use it directly
+                return static_cast<int_type>(_Str.front());
+
+            default:
+                return _Traits::eof(); // conversion failed
+            }
+        }
+    }
+
+    streamsize __CLR_OR_THIS_CALL xsgetn(_Elem* _Ptr, streamsize _Count) override {
+        // get _Count characters from stream
+        if constexpr (sizeof(_Elem) == 1) {
+            if (_Count <= 0) {
+                return 0;
+            }
+
+            if (_Pcvt) { // if we need a nontrivial codecvt transform, do the default expensive thing
+                return _Mysb::xsgetn(_Ptr, _Count);
+            }
+
+            // assuming this is OK because _Ptr + _Count must be valid
+            auto _Count_s           = static_cast<size_t>(_Count);
+            const auto _Start_count = _Count;
+            const auto _Available   = static_cast<size_t>(_Mysb::_Gnavail());
+            if (0 < _Available) { // copy from get area
+                const auto _Read_size = (_STD min) (_Count_s, _Available);
+                _Traits::copy(_Ptr, _Mysb::gptr(), _Read_size);
+                _Ptr += _Read_size;
+                _Count_s -= _Read_size;
+                _Mysb::gbump(static_cast<int>(_Read_size));
+            }
+
+            if (_Myfile) { // open C stream, attempt read
+                _Reset_back(); // revert from _Mychar buffer
+                // process in 4k - 1 chunks to avoid tripping over fread's clobber-the-end behavior when
+                // doing \r\n -> \n translation
+                constexpr size_t _Read_size = 4095; // _INTERNAL_BUFSIZ - 1
+                while (_Read_size < _Count_s) {
+                    const auto _Actual_read = _CSTD fread(_Ptr, sizeof(_Elem), _Read_size, _Myfile);
+                    _Ptr += _Actual_read;
+                    _Count_s -= _Actual_read;
+                    if (_Actual_read != _Read_size) {
+                        return static_cast<streamsize>(_Start_count - _Count_s);
+                    }
+                }
+
+                if (0 < _Count_s) {
+                    _Count_s -= _CSTD fread(_Ptr, sizeof(_Elem), _Count_s, _Myfile);
+                }
+            }
+
+            return static_cast<streamsize>(_Start_count - _Count_s);
+        } else { // non-chars always get element-by-element processing
+            return _Mysb::xsgetn(_Ptr, _Count);
+        }
+    }
+
+    streamsize __CLR_OR_THIS_CALL xsputn(const _Elem* _Ptr, streamsize _Count) override {
+        // put _Count characters to stream
+        if constexpr (sizeof(_Elem) == 1) {
+            if (_Pcvt) { // if we need a nontrivial codecvt transform, do the default expensive thing
+                return _Mysb::xsputn(_Ptr, _Count);
+            }
+
+            const streamsize _Start_count = _Count;
+            streamsize _Size              = _Mysb::_Pnavail();
+            if (0 < _Count && 0 < _Size) { // copy to write buffer
+                if (_Count < _Size) {
+                    _Size = _Count;
+                }
+
+                _Traits::copy(_Mysb::pptr(), _Ptr, static_cast<size_t>(_Size));
+                _Ptr += _Size;
+                _Count -= _Size;
+                _Mysb::pbump(static_cast<int>(_Size));
+            }
+
+            if (0 < _Count && _Myfile) { // open C stream, attempt write
+                _Count -= _CSTD fwrite(_Ptr, sizeof(_Elem), static_cast<size_t>(_Count), _Myfile);
+            }
+
+            return _Start_count - _Count;
+        } else { // non-chars always get element-by-element processing
+            return _Mysb::xsputn(_Ptr, _Count);
+        }
+    }
+
+    pos_type __CLR_OR_THIS_CALL seekoff(off_type _Off, ios_base::seekdir _Way,
+        ios_base::openmode = ios_base::in | ios_base::out) override { // change position by _Off
+        fpos_t _Fileposition;
+
+        if (_Mysb::gptr() == &_Mychar // something putback
+            && _Way == ios_base::cur // a relative seek
+            && !_Pcvt) { // not converting
+            _Off -= static_cast<off_type>(sizeof(_Elem)); // back up over _Elem bytes
+        }
+
+        if (!_Myfile || !_Endwrite()
+            || ((_Off != 0 || _Way != ios_base::cur) && _CSTD _fseeki64(_Myfile, _Off, _Way) != 0)
+            || _CSTD fgetpos(_Myfile, &_Fileposition) != 0) {
+            return pos_type{off_type{-1}}; // report failure
+        }
+
+        _Reset_back(); // revert from _Mychar buffer, discarding any putback
+        return pos_type{_State, _Fileposition}; // return new position
+    }
+
+    pos_type __CLR_OR_THIS_CALL seekpos(pos_type _Pos, ios_base::openmode = ios_base::in | ios_base::out) override {
+        // change position to _Pos
+        off_type _Off = static_cast<off_type>(_Pos);
+
+        if (!_Myfile || !_Endwrite() || _CSTD fsetpos(_Myfile, &_Off) != 0) {
+            return pos_type{off_type{-1}}; // report failure
+        }
+
+        _State = _Pos.state();
+        _Reset_back(); // revert from _Mychar buffer, discarding any putback
+        return pos_type{_State, _Off}; // return new position
+    }
+
+    _Mysb* __CLR_OR_THIS_CALL setbuf(_Elem* _Buffer, streamsize _Count) override { // offer _Buffer to C stream
+        int _Mode;
+        if (!_Buffer && _Count == 0) {
+            _Mode = _IONBF;
+        } else {
+            _Mode = _IOFBF;
+        }
+
+        const size_t _Size = static_cast<size_t>(_Count) * sizeof(_Elem);
+
+        if (!_Myfile || _CSTD setvbuf(_Myfile, reinterpret_cast<char*>(_Buffer), _Mode, _Size) != 0) {
+            return nullptr; // failed
+        }
+
+        // new buffer, reinitialize pointers
+        _Init(_Myfile, _Openfl);
+        return this;
+    }
+
+    int __CLR_OR_THIS_CALL sync() override { // synchronize C stream with external file
+        if (!_Myfile || _Traits::eq_int_type(_Traits::eof(), overflow()) || 0 <= _CSTD fflush(_Myfile)) {
+            return 0;
+        }
+
+        return -1;
+    }
+
+    void __CLR_OR_THIS_CALL imbue(const locale& _Loc) override {
+        // set locale to argument (capture nontrivial codecvt facet)
+        _Initcvt(_STD use_facet<_Cvt>(_Loc));
+    }
+
+    void _Init(FILE* _File, _Initfl _Which) noexcept { // initialize to C stream _File after {new, open, close}
+        using _State_type = typename _Traits::state_type;
+
+        __PURE_APPDOMAIN_GLOBAL static _State_type _Stinit; // initial state
+
+        _Closef    = _Which == _Openfl;
+        _Wrotesome = false;
+
+        _Mysb::_Init(); // initialize stream buffer base object
+
+        if (_File && sizeof(_Elem) == 1) { // point inside C stream with [first, first + count) buffer
+            _Elem** _Pb = nullptr;
+            _Elem** _Pn = nullptr;
+            int* _Nr    = nullptr;
+
+            ::_get_stream_buffer_pointers(
+                _File, reinterpret_cast<char***>(&_Pb), reinterpret_cast<char***>(&_Pn), &_Nr);
+            int* _Nw = _Nr;
+
+            _Mysb::_Init(_Pb, _Pn, _Nr, _Pb, _Pn, _Nw);
+        }
+
+        _Myfile = _File;
+        _State  = _Stinit;
+        _Pcvt   = nullptr; // pointer to codecvt facet
+    }
+
+    bool _Endwrite() { // put shift to initial conversion state, as needed
+        if (!_Pcvt || !_Wrotesome) {
+            return true;
+        }
+
+        // may have to put
+        if (_Traits::eq_int_type(_Traits::eof(), overflow())) {
+            return false;
+        }
+
+        constexpr size_t _Codecvt_temp_buf = 32;
+        char _Str[_Codecvt_temp_buf];
+        char* _Dest;
+        switch (_Pcvt->unshift(_State, _Str, _Str + _Codecvt_temp_buf, _Dest)) { // test result of homing conversion
+        case codecvt_base::ok:
+            _Wrotesome = false; // homed successfully
+            _FALLTHROUGH;
+
+        case codecvt_base::partial:
+            { // put any generated bytes
+                const auto _Count = static_cast<size_t>(_Dest - _Str);
+                if (0 < _Count && _Count != static_cast<size_t>(_CSTD fwrite(_Str, 1, _Count, _Myfile))) {
+                    return false; // write failed
+                }
+
+                return !_Wrotesome;
+            }
+
+        case codecvt_base::noconv:
+            _Wrotesome = false; // homed successfully
+            return true; // nothing else to do
+
+        default:
+            return false; // conversion failed
+        }
+    }
+
+    void _Initcvt(const _Cvt& _Newcvt) noexcept { // initialize codecvt pointer
+        if (_Newcvt.always_noconv()) {
+            _Pcvt = nullptr; // nothing to do
+        } else { // set up for nontrivial codecvt facet
+            _Pcvt = _STD addressof(_Newcvt);
+            _Mysb::_Init(); // reset any buffering
+        }
+    }
+
+private:
+    const _Cvt* _Pcvt; // pointer to codecvt facet (may be null)
+    _Elem _Mychar; // putback character, when _Ungetc fails
+    bool _Wrotesome; // true if homing sequence may be needed
+    typename _Traits::state_type _State; // current conversion state
+    bool _Closef; // true if C stream must be closed
+    FILE* _Myfile; // pointer to C stream
+
+    void _Reset_back() noexcept { // restore buffer after putback
+        if (_Mysb::eback() == &_Mychar) {
+            _Mysb::setg(_Set_eback, _Set_eback, _Set_egptr);
+        }
+    }
+
+    void _Set_back() noexcept { // set up putback area
+        if (_Mysb::eback() != &_Mychar) { // save current get buffer
+            _Set_eback = _Mysb::eback();
+            _Set_egptr = _Mysb::egptr();
+        }
+        _Mysb::setg(&_Mychar, &_Mychar, &_Mychar + 1);
+    }
+
+    _Elem* _Set_eback; // saves eback() during one-element putback
+    _Elem* _Set_egptr; // saves egptr()
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_filebuf<_Elem, _Traits>& _Left, basic_filebuf<_Elem, _Traits>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_FILEBUF_HPP
diff --git a/msvc-stl/stl/inc/__msvc_format_ucd_tables.hpp b/msvc-stl/stl/inc/__msvc_format_ucd_tables.hpp
new file mode 100644
index 0000000..a4ebf52
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_format_ucd_tables.hpp
@@ -0,0 +1,659 @@
+// __msvc_format_ucd_tables.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// WARNING, this entire header is generated by
+// tools/unicode_properties_parse/unicode_properties_data_gen.py
+// DO NOT MODIFY!
+
+// UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
+//
+// See Terms of Use <https://www.unicode.org/copyright.html>
+// for definitions of Unicode Inc.'s Data Files and Software.
+//
+// NOTICE TO USER: Carefully read the following legal agreement.
+// BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
+// DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
+// YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+// TERMS AND CONDITIONS OF THIS AGREEMENT.
+// IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
+// THE DATA FILES OR SOFTWARE.
+//
+// COPYRIGHT AND PERMISSION NOTICE
+//
+// Copyright (c) 1991-2022 Unicode, Inc. All rights reserved.
+// Distributed under the Terms of Use in https://www.unicode.org/copyright.html.
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of the Unicode data files and any associated documentation
+// (the "Data Files") or Unicode software and any associated documentation
+// (the "Software") to deal in the Data Files or Software
+// without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, and/or sell copies of
+// the Data Files or Software, and to permit persons to whom the Data Files
+// or Software are furnished to do so, provided that either
+// (a) this copyright and permission notice appear with all copies
+// of the Data Files or Software, or
+// (b) this copyright and permission notice appear in associated
+// Documentation.
+//
+// THE DATA FILES AND SOFTWARE ARE 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 OF THIRD PARTY RIGHTS.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+// NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+// DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+// DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+//
+// Except as contained in this notice, the name of a copyright holder
+// shall not be used in advertising or otherwise to promote the sale,
+// use or other dealings in these Data Files or Software without prior
+// written authorization of the copyright holder.
+
+#ifndef __MSVC_FORMAT_UCD_TABLES_HPP
+#define __MSVC_FORMAT_UCD_TABLES_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdint>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+template <class _ValueEnum, size_t _NumRanges, bool _Is_binary_property>
+struct _Unicode_property_data {
+    uint32_t _Lower_bounds[_NumRanges];
+    uint16_t _Props_and_size[_NumRanges];
+    _NODISCARD constexpr _ValueEnum _Get_property_for_codepoint(const uint32_t _Code_point) const noexcept {
+        ptrdiff_t _Upper_idx = _STD upper_bound(_Lower_bounds, _STD end(_Lower_bounds), _Code_point) - _Lower_bounds;
+        constexpr auto _No_value_constant = static_cast<_ValueEnum>(UINT8_MAX);
+        if (_Upper_idx == 0) {
+            return _No_value_constant;
+        }
+        --_Upper_idx;
+        const uint32_t _Lower_bound = _Lower_bounds[_Upper_idx];
+        const uint16_t _Data        = _Props_and_size[_Upper_idx];
+        _STL_INTERNAL_CHECK(_Code_point >= _Lower_bound);
+        if constexpr (_Is_binary_property) {
+            if (_Code_point < _Lower_bound + _Data) {
+                return static_cast<_ValueEnum>(0);
+            }
+        } else {
+            const uint16_t _Size   = static_cast<uint16_t>(_Data & 0x0FFF);
+            const _ValueEnum _Prop = static_cast<_ValueEnum>((_Data & 0xF000) >> 12);
+            if (_Code_point < _Lower_bound + _Size) {
+                return _Prop;
+            }
+        }
+        return _No_value_constant;
+    }
+};
+
+// The following static data tables are generated from the Unicode character database.
+// _Grapheme_Break_property_data comes from ucd/auxiliary/GraphemeBreakProperty.txt.
+//
+// _Indic_Conjunct_Break_property_data comes from ucd/DerivedCoreProperties.txt.
+//
+// _Extended_Pictographic_property_data comes from ucd/emoji/emoji-data.txt.
+//
+// __printable_property_data comes from ucd/extracted/DerivedGeneralCategory.txt.
+//
+// _Grapheme_Extend_property_data comes from ucd/DerivedCoreProperties.txt.
+//
+// The enums containing the values for the properties are also generated, in order to ensure they match
+// up correctly with how we're parsing them.
+//
+// All sets of data tables are generated by tools/unicode_properties_parse/unicode_properties_data_gen.py in the
+// https://github.com/microsoft/stl repository.
+//
+// The data format is a set of arrays for each character property. The first is an array of uint32_t encoding
+// the lower bound of each range of codepoints that has the given property.
+// The second is an array of uint16_t.
+// - For enumerated properties, this array encodes both the range size and property value as follows:
+//   16               12                                   0
+//   +-----------------------------------------------------+
+//   | property_value  |              range_size           |
+//   +-----------------------------------------------------+
+//   that is: the size is stored in the least significant 12 bits
+//   (leading to a max size of 4095), and the property value is stored in the most significant 4 bits,
+//   leading to a maximum of 16 property values.
+// - For binary properties, this array simply stores the range size.
+//
+// Codepoint ranges may not overlap, and, within one property, a codepoint may only appear once. Furthermore the
+// codepoint lower bounds appear in sorted (ascending) order.
+
+// GraphemeBreakProperty-17.0.0.txt
+// Date: 2025-06-30, 06:20:23 GMT
+enum class _Grapheme_Break_property_values : uint8_t {
+    _CR_value,
+    _Control_value,
+    _Extend_value,
+    _L_value,
+    _LF_value,
+    _LV_value,
+    _LVT_value,
+    _Prepend_value,
+    _Regional_Indicator_value,
+    _SpacingMark_value,
+    _T_value,
+    _V_value,
+    _ZWJ_value,
+    _No_value = 255
+};
+
+// GraphemeBreakProperty-17.0.0.txt
+// Date: 2025-06-30, 06:20:23 GMT
+inline constexpr _Unicode_property_data<_Grapheme_Break_property_values, 1386, false> _Grapheme_Break_property_data{
+    {0x0, 0xa, 0xb, 0xd, 0xe, 0x7f, 0xad, 0x300, 0x483, 0x591, 0x5bf, 0x5c1, 0x5c4, 0x5c7, 0x600, 0x610, 0x61c, 0x64b,
+        0x670, 0x6d6, 0x6dd, 0x6df, 0x6e7, 0x6ea, 0x70f, 0x711, 0x730, 0x7a6, 0x7eb, 0x7fd, 0x816, 0x81b, 0x825, 0x829,
+        0x859, 0x890, 0x897, 0x8ca, 0x8e2, 0x8e3, 0x903, 0x93a, 0x93b, 0x93c, 0x93e, 0x941, 0x949, 0x94d, 0x94e, 0x951,
+        0x962, 0x981, 0x982, 0x9bc, 0x9be, 0x9bf, 0x9c1, 0x9c7, 0x9cb, 0x9cd, 0x9d7, 0x9e2, 0x9fe, 0xa01, 0xa03, 0xa3c,
+        0xa3e, 0xa41, 0xa47, 0xa4b, 0xa51, 0xa70, 0xa75, 0xa81, 0xa83, 0xabc, 0xabe, 0xac1, 0xac7, 0xac9, 0xacb, 0xacd,
+        0xae2, 0xafa, 0xb01, 0xb02, 0xb3c, 0xb3e, 0xb40, 0xb41, 0xb47, 0xb4b, 0xb4d, 0xb55, 0xb62, 0xb82, 0xbbe, 0xbbf,
+        0xbc0, 0xbc1, 0xbc6, 0xbca, 0xbcd, 0xbd7, 0xc00, 0xc01, 0xc04, 0xc3c, 0xc3e, 0xc41, 0xc46, 0xc4a, 0xc55, 0xc62,
+        0xc81, 0xc82, 0xcbc, 0xcbe, 0xcbf, 0xcc1, 0xcc2, 0xcc3, 0xcc6, 0xcca, 0xcd5, 0xce2, 0xcf3, 0xd00, 0xd02, 0xd3b,
+        0xd3e, 0xd3f, 0xd41, 0xd46, 0xd4a, 0xd4d, 0xd4e, 0xd57, 0xd62, 0xd81, 0xd82, 0xdca, 0xdcf, 0xdd0, 0xdd2, 0xdd6,
+        0xdd8, 0xddf, 0xdf2, 0xe31, 0xe33, 0xe34, 0xe47, 0xeb1, 0xeb3, 0xeb4, 0xec8, 0xf18, 0xf35, 0xf37, 0xf39, 0xf3e,
+        0xf71, 0xf7f, 0xf80, 0xf86, 0xf8d, 0xf99, 0xfc6, 0x102d, 0x1031, 0x1032, 0x1039, 0x103b, 0x103d, 0x1056, 0x1058,
+        0x105e, 0x1071, 0x1082, 0x1084, 0x1085, 0x108d, 0x109d, 0x1100, 0x1160, 0x11a8, 0x135d, 0x1712, 0x1732, 0x1752,
+        0x1772, 0x17b4, 0x17b6, 0x17b7, 0x17be, 0x17c6, 0x17c7, 0x17c9, 0x17dd, 0x180b, 0x180e, 0x180f, 0x1885, 0x18a9,
+        0x1920, 0x1923, 0x1927, 0x1929, 0x1930, 0x1932, 0x1933, 0x1939, 0x1a17, 0x1a19, 0x1a1b, 0x1a55, 0x1a56, 0x1a57,
+        0x1a58, 0x1a60, 0x1a62, 0x1a65, 0x1a6d, 0x1a73, 0x1a7f, 0x1ab0, 0x1ae0, 0x1b00, 0x1b04, 0x1b34, 0x1b3e, 0x1b42,
+        0x1b6b, 0x1b80, 0x1b82, 0x1ba1, 0x1ba2, 0x1ba6, 0x1ba8, 0x1be6, 0x1be7, 0x1be8, 0x1bea, 0x1bed, 0x1bee, 0x1bef,
+        0x1c24, 0x1c2c, 0x1c34, 0x1c36, 0x1cd0, 0x1cd4, 0x1ce1, 0x1ce2, 0x1ced, 0x1cf4, 0x1cf7, 0x1cf8, 0x1dc0, 0x200b,
+        0x200c, 0x200d, 0x200e, 0x2028, 0x2060, 0x20d0, 0x2cef, 0x2d7f, 0x2de0, 0x302a, 0x3099, 0xa66f, 0xa674, 0xa69e,
+        0xa6f0, 0xa802, 0xa806, 0xa80b, 0xa823, 0xa825, 0xa827, 0xa82c, 0xa880, 0xa8b4, 0xa8c4, 0xa8e0, 0xa8ff, 0xa926,
+        0xa947, 0xa952, 0xa953, 0xa960, 0xa980, 0xa983, 0xa9b3, 0xa9b4, 0xa9b6, 0xa9ba, 0xa9bc, 0xa9be, 0xa9c0, 0xa9e5,
+        0xaa29, 0xaa2f, 0xaa31, 0xaa33, 0xaa35, 0xaa43, 0xaa4c, 0xaa4d, 0xaa7c, 0xaab0, 0xaab2, 0xaab7, 0xaabe, 0xaac1,
+        0xaaeb, 0xaaec, 0xaaee, 0xaaf5, 0xaaf6, 0xabe3, 0xabe5, 0xabe6, 0xabe8, 0xabe9, 0xabec, 0xabed, 0xac00, 0xac01,
+        0xac1c, 0xac1d, 0xac38, 0xac39, 0xac54, 0xac55, 0xac70, 0xac71, 0xac8c, 0xac8d, 0xaca8, 0xaca9, 0xacc4, 0xacc5,
+        0xace0, 0xace1, 0xacfc, 0xacfd, 0xad18, 0xad19, 0xad34, 0xad35, 0xad50, 0xad51, 0xad6c, 0xad6d, 0xad88, 0xad89,
+        0xada4, 0xada5, 0xadc0, 0xadc1, 0xaddc, 0xaddd, 0xadf8, 0xadf9, 0xae14, 0xae15, 0xae30, 0xae31, 0xae4c, 0xae4d,
+        0xae68, 0xae69, 0xae84, 0xae85, 0xaea0, 0xaea1, 0xaebc, 0xaebd, 0xaed8, 0xaed9, 0xaef4, 0xaef5, 0xaf10, 0xaf11,
+        0xaf2c, 0xaf2d, 0xaf48, 0xaf49, 0xaf64, 0xaf65, 0xaf80, 0xaf81, 0xaf9c, 0xaf9d, 0xafb8, 0xafb9, 0xafd4, 0xafd5,
+        0xaff0, 0xaff1, 0xb00c, 0xb00d, 0xb028, 0xb029, 0xb044, 0xb045, 0xb060, 0xb061, 0xb07c, 0xb07d, 0xb098, 0xb099,
+        0xb0b4, 0xb0b5, 0xb0d0, 0xb0d1, 0xb0ec, 0xb0ed, 0xb108, 0xb109, 0xb124, 0xb125, 0xb140, 0xb141, 0xb15c, 0xb15d,
+        0xb178, 0xb179, 0xb194, 0xb195, 0xb1b0, 0xb1b1, 0xb1cc, 0xb1cd, 0xb1e8, 0xb1e9, 0xb204, 0xb205, 0xb220, 0xb221,
+        0xb23c, 0xb23d, 0xb258, 0xb259, 0xb274, 0xb275, 0xb290, 0xb291, 0xb2ac, 0xb2ad, 0xb2c8, 0xb2c9, 0xb2e4, 0xb2e5,
+        0xb300, 0xb301, 0xb31c, 0xb31d, 0xb338, 0xb339, 0xb354, 0xb355, 0xb370, 0xb371, 0xb38c, 0xb38d, 0xb3a8, 0xb3a9,
+        0xb3c4, 0xb3c5, 0xb3e0, 0xb3e1, 0xb3fc, 0xb3fd, 0xb418, 0xb419, 0xb434, 0xb435, 0xb450, 0xb451, 0xb46c, 0xb46d,
+        0xb488, 0xb489, 0xb4a4, 0xb4a5, 0xb4c0, 0xb4c1, 0xb4dc, 0xb4dd, 0xb4f8, 0xb4f9, 0xb514, 0xb515, 0xb530, 0xb531,
+        0xb54c, 0xb54d, 0xb568, 0xb569, 0xb584, 0xb585, 0xb5a0, 0xb5a1, 0xb5bc, 0xb5bd, 0xb5d8, 0xb5d9, 0xb5f4, 0xb5f5,
+        0xb610, 0xb611, 0xb62c, 0xb62d, 0xb648, 0xb649, 0xb664, 0xb665, 0xb680, 0xb681, 0xb69c, 0xb69d, 0xb6b8, 0xb6b9,
+        0xb6d4, 0xb6d5, 0xb6f0, 0xb6f1, 0xb70c, 0xb70d, 0xb728, 0xb729, 0xb744, 0xb745, 0xb760, 0xb761, 0xb77c, 0xb77d,
+        0xb798, 0xb799, 0xb7b4, 0xb7b5, 0xb7d0, 0xb7d1, 0xb7ec, 0xb7ed, 0xb808, 0xb809, 0xb824, 0xb825, 0xb840, 0xb841,
+        0xb85c, 0xb85d, 0xb878, 0xb879, 0xb894, 0xb895, 0xb8b0, 0xb8b1, 0xb8cc, 0xb8cd, 0xb8e8, 0xb8e9, 0xb904, 0xb905,
+        0xb920, 0xb921, 0xb93c, 0xb93d, 0xb958, 0xb959, 0xb974, 0xb975, 0xb990, 0xb991, 0xb9ac, 0xb9ad, 0xb9c8, 0xb9c9,
+        0xb9e4, 0xb9e5, 0xba00, 0xba01, 0xba1c, 0xba1d, 0xba38, 0xba39, 0xba54, 0xba55, 0xba70, 0xba71, 0xba8c, 0xba8d,
+        0xbaa8, 0xbaa9, 0xbac4, 0xbac5, 0xbae0, 0xbae1, 0xbafc, 0xbafd, 0xbb18, 0xbb19, 0xbb34, 0xbb35, 0xbb50, 0xbb51,
+        0xbb6c, 0xbb6d, 0xbb88, 0xbb89, 0xbba4, 0xbba5, 0xbbc0, 0xbbc1, 0xbbdc, 0xbbdd, 0xbbf8, 0xbbf9, 0xbc14, 0xbc15,
+        0xbc30, 0xbc31, 0xbc4c, 0xbc4d, 0xbc68, 0xbc69, 0xbc84, 0xbc85, 0xbca0, 0xbca1, 0xbcbc, 0xbcbd, 0xbcd8, 0xbcd9,
+        0xbcf4, 0xbcf5, 0xbd10, 0xbd11, 0xbd2c, 0xbd2d, 0xbd48, 0xbd49, 0xbd64, 0xbd65, 0xbd80, 0xbd81, 0xbd9c, 0xbd9d,
+        0xbdb8, 0xbdb9, 0xbdd4, 0xbdd5, 0xbdf0, 0xbdf1, 0xbe0c, 0xbe0d, 0xbe28, 0xbe29, 0xbe44, 0xbe45, 0xbe60, 0xbe61,
+        0xbe7c, 0xbe7d, 0xbe98, 0xbe99, 0xbeb4, 0xbeb5, 0xbed0, 0xbed1, 0xbeec, 0xbeed, 0xbf08, 0xbf09, 0xbf24, 0xbf25,
+        0xbf40, 0xbf41, 0xbf5c, 0xbf5d, 0xbf78, 0xbf79, 0xbf94, 0xbf95, 0xbfb0, 0xbfb1, 0xbfcc, 0xbfcd, 0xbfe8, 0xbfe9,
+        0xc004, 0xc005, 0xc020, 0xc021, 0xc03c, 0xc03d, 0xc058, 0xc059, 0xc074, 0xc075, 0xc090, 0xc091, 0xc0ac, 0xc0ad,
+        0xc0c8, 0xc0c9, 0xc0e4, 0xc0e5, 0xc100, 0xc101, 0xc11c, 0xc11d, 0xc138, 0xc139, 0xc154, 0xc155, 0xc170, 0xc171,
+        0xc18c, 0xc18d, 0xc1a8, 0xc1a9, 0xc1c4, 0xc1c5, 0xc1e0, 0xc1e1, 0xc1fc, 0xc1fd, 0xc218, 0xc219, 0xc234, 0xc235,
+        0xc250, 0xc251, 0xc26c, 0xc26d, 0xc288, 0xc289, 0xc2a4, 0xc2a5, 0xc2c0, 0xc2c1, 0xc2dc, 0xc2dd, 0xc2f8, 0xc2f9,
+        0xc314, 0xc315, 0xc330, 0xc331, 0xc34c, 0xc34d, 0xc368, 0xc369, 0xc384, 0xc385, 0xc3a0, 0xc3a1, 0xc3bc, 0xc3bd,
+        0xc3d8, 0xc3d9, 0xc3f4, 0xc3f5, 0xc410, 0xc411, 0xc42c, 0xc42d, 0xc448, 0xc449, 0xc464, 0xc465, 0xc480, 0xc481,
+        0xc49c, 0xc49d, 0xc4b8, 0xc4b9, 0xc4d4, 0xc4d5, 0xc4f0, 0xc4f1, 0xc50c, 0xc50d, 0xc528, 0xc529, 0xc544, 0xc545,
+        0xc560, 0xc561, 0xc57c, 0xc57d, 0xc598, 0xc599, 0xc5b4, 0xc5b5, 0xc5d0, 0xc5d1, 0xc5ec, 0xc5ed, 0xc608, 0xc609,
+        0xc624, 0xc625, 0xc640, 0xc641, 0xc65c, 0xc65d, 0xc678, 0xc679, 0xc694, 0xc695, 0xc6b0, 0xc6b1, 0xc6cc, 0xc6cd,
+        0xc6e8, 0xc6e9, 0xc704, 0xc705, 0xc720, 0xc721, 0xc73c, 0xc73d, 0xc758, 0xc759, 0xc774, 0xc775, 0xc790, 0xc791,
+        0xc7ac, 0xc7ad, 0xc7c8, 0xc7c9, 0xc7e4, 0xc7e5, 0xc800, 0xc801, 0xc81c, 0xc81d, 0xc838, 0xc839, 0xc854, 0xc855,
+        0xc870, 0xc871, 0xc88c, 0xc88d, 0xc8a8, 0xc8a9, 0xc8c4, 0xc8c5, 0xc8e0, 0xc8e1, 0xc8fc, 0xc8fd, 0xc918, 0xc919,
+        0xc934, 0xc935, 0xc950, 0xc951, 0xc96c, 0xc96d, 0xc988, 0xc989, 0xc9a4, 0xc9a5, 0xc9c0, 0xc9c1, 0xc9dc, 0xc9dd,
+        0xc9f8, 0xc9f9, 0xca14, 0xca15, 0xca30, 0xca31, 0xca4c, 0xca4d, 0xca68, 0xca69, 0xca84, 0xca85, 0xcaa0, 0xcaa1,
+        0xcabc, 0xcabd, 0xcad8, 0xcad9, 0xcaf4, 0xcaf5, 0xcb10, 0xcb11, 0xcb2c, 0xcb2d, 0xcb48, 0xcb49, 0xcb64, 0xcb65,
+        0xcb80, 0xcb81, 0xcb9c, 0xcb9d, 0xcbb8, 0xcbb9, 0xcbd4, 0xcbd5, 0xcbf0, 0xcbf1, 0xcc0c, 0xcc0d, 0xcc28, 0xcc29,
+        0xcc44, 0xcc45, 0xcc60, 0xcc61, 0xcc7c, 0xcc7d, 0xcc98, 0xcc99, 0xccb4, 0xccb5, 0xccd0, 0xccd1, 0xccec, 0xcced,
+        0xcd08, 0xcd09, 0xcd24, 0xcd25, 0xcd40, 0xcd41, 0xcd5c, 0xcd5d, 0xcd78, 0xcd79, 0xcd94, 0xcd95, 0xcdb0, 0xcdb1,
+        0xcdcc, 0xcdcd, 0xcde8, 0xcde9, 0xce04, 0xce05, 0xce20, 0xce21, 0xce3c, 0xce3d, 0xce58, 0xce59, 0xce74, 0xce75,
+        0xce90, 0xce91, 0xceac, 0xcead, 0xcec8, 0xcec9, 0xcee4, 0xcee5, 0xcf00, 0xcf01, 0xcf1c, 0xcf1d, 0xcf38, 0xcf39,
+        0xcf54, 0xcf55, 0xcf70, 0xcf71, 0xcf8c, 0xcf8d, 0xcfa8, 0xcfa9, 0xcfc4, 0xcfc5, 0xcfe0, 0xcfe1, 0xcffc, 0xcffd,
+        0xd018, 0xd019, 0xd034, 0xd035, 0xd050, 0xd051, 0xd06c, 0xd06d, 0xd088, 0xd089, 0xd0a4, 0xd0a5, 0xd0c0, 0xd0c1,
+        0xd0dc, 0xd0dd, 0xd0f8, 0xd0f9, 0xd114, 0xd115, 0xd130, 0xd131, 0xd14c, 0xd14d, 0xd168, 0xd169, 0xd184, 0xd185,
+        0xd1a0, 0xd1a1, 0xd1bc, 0xd1bd, 0xd1d8, 0xd1d9, 0xd1f4, 0xd1f5, 0xd210, 0xd211, 0xd22c, 0xd22d, 0xd248, 0xd249,
+        0xd264, 0xd265, 0xd280, 0xd281, 0xd29c, 0xd29d, 0xd2b8, 0xd2b9, 0xd2d4, 0xd2d5, 0xd2f0, 0xd2f1, 0xd30c, 0xd30d,
+        0xd328, 0xd329, 0xd344, 0xd345, 0xd360, 0xd361, 0xd37c, 0xd37d, 0xd398, 0xd399, 0xd3b4, 0xd3b5, 0xd3d0, 0xd3d1,
+        0xd3ec, 0xd3ed, 0xd408, 0xd409, 0xd424, 0xd425, 0xd440, 0xd441, 0xd45c, 0xd45d, 0xd478, 0xd479, 0xd494, 0xd495,
+        0xd4b0, 0xd4b1, 0xd4cc, 0xd4cd, 0xd4e8, 0xd4e9, 0xd504, 0xd505, 0xd520, 0xd521, 0xd53c, 0xd53d, 0xd558, 0xd559,
+        0xd574, 0xd575, 0xd590, 0xd591, 0xd5ac, 0xd5ad, 0xd5c8, 0xd5c9, 0xd5e4, 0xd5e5, 0xd600, 0xd601, 0xd61c, 0xd61d,
+        0xd638, 0xd639, 0xd654, 0xd655, 0xd670, 0xd671, 0xd68c, 0xd68d, 0xd6a8, 0xd6a9, 0xd6c4, 0xd6c5, 0xd6e0, 0xd6e1,
+        0xd6fc, 0xd6fd, 0xd718, 0xd719, 0xd734, 0xd735, 0xd750, 0xd751, 0xd76c, 0xd76d, 0xd788, 0xd789, 0xd7b0, 0xd7cb,
+        0xfb1e, 0xfe00, 0xfe20, 0xfeff, 0xff9e, 0xfff0, 0x101fd, 0x102e0, 0x10376, 0x10a01, 0x10a05, 0x10a0c, 0x10a38,
+        0x10a3f, 0x10ae5, 0x10d24, 0x10d69, 0x10eab, 0x10efa, 0x10f46, 0x10f82, 0x11000, 0x11001, 0x11002, 0x11038,
+        0x11070, 0x11073, 0x1107f, 0x11082, 0x110b0, 0x110b3, 0x110b7, 0x110b9, 0x110bd, 0x110c2, 0x110cd, 0x11100,
+        0x11127, 0x1112c, 0x1112d, 0x11145, 0x11173, 0x11180, 0x11182, 0x111b3, 0x111b6, 0x111bf, 0x111c0, 0x111c2,
+        0x111c9, 0x111ce, 0x111cf, 0x1122c, 0x1122f, 0x11232, 0x11234, 0x1123e, 0x11241, 0x112df, 0x112e0, 0x112e3,
+        0x11300, 0x11302, 0x1133b, 0x1133e, 0x1133f, 0x11340, 0x11341, 0x11347, 0x1134b, 0x1134d, 0x11357, 0x11362,
+        0x11366, 0x11370, 0x113b8, 0x113b9, 0x113bb, 0x113c2, 0x113c5, 0x113c7, 0x113ca, 0x113cc, 0x113ce, 0x113d1,
+        0x113d2, 0x113e1, 0x11435, 0x11438, 0x11440, 0x11442, 0x11445, 0x11446, 0x1145e, 0x114b0, 0x114b1, 0x114b3,
+        0x114b9, 0x114ba, 0x114bb, 0x114bd, 0x114be, 0x114bf, 0x114c1, 0x114c2, 0x115af, 0x115b0, 0x115b2, 0x115b8,
+        0x115bc, 0x115be, 0x115bf, 0x115dc, 0x11630, 0x11633, 0x1163b, 0x1163d, 0x1163e, 0x1163f, 0x116ab, 0x116ac,
+        0x116ad, 0x116ae, 0x116b0, 0x1171d, 0x1171e, 0x1171f, 0x11722, 0x11726, 0x11727, 0x1182c, 0x1182f, 0x11838,
+        0x11839, 0x11930, 0x11931, 0x11937, 0x1193b, 0x1193f, 0x11940, 0x11941, 0x11942, 0x11943, 0x119d1, 0x119d4,
+        0x119da, 0x119dc, 0x119e0, 0x119e4, 0x11a01, 0x11a33, 0x11a39, 0x11a3b, 0x11a47, 0x11a51, 0x11a57, 0x11a59,
+        0x11a84, 0x11a8a, 0x11a97, 0x11a98, 0x11b60, 0x11b61, 0x11b62, 0x11b65, 0x11b66, 0x11b67, 0x11c2f, 0x11c30,
+        0x11c38, 0x11c3e, 0x11c3f, 0x11c92, 0x11ca9, 0x11caa, 0x11cb1, 0x11cb2, 0x11cb4, 0x11cb5, 0x11d31, 0x11d3a,
+        0x11d3c, 0x11d3f, 0x11d46, 0x11d47, 0x11d8a, 0x11d90, 0x11d93, 0x11d95, 0x11d96, 0x11d97, 0x11ef3, 0x11ef5,
+        0x11f00, 0x11f02, 0x11f03, 0x11f34, 0x11f36, 0x11f3e, 0x11f40, 0x11f5a, 0x13430, 0x13440, 0x13447, 0x1611e,
+        0x1612a, 0x1612d, 0x16af0, 0x16b30, 0x16d63, 0x16d67, 0x16f4f, 0x16f51, 0x16f8f, 0x16fe4, 0x16ff0, 0x1bc9d,
+        0x1bca0, 0x1cf00, 0x1cf30, 0x1d165, 0x1d16d, 0x1d173, 0x1d17b, 0x1d185, 0x1d1aa, 0x1d242, 0x1da00, 0x1da3b,
+        0x1da75, 0x1da84, 0x1da9b, 0x1daa1, 0x1e000, 0x1e008, 0x1e01b, 0x1e023, 0x1e026, 0x1e08f, 0x1e130, 0x1e2ae,
+        0x1e2ec, 0x1e4ec, 0x1e5ee, 0x1e6e3, 0x1e6e6, 0x1e6ee, 0x1e6f5, 0x1e8d0, 0x1e944, 0x1f1e6, 0x1f3fb, 0xe0000,
+        0xe0020, 0xe0080, 0xe0100, 0xe01f0},
+    {0x100a, 0x4001, 0x1002, 0x1, 0x1012, 0x1021, 0x1001, 0x2070, 0x2007, 0x202d, 0x2001, 0x2002, 0x2002, 0x2001,
+        0x7006, 0x200b, 0x1001, 0x2015, 0x2001, 0x2007, 0x7001, 0x2006, 0x2002, 0x2004, 0x7001, 0x2001, 0x201b, 0x200b,
+        0x2009, 0x2001, 0x2004, 0x2009, 0x2003, 0x2005, 0x2003, 0x7002, 0x2009, 0x2018, 0x7001, 0x2020, 0x9001, 0x2001,
+        0x9001, 0x2001, 0x9003, 0x2008, 0x9004, 0x2001, 0x9002, 0x2007, 0x2002, 0x2001, 0x9002, 0x2001, 0x2001, 0x9002,
+        0x2004, 0x9002, 0x9002, 0x2001, 0x2001, 0x2002, 0x2001, 0x2002, 0x9001, 0x2001, 0x9003, 0x2002, 0x2002, 0x2003,
+        0x2001, 0x2002, 0x2001, 0x2002, 0x9001, 0x2001, 0x9003, 0x2005, 0x2002, 0x9001, 0x9002, 0x2001, 0x2002, 0x2006,
+        0x2001, 0x9002, 0x2001, 0x2002, 0x9001, 0x2004, 0x9002, 0x9002, 0x2001, 0x2003, 0x2002, 0x2001, 0x2001, 0x9001,
+        0x2001, 0x9002, 0x9003, 0x9003, 0x2001, 0x2001, 0x2001, 0x9003, 0x2001, 0x2001, 0x2003, 0x9004, 0x2003, 0x2004,
+        0x2002, 0x2002, 0x2001, 0x9002, 0x2001, 0x9001, 0x2002, 0x9001, 0x2001, 0x9002, 0x2003, 0x2004, 0x2002, 0x2002,
+        0x9001, 0x2002, 0x9002, 0x2002, 0x2001, 0x9002, 0x2004, 0x9003, 0x9003, 0x2001, 0x7001, 0x2001, 0x2002, 0x2001,
+        0x9002, 0x2001, 0x2001, 0x9002, 0x2003, 0x2001, 0x9007, 0x2001, 0x9002, 0x2001, 0x9001, 0x2007, 0x2008, 0x2001,
+        0x9001, 0x2009, 0x2007, 0x2002, 0x2001, 0x2001, 0x2001, 0x9002, 0x200e, 0x9001, 0x2005, 0x2002, 0x200b, 0x2024,
+        0x2001, 0x2004, 0x9001, 0x2006, 0x2002, 0x9002, 0x2002, 0x9002, 0x2002, 0x2003, 0x2004, 0x2001, 0x9001, 0x2002,
+        0x2001, 0x2001, 0x3060, 0xb048, 0xa058, 0x2003, 0x2004, 0x2003, 0x2002, 0x2002, 0x2002, 0x9001, 0x2007, 0x9008,
+        0x2001, 0x9002, 0x200b, 0x2001, 0x2003, 0x1001, 0x2001, 0x2002, 0x2001, 0x2003, 0x9004, 0x2002, 0x9003, 0x9002,
+        0x2001, 0x9006, 0x2003, 0x2002, 0x9002, 0x2001, 0x9001, 0x2001, 0x9001, 0x2007, 0x2001, 0x2001, 0x2008, 0x9006,
+        0x200a, 0x2001, 0x202e, 0x200c, 0x2004, 0x9001, 0x200a, 0x9004, 0x2003, 0x2009, 0x2002, 0x9001, 0x9001, 0x2004,
+        0x9002, 0x2006, 0x2001, 0x9001, 0x2002, 0x9003, 0x2001, 0x9001, 0x2005, 0x9008, 0x2008, 0x9002, 0x2002, 0x2003,
+        0x200d, 0x9001, 0x2007, 0x2001, 0x2001, 0x9001, 0x2002, 0x2040, 0x1001, 0x2001, 0xc001, 0x1002, 0x1007, 0x1010,
+        0x2021, 0x2003, 0x2001, 0x2020, 0x2006, 0x2002, 0x2004, 0x200a, 0x2002, 0x2002, 0x2001, 0x2001, 0x2001, 0x9002,
+        0x2002, 0x9001, 0x2001, 0x9002, 0x9010, 0x2002, 0x2012, 0x2001, 0x2008, 0x200b, 0x9001, 0x2001, 0x301d, 0x2003,
+        0x9001, 0x2001, 0x9002, 0x2004, 0x9002, 0x2002, 0x9002, 0x2001, 0x2001, 0x2006, 0x9002, 0x2002, 0x9002, 0x2002,
+        0x2001, 0x2001, 0x9001, 0x2001, 0x2001, 0x2003, 0x2002, 0x2002, 0x2001, 0x9001, 0x2002, 0x9002, 0x9001, 0x2001,
+        0x9002, 0x2001, 0x9002, 0x2001, 0x9002, 0x9001, 0x2001, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001,
+        0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0x5001, 0x601b, 0xb017, 0xa031, 0x2001, 0x2010, 0x2010, 0x1001, 0x2002,
+        0x100c, 0x2001, 0x2001, 0x2005, 0x2003, 0x2002, 0x2004, 0x2003, 0x2001, 0x2002, 0x2004, 0x2005, 0x2002, 0x2006,
+        0x200b, 0x2004, 0x9001, 0x2001, 0x9001, 0x200f, 0x2001, 0x2002, 0x2003, 0x9001, 0x9003, 0x2004, 0x9002, 0x2002,
+        0x7001, 0x2001, 0x7001, 0x2003, 0x2005, 0x9001, 0x2008, 0x9002, 0x2001, 0x2002, 0x9001, 0x9003, 0x2009, 0x9001,
+        0x2001, 0x7002, 0x2004, 0x9001, 0x2001, 0x9003, 0x2003, 0x9002, 0x2004, 0x2001, 0x2001, 0x2001, 0x9003, 0x2008,
+        0x2002, 0x9002, 0x2002, 0x2001, 0x9001, 0x2001, 0x9004, 0x9002, 0x9002, 0x2001, 0x2001, 0x9002, 0x2007, 0x2005,
+        0x2001, 0x9002, 0x2006, 0x2001, 0x2001, 0x2003, 0x9001, 0x9002, 0x2003, 0x7001, 0x2001, 0x2002, 0x9003, 0x2008,
+        0x9002, 0x2003, 0x9001, 0x2001, 0x2001, 0x2001, 0x9002, 0x2006, 0x9001, 0x2001, 0x9002, 0x2001, 0x9001, 0x2002,
+        0x9001, 0x2002, 0x2001, 0x9002, 0x2004, 0x9004, 0x2002, 0x9001, 0x2002, 0x2002, 0x9003, 0x2008, 0x9002, 0x2001,
+        0x9001, 0x2002, 0x2001, 0x9001, 0x2001, 0x9002, 0x2008, 0x2001, 0x9001, 0x2001, 0x2004, 0x9001, 0x2005, 0x9003,
+        0x2009, 0x9001, 0x2002, 0x2001, 0x9005, 0x9002, 0x2004, 0x7001, 0x9001, 0x7001, 0x9001, 0x2001, 0x9003, 0x2004,
+        0x2002, 0x9004, 0x2001, 0x9001, 0x200a, 0x2006, 0x9001, 0x2004, 0x2001, 0x2006, 0x9002, 0x2003, 0x7006, 0x200d,
+        0x9001, 0x2002, 0x2001, 0x9001, 0x2003, 0x9001, 0x2001, 0x9001, 0x9001, 0x2007, 0x2006, 0x9001, 0x2001, 0x2016,
+        0x9001, 0x2007, 0x9001, 0x2002, 0x9001, 0x2002, 0x2006, 0x2001, 0x2002, 0x2007, 0x7001, 0x2001, 0x9005, 0x2002,
+        0x9002, 0x2001, 0x9001, 0x2001, 0x2002, 0x9002, 0x2002, 0x7001, 0x9001, 0x9002, 0x2005, 0x9002, 0x2003, 0x2001,
+        0x1010, 0x2001, 0x200f, 0x200c, 0x9003, 0x2003, 0x2005, 0x2007, 0xb001, 0xb004, 0x2001, 0x9037, 0x2004, 0x2001,
+        0x2002, 0x2002, 0x1004, 0x202e, 0x2017, 0x2005, 0x2006, 0x1008, 0x2008, 0x2007, 0x2004, 0x2003, 0x2037, 0x2032,
+        0x2001, 0x2001, 0x2005, 0x200f, 0x2007, 0x2011, 0x2007, 0x2002, 0x2005, 0x2001, 0x2007, 0x2001, 0x2004, 0x2004,
+        0x2002, 0x2001, 0x2001, 0x2002, 0x2001, 0x2007, 0x2007, 0x801a, 0x2005, 0x1020, 0x2060, 0x1080, 0x20f0,
+        0x1e10}};
+
+// DerivedCoreProperties-17.0.0.txt
+// Date: 2025-07-30, 23:55:08 GMT
+enum class _Indic_Conjunct_Break_property_values : uint8_t {
+    _Consonant_value,
+    _Extend_value,
+    _Linker_value,
+    _No_value = 255
+};
+
+// DerivedCoreProperties-17.0.0.txt
+// Date: 2025-07-30, 23:55:08 GMT
+inline constexpr _Unicode_property_data<_Indic_Conjunct_Break_property_values, 473, false>
+    _Indic_Conjunct_Break_property_data{
+        {0x300, 0x483, 0x591, 0x5bf, 0x5c1, 0x5c4, 0x5c7, 0x610, 0x64b, 0x670, 0x6d6, 0x6df, 0x6e7, 0x6ea, 0x711, 0x730,
+            0x7a6, 0x7eb, 0x7fd, 0x816, 0x81b, 0x825, 0x829, 0x859, 0x897, 0x8ca, 0x8e3, 0x915, 0x93a, 0x93c, 0x941,
+            0x94d, 0x951, 0x958, 0x962, 0x978, 0x981, 0x995, 0x9aa, 0x9b2, 0x9b6, 0x9bc, 0x9be, 0x9c1, 0x9cd, 0x9d7,
+            0x9dc, 0x9df, 0x9e2, 0x9f0, 0x9fe, 0xa01, 0xa3c, 0xa41, 0xa47, 0xa4b, 0xa51, 0xa70, 0xa75, 0xa81, 0xa95,
+            0xaaa, 0xab2, 0xab5, 0xabc, 0xac1, 0xac7, 0xacd, 0xae2, 0xaf9, 0xafa, 0xb01, 0xb15, 0xb2a, 0xb32, 0xb35,
+            0xb3c, 0xb3e, 0xb41, 0xb4d, 0xb55, 0xb5c, 0xb5f, 0xb62, 0xb71, 0xb82, 0xbbe, 0xbc0, 0xbcd, 0xbd7, 0xc00,
+            0xc04, 0xc15, 0xc2a, 0xc3c, 0xc3e, 0xc46, 0xc4a, 0xc4d, 0xc55, 0xc58, 0xc62, 0xc81, 0xcbc, 0xcbf, 0xcc2,
+            0xcc6, 0xcca, 0xcd5, 0xce2, 0xd00, 0xd15, 0xd3b, 0xd3e, 0xd41, 0xd4d, 0xd57, 0xd62, 0xd81, 0xdca, 0xdcf,
+            0xdd2, 0xdd6, 0xddf, 0xe31, 0xe34, 0xe47, 0xeb1, 0xeb4, 0xec8, 0xf18, 0xf35, 0xf37, 0xf39, 0xf71, 0xf80,
+            0xf86, 0xf8d, 0xf99, 0xfc6, 0x1000, 0x102d, 0x1032, 0x1039, 0x103a, 0x103d, 0x103f, 0x1050, 0x1058, 0x105a,
+            0x105e, 0x1061, 0x1065, 0x106e, 0x1071, 0x1075, 0x1082, 0x1085, 0x108d, 0x108e, 0x109d, 0x135d, 0x1712,
+            0x1732, 0x1752, 0x1772, 0x1780, 0x17b4, 0x17b7, 0x17c6, 0x17c9, 0x17d2, 0x17d3, 0x17dd, 0x180b, 0x180f,
+            0x1885, 0x18a9, 0x1920, 0x1927, 0x1932, 0x1939, 0x1a17, 0x1a1b, 0x1a20, 0x1a56, 0x1a58, 0x1a60, 0x1a62,
+            0x1a65, 0x1a73, 0x1a7f, 0x1ab0, 0x1ae0, 0x1b00, 0x1b0b, 0x1b13, 0x1b34, 0x1b42, 0x1b44, 0x1b45, 0x1b6b,
+            0x1b80, 0x1b83, 0x1ba2, 0x1ba8, 0x1bab, 0x1bac, 0x1bae, 0x1bbb, 0x1be6, 0x1be8, 0x1bed, 0x1bef, 0x1c2c,
+            0x1c36, 0x1cd0, 0x1cd4, 0x1ce2, 0x1ced, 0x1cf4, 0x1cf8, 0x1dc0, 0x200d, 0x20d0, 0x2cef, 0x2d7f, 0x2de0,
+            0x302a, 0x3099, 0xa66f, 0xa674, 0xa69e, 0xa6f0, 0xa802, 0xa806, 0xa80b, 0xa825, 0xa82c, 0xa8c4, 0xa8e0,
+            0xa8ff, 0xa926, 0xa947, 0xa953, 0xa980, 0xa989, 0xa98f, 0xa9b3, 0xa9b6, 0xa9bc, 0xa9c0, 0xa9e0, 0xa9e5,
+            0xa9e7, 0xa9fa, 0xaa29, 0xaa31, 0xaa35, 0xaa43, 0xaa4c, 0xaa60, 0xaa71, 0xaa7a, 0xaa7c, 0xaa7e, 0xaab0,
+            0xaab2, 0xaab7, 0xaabe, 0xaac1, 0xaae0, 0xaaec, 0xaaf6, 0xabc0, 0xabe5, 0xabe8, 0xabed, 0xfb1e, 0xfe00,
+            0xfe20, 0xff9e, 0x101fd, 0x102e0, 0x10376, 0x10a00, 0x10a01, 0x10a05, 0x10a0c, 0x10a10, 0x10a15, 0x10a19,
+            0x10a38, 0x10a3f, 0x10ae5, 0x10d24, 0x10d69, 0x10eab, 0x10efa, 0x10f46, 0x10f82, 0x11001, 0x11038, 0x11070,
+            0x11073, 0x1107f, 0x110b3, 0x110b9, 0x110c2, 0x11100, 0x11103, 0x11127, 0x1112d, 0x11133, 0x11134, 0x11144,
+            0x11147, 0x11173, 0x11180, 0x111b6, 0x111c0, 0x111c9, 0x111cf, 0x1122f, 0x11234, 0x1123e, 0x11241, 0x112df,
+            0x112e3, 0x11300, 0x1133b, 0x1133e, 0x11340, 0x1134d, 0x11357, 0x11366, 0x11370, 0x11380, 0x1138b, 0x1138e,
+            0x11390, 0x113b8, 0x113bb, 0x113c2, 0x113c5, 0x113c7, 0x113ce, 0x113d0, 0x113d2, 0x113e1, 0x11438, 0x11442,
+            0x11446, 0x1145e, 0x114b0, 0x114b3, 0x114ba, 0x114bd, 0x114bf, 0x114c2, 0x115af, 0x115b2, 0x115bc, 0x115bf,
+            0x115dc, 0x11633, 0x1163d, 0x1163f, 0x116ab, 0x116ad, 0x116b0, 0x1171d, 0x1171f, 0x11722, 0x11727, 0x1182f,
+            0x11839, 0x11900, 0x11909, 0x1190c, 0x11915, 0x11918, 0x11930, 0x1193b, 0x1193e, 0x11943, 0x119d4, 0x119da,
+            0x119e0, 0x11a00, 0x11a01, 0x11a0b, 0x11a33, 0x11a3b, 0x11a47, 0x11a50, 0x11a51, 0x11a59, 0x11a5c, 0x11a8a,
+            0x11a98, 0x11a99, 0x11b60, 0x11b62, 0x11b66, 0x11c30, 0x11c38, 0x11c3f, 0x11c92, 0x11caa, 0x11cb2, 0x11cb5,
+            0x11d31, 0x11d3a, 0x11d3c, 0x11d3f, 0x11d47, 0x11d90, 0x11d95, 0x11d97, 0x11ef3, 0x11f00, 0x11f04, 0x11f12,
+            0x11f36, 0x11f40, 0x11f42, 0x11f5a, 0x13440, 0x13447, 0x1611e, 0x1612d, 0x16af0, 0x16b30, 0x16f4f, 0x16f8f,
+            0x16fe4, 0x16ff0, 0x1bc9d, 0x1cf00, 0x1cf30, 0x1d165, 0x1d16d, 0x1d17b, 0x1d185, 0x1d1aa, 0x1d242, 0x1da00,
+            0x1da3b, 0x1da75, 0x1da84, 0x1da9b, 0x1daa1, 0x1e000, 0x1e008, 0x1e01b, 0x1e023, 0x1e026, 0x1e08f, 0x1e130,
+            0x1e2ae, 0x1e2ec, 0x1e4ec, 0x1e5ee, 0x1e6e3, 0x1e6e6, 0x1e6ee, 0x1e6f5, 0x1e8d0, 0x1e944, 0x1f3fb, 0xe0020,
+            0xe0100},
+        {0x1070, 0x1007, 0x102d, 0x1001, 0x1002, 0x1002, 0x1001, 0x100b, 0x1015, 0x1001, 0x1007, 0x1006, 0x1002, 0x1004,
+            0x1001, 0x101b, 0x100b, 0x1009, 0x1001, 0x1004, 0x1009, 0x1003, 0x1005, 0x1003, 0x1009, 0x1018, 0x1020,
+            0x25, 0x1001, 0x1001, 0x1008, 0x2001, 0x1007, 0x8, 0x1002, 0x8, 0x1001, 0x14, 0x7, 0x1, 0x4, 0x1001, 0x1001,
+            0x1004, 0x2001, 0x1001, 0x2, 0x1, 0x1002, 0x2, 0x1001, 0x1002, 0x1001, 0x1002, 0x1002, 0x1003, 0x1001,
+            0x1002, 0x1001, 0x1002, 0x14, 0x7, 0x2, 0x5, 0x1001, 0x1005, 0x1002, 0x2001, 0x1002, 0x1, 0x1006, 0x1001,
+            0x14, 0x7, 0x2, 0x5, 0x1001, 0x1002, 0x1004, 0x2001, 0x1003, 0x2, 0x1, 0x1002, 0x1, 0x1001, 0x1001, 0x1001,
+            0x1001, 0x1001, 0x1001, 0x1001, 0x14, 0x10, 0x1001, 0x1003, 0x1003, 0x1003, 0x2001, 0x1002, 0x3, 0x1002,
+            0x1001, 0x1001, 0x1002, 0x1001, 0x1003, 0x1004, 0x1002, 0x1002, 0x1002, 0x26, 0x1002, 0x1001, 0x1004,
+            0x2001, 0x1001, 0x1002, 0x1001, 0x1001, 0x1001, 0x1003, 0x1001, 0x1001, 0x1001, 0x1007, 0x1008, 0x1001,
+            0x1009, 0x1007, 0x1002, 0x1001, 0x1001, 0x1001, 0x100e, 0x1005, 0x1002, 0x100b, 0x1024, 0x1001, 0x2b,
+            0x1004, 0x1006, 0x2001, 0x1001, 0x1002, 0x1, 0x6, 0x1002, 0x4, 0x1003, 0x1, 0x2, 0x3, 0x1004, 0xd, 0x1001,
+            0x1002, 0x1001, 0x1, 0x1001, 0x1003, 0x1004, 0x1003, 0x1002, 0x1002, 0x34, 0x1002, 0x1007, 0x1001, 0x1009,
+            0x2001, 0x1001, 0x1001, 0x1003, 0x1001, 0x1002, 0x1001, 0x1003, 0x1002, 0x1001, 0x1003, 0x1002, 0x1001,
+            0x35, 0x1001, 0x1007, 0x2001, 0x1001, 0x1008, 0x100a, 0x1001, 0x102e, 0x100c, 0x1004, 0x2, 0x21, 0x100a,
+            0x1002, 0x2001, 0x8, 0x1009, 0x1002, 0x1e, 0x1004, 0x1003, 0x2001, 0x1002, 0x2, 0x3, 0x1001, 0x1002, 0x1001,
+            0x1005, 0x1008, 0x1002, 0x1003, 0x100d, 0x1007, 0x1001, 0x1001, 0x1002, 0x1040, 0x1001, 0x1021, 0x1003,
+            0x1001, 0x1020, 0x1006, 0x1002, 0x1004, 0x100a, 0x1002, 0x1002, 0x1001, 0x1001, 0x1001, 0x1002, 0x1001,
+            0x1002, 0x1012, 0x1001, 0x1008, 0x100b, 0x1001, 0x1003, 0x3, 0x24, 0x1001, 0x1004, 0x1002, 0x2001, 0x5,
+            0x1001, 0x9, 0x5, 0x1006, 0x1002, 0x1002, 0x1001, 0x1001, 0x10, 0x3, 0x1, 0x1001, 0x2, 0x1001, 0x1003,
+            0x1002, 0x1002, 0x1001, 0xb, 0x1002, 0x2001, 0x1b, 0x1001, 0x1001, 0x1001, 0x1001, 0x1010, 0x1010, 0x1002,
+            0x1001, 0x1001, 0x1005, 0x1, 0x1003, 0x1002, 0x1004, 0x4, 0x3, 0x1d, 0x1003, 0x2001, 0x1002, 0x1004, 0x1005,
+            0x1002, 0x1006, 0x100b, 0x1004, 0x1001, 0x100f, 0x1001, 0x1002, 0x1003, 0x1004, 0x1002, 0x1001, 0x1003,
+            0x24, 0x1005, 0x1006, 0x2001, 0x1001, 0x1, 0x1, 0x1001, 0x1002, 0x1009, 0x1001, 0x1004, 0x1001, 0x1003,
+            0x1004, 0x1001, 0x1001, 0x1001, 0x1008, 0x1002, 0x1002, 0x1001, 0x1001, 0x1001, 0x1001, 0x1007, 0x1005, 0xa,
+            0x1, 0x1, 0x26, 0x1001, 0x1006, 0x1001, 0x1001, 0x1003, 0x1002, 0x2001, 0x1001, 0x1002, 0x1008, 0x1003,
+            0x1001, 0x1001, 0x1001, 0x1006, 0x1001, 0x1001, 0x1002, 0x1002, 0x1001, 0x1004, 0x1002, 0x1002, 0x1002,
+            0x1008, 0x1001, 0x1002, 0x1001, 0x1001, 0x1008, 0x1001, 0x1001, 0x1004, 0x1005, 0x1009, 0x1002, 0x7, 0x1,
+            0x8, 0x2, 0x18, 0x1001, 0x1003, 0x2001, 0x1001, 0x1004, 0x1002, 0x1001, 0x1, 0x100a, 0x28, 0x1006, 0x1004,
+            0x2001, 0x1, 0x1006, 0x1003, 0x28, 0x100d, 0x1001, 0x2001, 0x1001, 0x1003, 0x1001, 0x1007, 0x1006, 0x1001,
+            0x1016, 0x1007, 0x1002, 0x1002, 0x1006, 0x1001, 0x1002, 0x1007, 0x1001, 0x1002, 0x1001, 0x1001, 0x1002,
+            0x1002, 0xd, 0x22, 0x1005, 0x1002, 0x2001, 0x1001, 0x1001, 0x100f, 0x100c, 0x1003, 0x1005, 0x1007, 0x1001,
+            0x1004, 0x1001, 0x1002, 0x1002, 0x102e, 0x1017, 0x1005, 0x1006, 0x1008, 0x1007, 0x1004, 0x1003, 0x1037,
+            0x1032, 0x1001, 0x1001, 0x1005, 0x100f, 0x1007, 0x1011, 0x1007, 0x1002, 0x1005, 0x1001, 0x1007, 0x1001,
+            0x1004, 0x1004, 0x1002, 0x1001, 0x1001, 0x1002, 0x1001, 0x1007, 0x1007, 0x1005, 0x1060, 0x10f0}};
+
+// emoji-data.txt
+// Date: 2025-07-25, 17:54:31 GMT
+enum class _Extended_Pictographic_property_values : uint8_t { _Extended_Pictographic_value, _No_value = 255 };
+
+// emoji-data.txt
+// Date: 2025-07-25, 17:54:31 GMT
+inline constexpr _Unicode_property_data<_Extended_Pictographic_property_values, 156, true>
+    _Extended_Pictographic_property_data{
+        {0xa9, 0xae, 0x203c, 0x2049, 0x2122, 0x2139, 0x2194, 0x21a9, 0x231a, 0x2328, 0x23cf, 0x23e9, 0x23f8, 0x24c2,
+            0x25aa, 0x25b6, 0x25c0, 0x25fb, 0x2600, 0x260e, 0x2611, 0x2614, 0x2618, 0x261d, 0x2620, 0x2622, 0x2626,
+            0x262a, 0x262e, 0x2638, 0x2640, 0x2642, 0x2648, 0x265f, 0x2663, 0x2665, 0x2668, 0x267b, 0x267e, 0x2692,
+            0x2699, 0x269b, 0x26a0, 0x26a7, 0x26aa, 0x26b0, 0x26bd, 0x26c4, 0x26c8, 0x26ce, 0x26d1, 0x26d3, 0x26e9,
+            0x26f0, 0x26f7, 0x26fd, 0x2702, 0x2705, 0x2708, 0x270f, 0x2712, 0x2714, 0x2716, 0x271d, 0x2721, 0x2728,
+            0x2733, 0x2744, 0x2747, 0x274c, 0x274e, 0x2753, 0x2757, 0x2763, 0x2795, 0x27a1, 0x27b0, 0x27bf, 0x2934,
+            0x2b05, 0x2b1b, 0x2b50, 0x2b55, 0x3030, 0x303d, 0x3297, 0x3299, 0x1f004, 0x1f02c, 0x1f094, 0x1f0af, 0x1f0c0,
+            0x1f0cf, 0x1f0f6, 0x1f170, 0x1f17e, 0x1f18e, 0x1f191, 0x1f1ae, 0x1f201, 0x1f21a, 0x1f22f, 0x1f232, 0x1f23c,
+            0x1f249, 0x1f266, 0x1f324, 0x1f396, 0x1f399, 0x1f39e, 0x1f3f3, 0x1f3f7, 0x1f400, 0x1f4ff, 0x1f549, 0x1f550,
+            0x1f56f, 0x1f573, 0x1f587, 0x1f58a, 0x1f590, 0x1f595, 0x1f5a4, 0x1f5a8, 0x1f5b1, 0x1f5bc, 0x1f5c2, 0x1f5d1,
+            0x1f5dc, 0x1f5e1, 0x1f5e3, 0x1f5e8, 0x1f5ef, 0x1f5f3, 0x1f5fa, 0x1f680, 0x1f6cb, 0x1f6d5, 0x1f6e9, 0x1f6eb,
+            0x1f6f3, 0x1f7da, 0x1f80c, 0x1f848, 0x1f85a, 0x1f888, 0x1f8ae, 0x1f8bc, 0x1f8c2, 0x1f8d9, 0x1f90c, 0x1f93c,
+            0x1f947, 0x1fa58, 0x1fa6e, 0x1fc00},
+        {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x6, 0x2, 0x2, 0x1, 0x1, 0xb, 0x3, 0x1, 0x2, 0x1, 0x1, 0x4, 0x5, 0x1, 0x1, 0x2,
+            0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x3, 0x1, 0x1, 0xc, 0x2, 0x1, 0x2, 0x1, 0x1, 0x2, 0x6, 0x1, 0x2, 0x2,
+            0x1, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, 0x1, 0x2, 0x2, 0x6, 0x4, 0x1, 0x1, 0x1, 0x6, 0x1, 0x1, 0x1, 0x1, 0x1,
+            0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x3, 0x1, 0x2, 0x3, 0x1, 0x1, 0x1, 0x2, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1,
+            0x1, 0x1, 0x1, 0x4, 0xc, 0x2, 0x1, 0x2, 0xa, 0x2, 0x2, 0x1, 0xa, 0x38, 0xf, 0x1, 0x1, 0x9, 0x4, 0x17, 0xbc,
+            0x70, 0x2, 0x3, 0x53, 0x3, 0x4, 0xfe, 0x3f, 0x6, 0x18, 0x2, 0x8, 0x1, 0x4, 0x1, 0x2, 0x2, 0x1, 0x2, 0x1,
+            0x3, 0x3, 0x3, 0x1, 0x1, 0x1, 0x1, 0x1, 0x56, 0x46, 0x8, 0x11, 0x1, 0x6, 0xd, 0x26, 0x4, 0x8, 0x6, 0x8, 0x2,
+            0x4, 0xe, 0x27, 0x2f, 0xa, 0xb9, 0x8, 0x92, 0x3fe}};
+
+// DerivedGeneralCategory-17.0.0.txt
+// Date: 2025-07-24, 00:12:50 GMT
+enum class __printable_property_values : uint8_t { _Yes_value, _No_value = 255 };
+
+// DerivedGeneralCategory-17.0.0.txt
+// Date: 2025-07-24, 00:12:50 GMT
+inline constexpr _Unicode_property_data<__printable_property_values, 741, true> __printable_property_data{
+    {0x20, 0xa1, 0xae, 0x37a, 0x384, 0x38c, 0x38e, 0x3a3, 0x531, 0x559, 0x58d, 0x591, 0x5d0, 0x5ef, 0x606, 0x61d, 0x6de,
+        0x710, 0x74d, 0x7c0, 0x7fd, 0x830, 0x840, 0x85e, 0x860, 0x870, 0x897, 0x8e3, 0x985, 0x98f, 0x993, 0x9aa, 0x9b2,
+        0x9b6, 0x9bc, 0x9c7, 0x9cb, 0x9d7, 0x9dc, 0x9df, 0x9e6, 0xa01, 0xa05, 0xa0f, 0xa13, 0xa2a, 0xa32, 0xa35, 0xa38,
+        0xa3c, 0xa3e, 0xa47, 0xa4b, 0xa51, 0xa59, 0xa5e, 0xa66, 0xa81, 0xa85, 0xa8f, 0xa93, 0xaaa, 0xab2, 0xab5, 0xabc,
+        0xac7, 0xacb, 0xad0, 0xae0, 0xae6, 0xaf9, 0xb01, 0xb05, 0xb0f, 0xb13, 0xb2a, 0xb32, 0xb35, 0xb3c, 0xb47, 0xb4b,
+        0xb55, 0xb5c, 0xb5f, 0xb66, 0xb82, 0xb85, 0xb8e, 0xb92, 0xb99, 0xb9c, 0xb9e, 0xba3, 0xba8, 0xbae, 0xbbe, 0xbc6,
+        0xbca, 0xbd0, 0xbd7, 0xbe6, 0xc00, 0xc0e, 0xc12, 0xc2a, 0xc3c, 0xc46, 0xc4a, 0xc55, 0xc58, 0xc5c, 0xc60, 0xc66,
+        0xc77, 0xc8e, 0xc92, 0xcaa, 0xcb5, 0xcbc, 0xcc6, 0xcca, 0xcd5, 0xcdc, 0xce0, 0xce6, 0xcf1, 0xd00, 0xd0e, 0xd12,
+        0xd46, 0xd4a, 0xd54, 0xd66, 0xd81, 0xd85, 0xd9a, 0xdb3, 0xdbd, 0xdc0, 0xdca, 0xdcf, 0xdd6, 0xdd8, 0xde6, 0xdf2,
+        0xe01, 0xe3f, 0xe81, 0xe84, 0xe86, 0xe8c, 0xea5, 0xea7, 0xec0, 0xec6, 0xec8, 0xed0, 0xedc, 0xf00, 0xf49, 0xf71,
+        0xf99, 0xfbe, 0xfce, 0x1000, 0x10c7, 0x10cd, 0x10d0, 0x124a, 0x1250, 0x1258, 0x125a, 0x1260, 0x128a, 0x1290,
+        0x12b2, 0x12b8, 0x12c0, 0x12c2, 0x12c8, 0x12d8, 0x1312, 0x1318, 0x135d, 0x1380, 0x13a0, 0x13f8, 0x1400, 0x1681,
+        0x16a0, 0x1700, 0x171f, 0x1740, 0x1760, 0x176e, 0x1772, 0x1780, 0x17e0, 0x17f0, 0x1800, 0x180f, 0x1820, 0x1880,
+        0x18b0, 0x1900, 0x1920, 0x1930, 0x1940, 0x1944, 0x1970, 0x1980, 0x19b0, 0x19d0, 0x19de, 0x1a1e, 0x1a60, 0x1a7f,
+        0x1a90, 0x1aa0, 0x1ab0, 0x1ae0, 0x1b00, 0x1b4e, 0x1bfc, 0x1c3b, 0x1c4d, 0x1c90, 0x1cbd, 0x1cd0, 0x1d00, 0x1f18,
+        0x1f20, 0x1f48, 0x1f50, 0x1f59, 0x1f5b, 0x1f5d, 0x1f5f, 0x1f80, 0x1fb6, 0x1fc6, 0x1fd6, 0x1fdd, 0x1ff2, 0x1ff6,
+        0x2010, 0x2030, 0x2070, 0x2074, 0x2090, 0x20a0, 0x20d0, 0x2100, 0x2190, 0x2440, 0x2460, 0x2b76, 0x2cf9, 0x2d27,
+        0x2d2d, 0x2d30, 0x2d6f, 0x2d7f, 0x2da0, 0x2da8, 0x2db0, 0x2db8, 0x2dc0, 0x2dc8, 0x2dd0, 0x2dd8, 0x2de0, 0x2e80,
+        0x2e9b, 0x2f00, 0x2ff0, 0x3001, 0x3041, 0x3099, 0x3105, 0x3131, 0x3190, 0x31ef, 0x3220, 0xa490, 0xa4d0, 0xa640,
+        0xa700, 0xa7f1, 0xa830, 0xa840, 0xa880, 0xa8ce, 0xa8e0, 0xa95f, 0xa980, 0xa9cf, 0xa9de, 0xaa00, 0xaa40, 0xaa50,
+        0xaa5c, 0xaadb, 0xab01, 0xab09, 0xab11, 0xab20, 0xab28, 0xab30, 0xab70, 0xabf0, 0xac00, 0xd7b0, 0xd7cb, 0xf900,
+        0xfa70, 0xfb00, 0xfb13, 0xfb1d, 0xfb38, 0xfb3e, 0xfb40, 0xfb43, 0xfb46, 0xfdf0, 0xfe20, 0xfe54, 0xfe68, 0xfe70,
+        0xfe76, 0xff01, 0xffc2, 0xffca, 0xffd2, 0xffda, 0xffe0, 0xffe8, 0xfffc, 0x10000, 0x1000d, 0x10028, 0x1003c,
+        0x1003f, 0x10050, 0x10080, 0x10100, 0x10107, 0x10137, 0x10190, 0x101a0, 0x101d0, 0x10280, 0x102a0, 0x102e0,
+        0x10300, 0x1032d, 0x10350, 0x10380, 0x1039f, 0x103c8, 0x10400, 0x104a0, 0x104b0, 0x104d8, 0x10500, 0x10530,
+        0x1056f, 0x1057c, 0x1058c, 0x10594, 0x10597, 0x105a3, 0x105b3, 0x105bb, 0x105c0, 0x10600, 0x10740, 0x10760,
+        0x10780, 0x10787, 0x107b2, 0x10800, 0x10808, 0x1080a, 0x10837, 0x1083c, 0x1083f, 0x10857, 0x108a7, 0x108e0,
+        0x108f4, 0x108fb, 0x1091f, 0x1093f, 0x10980, 0x109bc, 0x109d2, 0x10a05, 0x10a0c, 0x10a15, 0x10a19, 0x10a38,
+        0x10a3f, 0x10a50, 0x10a60, 0x10ac0, 0x10aeb, 0x10b00, 0x10b39, 0x10b58, 0x10b78, 0x10b99, 0x10ba9, 0x10c00,
+        0x10c80, 0x10cc0, 0x10cfa, 0x10d30, 0x10d40, 0x10d69, 0x10d8e, 0x10e60, 0x10e80, 0x10eab, 0x10eb0, 0x10ec2,
+        0x10ed0, 0x10efa, 0x10f30, 0x10f70, 0x10fb0, 0x10fe0, 0x11000, 0x11052, 0x1107f, 0x110be, 0x110d0, 0x110f0,
+        0x11100, 0x11136, 0x11150, 0x11180, 0x111e1, 0x11200, 0x11213, 0x11280, 0x11288, 0x1128a, 0x1128f, 0x1129f,
+        0x112b0, 0x112f0, 0x11300, 0x11305, 0x1130f, 0x11313, 0x1132a, 0x11332, 0x11335, 0x1133b, 0x11347, 0x1134b,
+        0x11350, 0x11357, 0x1135d, 0x11366, 0x11370, 0x11380, 0x1138b, 0x1138e, 0x11390, 0x113b7, 0x113c2, 0x113c5,
+        0x113c7, 0x113cc, 0x113d7, 0x113e1, 0x11400, 0x1145d, 0x11480, 0x114d0, 0x11580, 0x115b8, 0x11600, 0x11650,
+        0x11660, 0x11680, 0x116c0, 0x116d0, 0x11700, 0x1171d, 0x11730, 0x11800, 0x118a0, 0x118ff, 0x11909, 0x1190c,
+        0x11915, 0x11918, 0x11937, 0x1193b, 0x11950, 0x119a0, 0x119aa, 0x119da, 0x11a00, 0x11a50, 0x11ab0, 0x11b00,
+        0x11b60, 0x11bc0, 0x11bf0, 0x11c00, 0x11c0a, 0x11c38, 0x11c50, 0x11c70, 0x11c92, 0x11ca9, 0x11d00, 0x11d08,
+        0x11d0b, 0x11d3a, 0x11d3c, 0x11d3f, 0x11d50, 0x11d60, 0x11d67, 0x11d6a, 0x11d90, 0x11d93, 0x11da0, 0x11db0,
+        0x11de0, 0x11ee0, 0x11f00, 0x11f12, 0x11f3e, 0x11fb0, 0x11fc0, 0x11fff, 0x12400, 0x12470, 0x12480, 0x12f90,
+        0x13000, 0x13440, 0x13460, 0x14400, 0x16100, 0x16800, 0x16a40, 0x16a60, 0x16a6e, 0x16ac0, 0x16ad0, 0x16af0,
+        0x16b00, 0x16b50, 0x16b5b, 0x16b63, 0x16b7d, 0x16d40, 0x16e40, 0x16ea0, 0x16ebb, 0x16f00, 0x16f4f, 0x16f8f,
+        0x16fe0, 0x16ff0, 0x17000, 0x18cff, 0x18d80, 0x1aff0, 0x1aff5, 0x1affd, 0x1b000, 0x1b132, 0x1b150, 0x1b155,
+        0x1b164, 0x1b170, 0x1bc00, 0x1bc70, 0x1bc80, 0x1bc90, 0x1bc9c, 0x1cc00, 0x1cd00, 0x1ceba, 0x1cee0, 0x1cf00,
+        0x1cf30, 0x1cf50, 0x1d000, 0x1d100, 0x1d129, 0x1d17b, 0x1d200, 0x1d2c0, 0x1d2e0, 0x1d300, 0x1d360, 0x1d400,
+        0x1d456, 0x1d49e, 0x1d4a2, 0x1d4a5, 0x1d4a9, 0x1d4ae, 0x1d4bb, 0x1d4bd, 0x1d4c5, 0x1d507, 0x1d50d, 0x1d516,
+        0x1d51e, 0x1d53b, 0x1d540, 0x1d546, 0x1d54a, 0x1d552, 0x1d6a8, 0x1d7ce, 0x1da9b, 0x1daa1, 0x1df00, 0x1df25,
+        0x1e000, 0x1e008, 0x1e01b, 0x1e023, 0x1e026, 0x1e030, 0x1e08f, 0x1e100, 0x1e130, 0x1e140, 0x1e14e, 0x1e290,
+        0x1e2c0, 0x1e2ff, 0x1e4d0, 0x1e5d0, 0x1e5ff, 0x1e6c0, 0x1e6e0, 0x1e6fe, 0x1e7e0, 0x1e7e8, 0x1e7ed, 0x1e7f0,
+        0x1e800, 0x1e8c7, 0x1e900, 0x1e950, 0x1e95e, 0x1ec71, 0x1ed01, 0x1ee00, 0x1ee05, 0x1ee21, 0x1ee24, 0x1ee27,
+        0x1ee29, 0x1ee34, 0x1ee39, 0x1ee3b, 0x1ee42, 0x1ee47, 0x1ee49, 0x1ee4b, 0x1ee4d, 0x1ee51, 0x1ee54, 0x1ee57,
+        0x1ee59, 0x1ee5b, 0x1ee5d, 0x1ee5f, 0x1ee61, 0x1ee64, 0x1ee67, 0x1ee6c, 0x1ee74, 0x1ee79, 0x1ee7e, 0x1ee80,
+        0x1ee8b, 0x1eea1, 0x1eea5, 0x1eeab, 0x1eef0, 0x1f000, 0x1f030, 0x1f0a0, 0x1f0b1, 0x1f0c1, 0x1f0d1, 0x1f100,
+        0x1f1e6, 0x1f210, 0x1f240, 0x1f250, 0x1f260, 0x1f300, 0x1f6dc, 0x1f6f0, 0x1f700, 0x1f7e0, 0x1f7f0, 0x1f800,
+        0x1f810, 0x1f850, 0x1f860, 0x1f890, 0x1f8b0, 0x1f8c0, 0x1f8d0, 0x1f900, 0x1fa60, 0x1fa70, 0x1fa80, 0x1fa8e,
+        0x1fac8, 0x1facd, 0x1fadf, 0x1faef, 0x1fb00, 0x1fb94, 0x20000, 0x2a700, 0x2b820, 0x2ceb0, 0x2ebf0, 0x2f800,
+        0x30000, 0x31350, 0xe0100},
+    {0x5f, 0xc, 0x2ca, 0x6, 0x7, 0x1, 0x14, 0x18d, 0x26, 0x32, 0x3, 0x37, 0x1b, 0x6, 0x16, 0xc0, 0x30, 0x3b, 0x65, 0x3b,
+        0x31, 0xf, 0x1c, 0x1, 0xb, 0x20, 0x4b, 0xa1, 0x8, 0x2, 0x16, 0x7, 0x1, 0x4, 0x9, 0x2, 0x4, 0x1, 0x2, 0x5, 0x19,
+        0x3, 0x6, 0x2, 0x16, 0x7, 0x2, 0x2, 0x2, 0x1, 0x5, 0x2, 0x3, 0x1, 0x4, 0x1, 0x11, 0x3, 0x9, 0x3, 0x16, 0x7, 0x2,
+        0x5, 0xa, 0x3, 0x3, 0x1, 0x4, 0xc, 0x7, 0x3, 0x8, 0x2, 0x16, 0x7, 0x2, 0x5, 0x9, 0x2, 0x3, 0x3, 0x2, 0x5, 0x12,
+        0x2, 0x6, 0x3, 0x4, 0x2, 0x1, 0x2, 0x2, 0x3, 0xc, 0x5, 0x3, 0x4, 0x1, 0x1, 0x15, 0xd, 0x3, 0x17, 0x10, 0x9, 0x3,
+        0x4, 0x2, 0x3, 0x2, 0x4, 0xa, 0x16, 0x3, 0x17, 0xa, 0x5, 0x9, 0x3, 0x4, 0x2, 0x3, 0x4, 0xa, 0x3, 0xd, 0x3, 0x33,
+        0x3, 0x6, 0x10, 0x1a, 0x3, 0x12, 0x18, 0x9, 0x1, 0x7, 0x1, 0x6, 0x1, 0x8, 0xa, 0x3, 0x3a, 0x1d, 0x2, 0x1, 0x5,
+        0x18, 0x1, 0x17, 0x5, 0x1, 0x7, 0xa, 0x4, 0x48, 0x24, 0x27, 0x24, 0xf, 0xd, 0xc6, 0x1, 0x1, 0x179, 0x4, 0x7,
+        0x1, 0x4, 0x29, 0x4, 0x21, 0x4, 0x7, 0x1, 0x4, 0xf, 0x39, 0x4, 0x43, 0x20, 0x1a, 0x56, 0x6, 0x280, 0x1c, 0x59,
+        0x16, 0x18, 0x14, 0xd, 0x3, 0x2, 0x5e, 0xa, 0xa, 0xe, 0xb, 0x59, 0x2b, 0x46, 0x1f, 0xc, 0xc, 0x1, 0x2a, 0x5,
+        0x2c, 0x1a, 0xb, 0x3e, 0x41, 0x1d, 0xb, 0xa, 0xe, 0x2e, 0xc, 0x4d, 0xa6, 0x3c, 0xf, 0x3e, 0x2b, 0xb, 0x2b,
+        0x216, 0x6, 0x26, 0x6, 0x8, 0x1, 0x1, 0x1, 0x1f, 0x35, 0xf, 0xe, 0x6, 0x13, 0x3, 0x9, 0x18, 0x2f, 0x2, 0x1b,
+        0xd, 0x22, 0x21, 0x8c, 0x29a, 0xb, 0x714, 0x17e, 0x2d, 0x1, 0x1, 0x38, 0x2, 0x18, 0x7, 0x7, 0x7, 0x7, 0x7, 0x7,
+        0x7, 0x7, 0x7e, 0x1a, 0x59, 0xd6, 0x10, 0x3f, 0x56, 0x67, 0x2b, 0x5e, 0x56, 0x30, 0x726d, 0x37, 0x15c, 0xb8,
+        0xdd, 0x3c, 0xa, 0x38, 0x46, 0xc, 0x74, 0x1e, 0x4e, 0xb, 0x21, 0x37, 0xe, 0xa, 0x67, 0x1c, 0x6, 0x6, 0x6, 0x7,
+        0x7, 0x3c, 0x7e, 0xa, 0x2ba4, 0x17, 0x31, 0x16e, 0x6a, 0x7, 0x5, 0x1a, 0x5, 0x1, 0x2, 0x2, 0x28a, 0x2a, 0x33,
+        0x13, 0x4, 0x5, 0x87, 0xbe, 0x6, 0x6, 0x6, 0x3, 0x7, 0x7, 0x2, 0xc, 0x1a, 0x13, 0x2, 0xf, 0xe, 0x7b, 0x3, 0x2d,
+        0x58, 0xd, 0x1, 0x2e, 0x1d, 0x31, 0x1c, 0x24, 0x1e, 0x2b, 0x1e, 0x25, 0xe, 0x9e, 0xa, 0x24, 0x24, 0x28, 0x34,
+        0xc, 0xf, 0x7, 0x2, 0xb, 0xf, 0x7, 0x2, 0x34, 0x137, 0x16, 0x8, 0x6, 0x2a, 0x9, 0x6, 0x1, 0x2c, 0x2, 0x1, 0x17,
+        0x48, 0x9, 0x13, 0x2, 0x21, 0x1b, 0x1b, 0x38, 0x14, 0x32, 0x2, 0x8, 0x3, 0x1d, 0x3, 0xa, 0x9, 0x40, 0x27, 0xc,
+        0x36, 0x1d, 0x1b, 0x1a, 0x4, 0x7, 0x49, 0x33, 0x33, 0x2e, 0xa, 0x26, 0x1d, 0x2, 0x1f, 0x2a, 0x3, 0x2, 0x6, 0x9,
+        0x2e, 0x2a, 0x1a, 0x1c, 0x17, 0x4e, 0x24, 0x3e, 0x5, 0x19, 0xa, 0x35, 0x12, 0x27, 0x60, 0x14, 0x12, 0x2f, 0x7,
+        0x1, 0x4, 0xf, 0xb, 0x3b, 0xa, 0x4, 0x8, 0x2, 0x16, 0x7, 0x2, 0x5, 0xa, 0x2, 0x3, 0x1, 0x1, 0x7, 0x7, 0x5, 0xa,
+        0x1, 0x1, 0x26, 0xa, 0x1, 0x1, 0x4, 0xa, 0x2, 0x2, 0x5c, 0x5, 0x48, 0xa, 0x36, 0x26, 0x45, 0xa, 0xd, 0x3a, 0xa,
+        0x14, 0x1b, 0xf, 0x17, 0x3c, 0x53, 0x8, 0x1, 0x8, 0x2, 0x1e, 0x2, 0xc, 0xa, 0x8, 0x2e, 0xb, 0x48, 0x53, 0x49,
+        0xa, 0x8, 0x22, 0xa, 0x9, 0x2d, 0xe, 0x1d, 0x20, 0x16, 0xe, 0x7, 0x2, 0x2c, 0x1, 0x2, 0x9, 0xa, 0x6, 0x2, 0x25,
+        0x2, 0x6, 0xa, 0x2c, 0xa, 0x19, 0x11, 0x29, 0x1d, 0x1, 0x32, 0x39b, 0x6f, 0x5, 0xc4, 0x63, 0x430, 0x16, 0xf9b,
+        0x247, 0x3a, 0x239, 0x1f, 0xa, 0x51, 0xa, 0x1e, 0x6, 0x46, 0xa, 0x7, 0x15, 0x13, 0x3a, 0x5b, 0x19, 0x19, 0x4b,
+        0x39, 0x11, 0x5, 0x7, 0x1cd6, 0x20, 0x73, 0x4, 0x7, 0x2, 0x123, 0x1, 0x3, 0x1, 0x4, 0x18c, 0x6b, 0xd, 0x9, 0xa,
+        0x4, 0xfd, 0x1b4, 0x17, 0x11, 0x2e, 0x17, 0x74, 0xf6, 0x27, 0x4a, 0x70, 0x46, 0x14, 0x14, 0x57, 0x19, 0x55,
+        0x47, 0x2, 0x1, 0x2, 0x4, 0xc, 0x1, 0x7, 0x41, 0x4, 0x8, 0x7, 0x1c, 0x4, 0x5, 0x1, 0x7, 0x154, 0x124, 0x2be,
+        0x5, 0xf, 0x1f, 0x6, 0x7, 0x11, 0x7, 0x2, 0x5, 0x3e, 0x1, 0x2d, 0xe, 0xa, 0x2, 0x1f, 0x3a, 0x1, 0x2a, 0x2b, 0x1,
+        0x1f, 0x16, 0x2, 0x7, 0x4, 0x2, 0xf, 0xc5, 0x10, 0x4c, 0xa, 0x2, 0x44, 0x3d, 0x4, 0x1b, 0x2, 0x1, 0x1, 0xa, 0x4,
+        0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x4, 0x7, 0x4, 0x4, 0x1, 0xa,
+        0x11, 0x3, 0x5, 0x11, 0x2, 0x2c, 0x64, 0xf, 0xf, 0xf, 0x25, 0xae, 0x1d, 0x2c, 0x9, 0x2, 0x6, 0x3d9, 0x11, 0xd,
+        0xda, 0xc, 0x1, 0xc, 0x38, 0xa, 0x28, 0x1e, 0xc, 0x2, 0x9, 0x158, 0xe, 0xd, 0xb, 0x39, 0x1, 0x10, 0xc, 0xa,
+        0x93, 0x67, 0xa6e0, 0x111e, 0x168e, 0x1d31, 0x26e, 0x21e, 0x134b, 0x212a, 0xf0}};
+
+// DerivedCoreProperties-17.0.0.txt
+// Date: 2025-07-30, 23:55:08 GMT
+enum class _Grapheme_Extend_property_values : uint8_t { _Grapheme_Extend_value, _No_value = 255 };
+
+// DerivedCoreProperties-17.0.0.txt
+// Date: 2025-07-30, 23:55:08 GMT
+inline constexpr _Unicode_property_data<_Grapheme_Extend_property_values, 383, true> _Grapheme_Extend_property_data{
+    {0x300, 0x483, 0x591, 0x5bf, 0x5c1, 0x5c4, 0x5c7, 0x610, 0x64b, 0x670, 0x6d6, 0x6df, 0x6e7, 0x6ea, 0x711, 0x730,
+        0x7a6, 0x7eb, 0x7fd, 0x816, 0x81b, 0x825, 0x829, 0x859, 0x897, 0x8ca, 0x8e3, 0x93a, 0x93c, 0x941, 0x94d, 0x951,
+        0x962, 0x981, 0x9bc, 0x9be, 0x9c1, 0x9cd, 0x9d7, 0x9e2, 0x9fe, 0xa01, 0xa3c, 0xa41, 0xa47, 0xa4b, 0xa51, 0xa70,
+        0xa75, 0xa81, 0xabc, 0xac1, 0xac7, 0xacd, 0xae2, 0xafa, 0xb01, 0xb3c, 0xb3e, 0xb41, 0xb4d, 0xb55, 0xb62, 0xb82,
+        0xbbe, 0xbc0, 0xbcd, 0xbd7, 0xc00, 0xc04, 0xc3c, 0xc3e, 0xc46, 0xc4a, 0xc55, 0xc62, 0xc81, 0xcbc, 0xcbf, 0xcc2,
+        0xcc6, 0xcca, 0xcd5, 0xce2, 0xd00, 0xd3b, 0xd3e, 0xd41, 0xd4d, 0xd57, 0xd62, 0xd81, 0xdca, 0xdcf, 0xdd2, 0xdd6,
+        0xddf, 0xe31, 0xe34, 0xe47, 0xeb1, 0xeb4, 0xec8, 0xf18, 0xf35, 0xf37, 0xf39, 0xf71, 0xf80, 0xf86, 0xf8d, 0xf99,
+        0xfc6, 0x102d, 0x1032, 0x1039, 0x103d, 0x1058, 0x105e, 0x1071, 0x1082, 0x1085, 0x108d, 0x109d, 0x135d, 0x1712,
+        0x1732, 0x1752, 0x1772, 0x17b4, 0x17b7, 0x17c6, 0x17c9, 0x17dd, 0x180b, 0x180f, 0x1885, 0x18a9, 0x1920, 0x1927,
+        0x1932, 0x1939, 0x1a17, 0x1a1b, 0x1a56, 0x1a58, 0x1a60, 0x1a62, 0x1a65, 0x1a73, 0x1a7f, 0x1ab0, 0x1ae0, 0x1b00,
+        0x1b34, 0x1b42, 0x1b6b, 0x1b80, 0x1ba2, 0x1ba8, 0x1be6, 0x1be8, 0x1bed, 0x1bef, 0x1c2c, 0x1c36, 0x1cd0, 0x1cd4,
+        0x1ce2, 0x1ced, 0x1cf4, 0x1cf8, 0x1dc0, 0x200c, 0x20d0, 0x2cef, 0x2d7f, 0x2de0, 0x302a, 0x3099, 0xa66f, 0xa674,
+        0xa69e, 0xa6f0, 0xa802, 0xa806, 0xa80b, 0xa825, 0xa82c, 0xa8c4, 0xa8e0, 0xa8ff, 0xa926, 0xa947, 0xa953, 0xa980,
+        0xa9b3, 0xa9b6, 0xa9bc, 0xa9c0, 0xa9e5, 0xaa29, 0xaa31, 0xaa35, 0xaa43, 0xaa4c, 0xaa7c, 0xaab0, 0xaab2, 0xaab7,
+        0xaabe, 0xaac1, 0xaaec, 0xaaf6, 0xabe5, 0xabe8, 0xabed, 0xfb1e, 0xfe00, 0xfe20, 0xff9e, 0x101fd, 0x102e0,
+        0x10376, 0x10a01, 0x10a05, 0x10a0c, 0x10a38, 0x10a3f, 0x10ae5, 0x10d24, 0x10d69, 0x10eab, 0x10efa, 0x10f46,
+        0x10f82, 0x11001, 0x11038, 0x11070, 0x11073, 0x1107f, 0x110b3, 0x110b9, 0x110c2, 0x11100, 0x11127, 0x1112d,
+        0x11173, 0x11180, 0x111b6, 0x111c0, 0x111c9, 0x111cf, 0x1122f, 0x11234, 0x1123e, 0x11241, 0x112df, 0x112e3,
+        0x11300, 0x1133b, 0x1133e, 0x11340, 0x1134d, 0x11357, 0x11366, 0x11370, 0x113b8, 0x113bb, 0x113c2, 0x113c5,
+        0x113c7, 0x113ce, 0x113d2, 0x113e1, 0x11438, 0x11442, 0x11446, 0x1145e, 0x114b0, 0x114b3, 0x114ba, 0x114bd,
+        0x114bf, 0x114c2, 0x115af, 0x115b2, 0x115bc, 0x115bf, 0x115dc, 0x11633, 0x1163d, 0x1163f, 0x116ab, 0x116ad,
+        0x116b0, 0x1171d, 0x1171f, 0x11722, 0x11727, 0x1182f, 0x11839, 0x11930, 0x1193b, 0x11943, 0x119d4, 0x119da,
+        0x119e0, 0x11a01, 0x11a33, 0x11a3b, 0x11a47, 0x11a51, 0x11a59, 0x11a8a, 0x11a98, 0x11b60, 0x11b62, 0x11b66,
+        0x11c30, 0x11c38, 0x11c3f, 0x11c92, 0x11caa, 0x11cb2, 0x11cb5, 0x11d31, 0x11d3a, 0x11d3c, 0x11d3f, 0x11d47,
+        0x11d90, 0x11d95, 0x11d97, 0x11ef3, 0x11f00, 0x11f36, 0x11f40, 0x11f5a, 0x13440, 0x13447, 0x1611e, 0x1612d,
+        0x16af0, 0x16b30, 0x16f4f, 0x16f8f, 0x16fe4, 0x16ff0, 0x1bc9d, 0x1cf00, 0x1cf30, 0x1d165, 0x1d16d, 0x1d17b,
+        0x1d185, 0x1d1aa, 0x1d242, 0x1da00, 0x1da3b, 0x1da75, 0x1da84, 0x1da9b, 0x1daa1, 0x1e000, 0x1e008, 0x1e01b,
+        0x1e023, 0x1e026, 0x1e08f, 0x1e130, 0x1e2ae, 0x1e2ec, 0x1e4ec, 0x1e5ee, 0x1e6e3, 0x1e6e6, 0x1e6ee, 0x1e6f5,
+        0x1e8d0, 0x1e944, 0xe0020, 0xe0100},
+    {0x70, 0x7, 0x2d, 0x1, 0x2, 0x2, 0x1, 0xb, 0x15, 0x1, 0x7, 0x6, 0x2, 0x4, 0x1, 0x1b, 0xb, 0x9, 0x1, 0x4, 0x9, 0x3,
+        0x5, 0x3, 0x9, 0x18, 0x20, 0x1, 0x1, 0x8, 0x1, 0x7, 0x2, 0x1, 0x1, 0x1, 0x4, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2,
+        0x2, 0x3, 0x1, 0x2, 0x1, 0x2, 0x1, 0x5, 0x2, 0x1, 0x2, 0x6, 0x1, 0x1, 0x2, 0x4, 0x1, 0x3, 0x2, 0x1, 0x1, 0x1,
+        0x1, 0x1, 0x1, 0x1, 0x1, 0x3, 0x3, 0x4, 0x2, 0x2, 0x1, 0x1, 0x2, 0x1, 0x3, 0x4, 0x2, 0x2, 0x2, 0x2, 0x1, 0x4,
+        0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x3, 0x1, 0x1, 0x1, 0x7, 0x8, 0x1, 0x9, 0x7, 0x2, 0x1, 0x1, 0x1, 0xe, 0x5, 0x2,
+        0xb, 0x24, 0x1, 0x4, 0x6, 0x2, 0x2, 0x2, 0x3, 0x4, 0x1, 0x2, 0x1, 0x1, 0x3, 0x4, 0x3, 0x2, 0x2, 0x2, 0x7, 0x1,
+        0xb, 0x1, 0x3, 0x1, 0x2, 0x1, 0x3, 0x2, 0x1, 0x3, 0x2, 0x1, 0x1, 0x7, 0x1, 0x1, 0x8, 0xa, 0x1, 0x2e, 0xc, 0x4,
+        0xa, 0x3, 0x9, 0x2, 0x4, 0x6, 0x1, 0x2, 0x1, 0x5, 0x8, 0x2, 0x3, 0xd, 0x7, 0x1, 0x1, 0x2, 0x40, 0x1, 0x21, 0x3,
+        0x1, 0x20, 0x6, 0x2, 0x4, 0xa, 0x2, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x2, 0x12, 0x1, 0x8, 0xb, 0x1, 0x3, 0x1, 0x4,
+        0x2, 0x1, 0x1, 0x6, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x3, 0x2, 0x2, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x10, 0x10,
+        0x2, 0x1, 0x1, 0x5, 0x3, 0x2, 0x4, 0x3, 0x1, 0x2, 0x4, 0x5, 0x2, 0x6, 0xb, 0x4, 0x1, 0xf, 0x1, 0x2, 0x3, 0x4,
+        0x2, 0x1, 0x3, 0x5, 0x8, 0x1, 0x2, 0x9, 0x1, 0x4, 0x1, 0x3, 0x4, 0x1, 0x1, 0x1, 0x8, 0x2, 0x2, 0x1, 0x1, 0x1,
+        0x1, 0x7, 0x5, 0x1, 0x6, 0x1, 0x1, 0x3, 0x3, 0x1, 0x2, 0x8, 0x3, 0x1, 0x1, 0x1, 0x6, 0x1, 0x1, 0x2, 0x2, 0x1,
+        0x4, 0x2, 0x2, 0x2, 0x8, 0x1, 0x2, 0x1, 0x1, 0x8, 0x1, 0x1, 0x4, 0x5, 0x9, 0x2, 0x1, 0x4, 0x1, 0x4, 0x2, 0x1,
+        0xa, 0x6, 0x4, 0x1, 0x6, 0x3, 0xd, 0x2, 0x1, 0x3, 0x1, 0x7, 0x6, 0x1, 0x16, 0x7, 0x2, 0x2, 0x6, 0x1, 0x2, 0x7,
+        0x1, 0x2, 0x1, 0x1, 0x2, 0x2, 0x5, 0x3, 0x1, 0x1, 0xf, 0xc, 0x3, 0x5, 0x7, 0x1, 0x4, 0x1, 0x2, 0x2, 0x2e, 0x17,
+        0x5, 0x6, 0x8, 0x7, 0x4, 0x3, 0x37, 0x32, 0x1, 0x1, 0x5, 0xf, 0x7, 0x11, 0x7, 0x2, 0x5, 0x1, 0x7, 0x1, 0x4, 0x4,
+        0x2, 0x1, 0x1, 0x2, 0x1, 0x7, 0x7, 0x60, 0xf0}};
+
+// EastAsianWidth-17.0.0.txt
+// Date: 2025-07-24, 00:12:54 GMT
+inline constexpr char32_t _Width_estimate_intervals_v2[] = {0x1100, 0x1160, 0x231a, 0x231c, 0x2329, 0x232b, 0x23e9,
+    0x23ed, 0x23f0, 0x23f1, 0x23f3, 0x23f4, 0x25fd, 0x25ff, 0x2614, 0x2616, 0x2630, 0x2638, 0x2648, 0x2654, 0x267f,
+    0x2680, 0x268a, 0x2690, 0x2693, 0x2694, 0x26a1, 0x26a2, 0x26aa, 0x26ac, 0x26bd, 0x26bf, 0x26c4, 0x26c6, 0x26ce,
+    0x26cf, 0x26d4, 0x26d5, 0x26ea, 0x26eb, 0x26f2, 0x26f4, 0x26f5, 0x26f6, 0x26fa, 0x26fb, 0x26fd, 0x26fe, 0x2705,
+    0x2706, 0x270a, 0x270c, 0x2728, 0x2729, 0x274c, 0x274d, 0x274e, 0x274f, 0x2753, 0x2756, 0x2757, 0x2758, 0x2795,
+    0x2798, 0x27b0, 0x27b1, 0x27bf, 0x27c0, 0x2b1b, 0x2b1d, 0x2b50, 0x2b51, 0x2b55, 0x2b56, 0x2e80, 0x2e9a, 0x2e9b,
+    0x2ef4, 0x2f00, 0x2fd6, 0x2ff0, 0x303f, 0x3041, 0x3097, 0x3099, 0x3100, 0x3105, 0x3130, 0x3131, 0x318f, 0x3190,
+    0x31e6, 0x31ef, 0x321f, 0x3220, 0x3248, 0x3250, 0xa48d, 0xa490, 0xa4c7, 0xa960, 0xa97d, 0xac00, 0xd7a4, 0xf900,
+    0xfb00, 0xfe10, 0xfe1a, 0xfe30, 0xfe53, 0xfe54, 0xfe67, 0xfe68, 0xfe6c, 0xff01, 0xff61, 0xffe0, 0xffe7, 0x16fe0,
+    0x16fe5, 0x16ff0, 0x16ff7, 0x17000, 0x18cd6, 0x18cff, 0x18d1f, 0x18d80, 0x18df3, 0x1aff0, 0x1aff4, 0x1aff5, 0x1affc,
+    0x1affd, 0x1afff, 0x1b000, 0x1b123, 0x1b132, 0x1b133, 0x1b150, 0x1b153, 0x1b155, 0x1b156, 0x1b164, 0x1b168, 0x1b170,
+    0x1b2fc, 0x1d300, 0x1d357, 0x1d360, 0x1d377, 0x1f004, 0x1f005, 0x1f0cf, 0x1f0d0, 0x1f18e, 0x1f18f, 0x1f191, 0x1f19b,
+    0x1f200, 0x1f203, 0x1f210, 0x1f23c, 0x1f240, 0x1f249, 0x1f250, 0x1f252, 0x1f260, 0x1f266, 0x1f300, 0x1f650, 0x1f680,
+    0x1f6c6, 0x1f6cc, 0x1f6cd, 0x1f6d0, 0x1f6d3, 0x1f6d5, 0x1f6d9, 0x1f6dc, 0x1f6e0, 0x1f6eb, 0x1f6ed, 0x1f6f4, 0x1f6fd,
+    0x1f7e0, 0x1f7ec, 0x1f7f0, 0x1f7f1, 0x1f900, 0x1fa00, 0x1fa70, 0x1fa7d, 0x1fa80, 0x1fa8b, 0x1fa8e, 0x1fac7, 0x1fac8,
+    0x1fac9, 0x1facd, 0x1fadd, 0x1fadf, 0x1faeb, 0x1faef, 0x1faf9, 0x20000, 0x2fffe, 0x30000, 0x3fffe};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_FORMAT_UCD_TABLES_HPP
diff --git a/msvc-stl/stl/inc/__msvc_formatter.hpp b/msvc-stl/stl/inc/__msvc_formatter.hpp
new file mode 100644
index 0000000..e61fb08
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_formatter.hpp
@@ -0,0 +1,438 @@
+// __msvc_formatter.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// NOTE:
+// The contents of this header are derived in part from libfmt under the following license:
+
+// Copyright (c) 2012 - present, Victor Zverovich
+//
+// 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.
+//
+// --- Optional exception to the license ---
+//
+// As an exception, if, as a result of your compiling your source code, portions
+// of this Software are embedded into a machine-executable object form of such
+// source code, you may redistribute such embedded portions in such object form
+// without including the above copyright and permission notices.
+
+#ifndef __MSVC_FORMATTER_HPP
+#define __MSVC_FORMATTER_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20
+#error The contents of <format> are only available with C++20. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX20
+
+#include <concepts>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+#if _HAS_CXX23
+#include <xutility>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+#if _HAS_CXX23
+#define _FMT_P2286_BEGIN inline namespace __p2286 {
+#define _FMT_P2286_END   }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+#define _FMT_P2286_BEGIN
+#define _FMT_P2286_END
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+enum class _Fmt_align : uint8_t { _None, _Left, _Right, _Center };
+
+enum class _Fmt_sign : uint8_t { _None, _Plus, _Minus, _Space };
+
+enum class _Basic_format_arg_type : uint8_t {
+    _None,
+    _Int_type,
+    _UInt_type,
+    _Long_long_type,
+    _ULong_long_type,
+    _Bool_type,
+    _Char_type,
+    _Float_type,
+    _Double_type,
+    _Long_double_type,
+    _Pointer_type,
+    _CString_type,
+    _String_type,
+    _Custom_type,
+};
+static_assert(static_cast<int>(_Basic_format_arg_type::_Custom_type) < 16, "must fit in 4-bit bitfield");
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ty> // specializations allowed by N5014 [format.formatter.locking]/1
+constexpr bool enable_nonlocking_formatter_optimization = false;
+
+_NODISCARD consteval bool _Is_debug_enabled_fmt_type(_Basic_format_arg_type _Ty) {
+    return _Ty == _Basic_format_arg_type::_Char_type || _Ty == _Basic_format_arg_type::_CString_type
+        || _Ty == _Basic_format_arg_type::_String_type;
+}
+#endif // _HAS_CXX23
+
+template <class _CharT>
+struct _Basic_format_specs {
+    int _Width            = 0;
+    int _Precision        = -1;
+    char _Type            = '\0';
+    _Fmt_align _Alignment = _Fmt_align::_None;
+    _Fmt_sign _Sgn        = _Fmt_sign::_None;
+    bool _Alt             = false;
+    bool _Localized       = false;
+    bool _Leading_zero    = false;
+    uint8_t _Fill_length  = 1;
+    // At most one codepoint (so one char32_t or four utf-8 char8_t).
+    _CharT _Fill[4 / sizeof(_CharT)] = {_CharT{' '}};
+};
+
+// Adds width and precision references to _Basic_format_specs.
+// This is required for std::formatter implementations because we must
+// parse the format specs without having access to the format args (via a format context).
+template <class _CharT>
+struct _Dynamic_format_specs : _Basic_format_specs<_CharT> {
+    int _Dynamic_width_index     = -1;
+    int _Dynamic_precision_index = -1;
+};
+
+[[noreturn]] inline void _Throw_format_error(const char* _Message);
+
+_EXPORT_STD template <class _CharT>
+class _NO_SPECIALIZATIONS_CITING("N5014 [format.parse.ctx]/2") basic_format_parse_context;
+
+template <class _CharT>
+concept _Format_supported_charT = _Is_any_of_v<_CharT, char, wchar_t>;
+
+_EXPORT_STD template <class _Ty, class _CharT = char>
+struct formatter {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+_FMT_P2286_BEGIN
+template <class _Ty, class _CharT, _Basic_format_arg_type _ArgType>
+struct _Formatter_base {
+public:
+#if _HAS_CXX23
+    constexpr void _Set_debug_format() noexcept
+        requires (_Is_debug_enabled_fmt_type(_ArgType))
+    {
+        _Specs._Type = '?';
+    }
+#endif // _HAS_CXX23
+
+    template <class _ParseContext = basic_format_parse_context<_CharT>>
+    constexpr _ParseContext::iterator parse(type_identity_t<_ParseContext&> _Parse_ctx); // defined in <format>
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(const _Ty& _Val, _FormatContext& _Format_ctx) const; // defined in <format>
+
+private:
+    _Dynamic_format_specs<_CharT> _Specs;
+};
+_FMT_P2286_END
+
+#if _HAS_CXX23
+#define _FORMAT_SPECIALIZE_NONLOCKING_FOR(_Type) \
+    template <>                                  \
+    inline constexpr bool enable_nonlocking_formatter_optimization<_Type> = true;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+#define _FORMAT_SPECIALIZE_NONLOCKING_FOR(_Type)
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+#define _FORMAT_SPECIALIZE_FOR(_Type, _ArgType) \
+    _FORMAT_SPECIALIZE_NONLOCKING_FOR(_Type)    \
+    template <_Format_supported_charT _CharT>   \
+    struct formatter<_Type, _CharT> : _Formatter_base<_Type, _CharT, _ArgType> {}
+
+_FORMAT_SPECIALIZE_FOR(int, _Basic_format_arg_type::_Int_type);
+_FORMAT_SPECIALIZE_FOR(unsigned int, _Basic_format_arg_type::_UInt_type);
+_FORMAT_SPECIALIZE_FOR(long long, _Basic_format_arg_type::_Long_long_type);
+_FORMAT_SPECIALIZE_FOR(unsigned long long, _Basic_format_arg_type::_ULong_long_type);
+_FORMAT_SPECIALIZE_FOR(bool, _Basic_format_arg_type::_Bool_type);
+_FORMAT_SPECIALIZE_FOR(float, _Basic_format_arg_type::_Float_type);
+_FORMAT_SPECIALIZE_FOR(double, _Basic_format_arg_type::_Double_type);
+_FORMAT_SPECIALIZE_FOR(long double, _Basic_format_arg_type::_Long_double_type);
+_FORMAT_SPECIALIZE_FOR(nullptr_t, _Basic_format_arg_type::_Pointer_type);
+_FORMAT_SPECIALIZE_FOR(void*, _Basic_format_arg_type::_Pointer_type);
+_FORMAT_SPECIALIZE_FOR(const void*, _Basic_format_arg_type::_Pointer_type);
+_FORMAT_SPECIALIZE_FOR(short, _Basic_format_arg_type::_Int_type);
+_FORMAT_SPECIALIZE_FOR(unsigned short, _Basic_format_arg_type::_UInt_type);
+_FORMAT_SPECIALIZE_FOR(long, _Basic_format_arg_type::_Int_type);
+_FORMAT_SPECIALIZE_FOR(unsigned long, _Basic_format_arg_type::_UInt_type);
+_FORMAT_SPECIALIZE_FOR(signed char, _Basic_format_arg_type::_Int_type);
+_FORMAT_SPECIALIZE_FOR(unsigned char, _Basic_format_arg_type::_UInt_type);
+
+#undef _FORMAT_SPECIALIZE_FOR
+#undef _FORMAT_SPECIALIZE_NONLOCKING_FOR
+
+// not using the macro because we'd like to add 'set_debug_format' member function in C++23 mode
+template <_Format_supported_charT _CharT>
+struct formatter<char, _CharT> : _Formatter_base<char, _CharT, _Basic_format_arg_type::_Char_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+// not using the macro because we'd like to avoid the formatter<wchar_t, char> specialization
+template <>
+struct formatter<wchar_t, wchar_t> : _Formatter_base<wchar_t, wchar_t, _Basic_format_arg_type::_Char_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        _Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+// We could use the macro for these specializations, but it's confusing to refer to symbols that are defined
+// inside the macro in the macro's "call".
+template <_Format_supported_charT _CharT>
+struct formatter<_CharT*, _CharT> : _Formatter_base<_CharT*, _CharT, _Basic_format_arg_type::_CString_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+template <_Format_supported_charT _CharT>
+struct formatter<const _CharT*, _CharT>
+    : _Formatter_base<const _CharT*, _CharT, _Basic_format_arg_type::_CString_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+template <_Format_supported_charT _CharT, size_t _Nx>
+struct formatter<_CharT[_Nx], _CharT> : _Formatter_base<_CharT[_Nx], _CharT, _Basic_format_arg_type::_CString_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+class basic_string;
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_string_view;
+
+template <_Format_supported_charT _CharT, class _Traits, class _Allocator>
+struct formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
+    : _Formatter_base<basic_string<_CharT, _Traits, _Allocator>, _CharT, _Basic_format_arg_type::_String_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+template <_Format_supported_charT _CharT, class _Traits>
+struct formatter<basic_string_view<_CharT, _Traits>, _CharT>
+    : _Formatter_base<basic_string_view<_CharT, _Traits>, _CharT, _Basic_format_arg_type::_String_type> {
+#if _HAS_CXX23
+    constexpr void set_debug_format() noexcept {
+        this->_Set_debug_format();
+    }
+#endif // _HAS_CXX23
+};
+
+#if _HAS_CXX23
+template <>
+struct formatter<char*, wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <>
+struct formatter<const char*, wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <size_t _Size>
+struct formatter<char[_Size], wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <class _Traits, class _Allocator>
+struct formatter<basic_string<char, _Traits, _Allocator>, wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <class _Traits>
+struct formatter<basic_string_view<char, _Traits>, wchar_t> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+_EXPORT_STD enum class range_format { disabled, map, set, sequence, string, debug_string };
+
+template <class _Ty>
+struct _Invalid_format_kind {
+    static_assert(false, "A program that instantiates the primary template of format_kind is ill-formed. "
+                         "(N4981 [format.range.fmtkind]/1)");
+};
+
+_EXPORT_STD template <class _Ty>
+constexpr _Invalid_format_kind<_Ty> format_kind; // specializations allowed by N5014 [format.range.fmtkind]/3
+
+template <class _Ty>
+constexpr bool _Is_two_tuple = false;
+
+template <class _Ty, class _Uty>
+constexpr bool _Is_two_tuple<pair<_Ty, _Uty>> = true;
+
+template <class _Ty, class _Uty>
+constexpr bool _Is_two_tuple<tuple<_Ty, _Uty>> = true;
+
+template <_RANGES input_range _Rng>
+    requires same_as<_Rng, remove_cvref_t<_Rng>>
+constexpr range_format format_kind<_Rng> = []() consteval {
+    using _Ref_value_t = remove_cvref_t<_RANGES range_reference_t<_Rng>>;
+    if constexpr (same_as<_Ref_value_t, _Rng>) {
+        return range_format::disabled;
+    } else if constexpr (requires { typename _Rng::key_type; }) {
+        if constexpr (requires { typename _Rng::mapped_type; } && _Is_two_tuple<_Ref_value_t>) {
+            return range_format::map;
+        } else {
+            return range_format::set;
+        }
+    } else {
+        return range_format::sequence;
+    }
+}();
+
+// Specializations for pairs, tuples, and ranges are forward-declared to avoid any risk of using the disabled primary
+// template.
+
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+
+template <class _Rng>
+concept _Formatting_enabled_range = format_kind<_Rng> != range_format::disabled;
+
+template <_RANGES input_range _Rng, _Format_supported_charT _CharT>
+    requires _Formatting_enabled_range<_Rng>
+struct formatter<_Rng, _CharT>;
+
+template <_Format_supported_charT _CharT, class _Ty1, class _Ty2>
+struct formatter<pair<_Ty1, _Ty2>, _CharT>;
+
+template <_Format_supported_charT _CharT, class... _Types>
+struct formatter<tuple<_Types...>, _CharT>;
+
+template <_Format_supported_charT _CharT>
+constexpr bool enable_nonlocking_formatter_optimization<_CharT> = true;
+
+template <_Format_supported_charT _CharT>
+constexpr bool enable_nonlocking_formatter_optimization<_CharT*> = true;
+
+template <_Format_supported_charT _CharT>
+constexpr bool enable_nonlocking_formatter_optimization<const _CharT*> = true;
+
+template <_Format_supported_charT _CharT, size_t _Nx>
+constexpr bool enable_nonlocking_formatter_optimization<_CharT[_Nx]> = true;
+
+template <_Format_supported_charT _CharT, class _Traits, class _Allocator>
+constexpr bool enable_nonlocking_formatter_optimization<basic_string<_CharT, _Traits, _Allocator>> = true;
+
+template <_Format_supported_charT _CharT, class _Traits>
+constexpr bool enable_nonlocking_formatter_optimization<basic_string_view<_CharT, _Traits>> = true;
+
+template <class _Ty1, class _Ty2>
+constexpr bool enable_nonlocking_formatter_optimization<pair<_Ty1, _Ty2>> =
+    enable_nonlocking_formatter_optimization<remove_cvref_t<_Ty1>>
+    && enable_nonlocking_formatter_optimization<remove_cvref_t<_Ty2>>;
+
+template <class... _Ts>
+constexpr bool enable_nonlocking_formatter_optimization<tuple<_Ts...>> =
+    (enable_nonlocking_formatter_optimization<remove_cvref_t<_Ts>> && ...);
+
+template <class _CharT>
+struct _Fill_align_and_width_specs {
+    int _Width               = -1;
+    int _Dynamic_width_index = -1;
+    _Fmt_align _Alignment    = _Fmt_align::_None;
+    uint8_t _Fill_length     = 1;
+    // At most one codepoint (so one char32_t or four utf-8 char8_t).
+    _CharT _Fill[4 / sizeof(_CharT)]{' '};
+};
+
+template <class _CharT>
+struct _Fill_align_and_width_formatter {
+public:
+    template <class _ParseContext = basic_format_parse_context<_CharT>> // improves throughput, see GH-5003
+    _NODISCARD constexpr _ParseContext::iterator _Parse(
+        type_identity_t<_ParseContext&> _Parse_ctx); // defined in <format>
+
+    template <class _FormatContext, class _Func>
+    _NODISCARD _FormatContext::iterator _Format(_FormatContext& _Format_ctx, const int _Width,
+        _Fmt_align _Default_align,
+        _Func&& _Fn) const; // defined in <format>
+
+private:
+    _Fill_align_and_width_specs<_CharT> _Specs;
+};
+#endif // _HAS_CXX23
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_FORMATTER_HPP
diff --git a/msvc-stl/stl/inc/__msvc_heap_algorithms.hpp b/msvc-stl/stl/inc/__msvc_heap_algorithms.hpp
new file mode 100644
index 0000000..f368fc7
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_heap_algorithms.hpp
@@ -0,0 +1,150 @@
+// __msvc_heap_algorithms.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_HEAP_ALGORITHMS_HPP
+#define __MSVC_HEAP_ALGORITHMS_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _RanIt, class _Ty, class _Pr>
+_CONSTEXPR20 void _Push_heap_by_index(
+    _RanIt _First, _Iter_diff_t<_RanIt> _Hole, _Iter_diff_t<_RanIt> _Top, _Ty&& _Val, _Pr _Pred) {
+    // percolate _Hole to _Top or where _Val belongs
+    using _Diff = _Iter_diff_t<_RanIt>;
+    for (_Diff _Idx                                                         = (_Hole - 1) >> 1; // shift for codegen
+        _Top < _Hole && _DEBUG_LT_PRED(_Pred, *(_First + _Idx), _Val); _Idx = (_Hole - 1) >> 1) { // shift for codegen
+        // move _Hole up to parent
+        *(_First + _Hole) = _STD move(*(_First + _Idx));
+        _Hole             = _Idx;
+    }
+
+    *(_First + _Hole) = _STD forward<_Ty>(_Val); // drop _Val into final hole
+}
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_CONSTEXPR20 void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // push *(_Last - 1) onto heap at [_First, _Last - 1)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _ULast        = _STD _Get_unwrapped(_Last);
+    using _Diff        = _Iter_diff_t<_RanIt>;
+    _Diff _Count       = _ULast - _UFirst;
+    if (2 <= _Count) {
+        _Iter_value_t<_RanIt> _Val(_STD move(*--_ULast));
+        _STD _Push_heap_by_index(_UFirst, --_Count, _Diff(0), _STD move(_Val), _STD _Pass_fn(_Pred));
+    }
+}
+
+_EXPORT_STD template <class _RanIt>
+_CONSTEXPR20 void push_heap(_RanIt _First, _RanIt _Last) {
+    // push *(_Last - 1) onto heap at [_First, _Last - 1)
+    _STD push_heap(_First, _Last, less<>{});
+}
+
+template <class _RanIt, class _Ty, class _Pr>
+_CONSTEXPR20 void _Pop_heap_hole_by_index(
+    _RanIt _First, _Iter_diff_t<_RanIt> _Hole, _Iter_diff_t<_RanIt> _Bottom, _Ty&& _Val, _Pr _Pred) {
+    // percolate _Hole to _Bottom, then push _Val
+    _STL_INTERNAL_CHECK(_Bottom > 0);
+
+    using _Diff      = _Iter_diff_t<_RanIt>;
+    const _Diff _Top = _Hole;
+    _Diff _Idx       = _Hole;
+
+    // Check whether _Idx can have a child before calculating that child's index, since
+    // calculating the child's index can trigger integer overflows
+    const _Diff _Max_sequence_non_leaf = (_Bottom - 1) >> 1; // shift for codegen
+    while (_Idx < _Max_sequence_non_leaf) { // move _Hole down to larger child
+        _Idx = 2 * _Idx + 2;
+        if (_DEBUG_LT_PRED(_Pred, *(_First + _Idx), *(_First + (_Idx - 1)))) {
+            --_Idx;
+        }
+        *(_First + _Hole) = _STD move(*(_First + _Idx));
+        _Hole             = _Idx;
+    }
+
+    if (_Idx == _Max_sequence_non_leaf && _Bottom % 2 == 0) { // only child at bottom, move _Hole down to it
+        *(_First + _Hole) = _STD move(*(_First + (_Bottom - 1)));
+        _Hole             = _Bottom - 1;
+    }
+
+    _STD _Push_heap_by_index(_First, _Hole, _Top, _STD forward<_Ty>(_Val), _Pred);
+}
+
+template <class _RanIt, class _Ty, class _Pr>
+_CONSTEXPR20 void _Pop_heap_hole_unchecked(_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty&& _Val, _Pr _Pred) {
+    // pop *_First to *_Dest and reheap
+    // precondition: _First != _Last
+    // precondition: _First != _Dest
+    *_Dest      = _STD move(*_First);
+    using _Diff = _Iter_diff_t<_RanIt>;
+    _STD _Pop_heap_hole_by_index(
+        _First, static_cast<_Diff>(0), static_cast<_Diff>(_Last - _First), _STD forward<_Ty>(_Val), _Pred);
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Pop_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // pop *_First to *(_Last - 1) and reheap
+    if (2 <= _Last - _First) {
+        --_Last;
+        _Iter_value_t<_RanIt> _Val(_STD move(*_Last));
+        _STD _Pop_heap_hole_unchecked(_First, _Last, _Last, _STD move(_Val), _Pred);
+    }
+}
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_CONSTEXPR20 void pop_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // pop *_First to *(_Last - 1) and reheap
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Pop_heap_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _RanIt>
+_CONSTEXPR20 void pop_heap(_RanIt _First, _RanIt _Last) {
+    // pop *_First to *(_Last - 1) and reheap
+    _STD pop_heap(_First, _Last, less<>{});
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Make_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // make [_First, _Last) into a heap
+    using _Diff   = _Iter_diff_t<_RanIt>;
+    _Diff _Bottom = _Last - _First;
+    for (_Diff _Hole = _Bottom >> 1; _Hole > 0;) { // shift for codegen
+        // reheap top half, bottom to top
+        --_Hole;
+        _Iter_value_t<_RanIt> _Val(_STD move(*(_First + _Hole)));
+        _STD _Pop_heap_hole_by_index(_First, _Hole, _Bottom, _STD move(_Val), _Pred);
+    }
+}
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_CONSTEXPR20 void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) { // make [_First, _Last) into a heap
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Make_heap_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _RanIt>
+_CONSTEXPR20 void make_heap(_RanIt _First, _RanIt _Last) { // make [_First, _Last) into a heap
+    _STD make_heap(_First, _Last, less<>{});
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_HEAP_ALGORITHMS_HPP
diff --git a/msvc-stl/stl/inc/__msvc_int128.hpp b/msvc-stl/stl/inc/__msvc_int128.hpp
new file mode 100644
index 0000000..e7d9650
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_int128.hpp
@@ -0,0 +1,1605 @@
+// __msvc_int128.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_INT128_HPP
+#define __MSVC_INT128_HPP
+
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_bit_utils.hpp>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#include _STL_INTRIN_HEADER
+
+#if _HAS_CXX20
+#include <compare>
+#include <concepts>
+#define _TEMPLATE_CLASS_INTEGRAL(type) template <integral type>
+#define _ZERO_OR_NO_INIT
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+#define _TEMPLATE_CLASS_INTEGRAL(type) template <class type, enable_if_t<is_integral_v<type>, int> = 0>
+#define _ZERO_OR_NO_INIT \
+    {                    \
+    } // Trivial default initialization is not allowed in constexpr functions before C++20.
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+#if defined(_M_X64) && !defined(_M_ARM64EC) && !defined(_M_CEE_PURE)
+#define _STL_128_INTRINSICS 1
+#ifdef __clang__ // clang doesn't have _udiv128 / _div128
+#define _STL_128_DIV_INTRINSICS 0
+#else // ^^^ Clang / other vvv
+#define _STL_128_DIV_INTRINSICS 1
+#endif // ^^^ detect _udiv128 / _div128 ^^^
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _STL_128_INTRINSICS     0
+#define _STL_128_DIV_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+struct alignas(16) _Base128 {
+    uint64_t _Word[2];
+
+    constexpr void _Left_shift(const unsigned char _Count) noexcept {
+        // _STL_INTERNAL_CHECK(_Count < 128);
+        if (_Count == 0) {
+            return;
+        }
+
+        if (_Count >= 64) {
+            _Word[1] = _Word[0] << (_Count % 64);
+            _Word[0] = 0;
+            return;
+        }
+
+#if _STL_128_INTRINSICS
+        if (!_Is_constant_evaluated()) {
+            _Word[1] = __shiftleft128(_Word[0], _Word[1], _Count);
+        } else
+#endif // _STL_128_INTRINSICS
+        {
+            _Word[1] = (_Word[1] << _Count) | (_Word[0] >> (64 - _Count));
+        }
+
+        _Word[0] <<= _Count;
+    }
+
+    constexpr void _Unsigned_right_shift(const unsigned char _Count) noexcept {
+        // _STL_INTERNAL_CHECK(_Count < 128);
+        if (_Count == 0) {
+            return;
+        }
+
+        if (_Count >= 64) {
+            _Word[0] = _Word[1] >> (_Count % 64);
+            _Word[1] = 0;
+            return;
+        }
+
+#if _STL_128_INTRINSICS
+        if (!_Is_constant_evaluated()) {
+            _Word[0] = __shiftright128(_Word[0], _Word[1], _Count);
+        } else
+#endif // _STL_128_INTRINSICS
+        {
+            _Word[0] = (_Word[0] >> _Count) | (_Word[1] << (64 - _Count));
+        }
+
+        _Word[1] >>= _Count;
+    }
+
+    static constexpr unsigned char _AddCarry64(
+        unsigned char _Carry, uint64_t _Left, uint64_t _Right, uint64_t& _Result) noexcept {
+        // _STL_INTERNAL_CHECK(_Carry < 2);
+#if _STL_128_INTRINSICS
+        if (!_Is_constant_evaluated()) {
+            return _addcarry_u64(_Carry, _Left, _Right, &_Result);
+        }
+#endif // _STL_128_INTRINSICS
+
+        const uint64_t _Sum = _Left + _Right + _Carry;
+        _Result             = _Sum;
+        return _Carry ? _Sum <= _Left : _Sum < _Left;
+    }
+
+    static constexpr unsigned char _SubBorrow64(
+        unsigned char _Carry, uint64_t _Left, uint64_t _Right, uint64_t& _Result) noexcept {
+        // _STL_INTERNAL_CHECK(_Carry < 2);
+#if _STL_128_INTRINSICS
+        if (!_Is_constant_evaluated()) {
+            return _subborrow_u64(_Carry, _Left, _Right, &_Result);
+        }
+#endif // _STL_128_INTRINSICS
+
+        const auto _Difference = _Left - _Right - _Carry;
+        _Result                = _Difference;
+        return _Carry ? _Difference >= _Left : _Difference > _Left;
+    }
+
+    template <size_t __m, size_t __n>
+    static constexpr void _Knuth_4_3_1_M(
+        const uint32_t (&__u)[__m], const uint32_t (&__v)[__n], uint32_t (&__w)[__n + __m]) noexcept {
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        constexpr auto _Int_max = static_cast<size_t>(INT_MAX);
+        _STL_INTERNAL_STATIC_ASSERT(__m <= _Int_max);
+        _STL_INTERNAL_STATIC_ASSERT(__n <= _Int_max);
+#endif // defined(_ENABLE_STL_INTERNAL_CHECK)
+
+        for (auto& _Elem : __w) {
+            _Elem = 0;
+        }
+
+        for (int __j = 0; __j < static_cast<int>(__n); ++__j) {
+            // stash Knuth's `k` in the lower 32 bits of __t
+            uint64_t __t = 0;
+            for (int __i = 0; __i < static_cast<int>(__m); ++__i) {
+                __t += static_cast<uint64_t>(__u[__i]) * __v[__j] + __w[__i + __j];
+                __w[__i + __j] = static_cast<uint32_t>(__t);
+                __t >>= 32;
+            }
+            __w[__j + __m] = static_cast<uint32_t>(__t);
+        }
+    }
+
+    _NODISCARD static constexpr uint64_t _UMul128(
+        const uint64_t _Left, const uint64_t _Right, uint64_t& _High_result) noexcept {
+#if _STL_128_INTRINSICS
+        if (!_Is_constant_evaluated()) {
+            return _umul128(_Left, _Right, &_High_result);
+        }
+#endif // _STL_128_INTRINSICS
+
+        const uint32_t __u[2] = {
+            static_cast<uint32_t>(_Left),
+            static_cast<uint32_t>(_Left >> 32),
+        };
+        const uint32_t __v[2] = {
+            static_cast<uint32_t>(_Right),
+            static_cast<uint32_t>(_Right >> 32),
+        };
+        uint32_t __w[4] _ZERO_OR_NO_INIT;
+
+        // multiply 2-digit numbers with 4-digit result in base 2^32
+        _Knuth_4_3_1_M(__u, __v, __w);
+
+        _High_result = (static_cast<uint64_t>(__w[3]) << 32) | __w[2];
+        return (static_cast<uint64_t>(__w[1]) << 32) | __w[0];
+    }
+
+    static constexpr void _Knuth_4_3_1_D(uint32_t* const __u, const size_t __u_size, const uint32_t* const __v,
+        const size_t __v_size, uint32_t* const __q) noexcept {
+        // Pre: __u + [0, __u_size), __v + [0, __v_size), and __q + [0, __u_size - __v_size) are all valid ranges
+        // constexpr auto _Int_max = static_cast<size_t>(INT_MAX);
+        // _STL_INTERNAL_CHECK(__v_size <= _Int_max);
+        const int __n = static_cast<int>(__v_size);
+        // _STL_INTERNAL_CHECK(__u_size > __v_size);
+        // _STL_INTERNAL_CHECK(__u_size <= _Int_max);
+        const int __m = static_cast<int>(__u_size - __v_size - 1);
+        // _STL_INTERNAL_CHECK(__v[__n - 1] >> 31 != 0); // Arguments are already normalized
+
+        for (int __j = __m; __j >= 0; --__j) {
+            const auto _Two_digits = (static_cast<uint64_t>(__u[__j + __n]) << 32) | __u[__j + __n - 1];
+            auto __qhat            = _Two_digits / __v[__n - 1];
+            auto __rhat            = _Two_digits % __v[__n - 1];
+
+            while ((__qhat >> 32) != 0
+                   || static_cast<uint32_t>(__qhat) * static_cast<uint64_t>(__v[__n - 2])
+                          > ((__rhat << 32) | __u[__j + __n - 2])) {
+                --__qhat;
+                __rhat += __v[__n - 1];
+                if ((__rhat >> 32) != 0) {
+                    break;
+                }
+            }
+
+            int64_t __k = 0;
+            int64_t __t _ZERO_OR_NO_INIT;
+            for (int __i = 0; __i < __n; ++__i) {
+                const auto _Prod = static_cast<uint32_t>(__qhat) * static_cast<uint64_t>(__v[__i]);
+                __t              = __u[__i + __j] - __k - static_cast<uint32_t>(_Prod);
+                __u[__i + __j]   = static_cast<uint32_t>(__t);
+                __k              = static_cast<int64_t>(_Prod >> 32) - (__t >> 32);
+            }
+            __t            = __u[__j + __n] - __k;
+            __u[__j + __n] = static_cast<uint32_t>(__t);
+
+            __q[__j] = static_cast<uint32_t>(__qhat);
+            if (__t < 0) {
+                --__q[__j];
+                __k = 0;
+                for (int __i = 0; __i < __n; ++__i) {
+                    __t            = __u[__i + __j] + __k + __v[__i];
+                    __u[__i + __j] = static_cast<uint32_t>(__t);
+                    __k            = __t >> 32;
+                }
+                __u[__j + __n] += static_cast<int32_t>(__k);
+            }
+        }
+
+        // quotient is in __q, normalized remainder is in __u
+    }
+
+    _NODISCARD static constexpr uint64_t _UDiv128(
+        uint64_t _High, uint64_t _Low, uint64_t _Div, uint64_t& _Remainder) noexcept {
+        // _STL_INTERNAL_CHECK(_High < _Div);
+
+#if _STL_128_DIV_INTRINSICS
+        if (!_Is_constant_evaluated()) {
+            return _udiv128(_High, _Low, _Div, &_Remainder);
+        }
+#endif // _STL_128_DIV_INTRINSICS
+
+        const auto __d = _Countl_zero(static_cast<uint32_t>(_Div >> 32));
+        if (__d >= 32) { // _Div < 2^32
+            auto _Rem    = (_High << 32) | (_Low >> 32);
+            auto _Result = _Rem / static_cast<uint32_t>(_Div);
+            _Rem         = ((_Rem % static_cast<uint32_t>(_Div)) << 32) | static_cast<uint32_t>(_Low);
+            _Result      = (_Result << 32) | (_Rem / static_cast<uint32_t>(_Div));
+            _Remainder   = _Rem % static_cast<uint32_t>(_Div);
+            return _Result;
+        }
+
+        uint32_t __u[5] = {
+            static_cast<uint32_t>(_Low << __d),
+            static_cast<uint32_t>(_Low >> (32 - __d)),
+            static_cast<uint32_t>(_High << __d),
+            static_cast<uint32_t>(_High >> (32 - __d)),
+            0,
+        };
+        if (__d != 0) {
+            __u[2] |= static_cast<uint32_t>(_Low >> (64 - __d));
+            __u[4] |= static_cast<uint32_t>(_High >> (64 - __d));
+        }
+
+        uint32_t __v[2] = {
+            static_cast<uint32_t>(_Div << __d),
+            static_cast<uint32_t>(_Div >> (32 - __d)),
+        };
+        uint32_t __q[3] _ZERO_OR_NO_INIT;
+
+        _Knuth_4_3_1_D(__u, 5, __v, 2, __q);
+        // _STL_INTERNAL_CHECK(__u[4] == 0);
+        // _STL_INTERNAL_CHECK(__u[3] == 0);
+        // _STL_INTERNAL_CHECK(__u[2] == 0);
+        _Remainder = (static_cast<uint64_t>(__u[1]) << (32 - __d)) | (__u[0] >> __d);
+
+        // _STL_INTERNAL_CHECK(__q[2] == 0);
+        return (static_cast<uint64_t>(__q[1]) << 32) | __q[0];
+    }
+
+    constexpr _Base128() noexcept : _Word{} {}
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Base128(const _Ty _Val) noexcept : _Word{static_cast<uint64_t>(_Val)} {
+#if _HAS_CXX20
+        if constexpr (signed_integral<_Ty>)
+#else
+        if constexpr (is_signed_v<_Ty>)
+#endif
+        {
+            if (_Val < 0) {
+                _Word[1] = ~0ull;
+            }
+        }
+    }
+
+    constexpr explicit _Base128(const uint64_t _Low, const uint64_t _High) noexcept : _Word{_Low, _High} {}
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    _NODISCARD constexpr explicit operator _Ty() const noexcept {
+        return static_cast<_Ty>(_Word[0]);
+    }
+
+    _NODISCARD constexpr explicit operator bool() const noexcept {
+        return (_Word[0] | _Word[1]) != 0;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend constexpr bool operator==(const _Base128&, const _Base128&) noexcept = default;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD friend constexpr bool operator==(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return _Left._Word[0] == _Right._Word[0] && _Left._Word[1] == _Right._Word[1];
+    }
+
+    _NODISCARD friend constexpr bool operator!=(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD friend constexpr bool operator<(const _Base128& _Left, const _Base128& _Right) noexcept {
+        if (_Left._Word[1] < _Right._Word[1]) {
+            return true;
+        }
+
+        if (_Left._Word[1] > _Right._Word[1]) {
+            return false;
+        }
+        return _Left._Word[0] < _Right._Word[0];
+    }
+    _NODISCARD friend constexpr bool operator>(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return _Right < _Left;
+    }
+    _NODISCARD friend constexpr bool operator<=(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return !(_Right < _Left);
+    }
+    _NODISCARD friend constexpr bool operator>=(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return !(_Left < _Right);
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    _NODISCARD friend constexpr _Ty operator<<(const _Ty _Left, const _Base128& _Right) noexcept {
+        return _Left << _Right._Word[0];
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    _NODISCARD friend constexpr _Ty operator>>(const _Ty _Left, const _Base128& _Right) noexcept {
+        return _Left >> _Right._Word[0];
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Base128& operator<<=(const _Ty _Count) noexcept {
+        _Left_shift(static_cast<unsigned char>(_Count));
+        return *this;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator<<=(_Ty& _Left, const _Base128& _Right) noexcept {
+        _Left <<= _Right._Word[0];
+        return _Left;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Base128& operator>>=(const _Ty _Count) noexcept {
+        _Unsigned_right_shift(static_cast<unsigned char>(_Count));
+        return *this;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator>>=(_Ty& _Left, const _Base128& _Right) noexcept {
+        _Left >>= _Right._Word[0];
+        return _Left;
+    }
+
+    constexpr _Base128& operator++() noexcept {
+        if (++_Word[0] == 0) {
+            ++_Word[1];
+        }
+        return *this;
+    }
+    constexpr _Base128 operator++(int) noexcept {
+        auto _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    constexpr _Base128& operator--() noexcept {
+        if (_Word[0]-- == 0) {
+            --_Word[1];
+        }
+        return *this;
+    }
+    constexpr _Base128 operator--(int) noexcept {
+        auto _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _NODISCARD static constexpr _Base128 _Multiply(const _Base128& _Left, const _Base128& _Right) noexcept {
+        _Base128 _Result;
+        _Result._Word[0] = _UMul128(_Left._Word[0], _Right._Word[0], _Result._Word[1]);
+        _Result._Word[1] += _Left._Word[0] * _Right._Word[1];
+        _Result._Word[1] += _Left._Word[1] * _Right._Word[0];
+        return _Result;
+    }
+
+#if !_STL_128_DIV_INTRINSICS
+    _NODISCARD static constexpr _Base128 _Divide(const _Base128& _Num, const uint32_t _Den) noexcept {
+        _Base128 _Result;
+        _Result._Word[1] = _Num._Word[1] / _Den;
+        uint64_t _Rem    = ((_Num._Word[1] % _Den) << 32) | (_Num._Word[0] >> 32);
+        _Result._Word[0] = (_Rem / _Den) << 32;
+        _Rem             = ((_Rem % _Den) << 32) | static_cast<uint32_t>(_Num._Word[0]);
+        _Result._Word[0] |= static_cast<uint32_t>(_Rem / _Den);
+        return _Result;
+    }
+#endif // !_STL_128_DIV_INTRINSICS
+    _NODISCARD static constexpr _Base128 _Divide(const _Base128& _Num, const uint64_t _Den) noexcept {
+        _Base128 _Result;
+        _Result._Word[1] = _Num._Word[1] / _Den;
+        uint64_t _Rem _ZERO_OR_NO_INIT;
+        _Result._Word[0] = _UDiv128(_Num._Word[1] % _Den, _Num._Word[0], _Den, _Rem);
+        return _Result;
+    }
+    _NODISCARD static constexpr _Base128 _Divide(_Base128 _Num, _Base128 _Den) noexcept {
+        // establish _Den < _Num and _Num._Word[1] > 0
+        if (_Den._Word[1] >= _Num._Word[1]) {
+            if (_Den._Word[1] > _Num._Word[1]) {
+                return 0;
+            }
+
+            return _Num._Word[1] == 0 ? _Num._Word[0] / _Den._Word[0] : _Num._Word[0] >= _Den._Word[0];
+        }
+
+        // establish _Den has more than 1 non-zero "digit"
+        if (_Den._Word[1] == 0) {
+#if !_STL_128_DIV_INTRINSICS
+            if (_Den._Word[0] < (1ull << 32)) {
+                return _Divide(_Num, static_cast<uint32_t>(_Den._Word[0]));
+            } else
+#endif // !_STL_128_DIV_INTRINSICS
+            {
+                return _Divide(_Num, _Den._Word[0]);
+            }
+        }
+
+#if _STL_128_INTRINSICS
+        // Knuth 4.3.1D, 2-digit by 2-digit divide in base 2^64
+        // _STL_INTERNAL_CHECK(_Den._Word[1] != 0);
+        // _STL_INTERNAL_CHECK(_Num._Word[1] > _Den._Word[1]);
+        // Normalize by shifting both left until _Den's high bit is set (So _Den's high digit is >= b / 2)
+        const auto __d = _Countl_zero(_Den._Word[1]);
+        _Den <<= __d;
+        auto _High_digit = __d == 0 ? 0 : _Num._Word[1] >> (64 - __d); // This creates a third digit for _Num
+        _Num <<= __d;
+
+        _Base128 __qhat;
+        __qhat._Word[1] = _High_digit >= _Den._Word[1];
+        uint64_t __rhat _ZERO_OR_NO_INIT;
+        __qhat._Word[0] = _UDiv128(_High_digit >= _Den._Word[1] ? _High_digit - _Den._Word[1] : _High_digit,
+            _Num._Word[1], _Den._Word[1], __rhat);
+
+        for (;;) {
+            if (__qhat._Word[1] > 0) {
+                --__qhat;
+            } else {
+                _Base128 _Prod;
+                _Prod._Word[0] = _UMul128(__qhat._Word[0], _Den._Word[0], _Prod._Word[1]);
+                if (_Prod <= _Base128{_Num._Word[0], __rhat}) {
+                    break;
+                }
+                --__qhat._Word[0];
+            }
+
+            const auto _Sum = __rhat + _Den._Word[1];
+            if (__rhat > _Sum) {
+                break;
+            }
+            __rhat = _Sum;
+        }
+        // _STL_INTERNAL_CHECK(__qhat._Word[1] == 0);
+
+        // [_High_digit | _Num] -= __qhat * _Den [Since __qhat < b, this is 3-digit - 1-digit * 2-digit]
+        uint64_t _Prod0_hi _ZERO_OR_NO_INIT;
+        uint64_t _Prod_lo = _UMul128(__qhat._Word[0], _Den._Word[0], _Prod0_hi);
+        auto _Borrow      = _SubBorrow64(0, _Num._Word[0], _Prod_lo, _Num._Word[0]);
+        uint64_t _Prod1_hi _ZERO_OR_NO_INIT;
+        _Prod_lo = _UMul128(__qhat._Word[0], _Den._Word[1], _Prod1_hi);
+        _Prod1_hi += _AddCarry64(0, _Prod_lo, _Prod0_hi, _Prod_lo);
+        _Borrow = _SubBorrow64(_Borrow, _Num._Word[1], _Prod_lo, _Num._Word[1]);
+        _Borrow = _SubBorrow64(_Borrow, _High_digit, _Prod1_hi, _High_digit);
+        if (_Borrow) {
+            --__qhat._Word[0];
+        }
+        return __qhat;
+#else // ^^^ 128-bit intrinsics / no such intrinsics vvv
+        auto __d                   = _Countl_zero(_Den._Word[1]);
+        const bool _Three_word_den = __d >= 32;
+        __d &= 31;
+        uint32_t __u[5]{
+            static_cast<uint32_t>(_Num._Word[0] << __d),
+            static_cast<uint32_t>(_Num._Word[0] >> (32 - __d)),
+            static_cast<uint32_t>(_Num._Word[1] << __d),
+            static_cast<uint32_t>(_Num._Word[1] >> (32 - __d)),
+            0,
+        };
+        uint32_t __v[4] = {
+            static_cast<uint32_t>(_Den._Word[0] << __d),
+            static_cast<uint32_t>(_Den._Word[0] >> (32 - __d)),
+            static_cast<uint32_t>(_Den._Word[1] << __d),
+            static_cast<uint32_t>(_Den._Word[1] >> (32 - __d)),
+        };
+        if (__d != 0) {
+            __u[2] |= _Num._Word[0] >> (64 - __d);
+            __u[4] |= _Num._Word[1] >> (64 - __d);
+            __v[2] |= _Den._Word[0] >> (64 - __d);
+        }
+
+        uint32_t __q[2] _ZERO_OR_NO_INIT;
+        if (_Three_word_den) {
+            // 4-digit by 3-digit base 2^32 division
+            _Knuth_4_3_1_D(__u, 5, __v, 3, __q);
+        } else {
+            // 4-digit by 4-digit base 2^32 division
+            _Knuth_4_3_1_D(__u, 5, __v, 4, __q);
+            __q[1] = 0;
+        }
+
+        return (static_cast<uint64_t>(__q[1]) << 32) | __q[0];
+#endif // _STL_128_INTRINSICS
+    }
+
+#if !_STL_128_DIV_INTRINSICS
+    _NODISCARD static constexpr _Base128 _Modulo(const _Base128& _Num, const uint32_t _Den) noexcept {
+        uint64_t _Rem = _Num._Word[1];
+        _Rem          = ((_Rem % _Den) << 32) | (_Num._Word[0] >> 32);
+        _Rem          = ((_Rem % _Den) << 32) | static_cast<uint32_t>(_Num._Word[0]);
+        return _Rem % _Den;
+    }
+#endif // !_STL_128_DIV_INTRINSICS
+    _NODISCARD static constexpr _Base128 _Modulo(const _Base128& _Num, const uint64_t _Den) noexcept {
+        uint64_t _Rem _ZERO_OR_NO_INIT;
+        (void) _UDiv128(_Num._Word[1] % _Den, _Num._Word[0], _Den, _Rem);
+        return _Rem;
+    }
+    _NODISCARD static constexpr _Base128 _Modulo(_Base128 _Num, _Base128 _Den) noexcept {
+        // establish _Den < _Num and _Num._Word[1] > 0
+        if (_Den._Word[1] >= _Num._Word[1]) {
+            if (_Den._Word[1] > _Num._Word[1]) {
+                return _Num;
+            }
+
+            if (_Den._Word[0] <= _Num._Word[0]) {
+                return _Num._Word[1] == 0 ? _Num._Word[0] % _Den._Word[0] : _Num._Word[0] - _Den._Word[0];
+            }
+
+            return _Num;
+        }
+
+        // establish _Den has more than 1 non-zero "digit"
+        if (_Den._Word[1] == 0) {
+#if !_STL_128_DIV_INTRINSICS
+            if (_Den._Word[0] < (1ull << 32)) {
+                return _Modulo(_Num, static_cast<uint32_t>(_Den._Word[0]));
+            } else
+#endif // !_STL_128_DIV_INTRINSICS
+            {
+                return _Modulo(_Num, _Den._Word[0]);
+            }
+        }
+
+#if _STL_128_INTRINSICS
+        // Knuth 4.3.1D, 2-digit by 2-digit divide in base 2^64
+        // _STL_INTERNAL_CHECK(_Den._Word[1] != 0);
+        // _STL_INTERNAL_CHECK(_Num._Word[1] > _Den._Word[1]);
+        // Normalize by shifting both left until _Den's high bit is set (So _Den's high digit is >= b / 2)
+        const auto __d = _Countl_zero(_Den._Word[1]);
+        _Den <<= __d;
+        auto _High_digit = __d == 0 ? 0 : _Num._Word[1] >> (64 - __d); // This creates a third digit for _Num
+        _Num <<= __d;
+
+        uint64_t __qhat_high = _High_digit >= _Den._Word[1];
+        uint64_t __rhat _ZERO_OR_NO_INIT;
+        uint64_t __qhat = _UDiv128(_High_digit >= _Den._Word[1] ? _High_digit - _Den._Word[1] : _High_digit,
+            _Num._Word[1], _Den._Word[1], __rhat);
+
+        for (;;) {
+            if (__qhat_high > 0) {
+                if (__qhat-- == 0) {
+                    --__qhat_high;
+                }
+            } else {
+                _Base128 _Prod;
+                _Prod._Word[0] = _UMul128(__qhat, _Den._Word[0], _Prod._Word[1]);
+                if (_Prod <= _Base128{_Num._Word[0], __rhat}) {
+                    break;
+                }
+                --__qhat;
+            }
+
+            const auto _Sum = __rhat + _Den._Word[1];
+            if (__rhat > _Sum) {
+                break;
+            }
+            __rhat = _Sum;
+            // The addition didn't overflow, so `__rhat < b` holds
+        }
+        // _STL_INTERNAL_CHECK(__qhat_high == 0);
+
+        // [_High_digit | _Num] -= __qhat * _Den [3-digit - 1-digit * 2-digit]
+        uint64_t _Prod0_hi _ZERO_OR_NO_INIT;
+        uint64_t _Prod_lo = _UMul128(__qhat, _Den._Word[0], _Prod0_hi);
+        auto _Borrow      = _SubBorrow64(0, _Num._Word[0], _Prod_lo, _Num._Word[0]);
+        uint64_t _Prod1_hi _ZERO_OR_NO_INIT;
+        _Prod_lo = _UMul128(__qhat, _Den._Word[1], _Prod1_hi);
+        _Prod1_hi += _AddCarry64(0, _Prod_lo, _Prod0_hi, _Prod_lo);
+        _Borrow = _SubBorrow64(_Borrow, _Num._Word[1], _Prod_lo, _Num._Word[1]);
+        _Borrow = _SubBorrow64(_Borrow, _High_digit, _Prod1_hi, _High_digit);
+        if (_Borrow) {
+            auto _Carry = _AddCarry64(0, _Num._Word[0], _Den._Word[0], _Num._Word[0]);
+            (void) _AddCarry64(_Carry, _Num._Word[1], _Den._Word[1], _Num._Word[1]);
+        }
+#else // ^^^ 128-bit intrinsics / no such intrinsics vvv
+        auto __d                   = _Countl_zero(_Den._Word[1]);
+        const bool _Three_word_den = __d >= 32;
+        __d &= 31;
+        uint32_t __u[5]{
+            static_cast<uint32_t>(_Num._Word[0] << __d),
+            static_cast<uint32_t>(_Num._Word[0] >> (32 - __d)),
+            static_cast<uint32_t>(_Num._Word[1] << __d),
+            static_cast<uint32_t>(_Num._Word[1] >> (32 - __d)),
+            0,
+        };
+        uint32_t __v[4] = {
+            static_cast<uint32_t>(_Den._Word[0] << __d),
+            static_cast<uint32_t>(_Den._Word[0] >> (32 - __d)),
+            static_cast<uint32_t>(_Den._Word[1] << __d),
+            static_cast<uint32_t>(_Den._Word[1] >> (32 - __d)),
+        };
+        if (__d != 0) {
+            __u[2] |= _Num._Word[0] >> (64 - __d);
+            __u[4] |= _Num._Word[1] >> (64 - __d);
+            __v[2] |= _Den._Word[0] >> (64 - __d);
+        }
+
+        uint32_t __q[2] _ZERO_OR_NO_INIT;
+        if (_Three_word_den) {
+            // 4-digit by 3-digit base 2^32 division
+            _Knuth_4_3_1_D(__u, 5, __v, 3, __q);
+            // _STL_INTERNAL_CHECK(__u[3] == 0);
+        } else {
+            // 4-digit by 4-digit base 2^32 division
+            _Knuth_4_3_1_D(__u, 5, __v, 4, __q);
+        }
+        // _STL_INTERNAL_CHECK(__u[4] == 0);
+
+        _Num._Word[0] = (static_cast<uint64_t>(__u[1]) << 32) | __u[0];
+        _Num._Word[1] = (static_cast<uint64_t>(__u[3]) << 32) | __u[2];
+#endif // _STL_128_INTRINSICS
+        _Num >>= __d;
+        return _Num;
+    }
+
+#if _HAS_CXX23
+#if !_STL_128_DIV_INTRINSICS
+    _NODISCARD static constexpr _Base128 _Div_ceil(const _Base128& _Num, const uint32_t _Den) noexcept {
+        _Base128 _Result;
+        _Result._Word[1] = _Num._Word[1] / _Den;
+        uint64_t _Rem    = ((_Num._Word[1] % _Den) << 32) | (_Num._Word[0] >> 32);
+        _Result._Word[0] = (_Rem / _Den) << 32;
+        _Rem             = ((_Rem % _Den) << 32) | static_cast<uint32_t>(_Num._Word[0]);
+        _Result._Word[0] |= static_cast<uint32_t>(_Rem / _Den);
+        if (_Rem % _Den != 0) {
+            ++_Result;
+        }
+
+        return _Result;
+    }
+#endif // !_STL_128_DIV_INTRINSICS
+
+    _NODISCARD static constexpr _Base128 _Div_ceil(const _Base128& _Num, const uint64_t _Den) noexcept {
+        _Base128 _Result;
+        _Result._Word[1] = _Num._Word[1] / _Den;
+        uint64_t _Rem;
+        _Result._Word[0] = _UDiv128(_Num._Word[1] % _Den, _Num._Word[0], _Den, _Rem);
+        if (_Rem != 0) {
+            ++_Result;
+        }
+
+        return _Result;
+    }
+
+    _NODISCARD static constexpr _Base128 _Div_ceil(_Base128 _Num, _Base128 _Den) noexcept {
+        // establish _Den < _Num and _Num._Word[1] > 0
+        if (_Den._Word[1] >= _Num._Word[1]) {
+            if (_Den._Word[1] > _Num._Word[1]) {
+                return static_cast<_Base128>(_Num != 0);
+            }
+
+            if (_Num._Word[1] == 0) {
+                uint64_t _Result = _Num._Word[0] / _Den._Word[0]; // with 64-bit inputs, the ceiling is also 64-bit
+                if (_Num._Word[0] % _Den._Word[0] != 0) {
+                    ++_Result;
+                }
+
+                return _Result;
+            }
+
+            if (_Num._Word[0] > _Den._Word[0]) {
+                return 2u;
+            }
+
+            return 1u;
+        }
+
+        // establish _Den has more than 1 non-zero "digit"
+        if (_Den._Word[1] == 0) {
+#if !_STL_128_DIV_INTRINSICS
+            if (_Den._Word[0] < (1ull << 32)) {
+                return _Div_ceil(_Num, static_cast<uint32_t>(_Den._Word[0]));
+            } else
+#endif // !_STL_128_DIV_INTRINSICS
+            {
+                return _Div_ceil(_Num, _Den._Word[0]);
+            }
+        }
+
+        _Base128 _Result;
+#if _STL_128_INTRINSICS
+        // Knuth 4.3.1D, 2-digit by 2-digit divide in base 2^64
+        // _STL_INTERNAL_CHECK(_Den._Word[1] != 0);
+        // _STL_INTERNAL_CHECK(_Num._Word[1] > _Den._Word[1]);
+        // Normalize by shifting both left until _Den's high bit is set (So _Den's high digit is >= b / 2)
+        const auto __d = _STD _Countl_zero(_Den._Word[1]);
+        _Den <<= __d;
+        auto _High_digit = __d == 0 ? 0 : _Num._Word[1] >> (64 - __d); // This creates a third digit for _Num
+        _Num <<= __d;
+
+        _Base128 __qhat;
+        __qhat._Word[1] = _High_digit >= _Den._Word[1];
+        uint64_t __rhat;
+        __qhat._Word[0] = _UDiv128(_High_digit >= _Den._Word[1] ? _High_digit - _Den._Word[1] : _High_digit,
+            _Num._Word[1], _Den._Word[1], __rhat);
+
+        for (;;) {
+            if (__qhat._Word[1] > 0) {
+                --__qhat;
+            } else {
+                _Base128 _Prod;
+                _Prod._Word[0] = _UMul128(__qhat._Word[0], _Den._Word[0], _Prod._Word[1]);
+                if (_Prod <= _Base128{_Num._Word[0], __rhat}) {
+                    break;
+                }
+                --__qhat._Word[0];
+            }
+
+            const auto _Sum = __rhat + _Den._Word[1];
+            if (__rhat > _Sum) {
+                break;
+            }
+            __rhat = _Sum;
+        }
+        // _STL_INTERNAL_CHECK(__qhat._Word[1] == 0);
+
+        // [_High_digit | _Num] -= __qhat * _Den [Since __qhat < b, this is 3-digit - 1-digit * 2-digit]
+        uint64_t _Prod0_hi;
+        uint64_t _Prod_lo = _UMul128(__qhat._Word[0], _Den._Word[0], _Prod0_hi);
+        auto _Borrow      = _SubBorrow64(0, _Num._Word[0], _Prod_lo, _Num._Word[0]);
+        uint64_t _Prod1_hi;
+        _Prod_lo = _UMul128(__qhat._Word[0], _Den._Word[1], _Prod1_hi);
+        _Prod1_hi += _AddCarry64(0, _Prod_lo, _Prod0_hi, _Prod_lo);
+        _Borrow = _SubBorrow64(_Borrow, _Num._Word[1], _Prod_lo, _Num._Word[1]);
+        _Borrow = _SubBorrow64(_Borrow, _High_digit, _Prod1_hi, _High_digit);
+        if (_Borrow) {
+            --__qhat._Word[0];
+            auto _Carry = _AddCarry64(0, _Num._Word[0], _Den._Word[0], _Num._Word[0]);
+            (void) _AddCarry64(_Carry, _Num._Word[1], _Den._Word[1], _Num._Word[1]);
+        }
+        _Result = __qhat;
+#else // ^^^ 128-bit intrinsics / no such intrinsics vvv
+        auto __d                   = _Countl_zero(_Den._Word[1]);
+        const bool _Three_word_den = __d >= 32;
+        __d &= 31;
+        uint32_t __u[5]{
+            static_cast<uint32_t>(_Num._Word[0] << __d),
+            static_cast<uint32_t>(_Num._Word[0] >> (32 - __d)),
+            static_cast<uint32_t>(_Num._Word[1] << __d),
+            static_cast<uint32_t>(_Num._Word[1] >> (32 - __d)),
+            0,
+        };
+        uint32_t __v[4] = {
+            static_cast<uint32_t>(_Den._Word[0] << __d),
+            static_cast<uint32_t>(_Den._Word[0] >> (32 - __d)),
+            static_cast<uint32_t>(_Den._Word[1] << __d),
+            static_cast<uint32_t>(_Den._Word[1] >> (32 - __d)),
+        };
+        if (__d != 0) {
+            __u[2] |= _Num._Word[0] >> (64 - __d);
+            __u[4] |= _Num._Word[1] >> (64 - __d);
+            __v[2] |= _Den._Word[0] >> (64 - __d);
+        }
+
+        uint32_t __q[2] = {};
+        if (_Three_word_den) {
+            // 4-digit by 3-digit base 2^32 division
+            _Knuth_4_3_1_D(__u, 5, __v, 3, __q);
+            // _STL_INTERNAL_CHECK(__u[3] == 0);
+        } else {
+            // 4-digit by 4-digit base 2^32 division
+            _Knuth_4_3_1_D(__u, 5, __v, 4, __q);
+        }
+
+        _Result       = (static_cast<uint64_t>(__q[1]) << 32) | __q[0];
+        _Num._Word[0] = (static_cast<uint64_t>(__u[1]) << 32) | __u[0];
+        _Num._Word[1] = (static_cast<uint64_t>(__u[3]) << 32) | __u[2];
+#endif // _STL_128_INTRINSICS
+
+        if (_Num != 0) {
+            ++_Result;
+        }
+
+        return _Result;
+    }
+#endif // _HAS_CXX23
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator&=(_Ty& _Left, const _Base128& _Right) noexcept {
+        _Left &= _Right._Word[0];
+        return _Left;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator^=(_Ty& _Left, const _Base128& _Right) noexcept {
+        _Left ^= _Right._Word[0];
+        return _Left;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator|=(_Ty& _Left, const _Base128& _Right) noexcept {
+        _Left |= _Right._Word[0];
+        return _Left;
+    }
+};
+
+struct _Signed128;
+
+struct _Unsigned128 : _Base128 {
+    using _Signed_type   = _Signed128;
+    using _Unsigned_type = _Unsigned128;
+
+#if !_HAS_CXX17
+    constexpr _Unsigned128() noexcept : _Base128{} {}
+#endif // !_HAS_CXX17
+
+    using _Base128::_Base128;
+    constexpr explicit _Unsigned128(const _Base128& _That) noexcept : _Base128{_That} {}
+
+    constexpr _Unsigned128& operator=(const _Base128& _That) noexcept {
+        _Base128::operator=(_That);
+        return *this;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend constexpr strong_ordering operator<=>(
+        const _Unsigned128& _Left, const _Unsigned128& _Right) noexcept {
+        strong_ordering _Ord = _Left._Word[1] <=> _Right._Word[1];
+        if (_Ord == strong_ordering::equal) {
+            _Ord = _Left._Word[0] <=> _Right._Word[0];
+        }
+        return _Ord;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD friend constexpr bool operator<(const _Unsigned128& _Left, const _Unsigned128& _Right) noexcept {
+        if (_Left._Word[1] < _Right._Word[1]) {
+            return true;
+        }
+
+        if (_Right._Word[1] < _Left._Word[1]) {
+            return false;
+        }
+
+        return _Left._Word[0] < _Right._Word[0];
+    }
+
+    _NODISCARD friend constexpr bool operator>(const _Unsigned128& _Left, const _Unsigned128& _Right) noexcept {
+        return _Right < _Left;
+    }
+
+    _NODISCARD friend constexpr bool operator<=(const _Unsigned128& _Left, const _Unsigned128& _Right) noexcept {
+        return !(_Right < _Left);
+    }
+
+    _NODISCARD friend constexpr bool operator>=(const _Unsigned128& _Left, const _Unsigned128& _Right) noexcept {
+        return !(_Left < _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD friend constexpr _Unsigned128 operator<<(const _Unsigned128& _Left, const _Base128& _Right) noexcept {
+        auto _Tmp{_Left};
+        _Tmp._Left_shift(static_cast<unsigned char>(_Right._Word[0]));
+        return _Tmp;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Unsigned128& operator<<=(const _Ty _Count) noexcept {
+        _Left_shift(static_cast<unsigned char>(_Count));
+        return *this;
+    }
+    constexpr _Unsigned128& operator<<=(const _Base128& _Count) noexcept {
+        _Left_shift(static_cast<unsigned char>(_Count._Word[0]));
+        return *this;
+    }
+
+    _NODISCARD friend constexpr _Unsigned128 operator>>(const _Unsigned128& _Left, const _Base128& _Right) noexcept {
+        auto _Tmp{_Left};
+        _Tmp._Unsigned_right_shift(static_cast<unsigned char>(_Right._Word[0]));
+        return _Tmp;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Unsigned128& operator>>=(const _Ty _Count) noexcept {
+        _Unsigned_right_shift(static_cast<unsigned char>(_Count));
+        return *this;
+    }
+    constexpr _Unsigned128& operator>>=(const _Base128& _Count) noexcept {
+        _Unsigned_right_shift(static_cast<unsigned char>(_Count._Word[0]));
+        return *this;
+    }
+
+    constexpr _Unsigned128& operator++() noexcept {
+        if (++_Word[0] == 0) {
+            ++_Word[1];
+        }
+        return *this;
+    }
+    constexpr _Unsigned128 operator++(int) noexcept {
+        auto _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    constexpr _Unsigned128& operator--() noexcept {
+        if (_Word[0]-- == 0) {
+            --_Word[1];
+        }
+        return *this;
+    }
+    constexpr _Unsigned128 operator--(int) noexcept {
+        auto _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _NODISCARD constexpr _Unsigned128 operator+() const noexcept {
+        return *this;
+    }
+
+    _NODISCARD constexpr _Unsigned128 operator-() const noexcept {
+        return _Unsigned128{} - *this;
+    }
+
+    _NODISCARD constexpr _Unsigned128 operator~() const noexcept {
+        return _Unsigned128{~_Word[0], ~_Word[1]};
+    }
+
+    _NODISCARD friend constexpr _Unsigned128 operator+(const _Base128& _Left, const _Base128& _Right) noexcept {
+        _Unsigned128 _Result;
+        const auto _Carry = _AddCarry64(0, _Left._Word[0], _Right._Word[0], _Result._Word[0]);
+        _AddCarry64(_Carry, _Left._Word[1], _Right._Word[1], _Result._Word[1]);
+        return _Result;
+    }
+
+    constexpr _Unsigned128& operator+=(const _Base128& _That) noexcept {
+        const auto _Carry = _AddCarry64(0, _Word[0], _That._Word[0], _Word[0]);
+        _AddCarry64(_Carry, _Word[1], _That._Word[1], _Word[1]);
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator+=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
+        _Left += _Right._Word[0];
+        return _Left;
+    }
+
+    _NODISCARD friend constexpr _Unsigned128 operator-(const _Base128& _Left, const _Base128& _Right) noexcept {
+        _Unsigned128 _Result;
+        const auto _Borrow = _SubBorrow64(0, _Left._Word[0], _Right._Word[0], _Result._Word[0]);
+        _SubBorrow64(_Borrow, _Left._Word[1], _Right._Word[1], _Result._Word[1]);
+        return _Result;
+    }
+
+    constexpr _Unsigned128& operator-=(const _Base128& _That) noexcept {
+        const auto _Borrow = _SubBorrow64(0, _Word[0], _That._Word[0], _Word[0]);
+        _SubBorrow64(_Borrow, _Word[1], _That._Word[1], _Word[1]);
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator-=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
+        _Left -= _Right._Word[0];
+        return _Left;
+    }
+
+    _NODISCARD friend constexpr _Unsigned128 operator*(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return _Unsigned128{_Base128::_Multiply(_Left, _Right)};
+    }
+
+    constexpr _Unsigned128& operator*=(const _Base128& _That) noexcept {
+        *this = *this * _That;
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator*=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
+        _Left *= _Right._Word[0];
+        return _Left;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    _NODISCARD friend constexpr _Unsigned128 operator/(const _Unsigned128& _Num, const _Ty _Den) noexcept {
+#if !_STL_128_DIV_INTRINSICS
+        if constexpr (sizeof(_Ty) <= 4) {
+            return _Unsigned128{_Base128::_Divide(_Num, static_cast<uint32_t>(_Den))};
+        } else
+#endif // !_STL_128_DIV_INTRINSICS
+        {
+            return _Unsigned128{_Base128::_Divide(_Num, static_cast<uint64_t>(_Den))};
+        }
+    }
+    _NODISCARD friend constexpr _Unsigned128 operator/(const _Base128& _Num, const _Base128& _Den) noexcept {
+        return _Unsigned128{_Base128::_Divide(_Num, _Den)};
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Unsigned128& operator/=(const _Ty _That) noexcept {
+#if !_STL_128_DIV_INTRINSICS
+        if constexpr (sizeof(_Ty) <= 4) {
+            *this = _Unsigned128{_Base128::_Divide(*this, static_cast<uint32_t>(_That))};
+        } else
+#endif // !_STL_128_DIV_INTRINSICS
+        {
+            *this = _Unsigned128{_Base128::_Divide(*this, static_cast<uint64_t>(_That))};
+        }
+        return *this;
+    }
+    constexpr _Unsigned128& operator/=(const _Base128& _That) noexcept {
+        *this = _Unsigned128{_Base128::_Divide(*this, _That)};
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator/=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
+        if (_Right._Word[1] != 0) {
+            _Left = 0;
+        } else {
+            _Left /= _Right._Word[0];
+        }
+        return _Left;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    _NODISCARD friend constexpr _Unsigned128 operator%(const _Base128& _Num, const _Ty _Den) noexcept {
+#if !_STL_128_DIV_INTRINSICS
+        if constexpr (sizeof(_Ty) <= 4) {
+            return _Unsigned128{_Base128::_Modulo(_Num, static_cast<uint32_t>(_Den))};
+        } else
+#endif // !_STL_128_DIV_INTRINSICS
+        {
+            return _Unsigned128{_Base128::_Modulo(_Num, static_cast<uint64_t>(_Den))};
+        }
+    }
+    _NODISCARD friend constexpr _Unsigned128 operator%(const _Base128& _Num, const _Base128& _Den) noexcept {
+        return _Unsigned128{_Base128::_Modulo(_Num, _Den)};
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Unsigned128& operator%=(const _Ty _Den) noexcept {
+        *this = *this % _Den;
+        return *this;
+    }
+    constexpr _Unsigned128& operator%=(const _Base128& _Den) noexcept {
+        *this = *this % _Den;
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator%=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
+        if (_Right._Word[1] == 0) {
+            _Left %= _Right._Word[0];
+        }
+        return _Left;
+    }
+
+    _NODISCARD friend constexpr _Unsigned128 operator&(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return _Unsigned128{_Left._Word[0] & _Right._Word[0], _Left._Word[1] & _Right._Word[1]};
+    }
+
+    constexpr _Unsigned128& operator&=(const _Base128& _That) noexcept {
+        _Word[0] &= _That._Word[0];
+        _Word[1] &= _That._Word[1];
+        return *this;
+    }
+
+    _NODISCARD friend constexpr _Unsigned128 operator^(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return _Unsigned128{_Left._Word[0] ^ _Right._Word[0], _Left._Word[1] ^ _Right._Word[1]};
+    }
+
+    constexpr _Unsigned128& operator^=(const _Base128& _That) noexcept {
+        _Word[0] ^= _That._Word[0];
+        _Word[1] ^= _That._Word[1];
+        return *this;
+    }
+
+    _NODISCARD friend constexpr _Unsigned128 operator|(const _Base128& _Left, const _Base128& _Right) noexcept {
+        return _Unsigned128{_Left._Word[0] | _Right._Word[0], _Left._Word[1] | _Right._Word[1]};
+    }
+
+    constexpr _Unsigned128& operator|=(const _Base128& _That) noexcept {
+        _Word[0] |= _That._Word[0];
+        _Word[1] |= _That._Word[1];
+        return *this;
+    }
+};
+
+template <>
+class numeric_limits<_Unsigned128> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr _Unsigned128(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Unsigned128(max)() noexcept {
+        return _Unsigned128{~0ull, ~0ull};
+    }
+
+    _NODISCARD static constexpr _Unsigned128 lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr _Unsigned128 epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Unsigned128 round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Unsigned128 denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Unsigned128 infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Unsigned128 quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Unsigned128 signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr int digits     = 128;
+    static constexpr int digits10   = 38;
+};
+
+struct _Signed128 : _Base128 {
+    using _Signed_type   = _Signed128;
+    using _Unsigned_type = _Unsigned128;
+
+#if !_HAS_CXX17
+    constexpr _Signed128() noexcept : _Base128{} {}
+#endif // !_HAS_CXX17
+
+    using _Base128::_Base128;
+    constexpr explicit _Signed128(const _Base128& _That) noexcept : _Base128{_That} {}
+
+    constexpr _Signed128& operator=(const _Base128& _That) noexcept {
+        _Base128::operator=(_That);
+        return *this;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend constexpr strong_ordering operator<=>(
+        const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        strong_ordering _Ord = static_cast<int64_t>(_Left._Word[1]) <=> static_cast<int64_t>(_Right._Word[1]);
+        if (_Ord == strong_ordering::equal) {
+            _Ord = _Left._Word[0] <=> _Right._Word[0];
+        }
+        return _Ord;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD friend constexpr bool operator<(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        if (static_cast<int64_t>(_Left._Word[1]) < static_cast<int64_t>(_Right._Word[1])) {
+            return true;
+        }
+
+        if (static_cast<int64_t>(_Right._Word[1]) < static_cast<int64_t>(_Left._Word[1])) {
+            return false;
+        }
+
+        return _Left._Word[0] < _Right._Word[0];
+    }
+
+    _NODISCARD friend constexpr bool operator>(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        return _Right < _Left;
+    }
+
+    _NODISCARD friend constexpr bool operator<=(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        return !(_Right < _Left);
+    }
+
+    _NODISCARD friend constexpr bool operator>=(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        return !(_Left < _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD friend constexpr _Signed128 operator<<(const _Signed128& _Left, const _Base128& _Right) noexcept {
+        auto _Tmp{_Left};
+        _Tmp._Left_shift(static_cast<unsigned char>(_Right._Word[0]));
+        return _Tmp;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Signed128& operator<<=(const _Ty _Count) noexcept {
+        _Left_shift(static_cast<unsigned char>(_Count));
+        return *this;
+    }
+    constexpr _Signed128& operator<<=(const _Base128& _Count) noexcept {
+        _Left_shift(static_cast<unsigned char>(_Count._Word[0]));
+        return *this;
+    }
+
+    constexpr void _Signed_right_shift(const unsigned char _Count) noexcept {
+        if (_Count == 0) {
+            return;
+        }
+
+        if (_Count >= 64) {
+            _Word[0] = static_cast<uint64_t>(static_cast<int64_t>(_Word[1]) >> (_Count % 64));
+            _Word[1] = (_Word[1] & (1ull << 63)) == 0 ? 0 : ~0ull;
+            return;
+        }
+
+#if _STL_128_INTRINSICS
+        if (!_Is_constant_evaluated()) {
+            _Word[0] = __shiftright128(_Word[0], _Word[1], _Count);
+        } else
+#endif // _STL_128_INTRINSICS
+        {
+            _Word[0] = (_Word[0] >> _Count) | (_Word[1] << (64 - _Count));
+        }
+
+        _Word[1] = static_cast<uint64_t>(static_cast<int64_t>(_Word[1]) >> _Count);
+    }
+
+    _NODISCARD friend constexpr _Signed128 operator>>(const _Signed128& _Left, const _Base128& _Right) noexcept {
+        auto _Tmp{_Left};
+        _Tmp._Signed_right_shift(static_cast<unsigned char>(_Right._Word[0]));
+        return _Tmp;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Signed128& operator>>=(const _Ty _Count) noexcept {
+        _Signed_right_shift(static_cast<unsigned char>(_Count));
+        return *this;
+    }
+    constexpr _Signed128& operator>>=(const _Base128& _Count) noexcept {
+        _Signed_right_shift(static_cast<unsigned char>(_Count._Word[0]));
+        return *this;
+    }
+
+    constexpr _Signed128& operator++() noexcept {
+        if (++_Word[0] == 0) {
+            ++_Word[1];
+        }
+        return *this;
+    }
+    constexpr _Signed128 operator++(int) noexcept {
+        auto _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    constexpr _Signed128& operator--() noexcept {
+        if (_Word[0]-- == 0) {
+            --_Word[1];
+        }
+        return *this;
+    }
+    constexpr _Signed128 operator--(int) noexcept {
+        auto _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _NODISCARD constexpr _Signed128 operator+() const noexcept {
+        return *this;
+    }
+
+    _NODISCARD constexpr _Signed128 operator-() const noexcept {
+        return _Signed128{} - *this;
+    }
+
+    _NODISCARD constexpr _Signed128 operator~() const noexcept {
+        return _Signed128{~_Word[0], ~_Word[1]};
+    }
+
+    _NODISCARD friend constexpr _Signed128 operator+(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        _Signed128 _Result;
+        const auto _Carry = _AddCarry64(0, _Left._Word[0], _Right._Word[0], _Result._Word[0]);
+        _AddCarry64(_Carry, _Left._Word[1], _Right._Word[1], _Result._Word[1]);
+        return _Result;
+    }
+
+    constexpr _Signed128& operator+=(const _Base128& _That) noexcept {
+        const auto _Carry = _AddCarry64(0, _Word[0], _That._Word[0], _Word[0]);
+        _AddCarry64(_Carry, _Word[1], _That._Word[1], _Word[1]);
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator+=(_Ty& _Left, const _Signed128& _Right) noexcept {
+        _Left = static_cast<_Ty>(_Signed128{_Left} + _Right);
+        return _Left;
+    }
+
+    _NODISCARD friend constexpr _Signed128 operator-(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        _Signed128 _Result;
+        const auto _Borrow = _SubBorrow64(0, _Left._Word[0], _Right._Word[0], _Result._Word[0]);
+        _SubBorrow64(_Borrow, _Left._Word[1], _Right._Word[1], _Result._Word[1]);
+        return _Result;
+    }
+
+    constexpr _Signed128& operator-=(const _Base128& _That) noexcept {
+        const auto _Borrow = _SubBorrow64(0, _Word[0], _That._Word[0], _Word[0]);
+        _SubBorrow64(_Borrow, _Word[1], _That._Word[1], _Word[1]);
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator-=(_Ty& _Left, const _Signed128& _Right) noexcept {
+        _Left = static_cast<_Ty>(_Signed128{_Left} - _Right);
+        return _Left;
+    }
+
+    constexpr void _Strip_negative(bool& _Flip) noexcept {
+        if ((_Word[1] & (1ull << 63)) != 0) {
+            *this = -*this;
+            _Flip = !_Flip;
+        }
+    }
+
+    _NODISCARD friend constexpr _Signed128 operator*(_Signed128 _Left, _Signed128 _Right) noexcept {
+        bool _Negative = false;
+        _Left._Strip_negative(_Negative);
+        _Right._Strip_negative(_Negative);
+        _Signed128 _Result{_Base128::_Multiply(_Left, _Right)};
+        if (_Negative) {
+            _Result = -_Result;
+        }
+        return _Result;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Signed128& operator*=(const _Ty _That) noexcept {
+        *this = *this * _That;
+        return *this;
+    }
+    constexpr _Signed128& operator*=(const _Signed128& _That) noexcept {
+        *this = *this * _That;
+        return *this;
+    }
+    constexpr _Signed128& operator*=(const _Unsigned128& _That) noexcept {
+        *this = _Signed128{static_cast<const _Base128&>(*this) * _That};
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator*=(_Ty& _Left, const _Signed128& _Right) noexcept {
+        _Left = static_cast<_Ty>(_Signed128{_Left} * _Right);
+        return _Left;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    _NODISCARD friend constexpr _Signed128 operator/(_Signed128 _Num, _Ty _Den) noexcept {
+        bool _Negative = false;
+        _Num._Strip_negative(_Negative);
+        if constexpr (is_signed_v<_Ty>) {
+            if (_Den < 0) {
+                _Den      = -_Den;
+                _Negative = !_Negative;
+            }
+        }
+
+        _Signed128 _Result;
+#if !_STL_128_DIV_INTRINSICS
+        if constexpr (sizeof(_Ty) <= 4) {
+            _Result = _Signed128{_Base128::_Divide(_Num, static_cast<uint32_t>(_Den))};
+        } else
+#endif // !_STL_128_DIV_INTRINSICS
+        {
+            _Result = _Signed128{_Base128::_Divide(_Num, static_cast<uint64_t>(_Den))};
+        }
+
+        if (_Negative) {
+            _Result = -_Result;
+        }
+        return _Result;
+    }
+    _NODISCARD friend constexpr _Signed128 operator/(_Signed128 _Num, _Signed128 _Den) noexcept {
+        bool _Negative = false;
+        _Num._Strip_negative(_Negative);
+        _Den._Strip_negative(_Negative);
+        _Signed128 _Result{_Base128::_Divide(_Num, _Den)};
+        if (_Negative) {
+            _Result = -_Result;
+        }
+        return _Result;
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Signed128& operator/=(const _Ty _That) noexcept {
+        *this = *this / _That;
+        return *this;
+    }
+    constexpr _Signed128& operator/=(const _Signed128& _That) noexcept {
+        *this = *this / _That;
+        return *this;
+    }
+    constexpr _Signed128& operator/=(const _Unsigned128& _That) noexcept {
+        *this = _Signed128{static_cast<_Base128&>(*this) / _That};
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator/=(_Ty& _Left, const _Signed128& _Right) noexcept {
+        _Left = static_cast<_Ty>(_Signed128{_Left} / _Right);
+        return _Left;
+    }
+
+    _NODISCARD friend constexpr _Signed128 operator%(_Signed128 _Left, _Signed128 _Right) noexcept {
+        bool _Negative = false;
+        _Left._Strip_negative(_Negative);
+
+        if ((_Right._Word[1] & (1ull << 63)) != 0) {
+            _Right = -_Right;
+            // intentionally not flipping _Negative
+        }
+
+        _Unsigned128 _Result{_Base128::_Modulo(_Left, _Right)};
+        if (_Negative) {
+            _Result = -_Result;
+        }
+        return _Signed128{_Result};
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    _NODISCARD friend constexpr _Signed128 operator%(_Signed128 _Left, const _Ty _Right) noexcept {
+        return _Left % _Signed128{_Right};
+    }
+
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    constexpr _Signed128& operator%=(const _Ty _That) noexcept {
+        *this = *this % _That;
+        return *this;
+    }
+    constexpr _Signed128& operator%=(const _Signed128& _That) noexcept {
+        *this = *this % _That;
+        return *this;
+    }
+    constexpr _Signed128& operator%=(const _Unsigned128& _That) noexcept {
+        *this = static_cast<const _Base128&>(*this) % _That;
+        return *this;
+    }
+    _TEMPLATE_CLASS_INTEGRAL(_Ty)
+    friend constexpr _Ty& operator%=(_Ty& _Left, const _Signed128& _Right) noexcept {
+        _Left = static_cast<_Ty>(_Signed128{_Left} % _Right);
+        return _Left;
+    }
+
+#if _HAS_CXX23
+    _NODISCARD static constexpr _Signed128 _Div_ceil(_Signed128 _Num, _Signed128 _Den) noexcept {
+        // _STL_INTERNAL_CHECK(_Num >= 0);
+        // _STL_INTERNAL_CHECK(_Den > 0);
+        return _Signed128{_Base128::_Div_ceil(_Num, _Den)};
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD friend constexpr _Signed128 operator&(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        return _Signed128{_Left._Word[0] & _Right._Word[0], _Left._Word[1] & _Right._Word[1]};
+    }
+
+    constexpr _Signed128& operator&=(const _Base128& _That) noexcept {
+        _Word[0] &= _That._Word[0];
+        _Word[1] &= _That._Word[1];
+        return *this;
+    }
+
+    _NODISCARD friend constexpr _Signed128 operator^(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        return _Signed128{_Left._Word[0] ^ _Right._Word[0], _Left._Word[1] ^ _Right._Word[1]};
+    }
+
+    constexpr _Signed128& operator^=(const _Base128& _That) noexcept {
+        _Word[0] ^= _That._Word[0];
+        _Word[1] ^= _That._Word[1];
+        return *this;
+    }
+
+    _NODISCARD friend constexpr _Signed128 operator|(const _Signed128& _Left, const _Signed128& _Right) noexcept {
+        return _Signed128{_Left._Word[0] | _Right._Word[0], _Left._Word[1] | _Right._Word[1]};
+    }
+
+    constexpr _Signed128& operator|=(const _Base128& _That) noexcept {
+        _Word[0] |= _That._Word[0];
+        _Word[1] |= _That._Word[1];
+        return *this;
+    }
+};
+
+template <>
+class numeric_limits<_Signed128> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr _Signed128(min)() noexcept {
+        return _Signed128{0ull, 1ull << 63};
+    }
+
+    _NODISCARD static constexpr _Signed128(max)() noexcept {
+        return _Signed128{~0ull, ~0ull >> 1};
+    }
+
+    _NODISCARD static constexpr _Signed128 lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr _Signed128 epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Signed128 round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Signed128 denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Signed128 infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Signed128 quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Signed128 signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr int digits     = 127;
+    static constexpr int digits10   = 38;
+    static constexpr bool is_signed = true;
+};
+
+template <>
+struct common_type<_Signed128, _Unsigned128> {
+    using type = _Unsigned128;
+};
+template <>
+struct common_type<_Unsigned128, _Signed128> {
+    using type = _Unsigned128;
+};
+
+template <class _Ty>
+_NODISCARD constexpr _Ty _Min_limit() noexcept;
+
+template <>
+_NODISCARD constexpr _Unsigned128 _Min_limit<_Unsigned128>() noexcept {
+    return 0;
+}
+
+template <>
+_NODISCARD constexpr _Signed128 _Min_limit<_Signed128>() noexcept {
+    return _Signed128{0ull, 1ull << 63};
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty _Max_limit() noexcept;
+
+template <>
+_NODISCARD constexpr _Unsigned128 _Max_limit<_Unsigned128>() noexcept {
+    return _Unsigned128{~0ull, ~0ull};
+}
+
+template <>
+_NODISCARD constexpr _Signed128 _Max_limit<_Signed128>() noexcept {
+    return _Signed128{~0ull, ~0ull >> 1};
+}
+
+#undef _STL_128_INTRINSICS
+#undef _STL_128_DIV_INTRINSICS
+
+_STD_END
+
+#undef _TEMPLATE_CLASS_INTEGRAL
+#undef _ZERO_OR_NO_INIT
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_INT128_HPP
diff --git a/msvc-stl/stl/inc/__msvc_iter_core.hpp b/msvc-stl/stl/inc/__msvc_iter_core.hpp
new file mode 100644
index 0000000..439e8bf
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_iter_core.hpp
@@ -0,0 +1,560 @@
+// __msvc_iter_core.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_ITER_CORE_HPP
+#define __MSVC_ITER_CORE_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <utility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+template <class _Ty, class _Alloc, class = void>
+struct _Has_allocator_type : false_type {}; // tests for suitable _Ty::allocator_type
+
+template <class _Ty, class _Alloc>
+struct _Has_allocator_type<_Ty, _Alloc, void_t<typename _Ty::allocator_type>>
+    : is_convertible<_Alloc, typename _Ty::allocator_type>::type {};
+
+_EXPORT_STD struct allocator_arg_t { // tag type for added allocator argument
+    explicit allocator_arg_t() = default;
+};
+
+_EXPORT_STD _INLINE_VAR constexpr allocator_arg_t allocator_arg{};
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+struct uses_allocator : _Has_allocator_type<_Ty, _Alloc>::type {};
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool uses_allocator_v = uses_allocator<_Ty, _Alloc>::value;
+
+// from <iterator>
+_EXPORT_STD struct input_iterator_tag {};
+
+_EXPORT_STD struct output_iterator_tag {};
+
+_EXPORT_STD struct forward_iterator_tag : input_iterator_tag {};
+
+_EXPORT_STD struct bidirectional_iterator_tag : forward_iterator_tag {};
+
+_EXPORT_STD struct random_access_iterator_tag : bidirectional_iterator_tag {};
+
+#if _HAS_CXX20
+_EXPORT_STD struct contiguous_iterator_tag : random_access_iterator_tag {};
+
+template <class _Ty>
+using _With_reference = _Ty&;
+
+template <class _Ty>
+concept _Can_reference = requires { typename _With_reference<_Ty>; };
+
+template <class _Ty>
+concept _Dereferenceable = requires(_Ty& __t) {
+    { *__t } -> _Can_reference;
+};
+
+template <class _Ty>
+concept _Has_member_iterator_concept = requires { typename _Ty::iterator_concept; };
+
+template <class _Ty>
+concept _Has_member_iterator_category = requires { typename _Ty::iterator_category; };
+
+template <class _Ty>
+concept _Has_member_value_type = requires { typename _Ty::value_type; };
+
+template <class _Ty>
+concept _Has_member_element_type = requires { typename _Ty::element_type; };
+
+template <class _Ty>
+concept _Has_member_difference_type = requires { typename _Ty::difference_type; };
+
+template <class _Ty>
+concept _Has_member_pointer = requires { typename _Ty::pointer; };
+
+template <class _Ty>
+concept _Has_member_reference = requires { typename _Ty::reference; };
+
+_EXPORT_STD template <class>
+struct incrementable_traits {};
+
+template <class _Ty>
+    requires is_object_v<_Ty>
+struct incrementable_traits<_Ty*> {
+    using difference_type = ptrdiff_t;
+};
+
+template <class _Ty>
+struct incrementable_traits<const _Ty> : incrementable_traits<_Ty> {};
+
+template <_Has_member_difference_type _Ty>
+struct incrementable_traits<_Ty> {
+    using difference_type = _Ty::difference_type;
+};
+
+template <class _Ty>
+concept _Can_difference = requires(const _Ty& __a, const _Ty& __b) {
+    { __a - __b } -> integral;
+};
+
+template <class _Ty>
+    requires (!_Has_member_difference_type<_Ty> && _Can_difference<_Ty>)
+struct incrementable_traits<_Ty> {
+    using difference_type = make_signed_t<decltype(_STD declval<_Ty>() - _STD declval<_Ty>())>;
+};
+
+template <class _Ty>
+concept _Is_from_primary = _Same_impl<typename _Ty::_From_primary, _Ty>;
+
+_EXPORT_STD template <class>
+struct iterator_traits;
+
+_EXPORT_STD template <class _Ty>
+using iter_difference_t = conditional_t<_Is_from_primary<iterator_traits<remove_cvref_t<_Ty>>>,
+    incrementable_traits<remove_cvref_t<_Ty>>, iterator_traits<remove_cvref_t<_Ty>>>::difference_type;
+
+template <class>
+struct _Cond_value_type {};
+
+template <class _Ty>
+    requires is_object_v<_Ty>
+struct _Cond_value_type<_Ty> {
+    using value_type = remove_cv_t<_Ty>;
+};
+
+_EXPORT_STD template <class>
+struct indirectly_readable_traits {};
+
+template <class _Ty>
+struct indirectly_readable_traits<_Ty*> : _Cond_value_type<_Ty> {};
+
+template <class _Ty>
+    requires is_array_v<_Ty>
+struct indirectly_readable_traits<_Ty> {
+    using value_type = remove_cv_t<remove_extent_t<_Ty>>;
+};
+
+template <class _Ty>
+struct indirectly_readable_traits<const _Ty> : indirectly_readable_traits<_Ty> {};
+
+template <_Has_member_value_type _Ty>
+struct indirectly_readable_traits<_Ty> : _Cond_value_type<typename _Ty::value_type> {};
+
+template <_Has_member_element_type _Ty>
+struct indirectly_readable_traits<_Ty> : _Cond_value_type<typename _Ty::element_type> {};
+
+template <_Has_member_value_type _Ty>
+    requires _Has_member_element_type<_Ty>
+struct indirectly_readable_traits<_Ty> {};
+
+template <_Has_member_value_type _Ty>
+    requires _Has_member_element_type<_Ty>
+          && same_as<remove_cv_t<typename _Ty::value_type>, remove_cv_t<typename _Ty::element_type>>
+struct indirectly_readable_traits<_Ty> : _Cond_value_type<typename _Ty::value_type> {};
+
+_EXPORT_STD template <class _Ty>
+using iter_value_t = conditional_t<_Is_from_primary<iterator_traits<remove_cvref_t<_Ty>>>,
+    indirectly_readable_traits<remove_cvref_t<_Ty>>, iterator_traits<remove_cvref_t<_Ty>>>::value_type;
+
+_EXPORT_STD template <_Dereferenceable _Ty>
+using iter_reference_t = decltype(*_STD declval<_Ty&>());
+
+template <class>
+struct _Iterator_traits_base {};
+
+template <class _It>
+concept _Has_iter_types = _Has_member_difference_type<_It> && _Has_member_value_type<_It> && _Has_member_reference<_It>
+                       && _Has_member_iterator_category<_It>;
+
+template <bool _Has_member_typedef>
+struct _Old_iter_traits_pointer {
+    template <class _It>
+    using _Apply = _It::pointer;
+};
+
+template <>
+struct _Old_iter_traits_pointer<false> {
+    template <class>
+    using _Apply = void;
+};
+
+template <_Has_iter_types _It>
+struct _Iterator_traits_base<_It> {
+    using iterator_category = _It::iterator_category;
+    using value_type        = _It::value_type;
+    using difference_type   = _It::difference_type;
+    using pointer           = _Old_iter_traits_pointer<_Has_member_pointer<_It>>::template _Apply<_It>;
+    using reference         = _It::reference;
+};
+
+template <bool _Has_member_typedef>
+struct _Iter_traits_difference {
+    template <class _It>
+    using _Apply = incrementable_traits<_It>::difference_type;
+};
+
+template <>
+struct _Iter_traits_difference<false> {
+    template <class>
+    using _Apply = void;
+};
+
+template <class _It>
+concept _Cpp17_iterator = requires(_It __i) {
+    { *__i } -> _Can_reference;
+    { ++__i } -> same_as<_It&>;
+    { *__i++ } -> _Can_reference;
+} && copyable<_It>;
+
+template <class _It>
+concept _Cpp17_input_iterator =
+    _Cpp17_iterator<_It> && equality_comparable<_It> && _Has_member_difference_type<incrementable_traits<_It>>
+    && _Has_member_value_type<indirectly_readable_traits<_It>> && requires(_It __i) {
+           typename common_reference_t<iter_reference_t<_It>&&, typename indirectly_readable_traits<_It>::value_type&>;
+           typename common_reference_t<decltype(*__i++)&&, typename indirectly_readable_traits<_It>::value_type&>;
+           requires signed_integral<typename incrementable_traits<_It>::difference_type>;
+       };
+
+template <class _It>
+    requires (!_Has_iter_types<_It> && _Cpp17_iterator<_It> && !_Cpp17_input_iterator<_It>)
+struct _Iterator_traits_base<_It> {
+    using iterator_category = output_iterator_tag;
+    using value_type        = void;
+    using difference_type =
+        _Iter_traits_difference<_Has_member_difference_type<incrementable_traits<_It>>>::template _Apply<_It>;
+    using pointer   = void;
+    using reference = void;
+};
+
+enum class _Itraits_pointer_strategy { _Use_void, _Use_member, _Use_decltype };
+
+template <_Itraits_pointer_strategy>
+struct _Iter_traits_pointer;
+
+template <>
+struct _Iter_traits_pointer<_Itraits_pointer_strategy::_Use_void> {
+    template <class>
+    using _Apply = void;
+};
+
+template <>
+struct _Iter_traits_pointer<_Itraits_pointer_strategy::_Use_member> {
+    template <class _It>
+    using _Apply = _It::pointer;
+};
+
+template <>
+struct _Iter_traits_pointer<_Itraits_pointer_strategy::_Use_decltype> {
+    template <class _It>
+    using _Apply = decltype(_STD declval<_It&>().operator->());
+};
+
+template <class _Ty>
+concept _Has_member_arrow = requires(_Ty&& __t) { static_cast<_Ty&&>(__t).operator->(); };
+
+template <bool _Has_member_typedef>
+struct _Iter_traits_reference {
+    template <class _It>
+    using _Apply = _It::reference;
+};
+
+template <>
+struct _Iter_traits_reference<false> {
+    template <class _It>
+    using _Apply = iter_reference_t<_It>;
+};
+
+template <bool _Is_random>
+struct _Iter_traits_category4 {
+    using type = random_access_iterator_tag;
+};
+
+template <>
+struct _Iter_traits_category4<false> {
+    using type = bidirectional_iterator_tag;
+};
+
+template <class _It>
+concept _Cpp17_random_delta =
+    totally_ordered<_It> && requires(_It __i, incrementable_traits<_It>::difference_type __n) {
+        { __i += __n } -> same_as<_It&>;
+        { __i -= __n } -> same_as<_It&>;
+        { __i + __n } -> same_as<_It>;
+        { __n + __i } -> same_as<_It>;
+        { __i - __n } -> same_as<_It>;
+        { __i - __i } -> same_as<decltype(__n)>;
+        { __i[__n] } -> convertible_to<iter_reference_t<_It>>;
+    };
+
+template <bool _Is_bidi>
+struct _Iter_traits_category3 {
+    template <class _It>
+    using _Apply = _Iter_traits_category4<_Cpp17_random_delta<_It>>::type;
+};
+
+template <>
+struct _Iter_traits_category3<false> {
+    template <class>
+    using _Apply = forward_iterator_tag;
+};
+
+template <class _It>
+concept _Cpp17_bidi_delta = requires(_It __i) {
+    { --__i } -> same_as<_It&>;
+    { __i-- } -> convertible_to<const _It&>;
+    requires same_as<decltype(*__i--), iter_reference_t<_It>>;
+};
+
+template <bool _Is_forward>
+struct _Iter_traits_category2 {
+    template <class _It>
+    using _Apply = _Iter_traits_category3<_Cpp17_bidi_delta<_It>>::template _Apply<_It>;
+};
+
+template <>
+struct _Iter_traits_category2<false> {
+    template <class>
+    using _Apply = input_iterator_tag;
+};
+
+template <class _It>
+concept _Cpp17_forward_delta =
+    constructible_from<_It> && is_reference_v<iter_reference_t<_It>>
+    && same_as<remove_cvref_t<iter_reference_t<_It>>, typename indirectly_readable_traits<_It>::value_type>
+    && requires(_It __i) {
+           { __i++ } -> convertible_to<const _It&>;
+           requires same_as<decltype(*__i++), iter_reference_t<_It>>;
+       };
+
+template <bool _Has_member_typedef>
+struct _Iter_traits_category {
+    template <class _It>
+    using _Apply = _It::iterator_category;
+};
+
+template <>
+struct _Iter_traits_category<false> {
+    template <class _It>
+    using _Apply = _Iter_traits_category2<_Cpp17_forward_delta<_It>>::template _Apply<_It>;
+};
+
+template <class _It>
+    requires (!_Has_iter_types<_It> && _Cpp17_input_iterator<_It>)
+struct _Iterator_traits_base<_It> {
+    using iterator_category = _Iter_traits_category<_Has_member_iterator_category<_It>>::template _Apply<_It>;
+    using value_type        = indirectly_readable_traits<_It>::value_type;
+    using difference_type   = incrementable_traits<_It>::difference_type;
+    using pointer =
+        _Iter_traits_pointer<(_Has_member_pointer<_It>  ? _Itraits_pointer_strategy::_Use_member
+                              : _Has_member_arrow<_It&> ? _Itraits_pointer_strategy::_Use_decltype
+                                                        : _Itraits_pointer_strategy::_Use_void)>::template _Apply<_It>;
+    using reference = _Iter_traits_reference<_Has_member_reference<_It>>::template _Apply<_It>;
+};
+
+_EXPORT_STD template <class _Ty>
+struct iterator_traits : _Iterator_traits_base<_Ty> {
+    using _From_primary = iterator_traits;
+};
+
+template <class _Ty>
+    requires is_object_v<_Ty>
+struct iterator_traits<_Ty*> {
+    using iterator_concept  = contiguous_iterator_tag;
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = remove_cv_t<_Ty>;
+    using difference_type   = ptrdiff_t;
+    using pointer           = _Ty*;
+    using reference         = _Ty&;
+};
+
+template <class _Ty>
+constexpr bool _Integer_class = requires {
+    typename _Ty::_Signed_type;
+    typename _Ty::_Unsigned_type;
+};
+
+template <class _Ty>
+concept _Integer_like = _Is_nonbool_integral<_Ty> || _Integer_class<_Ty>;
+
+template <class _Ty>
+concept _Signed_integer_like = _Integer_like<_Ty> && static_cast<_Ty>(-1) < static_cast<_Ty>(0);
+
+_EXPORT_STD template <class _Ty>
+concept weakly_incrementable = movable<_Ty> && requires(_Ty __i) {
+    typename iter_difference_t<_Ty>;
+    requires _Signed_integer_like<iter_difference_t<_Ty>>;
+    { ++__i } -> same_as<_Ty&>;
+    __i++;
+};
+
+_EXPORT_STD template <class _It>
+concept input_or_output_iterator = requires(_It __i) {
+    { *__i } -> _Can_reference;
+} && weakly_incrementable<_It>;
+
+_EXPORT_STD template <class _Se, class _It>
+concept sentinel_for = semiregular<_Se> && !_Integer_like<_Se> && input_or_output_iterator<_It>
+                    && _Weakly_equality_comparable_with<_Se, _It>;
+
+_EXPORT_STD template <class _Se, class _It> // specializations allowed by N5014 [iterator.concept.sizedsentinel]/3
+constexpr bool disable_sized_sentinel_for = false;
+
+_EXPORT_STD template <class _Se, class _It>
+concept sized_sentinel_for = sentinel_for<_Se, _It> && !disable_sized_sentinel_for<remove_cv_t<_Se>, remove_cv_t<_It>>
+                          && requires(const _It& __i, const _Se& __s) {
+                                 { __s - __i } -> same_as<iter_difference_t<_It>>;
+                                 { __i - __s } -> same_as<iter_difference_t<_It>>;
+                             };
+
+_EXPORT_STD struct default_sentinel_t {};
+
+_EXPORT_STD inline constexpr default_sentinel_t default_sentinel{};
+
+namespace ranges {
+    _EXPORT_STD enum class subrange_kind : bool { unsized, sized };
+
+    _EXPORT_STD template <input_or_output_iterator _It, sentinel_for<_It> _Se = _It,
+        subrange_kind _Ki = sized_sentinel_for<_Se, _It> ? subrange_kind::sized : subrange_kind::unsized>
+        requires (_Ki == subrange_kind::sized || !sized_sentinel_for<_Se, _It>)
+    class subrange;
+
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+        requires ((_Idx == 0 && copyable<_It>) || _Idx == 1)
+    _NODISCARD constexpr auto get(const subrange<_It, _Se, _Ki>& _Val);
+
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+        requires (_Idx < 2)
+    _NODISCARD constexpr auto get(subrange<_It, _Se, _Ki>&& _Val);
+} // namespace ranges
+
+_EXPORT_STD using ranges::get;
+
+template <class _It, class _Se, ranges::subrange_kind _Ki>
+constexpr bool _Is_subrange_v<ranges::subrange<_It, _Se, _Ki>> = true;
+
+template <class _It, class _Se, ranges::subrange_kind _Ki>
+struct tuple_size<ranges::subrange<_It, _Se, _Ki>> : integral_constant<size_t, 2> {};
+
+template <class _It, class _Se, ranges::subrange_kind _Ki>
+struct tuple_element<0, ranges::subrange<_It, _Se, _Ki>> {
+    using type = _It;
+};
+
+template <class _It, class _Se, ranges::subrange_kind _Ki>
+struct tuple_element<1, ranges::subrange<_It, _Se, _Ki>> {
+    using type = _Se;
+};
+
+template <class _It, class _Se, ranges::subrange_kind _Ki>
+struct tuple_element<0, const ranges::subrange<_It, _Se, _Ki>> {
+    using type = _It;
+};
+
+template <class _It, class _Se, ranges::subrange_kind _Ki>
+struct tuple_element<1, const ranges::subrange<_It, _Se, _Ki>> {
+    using type = _Se;
+};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class, class = void>
+struct _Iterator_traits_base {}; // empty for non-iterators
+
+template <class _Iter>
+struct _Iterator_traits_base<_Iter,
+    void_t<typename _Iter::iterator_category, typename _Iter::value_type, typename _Iter::difference_type,
+        typename _Iter::pointer, typename _Iter::reference>> {
+    // defined if _Iter::* types exist
+    using iterator_category = typename _Iter::iterator_category;
+    using value_type        = typename _Iter::value_type;
+    using difference_type   = typename _Iter::difference_type;
+    using pointer           = typename _Iter::pointer;
+    using reference         = typename _Iter::reference;
+};
+
+template <class _Ty, bool = is_object_v<_Ty>>
+struct _Iterator_traits_pointer_base { // iterator properties for pointers to object
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = remove_cv_t<_Ty>;
+    using difference_type   = ptrdiff_t;
+    using pointer           = _Ty*;
+    using reference         = _Ty&;
+};
+
+template <class _Ty>
+struct _Iterator_traits_pointer_base<_Ty, false> {}; // iterator non-properties for pointers to non-object
+
+template <class _Iter>
+struct iterator_traits : _Iterator_traits_base<_Iter> {}; // get traits from iterator _Iter, if possible
+
+template <class _Ty>
+struct iterator_traits<_Ty*> : _Iterator_traits_pointer_base<_Ty> {}; // get traits from pointer, if possible
+
+template <class _Ty>
+constexpr bool _Integer_like = _Is_nonbool_integral<_Ty>;
+
+template <class _Ty>
+constexpr bool _Signed_integer_like = _Integer_like<_Ty> && is_signed_v<_Ty>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_INLINE_VAR constexpr auto _Meta_npos = ~size_t{0};
+
+constexpr size_t _Meta_find_index_i_(const bool* const _Ptr, const size_t _Count, size_t _Idx = 0) {
+    // return the index of the first true in the _Count bools at _Ptr, or _Meta_npos if all are false
+    for (; _Idx < _Count; ++_Idx) {
+        if (_Ptr[_Idx]) {
+            return _Idx;
+        }
+    }
+
+    return _Meta_npos;
+}
+
+template <class _List, class _Ty>
+struct _Meta_find_unique_index_ {
+    using type = integral_constant<size_t, _Meta_npos>;
+};
+template <class _List, class _Ty>
+using _Meta_find_unique_index =
+    // The index of _Ty in _List if it occurs exactly once, otherwise _Meta_npos
+    typename _Meta_find_unique_index_<_List, _Ty>::type;
+
+constexpr size_t _Meta_find_unique_index_i_2(const bool* const _Ptr, const size_t _Count, const size_t _First) {
+    // return _First if there is no _First < j < _Count such that _Ptr[j] is true, otherwise _Meta_npos
+    return _First != _Meta_npos && _STD _Meta_find_index_i_(_Ptr, _Count, _First + 1) == _Meta_npos ? _First
+                                                                                                    : _Meta_npos;
+}
+
+constexpr size_t _Meta_find_unique_index_i_(const bool* const _Ptr, const size_t _Count) {
+    // Pass the smallest i such that _Ptr[i] is true to _Meta_find_unique_index_i_2
+    return _STD _Meta_find_unique_index_i_2(_Ptr, _Count, _STD _Meta_find_index_i_(_Ptr, _Count));
+}
+
+template <template <class...> class _List, class _First, class... _Rest, class _Ty>
+struct _Meta_find_unique_index_<_List<_First, _Rest...>, _Ty> {
+    static constexpr bool _Bools[] = {is_same_v<_First, _Ty>, is_same_v<_Rest, _Ty>...};
+    using type = integral_constant<size_t, _STD _Meta_find_unique_index_i_(_Bools, 1 + sizeof...(_Rest))>;
+};
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_ITER_CORE_HPP
diff --git a/msvc-stl/stl/inc/__msvc_minmax.hpp b/msvc-stl/stl/inc/__msvc_minmax.hpp
new file mode 100644
index 0000000..7dce579
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_minmax.hpp
@@ -0,0 +1,86 @@
+// __msvc_minmax.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_MINMAX_HPP
+#define __MSVC_MINMAX_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstdint>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+struct _Min_max_element_t {
+    const void* _Min;
+    const void* _Max;
+};
+
+struct _Min_max_1i {
+    int8_t _Min;
+    int8_t _Max;
+};
+
+struct _Min_max_1u {
+    uint8_t _Min;
+    uint8_t _Max;
+};
+
+struct _Min_max_2i {
+    int16_t _Min;
+    int16_t _Max;
+};
+
+struct _Min_max_2u {
+    uint16_t _Min;
+    uint16_t _Max;
+};
+
+struct _Min_max_4i {
+    int32_t _Min;
+    int32_t _Max;
+};
+
+struct _Min_max_4u {
+    uint32_t _Min;
+    uint32_t _Max;
+};
+
+struct _Min_max_8i {
+    int64_t _Min;
+    int64_t _Max;
+};
+
+struct _Min_max_8u {
+    uint64_t _Min;
+    uint64_t _Max;
+};
+
+struct _Min_max_f {
+    float _Min;
+    float _Max;
+};
+
+struct _Min_max_d {
+    double _Min;
+    double _Max;
+};
+
+struct _Min_max_p {
+    void* _Min;
+    void* _Max;
+};
+} // extern "C"
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_MINMAX_HPP
diff --git a/msvc-stl/stl/inc/__msvc_ostream.hpp b/msvc-stl/stl/inc/__msvc_ostream.hpp
new file mode 100644
index 0000000..1ebb296
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_ostream.hpp
@@ -0,0 +1,1039 @@
+// __msvc_ostream.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_OSTREAM_HPP
+#define __MSVC_OSTREAM_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <ios>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#pragma vtordisp(push, 2) // compiler bug workaround
+
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
+class basic_ostream : virtual public basic_ios<_Elem, _Traits> { // control insertions into a stream buffer
+public:
+    using _Myios = basic_ios<_Elem, _Traits>;
+    using _Mysb  = basic_streambuf<_Elem, _Traits>;
+    using _Iter  = ostreambuf_iterator<_Elem, _Traits>;
+    using _Nput  = num_put<_Elem, _Iter>;
+
+    explicit __CLR_OR_THIS_CALL basic_ostream(basic_streambuf<_Elem, _Traits>* _Strbuf, bool _Isstd = false) {
+        _Myios::init(_Strbuf, _Isstd);
+    }
+
+    __CLR_OR_THIS_CALL basic_ostream(_Uninitialized, bool _Addit = true) {
+        if (_Addit) {
+            this->_Addstd(this); // suppress for basic_iostream
+        }
+    }
+
+protected:
+    __CLR_OR_THIS_CALL basic_ostream(basic_ostream&& _Right) noexcept(false) {
+        _Myios::init();
+        _Myios::move(_STD move(_Right));
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator=(basic_ostream&& _Right) noexcept /* strengthened */ {
+        this->swap(_Right);
+        return *this;
+    }
+
+    void __CLR_OR_THIS_CALL swap(basic_ostream& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Myios::swap(_Right);
+        }
+    }
+
+public:
+    __CLR_OR_THIS_CALL basic_ostream(const basic_ostream&)            = delete;
+    basic_ostream& __CLR_OR_THIS_CALL operator=(const basic_ostream&) = delete;
+
+    __CLR_OR_THIS_CALL ~basic_ostream() noexcept override {}
+
+    using int_type = typename _Traits::int_type;
+    using pos_type = typename _Traits::pos_type;
+    using off_type = typename _Traits::off_type;
+
+    class _Sentry_base { // stores thread lock and reference to output stream
+    public:
+        __CLR_OR_THIS_CALL _Sentry_base(basic_ostream& _Ostr) : _Myostr(_Ostr) { // lock the stream buffer, if there
+            const auto _Rdbuf = _Myostr.rdbuf();
+            if (_Rdbuf) {
+                _Rdbuf->_Lock();
+            }
+        }
+
+        __CLR_OR_THIS_CALL ~_Sentry_base() noexcept { // destroy after unlocking
+            const auto _Rdbuf = _Myostr.rdbuf();
+            if (_Rdbuf) {
+                _Rdbuf->_Unlock();
+            }
+        }
+
+        basic_ostream& _Myostr; // the output stream, for _Unlock call at destruction
+
+        _Sentry_base& operator=(const _Sentry_base&) = delete;
+    };
+
+    class sentry : public _Sentry_base {
+    public:
+        explicit __CLR_OR_THIS_CALL sentry(basic_ostream& _Ostr) : _Sentry_base(_Ostr) {
+            if (!_Ostr.good()) {
+                _Ok = false;
+                return;
+            }
+
+            const auto _Tied = _Ostr.tie();
+            if (!_Tied || _Tied == _STD addressof(_Ostr)) {
+                _Ok = true;
+                return;
+            }
+
+            _Tied->flush();
+            _Ok = _Ostr.good(); // store test only after flushing tie
+        }
+
+        _STL_DISABLE_DEPRECATED_WARNING
+        __CLR_OR_THIS_CALL ~sentry() noexcept {
+#if !_HAS_EXCEPTIONS
+            const bool _Zero_uncaught_exceptions = true;
+#elif _HAS_DEPRECATED_UNCAUGHT_EXCEPTION
+            const bool _Zero_uncaught_exceptions = !_STD uncaught_exception(); // TRANSITION, ArchivedOS-12000909
+#else // ^^^ _HAS_DEPRECATED_UNCAUGHT_EXCEPTION / !_HAS_DEPRECATED_UNCAUGHT_EXCEPTION vvv
+            const bool _Zero_uncaught_exceptions = _STD uncaught_exceptions() == 0;
+#endif // ^^^ !_HAS_DEPRECATED_UNCAUGHT_EXCEPTION ^^^
+
+            if (_Zero_uncaught_exceptions) {
+                this->_Myostr._Osfx();
+            }
+        }
+        _STL_RESTORE_DEPRECATED_WARNING
+
+        explicit __CLR_OR_THIS_CALL operator bool() const {
+            return _Ok;
+        }
+
+        __CLR_OR_THIS_CALL sentry(const sentry&)            = delete;
+        sentry& __CLR_OR_THIS_CALL operator=(const sentry&) = delete;
+
+    private:
+        bool _Ok; // true if stream state okay at construction
+    };
+
+#ifdef _CRTBLD
+    // TRANSITION, ABI: non-Standard opfx() is preserved for binary compatibility
+    bool __CLR_OR_THIS_CALL opfx() { // test stream state and flush tie stream as needed
+        if (!this->good()) {
+            return false;
+        }
+
+        const auto _Tied = _Myios::tie();
+        if (!_Tied || _Myios::tie() == this) {
+            return true;
+        }
+
+        _Tied->flush();
+        return this->good();
+    }
+
+    // TRANSITION, ABI: non-Standard osfx() is preserved for binary compatibility
+    void __CLR_OR_THIS_CALL osfx() noexcept { // perform any wrapup
+        _Osfx();
+    }
+#endif // ^^^ defined(_CRTBLD) ^^^
+
+    void __CLR_OR_THIS_CALL _Osfx() noexcept { // perform any wrapup
+        _TRY_BEGIN
+        if (this->good() && this->flags() & ios_base::unitbuf) {
+            if (_Myios::rdbuf()->pubsync() == -1) { // flush stream as needed
+                _Myios::setstate(ios_base::badbit);
+            }
+        }
+        _CATCH_ALL
+        _CATCH_END
+    }
+
+#ifdef _M_CEE_PURE
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(basic_ostream&(__clrcall* _Pfn)(basic_ostream&) ) {
+        // call basic_ostream manipulator
+        return _Pfn(*this);
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(_Myios&(__clrcall* _Pfn)(_Myios&) ) {
+        // call basic_ios manipulator
+        _Pfn(*this);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(ios_base&(__clrcall* _Pfn)(ios_base&) ) {
+        // call ios_base manipulator
+        _Pfn(*this);
+        return *this;
+    }
+#endif // defined(_M_CEE_PURE)
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(basic_ostream&(__cdecl* _Pfn)(basic_ostream&) ) {
+        // call basic_ostream manipulator
+        return _Pfn(*this);
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(_Myios&(__cdecl* _Pfn)(_Myios&) ) {
+        // call basic_ios manipulator
+        _Pfn(*this);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(ios_base&(__cdecl* _Pfn)(ios_base&) ) {
+        // call ios_base manipulator
+        _Pfn(*this);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(bool _Val) { // insert a boolean
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(short _Val) { // insert a short
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac  = _STD use_facet<_Nput>(this->getloc());
+            ios_base::fmtflags _Bfl = this->flags() & ios_base::basefield;
+
+            long _Tmp;
+            if (_Bfl == ios_base::oct || _Bfl == ios_base::hex) {
+                _Tmp = static_cast<long>(static_cast<unsigned short>(_Val));
+            } else {
+                _Tmp = static_cast<long>(_Val);
+            }
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Tmp).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    // NOTE:
+    // If you are not using native wchar_t, the unsigned short inserter
+    // is masked by an explicit specialization that treats an unsigned
+    // short as a wide character.
+
+    // To read or write unsigned shorts as integers with wchar_t streams,
+    // make wchar_t a native type with the command line option /Zc:wchar_t.
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(unsigned short _Val) { // insert an unsigned short
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), static_cast<unsigned long>(_Val))
+                    .failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(int _Val) { // insert an int
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac  = _STD use_facet<_Nput>(this->getloc());
+            ios_base::fmtflags _Bfl = this->flags() & ios_base::basefield;
+
+            long _Tmp;
+            if (_Bfl == ios_base::oct || _Bfl == ios_base::hex) {
+                _Tmp = static_cast<long>(static_cast<unsigned int>(_Val));
+            } else {
+                _Tmp = static_cast<long>(_Val);
+            }
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Tmp).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(unsigned int _Val) { // insert an unsigned int
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), static_cast<unsigned long>(_Val))
+                    .failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(long _Val) { // insert a long
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(unsigned long _Val) { // insert an unsigned long
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(long long _Val) { // insert a long long
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(unsigned long long _Val) { // insert an unsigned long long
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(float _Val) { // insert a float
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), static_cast<double>(_Val)).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(double _Val) { // insert a double
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(long double _Val) { // insert a long double
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(const void* _Val) { // insert a void pointer
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to insert
+            const _Nput& _Nput_fac = _STD use_facet<_Nput>(this->getloc());
+
+            _TRY_IO_BEGIN
+            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class = void> // TRANSITION, ABI
+    basic_ostream& operator<<(const volatile void* _Val) {
+        return *this << const_cast<const void*>(_Val);
+    }
+#endif // _HAS_CXX23
+
+#if _HAS_CXX17
+    template <class = void> // TRANSITION, ABI
+    basic_ostream& operator<<(nullptr_t) { // insert a null pointer
+        return *this << "nullptr";
+    }
+#endif // _HAS_CXX17
+
+    basic_ostream& __CLR_OR_THIS_CALL operator<<(_Mysb* _Strbuf) { // insert until end-of-file from a stream buffer
+        ios_base::iostate _State = ios_base::goodbit;
+        bool _Copied             = false;
+        const sentry _Ok(*this);
+
+        if (_Ok && _Strbuf) {
+            for (int_type _Meta = _Traits::eof();; _Copied = true) { // extract another character from stream buffer
+                _TRY_BEGIN
+                _Meta = _Traits::eq_int_type(_Traits::eof(), _Meta) ? _Strbuf->sgetc() : _Strbuf->snextc();
+                _CATCH_ALL
+                // N4971 [ostream.inserters]/9: "If an exception was thrown
+                // while extracting a character, the function sets failbit in the error state,
+                // and if failbit is set in exceptions() the caught exception is rethrown."
+                _Myios::setstate(ios_base::failbit, _Myios::exceptions() == ios_base::failbit);
+                _CATCH_END
+
+                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+                    break; // end of file, quit
+                }
+
+                _TRY_IO_BEGIN
+                if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sputc(_Traits::to_char_type(_Meta)))) {
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+                _CATCH_IO_END
+            }
+        }
+
+        this->width(0);
+        int _Setstate_with;
+        if (_Strbuf) {
+            if (_Copied) {
+                _Setstate_with = _State;
+            } else {
+                _Setstate_with = _State | ios_base::failbit;
+            }
+        } else {
+            _Setstate_with = ios_base::badbit;
+        }
+
+        _Myios::setstate(_Setstate_with);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL put(_Elem _Ch) { // insert a character
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (!_Ok) {
+            _State |= ios_base::badbit;
+        } else { // state okay, insert character
+            _TRY_IO_BEGIN
+            if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sputc(_Ch))) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL write(const _Elem* _Str, streamsize _Count) {
+        // insert _Count characters from array _Str
+        ios_base::iostate _State = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (!_Ok) {
+            _State |= ios_base::badbit;
+        } else if (0 < _Count) { // state okay, insert characters
+            _TRY_IO_BEGIN
+            if (_Myios::rdbuf()->sputn(_Str, _Count) != _Count) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL flush() { // flush output stream
+        const auto _Rdbuf = _Myios::rdbuf();
+        if (_Rdbuf) { // buffer exists, flush it
+            const sentry _Ok(*this);
+
+            if (_Ok) {
+                ios_base::iostate _State = ios_base::goodbit;
+                _TRY_IO_BEGIN
+                if (_Rdbuf->pubsync() == -1) {
+                    _State |= ios_base::badbit; // sync failed
+                }
+                _CATCH_IO_END
+                _Myios::setstate(_State);
+            }
+        }
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL seekp(pos_type _Pos) { // set output stream position to _Pos
+        const sentry _Ok(*this);
+
+        if (!this->fail()) {
+            ios_base::iostate _State = ios_base::goodbit;
+            _TRY_IO_BEGIN
+            if (static_cast<off_type>(_Myios::rdbuf()->pubseekpos(_Pos, ios_base::out)) == -1) {
+                _State |= ios_base::failbit; // seek failed
+            }
+            _CATCH_IO_END
+            _Myios::setstate(_State);
+        }
+
+        return *this;
+    }
+
+    basic_ostream& __CLR_OR_THIS_CALL seekp(off_type _Off, ios_base::seekdir _Way) {
+        // change output stream position by _Off, according to _Way
+        const sentry _Ok(*this);
+
+        if (!this->fail()) {
+            ios_base::iostate _State = ios_base::goodbit;
+            _TRY_IO_BEGIN
+            if (static_cast<off_type>(_Myios::rdbuf()->pubseekoff(_Off, _Way, ios_base::out)) == -1) {
+                _State |= ios_base::failbit; // seek failed
+            }
+            _CATCH_IO_END
+            _Myios::setstate(_State);
+        }
+
+        return *this;
+    }
+
+    pos_type __CLR_OR_THIS_CALL tellp() {
+        const sentry _Ok(*this);
+
+        if (!this->fail()) {
+            _TRY_IO_BEGIN
+            return _Myios::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+            _CATCH_IO_END
+        }
+
+        return pos_type{off_type{-1}};
+    }
+};
+
+#pragma vtordisp(pop) // compiler bug workaround
+
+#ifndef _NATIVE_WCHAR_T_DEFINED
+// NOTE:
+// If you are not using native wchar_t, the following explicit
+// specialization will mask the member function (above) that treats
+// an unsigned short as an integer.
+
+// To read or write unsigned shorts as integers with wchar_t streams,
+// make wchar_t a native type with the command line option /Zc:wchar_t.
+
+template <>
+inline basic_ostream<unsigned short, char_traits<unsigned short>>& __CLR_OR_THIS_CALL basic_ostream<unsigned short,
+    char_traits<unsigned short>>::operator<<(unsigned short _Ch) { // extract a character
+    using _Traits = char_traits<unsigned short>;
+
+    ios_base::iostate _State = ios_base::goodbit;
+    const sentry _Ok(*this);
+
+    if (_Ok) { // state okay, insert
+        streamsize _Pad = this->width() <= 1 ? 0 : this->width() - 1;
+
+        _TRY_IO_BEGIN
+        if ((this->flags() & ios_base::adjustfield) != ios_base::left) {
+            for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on left
+                if (_Traits::eq_int_type(_Traits::eof(), this->rdbuf()->sputc(this->fill()))) {
+                    _State |= ios_base::badbit;
+                }
+            }
+        }
+
+        if (_State == ios_base::goodbit && _Traits::eq_int_type(_Traits::eof(), this->rdbuf()->sputc(_Ch))) {
+            _State |= ios_base::badbit;
+        }
+
+        for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on right
+            if (_Traits::eq_int_type(_Traits::eof(), this->rdbuf()->sputc(this->fill()))) {
+                _State |= ios_base::badbit;
+            }
+        }
+        _CATCH_IO_END
+    }
+
+    this->width(0);
+    _Myios::setstate(_State);
+    return *this;
+}
+#endif // _NATIVE_WCHAR_T_DEFINED
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT basic_ostream<char, char_traits<char>>;
+template class _CRTIMP2_PURE_IMPORT basic_ostream<wchar_t, char_traits<wchar_t>>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template class _CRTIMP2_PURE_IMPORT basic_ostream<unsigned short, char_traits<unsigned short>>;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const char* _Val) { // insert NTBS
+    ios_base::iostate _State = ios_base::goodbit;
+    streamsize _Count        = static_cast<streamsize>(_CSTD strlen(_Val));
+    streamsize _Pad          = _Ostr.width() <= 0 || _Ostr.width() <= _Count ? 0 : _Ostr.width() - _Count;
+    const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);
+
+    if (!_Ok) {
+        _State |= ios_base::badbit;
+    } else { // state okay, insert characters
+        _TRY_IO_BEGIN
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Ostr.getloc());
+        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
+            for (; 0 < _Pad; --_Pad) { // pad on left
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+        }
+
+        for (; _State == ios_base::goodbit && 0 < _Count; --_Count, ++_Val) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ctype_fac.widen(*_Val)))) {
+                _State |= ios_base::badbit;
+            }
+        }
+
+        if (_State == ios_base::goodbit) {
+            for (; 0 < _Pad; --_Pad) { // pad on right
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+        }
+
+        _Ostr.width(0);
+        _CATCH_IO_(ios_base, _Ostr)
+    }
+
+    _Ostr.setstate(_State);
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, char _Ch) { // insert a character
+    ios_base::iostate _State = ios_base::goodbit;
+    const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);
+
+    if (_Ok) { // state okay, insert
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Ostr.getloc());
+        streamsize _Pad                = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;
+
+        _TRY_IO_BEGIN
+        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
+            for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on left
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit;
+                }
+            }
+        }
+
+        if (_State == ios_base::goodbit
+            && _Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ctype_fac.widen(_Ch)))) {
+            _State |= ios_base::badbit;
+        }
+
+        for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on right
+            if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                _State |= ios_base::badbit;
+            }
+        }
+        _CATCH_IO_(ios_base, _Ostr)
+    }
+
+    _Ostr.width(0);
+    _Ostr.setstate(_State);
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const char* _Val) {
+    // insert NTBS into char stream
+    using _Elem = char;
+    using _Myos = basic_ostream<_Elem, _Traits>;
+
+    ios_base::iostate _State = ios_base::goodbit;
+    streamsize _Count        = static_cast<streamsize>(_Traits::length(_Val));
+    streamsize _Pad          = _Ostr.width() <= 0 || _Ostr.width() <= _Count ? 0 : _Ostr.width() - _Count;
+    const typename _Myos::sentry _Ok(_Ostr);
+
+    if (!_Ok) {
+        _State |= ios_base::badbit;
+    } else { // state okay, insert
+        _TRY_IO_BEGIN
+        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
+            for (; 0 < _Pad; --_Pad) { // pad on left
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+        }
+
+        if (_State == ios_base::goodbit && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count) {
+            _State |= ios_base::badbit;
+        }
+
+        if (_State == ios_base::goodbit) {
+            for (; 0 < _Pad; --_Pad) { // pad on right
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+        }
+
+        _Ostr.width(0);
+        _CATCH_IO_(ios_base, _Ostr)
+    }
+
+    _Ostr.setstate(_State);
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, char _Ch) {
+    // insert a char into char stream
+    using _Elem = char;
+    using _Myos = basic_ostream<_Elem, _Traits>;
+
+    ios_base::iostate _State = ios_base::goodbit;
+    const typename _Myos::sentry _Ok(_Ostr);
+
+    if (_Ok) { // state okay, insert
+        streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;
+
+        _TRY_IO_BEGIN
+        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
+            for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on left
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit;
+                }
+            }
+        }
+
+        if (_State == ios_base::goodbit && _Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ch))) {
+            _State |= ios_base::badbit;
+        }
+
+        for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on right
+            if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                _State |= ios_base::badbit;
+            }
+        }
+        _CATCH_IO_(ios_base, _Ostr)
+    }
+
+    _Ostr.width(0);
+    _Ostr.setstate(_State);
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Elem* _Val) { // insert NTCS
+    using _Myos = basic_ostream<_Elem, _Traits>;
+
+    ios_base::iostate _State = ios_base::goodbit;
+    streamsize _Count        = static_cast<streamsize>(_Traits::length(_Val));
+    streamsize _Pad          = _Ostr.width() <= 0 || _Ostr.width() <= _Count ? 0 : _Ostr.width() - _Count;
+    const typename _Myos::sentry _Ok(_Ostr);
+
+    if (!_Ok) {
+        _State |= ios_base::badbit;
+    } else { // state okay, insert
+        _TRY_IO_BEGIN
+        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
+            for (; 0 < _Pad; --_Pad) { // pad on left
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+        }
+
+        if (_State == ios_base::goodbit && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count) {
+            _State |= ios_base::badbit;
+        }
+
+        if (_State == ios_base::goodbit) {
+            for (; 0 < _Pad; --_Pad) { // pad on right
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+        }
+
+        _Ostr.width(0);
+        _CATCH_IO_(ios_base, _Ostr)
+    }
+
+    _Ostr.setstate(_State);
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, _Elem _Ch) { // insert a character
+    using _Myos = basic_ostream<_Elem, _Traits>;
+
+    ios_base::iostate _State = ios_base::goodbit;
+    const typename _Myos::sentry _Ok(_Ostr);
+
+    if (_Ok) { // state okay, insert
+        streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;
+
+        _TRY_IO_BEGIN
+        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
+            for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on left
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= ios_base::badbit;
+                }
+            }
+        }
+
+        if (_State == ios_base::goodbit && _Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ch))) {
+            _State |= ios_base::badbit;
+        }
+
+        for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { // pad on right
+            if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                _State |= ios_base::badbit;
+            }
+        }
+        _CATCH_IO_(ios_base, _Ostr)
+    }
+
+    _Ostr.width(0);
+    _Ostr.setstate(_State);
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const signed char* _Val) {
+    // insert a signed char NTBS
+    return _Ostr << reinterpret_cast<const char*>(_Val);
+}
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, signed char _Ch) { // insert a signed char
+    return _Ostr << static_cast<char>(_Ch);
+}
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const unsigned char* _Val) {
+    // insert an unsigned char NTBS
+    return _Ostr << reinterpret_cast<const char*>(_Val);
+}
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, unsigned char _Ch) {
+    // insert an unsigned char
+    return _Ostr << static_cast<char>(_Ch);
+}
+
+#ifdef __cpp_char8_t // These deleted overloads are specified in P1423.
+// don't insert a UTF-8 NTBS
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
+_EXPORT_STD template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
+
+// don't insert a UTF-8 code unit
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
+_EXPORT_STD template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
+#endif // defined(__cpp_char8_t)
+
+#if !_HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20
+#ifdef _NATIVE_WCHAR_T_DEFINED
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
+#endif // _NATIVE_WCHAR_T_DEFINED
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
+_EXPORT_STD template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
+_EXPORT_STD template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
+
+_EXPORT_STD template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
+_EXPORT_STD template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
+#endif // !_HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20
+
+template <class _Ostr, class _Ty, class = void>
+struct _Can_stream_out : false_type {};
+
+template <class _Ostr, class _Ty>
+struct _Can_stream_out<_Ostr, _Ty, void_t<decltype(_STD declval<_Ostr&>() << _STD declval<const _Ty&>())>> : true_type {
+};
+
+_EXPORT_STD template <class _Ostr, class _Ty,
+    enable_if_t<conjunction_v<is_convertible<_Ostr*, ios_base*>, _Can_stream_out<_Ostr, _Ty>>, int> = 0>
+_Ostr&& operator<<(_Ostr&& _Os, const _Ty& _Val) { // insert to rvalue stream
+    _Os << _Val;
+    return _STD move(_Os);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL endl(
+    basic_ostream<_Elem, _Traits>& _Ostr) { // insert newline and flush stream
+    _Ostr.put(_Ostr.widen('\n'));
+    _Ostr.flush();
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL ends(basic_ostream<_Elem, _Traits>& _Ostr) { // insert null character
+    _Ostr.put(_Elem());
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& __CLRCALL_OR_CDECL flush(basic_ostream<_Elem, _Traits>& _Ostr) { // flush stream
+    _Ostr.flush();
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const error_code& _Errcode) {
+    // display error code
+    return _Ostr << _Errcode.category().name() << ':' << _Errcode.value();
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_OSTREAM_HPP
diff --git a/msvc-stl/stl/inc/__msvc_print.hpp b/msvc-stl/stl/inc/__msvc_print.hpp
new file mode 100644
index 0000000..5f6d36c
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_print.hpp
@@ -0,0 +1,81 @@
+// __msvc_print.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_PRINT_HPP
+#define __MSVC_PRINT_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20 // note: <format> includes this header in C++20 mode
+#error The contents of <print> are available only with C++23. (Also, you should not include this internal header.)
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#include <cstdio>
+#include <xfilesystem_abi.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+
+enum class __std_unicode_console_handle : intptr_t { _Invalid = -1 };
+
+struct __std_unicode_console_retrieval_result {
+    __std_unicode_console_handle _Console_handle;
+
+    // For this, we have a few potential return values:
+    //
+    //   - __std_win_error::_Success: The operation completed successfully. This is the only value for which the
+    //     _Console_handle field has a well-defined value.
+    //
+    //   - __std_win_error::_File_not_found: The FILE* provided is valid, but it is determined to not be associated
+    //     with a unicode console. In this case, printing should fall back to vprint_nonunicode().
+    //
+    //   - __std_win_error::_Not_supported: The FILE* provided does not actually have an associated output stream. In
+    //     this case, the entire print can safely be elided, thanks to the "as-if" rule.
+    //     (We haven't observed this happening in practice. Console applications with stdout redirected to NUL
+    //     and Windows applications both appear to activate the __std_win_error::_File_not_found "valid, but
+    //     not a unicode console" codepath.)
+    //
+    //   - __std_win_error::_Invalid_parameter: The FILE* provided is invalid. A std::system_error exception should be
+    //     thrown if this value is returned within the FILE* overload of vprint_unicode().
+    __std_win_error _Error;
+};
+
+_NODISCARD _Success_(return._Error == __std_win_error::_Success) __std_unicode_console_retrieval_result __stdcall
+    __std_get_unicode_console_handle_from_file_stream(_In_ FILE* _Stream) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error __stdcall __std_print_to_unicode_console(
+    _In_ __std_unicode_console_handle _Console_handle, _In_reads_(_Str_size) const char* _Str,
+    _In_ size_t _Str_size) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error __stdcall
+    __std_print_newline_only_to_unicode_console(_In_ __std_unicode_console_handle _Console_handle) noexcept;
+
+} // extern "C"
+
+_STD_BEGIN
+
+_NODISCARD consteval bool _Is_ordinary_literal_encoding_utf8() {
+    // See: https://learn.microsoft.com/windows/win32/intl/code-page-identifiers
+#if defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET == 65001 // Unicode (UTF-8) == 65001
+    return true;
+#else
+    return false;
+#endif
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_PRINT_HPP
diff --git a/msvc-stl/stl/inc/__msvc_ranges_to.hpp b/msvc-stl/stl/inc/__msvc_ranges_to.hpp
new file mode 100644
index 0000000..fa14c67
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_ranges_to.hpp
@@ -0,0 +1,1241 @@
+// __msvc_ranges_to.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This header provides ranges::to (C++23) and supporting machinery (C++20).
+
+#ifndef __MSVC_RANGES_TO_HPP
+#define __MSVC_RANGES_TO_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20
+#error The contents of <ranges> are only available with C++20. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX20
+
+#include <tuple>
+#include <xutility>
+
+#if _HAS_CXX23
+#include <xmemory>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+namespace ranges {
+    template <class _Ty>
+    constexpr bool _Is_initializer_list = _Is_specialization_v<remove_cvref_t<_Ty>, initializer_list>;
+
+    _EXPORT_STD template <class _Rng>
+    concept viewable_range = range<_Rng>
+                          && ((view<remove_cvref_t<_Rng>> && constructible_from<remove_cvref_t<_Rng>, _Rng>)
+                              || (!view<remove_cvref_t<_Rng>>
+                                  && (is_lvalue_reference_v<_Rng>
+                                      || (movable<remove_reference_t<_Rng>> && !_Is_initializer_list<_Rng>) )));
+
+    namespace _Pipe {
+        template <class _Derived>
+        struct _Base {};
+
+        template <class _Ty>
+        _Ty* _Derived_from_range_adaptor_closure(_Base<_Ty>&); // not defined
+
+        template <class _Ty>
+        concept _Range_adaptor_closure_object = !range<remove_cvref_t<_Ty>> && requires(remove_cvref_t<_Ty>& __t) {
+            { _Pipe::_Derived_from_range_adaptor_closure(__t) } -> same_as<remove_cvref_t<_Ty>*>;
+        };
+
+        template <class _ClosureLeft, class _ClosureRight>
+        struct _Pipeline : _Base<_Pipeline<_ClosureLeft, _ClosureRight>> {
+            _STL_INTERNAL_STATIC_ASSERT(_Range_adaptor_closure_object<_ClosureLeft>);
+            _STL_INTERNAL_STATIC_ASSERT(_Range_adaptor_closure_object<_ClosureRight>);
+
+            /* [[no_unique_address]] */ _ClosureLeft _Left;
+            /* [[no_unique_address]] */ _ClosureRight _Right;
+
+            template <class _Ty1, class _Ty2>
+            constexpr explicit _Pipeline(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
+                is_nothrow_constructible_v<_Ty1, _ClosureLeft> && is_nothrow_constructible_v<_Ty2, _ClosureRight>)
+                : _Left(_STD forward<_Ty1>(_Val1)), _Right(_STD forward<_Ty2>(_Val2)) {}
+
+            void operator()(auto&&) &       = delete;
+            void operator()(auto&&) const&  = delete;
+            void operator()(auto&&) &&      = delete;
+            void operator()(auto&&) const&& = delete;
+
+            template <class _Ty>
+            _NODISCARD constexpr decltype(auto) operator()(_Ty&& _Val) & noexcept(
+                noexcept(_Right(_Left(_STD forward<_Ty>(_Val)))))
+                requires requires { _Right(_Left(_STD forward<_Ty>(_Val))); }
+            {
+                return _Right(_Left(_STD forward<_Ty>(_Val)));
+            }
+
+            template <class _Ty>
+            _NODISCARD constexpr decltype(auto) operator()(_Ty&& _Val) const& noexcept(
+                noexcept(_Right(_Left(_STD forward<_Ty>(_Val)))))
+                requires requires { _Right(_Left(_STD forward<_Ty>(_Val))); }
+            {
+                return _Right(_Left(_STD forward<_Ty>(_Val)));
+            }
+
+            template <class _Ty>
+            _NODISCARD constexpr decltype(auto) operator()(_Ty&& _Val) && noexcept(
+                noexcept(_STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val)))))
+                requires requires { _STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val))); }
+            {
+                return _STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val)));
+            }
+
+            template <class _Ty>
+            _NODISCARD constexpr decltype(auto) operator()(_Ty&& _Val) const&& noexcept(
+                noexcept(_STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val)))))
+                requires requires { _STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val))); }
+            {
+                return _STD move(_Right)(_STD move(_Left)(_STD forward<_Ty>(_Val)));
+            }
+        };
+
+        template <class _Ty1, class _Ty2>
+        _Pipeline(_Ty1, _Ty2) -> _Pipeline<_Ty1, _Ty2>;
+
+        _EXPORT_STD template <class _Left, class _Right>
+            requires _Range_adaptor_closure_object<_Left> && _Range_adaptor_closure_object<_Right>
+                  && constructible_from<remove_cvref_t<_Left>, _Left>
+                  && constructible_from<remove_cvref_t<_Right>, _Right>
+        _NODISCARD constexpr auto operator|(_Left&& __l, _Right&& __r)
+            noexcept(noexcept(_Pipeline{static_cast<_Left&&>(__l), static_cast<_Right&&>(__r)})) {
+            return _Pipeline{static_cast<_Left&&>(__l), static_cast<_Right&&>(__r)};
+        }
+
+        _EXPORT_STD template <class _Left, class _Right>
+            requires (_Range_adaptor_closure_object<_Right> && range<_Left>)
+        _NODISCARD constexpr decltype(auto) operator|(_Left&& __l, _Right&& __r)
+            noexcept(noexcept(_STD forward<_Right>(__r)(_STD forward<_Left>(__l))))
+            requires requires { static_cast<_Right&&>(__r)(static_cast<_Left&&>(__l)); }
+        {
+            return _STD forward<_Right>(__r)(_STD forward<_Left>(__l));
+        }
+    } // namespace _Pipe
+
+    template <class _Ty>
+    concept _Valid_movable_box_object =
+#if _HAS_CXX23
+        move_constructible<_Ty>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        copy_constructible<_Ty>
+#endif // ^^^ !_HAS_CXX23 ^^^
+        && _Destructible_object<_Ty>;
+
+    // A simplified optional that augments copy_constructible types with full copyability,
+    // and move_constructible types with full movability.
+    // In C++20, this corresponds to copyable-box.
+    template <_Valid_movable_box_object _Ty>
+    class _Movable_box {
+    public:
+        constexpr _Movable_box() noexcept(is_nothrow_default_constructible_v<_Ty>)
+            requires default_initializable<_Ty>
+            : _Val(), _Engaged{true} {}
+
+        template <class... _Types>
+        constexpr _Movable_box(in_place_t, _Types&&... _Args)
+            noexcept(is_nothrow_constructible_v<_Ty, _Types...>) // strengthened
+            : _Val(_STD forward<_Types>(_Args)...), _Engaged{true} {}
+
+        constexpr ~_Movable_box() {
+            if (_Engaged) {
+                _Val.~_Ty();
+            }
+        }
+
+        ~_Movable_box()
+            requires is_trivially_destructible_v<_Ty>
+        = default;
+
+        _Movable_box(const _Movable_box&)
+            requires copy_constructible<_Ty> && is_trivially_copy_constructible_v<_Ty>
+        = default;
+
+        constexpr _Movable_box(const _Movable_box& _That)
+            requires copy_constructible<_Ty>
+            : _Engaged{_That._Engaged} {
+            if (_That._Engaged) {
+                _STD _Construct_in_place(_Val, static_cast<const _Ty&>(_That._Val));
+            }
+        }
+
+        _Movable_box(_Movable_box&&)
+            requires is_trivially_move_constructible_v<_Ty>
+        = default;
+
+        constexpr _Movable_box(_Movable_box&& _That) : _Engaged{_That._Engaged} {
+            if (_That._Engaged) {
+                _STD _Construct_in_place(_Val, static_cast<_Ty&&>(_That._Val));
+            }
+        }
+
+        _Movable_box& operator=(const _Movable_box&) noexcept
+            requires copyable<_Ty> && is_trivially_copy_assignable_v<_Ty>
+        = default;
+
+        constexpr _Movable_box& operator=(const _Movable_box& _That)
+            noexcept(is_nothrow_copy_constructible_v<_Ty> && is_nothrow_copy_assignable_v<_Ty>) // strengthened
+            requires copyable<_Ty>
+        {
+            if (_Engaged) {
+                if (_That._Engaged) {
+                    static_cast<_Ty&>(_Val) = static_cast<const _Ty&>(_That._Val);
+                } else {
+                    _Val.~_Ty();
+                    _Engaged = false;
+                }
+            } else {
+                if (_That._Engaged) {
+                    _STD _Construct_in_place(_Val, static_cast<const _Ty&>(_That._Val));
+                    _Engaged = true;
+                } else {
+                    // nothing to do
+                }
+            }
+
+            return *this;
+        }
+
+        constexpr _Movable_box& operator=(const _Movable_box& _That) noexcept(is_nothrow_copy_constructible_v<_Ty>)
+            requires copy_constructible<_Ty>
+        {
+            if (_STD addressof(_That) == this) {
+                return *this;
+            }
+
+            if (_Engaged) {
+                _Val.~_Ty();
+                _Engaged = false;
+            }
+
+            if (_That._Engaged) {
+                _STD _Construct_in_place(_Val, static_cast<const _Ty&>(_That._Val));
+                _Engaged = true;
+            }
+
+            return *this;
+        }
+
+        _Movable_box& operator=(_Movable_box&&) noexcept
+            requires movable<_Ty> && is_trivially_move_assignable_v<_Ty>
+        = default;
+
+        constexpr _Movable_box& operator=(_Movable_box&& _That)
+            noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>) // strengthened
+            requires movable<_Ty>
+        {
+            if (_Engaged) {
+                if (_That._Engaged) {
+                    static_cast<_Ty&>(_Val) = static_cast<_Ty&&>(_That._Val);
+                } else {
+                    _Val.~_Ty();
+                    _Engaged = false;
+                }
+            } else {
+                if (_That._Engaged) {
+                    _STD _Construct_in_place(_Val, static_cast<_Ty&&>(_That._Val));
+                    _Engaged = true;
+                } else {
+                    // nothing to do
+                }
+            }
+
+            return *this;
+        }
+
+        constexpr _Movable_box& operator=(_Movable_box&& _That) noexcept(is_nothrow_move_constructible_v<_Ty>) {
+            if (_STD addressof(_That) == this) {
+                return *this;
+            }
+
+            if (_Engaged) {
+                _Val.~_Ty();
+                _Engaged = false;
+            }
+
+            if (_That._Engaged) {
+                _STD _Construct_in_place(_Val, static_cast<_Ty&&>(_That._Val));
+                _Engaged = true;
+            }
+
+            return *this;
+        }
+
+        constexpr explicit operator bool() const noexcept {
+            return _Engaged;
+        }
+
+        _NODISCARD constexpr _Ty& operator*() noexcept {
+            _STL_INTERNAL_CHECK(_Engaged);
+            return _Val;
+        }
+        _NODISCARD constexpr const _Ty& operator*() const noexcept {
+            _STL_INTERNAL_CHECK(_Engaged);
+            return _Val;
+        }
+
+    private:
+        union {
+            remove_cv_t<_Ty> _Val;
+        };
+        bool _Engaged;
+    };
+
+    // [range.move.wrap]
+    template <class _Ty>
+    concept _Use_simple_movable_box_wrapper =
+        (copy_constructible<_Ty>
+                // 1. If copy_constructible<T> is true, movable-box<T> should store only a T if either T models
+                // copyable, or is_nothrow_move_constructible_v<T> && is_nothrow_copy_constructible_v<T> is true.
+                ? copyable<_Ty> || (is_nothrow_move_constructible_v<_Ty> && is_nothrow_copy_constructible_v<_Ty>)
+                // 2. Otherwise, movable-box<T> should store only a T if either T models movable or
+                // is_nothrow_move_constructible_v<T> is true.
+                : movable<_Ty> || is_nothrow_move_constructible_v<_Ty>);
+
+    template <class _Ty>
+    concept _Copy_constructible_for_box = is_copy_constructible_v<_Ty>;
+
+    template <_Valid_movable_box_object _Ty>
+        requires _Use_simple_movable_box_wrapper<_Ty>
+    class _Movable_box<_Ty> { // provide the same API more efficiently when we can avoid the disengaged state
+    public:
+        _Movable_box()
+            requires default_initializable<_Ty>
+        = default;
+
+        template <class... _Types>
+        constexpr _Movable_box(in_place_t, _Types&&... _Args)
+            noexcept(is_nothrow_constructible_v<_Ty, _Types...>) // strengthened
+            : _Val(_STD forward<_Types>(_Args)...) {}
+
+        _Movable_box(const _Movable_box&)
+            requires _Copy_constructible_for_box<_Ty> && is_trivially_copy_constructible_v<_Ty>
+        = default;
+        _Movable_box(_Movable_box&&)
+            requires is_trivially_move_constructible_v<_Ty>
+        = default;
+
+        constexpr _Movable_box(const _Movable_box& _That) noexcept(is_nothrow_copy_constructible_v<_Ty>)
+            requires _Copy_constructible_for_box<_Ty>
+            : _Val(static_cast<const _Ty&>(_That._Val)) {}
+
+        constexpr _Movable_box(_Movable_box&& _That) noexcept(is_nothrow_move_constructible_v<_Ty>)
+            : _Val(static_cast<_Ty&&>(_That._Val)) {}
+
+        _Movable_box& operator=(const _Movable_box&)
+            requires copyable<_Ty> && is_trivially_copy_assignable_v<_Ty>
+        = default;
+        _Movable_box& operator=(_Movable_box&&)
+            requires movable<_Ty> && is_trivially_move_assignable_v<_Ty>
+        = default;
+
+        constexpr _Movable_box& operator=(const _Movable_box& _That)
+            noexcept(is_nothrow_copy_assignable_v<_Ty> || !copyable<_Ty>) // strengthened
+            requires copy_constructible<_Ty>
+        {
+            if constexpr (copyable<_Ty>) {
+                static_cast<_Ty&>(_Val) = static_cast<const _Ty&>(_That._Val);
+            } else {
+                if (_STD addressof(_That) != this) {
+                    _Val.~_Ty();
+                    _STD _Construct_in_place(_Val, static_cast<const _Ty&>(_That._Val));
+                }
+            }
+            return *this;
+        }
+
+        constexpr _Movable_box& operator=(_Movable_box&& _That)
+            noexcept(is_nothrow_move_assignable_v<_Ty> || !movable<_Ty>) /* strengthened */ {
+            if constexpr (movable<_Ty>) {
+                static_cast<_Ty&>(_Val) = static_cast<_Ty&&>(_That._Val);
+            } else {
+                if (_STD addressof(_That) != this) {
+                    _Val.~_Ty();
+                    _STD _Construct_in_place(_Val, static_cast<_Ty&&>(_That._Val));
+                }
+            }
+            return *this;
+        }
+
+        constexpr explicit operator bool() const noexcept {
+            return true;
+        }
+
+        _NODISCARD constexpr _Ty& operator*() noexcept {
+            return _Val;
+        }
+        _NODISCARD constexpr const _Ty& operator*() const noexcept {
+            return _Val;
+        }
+
+    private:
+        /* [[no_unique_address]] */ remove_cv_t<_Ty> _Val{};
+    };
+
+    template <class _Fn, class... _Types>
+    class _Range_closure : public _Pipe::_Base<_Range_closure<_Fn, _Types...>> {
+    public:
+        // We assume that _Fn is the type of a customization point object. That means
+        // 1. The behavior of operator() is independent of cvref qualifiers, so we can use `invocable<_Fn, ` without
+        //    loss of generality, and
+        // 2. _Fn must be default-constructible and stateless, so we can create instances "on-the-fly" and avoid
+        //    storing a copy.
+
+        _STL_INTERNAL_STATIC_ASSERT((same_as<decay_t<_Types>, _Types> && ...));
+        _STL_INTERNAL_STATIC_ASSERT(is_empty_v<_Fn>&& is_default_constructible_v<_Fn>);
+
+        template <class... _UTypes>
+            requires (same_as<decay_t<_UTypes>, _Types> && ...)
+        constexpr explicit _Range_closure(_UTypes&&... _Args)
+            noexcept(conjunction_v<is_nothrow_constructible<_Types, _UTypes>...>)
+            : _Captures(_STD forward<_UTypes>(_Args)...) {}
+
+        void operator()(auto&&) &       = delete;
+        void operator()(auto&&) const&  = delete;
+        void operator()(auto&&) &&      = delete;
+        void operator()(auto&&) const&& = delete;
+
+        using _Indices = index_sequence_for<_Types...>;
+
+        template <class _Ty>
+            requires invocable<_Fn, _Ty, _Types&...>
+        constexpr decltype(auto) operator()(_Ty&& _Arg) & noexcept(
+            noexcept(_Call(*this, _STD forward<_Ty>(_Arg), _Indices{}))) {
+            return _Call(*this, _STD forward<_Ty>(_Arg), _Indices{});
+        }
+
+        template <class _Ty>
+            requires invocable<_Fn, _Ty, const _Types&...>
+        constexpr decltype(auto) operator()(_Ty&& _Arg) const& noexcept(
+            noexcept(_Call(*this, _STD forward<_Ty>(_Arg), _Indices{}))) {
+            return _Call(*this, _STD forward<_Ty>(_Arg), _Indices{});
+        }
+
+        template <class _Ty>
+            requires invocable<_Fn, _Ty, _Types...>
+        constexpr decltype(auto) operator()(_Ty&& _Arg) && noexcept(
+            noexcept(_Call(_STD move(*this), _STD forward<_Ty>(_Arg), _Indices{}))) {
+            return _Call(_STD move(*this), _STD forward<_Ty>(_Arg), _Indices{});
+        }
+
+        template <class _Ty>
+            requires invocable<_Fn, _Ty, const _Types...>
+        constexpr decltype(auto) operator()(_Ty&& _Arg) const&& noexcept(
+            noexcept(_Call(_STD move(*this), _STD forward<_Ty>(_Arg), _Indices{}))) {
+            return _Call(_STD move(*this), _STD forward<_Ty>(_Arg), _Indices{});
+        }
+
+    private:
+        template <class _SelfTy, class _Ty, size_t... _Idx>
+        static constexpr decltype(auto) _Call(_SelfTy&& _Self, _Ty&& _Arg, index_sequence<_Idx...>) noexcept(
+            noexcept(_Fn{}(_STD forward<_Ty>(_Arg), _STD get<_Idx>(_STD forward<_SelfTy>(_Self)._Captures)...))) {
+            _STL_INTERNAL_STATIC_ASSERT(same_as<index_sequence<_Idx...>, _Indices>);
+            return _Fn{}(_STD forward<_Ty>(_Arg), _STD get<_Idx>(_STD forward<_SelfTy>(_Self)._Captures)...);
+        }
+
+        tuple<_Types...> _Captures;
+    };
+
+    _EXPORT_STD template <range _Rng>
+        requires is_object_v<_Rng>
+    class ref_view : public view_interface<ref_view<_Rng>> {
+    private:
+        _Rng* _Range;
+
+        static void _Rvalue_poison(_Rng&);
+        static void _Rvalue_poison(_Rng&&) = delete;
+
+    public:
+        template <_Different_from<ref_view> _OtherRng>
+        constexpr ref_view(_OtherRng&& _Other)
+            noexcept(noexcept(static_cast<_Rng&>(_STD forward<_OtherRng>(_Other)))) // strengthened
+            requires convertible_to<_OtherRng, _Rng&> && requires { _Rvalue_poison(static_cast<_OtherRng&&>(_Other)); }
+            : _Range{_STD addressof(static_cast<_Rng&>(_STD forward<_OtherRng>(_Other)))} {}
+
+        _NODISCARD constexpr _Rng& base() const noexcept /* strengthened */ {
+            return *_Range;
+        }
+
+        _NODISCARD constexpr iterator_t<_Rng> begin() const
+            noexcept(noexcept(_RANGES begin(*_Range))) /* strengthened */ {
+            return _RANGES begin(*_Range);
+        }
+
+        _NODISCARD constexpr sentinel_t<_Rng> end() const noexcept(noexcept(_RANGES end(*_Range))) /* strengthened */ {
+            return _RANGES end(*_Range);
+        }
+
+        _NODISCARD constexpr bool empty() const noexcept(noexcept(_RANGES empty(*_Range))) /* strengthened */
+            requires _Can_empty<_Rng>
+        {
+            return _RANGES empty(*_Range);
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(*_Range))) /* strengthened */
+            requires sized_range<_Rng>
+        {
+            return _RANGES size(*_Range);
+        }
+
+        _NODISCARD constexpr auto data() const noexcept(noexcept(_RANGES data(*_Range))) /* strengthened */
+            requires contiguous_range<_Rng>
+        {
+            return _RANGES data(*_Range);
+        }
+    };
+
+    template <class _Rng>
+    ref_view(_Rng&) -> ref_view<_Rng>;
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<ref_view<_Rng>> = true;
+
+    _EXPORT_STD template <range _Rng>
+        requires (movable<_Rng> && !_Is_initializer_list<_Rng>)
+    class owning_view : public view_interface<owning_view<_Rng>> {
+    private:
+        _Rng _Range{};
+
+    public:
+        owning_view()
+            requires default_initializable<_Rng>
+        = default;
+
+        constexpr owning_view(_Rng&& _Range_) noexcept(is_nothrow_move_constructible_v<_Rng>) // strengthened
+            : _Range(_STD move(_Range_)) {}
+
+        owning_view(owning_view&&)            = default;
+        owning_view& operator=(owning_view&&) = default;
+
+        _NODISCARD constexpr _Rng& base() & noexcept {
+            return _Range;
+        }
+        _NODISCARD constexpr const _Rng& base() const& noexcept {
+            return _Range;
+        }
+        _NODISCARD constexpr _Rng&& base() && noexcept {
+            return _STD move(_Range);
+        }
+        _NODISCARD constexpr const _Rng&& base() const&& noexcept {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr iterator_t<_Rng> begin() noexcept(noexcept(_RANGES begin(_Range))) /* strengthened */ {
+            return _RANGES begin(_Range);
+        }
+
+        _NODISCARD constexpr sentinel_t<_Rng> end() noexcept(noexcept(_RANGES end(_Range))) /* strengthened */ {
+            return _RANGES end(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(noexcept(_RANGES begin(_Range))) /* strengthened */
+            requires range<const _Rng>
+        {
+            return _RANGES begin(_Range);
+        }
+
+        _NODISCARD constexpr auto end() const noexcept(noexcept(_RANGES end(_Range))) /* strengthened */
+            requires range<const _Rng>
+        {
+            return _RANGES end(_Range);
+        }
+
+        _NODISCARD constexpr bool empty() noexcept(noexcept(_RANGES empty(_Range))) /* strengthened */
+            requires _Can_empty<_Rng>
+        {
+            return _RANGES empty(_Range);
+        }
+        _NODISCARD constexpr bool empty() const noexcept(noexcept(_RANGES empty(_Range))) /* strengthened */
+            requires _Can_empty<const _Rng>
+        {
+            return _RANGES empty(_Range);
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Range))) /* strengthened */
+            requires sized_range<_Rng>
+        {
+            return _RANGES size(_Range);
+        }
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Range))) /* strengthened */
+            requires sized_range<const _Rng>
+        {
+            return _RANGES size(_Range);
+        }
+
+        _NODISCARD constexpr auto data() noexcept(noexcept(_RANGES data(_Range))) /* strengthened */
+            requires contiguous_range<_Rng>
+        {
+            return _RANGES data(_Range);
+        }
+        _NODISCARD constexpr auto data() const noexcept(noexcept(_RANGES data(_Range))) /* strengthened */
+            requires contiguous_range<const _Rng>
+        {
+            return _RANGES data(_Range);
+        }
+    };
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<owning_view<_Rng>> = enable_borrowed_range<_Rng>;
+
+    namespace views {
+        template <class _Rng>
+        concept _Can_ref_view = requires(_Rng&& __r) { ref_view{static_cast<_Rng&&>(__r)}; };
+
+        template <class _Rng>
+        concept _Ownable = requires(_Rng&& __r) { owning_view{static_cast<_Rng&&>(__r)}; };
+
+        class _All_fn : public _Pipe::_Base<_All_fn> {
+        private:
+            enum class _St { _None, _View, _Ref, _Own };
+
+            template <class _Rng>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                if constexpr (view<remove_cvref_t<_Rng>>) {
+                    if constexpr (convertible_to<_Rng, remove_cvref_t<_Rng>>) {
+                        return {_St::_View, is_nothrow_convertible_v<_Rng, remove_cvref_t<_Rng>>};
+                    }
+                } else if constexpr (_Can_ref_view<_Rng>) {
+                    return {_St::_Ref, noexcept(ref_view{_STD declval<_Rng>()})};
+                } else if constexpr (_Ownable<_Rng>) {
+                    return {_St::_Own, noexcept(owning_view{_STD declval<_Rng>()})};
+                }
+
+                return {_St::_None};
+            }
+
+            template <class _Rng>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();
+
+        public:
+            template <viewable_range _Rng>
+                requires (_Choice<_Rng>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
+                constexpr _St _Strat = _Choice<_Rng>._Strategy;
+
+                if constexpr (_Strat == _St::_View) {
+                    return _STD forward<_Rng>(_Range);
+                } else if constexpr (_Strat == _St::_Ref) {
+                    return ref_view{_STD forward<_Rng>(_Range)};
+                } else if constexpr (_Strat == _St::_Own) {
+                    return owning_view{_STD forward<_Rng>(_Range)};
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+
+        _EXPORT_STD inline constexpr _All_fn all;
+
+        _EXPORT_STD template <viewable_range _Rng>
+        using all_t = decltype(all(_STD declval<_Rng>()));
+    } // namespace views
+
+    _EXPORT_STD template <input_range _Vw, _Valid_movable_box_object _Fn>
+        requires view<_Vw> && regular_invocable<_Fn&, range_reference_t<_Vw>>
+              && _Can_reference<invoke_result_t<_Fn&, range_reference_t<_Vw>>>
+    class transform_view : public view_interface<transform_view<_Vw, _Fn>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        /* [[no_unique_address]] */ _Movable_box<_Fn> _Fun{};
+
+        template <bool _Const>
+        struct _Category_base {};
+
+        template <bool _Const>
+            requires forward_range<_Maybe_const<_Const, _Vw>>
+        struct _Category_base<_Const> {
+            using _Base = _Maybe_const<_Const, _Vw>;
+            using iterator_category =
+                conditional_t<is_reference_v<invoke_result_t<_Maybe_const<_Const, _Fn>&, range_reference_t<_Base>>>,
+                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_Base>>, contiguous_iterator_tag>,
+                        random_access_iterator_tag, _Iter_cat_t<iterator_t<_Base>>>,
+                    input_iterator_tag>;
+        };
+
+        template <bool _Const>
+        class _Iterator : public _Category_base<_Const> {
+        private:
+            friend transform_view;
+
+            using _Parent_t = _Maybe_const<_Const, transform_view>;
+            using _Base     = _Maybe_const<_Const, _Vw>;
+
+            iterator_t<_Base> _Current{};
+            _Parent_t* _Parent{};
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            constexpr void _Check_dereference() const noexcept {
+                _STL_VERIFY(_Parent != nullptr, "cannot dereference value-initialized transform_view iterator");
+                _STL_VERIFY(_Current != _RANGES end(_Parent->_Range), "cannot dereference end transform_view iterator");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            constexpr void _Same_range(const _Iterator& _Right) const noexcept {
+                _STL_VERIFY(_Parent == _Right._Parent, "cannot compare incompatible transform_view iterators");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        public:
+            using iterator_concept = conditional_t<random_access_range<_Base>, random_access_iterator_tag,
+                conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag,
+                    conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>>>;
+            using value_type = remove_cvref_t<invoke_result_t<_Maybe_const<_Const, _Fn>&, range_reference_t<_Base>>>;
+            using difference_type = range_difference_t<_Base>;
+
+            _Iterator()
+                requires default_initializable<iterator_t<_Base>>
+            = default;
+
+            constexpr _Iterator(_Parent_t& _Parent_, iterator_t<_Base> _Current_)
+                noexcept(is_nothrow_move_constructible_v<iterator_t<_Base>>) // strengthened
+                : _Current{_STD move(_Current_)}, _Parent{_STD addressof(_Parent_)} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STD _Adl_verify_range(_Current, _RANGES end(_Parent_._Range));
+                if constexpr (forward_range<_Base>) {
+                    _STD _Adl_verify_range(_RANGES begin(_Parent_._Range), _Current);
+                }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+            }
+
+            constexpr _Iterator(_Iterator<!_Const> _It)
+                noexcept(is_nothrow_constructible_v<iterator_t<_Base>, iterator_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<iterator_t<_Vw>, iterator_t<_Base>>
+                : _Current(_STD move(_It._Current)), _Parent(_It._Parent) {}
+
+            _NODISCARD constexpr const iterator_t<_Base>& base() const& noexcept {
+                return _Current;
+            }
+            _NODISCARD constexpr iterator_t<_Base> base() && noexcept(
+                is_nothrow_move_constructible_v<iterator_t<_Base>>) /* strengthened */ {
+                return _STD move(_Current);
+            }
+
+            _NODISCARD constexpr decltype(auto) operator*() const
+                noexcept(noexcept(_STD invoke(*_Parent->_Fun, *_Current))) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Check_dereference();
+                _STL_VERIFY(
+                    _Parent->_Fun, "Cannot dereference iterator into transform_view with no transformation function");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _STD invoke(*_Parent->_Fun, *_Current);
+            }
+
+            constexpr _Iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Parent != nullptr, "Cannot increment value-initialized transform_view iterator");
+                _STL_VERIFY(
+                    _Current != _RANGES end(_Parent->_Range), "Cannot increment transform_view iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                ++_Current;
+                return *this;
+            }
+
+            constexpr decltype(auto) operator++(int) noexcept(
+                noexcept(++_Current)
+                && (!forward_range<_Base> || is_nothrow_copy_constructible_v<iterator_t<_Base>>) ) /* strengthened */ {
+                if constexpr (forward_range<_Base>) {
+                    auto _Tmp = *this;
+                    ++*this;
+                    return _Tmp;
+                } else {
+                    ++*this;
+                }
+            }
+
+            constexpr _Iterator& operator--() noexcept(noexcept(--_Current)) /* strengthened */
+                requires bidirectional_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Parent != nullptr, "Cannot decrement value-initialized transform_view iterator");
+                if constexpr (forward_range<_Vw>) {
+                    _STL_VERIFY(_Current != _RANGES begin(_Parent->_Range),
+                        "Cannot decrement transform_view iterator before begin");
+                }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                --_Current;
+                return *this;
+            }
+            constexpr _Iterator operator--(int)
+                noexcept(noexcept(--_Current) && is_nothrow_copy_constructible_v<iterator_t<_Base>>) /* strengthened */
+                requires bidirectional_range<_Base>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            constexpr void _Verify_offset(const difference_type _Off) const noexcept
+                requires random_access_range<_Base>
+            {
+                _STL_VERIFY(_Off == 0 || _Parent, "cannot seek value-initialized transform_view iterator");
+                if constexpr (_Offset_verifiable_v<iterator_t<_Base>>) {
+                    _Current._Verify_offset(_Off);
+                }
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                noexcept(noexcept(_Current += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Current += _Off;
+                return *this;
+            }
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                noexcept(noexcept(_Current -= _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Off != _Min_possible_v<difference_type>, "integer overflow");
+                _Verify_offset(-_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Current -= _Off;
+                return *this;
+            }
+
+            _NODISCARD constexpr decltype(auto) operator[](const difference_type _Idx) const
+                noexcept(noexcept(_STD invoke(*_Parent->_Fun, _Current[_Idx]))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Verify_offset(_Idx);
+                _STL_VERIFY(
+                    _Parent->_Fun, "Cannot dereference iterator into transform_view with no transformation function");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _STD invoke(*_Parent->_Fun, _Current[_Idx]);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current == _Right._Current)) /* strengthened */
+                requires equality_comparable<iterator_t<_Base>>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Left._Same_range(_Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _Left._Current == _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Left._Same_range(_Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _Left._Current < _Right._Current;
+            }
+            _NODISCARD friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return _Right < _Left;
+            }
+            _NODISCARD friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return !(_Right < _Left);
+            }
+            _NODISCARD friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return !(_Left < _Right);
+            }
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current <=> _Right._Current)) /* strengthened */
+                requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Left._Same_range(_Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _Left._Current <=> _Right._Current;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(_Iterator _It, const difference_type _Off)
+                noexcept(noexcept(_It._Current += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _It._Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _It._Current += _Off;
+                return _It;
+            }
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, _Iterator _It)
+                noexcept(noexcept(_It._Current += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _It._Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _It._Current += _Off;
+                return _It;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(_Iterator _It, const difference_type _Off)
+                noexcept(noexcept(_It._Current -= _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Off != _Min_possible_v<difference_type>, "integer overflow");
+                _It._Verify_offset(-_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _It._Current -= _Off;
+                return _It;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current - _Right._Current)) /* strengthened */
+                requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Left._Same_range(_Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _Left._Current - _Right._Current;
+            }
+        };
+
+        template <bool _Const>
+        class _Sentinel {
+        private:
+            friend transform_view;
+
+            using _Parent_t = _Maybe_const<_Const, transform_view>;
+            using _Base     = _Maybe_const<_Const, _Vw>;
+            template <bool _OtherConst>
+            using _Maybe_const_iter = iterator_t<_Maybe_const<_OtherConst, _Vw>>;
+
+            sentinel_t<_Base> _Last{};
+
+            template <bool _OtherConst>
+            _NODISCARD static constexpr const _Maybe_const_iter<_OtherConst>& _Get_current(
+                const _Iterator<_OtherConst>& _It) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(
+                    _It._Parent != nullptr, "cannot compare transform_view sentinel with value-initialized iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _It._Current;
+            }
+
+        public:
+            _Sentinel() = default;
+            constexpr explicit _Sentinel(sentinel_t<_Base> _Last_)
+                noexcept(is_nothrow_move_constructible_v<sentinel_t<_Base>>) // strengthened
+                : _Last(_STD move(_Last_)) {}
+
+            constexpr _Sentinel(_Sentinel<!_Const> _Se)
+                noexcept(is_nothrow_constructible_v<sentinel_t<_Base>, sentinel_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<sentinel_t<_Vw>, sentinel_t<_Base>>
+                : _Last(_STD move(_Se._Last)) {}
+
+            _NODISCARD constexpr sentinel_t<_Base> base() const
+                noexcept(is_nothrow_copy_constructible_v<sentinel_t<_Base>>) /* strengthened */ {
+                return _Last;
+            }
+
+            template <bool _OtherConst>
+                requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_OtherConst>& _Left, const _Sentinel& _Right)
+                noexcept(noexcept(_Get_current(_Left) == _Right._Last)) /* strengthened */ {
+                return _Get_current(_Left) == _Right._Last;
+            }
+
+            template <bool _OtherConst>
+                requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD friend constexpr range_difference_t<_Maybe_const<_OtherConst, _Vw>> operator-(
+                const _Iterator<_OtherConst>& _Left, const _Sentinel& _Right)
+                noexcept(noexcept(_Get_current(_Left) - _Right._Last)) /* strengthened */ {
+                return _Get_current(_Left) - _Right._Last;
+            }
+
+            template <bool _OtherConst>
+                requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD friend constexpr range_difference_t<_Maybe_const<_OtherConst, _Vw>> operator-(
+                const _Sentinel& _Left, const _Iterator<_OtherConst>& _Right)
+                noexcept(noexcept(_Left._Last - _Get_current(_Right))) /* strengthened */ {
+                return _Left._Last - _Get_current(_Right);
+            }
+        };
+
+    public:
+        transform_view()
+            requires default_initializable<_Vw> && default_initializable<_Fn>
+        = default;
+
+        constexpr explicit transform_view(_Vw _Range_, _Fn _Fun_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Fn>) // strengthened
+            : _Range(_STD move(_Range_)), _Fun{in_place, _STD move(_Fun_)} {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr _Iterator<false> begin() noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */ {
+            return _Iterator<false>{*this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr _Iterator<true> begin() const noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */
+            requires range<const _Vw> && regular_invocable<const _Fn&, range_reference_t<const _Vw>>
+        {
+            return _Iterator<true>{*this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto end()
+            noexcept(noexcept(_RANGES end(_Range))
+                     && is_nothrow_move_constructible_v<decltype(_RANGES end(_Range))>) /* strengthened */ {
+            if constexpr (common_range<_Vw>) {
+                return _Iterator<false>{*this, _RANGES end(_Range)};
+            } else {
+                return _Sentinel<false>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            noexcept(noexcept(_RANGES end(_Range))
+                     && is_nothrow_move_constructible_v<decltype(_RANGES end(_Range))>) /* strengthened */
+            requires range<const _Vw> && regular_invocable<const _Fn&, range_reference_t<const _Vw>>
+        {
+            if constexpr (common_range<_Vw>) {
+                return _Iterator<true>{*this, _RANGES end(_Range)};
+            } else {
+                return _Sentinel<true>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Range))) /* strengthened */
+            requires sized_range<_Vw>
+        {
+            return _RANGES size(_Range);
+        }
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Range))) /* strengthened */
+            requires sized_range<const _Vw>
+        {
+            return _RANGES size(_Range);
+        }
+    };
+
+    template <class _Rng, class _Fn>
+    transform_view(_Rng&&, _Fn) -> transform_view<views::all_t<_Rng>, _Fn>;
+
+    namespace views {
+        struct _Transform_fn {
+            template <viewable_range _Rng, class _Fn>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Fn _Fun)
+                noexcept(noexcept(transform_view(_STD forward<_Rng>(_Range), _STD move(_Fun))))
+                requires requires { transform_view(static_cast<_Rng&&>(_Range), _STD move(_Fun)); }
+            {
+                return transform_view(_STD forward<_Rng>(_Range), _STD move(_Fun));
+            }
+
+            template <class _Fn>
+                requires constructible_from<decay_t<_Fn>, _Fn>
+            _NODISCARD static constexpr auto operator()(_Fn&& _Fun)
+                noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>) {
+                return _Range_closure<_Transform_fn, decay_t<_Fn>>{_STD forward<_Fn>(_Fun)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Transform_fn transform;
+    } // namespace views
+
+#if _HAS_CXX23
+    template <class _Range, class _Container>
+    concept _Sized_and_reservable = sized_range<_Range> && sized_range<_Container>
+                                 && requires(_Container& _Cont, const range_size_t<_Container> _Count) {
+                                        _Cont.reserve(_Count);
+                                        { _Cont.capacity() } -> same_as<range_size_t<_Container>>;
+                                        { _Cont.max_size() } -> same_as<range_size_t<_Container>>;
+                                    };
+
+    template <class _Rng, class _Container>
+    concept _Ref_converts =
+        !input_range<_Container> || convertible_to<range_reference_t<_Rng>, range_value_t<_Container>>;
+
+    template <class _Rng, class _Container, class... _Types>
+    concept _Common_constructible =
+        common_range<_Rng> //
+        && requires { typename iterator_traits<iterator_t<_Rng>>::iterator_category; }
+        && derived_from<typename iterator_traits<iterator_t<_Rng>>::iterator_category, input_iterator_tag>
+        && constructible_from<_Container, iterator_t<_Rng>, iterator_t<_Rng>, _Types...>;
+
+    template <class _Container, class _Reference>
+    concept _Can_emplace_back = requires(_Container& _Cont) { _Cont.emplace_back(_STD declval<_Reference>()); };
+
+    template <class _Container, class _Reference>
+    concept _Can_push_back = requires(_Container& _Cont) { _Cont.push_back(_STD declval<_Reference>()); };
+
+    template <class _Container, class _Reference>
+    concept _Can_emplace_end = requires(_Container& _Cont) { _Cont.emplace(_Cont.end(), _STD declval<_Reference>()); };
+
+    template <class _Container, class _Reference>
+    concept _Can_insert_end = requires(_Container& _Cont) { _Cont.insert(_Cont.end(), _STD declval<_Reference>()); };
+
+    template <class _Rng, class _Container, class... _Types>
+    concept _Constructible_appendable = constructible_from<_Container, _Types...>
+                                     && (_Can_emplace_back<_Container, range_reference_t<_Rng>>
+                                         || _Can_push_back<_Container, range_reference_t<_Rng>>
+                                         || _Can_emplace_end<_Container, range_reference_t<_Rng>>
+                                         || _Can_insert_end<_Container, range_reference_t<_Rng>>);
+
+    _EXPORT_STD template <class _Container, input_range _Rng, class... _Types>
+        requires (!view<_Container>)
+    _NODISCARD constexpr _Container to(_Rng&& _Range, _Types&&... _Args) {
+        static_assert(!is_const_v<_Container>, "C must not be const. (N5014 [range.utility.conv.to]/1)");
+        static_assert(!is_volatile_v<_Container>, "C must not be volatile. (N5014 [range.utility.conv.to]/1)");
+        static_assert(is_class_v<_Container> || is_union_v<_Container>,
+            "C must be a class type. (N5014 [range.utility.conv.to]/1)");
+        if constexpr (_Ref_converts<_Rng, _Container>) {
+            if constexpr (constructible_from<_Container, _Rng, _Types...>) {
+                return _Container(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+            } else if constexpr (constructible_from<_Container, const from_range_t&, _Rng, _Types...>) { // per LWG-3845
+                return _Container(from_range, _STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+            } else if constexpr (_Common_constructible<_Rng, _Container, _Types...>) {
+                return _Container(_RANGES begin(_Range), _RANGES end(_Range), _STD forward<_Types>(_Args)...);
+            } else if constexpr (_Constructible_appendable<_Rng, _Container, _Types...>) {
+                _Container _Cont(_STD forward<_Types>(_Args)...);
+                if constexpr (_Sized_and_reservable<_Rng, _Container>) {
+                    _Cont.reserve(static_cast<range_size_t<_Container>>(_RANGES size(_Range)));
+                }
+
+                auto _Iter       = _RANGES begin(_Range);
+                const auto _Sent = _RANGES end(_Range);
+                for (; _Iter != _Sent; ++_Iter) {
+                    auto&& _Elem  = *_Iter;
+                    using _ElemTy = decltype(_Elem);
+                    if constexpr (_Can_emplace_back<_Container, _ElemTy>) {
+                        _Cont.emplace_back(_STD forward<_ElemTy>(_Elem));
+                    } else if constexpr (_Can_push_back<_Container, _ElemTy>) {
+                        _Cont.push_back(_STD forward<_ElemTy>(_Elem));
+                    } else if constexpr (_Can_emplace_end<_Container, _ElemTy>) {
+                        _Cont.emplace(_Cont.end(), _STD forward<_ElemTy>(_Elem));
+                    } else {
+                        _STL_INTERNAL_STATIC_ASSERT(_Can_insert_end<_Container, _ElemTy>);
+                        _Cont.insert(_Cont.end(), _STD forward<_ElemTy>(_Elem));
+                    }
+                }
+                return _Cont;
+            } else {
+                static_assert(false, "ranges::to requires the result to be constructible from the source range, either "
+                                     "by using a suitable constructor, or by inserting each element of the range into "
+                                     "the default-constructed object. (N5014 [range.utility.conv.to]/2.1.5)");
+            }
+        } else if constexpr (input_range<range_reference_t<_Rng>>) {
+            const auto _Xform = [](auto&& _Elem) static {
+                return _RANGES to<range_value_t<_Container>>(_STD forward<decltype(_Elem)>(_Elem));
+            };
+            return _RANGES to<_Container>(views::transform(ref_view{_Range}, _Xform), _STD forward<_Types>(_Args)...);
+        } else {
+            static_assert(false,
+                "ranges::to requires the elements of the source range to be either implicitly convertible to the "
+                "elements of the destination container, or be ranges themselves for ranges::to to be applied "
+                "recursively. (N5014 [range.utility.conv.to]/2.3)");
+        }
+    }
+
+    template <class _Container>
+    struct _To_class_fn {
+        _STL_INTERNAL_STATIC_ASSERT(!is_const_v<_Container>);
+        _STL_INTERNAL_STATIC_ASSERT(!is_volatile_v<_Container>);
+        _STL_INTERNAL_STATIC_ASSERT(is_class_v<_Container> || is_union_v<_Container>);
+        _STL_INTERNAL_STATIC_ASSERT(!view<_Container>);
+
+        template <input_range _Rng, class... _Types>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Types&&... _Args)
+            requires requires { _RANGES to<_Container>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...); }
+        {
+            return _RANGES to<_Container>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+        }
+    };
+
+    _EXPORT_STD template <class _Container, class... _Types>
+        requires (!view<_Container>)
+    _NODISCARD constexpr auto to(_Types&&... _Args) {
+        static_assert(!is_const_v<_Container>, "C must not be const. (N5014 [range.utility.conv.adaptors]/1)");
+        static_assert(!is_volatile_v<_Container>, "C must not be volatile. (N5014 [range.utility.conv.adaptors]/1)");
+        static_assert(is_class_v<_Container> || is_union_v<_Container>,
+            "C must be a class type. (N5014 [range.utility.conv.adaptors]/1)");
+        return _Range_closure<_To_class_fn<_Container>, decay_t<_Types>...>{_STD forward<_Types>(_Args)...};
+    }
+
+    template <input_range _Rng>
+    struct _Phony_input_iterator {
+        using value_type      = range_value_t<_Rng>;
+        using difference_type = ptrdiff_t;
+
+        // These member functions are never defined:
+        range_reference_t<_Rng> operator*() const;
+        add_pointer_t<range_reference_t<_Rng>> operator->() const;
+        _Phony_input_iterator& operator++();
+        _Phony_input_iterator operator++(int);
+        bool operator==(const _Phony_input_iterator&) const;
+    };
+
+    template <template <class...> class _Cnt, class _Rng, class... _Args>
+    auto _To_helper() {
+        if constexpr (requires { _Cnt(_STD declval<_Rng>(), _STD declval<_Args>()...); }) {
+            return static_cast<decltype(_Cnt(_STD declval<_Rng>(), _STD declval<_Args>()...))*>(nullptr);
+        } else if constexpr (requires { _Cnt(from_range, _STD declval<_Rng>(), _STD declval<_Args>()...); }) {
+            return static_cast<decltype(_Cnt(from_range, _STD declval<_Rng>(), _STD declval<_Args>()...))*>(nullptr);
+        } else if constexpr (requires {
+                                 _Cnt(_STD declval<_Phony_input_iterator<_Rng>>(),
+                                     _STD declval<_Phony_input_iterator<_Rng>>(), _STD declval<_Args>()...);
+                             }) {
+            return static_cast<decltype(_Cnt(_STD declval<_Phony_input_iterator<_Rng>>(),
+                _STD declval<_Phony_input_iterator<_Rng>>(), _STD declval<_Args>()...))*>(nullptr);
+        }
+    }
+
+    _EXPORT_STD template <template <class...> class _Container, input_range _Rng, class... _Types,
+        class _Deduced = remove_pointer_t<decltype(_To_helper<_Container, _Rng, _Types...>())>>
+    _NODISCARD constexpr _Deduced to(_Rng&& _Range, _Types&&... _Args) {
+        return _RANGES to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+    }
+
+    template <template <class...> class _Container>
+    struct _To_template_fn {
+        template <input_range _Rng, class... _Types,
+            class _Deduced = remove_pointer_t<decltype(_To_helper<_Container, _Rng, _Types...>())>>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Types&&... _Args) {
+            return _RANGES to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
+        }
+    };
+
+    _EXPORT_STD template <template <class...> class _Container, class... _Types>
+    _NODISCARD constexpr auto to(_Types&&... _Args) {
+        return _Range_closure<_To_template_fn<_Container>, decay_t<_Types>...>{_STD forward<_Types>(_Args)...};
+    }
+#endif // _HAS_CXX23
+} // namespace ranges
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_RANGES_TO_HPP
diff --git a/msvc-stl/stl/inc/__msvc_ranges_tuple_formatter.hpp b/msvc-stl/stl/inc/__msvc_ranges_tuple_formatter.hpp
new file mode 100644
index 0000000..a3dafcd
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_ranges_tuple_formatter.hpp
@@ -0,0 +1,1240 @@
+// __msvc_ranges_tuple_formatter.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// NOTE:
+// The contents of this header are derived in part from libfmt under the following license:
+
+// Copyright (c) 2012 - present, Victor Zverovich
+//
+// 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.
+//
+// --- Optional exception to the license ---
+//
+// As an exception, if, as a result of your compiling your source code, portions
+// of this Software are embedded into a machine-executable object form of such
+// source code, you may redistribute such embedded portions in such object form
+// without including the above copyright and permission notices.
+
+#ifndef __MSVC_RANGES_TUPLE_FORMATTER_HPP
+#define __MSVC_RANGES_TUPLE_FORMATTER_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20
+#error The contents of <format> are only available with C++20. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX20
+
+#include <__msvc_formatter.hpp>
+#include <__msvc_string_view.hpp>
+#include <bit>
+#include <iterator>
+#include <stdexcept>
+#include <xlocale>
+
+#if _HAS_CXX23
+#include <tuple>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+_EXPORT_STD template <class, class>
+class vector;
+
+template <class _CharT>
+_NODISCARD constexpr const _CharT* _Choose_literal(const char* const _Str, const wchar_t* const _WStr) noexcept {
+    if constexpr (is_same_v<_CharT, char>) {
+        return _Str;
+    } else {
+        return _WStr;
+    }
+}
+
+// _STATICALLY_WIDEN is used by <chrono> since C++20 and by <format> since C++23.
+// It's defined here, so that both headers can use this definition.
+#define _STATICALLY_WIDEN(_CharT, _Literal) (_Choose_literal<_CharT>(_Literal, L##_Literal))
+
+_EXPORT_STD class _NODISCARD format_error : public runtime_error {
+    using runtime_error::runtime_error;
+};
+
+[[noreturn]] inline void _Throw_format_error(const char* const _Message) {
+    _THROW(format_error{_Message});
+}
+
+inline void _You_see_this_error_because_arg_id_is_out_of_range() noexcept {}
+inline void _Invalid_arg_type_for_dynamic_width_or_precision() noexcept {}
+
+template <class _CharT>
+class _Compile_time_parse_context;
+
+_EXPORT_STD template <class _CharT>
+class _NO_SPECIALIZATIONS_CITING("N5014 [format.parse.ctx]/2") basic_format_parse_context {
+public:
+    using char_type      = _CharT;
+    using const_iterator = basic_string_view<_CharT>::const_iterator;
+    using iterator       = const_iterator;
+
+    constexpr explicit basic_format_parse_context(
+        const basic_string_view<_CharT> _Fmt, const size_t _Num_args_ = 0) noexcept
+        : _Format_string(_Fmt), _Num_args(_Num_args_) {}
+
+    basic_format_parse_context(const basic_format_parse_context&)            = delete;
+    basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;
+
+    _NODISCARD constexpr const_iterator begin() const noexcept {
+        return _Format_string.begin();
+    }
+    _NODISCARD constexpr const_iterator end() const noexcept {
+        return _Format_string.end();
+    }
+    _NODISCARD constexpr const _CharT* _Unchecked_begin() const noexcept {
+        return _Format_string._Unchecked_begin();
+    }
+    _NODISCARD constexpr const _CharT* _Unchecked_end() const noexcept {
+        return _Format_string._Unchecked_end();
+    }
+
+    constexpr void advance_to(const const_iterator _It) {
+        _Adl_verify_range(_It, _Format_string.end());
+        _Adl_verify_range(_Format_string.begin(), _It);
+        const auto _Diff = static_cast<size_t>(_It._Unwrapped() - _Format_string._Unchecked_begin());
+        _Format_string.remove_prefix(_Diff);
+    }
+
+    // While the standard presents an exposition-only enum value for
+    // the indexing mode (manual, automatic, or unknown) we use _Next_arg_id to indicate it.
+    // _Next_arg_id > 0 means automatic
+    // _Next_arg_id == 0 means unknown
+    // _Next_arg_id < 0 means manual
+    _NODISCARD constexpr size_t next_arg_id() {
+        if (_Next_arg_id < 0) {
+            _Throw_format_error("Can not switch from manual to automatic indexing");
+        }
+
+        if (_STD is_constant_evaluated()) {
+            if (static_cast<size_t>(_Next_arg_id) >= _Num_args) {
+                _You_see_this_error_because_arg_id_is_out_of_range();
+            }
+        }
+
+        return static_cast<size_t>(_Next_arg_id++);
+    }
+
+    constexpr void check_arg_id(const size_t _Id) {
+        if (_STD is_constant_evaluated()) {
+            if (_Id >= _Num_args) {
+                _You_see_this_error_because_arg_id_is_out_of_range();
+            }
+        }
+
+        if (_Next_arg_id > 0) {
+            _Throw_format_error("Can not switch from automatic to manual indexing");
+        }
+        _Next_arg_id = -1;
+    }
+
+    constexpr void _Check_dynamic_spec_integral(const size_t _Idx) noexcept {
+        if (_STD is_constant_evaluated()) {
+            // This downcast might seem UB-prone, but since it only happens at compile-time,
+            // the compiler will produce an error if it is invalid.
+            auto& _Ctx = static_cast<_Compile_time_parse_context<_CharT>&>(*this);
+
+            _STL_INTERNAL_CHECK(_Ctx._Arg_type[_Idx] != _Basic_format_arg_type::_None);
+            if (_Ctx._Arg_type[_Idx] > _Basic_format_arg_type::_ULong_long_type) {
+                _Invalid_arg_type_for_dynamic_width_or_precision();
+            }
+        }
+    }
+
+private:
+    basic_string_view<_CharT> _Format_string;
+    size_t _Num_args;
+    // The standard says this is size_t, however we use ptrdiff_t to save some space
+    // by not having to store the indexing mode. Above is a more detailed explanation
+    // of how this works.
+    ptrdiff_t _Next_arg_id = 0;
+};
+
+template <class _CharT>
+class _Compile_time_parse_context : public basic_format_parse_context<_CharT> {
+    friend basic_format_parse_context<_CharT>;
+
+public:
+    constexpr _Compile_time_parse_context(const basic_string_view<_CharT> _Fmt, const size_t _Num_args,
+        const _Basic_format_arg_type* const _Arg_type_) noexcept
+        : basic_format_parse_context<_CharT>(_Fmt, _Num_args), _Arg_type(_Arg_type_) {}
+
+private:
+    const _Basic_format_arg_type* const _Arg_type;
+};
+
+_EXPORT_STD using format_parse_context  = basic_format_parse_context<char>;
+_EXPORT_STD using wformat_parse_context = basic_format_parse_context<wchar_t>;
+
+template <class _Ty, class _Context, class _Formatter = _Context::template formatter_type<remove_const_t<_Ty>>>
+concept _Formattable_with = semiregular<_Formatter>
+                         && requires(_Formatter& __f, const _Formatter& __cf, _Ty&& __t, _Context __fc,
+                             basic_format_parse_context<typename _Context::char_type> __pc) {
+                                { __f.parse(__pc) } -> same_as<typename decltype(__pc)::iterator>;
+                                { __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
+                            };
+
+template <class _Context>
+struct _Format_arg_traits {
+    using _Char_type = _Context::char_type;
+
+    // Function template _Type_eraser mirrors the type dispatching mechanism in the construction of basic_format_arg
+    // (N4950 [format.arg]). They determine the mapping from "raw" to "erased" argument type for _Format_arg_store.
+    template <class _Ty>
+    static auto _Type_eraser();
+
+    template <class _Ty>
+    using _Storage_type = decltype(_Type_eraser<remove_reference_t<_Ty>>());
+
+    template <class _Ty>
+    static constexpr size_t _Storage_size = sizeof(_Storage_type<_Ty>);
+};
+
+_EXPORT_STD template <class _Context>
+class basic_format_args;
+
+_FMT_P2286_BEGIN
+template <class _CharT>
+struct _Format_handler;
+_FMT_P2286_END
+
+_EXPORT_STD template <class _Context>
+class _NO_SPECIALIZATIONS_CITING("N5014 [format.arg]/2") basic_format_arg {
+public:
+    using _CharType = _Context::char_type;
+
+    class handle {
+    private:
+        const void* _Ptr;
+        void(__cdecl* _Format)(basic_format_parse_context<_CharType>& _Parse_ctx, _Context& _Format_ctx, const void*);
+
+        template <class _Ty>
+        static void __cdecl _Handle_format(
+            basic_format_parse_context<_CharType>& _Parse_ctx, _Context& _Format_ctx, const void* _Ptr) {
+            using _Td = remove_const_t<_Ty>;
+            // doesn't drop const-qualifier per an unnumbered LWG issue
+            using _Tq = conditional_t<_Formattable_with<const _Ty, _Context>, const _Ty, _Ty>;
+            _STL_INTERNAL_STATIC_ASSERT(_Formattable_with<_Tq, _Context>);
+
+            typename _Context::template formatter_type<_Td> _Formatter;
+            _Parse_ctx.advance_to(_Formatter.parse(_Parse_ctx));
+            _Format_ctx.advance_to(_Formatter.format(*const_cast<_Tq*>(static_cast<const _Td*>(_Ptr)), _Format_ctx));
+        }
+
+        template <class _Ty>
+        explicit handle(_Ty& _Val) noexcept : _Ptr(_STD addressof(_Val)), _Format(_Handle_format<_Ty>) {}
+
+    public:
+        void format(basic_format_parse_context<_CharType>& _Parse_ctx, _Context& _Format_ctx) const {
+            _Format(_Parse_ctx, _Format_ctx, _Ptr);
+        }
+
+        template <class _Ty>
+        _NODISCARD static handle _Make_from(_Ty& _Val) noexcept {
+            return handle{_Val};
+        }
+    };
+
+#ifdef __CUDACC__ // TRANSITION, DevCom-10863472 (still needed by CUDA 13.2)
+    basic_format_arg() noexcept : _Active_state(_Basic_format_arg_type::_None), _No_state() {}
+#else // ^^^ workaround / no workaround vvv
+    basic_format_arg() noexcept = default;
+#endif // ^^^ no workaround ^^^
+
+    explicit operator bool() const noexcept {
+        return _Active_state != _Basic_format_arg_type::_None;
+    }
+
+    // Function template _Make_from mirrors the exposition-only single-argument constructor template of
+    // basic_format_arg (N4950 [format.arg]).
+    template <_Formattable_with<_Context> _Ty>
+    _NODISCARD static basic_format_arg _Make_from(_Ty& _Val) noexcept {
+        using _Erased_type = _Format_arg_traits<_Context>::template _Storage_type<_Ty>;
+        if constexpr (is_same_v<remove_const_t<_Ty>, char> && is_same_v<_CharType, wchar_t>) {
+            return basic_format_arg(static_cast<_Erased_type>(static_cast<unsigned char>(_Val)));
+        }
+#if !_HAS_CXX23
+        else if constexpr (is_same_v<_Erased_type, basic_string_view<_CharType>>) {
+            return basic_format_arg(_Erased_type{_Val.data(), _Val.size()});
+        }
+#endif // !_HAS_CXX23
+        else {
+            return basic_format_arg(static_cast<_Erased_type>(_Val));
+        }
+    }
+
+    template <class _Visitor>
+    decltype(auto) _Visit(_Visitor&& _Vis) {
+        switch (_Active_state) {
+        case _Basic_format_arg_type::_None:
+            return _STD forward<_Visitor>(_Vis)(_No_state);
+        case _Basic_format_arg_type::_Int_type:
+            return _STD forward<_Visitor>(_Vis)(_Int_state);
+        case _Basic_format_arg_type::_UInt_type:
+            return _STD forward<_Visitor>(_Vis)(_UInt_state);
+        case _Basic_format_arg_type::_Long_long_type:
+            return _STD forward<_Visitor>(_Vis)(_Long_long_state);
+        case _Basic_format_arg_type::_ULong_long_type:
+            return _STD forward<_Visitor>(_Vis)(_ULong_long_state);
+        case _Basic_format_arg_type::_Bool_type:
+            return _STD forward<_Visitor>(_Vis)(_Bool_state);
+        case _Basic_format_arg_type::_Char_type:
+            return _STD forward<_Visitor>(_Vis)(_Char_state);
+        case _Basic_format_arg_type::_Float_type:
+            return _STD forward<_Visitor>(_Vis)(_Float_state);
+        case _Basic_format_arg_type::_Double_type:
+            return _STD forward<_Visitor>(_Vis)(_Double_state);
+        case _Basic_format_arg_type::_Long_double_type:
+            return _STD forward<_Visitor>(_Vis)(_Long_double_state);
+        case _Basic_format_arg_type::_Pointer_type:
+            return _STD forward<_Visitor>(_Vis)(_Pointer_state);
+        case _Basic_format_arg_type::_CString_type:
+            return _STD forward<_Visitor>(_Vis)(_CString_state);
+        case _Basic_format_arg_type::_String_type:
+            return _STD forward<_Visitor>(_Vis)(_String_state);
+        case _Basic_format_arg_type::_Custom_type:
+            return _STD forward<_Visitor>(_Vis)(_Custom_state);
+        default:
+            _STL_REPORT_ERROR("basic_format_arg contains an impossible type");
+            int _Dummy{};
+            return _STD forward<_Visitor>(_Vis)(_Dummy);
+        }
+    }
+
+private:
+    friend basic_format_args<_Context>;
+    friend _Format_handler<_CharType>;
+    friend _Format_arg_traits<_Context>;
+
+    explicit basic_format_arg(const int _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Int_type), _Int_state(_Val) {}
+    explicit basic_format_arg(const unsigned int _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_UInt_type), _UInt_state(_Val) {}
+    explicit basic_format_arg(const long long _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Long_long_type), _Long_long_state(_Val) {}
+    explicit basic_format_arg(const unsigned long long _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_ULong_long_type), _ULong_long_state(_Val) {}
+    explicit basic_format_arg(const bool _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Bool_type), _Bool_state(_Val) {}
+    explicit basic_format_arg(const _CharType _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Char_type), _Char_state(_Val) {}
+    explicit basic_format_arg(const float _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Float_type), _Float_state(_Val) {}
+    explicit basic_format_arg(const double _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Double_type), _Double_state(_Val) {}
+    explicit basic_format_arg(const long double _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Long_double_type), _Long_double_state(_Val) {}
+    explicit basic_format_arg(const void* _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Pointer_type), _Pointer_state(_Val) {}
+    explicit basic_format_arg(const _CharType* _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_CString_type), _CString_state(_Val) {}
+    explicit basic_format_arg(const basic_string_view<_CharType> _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_String_type), _String_state(_Val) {}
+    explicit basic_format_arg(const handle _Val) noexcept
+        : _Active_state(_Basic_format_arg_type::_Custom_type), _Custom_state(_Val) {}
+
+    _Basic_format_arg_type _Active_state = _Basic_format_arg_type::_None;
+    union {
+        monostate _No_state = monostate{};
+        int _Int_state;
+        unsigned int _UInt_state;
+        long long _Long_long_state;
+        unsigned long long _ULong_long_state;
+        bool _Bool_state;
+        _CharType _Char_state;
+        float _Float_state;
+        double _Double_state;
+        long double _Long_double_state;
+        const void* _Pointer_state;
+        const _CharType* _CString_state;
+        basic_string_view<_CharType> _String_state;
+        handle _Custom_state;
+    };
+};
+
+template <class _Ty, class _CharT>
+constexpr bool _Is_basic_string_like_for = false;
+
+template <class _CharT, class _Traits, class _Alloc>
+constexpr bool _Is_basic_string_like_for<basic_string<_CharT, _Traits, _Alloc>, _CharT> = true;
+
+template <class _CharT, class _Traits>
+constexpr bool _Is_basic_string_like_for<basic_string_view<_CharT, _Traits>, _CharT> = true;
+
+template <class _Context>
+template <class _Ty>
+auto _Format_arg_traits<_Context>::_Type_eraser() {
+    using _Td = remove_const_t<_Ty>;
+    // See N4950 [format.arg]/6
+    if constexpr (is_same_v<_Td, bool>) {
+        return bool{};
+    } else if constexpr (is_same_v<_Td, _Char_type>) {
+        return _Char_type{};
+    } else if constexpr (is_same_v<_Td, char> && is_same_v<_Char_type, wchar_t>) {
+        return _Char_type{};
+    } else if constexpr (signed_integral<_Td> && sizeof(_Td) <= sizeof(int)) {
+        return int{};
+    } else if constexpr (unsigned_integral<_Td> && sizeof(_Td) <= sizeof(unsigned int)) {
+        return static_cast<unsigned int>(42);
+    } else if constexpr (signed_integral<_Td> && sizeof(_Td) <= sizeof(long long)) {
+        return static_cast<long long>(42);
+    } else if constexpr (unsigned_integral<_Td> && sizeof(_Td) <= sizeof(unsigned long long)) {
+        return static_cast<unsigned long long>(42);
+    } else if constexpr (is_same_v<_Td, float>) {
+        return float{};
+    } else if constexpr (is_same_v<_Td, double>) {
+        return double{};
+    } else if constexpr (is_same_v<_Td, long double>) {
+        return static_cast<long double>(42);
+    } else if constexpr (_Is_basic_string_like_for<_Td, _Char_type>) {
+        return basic_string_view<_Char_type>{};
+    } else if constexpr (_Is_any_of_v<decay_t<_Td>, _Char_type*, const _Char_type*>) {
+        return static_cast<const _Char_type*>(nullptr);
+    } else if constexpr (is_void_v<remove_pointer_t<_Td>> || is_null_pointer_v<_Td>) {
+        return static_cast<const void*>(nullptr);
+    } else {
+        int _Dummy{};
+        return basic_format_arg<_Context>::handle::_Make_from(_Dummy);
+    }
+}
+
+template <class _Context, class _Ty>
+_NODISCARD consteval _Basic_format_arg_type _Get_format_arg_type() noexcept {
+    using _CharType    = _Context::char_type;
+    using _Erased_type = _Format_arg_traits<_Context>::template _Storage_type<_Ty>;
+
+    if constexpr (is_same_v<_Erased_type, bool>) {
+        return _Basic_format_arg_type::_Bool_type;
+    } else if constexpr (is_same_v<_Erased_type, _CharType>) {
+        return _Basic_format_arg_type::_Char_type;
+    } else if constexpr (is_same_v<_Erased_type, int>) {
+        return _Basic_format_arg_type::_Int_type;
+    } else if constexpr (is_same_v<_Erased_type, unsigned int>) {
+        return _Basic_format_arg_type::_UInt_type;
+    } else if constexpr (is_same_v<_Erased_type, long long>) {
+        return _Basic_format_arg_type::_Long_long_type;
+    } else if constexpr (is_same_v<_Erased_type, unsigned long long>) {
+        return _Basic_format_arg_type::_ULong_long_type;
+    } else if constexpr (is_same_v<_Erased_type, float>) {
+        return _Basic_format_arg_type::_Float_type;
+    } else if constexpr (is_same_v<_Erased_type, double>) {
+        return _Basic_format_arg_type::_Double_type;
+    } else if constexpr (is_same_v<_Erased_type, long double>) {
+        return _Basic_format_arg_type::_Long_double_type;
+    } else if constexpr (is_same_v<_Erased_type, const void*>) {
+        return _Basic_format_arg_type::_Pointer_type;
+    } else if constexpr (is_same_v<_Erased_type, const _CharType*>) {
+        return _Basic_format_arg_type::_CString_type;
+    } else if constexpr (is_same_v<_Erased_type, basic_string_view<_CharType>>) {
+        return _Basic_format_arg_type::_String_type;
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Erased_type, typename basic_format_arg<_Context>::handle>);
+        return _Basic_format_arg_type::_Custom_type;
+    }
+}
+
+_EXPORT_STD template <class _Visitor, class _Context>
+decltype(auto) visit_format_arg(_Visitor&& _Vis, basic_format_arg<_Context> _Arg) {
+    return _Arg._Visit(_STD forward<_Visitor>(_Vis));
+}
+
+struct _Format_arg_index {
+    // TRANSITION, Should be templated on number of arguments for even less storage
+
+    constexpr _Format_arg_index() = default;
+    constexpr explicit _Format_arg_index(const size_t _Index_) noexcept : _Index(_Index_) {
+        _Type(_Basic_format_arg_type::_None);
+    }
+
+    _NODISCARD constexpr _Basic_format_arg_type _Type() const noexcept {
+        return static_cast<_Basic_format_arg_type>(_Type_);
+    }
+
+    constexpr void _Type(_Basic_format_arg_type _Val) noexcept {
+        _Type_ = static_cast<size_t>(_Val);
+    }
+
+    size_t _Index : (sizeof(size_t) * 8 - 4){};
+    size_t _Type_ : 4 {};
+};
+
+template <class _Context, class... _Args>
+class _Format_arg_store {
+private:
+    using _CharType = _Context::char_type;
+    using _Traits   = _Format_arg_traits<_Context>;
+
+    friend basic_format_args<_Context>;
+
+    static constexpr size_t _Num_args       = sizeof...(_Args);
+    static constexpr size_t _Storage_length = (_Traits::template _Storage_size<_Args> + ...);
+
+    // The actual storage representation: _Num_args offsets into _Storage, followed immediately by the untyped
+    // _Storage which holds copies of the object representations of arguments (with no regard for alignment).
+    // These must be allocated consecutively, since basic_format_args thinks it can store a pointer to
+    // _Index_array and use arithmetic to access the bytes of _Storage.
+    _Format_arg_index _Index_array[_Num_args];
+    unsigned char _Storage[_Storage_length];
+
+#pragma warning(push)
+#pragma warning(disable : 6386) // Buffer overrun while writing to '%s' ...
+    template <class _Ty>
+    void _Store_impl(
+        const size_t _Arg_index, const _Basic_format_arg_type _Arg_type, const type_identity_t<_Ty>& _Val) noexcept {
+        _STL_INTERNAL_CHECK(_Arg_index < _Num_args);
+
+        const auto _Store_index = _Index_array[_Arg_index]._Index;
+
+        _CSTD memcpy(_Storage + _Store_index, _STD addressof(_Val), sizeof(_Ty));
+        _Index_array[_Arg_index]._Type(_Arg_type);
+        if (_Arg_index + 1 < _Num_args) {
+            // Set the starting index of the next arg, as that is dynamic, must be called with increasing index
+            _Index_array[_Arg_index + 1] = _Format_arg_index{_Store_index + sizeof(_Ty)};
+        }
+    }
+#pragma warning(pop)
+
+    template <class _Ty>
+    void _Store(const size_t _Arg_index, _Ty&& _Val) noexcept {
+        constexpr _Basic_format_arg_type _Arg_type = _STD _Get_format_arg_type<_Context, _Ty>();
+        using _Erased_type                         = _Traits::template _Storage_type<_Ty>;
+
+        if constexpr (is_same_v<remove_const_t<remove_reference_t<_Ty>>, char> && is_same_v<_CharType, wchar_t>) {
+            _Store_impl<_Erased_type>(
+                _Arg_index, _Arg_type, static_cast<_Erased_type>(static_cast<unsigned char>(_Val)));
+        } else if constexpr (is_same_v<_Erased_type, typename basic_format_arg<_Context>::handle>) {
+            _Store_impl<_Erased_type>(_Arg_index, _Arg_type, _Erased_type::_Make_from(_Val));
+        }
+#if !_HAS_CXX23
+        // Workaround towards N4950 [format.arg]/6.8 in C++20
+        else if constexpr (is_same_v<_Erased_type, basic_string_view<_CharType>>) {
+            _Store_impl<_Erased_type>(_Arg_index, _Arg_type, _Erased_type{_Val.data(), _Val.size()});
+        }
+#endif // !_HAS_CXX23
+        else {
+            _Store_impl<_Erased_type>(_Arg_index, _Arg_type, static_cast<_Erased_type>(_Val));
+        }
+    }
+
+public:
+    _Format_arg_store(_Args&... _Vals) noexcept {
+        _Index_array[0]   = {};
+        size_t _Arg_index = 0;
+        (_Store(_Arg_index++, _Vals), ...);
+    }
+};
+
+template <class _Context>
+class _Format_arg_store<_Context> {};
+
+_EXPORT_STD template <class _Context>
+class basic_format_args {
+public:
+    basic_format_args(const _Format_arg_store<_Context>&) noexcept {}
+
+    template <class... _Args>
+    basic_format_args(const _Format_arg_store<_Context, _Args...>& _Store) noexcept
+        : _Num_args(sizeof...(_Args)), _Index_array(_Store._Index_array) {}
+
+    _NODISCARD basic_format_arg<_Context> get(const size_t _Index) const noexcept {
+        if (_Index >= _Num_args) {
+            return basic_format_arg<_Context>{};
+        }
+
+        using _CharType = _Context::char_type;
+        // The explanatory comment in _Format_arg_store explains how the following works.
+        const auto _Packed_index = _Index_array[_Index];
+        const auto _Arg_storage =
+            reinterpret_cast<const unsigned char*>(_Index_array + _Num_args) + _Packed_index._Index;
+
+        switch (_Packed_index._Type()) {
+        case _Basic_format_arg_type::_None:
+        default:
+            _STL_ASSERT(false, "Invalid basic_format_arg type");
+            return basic_format_arg<_Context>{};
+        case _Basic_format_arg_type::_Int_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<int>(_Arg_storage)};
+        case _Basic_format_arg_type::_UInt_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<unsigned int>(_Arg_storage)};
+        case _Basic_format_arg_type::_Long_long_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<long long>(_Arg_storage)};
+        case _Basic_format_arg_type::_ULong_long_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<unsigned long long>(_Arg_storage)};
+        case _Basic_format_arg_type::_Bool_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<bool>(_Arg_storage)};
+        case _Basic_format_arg_type::_Char_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<_CharType>(_Arg_storage)};
+        case _Basic_format_arg_type::_Float_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<float>(_Arg_storage)};
+        case _Basic_format_arg_type::_Double_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<double>(_Arg_storage)};
+        case _Basic_format_arg_type::_Long_double_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<long double>(_Arg_storage)};
+        case _Basic_format_arg_type::_Pointer_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<const void*>(_Arg_storage)};
+        case _Basic_format_arg_type::_CString_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<const _CharType*>(_Arg_storage)};
+        case _Basic_format_arg_type::_String_type:
+            return basic_format_arg<_Context>{_Get_value_from_memory<basic_string_view<_CharType>>(_Arg_storage)};
+        case _Basic_format_arg_type::_Custom_type:
+            return basic_format_arg<_Context>{
+                _Get_value_from_memory<typename basic_format_arg<_Context>::handle>(_Arg_storage)};
+        }
+    }
+
+    _NODISCARD size_t _Estimate_required_capacity() const noexcept {
+        using _CharType = _Context::char_type;
+        size_t _Result  = 0;
+
+        for (size_t _Idx = 0; _Idx < _Num_args; ++_Idx) {
+            const auto _Packed_index = _Index_array[_Idx];
+            const auto _Arg_type     = _Packed_index._Type();
+            if (_Arg_type == _Basic_format_arg_type::_String_type) {
+                const auto _Arg_storage =
+                    reinterpret_cast<const unsigned char*>(_Index_array + _Num_args) + _Packed_index._Index;
+                const auto _View = _Get_value_from_memory<basic_string_view<_CharType>>(_Arg_storage);
+                _Result += _View.size();
+            } else if (_Arg_type == _Basic_format_arg_type::_CString_type) {
+                _Result += 32; // estimate for length of null-terminated strings
+            } else {
+                _Result += 8; // estimate for length of all other arguments
+            }
+        }
+        return _Result;
+    }
+
+private:
+    template <class _Ty>
+    _NODISCARD static auto _Get_value_from_memory(const unsigned char* const _Val) noexcept {
+        auto& _Temp = *reinterpret_cast<const unsigned char (*)[sizeof(_Ty)]>(_Val);
+        return _STD bit_cast<_Ty>(_Temp);
+    }
+
+    size_t _Num_args                      = 0;
+    const _Format_arg_index* _Index_array = nullptr;
+};
+
+template <class _Context, class... _Args>
+basic_format_args(_Format_arg_store<_Context, _Args...>) -> basic_format_args<_Context>;
+
+// _Lazy_locale is used instead of a std::locale so that the locale is only
+// constructed when needed, and is never constructed if the format string does not
+// contain locale-sensitive format specifiers. Note that this means that a new locale
+// will be constructed for _every_ locale-sensitive format specifier in the format string,
+// making that case slower than if we had stored a "real" locale in the basic_format_context.
+class _Lazy_locale {
+private:
+    const locale* _Loc = nullptr;
+
+public:
+    _Lazy_locale() = default;
+
+    explicit _Lazy_locale(const locale& _Loc_) : _Loc(&_Loc_) {}
+
+    explicit _Lazy_locale(const locale&&) = delete;
+
+    _NODISCARD locale _Get() const {
+        if (_Loc) {
+            return *_Loc;
+        } else {
+            return locale{};
+        }
+    }
+};
+
+_EXPORT_STD template <class _Out, class _CharT>
+    requires output_iterator<_Out, const _CharT&>
+class _NO_SPECIALIZATIONS_CITING("N5014 [format.context]/2") basic_format_context {
+private:
+    _Out _OutputIt;
+    basic_format_args<basic_format_context> _Args;
+    _Lazy_locale _Loc;
+
+    constexpr basic_format_context(
+        _Out&& _OutputIt_, const basic_format_args<basic_format_context>& _Ctx_args, const _Lazy_locale& _Loc_)
+        : _OutputIt(_STD move(_OutputIt_)), _Args(_Ctx_args), _Loc(_Loc_) {}
+
+    basic_format_context(const basic_format_context&)            = delete;
+    basic_format_context& operator=(const basic_format_context&) = delete;
+
+public:
+    using iterator  = _Out;
+    using char_type = _CharT;
+
+    template <class _Ty>
+    using formatter_type = formatter<_Ty, _CharT>;
+
+    _NODISCARD basic_format_arg<basic_format_context> arg(size_t _Id) const noexcept {
+        return _Args.get(_Id);
+    }
+    _NODISCARD locale locale() {
+        return _Loc._Get();
+    }
+    _NODISCARD iterator out() {
+        return _STD move(_OutputIt);
+    }
+    void advance_to(iterator _It) {
+        _OutputIt = _STD move(_It);
+    }
+
+    _NODISCARD const basic_format_args<basic_format_context>& _Get_args() const noexcept {
+        return _Args;
+    }
+    _NODISCARD _Lazy_locale _Get_lazy_locale() const {
+        return _Loc;
+    }
+
+    _NODISCARD static constexpr basic_format_context _Make_from(
+        _Out _OutputIt_, basic_format_args<basic_format_context> _Ctx_args, const _Lazy_locale& _Loc_) {
+        return basic_format_context{_STD move(_OutputIt_), _Ctx_args, _Loc_};
+    }
+};
+
+template <class _Ty>
+class _Fmt_buffer {
+private:
+    _Ty* _Ptr_        = nullptr;
+    size_t _Size_     = 0;
+    size_t _Capacity_ = 0;
+
+protected:
+    explicit _Fmt_buffer(const size_t _Size) noexcept : _Size_(_Size), _Capacity_(_Size) {}
+
+    ~_Fmt_buffer() = default;
+
+    _Fmt_buffer(_Ty* _Data, const size_t _Size, const size_t _Capacity) noexcept
+        : _Ptr_(_Data), _Size_(_Size), _Capacity_(_Capacity) {}
+
+    void _Set(_Ty* _Buf_data, const size_t _Buf_capacity) noexcept {
+        _Ptr_      = _Buf_data;
+        _Capacity_ = _Buf_capacity;
+    }
+
+    virtual void _Grow(size_t _Capacity) = 0;
+
+public:
+    using value_type = _Ty;
+
+    _Fmt_buffer(const _Fmt_buffer&)    = delete;
+    void operator=(const _Fmt_buffer&) = delete;
+
+    _NODISCARD _Ty* begin() noexcept {
+        return _Ptr_;
+    }
+
+    _NODISCARD _Ty* end() noexcept {
+        return _Ptr_ + _Size_;
+    }
+
+    _NODISCARD size_t _Size() const noexcept {
+        return _Size_;
+    }
+
+    _NODISCARD size_t _Capacity() const noexcept {
+        return _Capacity_;
+    }
+
+    void _Clear() noexcept {
+        _Size_ = 0;
+    }
+
+    void _Try_reserve(const size_t _New_capacity) {
+        if (_New_capacity > _Capacity_) {
+            _Grow(_New_capacity);
+        }
+    }
+
+    void push_back(const _Ty _Value) {
+        _Try_reserve(_Size_ + 1);
+        _Ptr_[_Size_++] = _Value;
+    }
+};
+
+struct _Fmt_buffer_traits {
+    explicit _Fmt_buffer_traits(ptrdiff_t) {}
+
+    _NODISCARD size_t _Count() const noexcept {
+        return 0;
+    }
+
+    _NODISCARD size_t _Limit(const size_t _Size) noexcept {
+        return _Size;
+    }
+};
+
+inline constexpr size_t _Fmt_buffer_size = 256;
+
+template <class _OutputIt>
+struct _Fmt_iterator_flush {
+    template <class _Ty>
+    static _OutputIt _Flush(const _Ty* const _First, const _Ty* const _Last, _OutputIt _Output) {
+        return _STD copy(_First, _Last, _STD move(_Output));
+    }
+};
+
+template <class _Container>
+struct _Back_insert_iterator_container_access : back_insert_iterator<_Container> {
+    explicit _Back_insert_iterator_container_access(back_insert_iterator<_Container> _Iter)
+        : back_insert_iterator<_Container>(_Iter) {}
+
+    using back_insert_iterator<_Container>::container;
+};
+
+template <class _Container>
+    requires (_Is_specialization_v<_Container, basic_string> || _Is_specialization_v<_Container, vector>)
+struct _Fmt_iterator_flush<back_insert_iterator<_Container>> {
+    using _OutputIt = back_insert_iterator<_Container>;
+
+    template <class _Ty>
+    static _OutputIt _Flush(const _Ty* const _First, const _Ty* const _Last, _OutputIt _Output) {
+        _Container& _Cont = *_Back_insert_iterator_container_access<_Container>{_Output}.container;
+        _Cont.insert(_Cont.end(), _First, _Last);
+        return _Output;
+    }
+};
+
+template <class _OutputIt, class _Ty, class _Traits = _Fmt_buffer_traits>
+class _Fmt_iterator_buffer final : public _Traits, public _Fmt_buffer<_Ty> {
+private:
+    _OutputIt _Output;
+    _Ty _Data[_Fmt_buffer_size];
+
+    void _Grow(size_t) final {
+        if (this->_Size() == _Fmt_buffer_size) {
+            _Flush();
+        }
+    }
+
+    void _Flush() {
+        auto _Size = this->_Size();
+        this->_Clear();
+        const auto _End = _Data + this->_Limit(_Size);
+
+        _Output = _Fmt_iterator_flush<_OutputIt>::_Flush(_Data, _End, _STD move(_Output));
+    }
+
+public:
+    explicit _Fmt_iterator_buffer(_OutputIt _Out, ptrdiff_t _Size = _Fmt_buffer_size)
+        : _Traits(_Size), _Fmt_buffer<_Ty>(_Data, 0, _Fmt_buffer_size), _Output(_STD move(_Out)) {}
+
+    ~_Fmt_iterator_buffer() {
+        if (this->_Size() != 0) {
+            _Flush();
+        }
+    }
+
+    _NODISCARD _OutputIt _Out() {
+        _Flush();
+        return _STD move(_Output);
+    }
+
+    _NODISCARD ptrdiff_t _Count() const noexcept {
+        return static_cast<ptrdiff_t>(_Traits::_Count() + this->_Size());
+    }
+};
+
+template <class _Ty>
+class _Fmt_iterator_buffer<_Ty*, _Ty> final : public _Fmt_buffer<_Ty> {
+private:
+    void _Grow(size_t) final {}
+
+public:
+    explicit _Fmt_iterator_buffer(_Ty* _Out, ptrdiff_t = 0) : _Fmt_buffer<_Ty>(_Out, 0, ~size_t{}) {}
+
+    _NODISCARD _Ty* _Out() noexcept {
+        return this->end();
+    }
+};
+
+#if _HAS_CXX23
+template <class _CharT>
+struct _Phony_fmt_iter_for {
+    using difference_type = ptrdiff_t;
+
+    // These member functions are never defined:
+    _CharT& operator*() const;
+    _Phony_fmt_iter_for& operator++();
+    _Phony_fmt_iter_for operator++(int);
+};
+
+_EXPORT_STD template <class _Ty, class _CharT>
+concept formattable =
+    _Formattable_with<remove_reference_t<_Ty>, basic_format_context<_Phony_fmt_iter_for<_CharT>, _CharT>>;
+
+template <class _CharT>
+struct _Range_specs : _Fill_align_and_width_specs<_CharT> {
+    bool _No_brackets = false;
+    char _Type        = '\0';
+};
+
+_EXPORT_STD template <class _Ty, class _CharT = char>
+    requires same_as<remove_cvref_t<_Ty>, _Ty> && formattable<_Ty, _CharT>
+class range_formatter {
+private:
+    formatter<_Ty, _CharT> _Underlying;
+    basic_string_view<_CharT> _Separator       = _STATICALLY_WIDEN(_CharT, ", ");
+    basic_string_view<_CharT> _Opening_bracket = _STATICALLY_WIDEN(_CharT, "[");
+    basic_string_view<_CharT> _Closing_bracket = _STATICALLY_WIDEN(_CharT, "]");
+    _Range_specs<_CharT> _Specs;
+
+public:
+    constexpr void set_separator(basic_string_view<_CharT> _Sep) noexcept {
+        _Separator = _Sep;
+    }
+
+    constexpr void set_brackets(basic_string_view<_CharT> _Opening, basic_string_view<_CharT> _Closing) noexcept {
+        _Opening_bracket = _Opening;
+        _Closing_bracket = _Closing;
+    }
+
+    _NODISCARD constexpr formatter<_Ty, _CharT>& underlying() noexcept {
+        return _Underlying;
+    }
+
+    _NODISCARD constexpr const formatter<_Ty, _CharT>& underlying() const noexcept {
+        return _Underlying;
+    }
+
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx); // defined in <format>
+
+    template <_RANGES input_range _Range, class _FormatContext>
+        requires formattable<_RANGES range_reference_t<_Range>, _CharT>
+              && same_as<remove_cvref_t<_RANGES range_reference_t<_Range>>, _Ty>
+    _FormatContext::iterator format(_Range&& _Rng, _FormatContext& _Ctx) const {
+        return _Format(_STD forward<_Range>(_Rng), _Ctx);
+    }
+
+private:
+    template <_RANGES input_range _Range, class _FormatContext>
+    _FormatContext::iterator _Format(_Range&&, _FormatContext&) const {
+        _Throw_format_error("Unsupported 'basic_format_context'.");
+    }
+
+    template <_RANGES input_range _Range, class _FormatContext>
+        requires _Is_specialization_v<typename _FormatContext::iterator, back_insert_iterator>
+              && derived_from<typename _FormatContext::iterator::container_type, _Fmt_buffer<_CharT>>
+    _FormatContext::iterator _Format(_Range&& _Rng, _FormatContext& _Ctx) const; // defined in <format>
+};
+
+template <class _Rng, class _CharT>
+concept _Const_formattable_range =
+    _RANGES input_range<const _Rng> && formattable<_RANGES range_reference_t<const _Rng>, _CharT>;
+
+template <class _Rng, class _CharT>
+using _Fmt_maybe_const = conditional_t<_Const_formattable_range<_Rng, _CharT>, const _Rng, _Rng>;
+
+template <range_format _Kind, _RANGES input_range _Rng, class _CharT>
+struct _Range_default_formatter;
+
+template <_RANGES input_range _Rng, class _CharT>
+struct _Range_default_formatter<range_format::sequence, _Rng, _CharT> {
+private:
+    using _Range_type = _Fmt_maybe_const<_Rng, _CharT>;
+
+    range_formatter<remove_cvref_t<_RANGES range_reference_t<_Range_type>>, _CharT> _Underlying;
+
+public:
+    constexpr void set_separator(const basic_string_view<_CharT> _Sep) noexcept {
+        _Underlying.set_separator(_Sep);
+    }
+
+    constexpr void set_brackets(
+        const basic_string_view<_CharT> _Opening, const basic_string_view<_CharT> _Closing) noexcept {
+        _Underlying.set_brackets(_Opening, _Closing);
+    }
+
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx) {
+        return _Underlying.parse(_Ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(_Range_type& _Elems, _FormatContext& _Ctx) const {
+        return _Underlying.format(_Elems, _Ctx);
+    }
+};
+
+template <_RANGES input_range _Rng, class _CharT>
+struct _Range_default_formatter<range_format::map, _Rng, _CharT> {
+private:
+    using _Map_type     = _Fmt_maybe_const<_Rng, _CharT>;
+    using _Element_type = remove_cvref_t<_RANGES range_reference_t<_Map_type>>;
+
+    range_formatter<_Element_type, _CharT> _Underlying;
+
+public:
+    constexpr _Range_default_formatter()
+        noexcept(is_nothrow_default_constructible_v<range_formatter<_Element_type, _CharT>>) /* strengthened */ {
+        static_assert(_Is_two_tuple<_Element_type>, "the element type of the formatted range must be either pair<T, U> "
+                                                    "or tuple<T, U> (N4981 [format.range.fmtmap]/1)");
+
+        _Underlying.set_brackets(_STATICALLY_WIDEN(_CharT, "{"), _STATICALLY_WIDEN(_CharT, "}"));
+        _Underlying.underlying().set_brackets({}, {});
+        _Underlying.underlying().set_separator(_STATICALLY_WIDEN(_CharT, ": "));
+    }
+
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx) {
+        return _Underlying.parse(_Ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(_Map_type& _Rx, _FormatContext& _Ctx) const {
+        return _Underlying.format(_Rx, _Ctx);
+    }
+};
+
+template <_RANGES input_range _Rng, class _CharT>
+struct _Range_default_formatter<range_format::set, _Rng, _CharT> {
+private:
+    using _Set_type = _Fmt_maybe_const<_Rng, _CharT>;
+    range_formatter<remove_cvref_t<_RANGES range_reference_t<_Set_type>>, _CharT> _Underlying;
+
+public:
+    constexpr _Range_default_formatter() noexcept(is_nothrow_default_constructible_v<
+        range_formatter<remove_cvref_t<_RANGES range_reference_t<_Set_type>>, _CharT>>) /* strengthened */ {
+        _Underlying.set_brackets(_STATICALLY_WIDEN(_CharT, "{"), _STATICALLY_WIDEN(_CharT, "}"));
+    }
+
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx) {
+        return _Underlying.parse(_Ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(_Set_type& _Rx, _FormatContext& _Ctx) const {
+        return _Underlying.format(_Rx, _Ctx);
+    }
+};
+
+template <range_format _Kind, _RANGES input_range _Rng, class _CharT>
+    requires (_Kind == range_format::string || _Kind == range_format::debug_string)
+struct _Range_default_formatter<_Kind, _Rng, _CharT> {
+private:
+    static_assert(is_same_v<remove_cvref_t<_RANGES range_reference_t<_Rng>>, _CharT>,
+        "the element type of the formatted range must be the character type used in formatting "
+        "(N4981 [format.range.fmtstr]/1)");
+
+    using _Range_type = _Maybe_const<_RANGES input_range<const _Rng>, _Rng>;
+
+    formatter<basic_string_view<_CharT>, _CharT> _Underlying; // avoid copying the string if possible
+
+public:
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx) {
+        auto _Iter = _Underlying.parse(_Ctx);
+        if constexpr (_Kind == range_format::debug_string) {
+            _Underlying.set_debug_format();
+        }
+        return _Iter;
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(_Range_type& _Rx, _FormatContext& _Ctx) const {
+        if constexpr (_RANGES contiguous_range<_Range_type>) {
+            const auto _Dist = _RANGES distance(_Rx);
+            const auto _Size = _STD _To_unsigned_like(_Dist);
+
+            if (!_STD in_range<size_t>(_Size)) {
+                _Throw_format_error("Formatted range is too long.");
+            }
+
+            const auto _First = _RANGES begin(_Rx);
+            const basic_string_view<_CharT> _Str(_STD to_address(_First), _STD to_address(_First + _Dist));
+            return _Underlying.format(_Str, _Ctx);
+        } else {
+            return _Underlying.format(basic_string<_CharT>{from_range, _Rx}, _Ctx);
+        }
+    }
+};
+
+// the deleted default constructor makes it "disabled" as per N4981 [format.formatter.spec]/5
+
+template <_RANGES input_range _Rng, _Format_supported_charT _CharT>
+    requires _Formatting_enabled_range<_Rng>
+struct formatter<_Rng, _CharT> {
+    formatter()                            = delete;
+    formatter(const formatter&)            = delete;
+    formatter& operator=(const formatter&) = delete;
+};
+
+template <_RANGES input_range _Rng, _Format_supported_charT _CharT>
+    requires _Formatting_enabled_range<_Rng> && formattable<_RANGES range_reference_t<_Rng>, _CharT>
+struct formatter<_Rng, _CharT> : _Range_default_formatter<format_kind<_Rng>, _Rng, _CharT> {};
+
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+template <class _AdaptorType, _Format_supported_charT _CharT, template <class> class _RefView>
+struct _Adaptor_formatter_base {
+private:
+    using _Container             = _AdaptorType::container_type;
+    using _Maybe_const_container = _Fmt_maybe_const<_Container, _CharT>;
+    using _Maybe_const_adaptor   = _Maybe_const<is_const_v<_Maybe_const_container>, _AdaptorType>;
+
+    formatter<_RefView<_Maybe_const_container>, _CharT> _Underlying;
+
+public:
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx) {
+        return _Underlying.parse(_Ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(_Maybe_const_adaptor& _Adaptor, _FormatContext& _Ctx) const {
+        struct _Container_exposer : _AdaptorType {
+            using _AdaptorType::c;
+
+            _Container_exposer(const _Container_exposer&)            = delete;
+            _Container_exposer& operator=(const _Container_exposer&) = delete;
+            ~_Container_exposer()                                    = delete;
+        };
+
+        constexpr auto _Mem_cont_ptr = &_Container_exposer::c;
+        return _Underlying.format(_Adaptor.*_Mem_cont_ptr, _Ctx);
+    }
+};
+
+template <class _CharT, formattable<_CharT>... _Types>
+class _Tuple_formatter_common_base {
+private:
+    tuple<formatter<remove_cvref_t<_Types>, _CharT>...> _Underlying;
+    basic_string_view<_CharT> _Separator       = _STATICALLY_WIDEN(_CharT, ", ");
+    basic_string_view<_CharT> _Opening_bracket = _STATICALLY_WIDEN(_CharT, "(");
+    basic_string_view<_CharT> _Closing_bracket = _STATICALLY_WIDEN(_CharT, ")");
+
+    _Fill_align_and_width_specs<_CharT> _Specs;
+
+protected:
+    static constexpr bool _Is_const_formattable = (formattable<const _Types, _CharT> && ...);
+
+    template <class _FormatContext, class... _ArgTypes>
+    _FormatContext::iterator _Format(_FormatContext& _Fmt_ctx, _ArgTypes&... _Args) const; // defined in <format>
+
+public:
+    constexpr void set_separator(const basic_string_view<_CharT> _Sep) noexcept {
+        _Separator = _Sep;
+    }
+
+    constexpr void set_brackets(
+        const basic_string_view<_CharT> _Opening, const basic_string_view<_CharT> _Closing) noexcept {
+        _Opening_bracket = _Opening;
+        _Closing_bracket = _Closing;
+    }
+
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx); // defined in <format>
+};
+
+// formatter definition for all pairs and tuples, the deleted default constructor
+// makes it "disabled" as per N4971 [format.formatter.spec]/5
+
+template <class _TupleOrPair, class _CharT>
+struct _Tuple_formatter_base {
+    _Tuple_formatter_base()                                        = delete;
+    _Tuple_formatter_base(const _Tuple_formatter_base&)            = delete;
+    _Tuple_formatter_base& operator=(const _Tuple_formatter_base&) = delete;
+};
+
+template <class _CharT, formattable<_CharT> _Ty1, formattable<_CharT> _Ty2>
+struct _Tuple_formatter_base<pair<_Ty1, _Ty2>, _CharT> : _Tuple_formatter_common_base<_CharT, _Ty1, _Ty2> {
+private:
+    using _Base           = _Tuple_formatter_common_base<_CharT, _Ty1, _Ty2>;
+    using _Formatted_type = _Maybe_const<_Base::_Is_const_formattable, pair<_Ty1, _Ty2>>;
+
+public:
+    template <class _FormatContext>
+    _FormatContext::iterator format(_Formatted_type& _Elems, _FormatContext& _Ctx) const {
+        return this->_Format(_Ctx, _Elems.first, _Elems.second);
+    }
+};
+
+template <class _CharT, formattable<_CharT>... _Types>
+struct _Tuple_formatter_base<tuple<_Types...>, _CharT> : _Tuple_formatter_common_base<_CharT, _Types...> {
+private:
+    using _Base           = _Tuple_formatter_common_base<_CharT, _Types...>;
+    using _Formatted_type = _Maybe_const<_Base::_Is_const_formattable, tuple<_Types...>>;
+
+public:
+    template <class _FormatContext>
+    _FormatContext::iterator format(_Formatted_type& _Elems, _FormatContext& _Ctx) const {
+        return _STD apply([this, &_Ctx](auto&... _Args) { return this->_Format(_Ctx, _Args...); }, _Elems);
+    }
+};
+
+// specializations for tuple-like types that are input ranges and not formattable as tuples
+
+template <_Format_supported_charT _CharT, class _Ty1, class _Ty2>
+    requires (!formattable<_Ty1, _CharT> || !formattable<_Ty2, _CharT>)
+          // TRANSITION, clang-format, () should be redundant
+          && (_RANGES input_range<pair<_Ty1, _Ty2>>) && _Formatting_enabled_range<pair<_Ty1, _Ty2>>
+          && formattable<_RANGES range_reference_t<pair<_Ty1, _Ty2>>, _CharT>
+struct _Tuple_formatter_base<pair<_Ty1, _Ty2>, _CharT>
+    : _Range_default_formatter<format_kind<pair<_Ty1, _Ty2>>, pair<_Ty1, _Ty2>, _CharT> {};
+
+template <_Format_supported_charT _CharT, class... _Types>
+    requires ((!formattable<_Types, _CharT>) || ...)
+          // TRANSITION, clang-format, () should be redundant
+          && (_RANGES input_range<tuple<_Types...>>) && _Formatting_enabled_range<tuple<_Types...>>
+          && formattable<_RANGES range_reference_t<tuple<_Types...>>, _CharT>
+struct _Tuple_formatter_base<tuple<_Types...>, _CharT>
+    : _Range_default_formatter<format_kind<tuple<_Types...>>, tuple<_Types...>, _CharT> {};
+
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+
+template <_Format_supported_charT _CharT, class _Ty1, class _Ty2>
+struct formatter<pair<_Ty1, _Ty2>, _CharT> : _Tuple_formatter_base<pair<_Ty1, _Ty2>, _CharT> {};
+
+template <_Format_supported_charT _CharT, class... _Types>
+struct formatter<tuple<_Types...>, _CharT> : _Tuple_formatter_base<tuple<_Types...>, _CharT> {};
+#endif // _HAS_CXX23
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_RANGES_TUPLE_FORMATTER_HPP
diff --git a/msvc-stl/stl/inc/__msvc_sanitizer_annotate_container.hpp b/msvc-stl/stl/inc/__msvc_sanitizer_annotate_container.hpp
new file mode 100644
index 0000000..dbfd83b
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_sanitizer_annotate_container.hpp
@@ -0,0 +1,230 @@
+// __msvc_sanitizer_annotate_container.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_SANITIZER_ANNOTATE_CONTAINER_HPP
+#define __MSVC_SANITIZER_ANNOTATE_CONTAINER_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// The following macros change the behavior of this file:
+//   - _DISABLE_STL_ANNOTATION: Disable ASan annotations in the standard library
+//     (this will be auto-defined on unsupported platforms)
+//     + _DISABLE_STRING_ANNOTATION: same, but for only `basic_string`
+//     + _DISABLE_VECTOR_ANNOTATION: same, but for only `vector`
+//     + _DISABLE_OPTIONAL_ANNOTATION: same, but for only `optional`
+//   - _ENABLE_STL_ANNOTATION_ON_UNSUPPORTED_PLATFORMS: Don't auto-disable ASan annotations
+//   - _ANNOTATE_STL: Even when ASan annotations are disabled, insert the code for annotating into the STL anyways;
+//     this is useful when building static libraries which may be linked against both ASan and non-ASan binaries.
+//     + _ANNOTATE_STRING: same, but only for `basic_string`
+//     + _ANNOTATE_VECTOR: same, but only for `vector`
+//     + _ANNOTATE_OPTIONAL: same, but only for `optional`
+
+#if !defined(_DISABLE_STL_ANNOTATION) && !defined(_ENABLE_STL_ANNOTATION_ON_UNSUPPORTED_PLATFORMS)
+
+#if defined(_M_ARM64EC) || defined(_M_CEE_PURE)
+#define _DISABLE_STL_ANNOTATION
+#endif // ^^^ unsupported platform ^^^
+
+#endif // ^^^ !defined(_DISABLE_STL_ANNOTATION) && !defined(_ENABLE_STL_ANNOTATION_ON_UNSUPPORTED_PLATFORMS) ^^^
+
+#ifdef _DISABLE_STL_ANNOTATION
+
+#ifdef _ENABLE_STL_ANNOTATION_ON_UNSUPPORTED_PLATFORMS
+#error _ENABLE_STL_ANNOTATION_ON_UNSUPPORTED_PLATFORMS and _DISABLE_STL_ANNOTATION are mutually exclusive
+#endif // ^^^ defined(_ENABLE_STL_ANNOTATION_ON_UNSUPPORTED_PLATFORMS) ^^^
+
+#ifndef _DISABLE_STRING_ANNOTATION
+#define _DISABLE_STRING_ANNOTATION
+#endif // ^^^ !defined(_DISABLE_STRING_ANNOTATION) ^^^
+#ifndef _DISABLE_VECTOR_ANNOTATION
+#define _DISABLE_VECTOR_ANNOTATION
+#endif // ^^^ !defined(_DISABLE_VECTOR_ANNOTATION) ^^^
+#ifndef _DISABLE_OPTIONAL_ANNOTATION
+#define _DISABLE_OPTIONAL_ANNOTATION
+#endif // ^^^ !defined(_DISABLE_OPTIONAL_ANNOTATION) ^^^
+
+#endif // ^^^ defined(_DISABLE_STL_ANNOTATION) ^^^
+
+#ifdef _ANNOTATE_STL
+
+#ifndef _ANNOTATE_STRING
+#define _ANNOTATE_STRING
+#endif // ^^^ !defined(_ANNOTATE_STRING) ^^^
+
+#ifndef _ANNOTATE_VECTOR
+#define _ANNOTATE_VECTOR
+#endif // ^^^ !defined(_ANNOTATE_VECTOR) ^^^
+
+#ifndef _ANNOTATE_OPTIONAL
+#define _ANNOTATE_OPTIONAL
+#endif // ^^^ !defined(_ANNOTATE_OPTIONAL) ^^^
+
+#endif // ^^^ defined(_ANNOTATE_STL) ^^^
+
+#ifdef __SANITIZE_ADDRESS__
+
+#define _ACTIVATE_STRING_ANNOTATION
+#define _INSERT_STRING_ANNOTATION
+#define _ACTIVATE_VECTOR_ANNOTATION
+#define _INSERT_VECTOR_ANNOTATION
+#define _ACTIVATE_OPTIONAL_ANNOTATION
+#define _INSERT_OPTIONAL_ANNOTATION
+
+#elif defined(__clang__) // ^^^ defined(__SANITIZE_ADDRESS__) / defined(__clang__) vvv
+
+#if __has_feature(address_sanitizer)
+#define _ACTIVATE_STRING_ANNOTATION
+#define _INSERT_STRING_ANNOTATION
+#define _ACTIVATE_VECTOR_ANNOTATION
+#define _INSERT_VECTOR_ANNOTATION
+#define _ACTIVATE_OPTIONAL_ANNOTATION
+#define _INSERT_OPTIONAL_ANNOTATION
+#pragma comment(linker, "/INFERASANLIBS")
+#endif // __has_feature(address_sanitizer)
+
+#endif // ^^^ defined(__clang__) ^^^
+
+
+#ifdef _DISABLE_STRING_ANNOTATION
+#undef _ACTIVATE_STRING_ANNOTATION
+#undef _INSERT_STRING_ANNOTATION
+#endif // ^^^ defined(_DISABLE_STRING_ANNOTATION) ^^^
+#ifdef _DISABLE_VECTOR_ANNOTATION
+#undef _ACTIVATE_VECTOR_ANNOTATION
+#undef _INSERT_VECTOR_ANNOTATION
+#endif // ^^^ defined(_DISABLE_VECTOR_ANNOTATION) ^^^
+#ifdef _DISABLE_OPTIONAL_ANNOTATION
+#undef _ACTIVATE_OPTIONAL_ANNOTATION
+#undef _INSERT_OPTIONAL_ANNOTATION
+#endif // ^^^ defined(_DISABLE_OPTIONAL_ANNOTATION) ^^^
+
+#ifdef _ANNOTATE_STRING
+#define _INSERT_STRING_ANNOTATION
+#endif // ^^^ defined(_ANNOTATE_STRING) ^^^
+#ifdef _ANNOTATE_VECTOR
+#define _INSERT_VECTOR_ANNOTATION
+#endif // ^^^ defined(_ANNOTATE_VECTOR) ^^^
+#ifdef _ANNOTATE_OPTIONAL
+#define _INSERT_OPTIONAL_ANNOTATION
+#endif // ^^^ defined(_ANNOTATE_OPTIONAL) ^^^
+
+
+#ifndef _INSERT_STRING_ANNOTATION
+#pragma detect_mismatch("annotate_string", "0")
+#endif // ^^^ !defined(_INSERT_STRING_ANNOTATION) ^^^
+#ifndef _INSERT_VECTOR_ANNOTATION
+#pragma detect_mismatch("annotate_vector", "0")
+#endif // ^^^ !defined(_INSERT_VECTOR_ANNOTATION) ^^^
+#ifndef _INSERT_OPTIONAL_ANNOTATION
+#pragma detect_mismatch("annotate_optional", "0")
+#endif // ^^^ !defined(_INSERT_OPTIONAL_ANNOTATION) ^^^
+
+#ifdef _ACTIVATE_STRING_ANNOTATION
+#pragma comment(lib, "stl_asan")
+#pragma detect_mismatch("annotate_string", "1")
+#endif // ^^^ defined(_ACTIVATE_STRING_ANNOTATION) ^^^
+#ifdef _ACTIVATE_VECTOR_ANNOTATION
+#pragma comment(lib, "stl_asan")
+#pragma detect_mismatch("annotate_vector", "1")
+#endif // ^^^ defined(_ACTIVATE_VECTOR_ANNOTATION) ^^^
+#ifdef _ACTIVATE_OPTIONAL_ANNOTATION
+#pragma comment(lib, "stl_asan")
+#pragma detect_mismatch("annotate_optional", "1")
+#endif // ^^^ defined(_ACTIVATE_OPTIONAL_ANNOTATION) ^^^
+
+#undef _ACTIVATE_STRING_ANNOTATION
+#undef _ACTIVATE_VECTOR_ANNOTATION
+#undef _ACTIVATE_OPTIONAL_ANNOTATION
+
+extern "C" {
+#ifdef _INSERT_VECTOR_ANNOTATION
+extern const bool _Asan_vector_should_annotate;
+#endif
+
+#ifdef _INSERT_STRING_ANNOTATION
+extern const bool _Asan_string_should_annotate;
+#endif
+
+#ifdef _INSERT_OPTIONAL_ANNOTATION
+extern const bool _Asan_optional_should_annotate;
+#endif
+} // extern "C"
+
+#if defined(_INSERT_VECTOR_ANNOTATION) || defined(_INSERT_STRING_ANNOTATION) || defined(_INSERT_OPTIONAL_ANNOTATION)
+extern "C" {
+void __cdecl __asan_poison_memory_region(const volatile void* _Addr, size_t _Size);
+void __cdecl __asan_unpoison_memory_region(const volatile void* _Addr, size_t _Size);
+
+// This must match ASan's primary declaration, which isn't marked `noexcept`.
+void __cdecl __sanitizer_annotate_contiguous_container(
+    const void* _First, const void* _End, const void* _Old_last, const void* _New_last);
+} // extern "C"
+
+#ifdef _M_ARM64EC
+#pragma comment(linker, "/alternatename:#__asan_poison_memory_region=#__asan_poison_memory_region_default")
+#pragma comment(linker, "/alternatename:__asan_poison_memory_region=__asan_poison_memory_region_default")
+#pragma comment(linker, "/alternatename:#__asan_unpoison_memory_region=#__asan_unpoison_memory_region_default")
+#pragma comment(linker, "/alternatename:__asan_unpoison_memory_region=__asan_unpoison_memory_region_default")
+#pragma comment(linker, \
+    "/alternatename:#__sanitizer_annotate_contiguous_container=#__sanitizer_annotate_contiguous_container_default")
+#pragma comment(linker, \
+    "/alternatename:__sanitizer_annotate_contiguous_container=__sanitizer_annotate_contiguous_container_default")
+#pragma comment(linker, "/alternatename:#_Asan_vector_should_annotate=#_Asan_vector_should_annotate_default")
+#pragma comment(linker, "/alternatename:_Asan_vector_should_annotate=_Asan_vector_should_annotate_default")
+#pragma comment(linker, "/alternatename:#_Asan_string_should_annotate=#_Asan_string_should_annotate_default")
+#pragma comment(linker, "/alternatename:_Asan_string_should_annotate=_Asan_string_should_annotate_default")
+#pragma comment(linker, "/alternatename:#_Asan_optional_should_annotate=#_Asan_optional_should_annotate_default")
+#pragma comment(linker, "/alternatename:_Asan_optional_should_annotate=_Asan_optional_should_annotate_default")
+#elif defined(_M_HYBRID)
+#pragma comment(linker, "/alternatename:#__asan_poison_memory_region=#__asan_poison_memory_region_default")
+#pragma comment(linker, "/alternatename:___asan_poison_memory_region=___asan_poison_memory_region_default")
+#pragma comment(linker, "/alternatename:#__asan_unpoison_memory_region=#__asan_unpoison_memory_region_default")
+#pragma comment(linker, "/alternatename:___asan_unpoison_memory_region=___asan_unpoison_memory_region_default")
+#pragma comment(linker, \
+    "/alternatename:#__sanitizer_annotate_contiguous_container=#__sanitizer_annotate_contiguous_container_default")
+#pragma comment(linker, \
+    "/alternatename:___sanitizer_annotate_contiguous_container=___sanitizer_annotate_contiguous_container_default")
+#pragma comment(linker, "/alternatename:#_Asan_vector_should_annotate=#_Asan_vector_should_annotate_default")
+#pragma comment(linker, "/alternatename:__Asan_vector_should_annotate=__Asan_vector_should_annotate_default")
+#pragma comment(linker, "/alternatename:#_Asan_string_should_annotate=#_Asan_string_should_annotate_default")
+#pragma comment(linker, "/alternatename:__Asan_string_should_annotate=__Asan_string_should_annotate_default")
+#pragma comment(linker, "/alternatename:#_Asan_optional_should_annotate=#_Asan_optional_should_annotate_default")
+#pragma comment(linker, "/alternatename:__Asan_optional_should_annotate=__Asan_optional_should_annotate_default")
+#elif defined(_M_IX86)
+#pragma comment(linker, "/alternatename:___asan_poison_memory_region=___asan_poison_memory_region_default")
+#pragma comment(linker, "/alternatename:___asan_unpoison_memory_region=___asan_unpoison_memory_region_default")
+#pragma comment(linker, \
+    "/alternatename:___sanitizer_annotate_contiguous_container=___sanitizer_annotate_contiguous_container_default")
+#pragma comment(linker, "/alternatename:__Asan_vector_should_annotate=__Asan_vector_should_annotate_default")
+#pragma comment(linker, "/alternatename:__Asan_string_should_annotate=__Asan_string_should_annotate_default")
+#pragma comment(linker, "/alternatename:__Asan_optional_should_annotate=__Asan_optional_should_annotate_default")
+#elif defined(_M_X64) || defined(_M_ARM64)
+#pragma comment(linker, "/alternatename:__asan_poison_memory_region=__asan_poison_memory_region_default")
+#pragma comment(linker, "/alternatename:__asan_unpoison_memory_region=__asan_unpoison_memory_region_default")
+#pragma comment(linker, \
+    "/alternatename:__sanitizer_annotate_contiguous_container=__sanitizer_annotate_contiguous_container_default")
+#pragma comment(linker, "/alternatename:_Asan_vector_should_annotate=_Asan_vector_should_annotate_default")
+#pragma comment(linker, "/alternatename:_Asan_string_should_annotate=_Asan_string_should_annotate_default")
+#pragma comment(linker, "/alternatename:_Asan_optional_should_annotate=_Asan_optional_should_annotate_default")
+#else // ^^^ known architecture / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+
+#endif // ^^^ insert ASan annotations ^^^
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_SANITIZER_ANNOTATE_CONTAINER_HPP
diff --git a/msvc-stl/stl/inc/__msvc_string_view.hpp b/msvc-stl/stl/inc/__msvc_string_view.hpp
new file mode 100644
index 0000000..3036533
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_string_view.hpp
@@ -0,0 +1,2165 @@
+// __msvc_string_view.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// (<string_view> without emitting non-C++17 warnings)
+
+#ifndef __MSVC_STRING_VIEW_HPP
+#define __MSVC_STRING_VIEW_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <iosfwd>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+// The "noalias" attribute tells the compiler optimizer that pointers going into these hand-vectorized algorithms
+// won't be stored beyond the lifetime of the function, and that the function will only reference arrays denoted by
+// those pointers. The optimizer also assumes in that case that a pointer parameter is not returned to the caller via
+// the return value, so functions using "noalias" must usually return void. This attribute is valuable because these
+// functions are in native code objects that the compiler cannot analyze. In the absence of the noalias attribute, the
+// compiler has to assume that the denoted arrays are "globally address taken", and that any later calls to
+// unanalyzable routines may modify those arrays.
+
+#if _VECTORIZED_FIND_FIRST_OF
+__declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_1(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_2(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_4(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_8(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+#if _VECTORIZED_FIND_LAST_OF
+__declspec(noalias) size_t __stdcall __std_find_last_of_trivial_pos_1(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_last_of_trivial_pos_2(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^
+
+#if _VECTORIZED_FIND
+const void* __stdcall __std_find_not_ch_1(const void* _First, const void* _Last, uint8_t _Val) noexcept;
+const void* __stdcall __std_find_not_ch_2(const void* _First, const void* _Last, uint16_t _Val) noexcept;
+const void* __stdcall __std_find_not_ch_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
+const void* __stdcall __std_find_not_ch_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;
+#endif // ^^^ _VECTORIZED_FIND ^^^
+
+#if _VECTORIZED_FIND_LAST
+__declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_1(
+    const void* _First, const void* _Last, uint8_t _Val) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_2(
+    const void* _First, const void* _Last, uint16_t _Val) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_4(
+    const void* _First, const void* _Last, uint32_t _Val) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_8(
+    const void* _First, const void* _Last, uint64_t _Val) noexcept;
+#endif // ^^^ _VECTORIZED_FIND_LAST ^^^
+
+#if _VECTORIZED_FIND_FIRST_OF
+__declspec(noalias) size_t __stdcall __std_find_first_not_of_trivial_pos_1(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_first_not_of_trivial_pos_2(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+#if _VECTORIZED_FIND_LAST_OF
+__declspec(noalias) size_t __stdcall __std_find_last_not_of_trivial_pos_1(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+__declspec(noalias) size_t __stdcall __std_find_last_not_of_trivial_pos_2(
+    const void* _Haystack, size_t _Haystack_length, const void* _Needle, size_t _Needle_length) noexcept;
+#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^
+
+} // extern "C"
+
+_STD_BEGIN
+
+#if _VECTORIZED_FIND_FIRST_OF
+template <class _Ty1, class _Ty2>
+size_t _Find_first_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _Haystack_length,
+    const _Ty2* const _Needle, const size_t _Needle_length) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Ty1) == sizeof(_Ty2));
+    if constexpr (sizeof(_Ty1) == 1) {
+        return ::__std_find_first_of_trivial_pos_1(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else if constexpr (sizeof(_Ty1) == 2) {
+        return ::__std_find_first_of_trivial_pos_2(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else if constexpr (sizeof(_Ty1) == 4) {
+        return ::__std_find_first_of_trivial_pos_4(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else if constexpr (sizeof(_Ty1) == 8) {
+        return ::__std_find_first_of_trivial_pos_8(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+#if _VECTORIZED_FIND_LAST_OF
+template <class _Ty1, class _Ty2>
+size_t _Find_last_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _Haystack_length,
+    const _Ty2* const _Needle, const size_t _Needle_length) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Ty1) == sizeof(_Ty2));
+    if constexpr (sizeof(_Ty1) == 1) {
+        return ::__std_find_last_of_trivial_pos_1(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else if constexpr (sizeof(_Ty1) == 2) {
+        return ::__std_find_last_of_trivial_pos_2(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^
+
+#if _VECTORIZED_FIND
+template <class _Ty>
+const _Ty* _Find_not_ch_vectorized(const _Ty* const _First, const _Ty* const _Last, const _Ty _Ch) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return static_cast<const _Ty*>(::__std_find_not_ch_1(_First, _Last, static_cast<uint8_t>(_Ch)));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return static_cast<const _Ty*>(::__std_find_not_ch_2(_First, _Last, static_cast<uint16_t>(_Ch)));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return static_cast<const _Ty*>(::__std_find_not_ch_4(_First, _Last, static_cast<uint32_t>(_Ch)));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return static_cast<const _Ty*>(::__std_find_not_ch_8(_First, _Last, static_cast<uint64_t>(_Ch)));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND ^^^
+
+#if _VECTORIZED_FIND_LAST
+template <class _Ty>
+size_t _Find_last_not_ch_pos_vectorized(const _Ty* const _First, const _Ty* const _Last, const _Ty _Ch) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return ::__std_find_last_not_ch_pos_1(_First, _Last, static_cast<uint8_t>(_Ch));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return ::__std_find_last_not_ch_pos_2(_First, _Last, static_cast<uint16_t>(_Ch));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return ::__std_find_last_not_ch_pos_4(_First, _Last, static_cast<uint32_t>(_Ch));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return ::__std_find_last_not_ch_pos_8(_First, _Last, static_cast<uint64_t>(_Ch));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND_LAST ^^^
+
+#if _VECTORIZED_FIND_FIRST_OF
+template <class _Ty1, class _Ty2>
+size_t _Find_first_not_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _Haystack_length,
+    const _Ty2* const _Needle, const size_t _Needle_length) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Ty1) == sizeof(_Ty2));
+    if constexpr (sizeof(_Ty1) == 1) {
+        return ::__std_find_first_not_of_trivial_pos_1(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else if constexpr (sizeof(_Ty1) == 2) {
+        return ::__std_find_first_not_of_trivial_pos_2(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+#if _VECTORIZED_FIND_LAST_OF
+template <class _Ty1, class _Ty2>
+size_t _Find_last_not_of_pos_vectorized(const _Ty1* const _Haystack, const size_t _Haystack_length,
+    const _Ty2* const _Needle, const size_t _Needle_length) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Ty1) == sizeof(_Ty2));
+    if constexpr (sizeof(_Ty1) == 1) {
+        return ::__std_find_last_not_of_trivial_pos_1(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else if constexpr (sizeof(_Ty1) == 2) {
+        return ::__std_find_last_not_of_trivial_pos_2(_Haystack, _Haystack_length, _Needle, _Needle_length);
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^
+
+#ifdef __clang__
+#define _HAS_MEMCPY_MEMMOVE_INTRINSICS 1
+#else // ^^^ use __builtin_memcpy and __builtin_memmove / use workaround vvv
+#define _HAS_MEMCPY_MEMMOVE_INTRINSICS 0 // TRANSITION, DevCom-1046483 (MSVC) and VSO-1129974 (EDG)
+#endif // ^^^ use workaround ^^^
+
+template <class _Elem, class _Int_type>
+struct _Char_traits { // properties of a string or stream element
+    using char_type  = _Elem;
+    using int_type   = _Int_type;
+    using pos_type   = streampos;
+    using off_type   = streamoff;
+    using state_type = _Mbstatet;
+#if _HAS_CXX20
+    using comparison_category = strong_ordering;
+#endif // _HAS_CXX20
+
+    // For copy/move, we can uniformly call memcpy/memmove (or their builtin versions) for all element types.
+
+    static _CONSTEXPR20 _Elem* copy(_Out_writes_all_(_Count) _Elem* const _First1,
+        _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept /* strengthened */ {
+        // copy [_First2, _First2 + _Count) to [_First1, ...)
+#if _HAS_MEMCPY_MEMMOVE_INTRINSICS
+        __builtin_memcpy(_First1, _First2, _Count * sizeof(_Elem));
+#else // ^^^ _HAS_MEMCPY_MEMMOVE_INTRINSICS / !_HAS_MEMCPY_MEMMOVE_INTRINSICS vvv
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            // pre: [_First1, _First1 + _Count) and [_First2, _First2 + _Count) do not overlap
+            for (size_t _Idx = 0; _Idx != _Count; ++_Idx) {
+                _First1[_Idx] = _First2[_Idx];
+            }
+
+            return _First1;
+        }
+#endif // _HAS_CXX20
+
+        _CSTD memcpy(_First1, _First2, _Count * sizeof(_Elem));
+#endif // ^^^ !_HAS_MEMCPY_MEMMOVE_INTRINSICS ^^^
+
+        return _First1;
+    }
+
+    _Pre_satisfies_(_Dest_size >= _Count) static _CONSTEXPR20 _Elem* _Copy_s(_Out_writes_all_(_Dest_size)
+                                                                                 _Elem* const _First1,
+        const size_t _Dest_size, _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept {
+        // copy [_First2, _First2 + _Count) to [_First1, _First1 + _Dest_size)
+        _STL_VERIFY(_Count <= _Dest_size, "invalid argument");
+        return copy(_First1, _First2, _Count);
+    }
+
+    static _CONSTEXPR20 _Elem* move(_Out_writes_all_(_Count) _Elem* const _First1,
+        _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept /* strengthened */ {
+        // copy [_First2, _First2 + _Count) to [_First1, ...), allowing overlap
+#if _HAS_MEMCPY_MEMMOVE_INTRINSICS
+        __builtin_memmove(_First1, _First2, _Count * sizeof(_Elem));
+#else // ^^^ _HAS_MEMCPY_MEMMOVE_INTRINSICS / !_HAS_MEMCPY_MEMMOVE_INTRINSICS vvv
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            // dest: [_First1, _First1 + _Count)
+            // src: [_First2, _First2 + _Count)
+            // We need to handle overlapping ranges.
+            // If _First1 is in the src range, we need a backward loop.
+            // Otherwise, the forward loop works (even if the back of dest overlaps the front of src).
+
+            // Usually, we would compare pointers with less-than, even though they could belong to different arrays.
+            // However, we're not allowed to do that during constant evaluation, so we need a linear scan for equality.
+            bool _Loop_forward = true;
+
+            for (const _Elem* _Src = _First2; _Src != _First2 + _Count; ++_Src) {
+                if (_First1 == _Src) {
+                    _Loop_forward = false;
+                    break;
+                }
+            }
+
+            if (_Loop_forward) {
+                for (size_t _Idx = 0; _Idx != _Count; ++_Idx) {
+                    _First1[_Idx] = _First2[_Idx];
+                }
+            } else {
+                for (size_t _Idx = _Count; _Idx != 0; --_Idx) {
+                    _First1[_Idx - 1] = _First2[_Idx - 1];
+                }
+            }
+
+            return _First1;
+        }
+#endif // _HAS_CXX20
+
+        _CSTD memmove(_First1, _First2, _Count * sizeof(_Elem));
+#endif // ^^^ !_HAS_MEMCPY_MEMMOVE_INTRINSICS ^^^
+
+        return _First1;
+    }
+
+    // For compare/length/find/assign, we can't uniformly call CRT functions (or their builtin versions).
+    // 8-bit: memcmp/strlen/memchr/memset; 16-bit: wmemcmp/wcslen/wmemchr/wmemset; 32-bit: nonexistent
+
+    _NODISCARD static _CONSTEXPR17 int compare(_In_reads_(_Count) const _Elem* _First1,
+        _In_reads_(_Count) const _Elem* _First2, size_t _Count) noexcept /* strengthened */ {
+        // compare [_First1, _First1 + _Count) with [_First2, ...)
+        for (; 0 < _Count; --_Count, ++_First1, ++_First2) {
+            if (*_First1 != *_First2) {
+                return *_First1 < *_First2 ? -1 : +1;
+            }
+        }
+
+        return 0;
+    }
+
+    _NODISCARD static _CONSTEXPR17 size_t length(_In_z_ const _Elem* _First) noexcept /* strengthened */ {
+        // find length of null-terminated sequence
+        size_t _Count = 0;
+        while (*_First != _Elem()) {
+            ++_Count;
+            ++_First;
+        }
+
+        return _Count;
+    }
+
+    _NODISCARD static _CONSTEXPR17 const _Elem* find(
+        _In_reads_(_Count) const _Elem* _First, size_t _Count, const _Elem& _Ch) noexcept /* strengthened */ {
+        // look for _Ch in [_First, _First + _Count)
+        for (; 0 < _Count; --_Count, ++_First) {
+            if (*_First == _Ch) {
+                return _First;
+            }
+        }
+
+        return nullptr;
+    }
+
+    static _CONSTEXPR20 _Elem* assign(
+        _Out_writes_all_(_Count) _Elem* const _First, size_t _Count, const _Elem _Ch) noexcept /* strengthened */ {
+        // assign _Count * _Ch to [_First, ...)
+        for (_Elem* _Next = _First; _Count > 0; --_Count, ++_Next) {
+            *_Next = _Ch;
+        }
+
+        return _First;
+    }
+
+    static _CONSTEXPR17 void assign(_Elem& _Left, const _Elem& _Right) noexcept {
+        _Left = _Right;
+    }
+
+    _NODISCARD static constexpr bool eq(const _Elem _Left, const _Elem _Right) noexcept {
+        return _Left == _Right;
+    }
+
+    _NODISCARD static constexpr bool lt(const _Elem _Left, const _Elem _Right) noexcept {
+        return _Left < _Right;
+    }
+
+    _NODISCARD static constexpr _Elem to_char_type(const int_type _Meta) noexcept {
+        return static_cast<_Elem>(_Meta);
+    }
+
+    _NODISCARD static constexpr int_type to_int_type(const _Elem _Ch) noexcept {
+        return static_cast<int_type>(_Ch);
+    }
+
+    _NODISCARD static constexpr bool eq_int_type(const int_type _Left, const int_type _Right) noexcept {
+        return _Left == _Right;
+    }
+
+    _NODISCARD static constexpr int_type not_eof(const int_type _Meta) noexcept {
+        return _Meta != eof() ? _Meta : !eof();
+    }
+
+    _NODISCARD static constexpr int_type eof() noexcept {
+        return static_cast<int_type>(EOF);
+    }
+};
+
+template <class _Elem>
+struct _WChar_traits : private _Char_traits<_Elem, unsigned short> {
+    // char_traits for the char16_t-likes: char16_t, wchar_t, unsigned short
+private:
+    using _Primary_char_traits = _Char_traits<_Elem, unsigned short>;
+
+public:
+    using char_type  = _Elem;
+    using int_type   = unsigned short;
+    using pos_type   = streampos;
+    using off_type   = streamoff;
+    using state_type = mbstate_t;
+#if _HAS_CXX20
+    using comparison_category = strong_ordering;
+#endif // _HAS_CXX20
+
+    using _Primary_char_traits::_Copy_s;
+    using _Primary_char_traits::copy;
+    using _Primary_char_traits::move;
+
+    _NODISCARD static _CONSTEXPR17 int compare(_In_reads_(_Count) const _Elem* const _First1,
+        _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept /* strengthened */ {
+        // compare [_First1, _First1 + _Count) with [_First2, ...)
+#if _VECTORIZED_MISMATCH
+        if (!_STD _Is_constant_evaluated()) {
+            // TRANSITION, GH-2289: Use vectorized algorithms for better performance than __builtin_wmemcmp.
+            const size_t _Pos = _Mismatch_vectorized<sizeof(_Elem)>(_First1, _First2, _Count);
+            if (_Pos == _Count) {
+                return 0;
+            } else {
+                return _First1[_Pos] < _First2[_Pos] ? -1 : +1;
+            }
+        }
+#endif // ^^^ _VECTORIZED_MISMATCH ^^^
+
+        if constexpr (is_same_v<_Elem, wchar_t>) {
+            return __builtin_wmemcmp(_First1, _First2, _Count);
+        } else {
+            return _Primary_char_traits::compare(_First1, _First2, _Count);
+        }
+    }
+
+    _NODISCARD static _CONSTEXPR17 size_t length(_In_z_ const _Elem* _First) noexcept /* strengthened */ {
+        // find length of null-terminated sequence
+#if _HAS_CXX17
+        if (_STD _Is_constant_evaluated()) {
+            if constexpr (is_same_v<_Elem, wchar_t>) {
+                return __builtin_wcslen(_First);
+            } else {
+                return _Primary_char_traits::length(_First);
+            }
+        }
+#endif // _HAS_CXX17
+
+        return _CSTD wcslen(reinterpret_cast<const wchar_t*>(_First));
+    }
+
+    _NODISCARD static _CONSTEXPR17 const _Elem* find(
+        _In_reads_(_Count) const _Elem* _First, const size_t _Count, const _Elem& _Ch) noexcept /* strengthened */ {
+        // look for _Ch in [_First, _First + _Count)
+#if _HAS_CXX17
+        if (_STD _Is_constant_evaluated()) {
+            if constexpr (is_same_v<_Elem, wchar_t>) {
+                return __builtin_wmemchr(_First, _Ch, _Count);
+            } else {
+                return _Primary_char_traits::find(_First, _Count, _Ch);
+            }
+        }
+#endif // _HAS_CXX17
+
+        return reinterpret_cast<const _Elem*>(_CSTD wmemchr(reinterpret_cast<const wchar_t*>(_First), _Ch, _Count));
+    }
+
+    static _CONSTEXPR20 _Elem* assign(
+        _Out_writes_all_(_Count) _Elem* const _First, size_t _Count, const _Elem _Ch) noexcept /* strengthened */ {
+        // assign _Count * _Ch to [_First, ...)
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            return _Primary_char_traits::assign(_First, _Count, _Ch);
+        }
+#endif // _HAS_CXX20
+
+        return reinterpret_cast<_Elem*>(_CSTD wmemset(reinterpret_cast<wchar_t*>(_First), _Ch, _Count));
+    }
+
+    static _CONSTEXPR17 void assign(_Elem& _Left, const _Elem& _Right) noexcept {
+        _Left = _Right;
+    }
+
+    _NODISCARD static constexpr bool eq(const _Elem _Left, const _Elem _Right) noexcept {
+        return _Left == _Right;
+    }
+
+    _NODISCARD static constexpr bool lt(const _Elem _Left, const _Elem _Right) noexcept {
+        return _Left < _Right;
+    }
+
+    _NODISCARD static constexpr _Elem to_char_type(const int_type _Meta) noexcept {
+        return _Meta;
+    }
+
+    _NODISCARD static constexpr int_type to_int_type(const _Elem _Ch) noexcept {
+        return _Ch;
+    }
+
+    _NODISCARD static constexpr bool eq_int_type(const int_type _Left, const int_type _Right) noexcept {
+        return _Left == _Right;
+    }
+
+    _NODISCARD static constexpr int_type not_eof(const int_type _Meta) noexcept {
+        return _Meta != eof() ? _Meta : static_cast<int_type>(!eof());
+    }
+
+    _NODISCARD static constexpr int_type eof() noexcept {
+        return WEOF;
+    }
+};
+
+_EXPORT_STD template <class _Elem>
+struct char_traits : _Char_traits<_Elem, long> {}; // properties of a string or stream unknown element
+
+template <>
+struct char_traits<char16_t> : _WChar_traits<char16_t> {};
+
+template <>
+struct char_traits<char32_t> : _Char_traits<char32_t, unsigned int> {};
+
+template <>
+struct char_traits<wchar_t> : _WChar_traits<wchar_t> {};
+
+#ifdef _CRTBLD
+template <>
+struct char_traits<unsigned short> : _WChar_traits<unsigned short> {};
+#endif // defined(_CRTBLD)
+
+// signed char and other unsigned integral types are supported as an extension.
+// Use of other arithmetic types and nullptr_t should be rejected.
+template <class _Ty>
+constexpr bool _Is_implementation_handled_char_like_type = is_arithmetic_v<_Ty> || is_null_pointer_v<_Ty>;
+
+template <class>
+constexpr bool _Is_implementation_handled_char_traits = false;
+template <class _Elem>
+constexpr bool _Is_implementation_handled_char_traits<char_traits<_Elem>> =
+    _Is_implementation_handled_char_like_type<_Elem>;
+
+#if defined(__cpp_char8_t) && !defined(__clang__) && !defined(__EDG__)
+#define _HAS_U8_INTRINSICS 1
+#else // ^^^ Use intrinsics for char8_t / don't use said intrinsics vvv
+#define _HAS_U8_INTRINSICS 0
+#endif // Detect u8 intrinsics
+
+template <class _Elem, class _Int_type>
+struct _Narrow_char_traits : private _Char_traits<_Elem, _Int_type> {
+    // Implement char_traits for narrow character types char and char8_t
+private:
+    using _Primary_char_traits = _Char_traits<_Elem, _Int_type>;
+
+public:
+    using char_type  = _Elem;
+    using int_type   = _Int_type;
+    using pos_type   = streampos;
+    using off_type   = streamoff;
+    using state_type = mbstate_t;
+#if _HAS_CXX20
+    using comparison_category = strong_ordering;
+#endif // _HAS_CXX20
+
+    using _Primary_char_traits::_Copy_s;
+    using _Primary_char_traits::copy;
+    using _Primary_char_traits::move;
+
+    _NODISCARD static _CONSTEXPR17 int compare(_In_reads_(_Count) const _Elem* const _First1,
+        _In_reads_(_Count) const _Elem* const _First2, const size_t _Count) noexcept /* strengthened */ {
+        // compare [_First1, _First1 + _Count) with [_First2, ...)
+#if _HAS_CXX17
+        return __builtin_memcmp(_First1, _First2, _Count);
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        return _CSTD memcmp(_First1, _First2, _Count);
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    _NODISCARD static _CONSTEXPR17 size_t length(_In_z_ const _Elem* const _First) noexcept /* strengthened */ {
+        // find length of null-terminated string
+#if _HAS_CXX17
+#ifdef __cpp_char8_t
+        if constexpr (is_same_v<_Elem, char8_t>) {
+#if _HAS_U8_INTRINSICS
+            return __builtin_u8strlen(_First);
+#else // ^^^ use u8 intrinsics / no u8 intrinsics vvv
+            return _Primary_char_traits::length(_First);
+#endif // ^^^ no u8 intrinsics ^^^
+        } else
+#endif // defined(__cpp_char8_t)
+        {
+            return __builtin_strlen(_First);
+        }
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        return _CSTD strlen(reinterpret_cast<const char*>(_First));
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    _NODISCARD static _CONSTEXPR17 const _Elem* find(_In_reads_(_Count) const _Elem* const _First, const size_t _Count,
+        const _Elem& _Ch) noexcept /* strengthened */ {
+        // look for _Ch in [_First, _First + _Count)
+#if _HAS_CXX17
+#ifdef __cpp_char8_t
+        if constexpr (is_same_v<_Elem, char8_t>) {
+#if _HAS_U8_INTRINSICS
+            return __builtin_u8memchr(_First, _Ch, _Count);
+#else // ^^^ use u8 intrinsics / no u8 intrinsics vvv
+            return _Primary_char_traits::find(_First, _Count, _Ch);
+#endif // ^^^ no u8 intrinsics ^^^
+        } else
+#endif // defined(__cpp_char8_t)
+        {
+            return __builtin_char_memchr(_First, _Ch, _Count);
+        }
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        return static_cast<const _Elem*>(_CSTD memchr(_First, _Ch, _Count));
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    static _CONSTEXPR20 _Elem* assign(
+        _Out_writes_all_(_Count) _Elem* const _First, size_t _Count, const _Elem _Ch) noexcept /* strengthened */ {
+        // assign _Count * _Ch to [_First, ...)
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            return _Primary_char_traits::assign(_First, _Count, _Ch);
+        }
+#endif // _HAS_CXX20
+
+        return static_cast<_Elem*>(_CSTD memset(_First, _Ch, _Count));
+    }
+
+    static _CONSTEXPR17 void assign(_Elem& _Left, const _Elem& _Right) noexcept {
+        _Left = _Right;
+    }
+
+    _NODISCARD static constexpr bool eq(const _Elem _Left, const _Elem _Right) noexcept {
+        return _Left == _Right;
+    }
+
+    _NODISCARD static constexpr bool lt(const _Elem _Left, const _Elem _Right) noexcept {
+        return static_cast<unsigned char>(_Left) < static_cast<unsigned char>(_Right);
+    }
+
+    _NODISCARD static constexpr _Elem to_char_type(const int_type _Meta) noexcept {
+        return static_cast<_Elem>(_Meta);
+    }
+
+    _NODISCARD static constexpr int_type to_int_type(const _Elem _Ch) noexcept {
+        return static_cast<unsigned char>(_Ch);
+    }
+
+    _NODISCARD static constexpr bool eq_int_type(const int_type _Left, const int_type _Right) noexcept {
+        return _Left == _Right;
+    }
+
+    _NODISCARD static constexpr int_type not_eof(const int_type _Meta) noexcept {
+        return _Meta != eof() ? _Meta : !eof();
+    }
+
+    _NODISCARD static constexpr int_type eof() noexcept {
+        return static_cast<int_type>(EOF);
+    }
+};
+
+#undef _HAS_U8_INTRINSICS
+#undef _HAS_MEMCPY_MEMMOVE_INTRINSICS
+
+template <>
+struct char_traits<char> : _Narrow_char_traits<char, int> {}; // properties of a string or stream char element
+
+#ifdef __cpp_char8_t
+template <>
+struct char_traits<char8_t> : _Narrow_char_traits<char8_t, unsigned int> {};
+#endif // defined(__cpp_char8_t)
+
+template <class _Elem, class _Traits, class _SizeT>
+basic_ostream<_Elem, _Traits>& _Insert_string(
+    basic_ostream<_Elem, _Traits>& _Ostr, const _Elem* const _Data, const _SizeT _Size) {
+    // insert a character-type sequence into _Ostr as if through a basic_string copy
+    using _Ostr_t                    = basic_ostream<_Elem, _Traits>;
+    typename _Ostr_t::iostate _State = _Ostr_t::goodbit;
+
+    _SizeT _Pad;
+    if (_Ostr.width() <= 0 || static_cast<_SizeT>(_Ostr.width()) <= _Size) {
+        _Pad = 0;
+    } else {
+        _Pad = static_cast<_SizeT>(_Ostr.width()) - _Size;
+    }
+
+    const typename _Ostr_t::sentry _Ok(_Ostr);
+
+    if (!_Ok) {
+        _State |= _Ostr_t::badbit;
+    } else { // state okay, insert characters
+        _TRY_IO_BEGIN
+        if ((_Ostr.flags() & _Ostr_t::adjustfield) != _Ostr_t::left) {
+            for (; 0 < _Pad; --_Pad) { // pad on left
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= _Ostr_t::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+        }
+
+        if (_State == _Ostr_t::goodbit
+            && _Ostr.rdbuf()->sputn(_Data, static_cast<streamsize>(_Size)) != static_cast<streamsize>(_Size)) {
+            _State |= _Ostr_t::badbit;
+        } else {
+            for (; 0 < _Pad; --_Pad) { // pad on right
+                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                    _State |= _Ostr_t::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+        }
+
+        _Ostr.width(0);
+        _CATCH_IO_(_Ostr_t, _Ostr)
+    }
+
+    _Ostr.setstate(_State);
+    return _Ostr;
+}
+
+template <class _Traits>
+using _Traits_ch_t = typename _Traits::char_type;
+
+template <class _Traits>
+using _Traits_ptr_t = const typename _Traits::char_type*;
+
+template <class _Traits>
+constexpr bool _Traits_equal(_In_reads_(_Left_size) const _Traits_ptr_t<_Traits> _Left, const size_t _Left_size,
+    _In_reads_(_Right_size) const _Traits_ptr_t<_Traits> _Right, const size_t _Right_size) noexcept {
+    // compare [_Left, _Left + _Left_size) to [_Right, _Right + _Right_size) for equality using _Traits
+    if (_Left_size != _Right_size) {
+        return false;
+    }
+
+    if (_Left_size == 0u) {
+        return true;
+    }
+
+    return _Traits::compare(_Left, _Right, _Left_size) == 0;
+}
+
+template <class _Traits>
+constexpr int _Traits_compare(_In_reads_(_Left_size) const _Traits_ptr_t<_Traits> _Left, const size_t _Left_size,
+    _In_reads_(_Right_size) const _Traits_ptr_t<_Traits> _Right, const size_t _Right_size) noexcept {
+    // compare [_Left, _Left + _Left_size) to [_Right, _Right + _Right_size) using _Traits
+    const int _Ans = _Traits::compare(_Left, _Right, (_STD min) (_Left_size, _Right_size));
+
+    if (_Ans != 0) {
+        return _Ans;
+    }
+
+    if (_Left_size < _Right_size) {
+        return -1;
+    }
+
+    if (_Left_size > _Right_size) {
+        return 1;
+    }
+
+    return 0;
+}
+
+template <class _Traits>
+constexpr size_t _Traits_find(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size,
+    const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t<_Traits> _Needle,
+    const size_t _Needle_size) noexcept {
+    // search [_Haystack, _Haystack + _Hay_size) for [_Needle, _Needle + _Needle_size), at/after _Start_at
+    if (_Needle_size > _Hay_size || _Start_at > _Hay_size - _Needle_size) {
+        // xpos cannot exist, report failure
+        // N4950 [string.view.find]/3 says:
+        // 1. _Start_at <= xpos
+        // 2. xpos + _Needle_size <= _Hay_size;
+        // therefore:
+        // 3. _Needle_size <= _Hay_size (by 2) (checked above)
+        // 4. _Start_at + _Needle_size <= _Hay_size (substitute 1 into 2)
+        // 5. _Start_at <= _Hay_size - _Needle_size (4, move _Needle_size to other side) (also checked above)
+        return static_cast<size_t>(-1);
+    }
+
+    if (_Needle_size == 0) { // empty string always matches if xpos is possible
+        return _Start_at;
+    }
+
+#if _VECTORIZED_SEARCH
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        if (!_STD _Is_constant_evaluated()) {
+            const auto _End = _Haystack + _Hay_size;
+            const auto _Ptr = _STD _Search_vectorized(_Haystack + _Start_at, _End, _Needle, _Needle_size);
+
+            if (_Ptr != _End) {
+                return static_cast<size_t>(_Ptr - _Haystack);
+            } else {
+                return static_cast<size_t>(-1);
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_SEARCH ^^^
+
+    const auto _Possible_matches_end = _Haystack + (_Hay_size - _Needle_size) + 1;
+    for (auto _Match_try = _Haystack + _Start_at;; ++_Match_try) {
+        _Match_try = _Traits::find(_Match_try, static_cast<size_t>(_Possible_matches_end - _Match_try), *_Needle);
+        if (!_Match_try) { // didn't find first character; report failure
+            return static_cast<size_t>(-1);
+        }
+
+        if (_Traits::compare(_Match_try, _Needle, _Needle_size) == 0) { // found match
+            return static_cast<size_t>(_Match_try - _Haystack);
+        }
+    }
+}
+
+template <class _Traits>
+constexpr size_t _Traits_find_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size,
+    const size_t _Start_at, const _Traits_ch_t<_Traits> _Ch) noexcept {
+    // search [_Haystack, _Haystack + _Hay_size) for _Ch, at/after _Start_at
+    if (_Start_at >= _Hay_size) {
+        return static_cast<size_t>(-1); // (npos) no room for match
+    }
+
+#if _VECTORIZED_FIND
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        if (!_STD _Is_constant_evaluated()) {
+            const auto _End = _Haystack + _Hay_size;
+            const auto _Ptr = _STD _Find_vectorized(_Haystack + _Start_at, _End, _Ch);
+
+            if (_Ptr != _End) {
+                return static_cast<size_t>(_Ptr - _Haystack);
+            } else {
+                return static_cast<size_t>(-1); // (npos) no match
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_FIND ^^^
+
+    const auto _Found_at = _Traits::find(_Haystack + _Start_at, _Hay_size - _Start_at, _Ch);
+    if (_Found_at) {
+        return static_cast<size_t>(_Found_at - _Haystack);
+    }
+
+    return static_cast<size_t>(-1); // (npos) no match
+}
+
+template <class _Traits>
+constexpr size_t _Traits_rfind(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size,
+    const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t<_Traits> _Needle,
+    const size_t _Needle_size) noexcept {
+    // search [_Haystack, _Haystack + _Hay_size) for [_Needle, _Needle + _Needle_size) beginning before _Start_at
+    if (_Needle_size == 0) {
+        return (_STD min) (_Start_at, _Hay_size); // empty string always matches
+    }
+
+    if (_Needle_size > _Hay_size) { // no room for match
+        return static_cast<size_t>(-1);
+    }
+
+    const size_t _Actual_start_at = (_STD min) (_Start_at, _Hay_size - _Needle_size);
+
+#if _VECTORIZED_FIND_END
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        if (!_STD _Is_constant_evaluated()) {
+            // _Find_end_vectorized takes into account the needle length when locating the search start.
+            // As a potentially earlier start position can be specified, we need to take it into account,
+            // and pick between the maximum possible start position and the specified one,
+            // and then add _Needle_size, so that it is subtracted back in _Find_end_vectorized.
+            const auto _End = _Haystack + _Actual_start_at + _Needle_size;
+            const auto _Ptr = _STD _Find_end_vectorized(_Haystack, _End, _Needle, _Needle_size);
+
+            if (_Ptr != _End) {
+                return static_cast<size_t>(_Ptr - _Haystack);
+            } else {
+                return static_cast<size_t>(-1);
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_FIND_END ^^^
+
+    for (auto _Match_try = _Haystack + _Actual_start_at;; --_Match_try) {
+        if (_Traits::eq(*_Match_try, *_Needle) && _Traits::compare(_Match_try, _Needle, _Needle_size) == 0) {
+            return static_cast<size_t>(_Match_try - _Haystack); // found a match
+        }
+
+        if (_Match_try == _Haystack) {
+            return static_cast<size_t>(-1); // at beginning, no more chance for match
+        }
+    }
+}
+
+template <class _Traits>
+constexpr size_t _Traits_rfind_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size,
+    const size_t _Start_at, const _Traits_ch_t<_Traits> _Ch) noexcept {
+    // search [_Haystack, _Haystack + _Hay_size) for _Ch before _Start_at
+
+    if (_Hay_size == 0) { // no room for match
+        return static_cast<size_t>(-1);
+    }
+
+    const size_t _Actual_start_at = (_STD min) (_Start_at, _Hay_size - 1);
+
+#if _VECTORIZED_FIND_LAST
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        if (!_STD _Is_constant_evaluated()) {
+            const auto _End = _Haystack + _Actual_start_at + 1;
+            const auto _Ptr = _STD _Find_last_vectorized(_Haystack, _End, _Ch);
+
+            if (_Ptr != _End) {
+                return static_cast<size_t>(_Ptr - _Haystack);
+            } else {
+                return static_cast<size_t>(-1);
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_FIND_LAST ^^^
+
+    for (auto _Match_try = _Haystack + _Actual_start_at;; --_Match_try) {
+        if (_Traits::eq(*_Match_try, _Ch)) {
+            return static_cast<size_t>(_Match_try - _Haystack); // found a match
+        }
+
+        if (_Match_try == _Haystack) {
+            return static_cast<size_t>(-1); // at beginning, no more chance for match
+        }
+    }
+}
+
+template <class _Elem, bool = _Is_character<_Elem>::value>
+class _String_bitmap { // _String_bitmap for character types
+public:
+    constexpr bool _Mark(const _Elem* _First, const _Elem* const _Last) noexcept {
+        // mark this bitmap such that the characters in [_First, _Last) are intended to match
+        // returns whether all inputs can be placed in the bitmap
+        for (; _First != _Last; ++_First) {
+            _Matches[static_cast<unsigned char>(*_First)] = true;
+        }
+
+        return true;
+    }
+
+    constexpr bool _Match(const _Elem _Ch) const noexcept { // test if _Ch is in the bitmap
+        // CodeQL [SM01954] This index is valid: we cast to unsigned char and the array has 256 elements.
+        return _Matches[static_cast<unsigned char>(_Ch)];
+    }
+
+private:
+    bool _Matches[256] = {};
+};
+
+template <class _Elem>
+class _String_bitmap<_Elem, false> { // _String_bitmap for wchar_t/unsigned short/char16_t/char32_t/etc. types
+public:
+    static_assert(is_unsigned_v<_Elem>, "Standard char_traits is only provided for char, wchar_t, char8_t, char16_t, "
+                                        "and char32_t. See N4988 [char.traits]. "
+                                        "Visual C++ accepts other unsigned integral types as an extension.");
+
+    constexpr bool _Mark(const _Elem* _First, const _Elem* const _Last) noexcept {
+        // mark this bitmap such that the characters in [_First, _Last) are intended to match
+        // returns whether all inputs can be placed in the bitmap
+        for (; _First != _Last; ++_First) {
+            const auto _Ch = *_First;
+            if (_Ch >= 256U) {
+                return false;
+            }
+
+            _Matches[static_cast<unsigned char>(_Ch)] = true;
+        }
+
+        return true;
+    }
+
+    constexpr bool _Match(const _Elem _Ch) const noexcept { // test if _Ch is in the bitmap
+        return _Ch < 256U && _Matches[_Ch];
+    }
+
+private:
+    bool _Matches[256] = {};
+};
+
+template <class _Traits>
+constexpr size_t _Traits_find_first_of(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack,
+    const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t<_Traits> _Needle,
+    const size_t _Needle_size) noexcept {
+    // in [_Haystack, _Haystack + _Hay_size), look for one of [_Needle, _Needle + _Needle_size), at/after _Start_at
+    if (_Needle_size == 0 || _Start_at >= _Hay_size) { // no match possible
+        return static_cast<size_t>(-1);
+    }
+
+    const auto _Hay_start = _Haystack + _Start_at;
+    const auto _Hay_end   = _Haystack + _Hay_size;
+
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+#if _VECTORIZED_FIND_FIRST_OF
+        if (!_STD _Is_constant_evaluated()) {
+            const size_t _Remaining_size = _Hay_size - _Start_at;
+            if (_Remaining_size + _Needle_size >= _Threshold_find_first_of) {
+                size_t _Pos = _Find_first_of_pos_vectorized(_Hay_start, _Remaining_size, _Needle, _Needle_size);
+                if (_Pos != static_cast<size_t>(-1)) {
+                    _Pos += _Start_at;
+                }
+                return _Pos;
+            }
+        }
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+        _String_bitmap<typename _Traits::char_type> _Matches;
+
+        if (_Matches._Mark(_Needle, _Needle + _Needle_size)) {
+            for (auto _Match_try = _Hay_start; _Match_try < _Hay_end; ++_Match_try) {
+                if (_Matches._Match(*_Match_try)) {
+                    return static_cast<size_t>(_Match_try - _Haystack); // found a match
+                }
+            }
+            return static_cast<size_t>(-1); // no match
+        }
+
+        // couldn't put one of the characters into the bitmap, fall back to serial algorithm
+    }
+
+    for (auto _Match_try = _Hay_start; _Match_try < _Hay_end; ++_Match_try) {
+        if (_Traits::find(_Needle, _Needle_size, *_Match_try)) {
+            return static_cast<size_t>(_Match_try - _Haystack); // found a match
+        }
+    }
+
+    return static_cast<size_t>(-1); // no match
+}
+
+template <class _Traits>
+constexpr size_t _Traits_find_last_of(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack,
+    const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t<_Traits> _Needle,
+    const size_t _Needle_size) noexcept {
+    // in [_Haystack, _Haystack + _Hay_size), look for last of [_Needle, _Needle + _Needle_size), before _Start_at
+    if (_Needle_size == 0 || _Hay_size == 0) { // not worth searching
+        return static_cast<size_t>(-1);
+    }
+
+    const auto _Hay_start = (_STD min) (_Start_at, _Hay_size - 1);
+
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        using _Elem = typename _Traits::char_type;
+#if _VECTORIZED_FIND_LAST_OF
+        if constexpr (sizeof(_Elem) <= 2) {
+            if (!_STD _Is_constant_evaluated()) {
+                const size_t _Remaining_size = _Hay_start + 1;
+                if (_Remaining_size + _Needle_size >= _Threshold_find_first_of) { // same threshold for first/last
+                    return _Find_last_of_pos_vectorized(_Haystack, _Remaining_size, _Needle, _Needle_size);
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^
+
+        _String_bitmap<_Elem> _Matches;
+        if (_Matches._Mark(_Needle, _Needle + _Needle_size)) {
+            for (auto _Match_try = _Haystack + _Hay_start;; --_Match_try) {
+                if (_Matches._Match(*_Match_try)) {
+                    return static_cast<size_t>(_Match_try - _Haystack); // found a match
+                }
+
+                if (_Match_try == _Haystack) {
+                    return static_cast<size_t>(-1); // at beginning, no more chance for match
+                }
+            }
+        }
+
+        // couldn't put one of the characters into the bitmap, fall back to serial algorithm
+    }
+
+    for (auto _Match_try = _Haystack + _Hay_start;; --_Match_try) {
+        if (_Traits::find(_Needle, _Needle_size, *_Match_try)) {
+            return static_cast<size_t>(_Match_try - _Haystack); // found a match
+        }
+
+        if (_Match_try == _Haystack) {
+            return static_cast<size_t>(-1); // at beginning, no more chance for match
+        }
+    }
+}
+
+template <class _Traits>
+constexpr size_t _Traits_find_first_not_of(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack,
+    const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t<_Traits> _Needle,
+    const size_t _Needle_size) noexcept {
+    // in [_Haystack, _Haystack + _Hay_size), look for none of [_Needle, _Needle + _Needle_size), at/after _Start_at
+    if (_Start_at >= _Hay_size) { // no room for match
+        return static_cast<size_t>(-1);
+    }
+
+    const auto _Hay_start = _Haystack + _Start_at;
+    const auto _Hay_end   = _Haystack + _Hay_size;
+
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        using _Elem = typename _Traits::char_type;
+#if _VECTORIZED_FIND_FIRST_OF
+        if constexpr (sizeof(_Elem) <= 2) {
+            if (!_STD _Is_constant_evaluated()) {
+                const size_t _Remaining_size = _Hay_size - _Start_at;
+                if (_Remaining_size + _Needle_size >= _Threshold_find_first_of) {
+                    size_t _Pos = _Find_first_not_of_pos_vectorized(_Hay_start, _Remaining_size, _Needle, _Needle_size);
+                    if (_Pos != static_cast<size_t>(-1)) {
+                        _Pos += _Start_at;
+                    }
+                    return _Pos;
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+        _String_bitmap<_Elem> _Matches;
+        if (_Matches._Mark(_Needle, _Needle + _Needle_size)) {
+            for (auto _Match_try = _Hay_start; _Match_try < _Hay_end; ++_Match_try) {
+                if (!_Matches._Match(*_Match_try)) {
+                    return static_cast<size_t>(_Match_try - _Haystack); // found a match
+                }
+            }
+            return static_cast<size_t>(-1); // no match
+        }
+
+        // couldn't put one of the characters into the bitmap, fall back to the serial algorithm
+    }
+
+    for (auto _Match_try = _Hay_start; _Match_try < _Hay_end; ++_Match_try) {
+        if (!_Traits::find(_Needle, _Needle_size, *_Match_try)) {
+            return static_cast<size_t>(_Match_try - _Haystack); // found a match
+        }
+    }
+
+    return static_cast<size_t>(-1); // no match
+}
+
+template <class _Traits>
+constexpr size_t _Traits_find_not_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack,
+    const size_t _Hay_size, const size_t _Start_at, const _Traits_ch_t<_Traits> _Ch) noexcept {
+    // search [_Haystack, _Haystack + _Hay_size) for any value other than _Ch, at/after _Start_at
+    if (_Start_at >= _Hay_size) { // no room for match
+        return static_cast<size_t>(-1); // no match
+    }
+
+    const auto _End = _Haystack + _Hay_size;
+
+#if _VECTORIZED_FIND
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        if (!_STD _Is_constant_evaluated()) {
+            const auto _Result = _STD _Find_not_ch_vectorized(_Haystack + _Start_at, _End, _Ch);
+            if (_Result != _End) {
+                return static_cast<size_t>(_Result - _Haystack);
+            } else {
+                return static_cast<size_t>(-1); // no match
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_FIND ^^^
+
+    for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try) {
+        if (!_Traits::eq(*_Match_try, _Ch)) {
+            return static_cast<size_t>(_Match_try - _Haystack); // found a match
+        }
+    }
+
+    return static_cast<size_t>(-1); // no match
+}
+
+template <class _Traits>
+constexpr size_t _Traits_find_last_not_of(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack,
+    const size_t _Hay_size, const size_t _Start_at, _In_reads_(_Needle_size) const _Traits_ptr_t<_Traits> _Needle,
+    const size_t _Needle_size) noexcept {
+    // in [_Haystack, _Haystack + _Hay_size), look for none of [_Needle, _Needle + _Needle_size), before _Start_at
+    if (_Hay_size == 0) { // no match possible
+        return static_cast<size_t>(-1);
+    }
+
+    const auto _Hay_start = (_STD min) (_Start_at, _Hay_size - 1);
+
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        using _Elem = typename _Traits::char_type;
+#if _VECTORIZED_FIND_LAST_OF
+        if constexpr (sizeof(_Elem) <= 2) {
+            if (!_STD _Is_constant_evaluated()) {
+                const size_t _Remaining_size = _Hay_start + 1;
+                if (_Remaining_size + _Needle_size >= _Threshold_find_first_of) { // same threshold for first/last
+                    return _Find_last_not_of_pos_vectorized(_Haystack, _Remaining_size, _Needle, _Needle_size);
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_FIND_LAST_OF ^^^
+
+        _String_bitmap<_Elem> _Matches;
+        if (_Matches._Mark(_Needle, _Needle + _Needle_size)) {
+            for (auto _Match_try = _Haystack + _Hay_start;; --_Match_try) {
+                if (!_Matches._Match(*_Match_try)) {
+                    return static_cast<size_t>(_Match_try - _Haystack); // found a match
+                }
+
+                if (_Match_try == _Haystack) {
+                    return static_cast<size_t>(-1); // at beginning, no more chance for match
+                }
+            }
+        }
+
+        // couldn't put one of the characters into the bitmap, fall back to the serial algorithm
+    }
+
+    for (auto _Match_try = _Haystack + _Hay_start;; --_Match_try) {
+        if (!_Traits::find(_Needle, _Needle_size, *_Match_try)) {
+            return static_cast<size_t>(_Match_try - _Haystack); // found a match
+        }
+
+        if (_Match_try == _Haystack) {
+            return static_cast<size_t>(-1); // at beginning, no more chance for match
+        }
+    }
+}
+
+template <class _Traits>
+constexpr size_t _Traits_rfind_not_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack,
+    const size_t _Hay_size, const size_t _Start_at, const _Traits_ch_t<_Traits> _Ch) noexcept {
+    // search [_Haystack, _Haystack + _Hay_size) for any value other than _Ch before _Start_at
+    if (_Hay_size == 0) { // no room for match
+        return static_cast<size_t>(-1);
+    }
+
+    const size_t _Actual_start_at = (_STD min) (_Start_at, _Hay_size - 1);
+
+#if _VECTORIZED_FIND_LAST
+    if constexpr (_Is_implementation_handled_char_traits<_Traits>) {
+        if (!_STD _Is_constant_evaluated()) {
+            return _STD _Find_last_not_ch_pos_vectorized(_Haystack, _Haystack + _Actual_start_at + 1, _Ch);
+        }
+    }
+#endif // ^^^ _VECTORIZED_FIND_LAST ^^^
+
+    for (auto _Match_try = _Haystack + _Actual_start_at;; --_Match_try) {
+        if (!_Traits::eq(*_Match_try, _Ch)) {
+            return static_cast<size_t>(_Match_try - _Haystack); // found a match
+        }
+
+        if (_Match_try == _Haystack) {
+            return static_cast<size_t>(-1); // at beginning, no more chance for match
+        }
+    }
+}
+
+template <class _Ty>
+constexpr bool _Is_EcharT = _Is_any_of_v<_Ty, char, wchar_t,
+#ifdef __cpp_char8_t
+    char8_t,
+#endif // defined(__cpp_char8_t)
+    char16_t, char32_t>;
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_string_view;
+
+template <class _Traits>
+class _String_view_iterator {
+public:
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Traits::char_type;
+    using difference_type   = ptrdiff_t;
+    using pointer           = const value_type*;
+    using reference         = const value_type&;
+
+    constexpr _String_view_iterator() noexcept = default;
+
+private:
+    friend basic_string_view<value_type, _Traits>;
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+    constexpr _String_view_iterator(const pointer _Data, const size_t _Size, const size_t _Off) noexcept
+        : _Mydata(_Data), _Mysize(_Size), _Myoff(_Off) {}
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+    constexpr explicit _String_view_iterator(const pointer _Ptr) noexcept : _Myptr(_Ptr) {}
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+
+public:
+    _NODISCARD constexpr reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mydata, "cannot dereference value-initialized string_view iterator");
+        _STL_VERIFY(_Myoff < _Mysize, "cannot dereference end string_view iterator");
+        return _Mydata[_Myoff];
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return *_Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    _NODISCARD constexpr pointer operator->() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mydata, "cannot dereference value-initialized string_view iterator");
+        _STL_VERIFY(_Myoff < _Mysize, "cannot dereference end string_view iterator");
+        return _Mydata + _Myoff;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return _Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    constexpr _String_view_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mydata, "cannot increment value-initialized string_view iterator");
+        _STL_VERIFY(_Myoff < _Mysize, "cannot increment string_view iterator past end");
+        ++_Myoff;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        ++_Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+        return *this;
+    }
+
+    constexpr _String_view_iterator operator++(int) noexcept {
+        _String_view_iterator _Tmp{*this};
+        ++*this;
+        return _Tmp;
+    }
+
+    constexpr _String_view_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mydata, "cannot decrement value-initialized string_view iterator");
+        _STL_VERIFY(_Myoff != 0, "cannot decrement string_view iterator before begin");
+        --_Myoff;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        --_Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+        return *this;
+    }
+
+    constexpr _String_view_iterator operator--(int) noexcept {
+        _String_view_iterator _Tmp{*this};
+        --*this;
+        return _Tmp;
+    }
+
+    constexpr void _Verify_offset(const difference_type _Off) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Off != 0) {
+            _STL_VERIFY(_Mydata, "cannot seek value-initialized string_view iterator");
+        }
+
+        if (_Off < 0) {
+            _STL_VERIFY(
+                _Myoff >= size_t{0} - static_cast<size_t>(_Off), "cannot seek string_view iterator before begin");
+        }
+
+        if (_Off > 0) {
+            _STL_VERIFY(_Mysize - _Myoff >= static_cast<size_t>(_Off), "cannot seek string_view iterator after end");
+        }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        (void) _Off;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    constexpr _String_view_iterator& operator+=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _Verify_offset(_Off);
+        _Myoff += static_cast<size_t>(_Off);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        _Myptr += _Off;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+
+        return *this;
+    }
+
+    _NODISCARD constexpr _String_view_iterator operator+(const difference_type _Off) const noexcept {
+        _String_view_iterator _Tmp{*this};
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend constexpr _String_view_iterator operator+(
+        const difference_type _Off, _String_view_iterator _Right) noexcept {
+        _Right += _Off;
+        return _Right;
+    }
+
+    constexpr _String_view_iterator& operator-=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Off != 0) {
+            _STL_VERIFY(_Mydata, "cannot seek value-initialized string_view iterator");
+        }
+
+        if (_Off > 0) {
+            _STL_VERIFY(_Myoff >= static_cast<size_t>(_Off), "cannot seek string_view iterator before begin");
+        }
+
+        if (_Off < 0) {
+            _STL_VERIFY(_Mysize - _Myoff >= size_t{0} - static_cast<size_t>(_Off),
+                "cannot seek string_view iterator after end");
+        }
+
+        _Myoff -= static_cast<size_t>(_Off);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        _Myptr -= _Off;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+
+        return *this;
+    }
+
+    _NODISCARD constexpr _String_view_iterator operator-(const difference_type _Off) const noexcept {
+        _String_view_iterator _Tmp{*this};
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD constexpr difference_type operator-(const _String_view_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mydata == _Right._Mydata && _Mysize == _Right._Mysize,
+            "cannot subtract incompatible string_view iterators");
+        return static_cast<difference_type>(_Myoff - _Right._Myoff);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return _Myptr - _Right._Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    _NODISCARD constexpr reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD constexpr bool operator==(const _String_view_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mydata == _Right._Mydata && _Mysize == _Right._Mysize,
+            "cannot compare incompatible string_view iterators for equality");
+        return _Myoff == _Right._Myoff;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return _Myptr == _Right._Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _String_view_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mydata == _Right._Mydata && _Mysize == _Right._Mysize,
+            "cannot compare incompatible string_view iterators");
+        return _Myoff <=> _Right._Myoff;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return _Myptr <=> _Right._Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD constexpr bool operator!=(const _String_view_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD constexpr bool operator<(const _String_view_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mydata == _Right._Mydata && _Mysize == _Right._Mysize,
+            "cannot compare incompatible string_view iterators");
+        return _Myoff < _Right._Myoff;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return _Myptr < _Right._Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    _NODISCARD constexpr bool operator>(const _String_view_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD constexpr bool operator<=(const _String_view_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD constexpr bool operator>=(const _String_view_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // !_HAS_CXX20
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+    friend constexpr void _Verify_range(const _String_view_iterator& _First, const _String_view_iterator& _Last) {
+        _STL_VERIFY(_First._Mydata == _Last._Mydata && _First._Mysize == _Last._Mysize,
+            "string_view iterators in range are from different views");
+        _STL_VERIFY(_First._Myoff <= _Last._Myoff, "string_view iterator range transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+    using _Prevent_inheriting_unwrap = _String_view_iterator;
+
+    _NODISCARD constexpr pointer _Unwrapped() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        return _Mydata + _Myoff;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return _Myptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _ITERATOR_DEBUG_LEVEL == 0;
+
+    constexpr void _Seek_to(pointer _It) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _Myoff = static_cast<size_t>(_It - _Mydata);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        _Myptr = _It;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+private:
+#if _ITERATOR_DEBUG_LEVEL >= 1
+    pointer _Mydata = nullptr;
+    size_t _Mysize  = 0;
+    size_t _Myoff   = 0;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+    pointer _Myptr = nullptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+};
+
+#if _HAS_CXX20
+template <class _Traits>
+struct pointer_traits<_String_view_iterator<_Traits>> {
+    using pointer         = _String_view_iterator<_Traits>;
+    using element_type    = const pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer& _Iter) noexcept {
+        return _Iter._Unwrapped();
+    }
+};
+#endif // _HAS_CXX20
+
+#pragma warning(push)
+// Invalid annotation: 'NullTerminated' property may only be used on buffers whose elements are of integral or pointer
+// type
+#pragma warning(disable : 6510)
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_string_view { // wrapper for any kind of contiguous character buffer
+public:
+    static_assert(is_same_v<_Elem, typename _Traits::char_type>,
+        "Bad char_traits for basic_string_view; N4950 [string.view.template.general]/1 "
+        "\"The program is ill-formed if traits::char_type is not the same type as charT.\"");
+
+    static_assert(!is_array_v<_Elem> && is_trivially_copyable_v<_Elem> && is_trivially_default_constructible_v<_Elem>
+                      && is_standard_layout_v<_Elem>,
+        "The character type of basic_string_view must be a non-array trivially copyable standard-layout type T where "
+        "is_trivially_default_constructible_v<T> is true. See N5001 [strings.general]/1.");
+
+    using traits_type            = _Traits;
+    using value_type             = _Elem;
+    using pointer                = _Elem*;
+    using const_pointer          = const _Elem*;
+    using reference              = _Elem&;
+    using const_reference        = const _Elem&;
+    using const_iterator         = _String_view_iterator<_Traits>;
+    using iterator               = const_iterator;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+    using reverse_iterator       = const_reverse_iterator;
+    using size_type              = size_t;
+    using difference_type        = ptrdiff_t;
+
+    static constexpr auto npos{static_cast<size_type>(-1)};
+
+    constexpr basic_string_view() noexcept : _Mydata(), _Mysize(0) {}
+
+    constexpr basic_string_view(const basic_string_view&) noexcept            = default;
+    constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;
+
+    /* implicit */ constexpr basic_string_view(_In_z_ const const_pointer _Ntcts) noexcept // strengthened
+        : _Mydata(_Ntcts), _Mysize(_Traits::length(_Ntcts)) {}
+
+#if _HAS_CXX23
+    basic_string_view(nullptr_t) = delete;
+#endif // _HAS_CXX23
+
+    constexpr basic_string_view(
+        _In_reads_(_Count) const const_pointer _Cts, const size_type _Count) noexcept // strengthened
+        : _Mydata(_Cts), _Mysize(_Count) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Count == 0 || _Cts, "cannot construct a string_view from a null pointer and a non-zero size");
+#endif
+    }
+
+#if _HAS_CXX20
+    template <contiguous_iterator _Iter, sized_sentinel_for<_Iter> _Sent>
+        requires (is_same_v<iter_value_t<_Iter>, _Elem> && !is_convertible_v<_Sent, size_type>)
+    constexpr basic_string_view(_Iter _First, _Sent _Last) noexcept(noexcept(_Last - _First)) // strengthened
+        : _Mydata(_STD to_address(_First)), _Mysize(static_cast<size_type>(_Last - _First)) {}
+
+#if _HAS_CXX23
+    template <class _Range>
+        requires (!same_as<remove_cvref_t<_Range>, basic_string_view> && _RANGES contiguous_range<_Range>
+                     && _RANGES sized_range<_Range> && same_as<_RANGES range_value_t<_Range>, _Elem>
+                     && !is_convertible_v<_Range, const _Elem*>
+                     && !requires(
+                         remove_cvref_t<_Range>& _Rng) { _Rng.operator _STD basic_string_view<_Elem, _Traits>(); })
+    constexpr explicit basic_string_view(_Range&& _Rng)
+        noexcept(noexcept(_RANGES data(_Rng)) && noexcept(_RANGES size(_Rng))) // strengthened
+        : _Mydata(_RANGES data(_Rng)), _Mysize(static_cast<size_t>(_RANGES size(_Rng))) {}
+#endif // _HAS_CXX23
+#endif // _HAS_CXX20
+
+    _NODISCARD constexpr const_iterator begin() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        return const_iterator(_Mydata, _Mysize, 0);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return const_iterator(_Mydata);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    _NODISCARD constexpr const_iterator end() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        return const_iterator(_Mydata, _Mysize, _Mysize);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return const_iterator(_Mydata + _Mysize);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    _NODISCARD constexpr const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD constexpr const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD constexpr const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator{end()};
+    }
+
+    _NODISCARD constexpr const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator{begin()};
+    }
+
+    _NODISCARD constexpr const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD constexpr const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    constexpr const_pointer _Unchecked_begin() const noexcept {
+        return _Mydata;
+    }
+
+    constexpr const_pointer _Unchecked_end() const noexcept {
+        return _Mydata + _Mysize;
+    }
+
+    _NODISCARD constexpr size_type size() const noexcept {
+        return _Mysize;
+    }
+
+    _NODISCARD constexpr size_type length() const noexcept {
+        return _Mysize;
+    }
+
+    _NODISCARD constexpr bool empty() const noexcept {
+        return _Mysize == 0;
+    }
+
+    _NODISCARD constexpr const_pointer data() const noexcept {
+        return _Mydata;
+    }
+
+    _NODISCARD constexpr size_type max_size() const noexcept {
+        // bound to PTRDIFF_MAX to make end() - begin() well defined (also makes room for npos)
+        // bound to static_cast<size_t>(-1) / sizeof(_Elem) by address space limits
+        return (_STD min) (static_cast<size_t>(PTRDIFF_MAX), static_cast<size_t>(-1) / sizeof(_Elem));
+    }
+
+    _NODISCARD constexpr const_reference operator[](const size_type _Off) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING_VIEW || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off < _Mysize, "string_view subscript out of range");
+#endif
+
+        // CodeQL [SM01954] This index is optionally validated above.
+        return _Mydata[_Off];
+    }
+
+    _NODISCARD constexpr const_reference at(const size_type _Off) const {
+        // get the character at _Off or throw if that is out of range
+        _Check_offset_exclusive(_Off);
+        return _Mydata[_Off];
+    }
+
+    _NODISCARD constexpr const_reference front() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING_VIEW || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize != 0, "front() called on empty string_view");
+#endif
+
+        return _Mydata[0];
+    }
+
+    _NODISCARD constexpr const_reference back() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING_VIEW || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize != 0, "back() called on empty string_view");
+#endif
+
+        return _Mydata[_Mysize - 1];
+    }
+
+    constexpr void remove_prefix(const size_type _Count) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING_VIEW || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize >= _Count, "cannot remove_prefix() larger than string_view size");
+#endif
+
+        _Mydata += _Count;
+        _Mysize -= _Count;
+    }
+
+    constexpr void remove_suffix(const size_type _Count) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING_VIEW || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize >= _Count, "cannot remove_suffix() larger than string_view size");
+#endif
+
+        _Mysize -= _Count;
+    }
+
+    constexpr void swap(basic_string_view& _Other) noexcept {
+        const basic_string_view _Tmp{_Other}; // note: std::swap is not constexpr before C++20
+        _Other = *this;
+        *this  = _Tmp;
+    }
+
+    _CONSTEXPR20 size_type copy(
+        _Out_writes_(_Count) _Elem* const _Ptr, size_type _Count, const size_type _Off = 0) const {
+        // copy [_Off, _Off + Count) to [_Ptr, _Ptr + _Count)
+        _Check_offset(_Off);
+        _Count = _Clamp_suffix_size(_Off, _Count);
+        _Traits::copy(_Ptr, _Mydata + _Off, _Count);
+        return _Count;
+    }
+
+    _Pre_satisfies_(_Dest_size >= _Count) _CONSTEXPR20 size_type
+        _Copy_s(_Out_writes_all_(_Dest_size) _Elem* const _Dest, const size_type _Dest_size, size_type _Count,
+            const size_type _Off = 0) const {
+        // copy [_Off, _Off + _Count) to [_Dest, _Dest + _Count)
+        _Check_offset(_Off);
+        _Count = _Clamp_suffix_size(_Off, _Count);
+        _Traits::_Copy_s(_Dest, _Dest_size, _Mydata + _Off, _Count);
+        return _Count;
+    }
+
+    _NODISCARD constexpr basic_string_view substr(const size_type _Off = 0, size_type _Count = npos) const {
+        // return a new basic_string_view moved forward by _Off and trimmed to _Count elements
+        _Check_offset(_Off);
+        _Count = _Clamp_suffix_size(_Off, _Count);
+        return basic_string_view(_Mydata + _Off, _Count);
+    }
+
+    constexpr bool _Equal(const basic_string_view _Right) const noexcept {
+        return _Traits_equal<_Traits>(_Mydata, _Mysize, _Right._Mydata, _Right._Mysize);
+    }
+
+    _NODISCARD constexpr int compare(const basic_string_view _Right) const noexcept {
+        return _Traits_compare<_Traits>(_Mydata, _Mysize, _Right._Mydata, _Right._Mysize);
+    }
+
+    _NODISCARD constexpr int compare(const size_type _Off, const size_type _Nx, const basic_string_view _Right) const {
+        // compare [_Off, _Off + _Nx) with _Right
+        return substr(_Off, _Nx).compare(_Right);
+    }
+
+    _NODISCARD constexpr int compare(const size_type _Off, const size_type _Nx, const basic_string_view _Right,
+        const size_type _Roff, const size_type _Count) const {
+        // compare [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        return substr(_Off, _Nx).compare(_Right.substr(_Roff, _Count));
+    }
+
+    _NODISCARD constexpr int compare(_In_z_ const _Elem* const _Ptr) const noexcept /* strengthened */ {
+        // compare [0, _Mysize) with [_Ptr, <null>)
+        return compare(basic_string_view(_Ptr));
+    }
+
+    _NODISCARD constexpr int compare(const size_type _Off, const size_type _Nx, _In_z_ const _Elem* const _Ptr) const {
+        // compare [_Off, _Off + _Nx) with [_Ptr, <null>)
+        return substr(_Off, _Nx).compare(basic_string_view(_Ptr));
+    }
+
+    _NODISCARD constexpr int compare(const size_type _Off, const size_type _Nx,
+        _In_reads_(_Count) const _Elem* const _Ptr, const size_type _Count) const {
+        // compare [_Off, _Off + _Nx) with [_Ptr, _Ptr + _Count)
+        return substr(_Off, _Nx).compare(basic_string_view(_Ptr, _Count));
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr bool starts_with(const basic_string_view _Right) const noexcept {
+        const auto _Rightsize = _Right._Mysize;
+        if (_Mysize < _Rightsize) {
+            return false;
+        }
+        return _Traits::compare(_Mydata, _Right._Mydata, _Rightsize) == 0;
+    }
+
+    _NODISCARD constexpr bool starts_with(const _Elem _Right) const noexcept {
+        return !empty() && _Traits::eq(front(), _Right);
+    }
+
+    _NODISCARD constexpr bool starts_with(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return starts_with(basic_string_view(_Right));
+    }
+
+    _NODISCARD constexpr bool ends_with(const basic_string_view _Right) const noexcept {
+        const auto _Rightsize = _Right._Mysize;
+        if (_Mysize < _Rightsize) {
+            return false;
+        }
+        return _Traits::compare(_Mydata + (_Mysize - _Rightsize), _Right._Mydata, _Rightsize) == 0;
+    }
+
+    _NODISCARD constexpr bool ends_with(const _Elem _Right) const noexcept {
+        return !empty() && _Traits::eq(back(), _Right);
+    }
+
+    _NODISCARD constexpr bool ends_with(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return ends_with(basic_string_view(_Right));
+    }
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+    _NODISCARD constexpr bool contains(const basic_string_view _Right) const noexcept {
+        return find(_Right) != npos;
+    }
+
+    _NODISCARD constexpr bool contains(const _Elem _Right) const noexcept {
+        return find(_Right) != npos;
+    }
+
+    _NODISCARD constexpr bool contains(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return find(_Right) != npos;
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD constexpr size_type find(const basic_string_view _Right, const size_type _Off = 0) const noexcept {
+        // look for _Right beginning at or after _Off
+        return _Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize);
+    }
+
+    _NODISCARD constexpr size_type find(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for _Ch at or after _Off
+        return _Traits_find_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
+    }
+
+    _NODISCARD constexpr size_type find(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for [_Ptr, _Ptr + _Count) beginning at or after _Off
+        return _Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count);
+    }
+
+    _NODISCARD constexpr size_type find(_In_z_ const _Elem* const _Ptr, const size_type _Off = 0) const noexcept
+    /* strengthened */ {
+        // look for [_Ptr, <null>) beginning at or after _Off
+        return _Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD constexpr size_type rfind(const basic_string_view _Right, const size_type _Off = npos) const noexcept {
+        // look for _Right beginning before _Off
+        return _Traits_rfind<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize);
+    }
+
+    _NODISCARD constexpr size_type rfind(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for _Ch before _Off
+        return _Traits_rfind_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
+    }
+
+    _NODISCARD constexpr size_type rfind(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for [_Ptr, _Ptr + _Count) beginning before _Off
+        return _Traits_rfind<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count);
+    }
+
+    _NODISCARD constexpr size_type rfind(_In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept
+    /* strengthened */ {
+        // look for [_Ptr, <null>) beginning before _Off
+        return _Traits_rfind<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD constexpr size_type find_first_of(const basic_string_view _Right,
+        const size_type _Off = 0) const noexcept { // look for one of _Right at or after _Off
+        return _Traits_find_first_of<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize);
+    }
+
+    _NODISCARD constexpr size_type find_first_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for _Ch at or after _Off
+        return _Traits_find_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
+    }
+
+    _NODISCARD constexpr size_type find_first_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, _Ptr + _Count) at or after _Off
+        return _Traits_find_first_of<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count);
+    }
+
+    _NODISCARD constexpr size_type find_first_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = 0) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, <null>) at or after _Off
+        return _Traits_find_first_of<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD constexpr size_type find_last_of(const basic_string_view _Right,
+        const size_type _Off = npos) const noexcept { // look for one of _Right before _Off
+        return _Traits_find_last_of<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize);
+    }
+
+    _NODISCARD constexpr size_type find_last_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for _Ch before _Off
+        return _Traits_rfind_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
+    }
+
+    _NODISCARD constexpr size_type find_last_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, _Ptr + _Count) before _Off
+        return _Traits_find_last_of<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count);
+    }
+
+    _NODISCARD constexpr size_type find_last_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, <null>) before _Off
+        return _Traits_find_last_of<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD constexpr size_type find_first_not_of(const basic_string_view _Right,
+        const size_type _Off = 0) const noexcept { // look for none of _Right at or after _Off
+        return _Traits_find_first_not_of<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize);
+    }
+
+    _NODISCARD constexpr size_type find_first_not_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for any value other than _Ch at or after _Off
+        return _Traits_find_not_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
+    }
+
+    _NODISCARD constexpr size_type find_first_not_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, _Ptr + _Count) at or after _Off
+        return _Traits_find_first_not_of<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count);
+    }
+
+    _NODISCARD constexpr size_type find_first_not_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = 0) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, <null>) at or after _Off
+        return _Traits_find_first_not_of<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD constexpr size_type find_last_not_of(const basic_string_view _Right,
+        const size_type _Off = npos) const noexcept { // look for none of _Right before _Off
+        return _Traits_find_last_not_of<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize);
+    }
+
+    _NODISCARD constexpr size_type find_last_not_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for any value other than _Ch before _Off
+        return _Traits_rfind_not_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
+    }
+
+    _NODISCARD constexpr size_type find_last_not_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, _Ptr + _Count) before _Off
+        return _Traits_find_last_not_of<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count);
+    }
+
+    _NODISCARD constexpr size_type find_last_not_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, <null>) before _Off
+        return _Traits_find_last_not_of<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD constexpr bool _Starts_with(const basic_string_view _View) const noexcept {
+        return _Mysize >= _View._Mysize && _Traits::compare(_Mydata, _View._Mydata, _View._Mysize) == 0;
+    }
+
+private:
+    constexpr void _Check_offset(const size_type _Off) const { // checks whether _Off is in the bounds of [0, size()]
+        if (_Mysize < _Off) {
+            _Xran();
+        }
+    }
+
+    constexpr void _Check_offset_exclusive(const size_type _Off) const {
+        // checks whether _Off is in the bounds of [0, size())
+        if (_Mysize <= _Off) {
+            _Xran();
+        }
+    }
+
+    constexpr size_type _Clamp_suffix_size(const size_type _Off, const size_type _Size) const noexcept {
+        // trims _Size to the longest it can be assuming a string at/after _Off
+        return (_STD min) (_Size, _Mysize - _Off);
+    }
+
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid string_view position");
+    }
+
+    const_pointer _Mydata;
+    size_type _Mysize;
+};
+
+#pragma warning(pop)
+
+#if _HAS_CXX20
+template <contiguous_iterator _Iter, sized_sentinel_for<_Iter> _Sent>
+basic_string_view(_Iter, _Sent) -> basic_string_view<iter_value_t<_Iter>>;
+
+#if _HAS_CXX23
+template <_RANGES contiguous_range _Range>
+basic_string_view(_Range&&) -> basic_string_view<_RANGES range_value_t<_Range>>;
+#endif // _HAS_CXX23
+
+namespace ranges {
+    template <class _Elem, class _Traits>
+    constexpr bool enable_view<basic_string_view<_Elem, _Traits>> = true;
+    template <class _Elem, class _Traits>
+    constexpr bool enable_borrowed_range<basic_string_view<_Elem, _Traits>> = true;
+} // namespace ranges
+
+_EXPORT_STD template <class _Elem, class _Traits>
+_NODISCARD constexpr bool operator==(const basic_string_view<_Elem, _Traits> _Lhs,
+    const type_identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return _Lhs._Equal(_Rhs);
+}
+
+template <class _Traits>
+struct _Get_comparison_category {
+    using type = weak_ordering;
+};
+
+template <class _Traits>
+    requires requires { typename _Traits::comparison_category; }
+struct _Get_comparison_category<_Traits> {
+    using type = _Traits::comparison_category;
+
+    static_assert(_Is_any_of_v<type, partial_ordering, weak_ordering, strong_ordering>,
+        "N4971 [string.view.comparison]/4: Mandates: R denotes a comparison category type.");
+};
+
+template <class _Traits>
+using _Get_comparison_category_t = _Get_comparison_category<_Traits>::type;
+
+_EXPORT_STD template <class _Elem, class _Traits>
+_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(const basic_string_view<_Elem, _Traits> _Lhs,
+    const type_identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return static_cast<_Get_comparison_category_t<_Traits>>(_Lhs.compare(_Rhs) <=> 0);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Elem, class _Traits>
+_NODISCARD constexpr bool operator==(
+    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs._Equal(_Rhs);
+}
+
+template <class _Elem, class _Traits, int = 1> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator==(
+    const _Identity_t<basic_string_view<_Elem, _Traits>> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs._Equal(_Rhs);
+}
+
+template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator==(
+    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return _Lhs._Equal(_Rhs);
+}
+
+template <class _Elem, class _Traits>
+_NODISCARD constexpr bool operator!=(
+    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return !_Lhs._Equal(_Rhs);
+}
+
+template <class _Elem, class _Traits, int = 1> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator!=(
+    const _Identity_t<basic_string_view<_Elem, _Traits>> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return !_Lhs._Equal(_Rhs);
+}
+
+template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator!=(
+    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return !_Lhs._Equal(_Rhs);
+}
+
+template <class _Elem, class _Traits>
+_NODISCARD constexpr bool operator<(
+    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) < 0;
+}
+
+template <class _Elem, class _Traits, int = 1> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator<(
+    const _Identity_t<basic_string_view<_Elem, _Traits>> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) < 0;
+}
+
+template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator<(
+    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) < 0;
+}
+
+template <class _Elem, class _Traits>
+_NODISCARD constexpr bool operator>(
+    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) > 0;
+}
+
+template <class _Elem, class _Traits, int = 1> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator>(
+    const _Identity_t<basic_string_view<_Elem, _Traits>> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) > 0;
+}
+
+template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator>(
+    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) > 0;
+}
+
+template <class _Elem, class _Traits>
+_NODISCARD constexpr bool operator<=(
+    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) <= 0;
+}
+
+template <class _Elem, class _Traits, int = 1> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator<=(
+    const _Identity_t<basic_string_view<_Elem, _Traits>> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) <= 0;
+}
+
+template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator<=(
+    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) <= 0;
+}
+
+template <class _Elem, class _Traits>
+_NODISCARD constexpr bool operator>=(
+    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) >= 0;
+}
+
+template <class _Elem, class _Traits, int = 1> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator>=(
+    const _Identity_t<basic_string_view<_Elem, _Traits>> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) >= 0;
+}
+
+template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+_NODISCARD constexpr bool operator>=(
+    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return _Lhs.compare(_Rhs) >= 0;
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD using string_view = basic_string_view<char>;
+#ifdef __cpp_lib_char8_t
+_EXPORT_STD using u8string_view = basic_string_view<char8_t>;
+#endif // defined(__cpp_lib_char8_t)
+_EXPORT_STD using u16string_view = basic_string_view<char16_t>;
+_EXPORT_STD using u32string_view = basic_string_view<char32_t>;
+_EXPORT_STD using wstring_view   = basic_string_view<wchar_t>;
+
+template <class _Elem>
+struct hash<basic_string_view<_Elem>> : _Conditionally_enabled_hash<basic_string_view<_Elem>, _Is_EcharT<_Elem>> {
+    _NODISCARD static size_t _Do_hash(const basic_string_view<_Elem> _Keyval) noexcept {
+        return _Hash_array_representation(_Keyval.data(), _Keyval.size());
+    }
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& operator<<(
+    basic_ostream<_Elem, _Traits>& _Ostr, const basic_string_view<_Elem, _Traits> _Str) {
+    return _Insert_string(_Ostr, _Str.data(), _Str.size());
+}
+
+inline namespace literals {
+    inline namespace string_view_literals {
+        _EXPORT_STD _NODISCARD constexpr string_view operator""sv(const char* _Str, size_t _Len) noexcept {
+            return string_view(_Str, _Len);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr wstring_view operator""sv(const wchar_t* _Str, size_t _Len) noexcept {
+            return wstring_view(_Str, _Len);
+        }
+
+#ifdef __cpp_char8_t
+        _EXPORT_STD _NODISCARD constexpr basic_string_view<char8_t> operator""sv(
+            const char8_t* _Str, size_t _Len) noexcept {
+            return basic_string_view<char8_t>(_Str, _Len);
+        }
+#endif // defined(__cpp_char8_t)
+
+        _EXPORT_STD _NODISCARD constexpr u16string_view operator""sv(const char16_t* _Str, size_t _Len) noexcept {
+            return u16string_view(_Str, _Len);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr u32string_view operator""sv(const char32_t* _Str, size_t _Len) noexcept {
+            return u32string_view(_Str, _Len);
+        }
+    } // namespace string_view_literals
+} // namespace literals
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <class _Elem, class _Traits>
+constexpr bool _Equivalence_is_equality_impl<basic_string_view<_Elem, _Traits>> =
+    _Is_implementation_handled_char_traits<_Traits>;
+#endif // _HAS_CXX23
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_STRING_VIEW_HPP
diff --git a/msvc-stl/stl/inc/__msvc_system_error_abi.hpp b/msvc-stl/stl/inc/__msvc_system_error_abi.hpp
new file mode 100644
index 0000000..1736392
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_system_error_abi.hpp
@@ -0,0 +1,40 @@
+// __msvc_system_error_abi.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_SYSTEM_ERROR_ABI_HPP
+#define __MSVC_SYSTEM_ERROR_ABI_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstddef>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#ifdef _M_CEE_PURE
+#define __CLRCALL_PURE_OR_STDCALL __clrcall
+#else
+#define __CLRCALL_PURE_OR_STDCALL __stdcall
+#endif
+
+extern "C" {
+_NODISCARD size_t __CLRCALL_PURE_OR_STDCALL __std_get_string_size_without_trailing_whitespace(
+    const char* _Str, size_t _Size) noexcept;
+
+_NODISCARD size_t __CLRCALL_PURE_OR_STDCALL __std_system_error_allocate_message(
+    unsigned long _Message_id, char** _Ptr_str) noexcept;
+void __CLRCALL_PURE_OR_STDCALL __std_system_error_deallocate_message(char* _Str) noexcept;
+} // extern "C"
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_SYSTEM_ERROR_ABI_HPP
diff --git a/msvc-stl/stl/inc/__msvc_threads_core.hpp b/msvc-stl/stl/inc/__msvc_threads_core.hpp
new file mode 100644
index 0000000..605af7d
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_threads_core.hpp
@@ -0,0 +1,102 @@
+// __msvc_threads_core.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_THREADS_CORE_HPP
+#define __MSVC_THREADS_CORE_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+using _Thrd_id_t = unsigned int;
+struct _Thrd_t { // thread identifier for Win32
+    void* _Hnd; // Win32 HANDLE
+    _Thrd_id_t _Id;
+};
+
+using _Smtx_t = void*;
+
+enum class _Thrd_result : int { _Success, _Nomem, _Timedout, _Busy, _Error };
+
+struct _Stl_critical_section {
+    void* _Unused       = nullptr; // TRANSITION, ABI: was the vptr
+    _Smtx_t _M_srw_lock = nullptr;
+};
+
+struct _Mtx_internal_imp_t {
+// TRANSITION, ABI: We should directly store _M_srw_lock above.
+#ifdef _WIN64
+    static constexpr size_t _Critical_section_size = 64;
+#else // ^^^ 64-bit / 32-bit vvv
+    static constexpr size_t _Critical_section_size = 36;
+#endif // ^^^ 32-bit ^^^
+
+    int _Type{};
+    union {
+        _Stl_critical_section _Critical_section{};
+        // TRANSITION, VSO-1659383 and VSO-2616030, use _Aligned_storage_t instead of alignas until /clr is fixed
+        _STD _Aligned_storage_t<_Critical_section_size, alignof(void*)> _Cs_storage;
+    };
+    long _Thread_id{};
+    int _Count{};
+};
+
+using _Mtx_t = _Mtx_internal_imp_t*;
+
+struct _Stl_condition_variable {
+    void* _Unused = nullptr; // TRANSITION, ABI: was the vptr
+    void* _Win_cv = nullptr;
+};
+
+#pragma warning(push)
+#pragma warning(disable : 26495) // Variable 'meow' is uninitialized. Always initialize a member variable (type.6).
+struct _Cnd_internal_imp_t {
+// TRANSITION, ABI: We should directly store _Win_cv above.
+#ifdef _WIN64
+    static constexpr size_t _Cnd_internal_imp_size = 72;
+#else // ^^^ 64-bit / 32-bit vvv
+    static constexpr size_t _Cnd_internal_imp_size = 40;
+#endif // ^^^ 32-bit ^^^
+
+    union {
+        _Stl_condition_variable _Stl_cv{};
+        // TRANSITION, VSO-1659383 and VSO-2616030, use _Aligned_storage_t instead of alignas until /clr is fixed
+        _STD _Aligned_storage_t<_Cnd_internal_imp_size, alignof(void*)> _Cv_storage;
+    };
+};
+#pragma warning(pop)
+
+using _Cnd_t = _Cnd_internal_imp_t*;
+} // extern "C"
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_THREADS_CORE_HPP
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/msvc-stl/stl/inc/__msvc_tzdb.hpp b/msvc-stl/stl/inc/__msvc_tzdb.hpp
new file mode 100644
index 0000000..ed9198e
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_tzdb.hpp
@@ -0,0 +1,168 @@
+// __msvc_tzdb.hpp internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_TZDB_HPP
+#define __MSVC_TZDB_HPP
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+
+using __std_tzdb_epoch_milli = double;
+
+struct __std_tzdb_leap_info {
+    uint16_t _Year;
+    uint16_t _Month;
+    uint16_t _Day;
+    uint16_t _Hour;
+    uint16_t _Negative;
+    uint16_t _Reserved;
+};
+
+enum class __std_tzdb_error {
+    _Success   = 0,
+    _Win_error = 1,
+    _Icu_error = 2,
+};
+
+struct __std_tzdb_time_zones_info {
+    __std_tzdb_error _Err;
+    // timezone data version currently being used
+    const char* _Version;
+    size_t _Num_time_zones;
+    // ordered list of null-terminated time_zone/time_zone_link names
+    const char** _Names;
+    // contains corresponding entry for every name, if:
+    //    (_Links[i] == nullptr) then _Names[i] is a time_zone
+    //    (_Links[i] != nullptr) then _Names[i] is a time_zone_link to time_zone with name _Links[i]
+    const char** _Links;
+};
+
+struct __std_tzdb_current_zone_info {
+    __std_tzdb_error _Err;
+    const char* _Tz_name;
+};
+
+struct __std_tzdb_sys_info {
+    __std_tzdb_error _Err;
+    __std_tzdb_epoch_milli _Begin;
+    __std_tzdb_epoch_milli _End;
+    int32_t _Offset;
+    int32_t _Save;
+    const char* _Abbrev;
+};
+
+enum class __std_tzdb_sys_info_type : char {
+    // TRANSITION, ABI: In order to be compatible with existing object files which do not know about
+    // `__std_tzdb_sys_info_type`, the type is passed in the after-end byte of a string passed with its length to
+    // `__std_tzdb_get_sys_info`. Since older object files always pass the `.c_str()` of a `std::string`
+    // to that function, the after-end byte will always be '\0'.
+    _Full = '\0',
+    _Offset_only,
+    _Offset_and_range,
+};
+
+_NODISCARD __std_tzdb_time_zones_info* __stdcall __std_tzdb_get_time_zones() noexcept;
+void __stdcall __std_tzdb_delete_time_zones(__std_tzdb_time_zones_info* _Info) noexcept;
+
+_NODISCARD __std_tzdb_current_zone_info* __stdcall __std_tzdb_get_current_zone() noexcept;
+void __stdcall __std_tzdb_delete_current_zone(__std_tzdb_current_zone_info* _Info) noexcept;
+
+_NODISCARD __std_tzdb_sys_info* __stdcall __std_tzdb_get_sys_info(
+    const char* _Tz, size_t _Tz_len, __std_tzdb_epoch_milli _Local) noexcept;
+void __stdcall __std_tzdb_delete_sys_info(__std_tzdb_sys_info* _Info) noexcept;
+
+_NODISCARD __std_tzdb_leap_info* __stdcall __std_tzdb_get_leap_seconds(
+    size_t _Prev_ls_size, size_t* _Current_ls_size) noexcept;
+void __stdcall __std_tzdb_delete_leap_seconds(__std_tzdb_leap_info* _Info) noexcept;
+
+_NODISCARD void* __stdcall __std_calloc_crt(size_t _Count, size_t _Size) noexcept;
+void __stdcall __std_free_crt(void* _Ptr) noexcept;
+
+} // extern "C"
+
+_STD_BEGIN
+
+template <class _Ty>
+struct _Tzdb_deleter;
+
+template <>
+struct _Tzdb_deleter<__std_tzdb_time_zones_info> {
+    static void operator()(__std_tzdb_time_zones_info* _Info) noexcept {
+        __std_tzdb_delete_time_zones(_Info);
+    }
+};
+
+template <>
+struct _Tzdb_deleter<__std_tzdb_current_zone_info> {
+    static void operator()(__std_tzdb_current_zone_info* _Info) noexcept {
+        __std_tzdb_delete_current_zone(_Info);
+    }
+};
+
+template <>
+struct _Tzdb_deleter<__std_tzdb_sys_info> {
+    static void operator()(__std_tzdb_sys_info* _Info) noexcept {
+        __std_tzdb_delete_sys_info(_Info);
+    }
+};
+
+template <>
+struct _Tzdb_deleter<__std_tzdb_leap_info[]> {
+    static void operator()(__std_tzdb_leap_info* _Info) noexcept {
+        __std_tzdb_delete_leap_seconds(_Info);
+    }
+};
+
+template <class _Ty>
+class _Crt_allocator {
+public:
+    using value_type                             = _Ty;
+    using propagate_on_container_move_assignment = true_type;
+    using is_always_equal                        = true_type;
+
+    constexpr _Crt_allocator() noexcept = default;
+
+    constexpr _Crt_allocator(const _Crt_allocator&) noexcept = default;
+    template <class _Other>
+    constexpr _Crt_allocator(const _Crt_allocator<_Other>&) noexcept {}
+
+    _NODISCARD __declspec(allocator) _Ty* allocate(_CRT_GUARDOVERFLOW const size_t _Count) {
+        const auto _Ptr = __std_calloc_crt(_Count, sizeof(_Ty));
+        if (!_Ptr) {
+            _Xbad_alloc();
+        }
+        return static_cast<_Ty*>(_Ptr);
+    }
+
+    void deallocate(_Ty* const _Ptr, size_t) noexcept {
+        __std_free_crt(_Ptr);
+    }
+
+    template <class _Other>
+    _NODISCARD bool operator==(const _Crt_allocator<_Other>&) const noexcept {
+        return true;
+    }
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_TZDB_HPP
diff --git a/msvc-stl/stl/inc/__msvc_xlocinfo_types.hpp b/msvc-stl/stl/inc/__msvc_xlocinfo_types.hpp
new file mode 100644
index 0000000..837b1f4
--- /dev/null
+++ b/msvc-stl/stl/inc/__msvc_xlocinfo_types.hpp
@@ -0,0 +1,46 @@
+// __msvc_xlocinfo_types.hpp internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef __MSVC_XLOCINFO_TYPES_HPP
+#define __MSVC_XLOCINFO_TYPES_HPP
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_EXTERN_C_UNLESS_PURE
+
+struct _Collvec { // stuff needed by _Strcoll, etc.
+    unsigned int _Page; // UINT
+    wchar_t* _LocaleName;
+};
+
+struct _Ctypevec { // stuff needed by _Tolower, etc.
+    unsigned int _Page; // UINT
+    const short* _Table;
+    int _Delfl;
+    wchar_t* _LocaleName;
+};
+
+struct _Cvtvec { // stuff needed by _Mbrtowc, etc.
+    unsigned int _Page; // UINT
+    unsigned int _Mbcurmax;
+    int _Isclocale; // LCID == _CLOCALEHANDLE
+    unsigned char _Isleadbyte[32]; // 256 bits
+};
+
+_END_EXTERN_C_UNLESS_PURE
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // __MSVC_XLOCINFO_TYPES_HPP
diff --git a/msvc-stl/stl/inc/algorithm b/msvc-stl/stl/inc/algorithm
new file mode 100644
index 0000000..73e3b0d
--- /dev/null
+++ b/msvc-stl/stl/inc/algorithm
@@ -0,0 +1,12051 @@
+// algorithm standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _ALGORITHM_
+#define _ALGORITHM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_heap_algorithms.hpp>
+#include <__msvc_int128.hpp>
+#include <__msvc_minmax.hpp>
+#include <xmemory>
+
+#if _HAS_CXX23
+#include <optional>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("lifetimebound")
+#undef msvc
+#undef lifetimebound
+
+extern "C" {
+// The "noalias" attribute tells the compiler optimizer that pointers going into these hand-vectorized algorithms
+// won't be stored beyond the lifetime of the function, and that the function will only reference arrays denoted by
+// those pointers. The optimizer also assumes in that case that a pointer parameter is not returned to the caller via
+// the return value, so functions using "noalias" must usually return void. This attribute is valuable because these
+// functions are in native code objects that the compiler cannot analyze. In the absence of the noalias attribute, the
+// compiler has to assume that the denoted arrays are "globally address taken", and that any later calls to
+// unanalyzable routines may modify those arrays.
+
+#if _VECTORIZED_FIND_FIRST_OF
+const void* __stdcall __std_find_first_of_trivial_1(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+const void* __stdcall __std_find_first_of_trivial_2(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+const void* __stdcall __std_find_first_of_trivial_4(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+const void* __stdcall __std_find_first_of_trivial_8(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+#if _VECTORIZED_REVERSE_COPY
+__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_1(
+    const void* _First, const void* _Last, void* _Dest) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_2(
+    const void* _First, const void* _Last, void* _Dest) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_4(
+    const void* _First, const void* _Last, void* _Dest) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_8(
+    const void* _First, const void* _Last, void* _Dest) noexcept;
+#endif // ^^^ _VECTORIZED_REVERSE_COPY ^^^
+
+#if _VECTORIZED_MINMAX_ELEMENT
+_Min_max_element_t __stdcall __std_minmax_element_1i(const void* _First, const void* _Last) noexcept;
+_Min_max_element_t __stdcall __std_minmax_element_1u(const void* _First, const void* _Last) noexcept;
+_Min_max_element_t __stdcall __std_minmax_element_2i(const void* _First, const void* _Last) noexcept;
+_Min_max_element_t __stdcall __std_minmax_element_2u(const void* _First, const void* _Last) noexcept;
+_Min_max_element_t __stdcall __std_minmax_element_4i(const void* _First, const void* _Last) noexcept;
+_Min_max_element_t __stdcall __std_minmax_element_4u(const void* _First, const void* _Last) noexcept;
+#if _VECTORIZED_MINMAX_ELEMENT_64BIT_INT
+_Min_max_element_t __stdcall __std_minmax_element_8i(const void* _First, const void* _Last) noexcept;
+_Min_max_element_t __stdcall __std_minmax_element_8u(const void* _First, const void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT_64BIT_INT ^^^
+_Min_max_element_t __stdcall __std_minmax_element_f_(const void* _First, const void* _Last) noexcept;
+_Min_max_element_t __stdcall __std_minmax_element_d_(const void* _First, const void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+#if _VECTORIZED_MINMAX
+__declspec(noalias) _Min_max_1i __stdcall __std_minmax_1i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_1u __stdcall __std_minmax_1u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_2i __stdcall __std_minmax_2i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_2u __stdcall __std_minmax_2u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_4i __stdcall __std_minmax_4i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_4u __stdcall __std_minmax_4u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_8i __stdcall __std_minmax_8i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_8u __stdcall __std_minmax_8u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_f __stdcall __std_minmax_f(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* _First, const void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+
+#if _VECTORIZED_IS_SORTED_UNTIL
+const void* __stdcall __std_is_sorted_until_1i(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_1u(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_2i(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_2u(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_4i(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_4u(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_8i(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_8u(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_f(const void* _First, const void* _Last, bool _Greater) noexcept;
+const void* __stdcall __std_is_sorted_until_d(const void* _First, const void* _Last, bool _Greater) noexcept;
+#endif // ^^^ _VECTORIZED_IS_SORTED_UNTIL ^^^
+
+#if _VECTORIZED_INCLUDES
+__declspec(noalias) bool __stdcall __std_includes_less_1i(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+__declspec(noalias) bool __stdcall __std_includes_less_1u(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+__declspec(noalias) bool __stdcall __std_includes_less_2i(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+__declspec(noalias) bool __stdcall __std_includes_less_2u(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+__declspec(noalias) bool __stdcall __std_includes_less_4i(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+__declspec(noalias) bool __stdcall __std_includes_less_4u(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+__declspec(noalias) bool __stdcall __std_includes_less_8i(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+__declspec(noalias) bool __stdcall __std_includes_less_8u(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+#endif // ^^^ _VECTORIZED_INCLUDES ^^^
+
+#if _VECTORIZED_REPLACE
+// TRANSITION, DevCom-10610477
+__declspec(noalias) void __stdcall __std_replace_4(
+    void* _First, void* _Last, uint32_t _Old_val, uint32_t _New_val) noexcept;
+__declspec(noalias) void __stdcall __std_replace_8(
+    void* _First, void* _Last, uint64_t _Old_val, uint64_t _New_val) noexcept;
+#endif // ^^^ _VECTORIZED_REPLACE ^^^
+
+#if _VECTORIZED_REPLACE_COPY
+__declspec(noalias) void __stdcall __std_replace_copy_1(
+    const void* _First, const void* _Last, void* _Dest, uint8_t _Old_val, uint8_t _New_val) noexcept;
+__declspec(noalias) void __stdcall __std_replace_copy_2(
+    const void* _First, const void* _Last, void* _Dest, uint16_t _Old_val, uint16_t _New_val) noexcept;
+__declspec(noalias) void __stdcall __std_replace_copy_4(
+    const void* _First, const void* _Last, void* _Dest, uint32_t _Old_val, uint32_t _New_val) noexcept;
+__declspec(noalias) void __stdcall __std_replace_copy_8(
+    const void* _First, const void* _Last, void* _Dest, uint64_t _Old_val, uint64_t _New_val) noexcept;
+#endif // ^^^ _VECTORIZED_REPLACE_COPY ^^^
+
+#if _VECTORIZED_SEARCH_N
+const void* __stdcall __std_search_n_1(const void* _First, const void* _Last, size_t _Count, uint8_t _Value) noexcept;
+const void* __stdcall __std_search_n_2(const void* _First, const void* _Last, size_t _Count, uint16_t _Value) noexcept;
+const void* __stdcall __std_search_n_4(const void* _First, const void* _Last, size_t _Count, uint32_t _Value) noexcept;
+const void* __stdcall __std_search_n_8(const void* _First, const void* _Last, size_t _Count, uint64_t _Value) noexcept;
+#endif // ^^^ _VECTORIZED_SEARCH_N ^^^
+
+#if _VECTORIZED_REMOVE_COPY
+void* __stdcall __std_remove_copy_1(const void* _First, const void* _Last, void* _Out, uint8_t _Val) noexcept;
+void* __stdcall __std_remove_copy_2(const void* _First, const void* _Last, void* _Out, uint16_t _Val) noexcept;
+void* __stdcall __std_remove_copy_4(const void* _First, const void* _Last, void* _Out, uint32_t _Val) noexcept;
+void* __stdcall __std_remove_copy_8(const void* _First, const void* _Last, void* _Out, uint64_t _Val) noexcept;
+#endif // ^^^ _VECTORIZED_REMOVE_COPY ^^^
+
+#if _VECTORIZED_UNIQUE
+void* __stdcall __std_unique_1(void* _First, void* _Last) noexcept;
+void* __stdcall __std_unique_2(void* _First, void* _Last) noexcept;
+void* __stdcall __std_unique_4(void* _First, void* _Last) noexcept;
+void* __stdcall __std_unique_8(void* _First, void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_UNIQUE ^^^
+
+#if _VECTORIZED_UNIQUE_COPY
+void* __stdcall __std_unique_copy_1(const void* _First, const void* _Last, void* _Dest) noexcept;
+void* __stdcall __std_unique_copy_2(const void* _First, const void* _Last, void* _Dest) noexcept;
+void* __stdcall __std_unique_copy_4(const void* _First, const void* _Last, void* _Dest) noexcept;
+void* __stdcall __std_unique_copy_8(const void* _First, const void* _Last, void* _Dest) noexcept;
+#endif // ^^^ _VECTORIZED_UNIQUE_COPY ^^^
+
+} // extern "C"
+
+_STD_BEGIN
+
+#if _VECTORIZED_FIND_FIRST_OF
+template <class _Ty1, class _Ty2>
+_Ty1* _Find_first_of_vectorized(
+    _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, _Ty2* const _Last2) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Ty1) == sizeof(_Ty2));
+    if constexpr (sizeof(_Ty1) == 1) {
+        return const_cast<_Ty1*>(
+            static_cast<const _Ty1*>(::__std_find_first_of_trivial_1(_First1, _Last1, _First2, _Last2)));
+    } else if constexpr (sizeof(_Ty1) == 2) {
+        return const_cast<_Ty1*>(
+            static_cast<const _Ty1*>(::__std_find_first_of_trivial_2(_First1, _Last1, _First2, _Last2)));
+    } else if constexpr (sizeof(_Ty1) == 4) {
+        return const_cast<_Ty1*>(
+            static_cast<const _Ty1*>(::__std_find_first_of_trivial_4(_First1, _Last1, _First2, _Last2)));
+    } else if constexpr (sizeof(_Ty1) == 8) {
+        return const_cast<_Ty1*>(
+            static_cast<const _Ty1*>(::__std_find_first_of_trivial_8(_First1, _Last1, _First2, _Last2)));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+#if _VECTORIZED_REVERSE_COPY
+template <size_t _Nx>
+__declspec(noalias) void _Reverse_copy_vectorized(const void* _First, const void* _Last, void* _Dest) noexcept {
+    if constexpr (_Nx == 1) {
+        ::__std_reverse_copy_trivially_copyable_1(_First, _Last, _Dest);
+    } else if constexpr (_Nx == 2) {
+        ::__std_reverse_copy_trivially_copyable_2(_First, _Last, _Dest);
+    } else if constexpr (_Nx == 4) {
+        ::__std_reverse_copy_trivially_copyable_4(_First, _Last, _Dest);
+    } else if constexpr (_Nx == 8) {
+        ::__std_reverse_copy_trivially_copyable_8(_First, _Last, _Dest);
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_REVERSE_COPY ^^^
+
+#if _VECTORIZED_MINMAX_ELEMENT
+template <class _Ty>
+pair<_Ty*, _Ty*> _Minmax_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    _Min_max_element_t _Res;
+
+    if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        _Res = ::__std_minmax_element_f_(_First, _Last);
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        _Res = ::__std_minmax_element_d_(_First, _Last);
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            _Res = ::__std_minmax_element_1i(_First, _Last);
+        } else {
+            _Res = ::__std_minmax_element_1u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            _Res = ::__std_minmax_element_2i(_First, _Last);
+        } else {
+            _Res = ::__std_minmax_element_2u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            _Res = ::__std_minmax_element_4i(_First, _Last);
+        } else {
+            _Res = ::__std_minmax_element_4u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+#if _VECTORIZED_MINMAX_ELEMENT_64BIT_INT
+        if constexpr (_Signed) {
+            _Res = ::__std_minmax_element_8i(_First, _Last);
+        } else {
+            _Res = ::__std_minmax_element_8u(_First, _Last);
+        }
+#else // ^^^ _VECTORIZED_MINMAX_ELEMENT_64BIT_INT / !_VECTORIZED_MINMAX_ELEMENT_64BIT_INT vvv
+        static_assert(false, "unexpected size");
+#endif // ^^^ !_VECTORIZED_MINMAX_ELEMENT_64BIT_INT ^^^
+    } else {
+        static_assert(false, "unexpected size");
+    }
+
+    return {const_cast<_Ty*>(static_cast<const _Ty*>(_Res._Min)), const_cast<_Ty*>(static_cast<const _Ty*>(_Res._Max))};
+}
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+#if _VECTORIZED_MINMAX
+template <class _Ty>
+auto _Minmax_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_pointer_v<_Ty>) {
+#ifdef _WIN64
+        const auto _Result = ::__std_minmax_8u(_First, _Last);
+#else
+        const auto _Result = ::__std_minmax_4u(_First, _Last);
+#endif
+        return _Min_max_p{reinterpret_cast<void*>(_Result._Min), reinterpret_cast<void*>(_Result._Max)};
+    } else if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return ::__std_minmax_f(_First, _Last);
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return ::__std_minmax_d(_First, _Last);
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return ::__std_minmax_1i(_First, _Last);
+        } else {
+            return ::__std_minmax_1u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return ::__std_minmax_2i(_First, _Last);
+        } else {
+            return ::__std_minmax_2u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return ::__std_minmax_4i(_First, _Last);
+        } else {
+            return ::__std_minmax_4u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+        if constexpr (_Signed) {
+            return ::__std_minmax_8i(_First, _Last);
+        } else {
+            return ::__std_minmax_8u(_First, _Last);
+        }
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+
+#if _VECTORIZED_IS_SORTED_UNTIL
+template <class _Ty>
+_Ty* _Is_sorted_until_vectorized(_Ty* const _First, _Ty* const _Last, const bool _Greater) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_f(_First, _Last, _Greater)));
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_d(_First, _Last, _Greater)));
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_1i(_First, _Last, _Greater)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_1u(_First, _Last, _Greater)));
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_2i(_First, _Last, _Greater)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_2u(_First, _Last, _Greater)));
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_4i(_First, _Last, _Greater)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_4u(_First, _Last, _Greater)));
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_8i(_First, _Last, _Greater)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_is_sorted_until_8u(_First, _Last, _Greater)));
+        }
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_IS_SORTED_UNTIL ^^^
+
+#if _VECTORIZED_INCLUDES
+template <class _Ty>
+bool _Includes_vectorized(
+    const _Ty* const _First1, const _Ty* const _Last1, const _Ty* const _First2, const _Ty* const _Last2) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return ::__std_includes_less_1i(_First1, _Last1, _First2, _Last2);
+        } else {
+            return ::__std_includes_less_1u(_First1, _Last1, _First2, _Last2);
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return ::__std_includes_less_2i(_First1, _Last1, _First2, _Last2);
+        } else {
+            return ::__std_includes_less_2u(_First1, _Last1, _First2, _Last2);
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return ::__std_includes_less_4i(_First1, _Last1, _First2, _Last2);
+        } else {
+            return ::__std_includes_less_4u(_First1, _Last1, _First2, _Last2);
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+        if constexpr (_Signed) {
+            return ::__std_includes_less_8i(_First1, _Last1, _First2, _Last2);
+        } else {
+            return ::__std_includes_less_8u(_First1, _Last1, _First2, _Last2);
+        }
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_INCLUDES ^^^
+
+#if _VECTORIZED_REPLACE
+template <class _Ty, class _TVal1, class _TVal2>
+__declspec(noalias) void _Replace_vectorized(
+    _Ty* const _First, _Ty* const _Last, const _TVal1 _Old_val, const _TVal2 _New_val) noexcept {
+    if constexpr (sizeof(_Ty) == 4) {
+        ::__std_replace_4(
+            _First, _Last, _STD _Find_arg_cast<uint32_t>(_Old_val), _STD _Find_arg_cast<uint32_t>(_New_val));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        ::__std_replace_8(
+            _First, _Last, _STD _Find_arg_cast<uint64_t>(_Old_val), _STD _Find_arg_cast<uint64_t>(_New_val));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_REPLACE ^^^
+
+#if _VECTORIZED_REPLACE_COPY
+template <class _Ty, class _TVal1, class _TVal2>
+__declspec(noalias) void _Replace_copy_vectorized(const _Ty* const _First, const _Ty* const _Last, _Ty* const _Dest,
+    const _TVal1 _Old_val, const _TVal2 _New_val) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        ::__std_replace_copy_1(
+            _First, _Last, _Dest, _STD _Find_arg_cast<uint8_t>(_Old_val), _STD _Find_arg_cast<uint8_t>(_New_val));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        ::__std_replace_copy_2(
+            _First, _Last, _Dest, _STD _Find_arg_cast<uint16_t>(_Old_val), _STD _Find_arg_cast<uint16_t>(_New_val));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        ::__std_replace_copy_4(
+            _First, _Last, _Dest, _STD _Find_arg_cast<uint32_t>(_Old_val), _STD _Find_arg_cast<uint32_t>(_New_val));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        ::__std_replace_copy_8(
+            _First, _Last, _Dest, _STD _Find_arg_cast<uint64_t>(_Old_val), _STD _Find_arg_cast<uint64_t>(_New_val));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_REPLACE_COPY ^^^
+
+#if _VECTORIZED_SEARCH_N
+template <class _Ty, class _TVal>
+_Ty* _Search_n_vectorized(_Ty* const _First, _Ty* const _Last, const size_t _Count, const _TVal _Val) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_search_n_1(_First, _Last, _Count, _STD _Find_arg_cast<uint8_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_search_n_2(_First, _Last, _Count, _STD _Find_arg_cast<uint16_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_search_n_4(_First, _Last, _Count, _STD _Find_arg_cast<uint32_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_search_n_8(_First, _Last, _Count, _STD _Find_arg_cast<uint64_t>(_Val))));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_SEARCH_N ^^^
+
+#if _VECTORIZED_UNIQUE
+template <class _Ty>
+_Ty* _Unique_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return reinterpret_cast<_Ty*>(::__std_unique_1(_First, _Last));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return reinterpret_cast<_Ty*>(::__std_unique_2(_First, _Last));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return reinterpret_cast<_Ty*>(::__std_unique_4(_First, _Last));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return reinterpret_cast<_Ty*>(::__std_unique_8(_First, _Last));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_UNIQUE ^^^
+
+#if _VECTORIZED_REMOVE_COPY
+template <class _Ty, class _TVal>
+_Ty* _Remove_copy_vectorized(
+    const _Ty* const _First, const _Ty* const _Last, _Ty* const _Dest, const _TVal _Val) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return reinterpret_cast<_Ty*>(::__std_remove_copy_1(_First, _Last, _Dest, _STD _Find_arg_cast<uint8_t>(_Val)));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return reinterpret_cast<_Ty*>(::__std_remove_copy_2(_First, _Last, _Dest, _STD _Find_arg_cast<uint16_t>(_Val)));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return reinterpret_cast<_Ty*>(::__std_remove_copy_4(_First, _Last, _Dest, _STD _Find_arg_cast<uint32_t>(_Val)));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return reinterpret_cast<_Ty*>(::__std_remove_copy_8(_First, _Last, _Dest, _STD _Find_arg_cast<uint64_t>(_Val)));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_REMOVE_COPY ^^^
+
+#if _VECTORIZED_UNIQUE_COPY
+template <class _Ty>
+_Ty* _Unique_copy_vectorized(const _Ty* const _First, const _Ty* const _Last, _Ty* const _Dest) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return reinterpret_cast<_Ty*>(::__std_unique_copy_1(_First, _Last, _Dest));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return reinterpret_cast<_Ty*>(::__std_unique_copy_2(_First, _Last, _Dest));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return reinterpret_cast<_Ty*>(::__std_unique_copy_4(_First, _Last, _Dest));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return reinterpret_cast<_Ty*>(::__std_unique_copy_8(_First, _Last, _Dest));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_UNIQUE_COPY ^^^
+
+#if _VECTORIZED_REPLACE
+// Can we activate the vector algorithms for replace?
+template <class _Iter, class _Ty1>
+constexpr bool _Vector_alg_in_replace_is_safe = _Vector_alg_in_find_is_safe<_Iter, _Ty1> // can search for the value
+                                             && sizeof(_Iter_value_t<_Iter>) >= 4; // avx masked op compatible size
+
+// Can we activate the vector algorithms for ranges::replace?
+template <class _Iter, class _Ty1, class _Ty2>
+constexpr bool _Vector_alg_in_ranges_replace_is_safe =
+    _Vector_alg_in_replace_is_safe<_Iter, _Ty1> // can search and replace
+    && _Vector_alg_in_find_is_safe_elem<_Ty2, _Iter_value_t<_Iter>>; // replacement fits
+#endif // ^^^ _VECTORIZED_REPLACE ^^^
+
+#if _VECTORIZED_SEARCH_N
+// Can we activate the vector algorithms for search_n?
+template <class _Iter, class _Ty, class _Pr>
+constexpr bool _Vector_alg_in_search_n_is_safe = _Vector_alg_in_find_is_safe<_Iter, _Ty>
+                                              && _Is_any_of_v<_Pr,
+#if _HAS_CXX20
+                                                  ranges::equal_to,
+#endif
+                                                  equal_to<>>;
+#endif // ^^^ _VECTORIZED_SEARCH_N ^^^
+
+#if _VECTORIZED_UNIQUE || _VECTORIZED_UNIQUE_COPY
+// Can we activate the vector algorithms for unique and unique_copy?
+template <class _Iter, class _Pr>
+constexpr bool _Vector_alg_in_unique_is_safe = _Vector_alg_in_search_is_safe<_Iter, _Iter, _Pr>;
+#endif // ^^^ _VECTORIZED_UNIQUE || _VECTORIZED_UNIQUE_COPY ^^^
+
+#if _VECTORIZED_REMOVE_COPY || _VECTORIZED_UNIQUE_COPY
+// Can we use this output iterator for remove_copy and unique_copy?
+template <class _Out, class _In>
+constexpr bool _Output_iterator_for_vector_alg_is_safe() {
+    // Before running remove_copy and unique_copy, the output size is unknown. This limits vectorization
+    // to pointers (after unwrapping). N5014 [iterator.requirements.general]/13 allows us to convert
+    // a range of contiguous iterators to pointers if and only if we know the size of the range ahead of time.
+    if constexpr (is_pointer_v<_Out>) {
+        return is_same_v<_Iter_value_t<_Out>, remove_const_t<_Iter_value_t<_In>>>;
+    } else {
+        return false;
+    }
+}
+#endif // ^^^ _VECTORIZED_REMOVE_COPY || _VECTORIZED_UNIQUE_COPY ^^^
+
+#if _VECTORIZED_REPLACE_COPY
+template <class _Out, class _In>
+constexpr bool _Output_iterator_for_known_size_vector_alg_is_safe() {
+    if constexpr (_Iterator_is_contiguous<_Out>) {
+        return is_same_v<_Iter_value_t<_Out>, remove_const_t<_Iter_value_t<_In>>>;
+    } else {
+        return false;
+    }
+}
+#endif // ^^^ _VECTORIZED_REPLACE_COPY ^^^
+
+#if _VECTORIZED_INCLUDES
+// Can we activate the vector algorithms for includes?
+template <class _Iter1, class _Iter2, class _Elem = _Iter_value_t<_Iter1>>
+constexpr bool _Vector_alg_includes_iterators_safe =
+    _Iterators_are_contiguous<_Iter1, _Iter2> // Iterators must be contiguous so we can get raw pointers.
+    && !_Iterator_is_volatile<_Iter1> && !_Iterator_is_volatile<_Iter2> // Iterators must not be volatile.
+    && is_same_v<_Elem, _Iter_value_t<_Iter2>> // Iterators have the same value type.
+    && disjunction_v<is_integral<_Elem>, is_pointer<_Elem>>; // Integral or pointer type.
+#endif // ^^^ _VECTORIZED_INCLUDES ^^^
+
+#define _REQUIRE_CPP17_MUTABLE_RANDOM_ACCESS_ITERATOR(_Iter) \
+    static_assert(_Is_cpp17_random_iter_v<_Iter>,            \
+        "This algorithm requires that mutable iterators be Cpp17RandomAccessIterators or stronger.")
+
+#define _REQUIRE_BIDIRECTIONAL_ITERATOR(_Iter) \
+    static_assert(_Is_ranges_bidi_iter_v<_Iter>, "This algorithm requires bidirectional iterators or stronger.")
+
+_INLINE_VAR constexpr int _ISORT_MAX = 32; // maximum size for insertion sort
+// If _ISORT_MAX is ever changed from 32 == 2^5, re-analyze the implementation of stable_sort for integer overflow.
+
+template <class _It>
+constexpr _Iter_diff_t<_It> _Isort_max{_ISORT_MAX};
+
+template <class _Diff>
+constexpr ptrdiff_t _Temporary_buffer_size(const _Diff _Value) noexcept {
+    // convert an iterator difference_type to a ptrdiff_t for use in temporary buffers
+    using _CT = common_type_t<ptrdiff_t, _Diff>;
+    return static_cast<ptrdiff_t>((_STD min) (static_cast<_CT>(PTRDIFF_MAX), static_cast<_CT>(_Value)));
+}
+
+template <class _Ty>
+struct _Optimistic_temporary_buffer2 { // temporary storage with _alloca-like attempt
+    static constexpr size_t _Optimistic_size  = 4096; // default to ~1 page
+    static constexpr size_t _Optimistic_count = (_STD max) (static_cast<size_t>(1), _Optimistic_size / sizeof(_Ty));
+
+    template <class _Diff>
+    explicit _Optimistic_temporary_buffer2(const _Diff _Requested_size) noexcept { // get temporary storage
+        const auto _Attempt = _Temporary_buffer_size(_Requested_size);
+        // Since _Diff is a count of elements in a forward range, and forward iterators must denote objects in memory,
+        // it must fit in a size_t.
+        if (static_cast<size_t>(_Requested_size) <= _Optimistic_count) { // unconditionally engage stack space
+            _Data     = reinterpret_cast<_Ty*>(_Stack_space);
+            _Capacity = static_cast<ptrdiff_t>(_Requested_size); // in bounds due to if condition
+            return;
+        }
+
+        const pair<_Ty*, ptrdiff_t> _Raw = _Get_temporary_buffer<_Ty>(_Attempt);
+        if (static_cast<size_t>(_Raw.second) > _Optimistic_count) { // engage heap space
+            _Data     = _Raw.first;
+            _Capacity = _Raw.second;
+            return;
+        }
+
+        // less heap space than stack space, give up and use stack instead
+        _STD _Return_temporary_buffer(_Raw.first);
+        _Data     = reinterpret_cast<_Ty*>(_Stack_space);
+        _Capacity = _Optimistic_count;
+    }
+
+    _Optimistic_temporary_buffer2(const _Optimistic_temporary_buffer2&)            = delete;
+    _Optimistic_temporary_buffer2& operator=(const _Optimistic_temporary_buffer2&) = delete;
+
+    ~_Optimistic_temporary_buffer2() noexcept {
+        if (static_cast<size_t>(_Capacity) > _Optimistic_count) {
+            _STD _Return_temporary_buffer(_Data);
+        }
+    }
+
+    _Ty* _Data; // points to heap memory iff _Capacity > _Optimistic_count
+    ptrdiff_t _Capacity;
+    alignas(_Ty) unsigned char _Stack_space[sizeof(_Ty) * _Optimistic_count];
+};
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Fun>
+    struct in_fun_result {
+        /* [[no_unique_address]] */ _In in;
+        /* [[no_unique_address]] */ _Fun fun;
+
+        template <_Convertible_from<const _In&> _IIn, _Convertible_from<const _Fun&> _FFun>
+        constexpr operator in_fun_result<_IIn, _FFun>() const& {
+            return {in, fun};
+        }
+
+        template <_Convertible_from<_In> _IIn, _Convertible_from<_Fun> _FFun>
+        constexpr operator in_fun_result<_IIn, _FFun>() && {
+            return {_STD move(in), _STD move(fun)};
+        }
+    };
+
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
+    struct in_in_out_result {
+        /* [[no_unique_address]] */ _In1 in1;
+        /* [[no_unique_address]] */ _In2 in2;
+        /* [[no_unique_address]] */ _Out out;
+
+        template <_Convertible_from<const _In1&> _IIn1, _Convertible_from<const _In2&> _IIn2,
+            _Convertible_from<const _Out&> _OOut>
+        constexpr operator in_in_out_result<_IIn1, _IIn2, _OOut>() const& {
+            return {in1, in2, out};
+        }
+
+        template <_Convertible_from<_In1> _IIn1, _Convertible_from<_In2> _IIn2, _Convertible_from<_Out> _OOut>
+        constexpr operator in_in_out_result<_IIn1, _IIn2, _OOut>() && {
+            return {_STD move(in1), _STD move(in2), _STD move(out)};
+        }
+    };
+
+    _EXPORT_STD template <class _In, class _Out1, class _Out2>
+    struct in_out_out_result {
+        /* [[no_unique_address]] */ _In in;
+        /* [[no_unique_address]] */ _Out1 out1;
+        /* [[no_unique_address]] */ _Out2 out2;
+
+        template <_Convertible_from<const _In&> _IIn, _Convertible_from<const _Out1&> _OOut1,
+            _Convertible_from<const _Out2&> _OOut2>
+        constexpr operator in_out_out_result<_IIn, _OOut1, _OOut2>() const& {
+            return {in, out1, out2};
+        }
+
+        template <_Convertible_from<_In> _IIn, _Convertible_from<_Out1> _OOut1, _Convertible_from<_Out2> _OOut2>
+        constexpr operator in_out_out_result<_IIn, _OOut1, _OOut2>() && {
+            return {_STD move(in), _STD move(out1), _STD move(out2)};
+        }
+    };
+
+    _EXPORT_STD template <class _Ty>
+    struct min_max_result {
+        /* [[no_unique_address]] */ _Ty min;
+        /* [[no_unique_address]] */ _Ty max;
+
+        template <_Convertible_from<const _Ty&> _Ty2>
+        constexpr operator min_max_result<_Ty2>() const& {
+            return {min, max};
+        }
+
+        template <_Convertible_from<_Ty> _Ty2>
+        constexpr operator min_max_result<_Ty2>() && {
+            return {_STD move(min), _STD move(max)};
+        }
+    };
+
+    _EXPORT_STD template <class _In>
+    struct in_found_result {
+        /* [[no_unique_address]] */ _In in;
+        bool found;
+
+        template <_Convertible_from<const _In&> _IIn>
+        constexpr operator in_found_result<_IIn>() const& {
+            return {in, found};
+        }
+
+        template <_Convertible_from<_In> _IIn>
+        constexpr operator in_found_result<_IIn>() && {
+            return {_STD move(in), found};
+        }
+    };
+
+#if _HAS_CXX23
+    _EXPORT_STD template <class _In, class _Ty>
+    struct in_value_result {
+        _MSVC_NO_UNIQUE_ADDRESS _In in;
+        _MSVC_NO_UNIQUE_ADDRESS _Ty value;
+
+        template <class _IIn, class _TTy>
+            requires convertible_to<const _In&, _IIn> && convertible_to<const _Ty&, _TTy>
+        constexpr operator in_value_result<_IIn, _TTy>() const& {
+            return {in, value};
+        }
+
+        template <class _IIn, class _TTy>
+            requires convertible_to<_In, _IIn> && convertible_to<_Ty, _TTy>
+        constexpr operator in_value_result<_IIn, _TTy>() && {
+            return {_STD move(in), _STD move(value)};
+        }
+    };
+#endif // _HAS_CXX23
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Fn>
+_CONSTEXPR20 _Fn for_each(_InIt _First, _InIt _Last, _Fn _Func) { // perform function for each element [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Func(*_UFirst);
+    }
+
+    return _Func;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+void for_each(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept; // terminates
+
+_EXPORT_STD template <class _InIt, class _Diff, class _Fn>
+_CONSTEXPR20 _InIt for_each_n(_InIt _First, const _Diff _Count_raw, _Fn _Func) {
+    // perform function for each element [_First, _First + _Count)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (0 < _Count) {
+        auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+        do {
+            _Func(*_UFirst);
+            --_Count;
+            ++_UFirst;
+        } while (0 < _Count);
+
+        _STD _Seek_wrapped(_First, _UFirst);
+    }
+
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt for_each_n(_ExPo&& _Exec, _FwdIt _First, _Diff _Count_raw, _Fn _Func) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Fun>
+    using for_each_result = in_fun_result<_In, _Fun>;
+
+    class _For_each_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirectly_unary_invocable<projected<_It, _Pj>> _Fn>
+        static constexpr for_each_result<_It, _Fn> operator()(_It _First, _Se _Last, _Fn _Func, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            auto _UResult = _For_each_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD move(_Func), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            return {_STD move(_First), _STD move(_UResult.fun)};
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirectly_unary_invocable<projected<iterator_t<_Rng>, _Pj>> _Fn>
+        static constexpr for_each_result<borrowed_iterator_t<_Rng>, _Fn> operator()(
+            _Rng&& _Range, _Fn _Func, _Pj _Proj = {}) {
+            auto _First = _RANGES begin(_Range);
+
+            auto _UResult = _For_each_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD move(_Func), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            return {_STD move(_First), _STD move(_UResult.fun)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Fn>
+        _NODISCARD static constexpr for_each_result<_It, _Fn> _For_each_unchecked(
+            _It _First, const _Se _Last, _Fn _Func, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_unary_invocable<_Fn, projected<_It, _Pj>>);
+
+            for (; _First != _Last; ++_First) {
+                _STD invoke(_Func, _STD invoke(_Proj, *_First));
+            }
+
+            return {_STD move(_First), _STD move(_Func)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _For_each_fn for_each;
+
+    _EXPORT_STD template <class _In, class _Fun>
+    using for_each_n_result = in_fun_result<_In, _Fun>;
+
+    struct _For_each_n_fn {
+        template <input_iterator _It, class _Pj = identity, indirectly_unary_invocable<projected<_It, _Pj>> _Fn>
+        static constexpr for_each_n_result<_It, _Fn> operator()(
+            _It _First, iter_difference_t<_It> _Count, _Fn _Func, _Pj _Proj = {}) {
+            if (0 < _Count) {
+                auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+                do {
+                    _STD invoke(_Func, _STD invoke(_Proj, *_UFirst));
+                    --_Count;
+                    ++_UFirst;
+                } while (0 < _Count);
+
+                _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            }
+
+            return {_STD move(_First), _STD move(_Func)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _For_each_n_fn for_each_n;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt, class _Pr>
+_NODISCARD _CONSTEXPR20 _InIt find_if_not(_InIt _First, const _InIt _Last, _Pr _Pred) {
+    // find first element that satisfies !_Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (!_Pred(*_UFirst)) {
+            break;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt find_if_not(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+    // find first satisfying _Pred with successor
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _ULast  = _STD _Get_unwrapped(_Last);
+    if (_UFirst != _ULast) {
+#if _VECTORIZED_ADJACENT_FIND
+        if constexpr (_Vector_alg_in_search_is_safe<decltype(_UFirst), decltype(_UFirst), _Pr>) {
+            if (!_STD _Is_constant_evaluated()) {
+                const auto _First_ptr = _STD _To_address(_UFirst);
+                const auto _Result    = _STD _Adjacent_find_vectorized(_First_ptr, _STD _To_address(_ULast));
+
+                if constexpr (is_pointer_v<decltype(_ULast)>) {
+                    _ULast = _Result;
+                } else {
+                    _ULast = _UFirst + static_cast<_Iter_diff_t<decltype(_UFirst)>>(_Result - _First_ptr);
+                }
+
+                _STD _Seek_wrapped(_Last, _ULast);
+                return _Last;
+            }
+        }
+#endif // ^^^ _VECTORIZED_ADJACENT_FIND ^^^
+
+        for (auto _UNext = _UFirst; ++_UNext != _ULast; _UFirst = _UNext) {
+            if (_Pred(*_UFirst, *_UNext)) {
+                _ULast = _UFirst;
+                break;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_Last, _ULast);
+    return _Last;
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD _CONSTEXPR20 _FwdIt adjacent_find(const _FwdIt _First, const _FwdIt _Last) { // find first matching successor
+    return _STD adjacent_find(_First, _Last, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt adjacent_find(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt adjacent_find(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last) noexcept /* terminates */ {
+    // find first matching successor
+    return _STD adjacent_find(_STD forward<_ExPo>(_Exec), _First, _Last, equal_to{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Count_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+        _NODISCARD static constexpr iter_difference_t<_It> operator()(
+            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            return _Count_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _Val, _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
+        _NODISCARD static constexpr range_difference_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) {
+            return _Count_unchecked(_Ubegin(_Range), _Uend(_Range), _Val, _STD _Pass_fn(_Proj));
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty, class _Pj>
+        _NODISCARD static constexpr iter_difference_t<_It> _Count_unchecked(
+            _It _First, const _Se _Last, const _Ty& _Val, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>);
+
+#if _VECTORIZED_COUNT
+            if constexpr (is_same_v<_Pj, identity> && _Vector_alg_in_find_is_safe<_It, _Ty>
+                          && sized_sentinel_for<_Se, _It>) {
+                if (!_STD is_constant_evaluated()) {
+                    if (!_STD _Could_compare_equal_to_value_type<_It>(_Val)) {
+                        return 0;
+                    }
+
+                    const auto _First_ptr = _STD _To_address(_First);
+                    const auto _Last_ptr  = _STD _To_address(_First + (_Last - _First));
+
+                    return static_cast<iter_difference_t<_It>>(_STD _Count_vectorized(_First_ptr, _Last_ptr, _Val));
+                }
+            }
+#endif // ^^^ _VECTORIZED_COUNT ^^^
+
+            iter_difference_t<_It> _Count = 0;
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Proj, *_First) == _Val) {
+                    ++_Count;
+                }
+            }
+
+            return _Count;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Count_fn count;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Pr>
+_NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count_if(_InIt _First, _InIt _Last, _Pr _Pred) {
+    // count elements satisfying _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst               = _STD _Get_unwrapped(_First);
+    const auto _ULast          = _STD _Get_unwrapped(_Last);
+    _Iter_diff_t<_InIt> _Count = 0;
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (_Pred(*_UFirst)) {
+            ++_Count;
+        }
+    }
+
+    return _Count;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Iter_diff_t<_FwdIt> count_if(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Count_if_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr iter_difference_t<_It> operator()(
+            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            return _Count_if_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr range_difference_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            return _Count_if_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr iter_difference_t<_It> _Count_if_unchecked(
+            _It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            iter_difference_t<_It> _Count = 0;
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    ++_Count;
+                }
+            }
+
+            return _Count;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Count_if_fn count_if;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InIt1 _Last1, _InIt2 _First2, _Pr _Pred) {
+    // return [_First1, _Last1)/[_First2, ...) mismatch
+    _STD _Adl_verify_range(_First1, _Last1);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1));
+#if _VECTORIZED_MISMATCH
+    if constexpr (_Equal_memcmp_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+        if (!_STD _Is_constant_evaluated()) {
+            constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>);
+
+            const auto _Dist = _STD _Contiguous_iter_distance(_UFirst1, _ULast1);
+            _STD _Contiguous_iter_verify(_UFirst2, static_cast<_Iter_diff_t<_InIt2>>(_Dist));
+
+            const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>(
+                _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast<size_t>(_Dist));
+
+            _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos);
+            _UFirst2 += static_cast<_Iter_diff_t<_InIt2>>(_Pos);
+
+            _STD _Seek_wrapped(_First2, _UFirst2);
+            _STD _Seek_wrapped(_First1, _UFirst1);
+            return {_First1, _First2};
+        }
+    }
+#endif // ^^^ _VECTORIZED_MISMATCH ^^^
+    while (_UFirst1 != _ULast1 && _Pred(*_UFirst1, *_UFirst2)) {
+        ++_UFirst1;
+        ++_UFirst2;
+    }
+
+    _STD _Seek_wrapped(_First2, _UFirst2);
+    _STD _Seek_wrapped(_First1, _UFirst1);
+    return {_First1, _First2};
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
+    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) {
+    // return [_First1, _Last1)/[_First2, ...) mismatch
+    return _STD mismatch(_First1, _Last1, _First2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
+    _ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2) noexcept /* terminates */ {
+    // return [_First1, _Last1)/[_First2, ...) mismatch
+    return _STD mismatch(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(
+    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred) {
+    // return [_First1, _Last1)/[_First2, _Last2) mismatch
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    auto _ULast1       = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    if constexpr (_Is_ranges_random_iter_v<_InIt1> && _Is_ranges_random_iter_v<_InIt2>) {
+        using _CT         = _Common_diff_t<_InIt1, _InIt2>;
+        const _CT _Count1 = _ULast1 - _UFirst1;
+        const _CT _Count2 = _ULast2 - _UFirst2;
+        const auto _Count = static_cast<_Iter_diff_t<_InIt1>>((_STD min) (_Count1, _Count2));
+        _ULast1           = _UFirst1 + _Count;
+#if _VECTORIZED_MISMATCH
+        if constexpr (_Equal_memcmp_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+            if (!_STD _Is_constant_evaluated()) {
+                constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>);
+
+                (void) _STD _To_address(_ULast1);
+                (void) _STD _To_address(_ULast2);
+
+                const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>(
+                    _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast<size_t>(_Count));
+
+                _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos);
+                _UFirst2 += static_cast<_Iter_diff_t<_InIt2>>(_Pos);
+
+                _STD _Seek_wrapped(_First2, _UFirst2);
+                _STD _Seek_wrapped(_First1, _UFirst1);
+                return {_First1, _First2};
+            }
+        }
+#endif // ^^^ _VECTORIZED_MISMATCH ^^^
+        while (_UFirst1 != _ULast1 && _Pred(*_UFirst1, *_UFirst2)) {
+            ++_UFirst1;
+            ++_UFirst2;
+        }
+    } else {
+        while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2 && _Pred(*_UFirst1, *_UFirst2)) {
+            ++_UFirst1;
+            ++_UFirst2;
+        }
+    }
+
+    _STD _Seek_wrapped(_First2, _UFirst2);
+    _STD _Seek_wrapped(_First1, _UFirst1);
+    return {_First1, _First2};
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
+    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
+    // return [_First1, _Last1)/[_First2, _Last2) mismatch
+    return _STD mismatch(_First1, _Last1, _First2, _Last2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
+    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept /* terminates */ {
+    // return [_First1, _Last1)/[_First2, _Last2) mismatch
+    return _STD mismatch(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <input_iterator _It1, input_iterator _It2, _Integer_like _Size, class _Pr, class _Pj1, class _Pj2>
+        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+    _NODISCARD constexpr bool _Equal_count(
+        _It1 _First1, _It2 _First2, _Size _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        _STL_INTERNAL_CHECK(_Count >= 0);
+        if constexpr (_Equal_memcmp_is_safe<_It1, _It2, _Pr> && same_as<_Pj1, identity> && same_as<_Pj2, identity>) {
+            if (!_STD is_constant_evaluated()) {
+                return _STD _Memcmp_count(_First1, _First2, static_cast<size_t>(_Count)) == 0;
+            }
+        }
+
+        for (; _Count != 0; ++_First1, (void) ++_First2, --_Count) {
+            if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    class _Equal_fn {
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Equal_4(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            for (;;) {
+                if (_First1 == _Last1) {
+                    return _First2 == _Last2;
+                } else if (_First2 == _Last2) {
+                    return false;
+                }
+
+                if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                    return false;
+                }
+
+                ++_First1;
+                ++_First2;
+            }
+        }
+
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr bool operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UFirst1 = _RANGES _Unwrap_iter<_Se1>(_STD move(_First1));
+            auto _ULast1  = _RANGES _Unwrap_sent<_It1>(_STD move(_Last1));
+            auto _UFirst2 = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            auto _ULast2  = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+
+            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
+                const auto _Count = _ULast1 - _UFirst1;
+                if (_Count != _ULast2 - _UFirst2) {
+                    return false;
+                }
+
+                return _RANGES _Equal_count(_STD move(_UFirst1), _STD move(_UFirst2), _Count, _STD _Pass_fn(_Pred),
+                    _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            } else {
+                return _Equal_4(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2), _STD move(_ULast2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            }
+        }
+
+        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr bool operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
+                const auto _Count = _RANGES distance(_Range1);
+                if (_Count != _RANGES distance(_Range2)) {
+                    return false;
+                }
+                return _RANGES _Equal_count(_Ubegin(_Range1), _Ubegin(_Range2), _Count, _STD _Pass_fn(_Pred),
+                    _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            } else {
+                return _Equal_4(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Equal_fn equal;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) {
+    // test if [_First1, _Last1) == permuted [_First2, ...)
+    _STD _Adl_verify_range(_First1, _Last1);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_FwdIt1>(_UFirst1, _ULast1));
+
+    for (;; ++_UFirst1, (void) ++_UFirst2) { // trim matching prefix
+        if (_UFirst1 == _ULast1) { // everything matched
+            return true;
+        }
+
+        if (!_Pred(*_UFirst1, *_UFirst2)) { // found first inequality, check match counts in suffix
+            break;
+        }
+    }
+
+    // Narrowing _Iter_diff_t<_FwdIt1> to _Iter_diff_t<_FwdIt2> is OK because the second range must be at least as long
+    // as the first.
+    const auto _Dist2 = static_cast<_Iter_diff_t<_FwdIt2>>(_STD distance(_UFirst1, _ULast1));
+    return _STD _Check_match_counts(_UFirst1, _ULast1, _UFirst2, _STD next(_UFirst2, _Dist2), _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
+_NODISCARD _CONSTEXPR20 bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2) {
+    // test if [_First1, _Last1) == permuted [_First2, ...)
+    return _STD is_permutation(_First1, _Last1, _First2, equal_to<>{});
+}
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool is_permutation(
+    _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) {
+    // test if [_First1, _Last1) == permuted [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2 = _STD _Get_unwrapped(_First2);
+    auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    if constexpr (_Is_ranges_random_iter_v<_FwdIt1> && _Is_ranges_random_iter_v<_FwdIt2>) {
+        if (_ULast1 - _UFirst1 != _ULast2 - _UFirst2) {
+            return false;
+        }
+
+        for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) { // trim matching prefix
+            if (!_Pred(*_UFirst1, *_UFirst2)) {
+                // found first inequality, check match counts in suffix
+                return _STD _Check_match_counts(_UFirst1, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred));
+            }
+        }
+
+        return true;
+    } else {
+        static_assert(_Is_ranges_fwd_iter_v<_FwdIt1> && _Is_ranges_fwd_iter_v<_FwdIt2>,
+            "Iterators must be at least forward iterators");
+        for (;; ++_UFirst1, (void) ++_UFirst2) { // trim matching prefix
+            if (_UFirst1 == _ULast1) {
+                return _UFirst2 == _ULast2;
+            }
+
+            if (_UFirst2 == _ULast2) {
+                return false;
+            }
+
+            if (!_Pred(*_UFirst1, *_UFirst2)) { // found first inequality, check match counts in suffix
+                break;
+            }
+        }
+
+        auto _Next1 = _UFirst1;
+        auto _Next2 = _UFirst2;
+        for (;; ++_Next1, (void) ++_Next2) { // check for same lengths
+            if (_Next1 == _ULast1) {
+                if (_Next2 == _ULast2) {
+                    return _STD _Check_match_counts(_UFirst1, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred));
+                }
+
+                return false; // sequence 1 is shorter than sequence 2, not a permutation
+            }
+
+            if (_Next2 == _ULast2) {
+                return false; // sequence 1 is longer than sequence 2, not a permutation
+            }
+        }
+    }
+}
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
+_NODISCARD _CONSTEXPR20 bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) {
+    // test if [_First1, _Last1) == permuted [_First2, _Last2)
+    return _STD is_permutation(_First1, _Last1, _First2, _Last2, equal_to<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Is_permutation_fn {
+    public:
+        template <forward_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pj1 = identity, class _Pj2 = identity,
+            indirect_equivalence_relation<projected<_It1, _Pj1>, projected<_It2, _Pj2>> _Pr = ranges::equal_to>
+        _NODISCARD static constexpr bool operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UFirst1 = _RANGES _Unwrap_iter<_Se1>(_STD move(_First1));
+            auto _ULast1  = _RANGES _Unwrap_sent<_It1>(_STD move(_Last1));
+            auto _UFirst2 = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            auto _ULast2  = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+
+            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
+                const auto _Count = _ULast1 - _UFirst1;
+                if (_ULast2 - _UFirst2 != _Count) {
+                    return false;
+                }
+
+                return _Is_permutation_sized(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                    _STD move(_ULast2), _Count, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            } else {
+                return _Is_permutation_unsized(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                    _STD move(_ULast2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            }
+        }
+
+        template <forward_range _Rng1, forward_range _Rng2, class _Pj1 = identity, class _Pj2 = identity,
+            indirect_equivalence_relation<projected<iterator_t<_Rng1>, _Pj1>, projected<iterator_t<_Rng2>, _Pj2>> _Pr =
+                ranges::equal_to>
+        _NODISCARD static constexpr bool operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
+                const auto _Count = _RANGES distance(_Range1);
+                if (_RANGES distance(_Range2) != _Count) {
+                    return false;
+                }
+
+                return _Is_permutation_sized(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2), _Count,
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            } else {
+                return _Is_permutation_unsized(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            }
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Is_permutation_sized(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
+            iter_difference_t<_It1> _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(
+                indirect_equivalence_relation<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First1, _Last1) == _Count);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First2, _Last2) == _Count);
+
+            for (;; ++_First1, (void) ++_First2, --_Count) { // trim matching prefixes
+                if (_Count == 0) { // everything matched
+                    return true;
+                }
+
+                if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) { // mismatch
+                    break;
+                }
+            }
+
+            if (_Count == 1) { // single non-matching elements remain; not a permutation
+                return false;
+            }
+            // If we get here, _Count > 1 and initial elements do not match.
+
+            if constexpr (bidirectional_iterator<_It1> && bidirectional_iterator<_It2>) {
+                // determine final iterator values
+                auto _Final1 = _RANGES _Find_last_iterator(_First1, _Last1, _Count);
+                using _Diff2 = iter_difference_t<_It2>; // avoid truncation warnings; ranges are the same length
+                auto _Final2 = _RANGES _Find_last_iterator(_First2, _Last2, static_cast<_Diff2>(_Count));
+
+                for (;;) { // trim matching suffixes
+                    --_Final1;
+                    --_Final2;
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_Final1), _STD invoke(_Proj2, *_Final2))) { // mismatch
+                        break;
+                    }
+
+                    if (--_Count == 1) {
+                        return false; // initial elements still do not match
+                    }
+                }
+                // If we get here, _Count > 1, initial elements do not match, and final elements do not match.
+
+                // We've trimmed matching prefixes and matching suffixes.
+                // Now we need to compare each range's prefix to the other range's suffix.
+
+                const auto _ProjectedPred = [&]<class _Ty1, class _Ty2>(_Ty1&& _Left, _Ty2&& _Right) -> bool {
+                    return _STD invoke(_Pred, _STD invoke(_Proj1, _STD forward<_Ty1>(_Left)),
+                        _STD invoke(_Proj2, _STD forward<_Ty2>(_Right)));
+                };
+
+                const _TrimResult _Res = _STD _Trim_completely(_First1, _Final1, _First2, _Final2, _ProjectedPred);
+
+                if (_Res != _TrimResult::_HaveWorkAfterTrimming) {
+                    return _Res == _TrimResult::_ReturnTrue;
+                }
+
+                ++_Final1;
+                ++_Final2;
+                // If we get here, initial elements do not match, final elements do not match, and ranges have length
+                // at least 2 and at most _Count.
+
+                // We've trimmed matching prefixes, matching suffixes,
+                // and each range's prefix matching the other range's suffix. That is, given:
+                // Range 1: [A, ..., B]
+                // Range 2: [X, ..., Y]
+                // we know that A != X, A != Y, B != X, and B != Y.
+                // (A == B and X == Y are possible but irrelevant.)
+
+                return _Match_counts(_STD move(_First1), _STD move(_Final1), _STD move(_First2), _STD move(_Final2),
+                    _Pred, _Proj1, _Proj2);
+            } else {
+                return _Match_counts(_STD move(_First1), _STD move(_Last1), _STD move(_First2), _STD move(_Last2),
+                    _Pred, _Proj1, _Proj2);
+            }
+        }
+
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Is_permutation_unsized(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(
+                indirect_equivalence_relation<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>);
+
+            for (;; ++_First1, (void) ++_First2) { // trim matching prefixes
+                if (_First1 == _Last1) { // first range is a prefix of second
+                    return _First2 == _Last2;
+                } else if (_First2 == _Last2) { // second range is a proper prefix of first
+                    return false;
+                }
+
+                if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) { // mismatch
+                    break;
+                }
+            }
+            // If we get here, initial elements do not match.
+
+            // determine final iterator values and validate lengths
+            auto _Final1 = _First1;
+            auto _Final2 = _First2;
+            for (;;) {
+                ++_Final1;
+                ++_Final2;
+                if (_Final1 == _Last1) {
+                    if (_Final2 == _Last2) {
+                        break; // equal lengths
+                    }
+
+                    return false; // different lengths; not a permutation
+                } else if (_Final2 == _Last2) {
+                    return false; // ditto different lengths
+                }
+            }
+            // If we get here, initial elements do not match and ranges have equal lengths.
+
+            if constexpr (bidirectional_iterator<_It1> && bidirectional_iterator<_It2>) {
+                for (;;) { // trim matching suffixes
+                    if (--_Final1 == _First1) {
+                        return false; // initial elements still do not match
+                    }
+                    --_Final2; // since ranges have equal lengths, _Final2 cannot equal _First2
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_Final1), _STD invoke(_Proj2, *_Final2))) { // mismatch
+                        break;
+                    }
+                }
+                // If we get here, initial elements do not match, final elements do not match, and ranges have length
+                // at least 2.
+
+                // We've trimmed matching prefixes and matching suffixes.
+                // Now we need to compare each range's prefix to the other range's suffix.
+
+                const auto _ProjectedPred = [&]<class _Ty1, class _Ty2>(_Ty1&& _Left, _Ty2&& _Right) -> bool {
+                    return _STD invoke(_Pred, _STD invoke(_Proj1, _STD forward<_Ty1>(_Left)),
+                        _STD invoke(_Proj2, _STD forward<_Ty2>(_Right)));
+                };
+
+                const _TrimResult _Res = _STD _Trim_completely(_First1, _Final1, _First2, _Final2, _ProjectedPred);
+
+                if (_Res != _TrimResult::_HaveWorkAfterTrimming) {
+                    return _Res == _TrimResult::_ReturnTrue;
+                }
+
+                ++_Final1;
+                ++_Final2;
+                // If we get here, initial elements do not match, final elements do not match, and ranges have length
+                // at least 2.
+
+                // We've trimmed matching prefixes, matching suffixes,
+                // and each range's prefix matching the other range's suffix. That is, given:
+                // Range 1: [A, ..., B]
+                // Range 2: [X, ..., Y]
+                // we know that A != X, A != Y, B != X, and B != Y.
+                // (A == B and X == Y are possible but irrelevant.)
+            }
+
+            return _Match_counts(
+                _STD move(_First1), _STD move(_Final1), _STD move(_First2), _STD move(_Final2), _Pred, _Proj1, _Proj2);
+        }
+
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Match_counts(const _It1 _First1, const _Se1 _Last1, const _It2 _First2,
+            const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(
+                indirect_equivalence_relation<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>);
+
+            for (auto _Current = _First1; _Current != _Last1; ++_Current) {
+                bool _Found = false;
+                auto _Mid1  = _First1;
+                for (; _Mid1 != _Current; ++_Mid1) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj1, *_Current), _STD invoke(_Proj1, *_Mid1))) {
+                        // this value appears earlier in the first range so we've already counted occurrences
+                        _Found = true;
+                        break;
+                    }
+                }
+
+                if (_Found) {
+                    continue;
+                }
+
+                // count occurrences of this value in the first range
+                iter_difference_t<_It1> _Occurrences = 1;
+                while (++_Mid1 != _Last1) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj1, *_Current), _STD invoke(_Proj1, *_Mid1))) {
+                        ++_Occurrences;
+                    }
+                }
+
+                // subtract occurrences in the second range
+                for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj1, *_Current), _STD invoke(_Proj2, *_Mid2))) {
+                        if (--_Occurrences < 0) {
+                            // value appears more in second range than first; not a permutation
+                            return false;
+                        }
+                    }
+                }
+
+                if (_Occurrences != 0) {
+                    // value appears more in first range than second; not a permutation
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Is_permutation_fn is_permutation;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+struct _All_of_vbool_traits;
+struct _Any_of_vbool_traits;
+struct _None_of_vbool_traits;
+
+template <class _Traits, class _VbIt, class _Mapped_fn>
+_NODISCARD _CONSTEXPR20 bool _Meow_of_vbool(_VbIt _First, _VbIt _Last, _Mapped_fn _Mapped_func);
+
+_EXPORT_STD template <class _InIt, class _Pr>
+_NODISCARD _CONSTEXPR20 bool all_of(_InIt _First, _InIt _Last, _Pr _Pred) { // test if all elements satisfy _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+    if constexpr (_Is_vb_iterator<decltype(_UFirst)> && !is_void_v<_Map_vb_functor_t<_Pr>>) {
+        return _Meow_of_vbool<_All_of_vbool_traits>(_UFirst, _ULast, _Map_vb_functor_t<_Pr>{});
+    } else {
+        for (; _UFirst != _ULast; ++_UFirst) {
+            if (!_Pred(*_UFirst)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool all_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _All_of_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            return _All_of_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            return _All_of_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr bool _All_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            for (; _First != _Last; ++_First) {
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _All_of_fn all_of;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Pr>
+_NODISCARD _CONSTEXPR20 bool any_of(const _InIt _First, const _InIt _Last, _Pr _Pred) {
+    // test if any element satisfies _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+    if constexpr (_Is_vb_iterator<decltype(_UFirst)> && !is_void_v<_Map_vb_functor_t<_Pr>>) {
+        return _Meow_of_vbool<_Any_of_vbool_traits>(_UFirst, _ULast, _Map_vb_functor_t<_Pr>{});
+    } else {
+        for (; _UFirst != _ULast; ++_UFirst) {
+            if (_Pred(*_UFirst)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool any_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Any_of_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            return _Any_of_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            return _Any_of_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr bool _Any_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Any_of_fn any_of;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Pr>
+_NODISCARD _CONSTEXPR20 bool none_of(const _InIt _First, const _InIt _Last, _Pr _Pred) {
+    // test if no elements satisfy _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (_Is_vb_iterator<decltype(_UFirst)> && !is_void_v<_Map_vb_functor_t<_Pr>>) {
+        return _Meow_of_vbool<_None_of_vbool_traits>(_UFirst, _ULast, _Map_vb_functor_t<_Pr>{});
+    } else {
+        for (; _UFirst != _ULast; ++_UFirst) {
+            if (_Pred(*_UFirst)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool none_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _None_of_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            return _None_of_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            return _None_of_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr bool _None_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _None_of_fn none_of;
+
+#if _HAS_CXX23
+    struct _Contains_fn {
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+        _NODISCARD static constexpr bool operator()(_It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            const auto _ULast   = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _UResult = _RANGES _Find_unchecked(
+                _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _ULast, _Val, _STD _Pass_fn(_Proj));
+            return _UResult != _ULast;
+        }
+
+        template <input_range _Rng, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
+        _NODISCARD static constexpr bool operator()(_Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) {
+            const auto _UResult = _RANGES _Find_unchecked(_Ubegin(_Range), _Uend(_Range), _Val, _STD _Pass_fn(_Proj));
+            return _UResult != _Uend(_Range);
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Contains_fn contains;
+
+    struct _Contains_subrange_fn {
+        template <forward_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr bool operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UFirst2 = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            auto _ULast2  = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+
+            if (_UFirst2 == _ULast2) {
+                return true;
+            }
+
+            const auto _Match = _RANGES search(_STD move(_First1), _STD move(_Last1), _STD move(_UFirst2),
+                _STD move(_ULast2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            return !_Match.empty();
+        }
+
+        template <forward_range _Rng1, forward_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr bool operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            if (_RANGES empty(_Range2)) {
+                return true;
+            }
+
+            const auto _Match =
+                _RANGES search(_Range1, _Range2, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            return !_Match.empty();
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Contains_subrange_fn contains_subrange;
+#endif // _HAS_CXX23
+
+    _EXPORT_STD template <class _In, class _Out>
+    using copy_n_result = in_out_result<_In, _Out>;
+
+    struct _Copy_n_fn {
+        template <input_iterator _It, weakly_incrementable _Out>
+            requires indirectly_copyable<_It, _Out>
+        static constexpr copy_n_result<_It, _Out> operator()(_It _First, iter_difference_t<_It> _Count, _Out _Output) {
+            if (_Count > 0) {
+                auto _UFirst  = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+                auto _UOutput = _STD _Get_unwrapped_n(_STD move(_Output), _Count);
+                if constexpr (_Iter_copy_cat<decltype(_UFirst), decltype(_UOutput)>::_Bitcopy_assignable) {
+                    if (!_STD is_constant_evaluated()) {
+                        _UOutput = _STD _Copy_memmove_n(_UFirst, static_cast<size_t>(_Count), _STD move(_UOutput));
+                        _UFirst += _Count;
+                        _STD _Seek_wrapped(_First, _STD move(_UFirst));
+                        _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+                        return {_STD move(_First), _STD move(_Output)};
+                    }
+                }
+
+                for (; _Count > 0; ++_UFirst, (void) ++_UOutput, --_Count) {
+                    *_UOutput = *_UFirst;
+                }
+
+                _STD _Seek_wrapped(_First, _STD move(_UFirst));
+                _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+            }
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Copy_n_fn copy_n;
+
+    _EXPORT_STD template <class _In, class _Out>
+    using copy_backward_result = in_out_result<_In, _Out>;
+
+    struct _Copy_backward_fn {
+        template <bidirectional_iterator _It1, sentinel_for<_It1> _Se1, bidirectional_iterator _It2>
+            requires indirectly_copyable<_It1, _It2>
+        static constexpr copy_backward_result<_It1, _It2> operator()(_It1 _First, _Se1 _Last, _It2 _Output) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se1>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It1>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            const auto _Count = _RANGES _Idl_distance<_It1>(_UFirst, _ULast);
+            auto _UOutput     = _STD _Copy_backward_unchecked(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Get_unwrapped_n(_STD move(_Output), -_Count));
+            _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <bidirectional_range _Rng, bidirectional_iterator _It>
+            requires indirectly_copyable<iterator_t<_Rng>, _It>
+        static constexpr copy_backward_result<borrowed_iterator_t<_Rng>, _It> operator()(_Rng&& _Range, _It _Output) {
+            auto _ULast       = _RANGES _Get_final_iterator_unwrapped(_Range);
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _UOutput     = _STD _Copy_backward_unchecked(
+                _Ubegin(_Range), _ULast, _STD _Get_unwrapped_n(_STD move(_Output), -_Count));
+            _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+            return {_RANGES _Rewrap_iterator(_Range, _STD move(_ULast)), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Copy_backward_fn copy_backward;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Pr>
+_CONSTEXPR20 _OutIt copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) { // copy each satisfying _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_unverified(_Dest);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (_Pred(*_UFirst)) {
+            *_UDest = *_UFirst;
+            ++_UDest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept /* terminates */ {
+    // copy each satisfying _Pred
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD copy_if(_First, _Last, _Dest, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using copy_if_result = in_out_result<_In, _Out>;
+
+    class _Copy_if_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+            requires indirectly_copyable<_It, _Out>
+        static constexpr copy_if_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Output, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Copy_if_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Get_unwrapped_unverified(_STD move(_Output)),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+        static constexpr copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, _Out _Output, _Pr _Pred, _Pj _Proj = {}) {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _Copy_if_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Get_unwrapped_unverified(_STD move(_Output)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Out, class _Pj, class _Pr>
+        _NODISCARD static constexpr copy_if_result<_It, _Out> _Copy_if_unchecked(
+            _It _First, const _Se _Last, _Out _Output, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    *_Output = *_First;
+                    ++_Output;
+                }
+            }
+
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Copy_if_fn copy_if;
+
+    _EXPORT_STD template <class _In, class _Out>
+    using move_result = in_out_result<_In, _Out>;
+
+    template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+        requires indirectly_movable<_It, _Out>
+    constexpr move_result<_It, _Out> _Move_unchecked(_It _First, _Se _Last, _Out _Output) {
+        if constexpr (_Iter_move_cat<_It, _Out>::_Bitcopy_assignable) {
+            if (!_STD is_constant_evaluated()) {
+                auto _Final = _RANGES next(_First, _STD move(_Last));
+                _Output     = _STD _Copy_memmove(_STD move(_First), _Final, _STD move(_Output));
+                return {_STD move(_Final), _STD move(_Output)};
+            }
+        }
+
+        for (; _First != _Last; ++_First, (void) ++_Output) {
+            *_Output = _RANGES iter_move(_First);
+        }
+
+        return {_STD move(_First), _STD move(_Output)};
+    }
+
+    struct _Move_fn {
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+            requires indirectly_movable<_It, _Out>
+        static constexpr move_result<_It, _Out> operator()(_It _First, _Se _Last, _Out _Output) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast       = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _Count = _RANGES _Idl_distance<_It>(_UFirst, _ULast);
+            auto _UResult     = _RANGES _Move_unchecked(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Get_unwrapped_n(_STD move(_Output), _Count));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out>
+            requires indirectly_movable<iterator_t<_Rng>, _Out>
+        static constexpr move_result<borrowed_iterator_t<_Rng>, _Out> operator()(_Rng&& _Range, _Out _Output) {
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _First       = _RANGES begin(_Range);
+            auto _UResult = _RANGES _Move_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Move_fn move;
+
+    _EXPORT_STD template <class _In, class _Out>
+    using move_backward_result = in_out_result<_In, _Out>;
+
+    // concept-constrained for strict enforcement as it is used by several algorithms
+    template <bidirectional_iterator _It1, bidirectional_iterator _It2>
+        requires indirectly_movable<_It1, _It2>
+    constexpr _It2 _Move_backward_common(const _It1 _First, _It1 _Last, _It2 _Output) {
+        if constexpr (_Iter_move_cat<_It1, _It2>::_Bitcopy_assignable) {
+            if (!_STD is_constant_evaluated()) {
+                return _STD _Copy_backward_memmove(_First, _Last, _Output);
+            }
+        }
+
+        while (_First != _Last) {
+            *--_Output = _RANGES iter_move(--_Last);
+        }
+
+        return _Output;
+    }
+
+    struct _Move_backward_fn {
+        template <bidirectional_iterator _It1, sentinel_for<_It1> _Se1, bidirectional_iterator _It2>
+            requires indirectly_movable<_It1, _It2>
+        static constexpr move_backward_result<_It1, _It2> operator()(_It1 _First, _Se1 _Last, _It2 _Output) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se1>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It1>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            const auto _Count = _RANGES _Idl_distance<_It1>(_UFirst, _ULast);
+            auto _UOutput     = _RANGES _Move_backward_common(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Get_unwrapped_n(_STD move(_Output), -_Count));
+            _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <bidirectional_range _Rng, bidirectional_iterator _It>
+            requires indirectly_movable<iterator_t<_Rng>, _It>
+        static constexpr move_backward_result<borrowed_iterator_t<_Rng>, _It> operator()(_Rng&& _Range, _It _Output) {
+            auto _ULast       = _RANGES _Get_final_iterator_unwrapped(_Range);
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _UOutput     = _RANGES _Move_backward_common(
+                _Ubegin(_Range), _ULast, _STD _Get_unwrapped_n(_STD move(_Output), -_Count));
+            _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+            return {_RANGES _Rewrap_iterator(_Range, _STD move(_ULast)), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Move_backward_fn move_backward;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _OutIt1, class _OutIt2, class _Pr>
+_CONSTEXPR20 pair<_OutIt1, _OutIt2> partition_copy(
+    _InIt _First, _InIt _Last, _OutIt1 _Dest_true, _OutIt2 _Dest_false, _Pr _Pred) {
+    // copy true partition to _Dest_true, false to _Dest_false
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest_true  = _STD _Get_unwrapped_unverified(_Dest_true);
+    auto _UDest_false = _STD _Get_unwrapped_unverified(_Dest_false);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (_Pred(*_UFirst)) {
+            *_UDest_true = *_UFirst;
+            ++_UDest_true;
+        } else {
+            *_UDest_false = *_UFirst;
+            ++_UDest_false;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest_false, _UDest_false);
+    _STD _Seek_wrapped(_Dest_true, _UDest_true);
+    return {_Dest_true, _Dest_false};
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+pair<_FwdIt2, _FwdIt3> partition_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest_true, _FwdIt3 _Dest_false,
+    _Pr _Pred) noexcept /* terminates */ {
+    // copy true partition to _Dest_true, false to _Dest_false
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    return _STD partition_copy(_First, _Last, _Dest_true, _Dest_false, _STD _Pass_fn(_Pred));
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out1, class _Out2>
+    using partition_copy_result = in_out_out_result<_In, _Out1, _Out2>;
+
+    class _Partition_copy_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out1, weakly_incrementable _Out2,
+            class _Pj = identity, indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+            requires indirectly_copyable<_It, _Out1> && indirectly_copyable<_It, _Out2>
+        static constexpr partition_copy_result<_It, _Out1, _Out2> operator()(
+            _It _First, _Se _Last, _Out1 _Dest_true, _Out2 _Dest_false, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Partition_copy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Get_unwrapped_unverified(_STD move(_Dest_true)),
+                _STD _Get_unwrapped_unverified(_STD move(_Dest_false)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Dest_true, _STD move(_UResult.out1));
+            _STD _Seek_wrapped(_Dest_false, _STD move(_UResult.out2));
+            return {_STD move(_First), _STD move(_Dest_true), _STD move(_Dest_false)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out1, weakly_incrementable _Out2, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out1> && indirectly_copyable<iterator_t<_Rng>, _Out2>
+        static constexpr partition_copy_result<borrowed_iterator_t<_Rng>, _Out1, _Out2> operator()(
+            _Rng&& _Range, _Out1 _Dest_true, _Out2 _Dest_false, _Pr _Pred, _Pj _Proj = {}) {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _Partition_copy_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)),
+                _Uend(_Range), _STD _Get_unwrapped_unverified(_STD move(_Dest_true)),
+                _STD _Get_unwrapped_unverified(_STD move(_Dest_false)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Dest_true, _STD move(_UResult.out1));
+            _STD _Seek_wrapped(_Dest_false, _STD move(_UResult.out2));
+            return {_STD move(_First), _STD move(_Dest_true), _STD move(_Dest_false)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Out1, class _Out2, class _Pr, class _Pj>
+        _NODISCARD static constexpr partition_copy_result<_It, _Out1, _Out2> _Partition_copy_unchecked(
+            _It _First, const _Se _Last, _Out1 _Dest_true, _Out2 _Dest_false, _Pr _Pred, _Pj _Proj) {
+            // copy true partition to _Dest_true, false to _Dest_false
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out1> && weakly_incrementable<_Out2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out1> && indirectly_copyable<_It, _Out2>);
+
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    *_Dest_true = *_First;
+                    ++_Dest_true;
+                } else {
+                    *_Dest_false = *_First;
+                    ++_Dest_false;
+                }
+            }
+
+            return {_STD move(_First), _STD move(_Dest_true), _STD move(_Dest_false)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Partition_copy_fn partition_copy;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt, class _Pr>
+_NODISCARD _CONSTEXPR20 bool is_partitioned(const _InIt _First, const _InIt _Last, _Pr _Pred) {
+    // test if [_First, _Last) partitioned by _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+    for (;; ++_UFirst) { // skip true partition
+        if (_UFirst == _ULast) {
+            return true;
+        }
+
+        if (!_Pred(*_UFirst)) {
+            break;
+        }
+    }
+
+    while (++_UFirst != _ULast) { // verify false partition
+        if (_Pred(*_UFirst)) {
+            return false; // found out of place element
+        }
+    }
+
+    return true;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool is_partitioned(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Is_partitioned_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            return _Is_partitioned_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            return _Is_partitioned_unchecked(
+                _Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pr, class _Pj>
+        _NODISCARD static constexpr bool _Is_partitioned_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            // test if [_First, _Last) is partitioned with respect to _Pred and _Proj
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            for (;; ++_First) { // skip true partition
+                if (_First == _Last) {
+                    return true;
+                }
+
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    break;
+                }
+            }
+
+            while (++_First != _Last) { // verify false partition
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    return false; // found out of place element
+                }
+            }
+
+            return true;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Is_partitioned_fn is_partitioned;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt partition_point(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+    // find beginning of false partition in [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _Count       = _STD distance(_UFirst, _ULast);
+    while (0 < _Count) { // divide and conquer, find half that contains answer
+        const auto _Count2 = static_cast<_Iter_diff_t<_FwdIt>>(_Count / 2);
+        const auto _UMid   = _STD next(_UFirst, _Count2);
+
+        if (_Pred(*_UMid)) { // try top half
+            _UFirst = _STD _Next_iter(_UMid);
+            _Count -= _Count2;
+            --_Count;
+        } else {
+            _Count = _Count2;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Partition_point_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            if constexpr (sized_sentinel_for<_Se, _It>) {
+                const auto _Length = _RANGES _Unwrap_sent<_It>(_STD move(_Last)) - _UFirst;
+                _UFirst            = _Partition_point_n_unchecked(
+                    _STD move(_UFirst), _Length, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            } else {
+                _UFirst = _Partition_point_unchecked(_STD move(_UFirst), _RANGES _Unwrap_sent<_It>(_STD move(_Last)),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            }
+
+            _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            if constexpr (sized_range<_Rng>) {
+                const auto _Length = _RANGES distance(_Range);
+                auto _UFirst =
+                    _Partition_point_n_unchecked(_Ubegin(_Range), _Length, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_iterator(_Range, _STD move(_UFirst));
+            } else {
+                auto _UFirst = _Partition_point_unchecked(
+                    _Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_iterator(_Range, _STD move(_UFirst));
+            }
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        _NODISCARD static constexpr _It _Partition_point_n_unchecked(
+            _It _First, iter_difference_t<_It> _Length, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+            _STL_INTERNAL_CHECK(_Length >= 0);
+
+            while (_Length > 0) {
+                const auto _Half = static_cast<iter_difference_t<_It>>(_Length / 2);
+                auto _Mid        = _RANGES next(_First, _Half);
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Mid))) { // _Mid is before the partition point
+                    _First = _STD move(_Mid);
+                    ++_First;
+                    _Length -= _Half;
+                    --_Length;
+                } else { // _Mid is at or past the partition point
+                    _Length = _Half;
+                }
+            }
+
+            return _First;
+        }
+
+        template <class _It, class _Se, class _Pr, class _Pj>
+        _NODISCARD static constexpr _It _Partition_point_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            // Instead of blindly seeking the end of the range, probe elements at exponentially increasing intervals to
+            // find an element past the partition point.
+            iter_difference_t<_It> _Skip = 2;
+            for (;;) {
+                auto _Mid = _First;
+                _Skip -= _RANGES advance(_Mid, _Skip, _Last);
+                if (_Mid == _Last) { // we've located the end of the range
+                    break;
+                }
+
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Mid))) { // _Mid is at or past the partition point
+                    break;
+                }
+
+                _First = _STD move(_Mid);
+                ++_First;
+
+                constexpr auto _Half_max = (numeric_limits<iter_difference_t<_It>>::max)() / 2;
+                if (_Skip <= _Half_max) {
+                    _Skip <<= 1;
+                }
+            }
+
+            return _Partition_point_n_unchecked(_STD move(_First), _Skip, _Pred, _Proj);
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Partition_point_fn partition_point;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool _Equal_rev_pred_unchecked(_InIt1 _First1, _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
+    // compare [_First1, ...) to [_First2, _Last2)
+    for (; _First2 != _Last2; ++_First1, (void) ++_First2) {
+        if (!_Pred(*_First1, *_First2)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+_EXPORT_STD template <class _FwdItHaystack, class _FwdItPat, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdItHaystack search(_FwdItHaystack _First1, _FwdItHaystack _Last1, const _FwdItPat _First2,
+    const _FwdItPat _Last2, _Pr _Pred) { // find first [_First2, _Last2) satisfying _Pred
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1       = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+    const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    if constexpr (_Is_ranges_random_iter_v<_FwdItHaystack> && _Is_ranges_random_iter_v<_FwdItPat>) {
+        const _Iter_diff_t<_FwdItPat> _Count2 = _ULast2 - _UFirst2;
+        if (_ULast1 - _UFirst1 >= _Count2) {
+#if _VECTORIZED_SEARCH
+            if constexpr (_Vector_alg_in_search_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+                if (!_STD _Is_constant_evaluated()) {
+                    const auto _Ptr1 = _STD _To_address(_UFirst1);
+                    (void) _STD _To_address(_ULast2);
+
+                    const auto _Ptr_res1 = _STD _Search_vectorized(
+                        _Ptr1, _STD _To_address(_ULast1), _STD _To_address(_UFirst2), static_cast<size_t>(_Count2));
+
+                    if constexpr (is_pointer_v<decltype(_UFirst1)>) {
+                        _UFirst1 = _Ptr_res1;
+                    } else {
+                        _UFirst1 += static_cast<_Iter_diff_t<decltype(_UFirst1)>>(_Ptr_res1 - _Ptr1);
+                    }
+
+                    _STD _Seek_wrapped(_Last1, _UFirst1);
+                    return _Last1;
+                }
+            }
+#endif // ^^^ _VECTORIZED_SEARCH ^^^
+
+            const auto _Last_possible = _ULast1 - static_cast<_Iter_diff_t<_FwdItHaystack>>(_Count2);
+            for (;; ++_UFirst1) {
+                if (_STD _Equal_rev_pred_unchecked(_UFirst1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred))) {
+                    _STD _Seek_wrapped(_Last1, _UFirst1);
+                    break;
+                }
+
+                if (_UFirst1 == _Last_possible) {
+                    break;
+                }
+            }
+        }
+    } else {
+        for (;; ++_UFirst1) { // loop until match or end of a sequence
+            auto _UMid1 = _UFirst1;
+            for (auto _UMid2 = _UFirst2;; ++_UMid1, (void) ++_UMid2) {
+                if (_UMid2 == _ULast2) {
+                    _STD _Seek_wrapped(_Last1, _UFirst1);
+                    return _Last1;
+                } else if (_UMid1 == _ULast1) {
+                    return _Last1;
+                } else if (!_Pred(*_UMid1, *_UMid2)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    return _Last1;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdItHaystack, class _FwdItPat, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdItHaystack search(_ExPo&& _Exec, _FwdItHaystack _First1, _FwdItHaystack _Last1, _FwdItPat _First2,
+    _FwdItPat _Last2, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _FwdItHaystack, class _FwdItPat>
+_NODISCARD _CONSTEXPR20 _FwdItHaystack search(
+    const _FwdItHaystack _First1, const _FwdItHaystack _Last1, const _FwdItPat _First2, const _FwdItPat _Last2) {
+    // find first [_First2, _Last2) match
+    return _STD search(_First1, _Last1, _First2, _Last2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdItHaystack, class _FwdItPat, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdItHaystack search(_ExPo&& _Exec, const _FwdItHaystack _First1, const _FwdItHaystack _Last1,
+    const _FwdItPat _First2, const _FwdItPat _Last2) noexcept /* terminates */ {
+    // find first [_First2, _Last2) match
+    return _STD search(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _FwdItHaystack, class _Searcher>
+_NODISCARD _CONSTEXPR20 _FwdItHaystack search(
+    const _FwdItHaystack _First, const _FwdItHaystack _Last, const _Searcher& _Search) {
+    // find _Search's pattern in [_First, _Last)
+    return _Search(_First, _Last).first;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Diff, class _Ty, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt search_n(
+    const _FwdIt _First, _FwdIt _Last, const _Diff _Count_raw, const _Ty& _Val, _Pr _Pred) {
+    // find first _Count * _Val satisfying _Pred
+    const _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return _First;
+    }
+
+    if constexpr (_Is_any_of_v<_Pr,
+#if _HAS_CXX20
+                      _RANGES equal_to,
+#endif
+                      equal_to<>>) {
+        if (_Count == 1) {
+            return _STD find(_First, _Last, _Val);
+        }
+    }
+
+    if (static_cast<uintmax_t>(_Count) > static_cast<uintmax_t>(_STD _Max_limit<_Iter_diff_t<_FwdIt>>())) {
+        // if the number of _Vals searched for is larger than the longest possible sequence, we can't find it
+        return _Last;
+    }
+
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (_Is_ranges_random_iter_v<_FwdIt>) {
+#if _VECTORIZED_SEARCH_N
+        if constexpr (_Vector_alg_in_search_n_is_safe<decltype(_UFirst), _Ty, _Pr>) {
+            if (!_STD _Is_constant_evaluated()) {
+                if (!_STD _Could_compare_equal_to_value_type<decltype(_UFirst)>(_Val)) {
+                    return _Last;
+                }
+
+                const auto _First_ptr = _STD _To_address(_UFirst);
+                const auto _Result =
+                    _STD _Search_n_vectorized(_First_ptr, _STD _To_address(_ULast), static_cast<size_t>(_Count), _Val);
+
+                if constexpr (is_pointer_v<decltype(_UFirst)>) {
+                    _UFirst = _Result;
+                } else {
+                    _UFirst += static_cast<_Iter_diff_t<decltype(_UFirst)>>(_Result - _First_ptr);
+                }
+
+                _STD _Seek_wrapped(_Last, _UFirst);
+                return _Last;
+            }
+        }
+#endif // ^^^ _VECTORIZED_SEARCH_N ^^^
+
+        const auto _Count_diff = static_cast<_Iter_diff_t<_FwdIt>>(_Count);
+        auto _UOld_first       = _UFirst;
+        for (_Iter_diff_t<_FwdIt> _Inc = 0; _Count_diff <= _ULast - _UOld_first;) { // enough room, look for a match
+            _UFirst = _UOld_first + _Inc;
+            if (_Pred(*_UFirst, _Val)) { // found part of possible match, check it out
+                _Iter_diff_t<_FwdIt> _Count1 = _Count_diff;
+                auto _UMid                   = _UFirst;
+
+                while (_UOld_first != _UFirst
+                       && _Pred(*_STD _Prev_iter(_UFirst), _Val)) { // back up over any skipped prefix
+                    --_Count1;
+                    --_UFirst;
+                }
+
+                if (_Count1 <= _ULast - _UMid) {
+                    for (;;) { // enough left, test suffix
+                        if (--_Count1 == 0) {
+                            _STD _Seek_wrapped(_Last, _UFirst); // found rest of match, report it
+                            return _Last;
+                        } else if (!_Pred(*++_UMid, _Val)) { // short match not at end
+                            break;
+                        }
+                    }
+                }
+                _UOld_first = ++_UMid; // failed match, take small jump
+                _Inc        = 0;
+            } else { // no match, take big jump and back up as needed
+                _UOld_first = _STD _Next_iter(_UFirst);
+                _Inc        = _Count_diff - 1;
+            }
+        }
+    } else {
+        for (; _UFirst != _ULast; ++_UFirst) {
+            if (_Pred(*_UFirst, _Val)) { // found start of possible match, check it out
+                auto _UMid = _UFirst;
+
+                for (_Algorithm_int_t<_Diff> _Count1 = _Count;;) {
+                    if (--_Count1 == 0) {
+                        _STD _Seek_wrapped(_Last, _UFirst); // found rest of match, report it
+                        return _Last;
+                    } else if (++_UMid == _ULast) {
+                        return _Last; // short match at end
+                    } else if (!_Pred(*_UMid, _Val)) { // short match not at end
+                        break;
+                    }
+                }
+
+                _UFirst = _UMid; // pick up just beyond failed match
+            }
+        }
+    }
+
+    return _Last;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt search_n(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Diff _Count_raw, const _Ty& _Val,
+    _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _FwdIt, class _Diff, class _Ty>
+_NODISCARD _CONSTEXPR20 _FwdIt search_n(const _FwdIt _First, const _FwdIt _Last, const _Diff _Count, const _Ty& _Val) {
+    // find first _Count * _Val match
+    return _STD search_n(_First, _Last, _Count, _Val, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt search_n(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Diff _Count,
+    const _Ty& _Val) noexcept /* terminates */ { // find first _Count * _Val match
+    return _STD search_n(_STD forward<_ExPo>(_Exec), _First, _Last, _Count, _Val, equal_to{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Search_n_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pr = ranges::equal_to,
+            class _Pj = identity>
+            requires indirectly_comparable<_It, const _Ty*, _Pr, _Pj>
+        _NODISCARD static constexpr subrange<_It> operator()(_It _First, _Se _Last, const iter_difference_t<_It> _Count,
+            const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            if (_Count <= 0) {
+                return {_First, _First};
+            }
+
+            if constexpr (_Is_any_of_v<_Pr, _STD equal_to<>, _RANGES equal_to>) {
+                if (_Count == 1) {
+                    auto _Res = _RANGES find(_First, _Last, _Val, _Pass_fn(_Proj));
+                    if (_Res != _Last) {
+                        auto _Res_end = _Res;
+                        ++_Res_end;
+                        return {_STD move(_Res), _STD move(_Res_end)};
+                    } else {
+                        return {_Res, _Res};
+                    }
+                }
+            }
+
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+
+            if constexpr (sized_sentinel_for<_Se, _It>) {
+                const auto _Dist = _ULast - _UFirst;
+                auto _UResult    = _Search_n_sized(
+                    _STD move(_UFirst), _Dist, _Val, _Count, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+            } else {
+                auto _UResult = _Search_n_unsized(
+                    _STD move(_UFirst), _STD move(_ULast), _Val, _Count, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+            }
+        }
+
+        template <forward_range _Rng, class _Ty, class _Pr = ranges::equal_to, class _Pj = identity>
+            requires indirectly_comparable<iterator_t<_Rng>, const _Ty*, _Pr, _Pj>
+        _NODISCARD static constexpr borrowed_subrange_t<_Rng> operator()(
+            _Rng&& _Range, const range_difference_t<_Rng> _Count, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _First = _RANGES begin(_Range);
+
+            if (_Count <= 0) {
+                return {_First, _First};
+            }
+
+            if constexpr (_Is_any_of_v<_Pr, _STD equal_to<>, _RANGES equal_to>) {
+                if (_Count == 1) {
+                    auto _Res  = _RANGES find(_Range, _Val, _Pass_fn(_Proj));
+                    auto _Last = _RANGES end(_Range);
+                    if (_Res != _Last) {
+                        auto _Res_end = _Res;
+                        ++_Res_end;
+                        return {_STD move(_Res), _STD move(_Res_end)};
+                    } else {
+                        return {_Res, _Res};
+                    }
+                }
+            }
+
+            if constexpr (sized_range<_Rng>) {
+                const auto _Dist = _RANGES distance(_Range);
+
+                auto _UResult = _Search_n_sized(
+                    _STD _Get_unwrapped(_First), _Dist, _Val, _Count, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_First, _STD move(_UResult));
+            } else {
+                auto _UResult = _Search_n_unsized(_RANGES _Unwrap_range_iter<_Rng>(_First), _Uend(_Range), _Val, _Count,
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_First, _STD move(_UResult));
+            }
+        }
+
+    private:
+        template <class _It, class _Ty, class _Pr, class _Pj>
+        _NODISCARD static constexpr subrange<_It> _Search_n_sized(_It _First, iter_difference_t<_It> _Dist,
+            const _Ty& _Val, const iter_difference_t<_It> _Count, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It, const _Ty*, _Pr, _Pj>);
+            _STL_INTERNAL_CHECK(_Count > 0);
+            // pre: _First + [0, _Dist) is a valid counted range
+
+            if constexpr (bidirectional_iterator<_It>) {
+                if (_Dist < _Count) {
+                    _RANGES advance(_First, _Dist);
+                    return {_First, _First};
+                }
+
+#if _VECTORIZED_SEARCH_N
+                if constexpr (_Vector_alg_in_search_n_is_safe<_It, _Ty, _Pr> && is_same_v<_Pj, identity>) {
+                    if (!_STD is_constant_evaluated()) {
+                        if (!_STD _Could_compare_equal_to_value_type<_It>(_Val)) {
+                            _First += _Dist;
+                            return {_First, _First};
+                        }
+
+                        const auto _First_ptr = _STD _To_address(_First);
+                        const auto _Last_ptr  = _STD _To_address(_First + _Dist);
+                        const auto _Result =
+                            _STD _Search_n_vectorized(_First_ptr, _Last_ptr, static_cast<size_t>(_Count), _Val);
+
+                        if constexpr (is_pointer_v<_It>) {
+                            if (_Result != _Last_ptr) {
+                                return {_Result, _Result + _Count};
+                            } else {
+                                return {_Result, _Result};
+                            }
+                        } else {
+                            if (_Result != _Last_ptr) {
+                                _First += static_cast<iter_difference_t<_It>>(_Result - _First_ptr);
+                                return {_First, _First + _Count};
+                            } else {
+                                _First += _Dist;
+                                return {_First, _First};
+                            }
+                        }
+                    }
+                }
+#endif // ^^^ _VECTORIZED_SEARCH_N ^^^
+
+                auto _Last = _RANGES next(_First, _Count);
+                auto _Mid1 = _First;
+                auto _Mid2 = _Last;
+                for (;;) {
+                    // Invariants: _Last - _First == _Count, [_First, _Mid1) and [_Mid2, _Last) match _Val:
+                    //
+                    // _First  _Mid1    _Mid2    _Last
+                    // |=======|????????|========|??????...
+
+                    --_Mid2;
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_Mid2), _Val)) {
+                        if (_Mid2 == _Mid1) { // [_Mid1, _Mid2) is empty, so [_First, _Last) all match
+                            return {_STD move(_First), _STD move(_Last)};
+                        }
+                    } else { // mismatch; skip past it
+                        ++_Mid2;
+                        const auto _Delta = _RANGES distance(_First, _Mid2);
+
+                        if (_Dist - _Delta < _Count) { // not enough space left
+                            _First = _STD move(_Last);
+                            _Dist -= _Count;
+                            break;
+                        }
+
+                        _First = _STD move(_Mid2);
+                        _Dist -= _Delta;
+                        _Mid1 = _Last;
+                        _RANGES advance(_Last, _Delta);
+                        _Mid2 = _Last;
+                    }
+                }
+            } else {
+                for (; _Dist >= _Count; ++_First, (void) --_Dist) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _Val)) {
+                        auto _Saved = _First;
+                        for (iter_difference_t<_It> _Len = 0;;) {
+                            ++_First;
+                            if (++_Len == _Count) { // match
+                                return {_STD move(_Saved), _STD move(_First)};
+                            }
+
+                            if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First), _Val)) { // mismatch
+                                _Dist -= _Len;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            _RANGES advance(_First, _Dist);
+            return {_First, _First};
+        }
+
+        template <class _It, class _Se, class _Ty, class _Pr, class _Pj>
+        _NODISCARD static constexpr subrange<_It> _Search_n_unsized(
+            _It _First, const _Se _Last, const _Ty& _Val, const iter_difference_t<_It> _Count, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It, const _Ty*, _Pr, _Pj>);
+            _STL_INTERNAL_CHECK(_Count > 0);
+
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _Val)) {
+                    auto _Saved = _First;
+                    for (auto _Len = _Count;;) {
+                        ++_First;
+                        if (--_Len == 0) { // match
+                            return {_STD move(_Saved), _STD move(_First)};
+                        }
+
+                        if (_First == _Last) { // no more to match against
+                            return {_First, _First};
+                        }
+
+                        if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First), _Val)) { // mismatch
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return {_First, _First};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Search_n_fn search_n;
+
+#if _HAS_CXX23
+    struct _Starts_with_fn {
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr bool operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+
+            auto _UFirst1      = _RANGES _Unwrap_iter<_Se1>(_STD move(_First1));
+            auto _ULast1       = _RANGES _Unwrap_sent<_It1>(_STD move(_Last1));
+            auto _UFirst2      = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            const auto _ULast2 = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+            if constexpr (_Sized_or_unreachable_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
+                const iter_difference_t<_It2> _Count2 = _ULast2 - _UFirst2;
+                if constexpr (sized_sentinel_for<_Se1, _It1>) {
+                    if (_Count2 > _ULast1 - _UFirst1) {
+                        return false;
+                    }
+                }
+
+                return _RANGES _Equal_count(_STD move(_UFirst1), _STD move(_UFirst2),
+                    static_cast<iter_difference_t<_It1>>(_Count2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                    _STD _Pass_fn(_Proj2));
+            } else {
+                const auto _Result = _RANGES _Mismatch_4(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                    _ULast2, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _Result.in2 == _ULast2;
+            }
+        }
+
+        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr bool operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            if constexpr (_Sized_or_infinite_range<_Rng1> && sized_range<_Rng2>) {
+                const range_difference_t<_Rng2> _Count2 = _RANGES distance(_Range2);
+                if constexpr (sized_range<_Rng1>) {
+                    if (_Count2 > _RANGES distance(_Range1)) {
+                        return false;
+                    }
+                }
+
+                return _RANGES _Equal_count(_Ubegin(_Range1), _Ubegin(_Range2),
+                    static_cast<range_difference_t<_Rng1>>(_Count2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                    _STD _Pass_fn(_Proj2));
+            } else {
+                const auto _ULast2 = _Uend(_Range2);
+                const auto _Result = _RANGES _Mismatch_4(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _ULast2,
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _Result.in2 == _ULast2;
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Starts_with_fn starts_with;
+
+    class _Ends_with_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires (forward_iterator<_It1> || sized_sentinel_for<_Se1, _It1>)
+                  && (forward_iterator<_It2> || sized_sentinel_for<_Se2, _It2>)
+                  && indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr bool operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UFirst1 = _RANGES _Unwrap_iter<_Se1>(_STD move(_First1));
+            auto _ULast1  = _RANGES _Unwrap_sent<_It1>(_STD move(_Last1));
+            auto _UFirst2 = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            auto _ULast2  = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+
+            const auto _Count1 = _Distance_helper(_UFirst1, _ULast1);
+            const auto _Count2 = _Distance_helper(_UFirst2, _ULast2);
+
+            return _Ends_with_impl(_STD move(_UFirst1), _STD move(_ULast1), _Count1, _STD move(_UFirst2),
+                _STD move(_ULast2), _Count2, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+        }
+
+        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires (forward_range<_Rng1> || sized_range<_Rng1>) && (forward_range<_Rng2> || sized_range<_Rng2>)
+                  && indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr bool operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            const auto _Count1 = _Distance_helper(_Range1);
+            const auto _Count2 = _Distance_helper(_Range2);
+
+            return _Ends_with_impl(_Ubegin(_Range1), _Uend(_Range1), _Count1, _Ubegin(_Range2), _Uend(_Range2), _Count2,
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+        }
+
+    private:
+        struct _Not_a_difference {};
+
+        template <class _It, class _Se>
+        _NODISCARD static constexpr auto _Distance_helper(const _It& _First, const _Se& _Last) {
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            if constexpr (sized_sentinel_for<_Se, _It>) {
+                return _Last - _First;
+            } else {
+                return _Not_a_difference{};
+            }
+        }
+
+        template <class _Rng>
+        _NODISCARD static constexpr auto _Distance_helper(_Rng&& _Range) {
+            _STL_INTERNAL_STATIC_ASSERT(range<_Rng>);
+            if constexpr (sized_range<_Rng>) {
+                return _RANGES distance(_Range);
+            } else {
+                return _Not_a_difference{};
+            }
+        }
+
+        template <class _Ty, class _It1, class _It2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Match_backwards(
+            const _Ty _First1, _It1 _Last1, const _It2 _First2, _It2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(same_as<_Ty, _It1> || same_as<_Ty, unreachable_sentinel_t>);
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            for (;;) {
+                if (_First2 == _Last2) { // needle exhausted - match
+                    return true;
+                }
+
+                if (_First1 == _Last1) { // haystack exhausted - no match
+                    return false;
+                }
+
+                --_Last1;
+                --_Last2;
+                if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_Last1), _STD invoke(_Proj2, *_Last2))) {
+                    return false; // non-equal elements - no match
+                }
+            }
+        }
+
+        template <class _It1, class _Se1, class _Diff1, class _It2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Ends_with_sized_needle(_It1 _First1, _Se1 _Last1, _Diff1 _Count1,
+            _It2 _First2, iter_difference_t<_It2> _Count2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1> && sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1> || same_as<_Diff1, iter_difference_t<_It1>>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            constexpr bool _Sized1 = !same_as<_Diff1, _Not_a_difference>;
+
+            if constexpr (random_access_iterator<_It1> && _Sized1) {
+                _First1 += static_cast<iter_difference_t<_It1>>(_Count1 - _Count2);
+            } else if constexpr (_Bidi_common<_It1, _Se1>) {
+                if constexpr (_Sized1) {
+                    if ((_Count1 >> 1) >= _Count2) { // beginning of potential match is closer to _Last1
+                        _RANGES advance(_Last1, static_cast<iter_difference_t<_It1>>(-_Count2));
+                        _First1 = _STD move(_Last1);
+                    } else { // beginning of potential match is closer to _First1
+                        _RANGES advance(_First1, static_cast<iter_difference_t<_It1>>(_Count1 - _Count2));
+                    }
+                } else { // Only second range is sized
+                    if (_RANGES advance(_Last1, static_cast<iter_difference_t<_It1>>(-_Count2), _First1) != 0) {
+                        // distance(_First1, _Last1) < _Count2
+                        return false;
+                    }
+                    _First1 = _STD move(_Last1);
+                }
+            } else if constexpr (forward_iterator<_It1>) {
+                auto _Mid1  = _First1;
+                auto _Count = _Count2;
+                do {
+                    if (_Mid1 == _Last1) { // distance(_First1, _Last1) < _Count2
+                        return false;
+                    }
+
+                    ++_Mid1;
+                } while (--_Count != 0);
+
+                // At this point, distance(_First1, _Mid1) == _Count2
+                while (_Mid1 != _Last1) {
+                    ++_First1;
+                    ++_Mid1;
+                }
+            } else {
+                _RANGES advance(_First1, static_cast<iter_difference_t<_It1>>(_Count1 - _Count2));
+            }
+
+            return _RANGES _Equal_count(_STD move(_First1), _STD move(_First2),
+                static_cast<iter_difference_t<_It1>>(_Count2), _Pred, _Proj1, _Proj2);
+        }
+
+        template <class _It1, class _Se1, class _Diff1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Ends_with_unsized_needle(
+            _It1 _First1, _Se1 _Last1, _Diff1 _Count1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1> && sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1> || same_as<_Diff1, iter_difference_t<_It1>>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2> && sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            constexpr bool _Sized1 = !same_as<_Diff1, _Not_a_difference>;
+
+            iter_difference_t<_It2> _Count2 = 0;
+
+            if constexpr (_Sized1) {
+                for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2, (void) ++_Count2) {
+                    if (_Count2 == _Count1) { // distance(_First1, _Last1) < distance(_First2, _Last2)
+                        return false;
+                    }
+                }
+
+                _RANGES advance(_First1, static_cast<iter_difference_t<_It1>>(_Count1 - _Count2));
+            } else { // first range isn't sized, so must be forward
+                auto _Mid1 = _First1;
+                for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid1, (void) ++_Mid2, ++_Count2) {
+                    if (_Mid1 == _Last1) { // distance(_First1, _Last1) < distance(_First2, _Last2)
+                        return false;
+                    }
+                }
+
+                // distance(_First1, _Mid1) == distance(_First2, _Last2) == _Count2
+                while (_Mid1 != _Last1) {
+                    ++_First1;
+                    ++_Mid1;
+                }
+            }
+
+            return _RANGES _Equal_count(_STD move(_First1), _STD move(_First2),
+                static_cast<iter_difference_t<_It1>>(_Count2), _Pred, _Proj1, _Proj2);
+        }
+
+        template <class _It1, class _Se1, class _Diff1, class _It2, class _Se2, class _Diff2, class _Pr, class _Pj1,
+            class _Pj2>
+        _NODISCARD static constexpr bool _Ends_with_impl(_It1 _First1, _Se1 _Last1, _Diff1 _Count1, _It2 _First2,
+            _Se2 _Last2, _Diff2 _Count2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_Diff1, iter_difference_t<_It1>, _Not_a_difference>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_Diff2, iter_difference_t<_It2>, _Not_a_difference>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            constexpr bool _Sized1           = !same_as<_Diff1, _Not_a_difference>;
+            constexpr bool _Sized2           = !same_as<_Diff2, _Not_a_difference>;
+            constexpr bool _Both_sized       = _Sized1 && _Sized2;
+            constexpr bool _Both_bidi_common = _Bidi_common<_It1, _Se1> && _Bidi_common<_It2, _Se2>;
+
+            if constexpr (_Both_sized) {
+                if (_Count2 > _Count1) {
+                    return false;
+                }
+            }
+
+            if constexpr (_Sized2) {
+                if (_Count2 == 0) {
+                    return true;
+                }
+            }
+
+            if constexpr (_Both_bidi_common && !(random_access_iterator<_It1> && _Both_sized)) {
+                if constexpr (_Both_sized) {
+                    return _Match_backwards(unreachable_sentinel, _STD move(_Last1), _STD move(_First2),
+                        _STD move(_Last2), _Pred, _Proj1, _Proj2);
+                } else {
+                    return _Match_backwards(_STD move(_First1), _STD move(_Last1), _STD move(_First2),
+                        _STD move(_Last2), _Pred, _Proj1, _Proj2);
+                }
+            } else if constexpr (_Sized2) {
+                return _Ends_with_sized_needle(
+                    _STD move(_First1), _STD move(_Last1), _Count1, _STD move(_First2), _Count2, _Pred, _Proj1, _Proj2);
+            } else {
+                return _Ends_with_unsized_needle(_STD move(_First1), _STD move(_Last1), _Count1, _STD move(_First2),
+                    _STD move(_Last2), _Pred, _Proj1, _Proj2);
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Ends_with_fn ends_with;
+
+    template <class _Fn>
+    class _Flipped {
+    private:
+        _Fn _Func;
+
+    public:
+        template <class _Ty, class _Uty>
+            requires invocable<_Fn&, _Uty, _Ty>
+        invoke_result_t<_Fn&, _Uty, _Ty> operator()(_Ty&&, _Uty&&);
+    };
+
+    template <class _Fn, class _Ty, class _It, class _Uty>
+    concept _Indirectly_binary_left_foldable_impl =
+        movable<_Ty> && movable<_Uty> && convertible_to<_Ty, _Uty> && invocable<_Fn&, _Uty, iter_reference_t<_It>>
+        && assignable_from<_Uty&, invoke_result_t<_Fn&, _Uty, iter_reference_t<_It>>>;
+
+    template <class _Fn, class _Ty, class _It>
+    concept _Indirectly_binary_left_foldable =
+        copy_constructible<_Fn> && indirectly_readable<_It> && invocable<_Fn&, _Ty, iter_reference_t<_It>>
+        && convertible_to<invoke_result_t<_Fn&, _Ty, iter_reference_t<_It>>,
+            decay_t<invoke_result_t<_Fn&, _Ty, iter_reference_t<_It>>>>
+        && _Indirectly_binary_left_foldable_impl<_Fn, _Ty, _It,
+            decay_t<invoke_result_t<_Fn&, _Ty, iter_reference_t<_It>>>>;
+
+    template <class _Fn, class _Ty, class _It>
+    concept _Indirectly_binary_right_foldable = _Indirectly_binary_left_foldable<_Flipped<_Fn>, _Ty, _It>;
+
+    _EXPORT_STD template <class _It, class _Ty>
+    using fold_left_with_iter_result = in_value_result<_It, _Ty>;
+
+    _EXPORT_STD template <class _It, class _Ty>
+    using fold_left_first_with_iter_result = in_value_result<_It, _Ty>;
+
+    class _Fold_left_with_iter_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, _Indirectly_binary_left_foldable<_Ty, _It> _Fn>
+        _NODISCARD static constexpr auto operator()(_It _First, _Se _Last, _Ty _Init, _Fn _Func) {
+            _STD _Adl_verify_range(_First, _Last);
+            return _Fold_left_with_iter_impl<_It>(
+                _STD move(_First), _STD move(_Last), _STD move(_Init), _STD _Pass_fn(_Func));
+        }
+
+        template <input_range _Rng, class _Ty, _Indirectly_binary_left_foldable<_Ty, iterator_t<_Rng>> _Fn>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Ty _Init, _Fn _Func) {
+            return _Fold_left_with_iter_impl<borrowed_iterator_t<_Rng>>(
+                _RANGES begin(_Range), _RANGES end(_Range), _STD move(_Init), _STD _Pass_fn(_Func));
+        }
+
+    private:
+        template <class _RetIt, class _It, class _Se, class _Ty, class _Fn>
+        _NODISCARD static constexpr auto _Fold_left_with_iter_impl(_It&& _First, _Se&& _Last, _Ty&& _Init, _Fn _Func) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(_Indirectly_binary_left_foldable<_Fn, _Ty, _It>);
+
+            using _Uty         = decay_t<invoke_result_t<_Fn&, _Ty, iter_reference_t<_It>>>;
+            using _Return_type = fold_left_with_iter_result<_RetIt, _Uty>;
+
+            if (_First == _Last) {
+                return _Return_type{_STD move(_First), static_cast<_Uty>(_STD move(_Init))};
+            } else {
+                auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+                auto _ULast  = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+
+                _Uty _Accum = _STD invoke(_Func, _STD move(_Init), *_UFirst);
+                for (++_UFirst; _UFirst != _ULast; ++_UFirst) {
+                    _Accum = _STD invoke(_Func, _STD move(_Accum), *_UFirst);
+                }
+
+                _STD _Seek_wrapped(_First, _STD move(_UFirst));
+                return _Return_type{_STD move(_First), _STD move(_Accum)};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fold_left_with_iter_fn fold_left_with_iter;
+
+    struct _Fold_left_fn {
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, _Indirectly_binary_left_foldable<_Ty, _It> _Fn>
+        _NODISCARD static constexpr auto operator()(_It _First, _Se _Last, _Ty _Init, _Fn _Func) {
+            return _RANGES fold_left_with_iter(_STD move(_First), _Last, _STD move(_Init), _STD _Pass_fn(_Func)).value;
+        }
+
+        template <input_range _Rng, class _Ty, _Indirectly_binary_left_foldable<_Ty, iterator_t<_Rng>> _Fn>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Ty _Init, _Fn _Func) {
+            return _RANGES fold_left_with_iter(_STD forward<_Rng>(_Range), _STD move(_Init), _STD _Pass_fn(_Func))
+                .value;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fold_left_fn fold_left;
+
+    class _Fold_left_first_with_iter_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se,
+            _Indirectly_binary_left_foldable<iter_value_t<_It>, _It> _Fn>
+            requires constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
+        _NODISCARD static constexpr auto operator()(_It _First, _Se _Last, _Fn _Func) {
+            _STD _Adl_verify_range(_First, _Last);
+            return _Fold_left_first_with_iter_impl<_It>(_STD move(_First), _STD move(_Last), _STD _Pass_fn(_Func));
+        }
+
+        template <input_range _Rng, _Indirectly_binary_left_foldable<range_value_t<_Rng>, iterator_t<_Rng>> _Fn>
+            requires constructible_from<range_value_t<_Rng>, range_reference_t<_Rng>>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Fn _Func) {
+            return _Fold_left_first_with_iter_impl<borrowed_iterator_t<_Rng>>(
+                _RANGES begin(_Range), _RANGES end(_Range), _STD _Pass_fn(_Func));
+        }
+
+    private:
+        template <class _RetIt, class _It, class _Se, class _Fn>
+        _NODISCARD static constexpr auto _Fold_left_first_with_iter_impl(_It&& _First, _Se&& _Last, _Fn _Func) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(_Indirectly_binary_left_foldable<_Fn, iter_value_t<_It>, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
+
+            using _Uty =
+                decltype(_RANGES fold_left(_STD move(_First), _Last, static_cast<iter_value_t<_It>>(*_First), _Func));
+            using _Return_type = fold_left_first_with_iter_result<_RetIt, optional<_Uty>>;
+            if (_First == _Last) {
+                return _Return_type{_STD move(_First), optional<_Uty>{}};
+            } else {
+                auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+                auto _ULast  = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+
+                optional<_Uty> _Init{in_place, *_UFirst};
+                _Uty& _Init_ref = _Init.operator*(); // per LWG-3969
+                for (++_UFirst; _UFirst != _ULast; ++_UFirst) {
+                    _Init_ref = _STD invoke(_Func, _STD move(_Init_ref), *_UFirst);
+                }
+
+                _STD _Seek_wrapped(_First, _STD move(_UFirst));
+                return _Return_type{_STD move(_First), _STD move(_Init)};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fold_left_first_with_iter_fn fold_left_first_with_iter;
+
+    struct _Fold_left_first_fn {
+        template <input_iterator _It, sentinel_for<_It> _Se,
+            _Indirectly_binary_left_foldable<iter_value_t<_It>, _It> _Fn>
+            requires constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
+        _NODISCARD static constexpr auto operator()(_It _First, _Se _Last, _Fn _Func) {
+            return _RANGES fold_left_first_with_iter(_STD move(_First), _STD move(_Last), _STD _Pass_fn(_Func)).value;
+        }
+
+        template <input_range _Rng, _Indirectly_binary_left_foldable<range_value_t<_Rng>, iterator_t<_Rng>> _Fn>
+            requires constructible_from<range_value_t<_Rng>, range_reference_t<_Rng>>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Fn _Func) {
+            return _RANGES fold_left_first_with_iter(_STD forward<_Rng>(_Range), _STD _Pass_fn(_Func)).value;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fold_left_first_fn fold_left_first;
+
+    template <class _It, class _Se, class _Ty, class _Fn>
+    _NODISCARD constexpr auto _Fold_right_unchecked(_It _First, _Se _Last, _Ty _Init, _Fn _Func) {
+        _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It>);
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+        _STL_INTERNAL_STATIC_ASSERT(_Indirectly_binary_right_foldable<_Fn, _Ty, _It>);
+
+        using _Uty = decay_t<invoke_result_t<_Fn&, iter_reference_t<_It>, _Ty>>;
+        if (_First == _Last) {
+            return static_cast<_Uty>(_STD move(_Init));
+        } else {
+            _It _Tail   = _RANGES next(_First, _Last);
+            _Uty _Accum = _STD invoke(_Func, *--_Tail, _STD move(_Init));
+            while (_First != _Tail) {
+                _Accum = _STD invoke(_Func, *--_Tail, _STD move(_Accum));
+            }
+            return _Accum;
+        }
+    }
+
+    struct _Fold_right_fn {
+        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Ty,
+            _Indirectly_binary_right_foldable<_Ty, _It> _Fn>
+        _NODISCARD static constexpr auto operator()(_It _First, _Se _Last, _Ty _Init, _Fn _Func) {
+            _STD _Adl_verify_range(_First, _Last);
+            return _RANGES _Fold_right_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD move(_Init), _STD _Pass_fn(_Func));
+        }
+
+        template <bidirectional_range _Rng, class _Ty, _Indirectly_binary_right_foldable<_Ty, iterator_t<_Rng>> _Fn>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Ty _Init, _Fn _Func) {
+            return _RANGES _Fold_right_unchecked(
+                _Ubegin(_Range), _Uend(_Range), _STD move(_Init), _STD _Pass_fn(_Func));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fold_right_fn fold_right;
+
+    class _Fold_right_last_fn {
+    public:
+        template <bidirectional_iterator _It, sentinel_for<_It> _Se,
+            _Indirectly_binary_right_foldable<iter_value_t<_It>, _It> _Fn>
+            requires constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
+        _NODISCARD static constexpr auto operator()(_It _First, _Se _Last, _Fn _Func) {
+            _STD _Adl_verify_range(_First, _Last);
+            return _Fold_right_last_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Func));
+        }
+
+        template <bidirectional_range _Rng,
+            _Indirectly_binary_right_foldable<range_value_t<_Rng>, iterator_t<_Rng>> _Fn>
+            requires constructible_from<range_value_t<_Rng>, range_reference_t<_Rng>>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Fn _Func) {
+            return _Fold_right_last_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Func));
+        }
+
+    private:
+        template <class _It, class _Se, class _Fn>
+        _NODISCARD static constexpr auto _Fold_right_last_unchecked(_It _First, _Se _Last, _Fn _Func) {
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(_Indirectly_binary_right_foldable<_Fn, iter_value_t<_It>, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
+
+            using _Uty = decltype(_RANGES fold_right(_First, _Last, static_cast<iter_value_t<_It>>(*_First), _Func));
+            if (_First == _Last) {
+                return optional<_Uty>{};
+            } else {
+                _It _Tail = _RANGES prev(_RANGES next(_First, _STD move(_Last)));
+                return optional<_Uty>{in_place, _RANGES _Fold_right_unchecked(_STD move(_First), _Tail,
+                                                    static_cast<iter_value_t<_It>>(*_Tail), _STD move(_Func))};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fold_right_last_fn fold_right_last;
+
+    class _Find_last_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+        _NODISCARD static constexpr subrange<_It> operator()(_It _First, _Se _Last, const _Ty& _Value, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            if constexpr (bidirectional_iterator<_It>) {
+                auto _ULast = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+                auto _UResult =
+                    _Find_last_unchecked(_STD move(_UFirst), _STD move(_ULast), _Value, _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+            } else {
+                auto _ULast = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+                auto _UResult =
+                    _Find_last_unchecked(_STD move(_UFirst), _STD move(_ULast), _Value, _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+            }
+        }
+
+        template <forward_range _Rng, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
+        _NODISCARD static constexpr borrowed_subrange_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty& _Value, _Pj _Proj = {}) {
+            if constexpr (bidirectional_range<_Rng>) {
+                auto _UResult = _Find_last_unchecked(
+                    _Ubegin(_Range), _RANGES _Get_final_iterator_unwrapped(_Range), _Value, _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+            } else {
+                auto _UResult = _Find_last_unchecked(_Ubegin(_Range), _Uend(_Range), _Value, _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+            }
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty, class _Pj>
+        _NODISCARD static constexpr subrange<_It> _Find_last_unchecked(
+            _It _First, _Se _Last, const _Ty& _Value, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>);
+
+#if _VECTORIZED_FIND_LAST
+            if constexpr (is_same_v<_Pj, identity> && _Vector_alg_in_find_is_safe<_It, _Ty>
+                          && sized_sentinel_for<_Se, _It>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _Count = _Last - _First;
+
+                    if (!_STD _Could_compare_equal_to_value_type<_It>(_Value)) {
+                        return {_First + _Count, _First + _Count};
+                    }
+
+                    const auto _First_ptr = _STD _To_address(_First);
+                    const auto _Last_ptr  = _STD _To_address(_First + _Count);
+
+                    const auto _Result = _STD _Find_last_vectorized(_First_ptr, _Last_ptr, _Value);
+                    if constexpr (is_pointer_v<_It>) {
+                        return {_Result, _Last_ptr};
+                    } else {
+                        return {_First + static_cast<iter_difference_t<_It>>(_Result - _First_ptr), _First + _Count};
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_FIND_LAST ^^^
+
+            if constexpr (_Bidi_common<_It, _Se>) {
+                for (auto _Result = _Last; _Result != _First;) {
+                    if (_STD invoke(_Proj, *--_Result) == _Value) {
+                        return {_STD move(_Result), _STD move(_Last)};
+                    }
+                }
+                return {_Last, _Last};
+            } else if constexpr (same_as<_It, _Se>) {
+                auto _Result = _Last;
+                for (; _First != _Last; ++_First) {
+                    if (_STD invoke(_Proj, *_First) == _Value) {
+                        _Result = _First;
+                    }
+                }
+                return {_STD move(_Result), _STD move(_Last)};
+            } else {
+                auto _Result = _First;
+                bool _Found  = false;
+                for (;; ++_First) {
+                    if (_First == _Last) {
+                        if (!_Found) {
+                            _Result = _First;
+                        }
+                        break;
+                    }
+
+                    if (_STD invoke(_Proj, *_First) == _Value) {
+                        _Result = _First;
+                        _Found  = true;
+                    }
+                }
+                return {_STD move(_Result), _STD move(_First)};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_last_fn find_last;
+
+    template <bool _Search_for>
+    class _Find_last_if_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr subrange<_It> operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            if constexpr (bidirectional_iterator<_It>) {
+                auto _ULast   = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+                auto _UResult = _Find_last_if_unchecked(
+                    _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+            } else {
+                auto _ULast   = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+                auto _UResult = _Find_last_if_unchecked(
+                    _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+            }
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            if constexpr (bidirectional_range<_Rng>) {
+                auto _UResult = _Find_last_if_unchecked(_Ubegin(_Range), _RANGES _Get_final_iterator_unwrapped(_Range),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+            } else {
+                auto _UResult =
+                    _Find_last_if_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+            }
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr subrange<_It> _Find_last_if_unchecked(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            if constexpr (_Bidi_common<_It, _Se>) {
+                for (auto _Result = _Last; _Result != _First;) {
+                    if (_STD invoke_r<bool>(_Pred, _STD invoke(_Proj, *--_Result)) == _Search_for) {
+                        return {_STD move(_Result), _STD move(_Last)};
+                    }
+                }
+                return {_Last, _Last};
+            } else if constexpr (same_as<_It, _Se>) {
+                auto _Result = _Last;
+                for (; _First != _Last; ++_First) {
+                    if (_STD invoke_r<bool>(_Pred, _STD invoke(_Proj, *_First)) == _Search_for) {
+                        _Result = _First;
+                    }
+                }
+                return {_STD move(_Result), _STD move(_Last)};
+            } else {
+                auto _Result = _First;
+                bool _Found  = false;
+                for (;; ++_First) {
+                    if (_First == _Last) {
+                        if (!_Found) {
+                            _Result = _First;
+                        }
+                        break;
+                    }
+
+                    if (_STD invoke_r<bool>(_Pred, _STD invoke(_Proj, *_First)) == _Search_for) {
+                        _Result = _First;
+                        _Found  = true;
+                    }
+                }
+                return {_STD move(_Result), _STD move(_First)};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_last_if_fn<true> find_last_if;
+    _EXPORT_STD inline constexpr _Find_last_if_fn<false> find_last_if_not;
+#endif // _HAS_CXX23
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt1 find_end(
+    _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, _Pr _Pred) {
+    // find last [_First2, _Last2) satisfying _Pred
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1       = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+    const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    if constexpr (_Is_ranges_random_iter_v<_FwdIt1> && _Is_ranges_random_iter_v<_FwdIt2>) {
+        const _Iter_diff_t<_FwdIt2> _Count2 = _ULast2 - _UFirst2;
+        if (_Count2 > 0 && _Count2 <= _ULast1 - _UFirst1) {
+#if _VECTORIZED_FIND_END
+            if constexpr (_Vector_alg_in_search_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+                if (!_STD _Is_constant_evaluated()) {
+                    const auto _Ptr1 = _STD _To_address(_UFirst1);
+                    (void) _STD _To_address(_ULast2);
+
+                    const auto _Ptr_res1 = _STD _Find_end_vectorized(
+                        _Ptr1, _STD _To_address(_ULast1), _STD _To_address(_UFirst2), static_cast<size_t>(_Count2));
+
+                    if constexpr (is_pointer_v<decltype(_UFirst1)>) {
+                        _UFirst1 = _Ptr_res1;
+                    } else {
+                        _UFirst1 += static_cast<_Iter_diff_t<decltype(_UFirst1)>>(_Ptr_res1 - _Ptr1);
+                    }
+
+                    _STD _Seek_wrapped(_First1, _UFirst1);
+                    return _First1;
+                }
+            }
+#endif // ^^^ _VECTORIZED_FIND_END ^^^
+
+            for (auto _UCandidate = _ULast1 - static_cast<_Iter_diff_t<_FwdIt1>>(_Count2);; --_UCandidate) {
+                if (_STD _Equal_rev_pred_unchecked(_UCandidate, _UFirst2, _ULast2, _STD _Pass_fn(_Pred))) {
+                    _STD _Seek_wrapped(_First1, _UCandidate);
+                    return _First1;
+                }
+
+                if (_UCandidate == _UFirst1) {
+                    break;
+                }
+            }
+        }
+
+        return _Last1;
+    } else if constexpr (_Is_ranges_bidi_iter_v<_FwdIt1> && _Is_ranges_bidi_iter_v<_FwdIt2>) {
+        for (auto _UCandidate = _ULast1;; --_UCandidate) { // try a match at _UCandidate
+            auto _UNext1 = _UCandidate;
+            auto _UNext2 = _ULast2;
+            for (;;) { // test if [_UFirst2, _ULast2) is a suffix of [_UFirst1, _UCandidate)
+                if (_UFirst2 == _UNext2) { // match found
+                    _STD _Seek_wrapped(_First1, _UNext1);
+                    return _First1;
+                }
+
+                if (_UFirst1 == _UNext1) {
+                    // [_UFirst1, _UCandidate) is shorter than [_UFirst2, _ULast2), remaining candidates nonviable
+                    return _Last1;
+                }
+
+                --_UNext1;
+                --_UNext2;
+                if (!_Pred(*_UNext1, *_UNext2)) { // counterexample found
+                    break;
+                }
+            }
+        }
+    } else {
+        auto _UResult = _ULast1;
+        for (;;) { // try a match at _UFirst1
+            auto _UNext1 = _UFirst1;
+            auto _UNext2 = _UFirst2;
+            for (;;) { // test if [_UFirst2, _ULast2) is a prefix of [_UFirst1, _ULast1)
+                const bool _End_of_needle = static_cast<bool>(_UNext2 == _ULast2);
+                if (_End_of_needle) { // match candidate found
+                    _UResult = _UFirst1;
+                }
+
+                if (_UNext1 == _ULast1) {
+                    // trying the next candidate would make [_UFirst1, _ULast1) shorter than [_UFirst2, _ULast2), done
+                    _STD _Seek_wrapped(_First1, _UResult);
+                    return _First1;
+                }
+
+                if (_End_of_needle || !_Pred(*_UNext1, *_UNext2)) {
+                    break; // end of match or counterexample found, go to the next candidate
+                }
+
+                ++_UNext1;
+                ++_UNext2;
+            }
+
+            ++_UFirst1;
+        }
+
+        _STD _Seek_wrapped(_First1, _UResult);
+        return _First1;
+    }
+}
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
+_NODISCARD _CONSTEXPR20 _FwdIt1 find_end(
+    _FwdIt1 const _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2) {
+    // find last [_First2, _Last2) match
+    return _STD find_end(_First1, _Last1, _First2, _Last2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt1 find_end(
+    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt1 find_end(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept
+/* terminates */ { // find last [_First2, _Last2) match
+    return _STD find_end(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Find_end_fn {
+    private:
+        template <class _It1, class _It2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr subrange<_It1> _Random_access_sized_ranges(_It1 _First1,
+            const iter_difference_t<_It1> _Count1, _It2 _First2, const iter_difference_t<_It2> _Count2, _Pr _Pred,
+            _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+            // pre: _First1 + [0, _Count1) is a valid counted range
+            // pre: _First2 + [0, _Count2) is a valid counted range
+
+            if (_Count2 > 0 && _Count2 <= _Count1) {
+                const auto _Count2_as1 = static_cast<iter_difference_t<_It1>>(_Count2);
+#if _VECTORIZED_FIND_END
+                if constexpr (_Vector_alg_in_search_is_safe<_It1, _It2, _Pr> && is_same_v<_Pj1, identity>
+                              && is_same_v<_Pj2, identity>) {
+                    if (!_STD is_constant_evaluated()) {
+                        _STD _Contiguous_iter_verify(_First2, _Count2);
+
+                        const auto _Ptr1      = _STD to_address(_First1);
+                        const auto _Ptr2      = _STD to_address(_First2);
+                        const auto _Ptr_last1 = _STD to_address(_First1 + _Count1);
+
+                        const auto _Ptr_res1 =
+                            _STD _Find_end_vectorized(_Ptr1, _Ptr_last1, _Ptr2, static_cast<size_t>(_Count2));
+
+                        if constexpr (is_pointer_v<_It1>) {
+                            if (_Ptr_res1 != _Ptr_last1) {
+                                return {_Ptr_res1, _Ptr_res1 + _Count2};
+                            } else {
+                                return {_Ptr_res1, _Ptr_res1};
+                            }
+                        } else {
+                            _First1 += static_cast<iter_difference_t<_It1>>(_Ptr_res1 - _Ptr1);
+                            if (_Ptr_res1 != _Ptr_last1) {
+                                return {_First1, _First1 + _Count2_as1};
+                            } else {
+                                return {_First1, _First1};
+                            }
+                        }
+                    }
+                }
+#endif // ^^^ _VECTORIZED_FIND_END ^^^
+
+                for (auto _Candidate = _First1 + (_Count1 - _Count2_as1);; --_Candidate) {
+                    auto _Match_and_mid1 =
+                        _RANGES _Equal_rev_pred(_Candidate, _First2, _First2 + _Count2, _Pred, _Proj1, _Proj2);
+                    if (_Match_and_mid1.first) {
+                        return {_STD move(_Candidate), _STD move(_Match_and_mid1.second)};
+                    }
+
+                    if (_Candidate == _First1) {
+                        break;
+                    }
+                }
+            }
+
+            _First1 += _Count1;
+            return {_First1, _First1};
+        }
+
+        template <class _It1, class _It2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr subrange<_It1> _Bidi_common_ranges(
+            _It1 _First1, _It1 _Last1, _It2 _First2, const _It2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            for (auto _Candidate = _Last1;; --_Candidate) { // try a match at _Candidate
+                auto _Next1 = _Candidate;
+                auto _Next2 = _Last2;
+                for (;;) { // test if [_First2, _Last2) is a suffix of [_First1, _Candidate)
+                    if (_First2 == _Next2) { // match found
+                        return {_STD move(_Next1), _STD move(_Candidate)};
+                    }
+
+                    if (_First1 == _Next1) {
+                        // [_First1, _Candidate) is shorter than [_First2, _Last2); remaining candidates nonviable
+                        return {_Last1, _Last1};
+                    }
+
+                    --_Next1;
+                    --_Next2;
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_Next1), _STD invoke(_Proj2, *_Next2))) {
+                        break; // mismatch
+                    }
+                }
+            }
+        }
+
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr subrange<_It1> _Forward_ranges(
+            _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            subrange<_It1> _Match{};
+            bool _Found = false;
+
+            for (;; ++_First1) { // try a match at _First1
+                auto _Next1 = _First1;
+                auto _Next2 = _First2;
+                for (;; ++_Next1, (void) ++_Next2) { // test if [_First2, _Last2) is a prefix of [_First1, _Last1)
+                    const bool _End_of_needle = _Next2 == _Last2;
+                    if (_End_of_needle) { // match candidate found
+                        _Match = subrange{_First1, _Next1};
+                        _Found = true;
+                    }
+
+                    if (_Next1 == _Last1) { // haystack exhausted
+                        if (!_Found) {
+                            _Match = subrange{_Next1, _Next1};
+                        }
+
+                        return _Match;
+                    }
+
+                    if (_End_of_needle) {
+                        break; // end of match found, go to the next candidate
+                    }
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_Next1), _STD invoke(_Proj2, *_Next2))) {
+                        break; // mismatch, go to the next candidate
+                    }
+                }
+            }
+        }
+
+    public:
+        template <forward_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr subrange<_It1> operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UFirst1 = _RANGES _Unwrap_iter<_Se1>(_First1);
+            auto _ULast1  = _RANGES _Unwrap_sent<_It1>(_Last1);
+            auto _UFirst2 = _RANGES _Unwrap_iter<_Se2>(_First2);
+            auto _ULast2  = _RANGES _Unwrap_sent<_It2>(_Last2);
+
+            if constexpr (random_access_iterator<_It1> && sized_sentinel_for<_Se1, _It1> && random_access_iterator<_It2>
+                          && sized_sentinel_for<_Se2, _It2>) {
+                const auto _Count1 = _ULast1 - _UFirst1;
+                const auto _Count2 = _ULast2 - _UFirst2;
+                auto _UResult = _Random_access_sized_ranges(_STD move(_UFirst1), _Count1, _STD move(_UFirst2), _Count2,
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<subrange<_It1>>(_First1, _STD move(_UResult));
+            } else if constexpr (_Bidi_common<_It1, _Se1> && _Bidi_common<_It2, _Se2>) {
+                auto _UResult = _Bidi_common_ranges(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                    _STD move(_ULast2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<subrange<_It1>>(_First1, _STD move(_UResult));
+            } else {
+                auto _UResult = _Forward_ranges(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                    _STD move(_ULast2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<subrange<_It1>>(_First1, _STD move(_UResult));
+            }
+        }
+
+        template <forward_range _Rng1, forward_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr borrowed_subrange_t<_Rng1> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            if constexpr (random_access_range<_Rng1> && sized_range<_Rng1> && random_access_range<_Rng2>
+                          && sized_range<_Rng2>) {
+                auto _UResult =
+                    _Random_access_sized_ranges(_Ubegin(_Range1), _RANGES distance(_Range1), _Ubegin(_Range2),
+                        _RANGES distance(_Range2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, _STD move(_UResult));
+            } else if constexpr (_Bidi_common_range<_Rng1> && _Bidi_common_range<_Rng2>) {
+                auto _UResult = _Bidi_common_ranges(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, _STD move(_UResult));
+            } else {
+                auto _UResult = _Forward_ranges(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, _STD move(_UResult));
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_end_fn find_end;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of(
+    _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, _Pr _Pred) {
+    // look for one of [_First2, _Last2) satisfying _Pred with element
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    auto _ULast1       = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+
+    constexpr bool _Is_predicate_equal = _Is_any_of_v<_Pr,
+#if _HAS_CXX20
+        _RANGES equal_to,
+#endif // _HAS_CXX20
+        _STD equal_to<>>;
+
+    if constexpr (_Is_ranges_random_iter_v<decltype(_UFirst2)> && _Is_predicate_equal) {
+        const auto _Count2 = _ULast2 - _UFirst2;
+        if (_Count2 == 1) {
+            _UFirst1 = _STD _Find_unchecked(_STD move(_UFirst1), _STD move(_ULast1), *_UFirst2);
+            _STD _Seek_wrapped(_First1, _UFirst1);
+            return _First1;
+        }
+    }
+
+#if _VECTORIZED_FIND_FIRST_OF
+    if constexpr (_Vector_alg_in_search_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+        if (!_STD _Is_constant_evaluated() && _ULast1 - _UFirst1 >= _Threshold_find_first_of) {
+            const auto _First1_ptr = _STD _To_address(_UFirst1);
+            const auto _Result     = _STD _Find_first_of_vectorized(
+                _First1_ptr, _STD _To_address(_ULast1), _STD _To_address(_UFirst2), _STD _To_address(_ULast2));
+
+            if constexpr (is_pointer_v<decltype(_UFirst1)>) {
+                _UFirst1 = _Result;
+            } else {
+                _UFirst1 += static_cast<_Iter_diff_t<decltype(_UFirst1)>>(_Result - _First1_ptr);
+            }
+            _STD _Seek_wrapped(_First1, _UFirst1);
+            return _First1;
+        }
+    }
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+    for (; _UFirst1 != _ULast1; ++_UFirst1) {
+        for (auto _UMid2 = _UFirst2; _UMid2 != _ULast2; ++_UMid2) {
+            if (_Pred(*_UFirst1, *_UMid2)) {
+                _STD _Seek_wrapped(_First1, _UFirst1);
+                return _First1;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First1, _UFirst1);
+    return _First1;
+}
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
+_NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of(const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2) { // look for one of [_First2, _Last2) that matches element
+    return _STD find_first_of(_First1, _Last1, _First2, _Last2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt1 find_first_of(
+    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2) noexcept /* terminates */ { // look for one of [_First2, _Last2) that matches element
+    return _STD find_first_of(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Find_first_of_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr _It1 operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+
+            auto _UResult = _Find_first_of_unchecked(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult));
+            return _First1;
+        }
+
+        template <input_range _Rng1, forward_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng1> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            auto _First1 = _RANGES begin(_Range1);
+
+            auto _UResult = _Find_first_of_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult));
+            return _First1;
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr _It1 _Find_first_of_unchecked(
+            _It1 _First1, _Se1 _Last1, const _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            if constexpr (_Is_ranges_random_iter_v<_It2> && sized_sentinel_for<_Se2, _It2>
+                          && _Is_any_of_v<_Pr, _STD equal_to<>, _RANGES equal_to>) {
+                const auto _Count2 = _Last2 - _First2;
+                if (_Count2 == 1) {
+                    return _RANGES _Find_unchecked(
+                        _STD move(_First1), _STD move(_Last1), _STD invoke(_Proj2, *_First2), _Proj1);
+                }
+            }
+
+#if _VECTORIZED_FIND_FIRST_OF
+            if constexpr (_Vector_alg_in_search_is_safe<_It1, _It2, _Pr> && sized_sentinel_for<_Se1, _It1>
+                          && sized_sentinel_for<_Se2, _It2> && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) {
+                if (!_STD is_constant_evaluated() && _Last1 - _First1 >= _Threshold_find_first_of) {
+                    const auto _First1_ptr = _STD _To_address(_First1);
+                    const auto _Last1_ptr  = _STD _To_address(_First1 + (_Last1 - _First1));
+
+                    const auto _First2_ptr = _STD _To_address(_First2);
+                    const auto _Last2_ptr  = _STD _To_address(_First2 + (_Last2 - _First2));
+
+                    const auto _Result =
+                        _STD _Find_first_of_vectorized(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr);
+
+                    if constexpr (is_pointer_v<_It1>) {
+                        return _Result;
+                    } else {
+                        return _First1 + static_cast<iter_difference_t<_It1>>(_Result - _First1_ptr);
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF ^^^
+
+            for (; _First1 != _Last1; ++_First1) {
+                for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_Mid2))) {
+                        return _First1;
+                    }
+                }
+            }
+
+            return _First1;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_first_of_fn find_first_of;
+
+    template <class _Ty>
+    constexpr bool _Is_trivially_ranges_swappable_v =
+        disjunction_v<conjunction<is_scalar<_Ty>, negation<is_enum<_Ty>>>, _Is_trivially_swappable<_Ty>>;
+
+    template <class _Ty, size_t _Len>
+    constexpr bool _Is_trivially_ranges_swappable_v<_Ty[_Len]> = _Is_trivially_ranges_swappable_v<_Ty>;
+
+    template <class _Ty>
+    struct _Is_trivially_ranges_swappable : bool_constant<_Is_trivially_ranges_swappable_v<_Ty>> {};
+
+    _EXPORT_STD template <class _In1, class _In2>
+    using swap_ranges_result = in_in_result<_In1, _In2>;
+
+    template <class _It1, class _Se1, class _It2, class _Se2>
+    _NODISCARD constexpr swap_ranges_result<_It1, _It2> _Swap_ranges_common(
+        _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2) {
+        _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+        _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+        _STL_INTERNAL_STATIC_ASSERT(indirectly_swappable<_It1, _It2>);
+
+#if _VECTORIZED_SWAP_RANGES
+        using _Elem1 = remove_reference_t<iter_reference_t<_It1>>;
+        using _Elem2 = remove_reference_t<iter_reference_t<_It2>>;
+        if constexpr (same_as<_Elem1, _Elem2> && _Is_trivially_ranges_swappable_v<_Elem1> //
+                      && contiguous_iterator<_It1> && _Sized_or_unreachable_sentinel_for<_Se1, _It1> //
+                      && contiguous_iterator<_It2> && _Sized_or_unreachable_sentinel_for<_Se2, _It2>) {
+            if (!_STD is_constant_evaluated()) {
+                constexpr bool _Is_sized1 = sized_sentinel_for<_Se1, _It1>;
+                constexpr bool _Is_sized2 = sized_sentinel_for<_Se2, _It2>;
+                const auto _First1_addr   = _STD to_address(_First1);
+                const auto _First2_addr   = _STD to_address(_First2);
+                if constexpr (_Is_sized1 && _Is_sized2) {
+                    const size_t _Count =
+                        (_STD min) (static_cast<size_t>(_Last1 - _First1), static_cast<size_t>(_Last2 - _First2));
+                    const auto _Last1_addr = _STD to_address(_First1 + static_cast<iter_difference_t<_It1>>(_Count));
+                    _STD _Contiguous_iter_verify(_First2, static_cast<iter_difference_t<_It2>>(_Count));
+                    ::__std_swap_ranges_trivially_swappable_noalias(_First1_addr, _Last1_addr, _First2_addr);
+                    return {_First1 + static_cast<iter_difference_t<_It1>>(_Count),
+                        _First2 + static_cast<iter_difference_t<_It2>>(_Count)};
+                } else if constexpr (_Is_sized1) {
+                    const auto _Dist1      = _Last1 - _First1;
+                    const auto _Final1     = _First1 + _Dist1;
+                    const auto _Last1_addr = _STD to_address(_Final1);
+                    _STD _Contiguous_iter_verify(_First2, static_cast<iter_difference_t<_It2>>(_Dist1));
+                    ::__std_swap_ranges_trivially_swappable_noalias(_First1_addr, _Last1_addr, _First2_addr);
+                    return {_Final1, _First2 + static_cast<iter_difference_t<_It2>>(_Dist1)};
+                } else if constexpr (_Is_sized2) {
+                    const auto _Dist2      = _Last2 - _First2;
+                    const auto _Final2     = _First2 + _Dist2;
+                    const auto _Last2_addr = _STD to_address(_Final2);
+                    _STD _Contiguous_iter_verify(_First1, static_cast<iter_difference_t<_It1>>(_Dist2));
+                    ::__std_swap_ranges_trivially_swappable_noalias(_First2_addr, _Last2_addr, _First1_addr);
+                    return {_First1 + static_cast<iter_difference_t<_It1>>(_Dist2), _Final2};
+                } else {
+                    _STL_ASSERT(false, "Tried to swap_ranges with two unreachable sentinels");
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_SWAP_RANGES ^^^
+
+        for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void) ++_First2) {
+            _RANGES iter_swap(_First1, _First2);
+        }
+
+        return {_STD move(_First1), _STD move(_First2)};
+    }
+
+    struct _Swap_ranges_fn {
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2>
+            requires indirectly_swappable<_It1, _It2>
+        static constexpr swap_ranges_result<_It1, _It2> operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+
+            auto _UResult = _RANGES _Swap_ranges_common(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            return {_STD move(_First1), _STD move(_First2)};
+        }
+
+        template <input_range _Rng1, input_range _Rng2>
+            requires indirectly_swappable<iterator_t<_Rng1>, iterator_t<_Rng2>>
+        static constexpr swap_ranges_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2) {
+            auto _First1 = _RANGES begin(_Range1);
+            auto _First2 = _RANGES begin(_Range2);
+
+            auto _UResult = _RANGES _Swap_ranges_common(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                _Uend(_Range1), _RANGES _Unwrap_range_iter<_Rng2>(_STD move(_First2)), _Uend(_Range2));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            return {_STD move(_First1), _STD move(_First2)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Swap_ranges_fn swap_ranges;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
+_CONSTEXPR20 _FwdIt2 swap_ranges(const _FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) {
+    // swap [_First1, _Last1) with [_First2, ...)
+    _STD _Adl_verify_range(_First1, _Last1);
+    const auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    const auto _UFirst2 = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_FwdIt1>(_UFirst1, _ULast1));
+    _STD _Verify_ranges_do_not_overlap(_UFirst1, _ULast1, _UFirst2);
+    _STD _Seek_wrapped(_First2, _STD _Swap_ranges_unchecked(_UFirst1, _ULast1, _UFirst2));
+    return _First2;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 swap_ranges(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // swap [_First1, _Last1) with [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD swap_ranges(_First1, _Last1, _Dest);
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _FwdIt1, class _FwdIt2>
+_CONSTEXPR20 void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right) { // swap *_Left and *_Right
+    swap(*_Left, *_Right); // intentional ADL
+}
+
+template <class _VbIt, class _OutIt, class _Mapped_fn>
+_CONSTEXPR20 _OutIt _Transform_vbool_aligned(_VbIt _First, _VbIt _Last, _OutIt _Dest, _Mapped_fn _Mapped_func);
+
+template <class _VbIt1, class _VbIt2, class _OutIt, class _Mapped_fn>
+_CONSTEXPR20 _OutIt _Transform_vbool_aligned(
+    _VbIt1 _First1, _VbIt1 _Last1, _VbIt2 _First2, _OutIt _Dest, _Mapped_fn _Mapped_func);
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Fn>
+_CONSTEXPR20 _OutIt transform(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Fn _Func) {
+    // transform [_First, _Last) with _Func
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+
+    if constexpr (_Is_vb_iterator<decltype(_UFirst)> && _Is_vb_iterator<decltype(_UDest), true>
+                  && !is_void_v<_Map_vb_functor_t<_Fn>>) {
+        if (_UFirst._Myoff == 0 && _UDest._Myoff == 0) {
+            _UDest = _Transform_vbool_aligned(_UFirst, _ULast, _UDest, _Map_vb_functor_t<_Fn>{});
+            _STD _Seek_wrapped(_Dest, _UDest);
+            return _Dest;
+        }
+    }
+
+    for (; _UFirst != _ULast; ++_UFirst, (void) ++_UDest) {
+        *_UDest = _Func(*_UFirst);
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 transform(_ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Fn _Func) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Fn>
+_CONSTEXPR20 _OutIt transform(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _OutIt _Dest, _Fn _Func) {
+    // transform [_First1, _Last1) and [_First2, ...) with _Func
+    _STD _Adl_verify_range(_First1, _Last1);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    const auto _Count  = _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1);
+    auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _Count);
+    auto _UDest        = _STD _Get_unwrapped_n(_Dest, _Count);
+
+    if constexpr (_Is_vb_iterator<decltype(_UFirst1)> && _Is_vb_iterator<decltype(_UFirst2)>
+                  && _Is_vb_iterator<decltype(_UDest), true> && !is_void_v<_Map_vb_functor_t<_Fn>>) {
+        if (_UFirst1._Myoff == 0 && _UFirst2._Myoff == 0 && _UDest._Myoff == 0) {
+            _UDest = _Transform_vbool_aligned(_UFirst1, _ULast1, _UFirst2, _UDest, _Map_vb_functor_t<_Fn>{});
+            _STD _Seek_wrapped(_Dest, _UDest);
+            return _Dest;
+        }
+    }
+
+    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2, ++_UDest) {
+        *_UDest = _Func(*_UFirst1, *_UFirst2);
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 transform(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt3 _Dest,
+    _Fn _Func) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _Diff1, class _Diff2>
+    _NODISCARD constexpr auto _Idl_dist_min([[maybe_unused]] const _Diff1 _Lhs, [[maybe_unused]] const _Diff2 _Rhs) {
+        // returns the minimum of two results from _Idl_distance calls
+        if constexpr (is_same_v<_Diff1, _Distance_unknown> || is_same_v<_Diff2, _Distance_unknown>) {
+            return _Distance_unknown{};
+        } else if constexpr (is_same_v<_Diff1, _Distance_unbounded>) {
+            return _Rhs;
+        } else if constexpr (is_same_v<_Diff2, _Distance_unbounded>) {
+            return _Lhs;
+        } else {
+            if (_Rhs < _Lhs) {
+                return static_cast<_Diff1>(_Rhs);
+            } else {
+                return _Lhs;
+            }
+        }
+    }
+
+    _EXPORT_STD template <class _In, class _Out>
+    using unary_transform_result = in_out_result<_In, _Out>;
+
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
+    using binary_transform_result = in_in_out_result<_In1, _In2, _Out>;
+
+    class _Transform_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, copy_constructible _Fn,
+            class _Pj = identity>
+            requires indirectly_writable<_Out, indirect_result_t<_Fn&, projected<_It, _Pj>>>
+        static constexpr unary_transform_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Output, _Fn _Func, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast       = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _Count = _RANGES _Idl_distance<_It>(_UFirst, _ULast);
+
+            auto _UResult = _Transform_unary_unchecked(_STD move(_UFirst), _STD move(_ULast),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count), _STD _Pass_fn(_Func), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out, copy_constructible _Fn, class _Pj = identity>
+            requires indirectly_writable<_Out, indirect_result_t<_Fn&, projected<iterator_t<_Rng>, _Pj>>>
+        static constexpr unary_transform_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, _Out _Output, _Fn _Func, _Pj _Proj = {}) {
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _First       = _RANGES begin(_Range);
+
+            auto _UResult =
+                _Transform_unary_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                    _STD _Get_unwrapped_n(_STD move(_Output), _Count), _STD _Pass_fn(_Func), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            weakly_incrementable _Out, copy_constructible _Fn, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_writable<_Out, indirect_result_t<_Fn&, projected<_It1, _Pj1>, projected<_It2, _Pj2>>>
+        static constexpr binary_transform_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
+            _Se2 _Last2, _Out _Output, _Fn _Func, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+
+            auto _UFirst1      = _RANGES _Unwrap_iter<_Se1>(_STD move(_First1));
+            auto _ULast1       = _RANGES _Unwrap_sent<_It1>(_STD move(_Last1));
+            const auto _Count1 = _RANGES _Idl_distance<_It1>(_UFirst1, _ULast1);
+            auto _UFirst2      = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            auto _ULast2       = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+            const auto _Count2 = _RANGES _Idl_distance<_It2>(_UFirst2, _ULast2);
+            const auto _Count  = _RANGES _Idl_dist_min(_Count1, _Count2);
+
+            auto _UResult = _Transform_binary_unchecked(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                _STD move(_ULast2), _STD _Get_unwrapped_n(_STD move(_Output), _Count), _STD _Pass_fn(_Func),
+                _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, copy_constructible _Fn,
+            class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_writable<_Out,
+                indirect_result_t<_Fn&, projected<iterator_t<_Rng1>, _Pj1>, projected<iterator_t<_Rng2>, _Pj2>>>
+        static constexpr binary_transform_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out>
+            operator()(_Rng1&& _Range1, _Rng2&& _Range2, _Out _Output, _Fn _Func, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            const auto _Count = _RANGES _Idl_dist_min(_RANGES _Idl_distance(_Range1), _RANGES _Idl_distance(_Range2));
+            auto _First1      = _RANGES begin(_Range1);
+            auto _First2      = _RANGES begin(_Range2);
+
+            auto _UResult = _Transform_binary_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                _Uend(_Range1), _RANGES _Unwrap_range_iter<_Rng2>(_STD move(_First2)), _Uend(_Range2),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count), _STD _Pass_fn(_Func), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Out, class _Fn, class _Pj>
+        _NODISCARD static constexpr unary_transform_result<_It, _Out> _Transform_unary_unchecked(
+            _It _First, const _Se _Last, _Out _Output, _Fn _Func, _Pj _Proj) {
+            // transform projected [_First, _Last) with _Func
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_writable<_Out, indirect_result_t<_Fn&, projected<_It, _Pj>>>);
+
+            for (; _First != _Last; ++_First, (void) ++_Output) {
+                *_Output = _STD invoke(_Func, _STD invoke(_Proj, *_First));
+            }
+
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Fn, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr binary_transform_result<_It1, _It2, _Out> _Transform_binary_unchecked(_It1 _First1,
+            const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Out _Output, _Fn _Func, _Pj1 _Proj1, _Pj2 _Proj2) {
+            // transform projected [_First1, _Last1) and projected [_First2, _Last2) with _Func
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(
+                indirectly_writable<_Out, indirect_result_t<_Fn&, projected<_It1, _Pj1>, projected<_It2, _Pj2>>>);
+
+            for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void) ++_First2, ++_Output) {
+                *_Output = _STD invoke(_Func, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2));
+            }
+
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Transform_fn transform;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_CONSTEXPR20 void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval) {
+    // replace each matching _Oldval with _Newval
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+#if _VECTORIZED_REPLACE
+    if constexpr (_Vector_alg_in_replace_is_safe<decltype(_UFirst), _Ty>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if (_STD _Could_compare_equal_to_value_type<decltype(_UFirst)>(_Oldval)) {
+                _STD _Replace_vectorized(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Oldval, _Newval);
+            }
+
+            return;
+        }
+    }
+#endif // ^^^ _VECTORIZED_REPLACE ^^^
+
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (*_UFirst == _Oldval) {
+            *_UFirst = _Newval;
+        }
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+void replace(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, const _Ty& _Oldval,
+    const _Ty& _Newval) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Replace_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty1, class _Ty2, class _Pj = identity>
+            requires indirectly_writable<_It, const _Ty2&>
+                  && indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty1*>
+        static constexpr _It operator()(
+            _It _First, _Se _Last, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Replace_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _Oldval, _Newval, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <input_range _Rng, class _Ty1, class _Ty2, class _Pj = identity>
+            requires indirectly_writable<iterator_t<_Rng>, const _Ty2&>
+                  && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty1*>
+        static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _Replace_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _Oldval, _Newval, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty1, class _Ty2, class _Pj>
+        _NODISCARD static constexpr _It _Replace_unchecked(
+            _It _First, const _Se _Last, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj) {
+            // replace projected _Oldval with _Newval in [_First, _Last)
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_writable<_It, const _Ty2&>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty1*>);
+
+#if _VECTORIZED_REPLACE
+            if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It>
+                          && _Vector_alg_in_ranges_replace_is_safe<_It, _Ty1, _Ty2>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _Count = _Last - _First;
+
+                    if (_STD _Could_compare_equal_to_value_type<_It>(_Oldval)) {
+                        const auto _First_ptr = _STD to_address(_First);
+                        const auto _Last_ptr  = _STD to_address(_First + _Count);
+                        _STD _Replace_vectorized(_First_ptr, _Last_ptr, _Oldval, _Newval);
+                    }
+
+                    return _First + _Count;
+                }
+            }
+#endif // ^^^ _VECTORIZED_REPLACE ^^^
+
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Proj, *_First) == _Oldval) {
+                    *_First = _Newval;
+                }
+            }
+
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Replace_fn replace;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Pr, class _Ty>
+_CONSTEXPR20 void replace_if(const _FwdIt _First, const _FwdIt _Last, _Pr _Pred, const _Ty& _Val) {
+    // replace each satisfying _Pred with _Val
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (_Pred(*_UFirst)) {
+            *_UFirst = _Val;
+        }
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+void replace_if(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty& _Val) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Replace_if_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+            requires indirectly_writable<_It, const _Ty&>
+        static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Replace_if_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _Newval, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <input_range _Rng, class _Ty, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+            requires indirectly_writable<iterator_t<_Rng>, const _Ty&>
+        static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _Replace_if_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Pass_fn(_Pred), _Newval, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty, class _Pj, class _Pr>
+        _NODISCARD static constexpr _It _Replace_if_unchecked(
+            _It _First, const _Se _Last, _Pr _Pred, const _Ty& _Newval, _Pj _Proj) {
+            // replace projected _Oldval that fulfills _Pred with _Newval in [_First, _Last)
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_writable<_It, const _Ty&>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    *_First = _Newval;
+                }
+            }
+
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Replace_if_fn replace_if;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty>
+_CONSTEXPR20 _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty& _Oldval, const _Ty& _Newval) {
+    // copy replacing each matching _Oldval with _Newval
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Verify_ranges_do_not_overlap(_First, _Last, _Dest);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+
+#if _VECTORIZED_REPLACE_COPY
+    if constexpr (_Vector_alg_in_find_is_safe<decltype(_UFirst), _Ty>
+                  && _Output_iterator_for_known_size_vector_alg_is_safe<decltype(_UDest), decltype(_UFirst)>()) {
+        if (!_STD _Is_constant_evaluated()) {
+            const auto _Count = static_cast<_Iter_diff_t<decltype(_UDest)>>(_ULast - _UFirst);
+            _STD _Contiguous_iter_verify(_UDest, _Count);
+
+            const auto _First_ptr = _STD _To_address(_UFirst);
+            const auto _Last_ptr  = _STD _To_address(_ULast);
+            const auto _Dest_ptr  = _STD _To_address(_UDest);
+
+            if (_STD _Could_compare_equal_to_value_type<decltype(_UFirst)>(_Oldval)) {
+                _STD _Replace_copy_vectorized(_First_ptr, _Last_ptr, _Dest_ptr, _Oldval, _Newval);
+            } else {
+                _CSTD memcpy(_Dest_ptr, _First_ptr, static_cast<size_t>(_Count) * sizeof(*_Dest_ptr));
+            }
+
+            _UDest += _Count;
+            _STD _Seek_wrapped(_Dest, _UDest);
+            return _Dest;
+        }
+    }
+#endif // ^^^ _VECTORIZED_REPLACE_COPY ^^^
+
+    for (; _UFirst != _ULast; ++_UFirst, (void) ++_UDest) {
+        if (*_UFirst == _Oldval) {
+            *_UDest = _Newval;
+        } else {
+            *_UDest = *_UFirst;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 replace_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, const _Ty& _Oldval,
+    const _Ty& _Newval) noexcept /* terminates */ {
+    // copy replacing each matching _Oldval with _Newval
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD replace_copy(_First, _Last, _Dest, _Oldval, _Newval);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using replace_copy_result = in_out_result<_In, _Out>;
+
+    class _Replace_copy_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty1, class _Ty2, output_iterator<const _Ty2&> _Out,
+            class _Pj = identity>
+            requires indirectly_copyable<_It, _Out>
+                  && indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty1*>
+        static constexpr replace_copy_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Output, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast       = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _Count = _RANGES _Idl_distance<_It>(_UFirst, _ULast);
+            auto _UResult     = _Replace_copy_common(_STD move(_UFirst), _STD move(_ULast),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count), _Oldval, _Newval, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, class _Ty1, class _Ty2, output_iterator<const _Ty2&> _Out, class _Pj = identity>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+                  && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty1*>
+        static constexpr replace_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, _Out _Output, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) {
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _First       = _RANGES begin(_Range);
+            auto _UResult     = _Replace_copy_common(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count), _Oldval, _Newval, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty1, class _Ty2, class _Out, class _Pj>
+        _NODISCARD static constexpr replace_copy_result<_It, _Out> _Replace_copy_common(
+            _It _First, const _Se _Last, _Out _Output, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj) {
+            // copy [_First, _Last) to _Output while replacing projected _Oldval with _Newval
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(output_iterator<_Out, const _Ty2&>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<equal_to, projected<_It, _Pj>, const _Ty1*>);
+
+            _STD _Verify_ranges_do_not_overlap(_First, _Last, _Output);
+
+#if _VECTORIZED_REPLACE_COPY
+            if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It>
+                          && _Vector_alg_in_find_is_safe<_It, _Ty1> && _Vector_alg_in_find_is_safe<_It, _Ty2>
+                          && _Output_iterator_for_known_size_vector_alg_is_safe<_Out, _It>()) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _Count = _Last - _First;
+                    _STD _Contiguous_iter_verify(_First, _Count);
+                    _STD _Contiguous_iter_verify(_Output, static_cast<iter_difference_t<_Out>>(_Count));
+
+                    const auto _First_ptr = _STD to_address(_First);
+                    const auto _Last_ptr  = _First_ptr + static_cast<size_t>(_Count);
+                    const auto _Out_ptr   = _STD to_address(_Output);
+
+                    if (_STD _Could_compare_equal_to_value_type<_It>(_Oldval)) {
+                        _STD _Replace_copy_vectorized(_First_ptr, _Last_ptr, _Out_ptr, _Oldval, _Newval);
+                    } else {
+                        _CSTD memcpy(_Out_ptr, _First_ptr, static_cast<size_t>(_Count) * sizeof(*_Out_ptr));
+                    }
+
+                    _First += _Count;
+                    _Output += static_cast<iter_difference_t<_Out>>(_Count);
+                    return {_STD move(_First), _STD move(_Output)};
+                }
+            }
+#endif // ^^^ _VECTORIZED_REPLACE_COPY ^^^
+
+            for (; _First != _Last; ++_First, (void) ++_Output) {
+                if (_STD invoke(_Proj, *_First) == _Oldval) {
+                    *_Output = _Newval;
+                } else {
+                    *_Output = *_First;
+                }
+            }
+
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Replace_copy_fn replace_copy;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Pr, class _Ty>
+_CONSTEXPR20 _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty& _Val) {
+    // copy replacing each satisfying _Pred with _Val
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Verify_ranges_do_not_overlap(_First, _Last, _Dest);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    for (; _UFirst != _ULast; ++_UFirst, (void) ++_UDest) {
+        if (_Pred(*_UFirst)) {
+            *_UDest = _Val;
+        } else {
+            *_UDest = *_UFirst;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, class _Ty,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 replace_copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred, const _Ty& _Val) noexcept
+/* terminates */ {
+    // copy replacing each satisfying _Pred with _Val
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD replace_copy_if(_First, _Last, _Dest, _STD _Pass_fn(_Pred), _Val);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using replace_copy_if_result = in_out_result<_In, _Out>;
+
+    class _Replace_copy_if_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, output_iterator<const _Ty&> _Out,
+            class _Pj = identity, indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+            requires indirectly_copyable<_It, _Out>
+        static constexpr replace_copy_if_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Output, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast       = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _Count = _RANGES _Idl_distance<_It>(_UFirst, _ULast);
+
+            auto _UResult = _Replace_copy_if_common(_STD move(_UFirst), _STD move(_ULast),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count), _STD _Pass_fn(_Pred), _Newval, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, class _Ty, output_iterator<const _Ty&> _Out, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+        static constexpr replace_copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, _Out _Output, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) {
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _First       = _RANGES begin(_Range);
+            auto _UResult = _Replace_copy_if_common(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count), _STD _Pass_fn(_Pred), _Newval, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty, class _Out, class _Pj, class _Pr>
+        _NODISCARD static constexpr replace_copy_if_result<_It, _Out> _Replace_copy_if_common(
+            _It _First, const _Se _Last, _Out _Output, _Pr _Pred, const _Ty& _Newval, _Pj _Proj) {
+            // copy [_First, _Last) to _Output while replacing _Oldval with _Newval if projected _Oldval fulfills _Pred
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(output_iterator<_Out, const _Ty&>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            _STD _Verify_ranges_do_not_overlap(_First, _Last, _Output);
+
+            for (; _First != _Last; ++_First, (void) ++_Output) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    *_Output = _Newval;
+                } else {
+                    *_Output = *_First;
+                }
+            }
+
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Replace_copy_if_fn replace_copy_if;
+
+    struct _Fill_fn {
+        template <class _Ty, output_iterator<const _Ty&> _It, sentinel_for<_It> _Se>
+        static constexpr _It operator()(_It _First, _Se _Last, const _Ty& _Value) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            const auto _ULast = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            if (!_STD is_constant_evaluated()) {
+                if constexpr (sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
+                    if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
+                        const auto _Distance = static_cast<size_t>(_ULast - _UFirst);
+                        _STD _Fill_memset(_UFirst, _Value, _Distance);
+                        _STD _Seek_wrapped(_First, _UFirst + _Distance);
+                        return _First;
+                    } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
+                        if (_STD _Is_all_bits_zero(_Value)) {
+                            const auto _Distance = static_cast<size_t>(_ULast - _UFirst);
+                            _STD _Fill_zero_memset(_UFirst, _Distance);
+                            _STD _Seek_wrapped(_First, _UFirst + _Distance);
+                            return _First;
+                        }
+                    }
+                }
+            }
+
+            for (; _UFirst != _ULast; ++_UFirst) {
+                *_UFirst = _Value;
+            }
+
+            _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            return _First;
+        }
+
+        template <class _Ty, output_range<const _Ty&> _Rng>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, const _Ty& _Value) {
+            auto _First = _RANGES begin(_Range);
+            _STD _Seek_wrapped(
+                _First, operator()(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range), _Value));
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fill_fn fill;
+
+    class _Generate_fn {
+    public:
+        template <input_or_output_iterator _Out, sentinel_for<_Out> _Se, copy_constructible _Fn>
+            requires invocable<_Fn&> && indirectly_writable<_Out, invoke_result_t<_Fn&>>
+        static constexpr _Out operator()(_Out _First, _Se _Last, _Fn _Gen) {
+            _STD _Adl_verify_range(_First, _Last);
+            _STD _Seek_wrapped(_First, _Generate_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                                           _RANGES _Unwrap_sent<_Out>(_STD move(_Last)), _STD _Pass_fn(_Gen)));
+            return _First;
+        }
+
+        template <class _Rng, copy_constructible _Fn>
+            requires invocable<_Fn&> && output_range<_Rng, invoke_result_t<_Fn&>>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Fn _Gen) {
+            auto _First = _RANGES begin(_Range);
+            _STD _Seek_wrapped(_First, _Generate_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)),
+                                           _Uend(_Range), _STD _Pass_fn(_Gen)));
+            return _First;
+        }
+
+    private:
+        template <class _Out, class _Se, class _Fn>
+        _NODISCARD static constexpr _Out _Generate_unchecked(_Out _First, const _Se _Last, _Fn _Gen) {
+            _STL_INTERNAL_STATIC_ASSERT(input_or_output_iterator<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _Out>);
+            _STL_INTERNAL_STATIC_ASSERT(copy_constructible<_Fn>);
+            _STL_INTERNAL_STATIC_ASSERT(invocable<_Fn&>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_writable<_Out, invoke_result_t<_Fn&>>);
+
+            for (; _First != _Last; ++_First) {
+                *_First = _Gen();
+            }
+
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Generate_fn generate;
+
+    struct _Generate_n_fn {
+        template <input_or_output_iterator _Out, copy_constructible _Fn>
+            requires invocable<_Fn&> && indirectly_writable<_Out, invoke_result_t<_Fn&>>
+        static constexpr _Out operator()(_Out _First, iter_difference_t<_Out> _Count, _Fn _Gen) {
+            if (_Count > 0) {
+                auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+                do {
+                    *_UFirst = _Gen();
+                    ++_UFirst;
+                } while (--_Count > 0);
+
+                _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            }
+
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Generate_n_fn generate_n;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Fn>
+_CONSTEXPR20 void generate(_FwdIt _First, _FwdIt _Last, _Fn _Func) { // replace [_First, _Last) with _Func()
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        *_UFirst = _Func();
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+void generate(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept /* terminates */ {
+    // replace [_First, _Last) with _Func()
+    // not parallelized at present due to unclear parallelism requirements on _Func
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD generate(_First, _Last, _STD _Pass_fn(_Func));
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _OutIt, class _Diff, class _Fn>
+_CONSTEXPR20 _OutIt generate_n(_OutIt _Dest, const _Diff _Count_raw, _Fn _Func) {
+    // replace [_Dest, _Dest + _Count) with _Func()
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (0 < _Count) {
+        auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count);
+        do {
+            *_UDest = _Func();
+            --_Count;
+            ++_UDest;
+        } while (0 < _Count);
+
+        _STD _Seek_wrapped(_Dest, _UDest);
+    }
+
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt generate_n(_ExPo&&, const _FwdIt _Dest, const _Diff _Count_raw, _Fn _Func) noexcept /* terminates */ {
+    // replace [_Dest, _Dest + _Count) with _Func()
+    // not parallelized at present due to unclear parallelism requirements on _Func
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD generate_n(_Dest, _Count_raw, _STD _Pass_fn(_Func));
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty>
+_CONSTEXPR20 _OutIt remove_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty& _Val) {
+    // copy omitting each matching _Val
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_unverified(_Dest);
+
+#if _VECTORIZED_REMOVE_COPY
+    if constexpr (_Vector_alg_in_find_is_safe<decltype(_UFirst), _Ty>
+                  && _Output_iterator_for_vector_alg_is_safe<decltype(_UDest), decltype(_UFirst)>()) {
+        if (!_STD _Is_constant_evaluated()) {
+            if (!_STD _Could_compare_equal_to_value_type<decltype(_UFirst)>(_Val)) {
+                _UDest = _STD _Copy_unchecked(_UFirst, _ULast, _UDest);
+                _STD _Seek_wrapped(_Dest, _UDest);
+                return _Dest;
+            }
+
+            const auto _Dest_ptr = _STD _To_address(_UDest);
+            const auto _Result =
+                _STD _Remove_copy_vectorized(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Dest_ptr, _Val);
+
+            if constexpr (is_pointer_v<decltype(_UDest)>) {
+                _UDest = _Result;
+            } else {
+                _UDest += static_cast<_Iter_diff_t<decltype(_UDest)>>(_Result - _Dest_ptr);
+            }
+
+            _STD _Seek_wrapped(_Dest, _UDest);
+            return _Dest;
+        }
+    }
+#endif // ^^^ _VECTORIZED_REMOVE_COPY ^^^
+
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (!(*_UFirst == _Val)) {
+            *_UDest = *_UFirst;
+            ++_UDest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 remove_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, const _Ty& _Val) noexcept /* terminates */ {
+    // copy omitting each matching _Val
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD remove_copy(_First, _Last, _Dest, _Val);
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Pr>
+_CONSTEXPR20 _OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) {
+    // copy omitting each element satisfying _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_unverified(_Dest);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (!_Pred(*_UFirst)) {
+            *_UDest = *_UFirst;
+            ++_UDest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 remove_copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept /* terminates */ {
+    // copy omitting each element satisfying _Pred
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD remove_copy_if(_First, _Last, _Dest, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD_REMOVE_ALG _FwdIt remove(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD_REMOVE_ALG _FwdIt remove_if(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Remove_fn {
+    public:
+        template <permutable _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+        _NODISCARD_REMOVE_ALG static constexpr subrange<_It> operator()(
+            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Remove_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _Val, _STD _Pass_fn(_Proj));
+
+            return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+        }
+
+        template <forward_range _Rng, class _Ty, class _Pj = identity>
+            requires permutable<iterator_t<_Rng>>
+                  && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
+        _NODISCARD_REMOVE_ALG static constexpr borrowed_subrange_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) {
+            auto _UResult = _Remove_unchecked(_Ubegin(_Range), _Uend(_Range), _Val, _STD _Pass_fn(_Proj));
+
+            return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty, class _Pj>
+        _NODISCARD static constexpr subrange<_It> _Remove_unchecked(
+            _It _First, const _Se _Last, const _Ty& _Val, _Pj _Proj) {
+            // Remove projected values equal to _Val from [_First, _Last)
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>);
+
+            _First     = _RANGES _Find_unchecked(_STD move(_First), _Last, _Val, _Proj);
+            auto _Next = _First;
+            if (_First == _Last) {
+                return {_STD move(_Next), _STD move(_First)};
+            }
+
+#if _VECTORIZED_REMOVE
+            if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty> && sized_sentinel_for<_Se, _It>
+                          && is_same_v<_Pj, identity>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _Size      = _Last - _First;
+                    const auto _First_ptr = _STD to_address(_First);
+                    const auto _Last_ptr  = _STD to_address(_First + _Size);
+                    const auto _Result    = _STD _Remove_vectorized(_First_ptr, _Last_ptr, _Val);
+
+                    if constexpr (is_pointer_v<_It>) {
+                        return {_Result, _Last_ptr};
+                    } else {
+                        return {_First + static_cast<iter_difference_t<_It>>(_Result - _First_ptr), _First + _Size};
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_REMOVE ^^^
+
+            while (++_First != _Last) {
+                if (_STD invoke(_Proj, *_First) != _Val) {
+                    *_Next = _RANGES iter_move(_First);
+                    ++_Next;
+                }
+            }
+
+            return {_STD move(_Next), _STD move(_First)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Remove_fn remove;
+
+    class _Remove_if_fn {
+    public:
+        template <permutable _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD_REMOVE_ALG static constexpr subrange<_It> operator()(
+            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Remove_if_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+            requires permutable<iterator_t<_Rng>>
+        _NODISCARD_REMOVE_ALG static constexpr borrowed_subrange_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            auto _UResult =
+                _Remove_if_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pr, class _Pj>
+        _NODISCARD static constexpr subrange<_It> _Remove_if_unchecked(
+            _It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            // Remove values whose projection satisfies _Pred from [_First, _Last)
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            _First     = _RANGES _Find_if_unchecked(_STD move(_First), _Last, _Pred, _Proj);
+            auto _Next = _First;
+            if (_First == _Last) {
+                return {_STD move(_Next), _STD move(_First)};
+            }
+
+            while (++_First != _Last) {
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    *_Next = _RANGES iter_move(_First);
+                    ++_Next;
+                }
+            }
+
+            return {_STD move(_Next), _STD move(_First)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Remove_if_fn remove_if;
+
+    _EXPORT_STD template <class _In, class _Out>
+    using remove_copy_result = in_out_result<_In, _Out>;
+
+    class _Remove_copy_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Ty, class _Pj = identity>
+            requires indirectly_copyable<_It, _Out>
+                  && indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+        static constexpr remove_copy_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Output, const _Ty& _Val, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Remove_copy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Get_unwrapped_unverified(_STD move(_Output)), _Val,
+                _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out, class _Ty, class _Pj = identity>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+                  && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
+        static constexpr remove_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, _Out _Output, const _Ty& _Val, _Pj _Proj = {}) {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _Remove_copy_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Get_unwrapped_unverified(_STD move(_Output)), _Val, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Out, class _Ty, class _Pj>
+        _NODISCARD static constexpr remove_copy_result<_It, _Out> _Remove_copy_unchecked(
+            _It _First, const _Se _Last, _Out _Output, const _Ty& _Val, _Pj _Proj) {
+            // Copy [_First, _Last) to _Output except projected values equal to _Val
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>);
+
+#if _VECTORIZED_REMOVE_COPY
+            if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty> && _Output_iterator_for_vector_alg_is_safe<_Out, _It>()
+                          && sized_sentinel_for<_Se, _It> && is_same_v<_Pj, identity>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _Size = _Last - _First;
+                    auto _End        = _First + _Size;
+
+                    if (!_STD _Could_compare_equal_to_value_type<_It>(_Val)) {
+                        _Output = _STD _Copy_unchecked(_First, _Last, _Output);
+                        return {_STD move(_End), _STD move(_Output)};
+                    }
+
+                    const auto _Dest_ptr = _STD to_address(_Output);
+                    const auto _Result =
+                        _STD _Remove_copy_vectorized(_STD to_address(_First), _STD to_address(_End), _Dest_ptr, _Val);
+
+                    if constexpr (is_pointer_v<_Out>) {
+                        return {_STD move(_End), _Result};
+                    } else {
+                        return {_STD move(_End),
+                            _STD move(_Output) + static_cast<iter_difference_t<_Out>>(_Result - _Dest_ptr)};
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_REMOVE_COPY ^^^
+
+            for (; _First != _Last; ++_First) {
+                if (_STD invoke(_Proj, *_First) != _Val) {
+                    *_Output = *_First;
+                    ++_Output;
+                }
+            }
+
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Remove_copy_fn remove_copy;
+
+    _EXPORT_STD template <class _In, class _Out>
+    using remove_copy_if_result = in_out_result<_In, _Out>;
+
+    class _Remove_copy_if_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+            requires indirectly_copyable<_It, _Out>
+        static constexpr remove_copy_if_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Output, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Remove_copy_if_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Get_unwrapped_unverified(_STD move(_Output)),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+        static constexpr remove_copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, _Out _Output, _Pr _Pred, _Pj _Proj = {}) {
+            auto _First = _RANGES begin(_Range);
+            auto _UResult =
+                _Remove_copy_if_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                    _STD _Get_unwrapped_unverified(_STD move(_Output)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Out, class _Pr, class _Pj>
+        _NODISCARD static constexpr remove_copy_if_result<_It, _Out> _Remove_copy_if_unchecked(
+            _It _First, const _Se _Last, _Out _Output, _Pr _Pred, _Pj _Proj) {
+            // Copy [_First, _Last) to _Output except projected values that satisfy _Pred
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            for (; _First != _Last; ++_First) {
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    *_Output = *_First;
+                    ++_Output;
+                }
+            }
+
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Remove_copy_if_fn remove_copy_if;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD_UNIQUE_ALG _CONSTEXPR20 _FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+    // remove each satisfying _Pred with previous
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+#if _VECTORIZED_UNIQUE
+    if constexpr (_Vector_alg_in_unique_is_safe<decltype(_UFirst), _Pr>) {
+        if (!_STD _Is_constant_evaluated()) {
+            const auto _First_ptr = _STD _To_address(_UFirst);
+            const auto _Result    = _STD _Unique_vectorized(_First_ptr, _STD _To_address(_ULast));
+
+            if constexpr (is_pointer_v<decltype(_UFirst)>) {
+                _UFirst = _Result;
+            } else {
+                _UFirst += static_cast<_Iter_diff_t<decltype(_UFirst)>>(_Result - _First_ptr);
+            }
+
+            _STD _Seek_wrapped(_Last, _UFirst);
+            return _Last;
+        }
+    }
+#endif // ^^^ _VECTORIZED_UNIQUE ^^^
+
+    if (_UFirst != _ULast) {
+        for (auto _UFirstb = _UFirst; ++_UFirst != _ULast; _UFirstb = _UFirst) {
+            if (_Pred(*_UFirstb, *_UFirst)) { // copy down
+                while (++_UFirst != _ULast) {
+                    if (!_Pred(*_UFirstb, *_UFirst)) {
+                        *++_UFirstb = _STD move(*_UFirst);
+                    }
+                }
+
+                _STD _Seek_wrapped(_Last, ++_UFirstb);
+                return _Last;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_Last, _ULast);
+    return _Last;
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD_UNIQUE_ALG _CONSTEXPR20 _FwdIt unique(_FwdIt _First, _FwdIt _Last) { // remove each matching previous
+    return _STD unique(_First, _Last, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD_UNIQUE_ALG _FwdIt unique(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // remove each satisfying _Pred with previous
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD unique(_First, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD_UNIQUE_ALG _FwdIt unique(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
+    // remove each matching previous
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD unique(_First, _Last);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Unique_fn {
+    public:
+        template <permutable _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_equivalence_relation<projected<_It, _Pj>> _Pr = ranges::equal_to>
+        _NODISCARD_UNIQUE_ALG static constexpr subrange<_It> operator()(
+            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Unique_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_equivalence_relation<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::equal_to>
+            requires permutable<iterator_t<_Rng>>
+        _NODISCARD_UNIQUE_ALG static constexpr borrowed_subrange_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UResult =
+                _Unique_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr subrange<_It> _Unique_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            // Remove adjacent elements from [_First, _Last) whose projections satisfy _Pred
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_equivalence_relation<_Pr, projected<_It, _Pj>>);
+
+#if _VECTORIZED_UNIQUE
+            if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It>
+                          && _Vector_alg_in_unique_is_safe<_It, _Pr>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _Size      = _Last - _First;
+                    const auto _First_ptr = _STD to_address(_First);
+                    const auto _Last_ptr  = _STD to_address(_First + _Size);
+                    const auto _Result    = _STD _Unique_vectorized(_First_ptr, _Last_ptr);
+
+                    if constexpr (is_pointer_v<_It>) {
+                        return {_Result, _Last_ptr};
+                    } else {
+                        return {_First + static_cast<iter_difference_t<_It>>(_Result - _First_ptr), _First + _Size};
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_UNIQUE ^^^
+
+            auto _Current = _First;
+            if (_First == _Last) {
+                return {_STD move(_Current), _STD move(_First)};
+            }
+
+            for (;; ++_Current) {
+                if (++_First == _Last) {
+                    ++_Current;
+                    return {_STD move(_Current), _STD move(_First)};
+                }
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Current), _STD invoke(_Proj, *_First))) {
+                    break;
+                }
+            }
+
+            while (++_First != _Last) {
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Current), _STD invoke(_Proj, *_First))) {
+                    ++_Current;
+                    *_Current = _RANGES iter_move(_First);
+                }
+            }
+            ++_Current;
+
+            return {_STD move(_Current), _STD move(_First)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Unique_fn unique;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _InIt, class _OutIt>
+#if _HAS_CXX20
+concept
+#else
+constexpr bool
+#endif
+    _Can_reread_dest = _Is_cpp17_fwd_iter_v<_OutIt> && is_same_v<_Iter_value_t<_InIt>, _Iter_value_t<_OutIt>>;
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Pr>
+_CONSTEXPR20 _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) {
+    // copy compressing pairs that match
+    _STD _Adl_verify_range(_First, _Last);
+
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+    if (_UFirst == _ULast) {
+        return _Dest;
+    }
+
+    auto _UDest = _STD _Get_unwrapped_unverified(_Dest);
+
+#if _VECTORIZED_UNIQUE_COPY
+    if constexpr (_Vector_alg_in_unique_is_safe<decltype(_UFirst), _Pr>
+                  && _Output_iterator_for_vector_alg_is_safe<decltype(_UDest), decltype(_UFirst)>()) {
+        if (!_STD _Is_constant_evaluated()) {
+            const auto _First_ptr = _STD _To_address(_UFirst);
+            const auto _Dest_ptr  = _STD _To_address(_UDest);
+            const auto _Result    = _STD _Unique_copy_vectorized(_First_ptr, _STD _To_address(_ULast), _Dest_ptr);
+
+            if constexpr (is_pointer_v<decltype(_UDest)>) {
+                _UDest = _Result;
+            } else {
+                _UDest += static_cast<_Iter_diff_t<decltype(_UDest)>>(_Result - _Dest_ptr);
+            }
+
+            _STD _Seek_wrapped(_Dest, _UDest);
+            return _Dest;
+        }
+    }
+#endif // ^^^ _VECTORIZED_UNIQUE_COPY ^^^
+
+    if constexpr (_Is_ranges_fwd_iter_v<_InIt>) { // can reread the source for comparison
+        auto _Firstb = _UFirst;
+
+        *_UDest = *_Firstb;
+        ++_UDest;
+
+        while (++_UFirst != _ULast) {
+            if (!static_cast<bool>(_Pred(*_Firstb, *_UFirst))) { // copy unmatched
+                _Firstb = _UFirst;
+                *_UDest = *_Firstb;
+                ++_UDest;
+            }
+        }
+    } else if constexpr (_Can_reread_dest<_InIt, _OutIt>) { // assignment copies T; can reread dest for comparison
+        *_UDest = *_UFirst;
+
+        while (++_UFirst != _ULast) {
+            if (!static_cast<bool>(_Pred(*_UDest, *_UFirst))) {
+                *++_UDest = *_UFirst;
+            }
+        }
+
+        ++_UDest;
+    } else { // can't reread source or dest, construct a temporary
+        _Iter_value_t<_InIt> _Val(*_UFirst);
+
+        *_UDest = _Val;
+        ++_UDest;
+
+        while (++_UFirst != _ULast) {
+            if (!static_cast<bool>(_Pred(_Val, *_UFirst))) { // copy unmatched
+                _Val    = *_UFirst;
+                *_UDest = _Val;
+                ++_UDest;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy compressing pairs that match
+    return _STD unique_copy(_First, _Last, _Dest, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 unique_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept /* terminates */ {
+    // copy compressing pairs that match
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD unique_copy(_First, _Last, _Dest, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 unique_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // copy compressing pairs that match
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD unique_copy(_First, _Last, _Dest);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using unique_copy_result = in_out_result<_In, _Out>;
+
+    template <class _It, class _Ty>
+    concept _Is_input_with_value_type = input_iterator<_It> && same_as<iter_value_t<_It>, _Ty>;
+
+    template <class _It, class _Out>
+    concept _Can_reread_or_store = forward_iterator<_It> || _Is_input_with_value_type<_Out, iter_value_t<_It>>
+                                || indirectly_copyable_storable<_It, _Out>;
+
+    class _Unique_copy_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Pj = identity,
+            indirect_equivalence_relation<projected<_It, _Pj>> _Pr = ranges::equal_to>
+            requires indirectly_copyable<_It, _Out> && _Can_reread_or_store<_It, _Out>
+        static constexpr unique_copy_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Output, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Unique_copy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Get_unwrapped_unverified(_STD move(_Output)),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out, class _Pj = identity,
+            indirect_equivalence_relation<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::equal_to>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out> && _Can_reread_or_store<iterator_t<_Rng>, _Out>
+        static constexpr unique_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, _Out _Output, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _Unique_copy_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Get_unwrapped_unverified(_STD move(_Output)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Out, class _Pj, class _Pr>
+        _NODISCARD static constexpr unique_copy_result<_It, _Out> _Unique_copy_unchecked(
+            _It _First, const _Se _Last, _Out _Output, _Pr _Pred, _Pj _Proj) {
+            // Copy elements from [_First, _Last) to _Output, compressing adjacent elements whose projections satisfy
+            // _Pred
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_equivalence_relation<_Pr, projected<_It, _Pj>>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+            _STL_INTERNAL_STATIC_ASSERT(_Can_reread_or_store<_It, _Out>);
+
+            if (_First == _Last) {
+                return {_STD move(_First), _STD move(_Output)};
+            }
+
+#if _VECTORIZED_UNIQUE_COPY
+            if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It>
+                          && _Vector_alg_in_unique_is_safe<_It, _Pr>
+                          && _Output_iterator_for_vector_alg_is_safe<_Out, _It>()) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _Size       = _Last - _First;
+                    const auto _First_ptr  = _STD to_address(_First);
+                    const auto _Last_ptr   = _STD to_address(_First + _Size);
+                    const auto _Output_ptr = _STD to_address(_Output);
+                    const auto _Result     = _STD _Unique_copy_vectorized(_First_ptr, _Last_ptr, _Output_ptr);
+
+                    if constexpr (is_pointer_v<_It> && is_pointer_v<_Out>) {
+                        return {_Last_ptr, _Result};
+                    } else {
+                        return {_STD move(_First) + _Size,
+                            _STD move(_Output) + static_cast<iter_difference_t<_Out>>(_Result - _Output_ptr)};
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_UNIQUE_COPY ^^^
+
+            if constexpr (_Is_input_with_value_type<_Out, iter_value_t<_It>>) {
+                // Can reread _Output
+                *_Output = *_First;
+
+                while (++_First != _Last) {
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Output), _STD invoke(_Proj, *_First))) {
+                        ++_Output;
+                        *_Output = *_First;
+                    }
+                }
+            } else if constexpr (forward_iterator<_It>) {
+                // Can reread _First
+                auto _Current = _First;
+                *_Output      = *_First;
+
+                while (++_First != _Last) {
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Current), _STD invoke(_Proj, *_First))) {
+                        _Current = _First;
+                        ++_Output;
+                        *_Output = *_First;
+                    }
+                }
+            } else {
+                // Neither _First nor _Output can be reread, construct temporary
+                iter_value_t<_It> _Val(*_First);
+
+                while (++_First != _Last) {
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj, _Val), _STD invoke(_Proj, *_First))) {
+                        *_Output = _STD move(_Val);
+                        ++_Output;
+                        _Val = *_First;
+                    }
+                }
+                *_Output = _STD move(_Val);
+            }
+            ++_Output;
+
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Unique_copy_fn unique_copy;
+
+    // concept-constrained for strict enforcement as it is used by several algorithms
+    template <bidirectional_iterator _It>
+        requires permutable<_It>
+    constexpr void _Reverse_common(_It _First, _It _Last) {
+#if _VECTORIZED_REVERSE
+        if constexpr (contiguous_iterator<_It>) {
+            using _Elem          = remove_reference_t<iter_reference_t<_It>>;
+            constexpr size_t _Nx = sizeof(_Elem);
+            constexpr bool _Allow_vectorization =
+                conjunction_v<_Is_trivially_ranges_swappable<_Elem>, negation<is_volatile<_Elem>>>;
+
+            if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
+                if (!_STD is_constant_evaluated()) {
+                    _STD _Reverse_vectorized<_Nx>(_STD to_address(_First), _STD to_address(_Last));
+                    return;
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_REVERSE ^^^
+
+        for (; _First != _Last && _First != --_Last; ++_First) {
+            _RANGES iter_swap(_First, _Last);
+        }
+    }
+
+    struct _Reverse_fn {
+        template <bidirectional_iterator _It, sentinel_for<_It> _Se>
+            requires permutable<_It>
+        static constexpr _It operator()(_It _First, _Se _Last) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            _RANGES _Reverse_common(_STD move(_UFirst), _STD move(_ULast));
+            return _First;
+        }
+
+        template <bidirectional_range _Rng>
+            requires permutable<iterator_t<_Rng>>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) {
+            auto _ULast = _RANGES _Get_final_iterator_unwrapped(_Range);
+            _RANGES _Reverse_common(_Ubegin(_Range), _ULast);
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_ULast));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Reverse_fn reverse;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Ty>
+struct _Is_trivially_copy_assignable_returning_same_reference
+    : bool_constant<_Is_trivially_assignable_returning_same_reference_v<_Ty&, const _Ty&>> {};
+
+_EXPORT_STD template <class _BidIt, class _OutIt>
+_CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) {
+    // copy reversing elements in [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Verify_ranges_do_not_overlap(_First, _Last, _Dest);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _ULast        = _STD _Get_unwrapped(_Last);
+    auto _UDest        = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_BidIt>(_UFirst, _ULast));
+
+#if _VECTORIZED_REVERSE_COPY
+    using _Elem                         = remove_reference_t<_Iter_ref_t<remove_const_t<decltype(_UFirst)>>>;
+    using _DestElem                     = remove_reference_t<_Iter_ref_t<decltype(_UDest)>>;
+    constexpr bool _Allow_vectorization = conjunction_v<is_same<remove_const_t<_Elem>, _DestElem>,
+        bool_constant<_Iterators_are_contiguous<decltype(_ULast), decltype(_UDest)>>,
+        _Is_trivially_copy_assignable_returning_same_reference<_Elem>, negation<is_volatile<_Elem>>>;
+    constexpr size_t _Nx                = sizeof(_Elem);
+
+    if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            const auto _Dest_dist = static_cast<_Iter_diff_t<decltype(_UDest)>>(_ULast - _UFirst);
+            _STD _Contiguous_iter_verify(_UDest, _Dest_dist);
+
+            _STD _Reverse_copy_vectorized<_Nx>(
+                _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest));
+            _UDest += _Dest_dist;
+            _STD _Seek_wrapped(_Dest, _UDest);
+            return _Dest;
+        }
+    }
+#endif // ^^^ _VECTORIZED_REVERSE_COPY ^^^
+
+    for (; _UFirst != _ULast; ++_UDest) {
+        *_UDest = *--_ULast;
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _BidIt, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt reverse_copy(_ExPo&&, _BidIt _First, _BidIt _Last, _FwdIt _Dest) noexcept /* terminates */ {
+    // copy reversing elements in [_First, _Last)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_BIDIRECTIONAL_ITERATOR(_BidIt);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD reverse_copy(_First, _Last, _Dest);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using reverse_copy_result = in_out_result<_In, _Out>;
+
+    class _Reverse_copy_fn {
+    public:
+        template <bidirectional_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+            requires indirectly_copyable<_It, _Out>
+        static constexpr reverse_copy_result<_It, _Out> operator()(_It _First, _Se _Last, _Out _Output) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            const auto _Count = _RANGES _Idl_distance<_It>(_UFirst, _ULast);
+            auto _UOutput     = _Reverse_copy_common(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Get_unwrapped_n(_STD move(_Output), _Count));
+            _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <bidirectional_range _Rng, weakly_incrementable _Out>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+        static constexpr reverse_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(_Rng&& _Range, _Out _Output) {
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _UOutput     = _STD _Get_unwrapped_n(_STD move(_Output), _Count);
+            if constexpr (common_range<_Rng>) {
+                _UOutput = _Reverse_copy_common(_Ubegin(_Range), _Uend(_Range), _STD move(_UOutput));
+                _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+                return {_RANGES end(_Range), _STD move(_Output)};
+            } else {
+                auto _ULast = _RANGES _Get_final_iterator_unwrapped(_Range);
+                _UOutput    = _Reverse_copy_common(_Ubegin(_Range), _ULast, _STD move(_UOutput));
+                _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+                return {_RANGES _Rewrap_iterator(_Range, _STD move(_ULast)), _STD move(_Output)};
+            }
+        }
+
+    private:
+        template <class _It, class _Out>
+        _NODISCARD static constexpr _Out _Reverse_copy_common(const _It _First, _It _Last, _Out _Output) {
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+
+            _STD _Verify_ranges_do_not_overlap(_First, _Last, _Output);
+
+#if _VECTORIZED_REVERSE_COPY
+            if constexpr (contiguous_iterator<_It> && contiguous_iterator<_Out>) {
+                using _Elem                         = remove_reference_t<iter_reference_t<_It>>;
+                using _DestElem                     = remove_reference_t<iter_reference_t<_Out>>;
+                constexpr bool _Allow_vectorization = conjunction_v<is_same<remove_const_t<_Elem>, _DestElem>,
+                    _Is_trivially_copy_assignable_returning_same_reference<_Elem>, negation<is_volatile<_Elem>>>;
+                constexpr size_t _Nx                = sizeof(_Elem);
+
+                if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
+                    if (!_STD is_constant_evaluated()) {
+                        const auto _Dest_dist = static_cast<iter_difference_t<_Out>>(_Last - _First);
+                        _STD _Contiguous_iter_verify(_Output, _Dest_dist);
+                        _STD _Reverse_copy_vectorized<_Nx>(
+                            _STD to_address(_First), _STD to_address(_Last), _STD to_address(_Output));
+                        _Output += _Dest_dist;
+                        return _Output;
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_REVERSE_COPY ^^^
+
+            for (; _First != _Last; ++_Output) {
+                *_Output = *--_Last;
+            }
+
+            return _Output;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Reverse_copy_fn reverse_copy;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <permutable _It>
+    _NODISCARD constexpr subrange<_It> _Reverse_until_mid_unchecked(_It _First, const _It _Mid, _It _Last) {
+        // reverse until either _First or _Last hits _Mid
+        _STL_INTERNAL_CHECK(_First != _Mid);
+        _STL_INTERNAL_CHECK(_Mid != _Last);
+
+        do {
+            _RANGES iter_swap(_First, --_Last);
+        } while (++_First != _Mid && _Last != _Mid);
+
+        return {_STD move(_First), _STD move(_Last)};
+    }
+
+    template <permutable _It, sentinel_for<_It> _Se>
+    _NODISCARD constexpr subrange<_It> _Rotate_unchecked(_It _First, _It _Mid, _Se _Last) {
+        // Exchange the ranges [_First, _Mid) and [_Mid, _Last)
+        // that is, rotates [_First, _Last) left by distance(_First, _Mid) positions
+
+        if (_First == _Mid) {
+            auto _Final = _RANGES _Get_final_iterator_unwrapped<_It>(_Mid, _STD move(_Last));
+            return {_Final, _Final};
+        }
+
+        if (_Mid == _Last) {
+            return {_STD move(_First), _STD move(_Mid)};
+        }
+
+        if constexpr (bidirectional_iterator<_It>) {
+#if _VECTORIZED_ROTATE
+            using _Elem = remove_reference_t<iter_reference_t<_It>>;
+
+            if constexpr (contiguous_iterator<_It> && sized_sentinel_for<_Se, _It>
+                          && conjunction_v<_Is_trivially_ranges_swappable<_Elem>, negation<is_volatile<_Elem>>>) {
+                if (!_STD is_constant_evaluated()) {
+                    const _It _Last_it = _First + (_Last - _First);
+                    ::__std_rotate(_STD to_address(_First), _STD to_address(_Mid), _STD to_address(_Last_it));
+                    return {_First + (_Last - _Mid), _Last};
+                }
+            }
+#endif // ^^^ _VECTORIZED_ROTATE ^^^
+
+            _RANGES _Reverse_common(_First, _Mid);
+            auto _Final = _RANGES _Get_final_iterator_unwrapped<_It>(_Mid, _STD move(_Last));
+            _RANGES _Reverse_common(_Mid, _Final);
+
+            if constexpr (random_access_iterator<_It>) {
+                _RANGES _Reverse_common(_First, _Final);
+                _First += _Final - _Mid;
+
+                return {_STD move(_First), _STD move(_Final)};
+            } else {
+                const auto _Result = _RANGES _Reverse_until_mid_unchecked(_STD move(_First), _Mid, _Final);
+                auto _Mid_first    = _Result.begin();
+                auto _Mid_last     = _Result.end();
+                _RANGES _Reverse_common(_Mid_first, _Mid_last);
+
+                if (_Mid_first == _Mid) {
+                    return {_STD move(_Mid_last), _STD move(_Final)};
+                } else {
+                    return {_STD move(_Mid_first), _STD move(_Final)};
+                }
+            }
+        } else {
+            auto _Next = _Mid;
+            do { // rotate the first cycle
+                _RANGES iter_swap(_First, _Next);
+                ++_First;
+                ++_Next;
+                if (_First == _Mid) {
+                    _Mid = _Next;
+                }
+            } while (_Next != _Last);
+
+            auto _Begin = _First;
+
+            while (_Mid != _Last) { // rotate subsequent cycles
+                _Next = _Mid;
+                do {
+                    _RANGES iter_swap(_First, _Next);
+                    ++_First;
+                    ++_Next;
+                    if (_First == _Mid) {
+                        _Mid = _Next;
+                    }
+                } while (_Next != _Last);
+            }
+            return {_STD move(_Begin), _STD move(_Mid)};
+        }
+    }
+
+    struct _Rotate_fn {
+        template <permutable _It, sentinel_for<_It> _Se>
+        static constexpr subrange<_It> operator()(_It _First, _It _Mid, _Se _Last) {
+            _STD _Adl_verify_range(_First, _Mid);
+            _STD _Adl_verify_range(_Mid, _Last);
+            auto _UResult = _RANGES _Rotate_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_iter<_Se>(_STD move(_Mid)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+
+            return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+        }
+
+        template <forward_range _Rng>
+            requires permutable<iterator_t<_Rng>>
+        static constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, iterator_t<_Rng> _Mid) {
+            _STD _Adl_verify_range(_RANGES begin(_Range), _Mid);
+            _STD _Adl_verify_range(_Mid, _RANGES end(_Range));
+            auto _UResult = _RANGES _Rotate_unchecked(
+                _Ubegin(_Range), _RANGES _Unwrap_range_iter<_Rng>(_STD move(_Mid)), _Uend(_Range));
+
+            return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Mid, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Rotate_fn rotate;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _OutIt>
+_CONSTEXPR20 _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest) {
+    // copy rotating [_First, _Last)
+    _STD _Adl_verify_range(_First, _Mid);
+    _STD _Adl_verify_range(_Mid, _Last);
+    _STD _Verify_ranges_do_not_overlap(_First, _Last, _Dest);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _UMid   = _STD _Get_unwrapped(_Mid);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    auto _UDest        = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt>(_UFirst, _ULast));
+    _UDest             = _STD _Copy_unchecked(_UMid, _ULast, _UDest);
+    _STD _Seek_wrapped(_Dest, _STD _Copy_unchecked(_UFirst, _UMid, _UDest));
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 rotate_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Mid, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // copy rotating [_First, _Last)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD rotate_copy(_First, _Mid, _Last, _Dest);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using rotate_copy_result = in_out_result<_In, _Out>;
+
+    class _Rotate_copy_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+            requires indirectly_copyable<_It, _Out>
+        static constexpr rotate_copy_result<_It, _Out> operator()(_It _First, _It _Mid, _Se _Last, _Out _Output) {
+            _STD _Adl_verify_range(_First, _Mid);
+            _STD _Adl_verify_range(_Mid, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast       = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _Count = _RANGES _Idl_distance<_It>(_UFirst, _ULast);
+            auto _UResult     = _Rotate_copy_common(_STD move(_UFirst), _RANGES _Unwrap_iter<_Se>(_STD move(_Mid)),
+                _STD move(_ULast), _STD _Get_unwrapped_n(_STD move(_Output), _Count));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <forward_range _Rng, weakly_incrementable _Out>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+        static constexpr rotate_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
+            _Rng&& _Range, iterator_t<_Rng> _Mid, _Out _Output) {
+            _STD _Adl_verify_range(_RANGES begin(_Range), _Mid);
+            _STD _Adl_verify_range(_Mid, _RANGES end(_Range));
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _UResult     = _Rotate_copy_common(_Ubegin(_Range), _RANGES _Unwrap_range_iter<_Rng>(_STD move(_Mid)),
+                _Uend(_Range), _STD _Get_unwrapped_n(_STD move(_Output), _Count));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_RANGES _Rewrap_iterator(_Range, _STD move(_UResult.in)), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Out>
+        _NODISCARD static constexpr rotate_copy_result<_It, _Out> _Rotate_copy_common(
+            _It _First, _It _Mid, _Se _Last, _Out _Output) {
+            // Copy the content of [_Mid, _Last) and [_First, _Mid) to _Output
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+
+            _STD _Verify_ranges_do_not_overlap(_First, _Last, _Output);
+
+            auto _UResult1 = _RANGES _Copy_unchecked(_Mid, _STD move(_Last), _STD move(_Output));
+            auto _UResult2 = _RANGES _Copy_unchecked(_STD move(_First), _STD move(_Mid), _STD move(_UResult1.out));
+            return {_STD move(_UResult1.in), _STD move(_UResult2.out)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Rotate_copy_fn rotate_copy;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+template <class _Diff, class _Urng>
+class _Rng_from_urng_v2 { // wrap a URNG as an RNG
+public:
+    using _Ty0 = make_unsigned_t<_Diff>;
+    using _Ty1 = _Invoke_result_t<_Urng&>;
+
+    using _Udiff                              = conditional_t<sizeof(_Ty1) < sizeof(_Ty0), _Ty0, _Ty1>;
+    static constexpr unsigned int _Udiff_bits = sizeof(_Udiff) * CHAR_BIT;
+    using _Uprod = conditional_t<_Udiff_bits <= 16, uint32_t, conditional_t<_Udiff_bits <= 32, uint64_t, _Unsigned128>>;
+
+    explicit _Rng_from_urng_v2(_Urng& _Func) noexcept : _Ref(_Func) {}
+
+    _Diff operator()(_Diff _Index) { // adapt _Urng closed range to [0, _Index)
+        // From Daniel Lemire, "Fast Random Integer Generation in an Interval",
+        // ACM Trans. Model. Comput. Simul. 29 (1), 2019.
+        //
+        // Algorithm 5 <-> This Code:
+        //   m <-> _Product
+        //   l <-> _Rem
+        //   s <-> _Index
+        //   t <-> _Threshold
+        //   L <-> _Generated_bits
+        //   2^L - 1 <-> _Mask
+
+        _Udiff _Mask        = _Bmask;
+        unsigned int _Niter = 1;
+
+        if constexpr (_Bits < _Udiff_bits) {
+            while (_Mask < static_cast<_Udiff>(_Index - 1)) {
+                _Mask <<= _Bits;
+                _Mask |= _Bmask;
+                ++_Niter;
+            }
+        }
+
+        // x <- random integer in [0, 2^L)
+        // m <- x * s
+        auto _Product = _Get_random_product(_Index, _Niter);
+        // l <- m mod 2^L
+        auto _Rem = static_cast<_Udiff>(_Product) & _Mask;
+
+        if (_Rem < static_cast<_Udiff>(_Index)) {
+            // t <- (2^L - s) mod s
+            const auto _Threshold = (_Mask - _Index + 1) % _Index;
+            while (_Rem < _Threshold) {
+                _Product = _Get_random_product(_Index, _Niter);
+                _Rem     = static_cast<_Udiff>(_Product) & _Mask;
+            }
+        }
+
+        unsigned int _Generated_bits;
+        if constexpr (_Bits < _Udiff_bits) {
+            _Generated_bits = static_cast<unsigned int>(_Popcount(_Mask));
+        } else {
+            _Generated_bits = _Udiff_bits;
+        }
+
+        // m / 2^L
+        return static_cast<_Diff>(_Product >> _Generated_bits);
+    }
+
+    _Udiff _Get_all_bits() {
+        _Udiff _Ret = _Get_bits();
+
+        if constexpr (_Bits < _Udiff_bits) {
+            for (unsigned int _Num = _Bits; _Num < _Udiff_bits; _Num += _Bits) { // don't mask away any bits
+                _Ret <<= _Bits;
+                _Ret |= _Get_bits();
+            }
+        }
+
+        return _Ret;
+    }
+
+    _Rng_from_urng_v2(const _Rng_from_urng_v2&)            = delete;
+    _Rng_from_urng_v2& operator=(const _Rng_from_urng_v2&) = delete;
+
+private:
+    _Udiff _Get_bits() { // return a random value within [0, _Bmask]
+        constexpr auto _Urng_min = (_Urng::min) ();
+        for (;;) { // repeat until random value is in range
+            const _Udiff _Val = static_cast<_Udiff>(_Ref() - _Urng_min);
+
+            if (_Val <= _Bmask) {
+                return _Val;
+            }
+        }
+    }
+
+    static constexpr size_t _Calc_bits() {
+        auto _Bits_local  = _Udiff_bits;
+        auto _Bmask_local = static_cast<_Udiff>(-1);
+        for (; static_cast<_Udiff>((_Urng::max) () - (_Urng::min) ()) < _Bmask_local; _Bmask_local >>= 1) {
+            --_Bits_local;
+        }
+
+        return _Bits_local;
+    }
+
+    _Uprod _Get_random_product(const _Diff _Index, unsigned int _Niter) {
+        _Udiff _Ret = _Get_bits();
+        if constexpr (_Bits < _Udiff_bits) {
+            while (--_Niter > 0) {
+                _Ret <<= _Bits;
+                _Ret |= _Get_bits();
+            }
+        }
+
+        if constexpr (is_same_v<_Udiff, uint64_t>) {
+            uint64_t _High;
+            const auto _Low = _Base128::_UMul128(_Ret, static_cast<_Udiff>(_Index), _High);
+            return _Uprod{_Low, _High};
+        } else {
+            return _Uprod{_Ret} * static_cast<_Uprod>(_Index);
+        }
+    }
+
+    _Urng& _Ref; // reference to URNG
+    static constexpr size_t _Bits  = _Calc_bits(); // number of random bits generated by _Get_bits()
+    static constexpr _Udiff _Bmask = static_cast<_Udiff>(-1) >> (_Udiff_bits - _Bits); // 2^_Bits - 1
+};
+
+#if _HAS_CXX17
+template <class _PopIt, class _SampleIt, class _Diff, class _RngFn>
+_SampleIt _Sample_reservoir_unchecked(
+    _PopIt _First, const _PopIt _Last, const _SampleIt _Dest, const _Diff _Count, _RngFn& _RngFunc) {
+    // source is input: use reservoir sampling (unstable)
+    // pre: _SampleIt is random-access && 0 < _Count && the range [_Dest, _Dest + _Count) is valid
+    using _Diff_sample = _Iter_diff_t<_SampleIt>;
+    const auto _SCount = static_cast<_Diff_sample>(_Count);
+    _Iter_diff_t<_PopIt> _Pop_size{};
+    for (; _Pop_size < _SCount; ++_Pop_size, (void) ++_First) {
+        // _Pop_size is less than _SCount, and [_Dest, _Dest + _SCount) is valid,
+        // so [_Dest, _Dest + _Pop_size) must be valid, so narrowing to _Diff_sample
+        // can't overflow
+        const auto _Sample_pop = static_cast<_Diff_sample>(_Pop_size);
+        if (_First == _Last) {
+            return _Dest + _Sample_pop;
+        }
+
+        *(_Dest + _Sample_pop) = *_First;
+    }
+    for (; _First != _Last; ++_First) {
+        const auto _Idx = _RngFunc(++_Pop_size);
+        if (_Idx < _SCount) {
+            *(_Dest + static_cast<_Diff_sample>(_Idx)) = *_First; // again, valid narrowing because _Idx < _SCount
+        }
+    }
+    return _Dest + _SCount;
+}
+
+template <class _PopIt, class _SampleIt, class _Diff, class _RngFn>
+_SampleIt _Sample_selection_unchecked(
+    _PopIt _First, _Iter_diff_t<_PopIt> _Pop_size, _SampleIt _Dest, _Diff _Count, _RngFn& _RngFunc) {
+    // source is forward *and* we know the source range size: use selection sampling (stable)
+    // pre: _PopIt is forward && _Count <= _Pop_size
+    using _CT = common_type_t<_Iter_diff_t<_PopIt>, _Diff>;
+    for (; _Pop_size > 0; ++_First, (void) --_Pop_size) {
+        if (static_cast<_CT>(_RngFunc(_Pop_size)) < static_cast<_CT>(_Count)) {
+            --_Count;
+            *_Dest = *_First;
+            ++_Dest;
+        }
+    }
+    return _Dest;
+}
+
+_EXPORT_STD template <class _PopIt, class _SampleIt, class _Diff, class _Urng>
+_SampleIt sample(_PopIt _First, _PopIt _Last, _SampleIt _Dest, _Diff _Count, _Urng&& _Func) {
+    // randomly select _Count elements from [_First, _Last) into _Dest
+    static_assert(_Is_ranges_fwd_iter_v<_PopIt> || _Is_cpp17_random_iter_v<_SampleIt>,
+        "If the source range is not forward, the destination range must be a Cpp17RandomAccessIterator.");
+
+    static_assert(is_integral_v<_Diff>, "The sample size must have an integer type.");
+    _STD _Adl_verify_range(_First, _Last);
+    if (0 < _Count) {
+        auto _UFirst   = _STD _Get_unwrapped(_First);
+        auto _ULast    = _STD _Get_unwrapped(_Last);
+        using _PopDiff = _Iter_diff_t<_PopIt>;
+        _Rng_from_urng_v2<_PopDiff, remove_reference_t<_Urng>> _RngFunc(_Func);
+        if constexpr (_Is_ranges_fwd_iter_v<_PopIt>) {
+            // source is forward: use selection sampling (stable)
+            using _CT            = common_type_t<_Diff, _PopDiff>;
+            const auto _Pop_size = _STD distance(_UFirst, _ULast);
+            if (static_cast<_CT>(_Count) > static_cast<_CT>(_Pop_size)) {
+                _Count = static_cast<_Diff>(_Pop_size); // narrowing OK because _Count is getting smaller
+            }
+
+            _STD _Seek_wrapped(_Dest, _STD _Sample_selection_unchecked(
+                                          _UFirst, _Pop_size, _STD _Get_unwrapped_n(_Dest, _Count), _Count, _RngFunc));
+        } else {
+            static_assert(_Is_ranges_input_iter_v<_PopIt>, "Source iterators must be at least input iterators");
+            // source is input: use reservoir sampling (unstable)
+            _STD _Seek_wrapped(_Dest, _STD _Sample_reservoir_unchecked(
+                                          _UFirst, _ULast, _STD _Get_unwrapped_unverified(_Dest), _Count, _RngFunc));
+        }
+    }
+
+    return _Dest;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+concept uniform_random_bit_generator = invocable<_Ty&> && unsigned_integral<invoke_result_t<_Ty&>> && requires {
+    { (_Ty::min)() } -> same_as<invoke_result_t<_Ty&>>;
+    { (_Ty::max)() } -> same_as<invoke_result_t<_Ty&>>;
+    requires bool_constant<(_Ty::min) () < (_Ty::max) ()>::value;
+};
+
+namespace ranges {
+    class _Sample_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Urng>
+            requires (forward_iterator<_It> || random_access_iterator<_Out>)
+                  && indirectly_copyable<_It, _Out> && uniform_random_bit_generator<remove_reference_t<_Urng>>
+        static _Out operator()(_It _First, _Se _Last, _Out _Output, iter_difference_t<_It> _Count, _Urng&& _Func) {
+            _STD _Adl_verify_range(_First, _Last);
+            if (_Count <= 0) {
+                return _Output;
+            }
+
+            _Rng_from_urng_v2<iter_difference_t<_It>, remove_reference_t<_Urng>> _RngFunc(_Func);
+            if constexpr (forward_iterator<_It>) {
+                auto _UFirst   = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+                auto _Pop_size = _RANGES distance(_UFirst, _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+                return _Selection_sample(_STD move(_UFirst), _Pop_size, _STD move(_Output), _Count, _RngFunc);
+            } else {
+                return _Reservoir_sample(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                    _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD move(_Output), _Count, _RngFunc);
+            }
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out, class _Urng>
+            requires (forward_range<_Rng> || random_access_iterator<_Out>)
+                  && indirectly_copyable<iterator_t<_Rng>, _Out>
+                  && uniform_random_bit_generator<remove_reference_t<_Urng>>
+        static _Out operator()(_Rng&& _Range, _Out _Output, range_difference_t<_Rng> _Count, _Urng&& _Func) {
+            if (_Count <= 0) {
+                return _Output;
+            }
+
+            _Rng_from_urng_v2<range_difference_t<_Rng>, remove_reference_t<_Urng>> _RngFunc(_Func);
+            if constexpr (forward_range<_Rng>) {
+                auto _UFirst   = _Ubegin(_Range);
+                auto _Pop_size = _RANGES distance(_UFirst, _Uend(_Range));
+                return _Selection_sample(_STD move(_UFirst), _Pop_size, _STD move(_Output), _Count, _RngFunc);
+            } else {
+                return _Reservoir_sample(_Ubegin(_Range), _Uend(_Range), _STD move(_Output), _Count, _RngFunc);
+            }
+        }
+
+    private:
+        template <class _It, class _Out, class _Rng>
+        _NODISCARD static _Out _Selection_sample(
+            _It _First, iter_difference_t<_It> _Pop_size, _Out _Output, iter_difference_t<_It> _Count, _Rng& _RngFunc) {
+            // Randomly select _Count elements from _First + [0, _Pop_size) into _Output.
+            // _First should be already unwrapped, _Output will be unwrapped locally.
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+
+            if (_Count > _Pop_size) {
+                _Count = _Pop_size;
+            }
+            auto _UOutput = _STD _Get_unwrapped_n(_STD move(_Output), _Count);
+
+            for (; _Pop_size > 0; ++_First, (void) --_Pop_size) {
+                if (_RngFunc(_Pop_size) < _Count) {
+                    *_UOutput = *_First;
+                    ++_UOutput;
+                    if (--_Count == 0) {
+                        break;
+                    }
+                }
+            }
+
+            _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+            return _Output;
+        }
+
+        template <class _It, class _Se, class _Out, class _Rng>
+        _NODISCARD static _Out _Reservoir_sample(
+            _It _First, const _Se _Last, _Out _Output, const iter_difference_t<_It> _Count, _Rng& _RngFunc) {
+            // Randomly select _Count elements from [_First, _Last) into _Output.
+            // _First should be already unwrapped, _Output will be unwrapped locally.
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It, _Out>);
+
+            auto _UOutput = _STD _Get_unwrapped_unverified(_STD move(_Output));
+            iter_difference_t<_It> _Pop_size{};
+            for (; _Pop_size < _Count; ++_Pop_size, (void) ++_First) {
+                if (_First == _Last) {
+                    _UOutput += _Pop_size;
+                    _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+                    return _Output;
+                }
+
+                *(_UOutput + _Pop_size) = *_First;
+            }
+            for (; _First != _Last; ++_First) {
+                const auto _Idx = _RngFunc(++_Pop_size);
+                if (_Idx < _Count) {
+                    *(_UOutput + _Idx) = *_First;
+                }
+            }
+
+            _UOutput += _Count;
+            _STD _Seek_wrapped(_Output, _STD move(_UOutput));
+            return _Output;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Sample_fn sample;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+template <class _RanIt, class _RngFn>
+void _Random_shuffle1(_RanIt _First, _RanIt _Last, _RngFn& _RngFunc) {
+    // shuffle [_First, _Last) using random function _RngFunc
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if (_UFirst == _ULast) {
+        return;
+    }
+
+    using _Diff         = _Iter_diff_t<_RanIt>;
+    auto _UTarget       = _UFirst;
+    _Diff _Target_index = 1;
+    for (; ++_UTarget != _ULast; ++_Target_index) { // randomly place an element from [_First, _Target] at _Target
+        _Diff _Off = _RngFunc(static_cast<_Diff>(_Target_index + 1));
+        _STL_ASSERT(0 <= _Off && _Off <= _Target_index, "random value out of range");
+        if (_Off != _Target_index) { // avoid self-move-assignment
+            swap(*_UTarget, *(_UFirst + _Off)); // intentional ADL
+        }
+    }
+}
+
+_EXPORT_STD template <class _RanIt, class _Urng>
+void shuffle(_RanIt _First, _RanIt _Last, _Urng&& _Func) { // shuffle [_First, _Last) using URNG _Func
+    using _Urng0 = remove_reference_t<_Urng>;
+    _Rng_from_urng_v2<_Iter_diff_t<_RanIt>, _Urng0> _RngFunc(_Func);
+    _STD _Random_shuffle1(_First, _Last, _RngFunc);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Shuffle_fn {
+    public:
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Urng>
+            requires permutable<_It> && uniform_random_bit_generator<remove_reference_t<_Urng>>
+        static _It operator()(_It _First, _Se _Last, _Urng&& _Func) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            _Rng_from_urng_v2<iter_difference_t<_It>, remove_reference_t<_Urng>> _RngFunc(_Func);
+            auto _UResult = _Shuffle_unchecked(
+                _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _RngFunc);
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <random_access_range _Rng, class _Urng>
+            requires permutable<iterator_t<_Rng>> && uniform_random_bit_generator<remove_reference_t<_Urng>>
+        static borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Urng&& _Func) {
+            _Rng_from_urng_v2<range_difference_t<_Rng>, remove_reference_t<_Urng>> _RngFunc(_Func);
+
+            return _RANGES _Rewrap_iterator(_Range, _Shuffle_unchecked(_Ubegin(_Range), _Uend(_Range), _RngFunc));
+        }
+
+    private:
+        template <class _It, class _Se, class _Rng>
+        _NODISCARD static _It _Shuffle_unchecked(_It _First, const _Se _Last, _Rng& _Func) {
+            // shuffle [_First, _Last) using random function _Func
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+
+            if (_First == _Last) {
+                return _First;
+            }
+            using _Diff = iter_difference_t<_It>;
+
+            auto _Target        = _First;
+            _Diff _Target_index = 1;
+            for (; ++_Target != _Last; ++_Target_index) {
+                // randomly place an element from [_First, _Target] at _Target
+                const _Diff _Off = _Func(_Target_index + 1);
+                _STL_ASSERT(0 <= _Off && _Off <= _Target_index, "random value out of range");
+                if (_Off != _Target_index) { // avoid self-move-assignment
+                    _RANGES iter_swap(_Target, _First + _Off);
+                }
+            }
+            return _Target;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Shuffle_fn shuffle;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+#if _HAS_AUTO_PTR_ETC
+_EXPORT_STD template <class _RanIt, class _RngFn>
+void random_shuffle(_RanIt _First, _RanIt _Last, _RngFn&& _RngFunc) {
+    // shuffle [_First, _Last) using random function _RngFunc
+    _STD _Random_shuffle1(_First, _Last, _RngFunc);
+}
+
+struct _Rand_urng_from_func { // wrap rand() as a URNG
+    using result_type = unsigned int;
+
+    static constexpr result_type(min)() { // return minimum possible generated value
+        return 0;
+    }
+
+    static constexpr result_type(max)() { // return maximum possible generated value
+        return RAND_MAX;
+    }
+
+    result_type operator()() { // invoke rand()
+        return static_cast<result_type>(_CSTD rand());
+    }
+};
+
+_EXPORT_STD template <class _RanIt>
+void random_shuffle(_RanIt _First, _RanIt _Last) { // shuffle [_First, _Last) using rand()
+    _Rand_urng_from_func _Func;
+    _STD shuffle(_First, _Last, _Func);
+}
+#endif // _HAS_AUTO_PTR_ETC
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _FwdIt>
+constexpr _FwdIt shift_left(
+    _FwdIt _First, const _FwdIt _Last, typename iterator_traits<_FwdIt>::difference_type _Pos_to_shift) {
+    // shift [_First, _Last) left by _Pos_to_shift
+    // positions; returns the end of the resulting range
+    _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/1)");
+
+    _STD _Adl_verify_range(_First, _Last);
+
+    if (_Pos_to_shift == 0) {
+        return _Last;
+    }
+
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    auto _Start_at     = _UFirst;
+
+    if constexpr (_Is_cpp17_random_iter_v<_FwdIt>) {
+        if (_Pos_to_shift >= _ULast - _UFirst) {
+            return _First;
+        }
+        _Start_at += _Pos_to_shift;
+    } else {
+        for (; 0 < _Pos_to_shift; --_Pos_to_shift) {
+            if (_Start_at == _ULast) {
+                return _First;
+            }
+            ++_Start_at;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _STD _Move_unchecked(_Start_at, _ULast, _UFirst));
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt>
+    requires requires { typename _Enable_if_execution_policy_t<_ExPo>; }
+_FwdIt shift_left(_ExPo&&, _FwdIt _First, _FwdIt _Last,
+    typename iterator_traits<_FwdIt>::difference_type _Pos_to_shift) noexcept /* terminates */ {
+    // shift [_First, _Last) left by _Pos_to_shift positions
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD shift_left(_First, _Last, _Pos_to_shift);
+}
+
+_EXPORT_STD template <class _FwdIt>
+constexpr _FwdIt shift_right(
+    _FwdIt _First, const _FwdIt _Last, typename iterator_traits<_FwdIt>::difference_type _Pos_to_shift) {
+    // shift [_First, _Last) right by _Pos_to_shift
+    // positions; returns the beginning of the resulting range
+    _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/5)");
+
+    _STD _Adl_verify_range(_First, _Last);
+
+    if (_Pos_to_shift == 0) {
+        return _First;
+    }
+
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+
+    if constexpr (_Is_cpp17_bidi_iter_v<_FwdIt>) {
+        auto _UEnd_at = _ULast;
+        if constexpr (_Is_cpp17_random_iter_v<_FwdIt>) {
+            if (_Pos_to_shift >= _ULast - _UFirst) {
+                return _Last;
+            }
+            _UEnd_at -= _Pos_to_shift;
+        } else {
+            for (; 0 < _Pos_to_shift; --_Pos_to_shift) {
+                if (_UEnd_at == _UFirst) {
+                    return _Last;
+                }
+                --_UEnd_at;
+            }
+        }
+
+        _STD _Seek_wrapped(_First, _STD _Move_backward_unchecked(_UFirst, _UEnd_at, _ULast));
+        return _First;
+    } else {
+        auto _UResult = _UFirst;
+
+        for (; 0 < _Pos_to_shift; --_Pos_to_shift) {
+            if (_UResult == _ULast) {
+                return _Last;
+            }
+            ++_UResult;
+        }
+        _STD _Seek_wrapped(_First, _UResult);
+
+        auto _Trail = _UFirst;
+        auto _Lead  = _UResult;
+
+        for (; _Trail != _UResult; ++_Trail, (void) ++_Lead) {
+            if (_Lead == _ULast) {
+                _STD _Move_unchecked(_UFirst, _Trail, _UResult);
+
+                return _First;
+            }
+        }
+
+        // Here, _Trail = _UFirst + original _Pos_to_shift
+        // Here, _Lead = _UFirst + 2 * original _Pos_to_shift
+
+        for (;;) {
+            // This loop swaps the range [_UFirst, _UResult) with [_Trail, _Lead),
+            // advancing _Trail and _Lead by _Pos_to_shift
+            for (auto _Mid = _UFirst; _Mid != _UResult; ++_Mid, (void) ++_Trail, ++_Lead) {
+                if (_Lead == _ULast) {
+                    _Trail = _STD _Move_unchecked(_Mid, _UResult, _Trail);
+                    _STD _Move_unchecked(_UFirst, _Mid, _Trail);
+
+                    return _First;
+                }
+                swap(*_Mid, *_Trail); // intentional ADL
+            }
+        }
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt>
+    requires requires { typename _Enable_if_execution_policy_t<_ExPo>; }
+_FwdIt shift_right(_ExPo&&, _FwdIt _First, _FwdIt _Last,
+    typename iterator_traits<_FwdIt>::difference_type _Pos_to_shift) noexcept /* terminates */ {
+    // shift [_First, _Last) right by _Pos_to_shift positions
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD shift_right(_First, _Last, _Pos_to_shift);
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+namespace ranges {
+    class _Shift_left_fn {
+    public:
+        template <permutable _It, sentinel_for<_It> _Se>
+        static constexpr subrange<_It> operator()(_It _First, const _Se _Last, iter_difference_t<_It> _Pos_to_shift) {
+            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/1)");
+
+            _STD _Adl_verify_range(_First, _Last);
+            auto _Result = _First;
+            _Unwrap_iter_t<_It, _Se> _UResult;
+
+            if (_Pos_to_shift == 0) {
+                _UResult = _RANGES _Get_final_iterator_unwrapped<_It>(_RANGES _Unwrap_iter<_Se>(_Result), _Last);
+            } else {
+                _UResult = _Shift_left_impl(
+                    _RANGES _Unwrap_iter<_Se>(_First), _RANGES _Unwrap_sent<_It>(_Last), _Pos_to_shift);
+            }
+            _STD _Seek_wrapped(_Result, _UResult);
+            return {_STD move(_First), _STD move(_Result)};
+        }
+
+        template <forward_range _Rng>
+            requires permutable<iterator_t<_Rng>>
+        static constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, range_difference_t<_Rng> _Pos_to_shift) {
+            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/1)");
+
+            if (_Pos_to_shift == 0) {
+                auto _Last = _RANGES _Rewrap_iterator(_Range, _RANGES _Get_final_iterator_unwrapped(_Range));
+                return {_RANGES begin(_Range), _STD move(_Last)};
+            }
+
+            if constexpr (sized_range<_Rng>) {
+                auto _First = _RANGES begin(_Range);
+                if (_RANGES distance(_Range) <= _Pos_to_shift) {
+                    return {_First, _First};
+                }
+
+                auto _UFirst   = _RANGES _Unwrap_range_iter<_Rng>(_First);
+                auto _Start_at = _RANGES next(_UFirst, _Pos_to_shift);
+                auto _Result   = _RANGES _Move_unchecked(_STD move(_Start_at), _Uend(_Range), _UFirst).out;
+                return {_STD move(_First), _RANGES _Rewrap_iterator(_Range, _STD move(_Result))};
+            } else {
+                auto _Result = _Shift_left_impl(_Ubegin(_Range), _Uend(_Range), _Pos_to_shift);
+                return {_RANGES begin(_Range), _RANGES _Rewrap_iterator(_Range, _STD move(_Result))};
+            }
+        }
+
+    private:
+        template <class _It, class _Se>
+        _NODISCARD static constexpr _It _Shift_left_impl(_It _First, _Se _Last, iter_difference_t<_It> _Pos_to_shift) {
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_CHECK(_Pos_to_shift > 0);
+
+            auto _Start_at = _First;
+            if (_RANGES advance(_Start_at, _Pos_to_shift, _Last) != 0) {
+                return _First;
+            }
+
+            return _RANGES _Move_unchecked(_STD move(_Start_at), _STD move(_Last), _STD move(_First)).out;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Shift_left_fn shift_left;
+
+    class _Shift_right_fn {
+    public:
+        template <permutable _It, sentinel_for<_It> _Se>
+        static constexpr subrange<_It> operator()(_It _First, const _Se _Last, iter_difference_t<_It> _Pos_to_shift) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst     = _RANGES _Unwrap_iter<_Se>(_First);
+            auto _ULast      = _RANGES _Unwrap_sent<_It>(_Last);
+            const auto _Size = _Size_helper(_UFirst, _ULast);
+            auto _Result     = _Shift_right_impl(_STD move(_UFirst), _STD move(_ULast), _Pos_to_shift, _Size);
+            _STD _Seek_wrapped(_First, _Result.begin());
+            auto _Final = _First;
+            _STD _Seek_wrapped(_Final, _Result.end());
+            return {_STD move(_First), _STD move(_Final)};
+        }
+
+        template <forward_range _Rng>
+            requires permutable<iterator_t<_Rng>>
+        static constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, range_difference_t<_Rng> _Pos_to_shift) {
+            const auto _Size = _Size_helper(_Range);
+            auto _Result     = _Shift_right_impl(_Ubegin(_Range), _Uend(_Range), _Pos_to_shift, _Size);
+            auto _First      = _RANGES _Rewrap_iterator(_Range, _Result.begin());
+            auto _Final      = _RANGES _Rewrap_iterator(_Range, _Result.end());
+            return {_STD move(_First), _STD move(_Final)};
+        }
+
+    private:
+        struct _Unsized {};
+
+        template <range _Rng>
+        _NODISCARD static constexpr auto _Size_helper(_Rng&& _Range) {
+            if constexpr (sized_range<_Rng>) {
+                return _RANGES distance(_Range);
+            } else {
+                return _Unsized{};
+            }
+        }
+
+        template <class _It, sentinel_for<_It> _Se>
+        _NODISCARD static constexpr auto _Size_helper(const _It& _First, const _Se& _Last) {
+            if constexpr (sized_sentinel_for<_Se, _It>) {
+                return _Last - _First;
+            } else {
+                return _Unsized{};
+            }
+        }
+
+        template <input_iterator _It, weakly_incrementable _Out>
+            requires indirectly_movable<_It, _Out>
+        _NODISCARD static constexpr _Out _Move_n_helper(_It _First, iter_difference_t<_It> _Count, _Out _Output) {
+            for (; _Count > 0; ++_First, (void) --_Count, ++_Output) {
+                *_Output = _RANGES iter_move(_First);
+            }
+
+            return _Output;
+        }
+
+        template <class _It, class _Se, class _SizeTy>
+        _NODISCARD static constexpr subrange<_It> _Shift_right_impl(
+            _It _First, _Se _Last, iter_difference_t<_It> _Pos_to_shift, const _SizeTy _Size) {
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_ASSERT(_Pos_to_shift >= 0, "shift count must be non-negative (N4950 [alg.shift]/5)");
+
+            if (_Pos_to_shift == 0) {
+                return {_First, _RANGES next(_First, _Last)};
+            }
+
+            constexpr bool _Is_sized = !same_as<_SizeTy, _Unsized>;
+
+            if constexpr (_Is_sized) {
+                if (_Pos_to_shift >= _Size) {
+                    if constexpr (same_as<_It, _Se>) {
+                        return {_Last, _Last};
+                    } else if constexpr (random_access_iterator<_It>) {
+                        _First += _Size;
+                        return {_First, _First};
+                    } else {
+                        _RANGES advance(_First, _Last);
+                        return {_First, _First};
+                    }
+                }
+            }
+
+            if constexpr (_Bidi_common<_It, _Se>) {
+                auto _Mid = _Last;
+                if constexpr (_Is_sized) {
+                    // We validated above that the length of the range is more than _Pos_to_shift
+                    _RANGES advance(_Mid, -_Pos_to_shift);
+                } else {
+                    if (_RANGES advance(_Mid, -_Pos_to_shift, _First) != 0) {
+                        return {_Last, _Last};
+                    }
+                }
+                return {_RANGES _Move_backward_common(_STD move(_First), _STD move(_Mid), _Last), _Last};
+            } else if constexpr (_Is_sized && random_access_iterator<_It>) {
+                auto _Final = _First + _Size;
+                auto _Mid   = _Final - _Pos_to_shift;
+                return {_RANGES _Move_backward_common(_STD move(_First), _STD move(_Mid), _Final), _Final};
+            } else {
+                auto _Buf = _First;
+                if constexpr (_Is_sized) {
+                    _RANGES advance(_Buf, _Pos_to_shift);
+                } else {
+                    if (_RANGES advance(_Buf, _Pos_to_shift, _Last) != 0) {
+                        return {_Buf, _Buf};
+                    }
+                }
+
+                if constexpr (_Is_sized) {
+                    if (_Size < 2 * _Pos_to_shift) {
+                        return {_Buf, _Move_n_helper(_First, _Size - _Pos_to_shift, _Buf)};
+                    }
+                }
+
+                auto _Lead = _Buf;
+                if constexpr (_Is_sized) {
+                    // We validated above that the length of the range is at least 2 * _Pos_to_shift
+                    _RANGES advance(_Lead, _Pos_to_shift);
+                } else {
+                    if (auto _Rem = _RANGES advance(_Lead, _Pos_to_shift, _Last); _Rem != 0) {
+                        return {_Buf, _Move_n_helper(_First, _Pos_to_shift - _Rem, _Buf)};
+                    }
+                }
+
+                auto _Trail = _Buf;
+
+                // The range is now partitioned like:
+                //
+                // | _Pos_to_shift elements |           | _Pos_to_shift elements |
+                // |------------------------|-----------|------------------------|------------|
+                // ^_First              _Buf^     _Trail^                   _Lead^       _Last^
+                //
+                // From now on, _Mid repeatedly cycles through the [_First, _Buf) window while the
+                // [_Trail, _Lead) window advances toward _Last.
+
+                for (;;) {
+                    for (auto _Mid = _First; _Mid != _Buf; ++_Mid, (void) ++_Trail, ++_Lead) {
+                        if (_Lead == _Last) {
+                            // The leading edge of the [_Trail, _Lead) window has hit the end of
+                            // the range, so we have only the final _Pos_to_shift elements to process.
+                            // Their original values are lost - shifted off the end of the range -
+                            // so we only need to fill them with new values from [_First, _Buf).
+                            _Trail = _RANGES _Move_unchecked(_Mid, _Buf, _STD move(_Trail)).out;
+                            _Trail = _RANGES _Move_unchecked(_First, _Mid, _STD move(_Trail)).out;
+                            _STL_INTERNAL_CHECK(_Trail == _Lead);
+                            return {_STD move(_Buf), _STD move(_Trail)};
+                        }
+
+                        _RANGES iter_swap(_Mid, _Trail);
+                    }
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Shift_right_fn shift_right;
+} // namespace ranges
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_CONSTEXPR20 _FwdIt partition(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
+    // move elements satisfying _Pred to beginning of sequence
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (_Is_cpp17_bidi_iter_v<_FwdIt>) {
+        for (;;) { // find any out-of-order pair
+            for (;;) { // skip in-place elements at beginning
+                if (_UFirst == _ULast) {
+                    _STD _Seek_wrapped(_First, _UFirst);
+                    return _First;
+                }
+
+                if (!_Pred(*_UFirst)) {
+                    break;
+                }
+
+                ++_UFirst;
+            }
+
+            do { // skip in-place elements at end
+                --_ULast;
+                if (_UFirst == _ULast) {
+                    _STD _Seek_wrapped(_First, _UFirst);
+                    return _First;
+                }
+            } while (!_Pred(*_ULast));
+
+            swap(*_UFirst, *_ULast); // out of place, swap and loop; intentional ADL
+            ++_UFirst;
+        }
+    } else {
+        for (;;) { // skip in-place elements at beginning
+            if (_UFirst == _ULast) {
+                _STD _Seek_wrapped(_First, _UFirst);
+                return _First;
+            }
+
+            if (!_Pred(*_UFirst)) {
+                break;
+            }
+
+            ++_UFirst;
+        }
+
+        for (auto _UNext = _UFirst; ++_UNext != _ULast;) {
+            if (_Pred(*_UNext)) {
+                swap(*_UFirst, *_UNext); // out of place, swap and loop; intentional ADL
+                ++_UFirst;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt partition(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Partition_fn {
+    public:
+        template <permutable _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        static constexpr subrange<_It> operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Partition_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+            requires permutable<iterator_t<_Rng>>
+        static constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            auto _UResult =
+                _Partition_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pr, class _Pj>
+        _NODISCARD static constexpr subrange<_It> _Partition_unchecked(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            if constexpr (bidirectional_iterator<_It>) {
+                auto _Saved_last = _RANGES next(_First, _Last);
+                auto _Tail       = _Saved_last;
+                for (;; ++_First) { // find any out-of-order pair
+                    for (;; ++_First) { // skip in-place elements at beginning
+                        if (_First == _Tail) {
+                            return {_STD move(_First), _STD move(_Saved_last)};
+                        }
+
+                        if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                            break;
+                        }
+                    }
+
+                    do { // skip in-place elements at end
+                        --_Tail;
+                        if (_First == _Tail) {
+                            return {_STD move(_First), _STD move(_Saved_last)};
+                        }
+                    } while (!_STD invoke(_Pred, _STD invoke(_Proj, *_Tail)));
+
+                    _RANGES iter_swap(_First, _Tail); // out of place, swap and loop
+                }
+
+                return {_STD move(_First), _STD move(_Saved_last)};
+            } else {
+                for (;; ++_First) { // skip in-place elements at beginning
+                    if (_First == _Last) {
+                        return {_First, _First};
+                    }
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                        break;
+                    }
+                }
+
+                auto _Next = _First;
+                while (++_Next != _Last) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_Next))) {
+                        _RANGES iter_swap(_First, _Next); // out of place, swap and loop
+                        ++_First;
+                    }
+                }
+
+                return {_STD move(_First), _STD move(_Next)};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Partition_fn partition;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+template <class _BidIt>
+_BidIt _Buffered_rotate_unchecked(const _BidIt _First, const _BidIt _Mid, const _BidIt _Last,
+    const _Iter_diff_t<_BidIt> _Count1, const _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr,
+    const ptrdiff_t _Capacity) { // rotate [_First, _Last) using temp buffer
+                                 // precondition: _Count1 == distance(_First, _Mid)
+                                 // precondition: _Count2 == distance(_Mid, _Last)
+    if (_Count1 == 0) {
+        return _Last;
+    }
+
+    if (_Count2 == 0) {
+        return _First;
+    }
+
+    if (_Count1 <= _Count2 && _Count1 <= _Capacity) { // buffer left range, then copy parts
+        _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{
+            _Temp_ptr, _STD _Uninitialized_move_unchecked(_First, _Mid, _Temp_ptr)};
+        const _BidIt _New_mid = _STD _Move_unchecked(_Mid, _Last, _First);
+        _STD _Move_unchecked(_Backout._First, _Backout._Last, _New_mid);
+        return _New_mid; // _Backout destroys elements in temporary buffer
+    }
+
+    if (_Count2 <= _Capacity) { // buffer right range, then copy parts
+        _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{
+            _Temp_ptr, _STD _Uninitialized_move_unchecked(_Mid, _Last, _Temp_ptr)};
+        _STD _Move_backward_unchecked(_First, _Mid, _Last);
+        return _STD _Move_unchecked(_Backout._First, _Backout._Last, _First); // ditto _Backout destroys elements
+    }
+
+    // buffer too small, rotate in place
+    return _STD rotate(_First, _Mid, _Last);
+}
+
+template <class _BidIt, class _Pr>
+pair<_BidIt, _Iter_diff_t<_BidIt>> _Stable_partition_unchecked1(_BidIt _First, _BidIt _Last, _Pr _Pred,
+    const _Iter_diff_t<_BidIt> _Count, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity) {
+    // implement stable_partition of [_First, _Last] (note: closed range)
+    // precondition: !_Pred(*_First)
+    // precondition: _Pred(*_Last)
+    // precondition: distance(_First, _Last) + 1 == _Count
+    // note: _Count >= 2 and _First != _Last
+    // returns: a pair such that first is the partition point, and second is distance(_First, partition point)
+    using _Diff = _Iter_diff_t<_BidIt>;
+    if (_Count - static_cast<_Diff>(1) <= _Capacity) { // - 1 since we never need to store *_Last
+        _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{_Temp_ptr};
+        _BidIt _Next = _First;
+        _Backout._Emplace_back(_STD move(*_First));
+        while (++_First != _Last) { // test each element, copying to _Temp_ptr if it's in the false range, or assigning
+                                    // backwards if it's in the true range
+            if (_Pred(*_First)) {
+                *_Next = _STD move(*_First);
+                ++_Next;
+            } else {
+                _Backout._Emplace_back(_STD move(*_First));
+            }
+        }
+
+        // move the last true element, *_Last, to the end of the true range
+        *_Next = _STD move(*_Last);
+        ++_Next;
+        _STD _Move_unchecked(_Backout._First, _Backout._Last, _Next); // copy back the false range
+        _Diff _True_distance = static_cast<_Diff>(_Count - static_cast<_Diff>(_Backout._Last - _Backout._First));
+        return pair<_BidIt, _Diff>(_Next, _True_distance); // _Backout destroys elements
+    }
+
+    const _Diff _Mid_offset = _Count / static_cast<_Diff>(2); // note: >= 1 because _Count >= 2
+    const _BidIt _Mid       = _STD next(_First, _Mid_offset);
+
+    // form [_First, _Left) true range, [_Left, _Mid) false range
+    _BidIt _Left           = _Mid;
+    _Diff _Left_true_count = _Mid_offset;
+    for (;;) { // skip over the trailing false range before _Mid
+        --_Left;
+        if (_First == _Left) { // the entire left range is false
+            --_Left_true_count; // to exclude *_First
+            break;
+        }
+
+        if (_Pred(*_Left)) { // excluded the false range before _Mid, invariants reestablished, recurse
+            const pair<_BidIt, _Diff> _Low =
+                _STD _Stable_partition_unchecked1(_First, _Left, _Pred, _Left_true_count, _Temp_ptr, _Capacity);
+            _Left            = _Low.first;
+            _Left_true_count = _Low.second;
+            break;
+        }
+
+        --_Left_true_count;
+    }
+
+    // form [_Mid, _Right) true range, [_Right, next(_Last)) false range
+    _BidIt _Right           = _Mid;
+    _Diff _Right_true_count = 0;
+    for (;;) { // skip over the leading true range after and including _Mid
+        if (_Right == _Last) { // the entire right range is true
+            ++_Right; // to include _Last
+            ++_Right_true_count;
+            break;
+        }
+
+        if (!_Pred(*_Right)) { // excluded the true range after and including _Mid, invariants reestablished, recurse
+            const _Diff _Right_count = _Count - _Mid_offset;
+            const _Diff _Remaining   = _Right_count - _Right_true_count;
+            const pair<_BidIt, _Diff> _High =
+                _STD _Stable_partition_unchecked1(_Right, _Last, _Pred, _Remaining, _Temp_ptr, _Capacity);
+            _Right = _High.first;
+            _Right_true_count += _High.second;
+            break;
+        }
+
+        ++_Right;
+        ++_Right_true_count;
+    }
+
+    // swap the [_Left, _Mid) false range with the [_Mid, _Right) true range
+    const _BidIt _Partition_point = _STD _Buffered_rotate_unchecked(_Left, _Mid, _Right,
+        static_cast<_Diff>(_Mid_offset - _Left_true_count), _Right_true_count, _Temp_ptr, _Capacity);
+    return pair<_BidIt, _Diff>(_Partition_point, static_cast<_Diff>(_Left_true_count + _Right_true_count));
+}
+
+template <class _BidIt, class _Pr>
+_BidIt _Stable_partition_unchecked(_BidIt _First, _BidIt _Last, _Pr _Pred) {
+    // partition preserving order of equivalents
+    for (;;) {
+        if (_First == _Last) { // the input range is true (already partitioned)
+            return _First;
+        }
+
+        if (!_Pred(*_First)) { // excluded the leading true range
+            break;
+        }
+
+        ++_First;
+    }
+
+    for (;;) {
+        --_Last;
+        if (_First == _Last) { // the input range is already partitioned
+            return _First;
+        }
+
+        if (_Pred(*_Last)) { // excluded the trailing false range
+            break;
+        }
+    }
+
+    using _Diff              = _Iter_diff_t<_BidIt>;
+    const _Diff _Temp_count  = _STD distance(_First, _Last); // _Total_count - 1 since we never need to store *_Last
+    const _Diff _Total_count = _Temp_count + static_cast<_Diff>(1);
+    _Optimistic_temporary_buffer2<_Iter_value_t<_BidIt>> _Temp_buf{_Temp_count};
+    return _STD _Stable_partition_unchecked1(_First, _Last, _Pred, _Total_count, _Temp_buf._Data, _Temp_buf._Capacity)
+        .first;
+}
+
+_EXPORT_STD template <class _BidIt, class _Pr>
+_BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred) {
+    // partition preserving order of equivalents
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Seek_wrapped(_First, _STD _Stable_partition_unchecked(
+                                   _STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_BidIt stable_partition(_ExPo&&, _BidIt _First, _BidIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // partition preserving order of equivalents
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_CPP17_MUTABLE_BIDIRECTIONAL_ITERATOR(_BidIt);
+    return _STD stable_partition(_First, _Last, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <bidirectional_iterator _It>
+    _It _Buffered_rotate_common(const _It _First, const _It _Mid, const _It _Last, const iter_difference_t<_It> _Count1,
+        const iter_difference_t<_It> _Count2, iter_value_t<_It>* const _Temp_ptr, const ptrdiff_t _Capacity) {
+        // rotate [_First, _Last) using temp buffer
+        _STL_INTERNAL_CHECK(_Count1 == _RANGES distance(_First, _Mid));
+        _STL_INTERNAL_CHECK(_Count2 == _RANGES distance(_Mid, _Last));
+
+        if (_Count1 == 0) {
+            return _Last;
+        }
+
+        if (_Count2 == 0) {
+            return _First;
+        }
+
+        if (_Count1 <= _Count2 && _Count1 <= _Capacity) { // buffer left range, then move parts
+            _Uninitialized_backout<iter_value_t<_It>*> _Backout{
+                _Temp_ptr, _RANGES _Uninitialized_move_unchecked(
+                               _First, _Mid, _Temp_ptr, _Temp_ptr + static_cast<ptrdiff_t>(_Count1))
+                               .out};
+            const _It _New_mid = _RANGES _Move_unchecked(_STD move(_Mid), _STD move(_Last), _STD move(_First)).out;
+            _RANGES _Move_unchecked(_Backout._First, _Backout._Last, _New_mid);
+            return _New_mid;
+        }
+
+        if (_Count2 <= _Capacity) { // buffer right range, then move parts
+            _Uninitialized_backout<iter_value_t<_It>*> _Backout{
+                _Temp_ptr, _RANGES _Uninitialized_move_unchecked(
+                               _Mid, _Last, _Temp_ptr, _Temp_ptr + static_cast<ptrdiff_t>(_Count2))
+                               .out};
+            _RANGES _Move_backward_common(_First, _STD move(_Mid), _STD move(_Last));
+            return _RANGES _Move_unchecked(_Backout._First, _Backout._Last, _STD move(_First)).out;
+        }
+
+        // buffer too small, rotate in place
+        return _RANGES _Rotate_unchecked(_STD move(_First), _STD move(_Mid), _STD move(_Last)).begin();
+    }
+
+    class _Stable_partition_fn {
+    public:
+        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+            requires permutable<_It>
+        static subrange<_It> operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+
+            auto _UResult = _Stable_partition_common(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+        }
+
+        template <bidirectional_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+            requires permutable<iterator_t<_Rng>>
+        static borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            auto _ULast   = _RANGES _Get_final_iterator_unwrapped(_Range);
+            auto _UResult = _Stable_partition_common(
+                _Ubegin(_Range), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        _NODISCARD static subrange<_It> _Stable_partition_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            // partition preserving order of equivalents
+            for (;;) { // skip in-place elements at front
+                if (_First == _Last) { // the input range is true (already partitioned)
+                    return {_STD move(_First), _STD move(_Last)};
+                }
+
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    break;
+                }
+                ++_First;
+            }
+
+            auto _Saved_last = _Last;
+            do { // skip in-place elements at end
+                --_Last;
+                if (_First == _Last) {
+                    return {_STD move(_First), _STD move(_Saved_last)};
+                }
+            } while (!_STD invoke(_Pred, _STD invoke(_Proj, *_Last)));
+
+            const iter_difference_t<_It> _Temp_count = _RANGES distance(_First, _Last);
+            _Optimistic_temporary_buffer2<iter_value_t<_It>> _Temp_buf{_Temp_count};
+
+            // _Temp_count + 1 since we work on closed ranges
+            const auto _Total_count = static_cast<iter_difference_t<_It>>(_Temp_count + 1);
+
+            auto _Result = _Stable_partition_common_buffered(
+                _STD move(_First), _STD move(_Last), _Pred, _Proj, _Total_count, _Temp_buf._Data, _Temp_buf._Capacity);
+            return {_STD move(_Result.first), _STD move(_Saved_last)};
+        }
+
+        template <class _It, class _Pr, class _Pj>
+        _NODISCARD static pair<_It, iter_difference_t<_It>> _Stable_partition_common_buffered(_It _First, _It _Last,
+            _Pr _Pred, _Pj _Proj, const iter_difference_t<_It> _Count, iter_value_t<_It>* const _Temp_ptr,
+            const ptrdiff_t _Capacity) {
+            // implement stable_partition of [_First, _Last] (note: closed range)
+            // note: _Count >= 2 and _First != _Last
+            _STL_INTERNAL_STATIC_ASSERT(permutable<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It>);
+            _STL_INTERNAL_CHECK(!_STD invoke(_Pred, _STD invoke(_Proj, *_First)));
+            _STL_INTERNAL_CHECK(_STD invoke(_Pred, _STD invoke(_Proj, *_Last)));
+            _STL_INTERNAL_CHECK(_Count == _RANGES distance(_First, _Last) + 1);
+
+            using _Diff = iter_difference_t<_It>;
+            if (_Count - 1 <= _Capacity) { // - 1 since we never need to store *_Last
+                _Uninitialized_backout<iter_value_t<_It>*> _Backout{_Temp_ptr};
+                _It _Next = _First;
+                _Backout._Emplace_back(_RANGES iter_move(_First));
+                while (++_First != _Last) {
+                    // test each element, moving into the temporary buffer if it's in the false range, or
+                    // assigning backwards if it's in the true range
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                        *_Next = _RANGES iter_move(_First);
+                        ++_Next;
+                    } else {
+                        _Backout._Emplace_back(_RANGES iter_move(_First));
+                    }
+                }
+
+                // move the last true element, *_Last, to the end of the true range
+                *_Next = _RANGES iter_move(_Last);
+                ++_Next;
+                // copy back the false range
+                _RANGES _Move_unchecked(_Backout._First, _Backout._Last, _Next);
+                const auto _True_distance = static_cast<_Diff>(_Count - (_Backout._Last - _Backout._First));
+                return {_STD move(_Next), _True_distance};
+            }
+
+            const _Diff _Mid_offset = _Count >> 1; // _Mid_offset >= 1 because _Count >= 2
+            const _It _Mid          = _RANGES next(_First, _Mid_offset);
+            // form [_First, _Left) true range, [_Left, _Mid) false range
+            _It _Left              = _Mid;
+            _Diff _Left_true_count = _Mid_offset;
+            for (;;) { // skip over the trailing false range before _Mid
+                --_Left;
+                --_Left_true_count;
+                if (_First == _Left) { // the entire left range is false
+                    break;
+                }
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Left))) {
+                    // excluded the false range before _Mid, invariants reestablished, recurse
+                    ++_Left_true_count; // to include *_First
+                    const auto _Low = _Stable_partition_common_buffered(
+                        _First, _STD move(_Left), _Pred, _Proj, _Left_true_count, _Temp_ptr, _Capacity);
+                    _Left            = _STD move(_Low.first);
+                    _Left_true_count = _Low.second;
+                    break;
+                }
+            }
+
+            // form [_Mid, _Right) true range, [_Right, next(_Last)) false range
+            _It _Right              = _Mid;
+            _Diff _Right_true_count = 0;
+            for (;;) { // skip over the leading true range after and including _Mid
+                if (_Right == _Last) { // the entire right range is true
+                    ++_Right; // to include _Last
+                    ++_Right_true_count;
+                    break;
+                }
+
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Right))) {
+                    // excluded the true range after and including _Mid, invariants reestablished, recurse
+                    const auto _Right_count = static_cast<_Diff>(_Count - _Mid_offset);
+                    const auto _Remaining   = static_cast<_Diff>(_Right_count - _Right_true_count);
+                    const auto _High        = _Stable_partition_common_buffered(
+                        _STD move(_Right), _Last, _Pred, _Proj, _Remaining, _Temp_ptr, _Capacity);
+                    _Right = _STD move(_High.first);
+                    _Right_true_count += _High.second;
+                    break;
+                }
+
+                ++_Right;
+                ++_Right_true_count;
+            }
+
+            // swap the [_Left, _Mid) false range with the [_Mid, _Right) true range
+            auto _Partition_point =
+                _RANGES _Buffered_rotate_common(_STD move(_Left), _STD move(_Mid), _STD move(_Right),
+                    static_cast<_Diff>(_Mid_offset - _Left_true_count), _Right_true_count, _Temp_ptr, _Capacity);
+            return {_STD move(_Partition_point), static_cast<_Diff>(_Left_true_count + _Right_true_count)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Stable_partition_fn stable_partition;
+
+    template <random_access_iterator _It, class _Ty, class _Pr, class _Pj1, class _Pj2>
+        requires sortable<_It, _Pr, _Pj1> && indirectly_writable<_It, _Ty>
+              && indirect_strict_weak_order<_Pr, projected<_It, _Pj1>, projected<remove_reference_t<_Ty>*, _Pj2>>
+    constexpr void _Push_heap_by_index(const _It _First, iter_difference_t<_It> _Hole,
+        const iter_difference_t<_It> _Top, _Ty&& _Val, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        // percolate _Hole to _Top or where _Val belongs
+        while (_Top < _Hole) {
+            const auto _Idx = static_cast<iter_difference_t<_It>>((_Hole - 1) >> 1); // shift for codegen
+            if (!_STD invoke(_Pred, _STD invoke(_Proj1, *(_First + _Idx)), _STD invoke(_Proj2, _Val))) {
+                break;
+            }
+
+            // move _Hole up to parent
+            *(_First + _Hole) = _RANGES iter_move(_First + _Idx);
+            _Hole             = _Idx;
+        }
+
+        *(_First + _Hole) = _STD forward<_Ty>(_Val); // drop _Val into final hole
+    }
+
+    class _Push_heap_fn {
+    public:
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            _Push_heap_unchecked(_STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _First;
+        }
+
+        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            if constexpr (common_range<_Rng>) {
+                _Push_heap_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES end(_Range);
+            } else {
+                auto _ULast = _RANGES _Get_final_iterator_unwrapped(_Range);
+                _Push_heap_unchecked(_Ubegin(_Range), _ULast, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_iterator(_Range, _STD move(_ULast));
+            }
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        static constexpr void _Push_heap_unchecked(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+
+            const auto _Count = _Last - _First;
+            if (_Count < 2) {
+                return;
+            }
+
+            --_Last;
+            iter_value_t<_It> _Val(_RANGES iter_move(_Last));
+            // NB: if _Proj is a _Ref_fn, this aliases the _Proj1 and _Proj2 parameters of _Push_heap_by_index
+            _RANGES _Push_heap_by_index(_STD move(_First), _Count - 1, 0, _STD move(_Val), _Pred, _Proj, _Proj);
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Push_heap_fn push_heap;
+
+    template <random_access_iterator _It, class _Ty, class _Pr, class _Pj1, class _Pj2>
+        requires sortable<_It, _Pr, _Pj1> && indirectly_writable<_It, _Ty>
+              && indirect_strict_weak_order<_Pr, projected<_It, _Pj1>, projected<remove_reference_t<_Ty>*, _Pj2>>
+    constexpr void _Pop_heap_hole_by_index(_It _First, iter_difference_t<_It> _Hole,
+        const iter_difference_t<_It> _Bottom, _Ty&& _Val, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        // percolate _Hole to _Bottom, then push _Val
+        _STL_INTERNAL_CHECK(_Hole >= 0);
+        _STL_INTERNAL_CHECK(_Bottom > 0);
+
+        using _Diff      = iter_difference_t<_It>;
+        const _Diff _Top = _Hole;
+        _Diff _Idx       = _Hole;
+
+        // Check whether _Idx can have a child before calculating that child's index, since
+        // calculating the child's index can trigger integer overflows
+        const _Diff _Max_sequence_non_leaf = (_Bottom - 1) >> 1; // shift for codegen
+        while (_Idx < _Max_sequence_non_leaf) { // move _Hole down to larger child
+            _Idx      = 2 * _Idx + 2;
+            auto _Mid = _First + _Idx;
+            if (_STD invoke(_Pred, _STD invoke(_Proj1, *_Mid), _STD invoke(_Proj1, *_RANGES prev(_Mid)))) {
+                --_Idx;
+                --_Mid;
+            }
+            *(_First + _Hole) = _RANGES iter_move(_Mid);
+            _Hole             = _Idx;
+        }
+
+        if (_Idx == _Max_sequence_non_leaf && _Bottom % 2 == 0) { // only child at bottom, move _Hole down to it
+            *(_First + _Hole) = _RANGES iter_move(_First + (_Bottom - 1));
+            _Hole             = _Bottom - 1;
+        }
+
+        _RANGES _Push_heap_by_index(_STD move(_First), _Hole, _Top, _STD forward<_Ty>(_Val), _Pred, _Proj1, _Proj2);
+    }
+
+    template <random_access_iterator _It, class _Ty, class _Pr, class _Pj1, class _Pj2>
+        requires sortable<_It, _Pr, _Pj1> && indirectly_writable<_It, _Ty>
+              && indirect_strict_weak_order<_Pr, projected<_It, _Pj1>, projected<remove_reference_t<_Ty>*, _Pj2>>
+    constexpr void _Pop_heap_hole_unchecked(
+        _It _First, const _It _Last, const _It _Dest, _Ty&& _Val, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        // pop *_First to *_Dest and reheap
+        _STL_INTERNAL_CHECK(_First != _Last);
+        _STL_INTERNAL_CHECK(_First != _Dest);
+
+        *_Dest            = _RANGES iter_move(_First);
+        const auto _Count = _Last - _First;
+        _RANGES _Pop_heap_hole_by_index(_STD move(_First), 0, _Count, _STD forward<_Ty>(_Val), _Pred, _Proj1, _Proj2);
+    }
+
+    template <random_access_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    constexpr void _Pop_heap_unchecked(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
+        // pop *_First to *(_Last - 1) and reheap
+        if (_Last - _First < 2) {
+            return;
+        }
+
+        --_Last;
+        iter_value_t<_It> _Val(_RANGES iter_move(_Last));
+        // NB: if _Proj is a _Ref_fn, this aliases the _Proj1 and _Proj2 parameters of _Pop_heap_hole_unchecked
+        _RANGES _Pop_heap_hole_unchecked(_STD move(_First), _Last, _Last, _STD move(_Val), _Pred, _Proj, _Proj);
+    }
+
+    struct _Pop_heap_fn {
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            _RANGES _Pop_heap_unchecked(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _First;
+        }
+
+        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            if constexpr (common_range<_Rng>) {
+                _RANGES _Pop_heap_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES end(_Range);
+            } else {
+                auto _ULast = _Get_final_iterator_unwrapped(_Range);
+                _RANGES _Pop_heap_unchecked(_Ubegin(_Range), _ULast, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _Rewrap_iterator(_Range, _STD move(_ULast));
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Pop_heap_fn pop_heap;
+
+    template <random_access_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    constexpr void _Make_heap_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
+        // make [_First, _Last) into a heap with respect to _Pred and _Proj
+        using _Diff         = iter_difference_t<_It>;
+        const _Diff _Bottom = _Last - _First;
+        for (_Diff _Hole = _Bottom >> 1; _Hole > 0;) { // shift for codegen
+            // reheap top half, bottom to top
+            --_Hole;
+            iter_value_t<_It> _Val(_RANGES iter_move(_First + _Hole));
+            // NB: if _Proj is a _Ref_fn, this aliases the _Proj1 and _Proj2 parameters of _Pop_heap_hole_by_index
+            _RANGES _Pop_heap_hole_by_index(_First, _Hole, _Bottom, _STD move(_Val), _Pred, _Proj, _Proj);
+        }
+    }
+
+    struct _Make_heap_fn {
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            _RANGES _Make_heap_common(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _First;
+        }
+
+        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            if constexpr (common_range<_Rng>) {
+                _RANGES _Make_heap_common(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES end(_Range);
+            } else {
+                auto _ULast = _RANGES _Get_final_iterator_unwrapped(_Range);
+                _RANGES _Make_heap_common(_Ubegin(_Range), _ULast, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_iterator(_Range, _STD move(_ULast));
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Make_heap_fn make_heap;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 _RanIt _Is_heap_until_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // find extent of range that is a heap
+    using _Diff       = _Iter_diff_t<_RanIt>;
+    const _Diff _Size = _Last - _First;
+    for (_Diff _Off = 1; _Off < _Size; ++_Off) {
+        if (_DEBUG_LT_PRED(_Pred, *(_First + ((_Off - 1) >> 1)), *(_First + _Off))) { // shift for codegen
+            return _First + _Off;
+        }
+    }
+
+    return _Last;
+}
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_NODISCARD _CONSTEXPR20 _RanIt is_heap_until(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // find extent of range that is a heap
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Seek_wrapped(_First,
+        _STD _Is_heap_until_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_NODISCARD _CONSTEXPR20 bool is_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // test if range is a heap
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    return _STD _Is_heap_until_unchecked(_UFirst, _ULast, _STD _Pass_fn(_Pred)) == _ULast;
+}
+
+_EXPORT_STD template <class _RanIt>
+_NODISCARD _CONSTEXPR20 _RanIt is_heap_until(_RanIt _First, _RanIt _Last) {
+    // find extent of range that is a heap ordered by operator<
+    return _STD is_heap_until(_First, _Last, less<>{});
+}
+
+_EXPORT_STD template <class _RanIt>
+_NODISCARD _CONSTEXPR20 bool is_heap(_RanIt _First, _RanIt _Last) { // test if range is a heap ordered by operator<
+    return _STD is_heap(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _RanIt is_heap_until(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool is_heap(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // test if range is a heap
+    return _STD is_heap_until(_STD forward<_ExPo>(_Exec), _First, _Last, _STD _Pass_fn(_Pred)) == _Last;
+}
+
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _RanIt is_heap_until(_ExPo&& _Exec, _RanIt _First, _RanIt _Last) noexcept /* terminates */ {
+    // find extent of range that is a heap ordered by operator<
+    return _STD is_heap_until(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
+}
+
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool is_heap(_ExPo&& _Exec, _RanIt _First, _RanIt _Last) noexcept /* terminates */ {
+    // test if range is a heap ordered by operator<
+    return _STD is_heap(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It, class _Pr, class _Pj>
+    _NODISCARD constexpr _It _Is_heap_until_unchecked(
+        _It _First, const iter_difference_t<_It> _Size, _Pr _Pred, _Pj _Proj) {
+        // find extent of counted range that is a heap
+        _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+        _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>);
+
+        if (_Size == 0) {
+            return _First;
+        }
+
+        using _Diff = iter_difference_t<_It>;
+        _Diff _Off  = 1;
+        for (; _Off < _Size; ++_Off) {
+            const auto _Mid1 = _First + static_cast<_Diff>((_Off - 1) >> 1); // shift for codegen
+            auto _Mid2       = _First + _Off;
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Mid1), _STD invoke(_Proj, *_Mid2))) {
+                return _Mid2;
+            }
+        }
+
+        return _First + _Off;
+    }
+
+    struct _Is_heap_fn {
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            const auto _ULast = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _Size  = _RANGES distance(_UFirst, _ULast);
+            const auto _UResult =
+                _RANGES _Is_heap_until_unchecked(_STD move(_UFirst), _Size, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _UResult == _ULast;
+        }
+
+        template <random_access_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr bool operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _Size = _RANGES distance(_Range);
+            const auto _UResult =
+                _RANGES _Is_heap_until_unchecked(_Ubegin(_Range), _Size, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _UResult == _Uend(_Range);
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Is_heap_fn is_heap;
+
+    struct _Is_heap_until_fn {
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst     = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            const auto _Size = _RANGES distance(_UFirst, _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+            auto _UResult =
+                _RANGES _Is_heap_until_unchecked(_STD move(_UFirst), _Size, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <random_access_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _Size = _RANGES distance(_Range);
+            auto _UResult =
+                _RANGES _Is_heap_until_unchecked(_Ubegin(_Range), _Size, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Is_heap_until_fn is_heap_until;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Sort_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // order heap by repeatedly popping
+    for (; _Last - _First >= 2; --_Last) {
+        _STD _Pop_heap_unchecked(_First, _Last, _Pred);
+    }
+}
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_CONSTEXPR20 void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) { // order heap by repeatedly popping
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+#if _ITERATOR_DEBUG_LEVEL == 2
+    const auto _Counterexample = _STD _Is_heap_until_unchecked(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    _STL_VERIFY(_Counterexample == _ULast, "invalid heap in sort_heap()");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+    _STD _Sort_heap_unchecked(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _RanIt>
+_CONSTEXPR20 void sort_heap(_RanIt _First, _RanIt _Last) { // order heap by repeatedly popping
+    _STD sort_heap(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <random_access_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    constexpr void _Sort_heap_common(const _It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
+        // order heap by repeatedly popping
+        for (; _Last - _First >= 2; --_Last) {
+            _RANGES _Pop_heap_unchecked(_First, _Last, _Pred, _Proj);
+        }
+    }
+
+    struct _Sort_heap_fn {
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            _RANGES _Sort_heap_common(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _First;
+        }
+
+        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            if constexpr (common_range<_Rng>) {
+                _RANGES _Sort_heap_common(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES end(_Range);
+            } else {
+                auto _ULast = _RANGES _Get_final_iterator_unwrapped(_Range);
+                _RANGES _Sort_heap_common(_Ubegin(_Range), _ULast, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES _Rewrap_iterator(_Range, _STD move(_ULast));
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Sort_heap_fn sort_heap;
+
+    template <class _It, class _Ty, class _Pr, class _Pj>
+    _NODISCARD constexpr _It _Lower_bound_unchecked(
+        _It _First, iter_difference_t<_It> _Count, _Ty&& _Val, _Pr _Pred, _Pj _Proj) {
+        _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+        _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, add_pointer_t<_Ty>, projected<_It, _Pj>>);
+
+        using _Diff = iter_difference_t<_It>;
+
+        while (_Count > 0) { // divide and conquer, check midpoint
+            const auto _Half = static_cast<_Diff>(_Count / 2);
+            auto _Mid        = _RANGES next(_First, _Half);
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Mid), _Val)) { // try top half
+                _First = _STD move(_Mid);
+                ++_First;
+                _Count -= static_cast<_Diff>(_Half + 1);
+            } else { // try bottom half
+                _Count = _Half;
+            }
+        }
+
+        return _First;
+    }
+
+    struct _Lower_bound_fn {
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<const _Ty*, projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr _It operator()(
+            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            const auto _Count = _RANGES distance(_UFirst, _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+            _UFirst           = _RANGES _Lower_bound_unchecked(
+                _STD move(_UFirst), _Count, _Val, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<const _Ty*, projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _Count = _RANGES distance(_Range);
+            auto _UResult     = _RANGES _Lower_bound_unchecked(
+                _Ubegin(_Range), _Count, _Val, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Lower_bound_fn lower_bound;
+
+    template <class _It, class _Ty, class _Pr, class _Pj>
+    _NODISCARD constexpr _It _Upper_bound_unchecked(
+        _It _First, iter_difference_t<_It> _Count, _Ty&& _Val, _Pr _Pred, _Pj _Proj) {
+        _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+        _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, add_pointer_t<_Ty>, projected<_It, _Pj>>);
+
+        using _Diff = iter_difference_t<_It>;
+
+        while (_Count > 0) { // divide and conquer: find half that contains answer
+            const auto _Half = static_cast<_Diff>(_Count / 2);
+            auto _Mid        = _RANGES next(_First, _Half);
+            if (_STD invoke(_Pred, _Val, _STD invoke(_Proj, *_Mid))) {
+                _Count = _Half;
+            } else { // try top half
+                _First = _STD move(_Mid);
+                ++_First;
+                _Count -= static_cast<_Diff>(_Half + 1);
+            }
+        }
+
+        return _First;
+    }
+
+    struct _Upper_bound_fn {
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<const _Ty*, projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr _It operator()(
+            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            const auto _Count = _RANGES distance(_UFirst, _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+            _UFirst           = _RANGES _Upper_bound_unchecked(
+                _STD move(_UFirst), _Count, _Val, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<const _Ty*, projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _Count = _RANGES distance(_Range);
+            auto _UResult     = _RANGES _Upper_bound_unchecked(
+                _Ubegin(_Range), _Count, _Val, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Upper_bound_fn upper_bound;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
+_NODISCARD _CONSTEXPR20 pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
+    // find range equivalent to _Val
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+    using _Diff  = _Iter_diff_t<_FwdIt>;
+    _Diff _Count = _STD distance(_UFirst, _ULast);
+
+    for (;;) { // divide and conquer, check midpoint
+        if (_Count <= 0) {
+            _STD _Seek_wrapped(_Last, _UFirst); // empty range
+            _STD _Seek_wrapped(_First, _UFirst);
+            break;
+        }
+
+        _Diff _Count2    = _Count / 2;
+        const auto _UMid = _STD next(_UFirst, _Count2);
+        if (_DEBUG_LT_PRED(_Pred, *_UMid, _Val)) { // range begins above _UMid, loop
+            _UFirst = _STD _Next_iter(_UMid);
+            _Count -= _Count2 + 1;
+        } else if (_Pred(_Val, *_UMid)) {
+            _Count = _Count2; // range in first half, loop
+        } else { // range straddles _UMid, find each end and return
+            auto _UFirst2 = _STD lower_bound(_UFirst, _UMid, _Val, _STD _Pass_fn(_Pred));
+            _STD advance(_UFirst, _Count);
+            auto _ULast2 = _STD upper_bound(_STD _Next_iter(_UMid), _UFirst, _Val, _STD _Pass_fn(_Pred));
+            _STD _Seek_wrapped(_Last, _ULast2);
+            _STD _Seek_wrapped(_First, _UFirst2);
+            break;
+        }
+    }
+
+    return {_First, _Last};
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_NODISCARD _CONSTEXPR20 pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
+    // find range equivalent to _Val
+    return _STD equal_range(_First, _Last, _Val, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Equal_range_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<const _Ty*, projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr subrange<_It> operator()(
+            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            const auto _Count = _RANGES distance(_UFirst, _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+            auto _UResult =
+                _Equal_range_unchecked(_STD move(_UFirst), _Count, _Val, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_subrange<subrange<_It>>(_First, _STD move(_UResult));
+        }
+
+        template <forward_range _Rng, class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<const _Ty*, projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr borrowed_subrange_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _Count = _RANGES distance(_Range);
+            auto _UResult =
+                _Equal_range_unchecked(_Ubegin(_Range), _Count, _Val, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            auto _Result = _RANGES begin(_Range);
+            return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Result, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Ty, class _Pr, class _Pj>
+        _NODISCARD static constexpr subrange<_It> _Equal_range_unchecked(
+            _It _First, iter_difference_t<_It> _Count, const _Ty& _Val, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, const _Ty*, projected<_It, _Pj>>);
+
+            using _Diff = iter_difference_t<_It>;
+
+            while (_Count > 0) { // divide and conquer, check midpoint
+                const auto _Half = static_cast<_Diff>(_Count / 2);
+                auto _Mid        = _RANGES next(_First, _Half);
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Mid), _Val)) { // range in second half
+                    _First = _STD move(_Mid);
+                    ++_First;
+                    _Count -= static_cast<_Diff>(_Half + 1);
+                } else if (_STD invoke(_Pred, _Val, _STD invoke(_Proj, *_Mid))) {
+                    _Count = _Half; // range in first half
+                } else { // range straddles _Mid, find the ends
+                    _First = _RANGES _Lower_bound_unchecked(_STD move(_First), _Half, _Val, _Pred, _Proj);
+                    ++_Mid;
+                    _Count -= static_cast<_Diff>(_Half + 1);
+                    _Mid = _RANGES _Upper_bound_unchecked(_STD move(_Mid), _Count, _Val, _Pred, _Proj);
+                    return {_STD move(_First), _STD move(_Mid)};
+                }
+            }
+
+            return {_First, _First};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Equal_range_fn equal_range;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
+_NODISCARD _CONSTEXPR20 bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
+    // test if _Val equivalent to some element
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    _UFirst           = _STD lower_bound(_UFirst, _ULast, _Val, _STD _Pass_fn(_Pred));
+    return _UFirst != _ULast && !_Pred(_Val, *_UFirst);
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_NODISCARD _CONSTEXPR20 bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
+    // test if _Val equivalent to some element
+    return _STD binary_search(_First, _Last, _Val, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Binary_search_fn {
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<const _Ty*, projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr bool operator()(
+            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            const auto _ULast = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _Count = _RANGES distance(_UFirst, _ULast);
+            _UFirst           = _RANGES _Lower_bound_unchecked(
+                _STD move(_UFirst), _Count, _Val, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _UFirst != _ULast && !_STD invoke(_Pred, _Val, _STD invoke(_Proj, *_UFirst));
+        }
+
+        template <forward_range _Rng, class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<const _Ty*, projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr bool operator()(_Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _Count  = _RANGES distance(_Range);
+            const auto _UFirst = _RANGES _Lower_bound_unchecked(
+                _Ubegin(_Range), _Count, _Val, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _UFirst != _Uend(_Range) && !_STD invoke(_Pred, _Val, _STD invoke(_Proj, *_UFirst));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Binary_search_fn binary_search;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Diff1, class _Diff2>
+_NODISCARD constexpr auto _Idl_dist_add(_Diff1 _Lhs, _Diff2 _Rhs) {
+    (void) _Lhs;
+    (void) _Rhs;
+#if _HAS_CXX20
+    if constexpr (is_same_v<_Diff1, ranges::_Distance_unbounded> || is_same_v<_Diff2, ranges::_Distance_unbounded>) {
+        return ranges::_Distance_unbounded{};
+    } else
+#endif // _HAS_CXX20
+    {
+        if constexpr (is_same_v<_Diff1, _Distance_unknown> || is_same_v<_Diff2, _Distance_unknown>) {
+            return _Distance_unknown{};
+        } else {
+            return _Lhs + _Rhs;
+        }
+    }
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
+    // copy merging ranges
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt2, _UFirst1, _ULast1, _Pred);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt1, _UFirst2, _ULast2, _Pred);
+    const auto _Count1 = _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1);
+    const auto _Count2 = _STD _Idl_distance<_InIt2>(_UFirst2, _ULast2);
+    auto _UDest        = _STD _Get_unwrapped_n(_Dest, _STD _Idl_dist_add(_Count1, _Count2));
+    if (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
+        for (;;) {
+            if (_DEBUG_LT_PRED(_Pred, *_UFirst2, *_UFirst1)) {
+                *_UDest = *_UFirst2;
+                ++_UDest;
+                ++_UFirst2;
+
+                if (_UFirst2 == _ULast2) {
+                    break;
+                }
+            } else {
+                *_UDest = *_UFirst1;
+                ++_UDest;
+                ++_UFirst1;
+
+                if (_UFirst1 == _ULast1) {
+                    break;
+                }
+            }
+        }
+    }
+
+    _UDest = _STD _Copy_unchecked(_UFirst1, _ULast1, _UDest); // copy any tail
+    _STD _Seek_wrapped(_Dest, _STD _Copy_unchecked(_UFirst2, _ULast2, _UDest));
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
+_CONSTEXPR20 _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
+    // copy merging ranges
+    return _STD merge(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 merge(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
+    _Pr _Pred) noexcept /* terminates */ {
+    // copy merging ranges
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    return _STD merge(_First1, _Last1, _First2, _Last2, _Dest, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 merge(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest) noexcept
+/* terminates */ {
+    // copy merging ranges
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    return _STD merge(_First1, _Last1, _First2, _Last2, _Dest);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
+    using merge_result = in_in_out_result<_In1, _In2, _Out>;
+
+    class _Merge_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr merge_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
+            _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UFirst1      = _RANGES _Unwrap_iter<_Se1>(_STD move(_First1));
+            auto _ULast1       = _RANGES _Unwrap_sent<_It1>(_STD move(_Last1));
+            const auto _Count1 = _RANGES _Idl_distance<_It1>(_UFirst1, _ULast1);
+            auto _UFirst2      = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            auto _ULast2       = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+            const auto _Count2 = _RANGES _Idl_distance<_It2>(_UFirst2, _ULast2);
+            const auto _Count  = _STD _Idl_dist_add(_Count1, _Count2);
+            auto _UResult      = _Merge_unchecked(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                _STD move(_ULast2), _STD _Get_unwrapped_n(_STD move(_Output), _Count), _STD _Pass_fn(_Pred),
+                _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
+            class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr merge_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            const auto _Count1 = _RANGES _Idl_distance(_Range1);
+            const auto _Count2 = _RANGES _Idl_distance(_Range2);
+            const auto _Count  = _STD _Idl_dist_add(_Count1, _Count2);
+            auto _First1       = _RANGES begin(_Range1);
+            auto _First2       = _RANGES begin(_Range2);
+            auto _UResult      = _Merge_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)), _Uend(_Range1),
+                _RANGES _Unwrap_range_iter<_Rng2>(_STD move(_First2)), _Uend(_Range2),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr merge_result<_It1, _It2, _Out> _Merge_unchecked(_It1 _First1, const _Se1 _Last1,
+            _It2 _First2, const _Se2 _Last2, _Out _Output, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>);
+
+            for (;; ++_Output) {
+                if (_First1 == _Last1) {
+                    auto _Copy_result =
+                        _RANGES _Copy_unchecked(_STD move(_First2), _STD move(_Last2), _STD move(_Output));
+                    return {_STD move(_First1), _STD move(_Copy_result.in), _STD move(_Copy_result.out)};
+                }
+
+                if (_First2 == _Last2) {
+                    auto _Copy_result =
+                        _RANGES _Copy_unchecked(_STD move(_First1), _STD move(_Last1), _STD move(_Output));
+                    return {_STD move(_Copy_result.in), _STD move(_First2), _STD move(_Copy_result.out)};
+                }
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj2, *_First2), _STD invoke(_Proj1, *_First1))) {
+                    *_Output = *_First2;
+                    ++_First2;
+                } else {
+                    *_Output = *_First1;
+                    ++_First1;
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Merge_fn merge;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+// The "usual invariants" for the inplace_merge helpers below are:
+// [_First, _Mid) and [_Mid, _Last) are sorted
+// _Pred(*_Mid, *_First)             note: this means *_Mid is the "lowest" element
+// _Pred(*prev(_Last), *prev(_Mid))  note: this means *prev(_Mid) is the "highest" element
+// _Count1 == distance(_First, _Mid)
+// _Count2 == distance(_Mid, _Last)
+// _Count1 > 1
+// _Count2 > 1
+template <class _BidIt>
+void _Rotate_one_right(_BidIt _First, _BidIt _Mid, _BidIt _Last) {
+    // exchanges the range [_First, _Mid) with [_Mid, _Last)
+    // pre: distance(_Mid, _Last) is 1
+    _Iter_value_t<_BidIt> _Temp(_STD move(*_Mid));
+    _STD _Move_backward_unchecked(_First, _Mid, _Last);
+    *_First = _STD move(_Temp);
+}
+
+template <class _BidIt>
+void _Rotate_one_left(_BidIt _First, _BidIt _Mid, _BidIt _Last) {
+    // exchanges the range [_First, _Mid) with [_Mid, _Last)
+    // pre: distance(_First, _Mid) is 1
+    _Iter_value_t<_BidIt> _Temp(_STD move(*_First));
+    *_STD _Move_unchecked(_Mid, _Last, _First) = _STD move(_Temp);
+}
+
+template <class _BidIt, class _Pr>
+void _Inplace_merge_buffer_left(
+    _BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_value_t<_BidIt>* const _Temp_ptr, _Pr _Pred) {
+    // move the range [_First, _Mid) to _Temp_ptr, and merge it with [_Mid, _Last) to _First
+    // usual invariants apply
+    using _Ptr_ty = _Iter_value_t<_BidIt>*;
+    _Uninitialized_backout<_Ptr_ty> _Backout{_Temp_ptr, _STD _Uninitialized_move_unchecked(_First, _Mid, _Temp_ptr)};
+    _Ptr_ty _Left_first      = _Temp_ptr;
+    const _Ptr_ty _Left_last = _Backout._Last - 1; // avoid a compare with the highest element
+    *_First                  = _STD move(*_Mid); // the lowest element is now in position
+    ++_First;
+    ++_Mid;
+    for (;;) {
+        if (_Pred(*_Mid, *_Left_first)) { // take element from the right partition
+            *_First = _STD move(*_Mid);
+            ++_First;
+            ++_Mid;
+            if (_Mid == _Last) {
+                _STD _Move_unchecked(_Left_first, _Backout._Last, _First); // move any tail (and the highest element)
+                return;
+            }
+        } else { // take element from the left partition
+            *_First = _STD move(*_Left_first);
+            ++_First;
+            ++_Left_first;
+            if (_Left_first == _Left_last) {
+                // move the remaining right partition and highest element, since *_Left_first is highest
+                *_STD _Move_unchecked(_Mid, _Last, _First) = _STD move(*_Left_last);
+                return;
+            }
+        }
+    }
+}
+
+template <class _BidIt, class _Pr>
+void _Inplace_merge_buffer_right(
+    _BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_value_t<_BidIt>* const _Temp_ptr, _Pr _Pred) {
+    // move the range [_Mid, _Last) to _Temp_ptr, and merge it with [_First, _Mid) to _Last
+    // usual invariants apply
+    using _Ptr_ty = _Iter_value_t<_BidIt>*;
+    _Uninitialized_backout<_Ptr_ty> _Backout{_Temp_ptr, _STD _Uninitialized_move_unchecked(_Mid, _Last, _Temp_ptr)};
+    *--_Last                   = _STD move(*--_Mid); // move the highest element into position
+    const _Ptr_ty _Right_first = _Temp_ptr;
+    _Ptr_ty _Right_last        = _Backout._Last - 1;
+    --_Mid;
+    for (;;) {
+        if (_Pred(*_Right_last, *_Mid)) { // merge from the left partition
+            *--_Last = _STD move(*_Mid);
+            if (_First == _Mid) {
+                *--_Last = _STD move(*_Right_last); // to make [_Right_first, _Right_last) a half-open range
+                _STD _Move_backward_unchecked(_Right_first, _Right_last, _Last); // move any head (and lowest element)
+                return;
+            }
+
+            --_Mid;
+        } else { // merge from the right partition
+            *--_Last = _STD move(*_Right_last);
+            --_Right_last;
+            if (_Right_first == _Right_last) { // we can't compare with *_Right_first, but we know it is lowest
+                *--_Last = _STD move(*_Mid); // restore half-open range [_First, _Mid)
+                _STD _Move_backward_unchecked(_First, _Mid, _Last);
+                *_First = _STD move(*_Right_first);
+                return;
+            }
+        }
+    }
+}
+
+template <class _BidIt, class _Pr>
+void _Buffered_inplace_merge_unchecked(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
+    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* _Temp_ptr, ptrdiff_t _Capacity, _Pr _Pred);
+
+template <class _BidIt, class _Pr>
+void _Buffered_inplace_merge_divide_and_conquer2(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
+    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred,
+    _BidIt _Firstn, _BidIt _Lastn, _Iter_diff_t<_BidIt> _Count1n, _Iter_diff_t<_BidIt> _Count2n) {
+    // common block of _Buffered_inplace_merge_divide_and_conquer, below
+    using _Diff  = _Iter_diff_t<_BidIt>;
+    _BidIt _Midn = _STD _Buffered_rotate_unchecked(_Firstn, _Mid, _Lastn, static_cast<_Diff>(_Count1 - _Count1n),
+        _Count2n, _Temp_ptr, _Capacity); // rearrange middle
+    _STD _Buffered_inplace_merge_unchecked(
+        _First, _Firstn, _Midn, _Count1n, _Count2n, _Temp_ptr, _Capacity, _Pred); // merge each new part
+    _STD _Buffered_inplace_merge_unchecked(_Midn, _Lastn, _Last, static_cast<_Diff>(_Count1 - _Count1n),
+        static_cast<_Diff>(_Count2 - _Count2n), _Temp_ptr, _Capacity, _Pred);
+}
+
+template <class _BidIt, class _Pr>
+void _Buffered_inplace_merge_divide_and_conquer(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
+    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred) {
+    // merge sorted [_First, _Mid) with sorted [_Mid, _Last)
+    // usual invariants apply
+    using _Diff = _Iter_diff_t<_BidIt>;
+    if (_Count1 <= _Count2) {
+        const _Diff _Count1n = _Count1 >> 1; // shift for codegen
+        const _BidIt _Firstn = _STD next(_First, _Count1n);
+        const _BidIt _Lastn  = _STD lower_bound(_Mid, _Last, *_Firstn, _Pred);
+        _STD _Buffered_inplace_merge_divide_and_conquer2(_First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity,
+            _Pred, _Firstn, _Lastn, _Count1n, _STD distance(_Mid, _Lastn));
+    } else {
+        const _Diff _Count2n = _Count2 >> 1; // shift for codegen
+        const _BidIt _Lastn  = _STD next(_Mid, _Count2n);
+        const _BidIt _Firstn = _STD upper_bound(_First, _Mid, *_Lastn, _Pred);
+        _STD _Buffered_inplace_merge_divide_and_conquer2(_First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity,
+            _Pred, _Firstn, _Lastn, _STD distance(_First, _Firstn), _Count2n);
+    }
+}
+
+template <class _BidIt, class _Pr>
+void _Buffered_inplace_merge_unchecked_impl(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
+    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred) {
+    // merge sorted [_First, _Mid) with sorted [_Mid, _Last)
+    // usual invariants apply
+    if (_Count1 <= _Count2 && _Count1 <= _Capacity) {
+        _STD _Inplace_merge_buffer_left(_First, _Mid, _Last, _Temp_ptr, _Pred);
+    } else if (_Count2 <= _Capacity) {
+        _STD _Inplace_merge_buffer_right(_First, _Mid, _Last, _Temp_ptr, _Pred);
+    } else {
+        _STD _Buffered_inplace_merge_divide_and_conquer(
+            _First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity, _Pred);
+    }
+}
+
+template <class _BidIt, class _Pr>
+void _Buffered_inplace_merge_unchecked(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
+    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred) {
+    // merge sorted [_First, _Mid) with sorted [_Mid, _Last)
+    // usual invariants *do not* apply; only sortedness applies
+    // establish the usual invariants (explained in inplace_merge)
+    if (_Mid == _Last) {
+        return;
+    }
+
+    for (;;) {
+        if (_First == _Mid) {
+            return;
+        }
+
+        if (_Pred(*_Mid, *_First)) {
+            break;
+        }
+
+        ++_First;
+        --_Count1;
+    }
+
+    const auto _Highest = _STD _Prev_iter(_Mid);
+    do {
+        --_Last;
+        --_Count2;
+        if (_Mid == _Last) {
+            _STD _Rotate_one_right(_First, _Mid, ++_Last);
+            return;
+        }
+    } while (!_Pred(*_Last, *_Highest));
+
+    ++_Last;
+    ++_Count2;
+
+    if (_Count1 == 1) {
+        _STD _Rotate_one_left(_First, _Mid, _Last);
+        return;
+    }
+
+    _STD _Buffered_inplace_merge_unchecked_impl(_First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity, _Pred);
+}
+
+_EXPORT_STD template <class _BidIt, class _Pr>
+void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred) {
+    // merge [_First, _Mid) with [_Mid, _Last)
+    _STD _Adl_verify_range(_First, _Mid);
+    _STD _Adl_verify_range(_Mid, _Last);
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _UMid   = _STD _Get_unwrapped(_Mid);
+    auto _ULast  = _STD _Get_unwrapped(_Last);
+    _DEBUG_ORDER_UNWRAPPED(_UFirst, _UMid, _Pred);
+
+    // establish the usual invariants:
+    if (_UMid == _ULast) {
+        return;
+    }
+
+    for (;;) {
+        if (_UFirst == _UMid) {
+            return;
+        }
+
+        if (_Pred(*_UMid, *_UFirst)) { // found that *_UMid goes in *_UFirst's position
+            break;
+        }
+
+        ++_UFirst;
+    }
+
+    const auto _Highest = _STD _Prev_iter(_UMid);
+    do {
+        --_ULast;
+        if (_UMid == _ULast) { // rotate only element remaining in right partition to the beginning, without allocating
+            _STD _Rotate_one_right(_UFirst, _UMid, ++_ULast);
+            return;
+        }
+    } while (!_Pred(*_ULast, *_Highest)); // found that *_Highest goes in *_ULast's position
+
+    ++_ULast;
+
+    const auto _Count1 = _STD distance(_UFirst, _UMid);
+    if (_Count1 == 1) { // rotate only element remaining in left partition to the end, without allocating
+        _STD _Rotate_one_left(_UFirst, _UMid, _ULast);
+        return;
+    }
+
+    const auto _Count2 = _STD distance(_UMid, _ULast);
+    _Optimistic_temporary_buffer2<_Iter_value_t<_BidIt>> _Temp_buf{(_STD min) (_Count1, _Count2)};
+    _STD _Buffered_inplace_merge_unchecked_impl(
+        _UFirst, _UMid, _ULast, _Count1, _Count2, _Temp_buf._Data, _Temp_buf._Capacity, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _BidIt>
+void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last) {
+    // merge [_First, _Mid) with [_Mid, _Last)
+    _STD inplace_merge(_First, _Mid, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+void inplace_merge(_ExPo&&, _BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // merge [_First, _Mid) with [_Mid, _Last)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_CPP17_MUTABLE_BIDIRECTIONAL_ITERATOR(_BidIt);
+    _STD inplace_merge(_First, _Mid, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void inplace_merge(_ExPo&&, _BidIt _First, _BidIt _Mid, _BidIt _Last) noexcept /* terminates */ {
+    // merge [_First, _Mid) with [_Mid, _Last)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_CPP17_MUTABLE_BIDIRECTIONAL_ITERATOR(_BidIt);
+    _STD inplace_merge(_First, _Mid, _Last);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <forward_iterator _It, sentinel_for<_It> _Se, class _Pr, class _Pj>
+        requires indirect_strict_weak_order<_Pr, projected<_It, _Pj>>
+    _NODISCARD constexpr _It _Is_sorted_until_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+        if (_First == _Last) {
+            return _First;
+        }
+
+#if _VECTORIZED_IS_SORTED_UNTIL
+        if constexpr (_Is_min_max_iterators_safe<_It> && sized_sentinel_for<_Se, _It> && is_same_v<_Pj, identity>) {
+            constexpr bool _Is_greater = _Is_predicate_greater<_It, _Pr>;
+            if constexpr (_Is_greater || _Is_predicate_less<_It, _Pr>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _First_ptr = _STD _To_address(_First);
+                    const auto _Last_ptr  = _STD _To_address(_First + (_Last - _First));
+                    const auto _Result    = _STD _Is_sorted_until_vectorized(_First_ptr, _Last_ptr, _Is_greater);
+
+                    if constexpr (is_pointer_v<_It>) {
+                        return _Result;
+                    } else {
+                        return _First + static_cast<iter_difference_t<_It>>(_Result - _First_ptr);
+                    }
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_IS_SORTED_UNTIL ^^^
+
+        for (auto _Prev = _First; ++_First != _Last; ++_Prev) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Prev))) {
+                break;
+            }
+        }
+
+        return _First;
+    }
+
+    template <bidirectional_iterator _It>
+    void _Rotate_one_right(_It _First, _It _Mid, _It _Last) {
+        // exchanges the range [_First, _Mid) with [_Mid, _Last)
+        _STL_INTERNAL_CHECK(_RANGES next(_Mid) == _Last);
+        iter_value_t<_It> _Temp(_RANGES iter_move(_Mid));
+        _RANGES _Move_backward_common(_First, _STD move(_Mid), _STD move(_Last));
+        *_First = _STD move(_Temp);
+    }
+
+    template <bidirectional_iterator _It>
+    void _Rotate_one_left(_It _First, _It _Mid, _It _Last) {
+        // exchanges the range [_First, _Mid) with [_Mid, _Last)
+        _STL_INTERNAL_CHECK(_RANGES next(_First) == _Mid);
+        iter_value_t<_It> _Temp(_RANGES iter_move(_First));
+        auto _Result = _RANGES _Move_unchecked(_STD move(_Mid), _STD move(_Last), _STD move(_First));
+        *_Result.out = _STD move(_Temp);
+    }
+
+    template <bidirectional_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    void _Inplace_merge_buffer_left(_It _First, _It _Mid, _It _Last, iter_value_t<_It>* _Left_first,
+        const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj) {
+        // move the range [_First, _Mid) to _Left_first, and merge it with [_Mid, _Last) to _First
+        // usual invariants apply
+        using _Ty = iter_value_t<_It>;
+
+        _Ty* _Left_last = _RANGES _Uninitialized_move_unchecked(_First, _Mid, _Left_first, _Left_first + _Capacity).out;
+        _Uninitialized_backout<_Ty*> _Backout{_Left_first, _Left_last};
+
+        // We already know that _Backout._Last - 1 is the highest element, so do not compare against it again.
+        --_Left_last;
+
+        // We already know that _Mid points to the lowest element and that there is more than 1 element left.
+        *_First = _RANGES iter_move(_Mid);
+        ++_First;
+        ++_Mid;
+
+        for (;;) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Mid), _STD invoke(_Proj, *_Left_first))) {
+                *_First = _RANGES iter_move(_Mid); // the lowest element is now in position
+                ++_First;
+                ++_Mid;
+                if (_Mid == _Last) {
+                    // move the remaining left partition
+                    _RANGES _Move_unchecked(_Left_first, _Backout._Last, _First);
+                    return;
+                }
+            } else {
+                *_First = _RANGES iter_move(_Left_first);
+                ++_First;
+                ++_Left_first;
+                if (_Left_first == _Left_last) {
+                    // move the remaining right partition and highest element, since *_Left_first is highest
+                    const auto _Final = _RANGES _Move_unchecked(_Mid, _Last, _First);
+                    *_Final.out       = _RANGES iter_move(_Left_first);
+                    return;
+                }
+            }
+        }
+    }
+
+    template <bidirectional_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    void _Inplace_merge_buffer_right(_It _First, _It _Mid, _It _Last, iter_value_t<_It>* _Right_first,
+        const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj) {
+        // move the range [_Mid, _Last) to _Right_first, and merge it with [_First, _Mid) to _Last
+        // usual invariants apply
+        using _Ty = iter_value_t<_It>;
+
+        _Ty* _Right_last =
+            _RANGES _Uninitialized_move_unchecked(_Mid, _Last, _Right_first, _Right_first + _Capacity).out;
+        _Uninitialized_backout<_Ty*> _Backout{_Right_first, _Right_last};
+
+        // We already know that _Mid points to the next highest element and that there is more than 1 element left.
+        *--_Last = _RANGES iter_move(--_Mid);
+
+        // We already know that _Backout._Last - 1 is the highest element, so do not compare against it again.
+        --_Mid;
+        --_Right_last;
+        for (;;) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Right_last), _STD invoke(_Proj, *_Mid))) {
+                *--_Last = _RANGES iter_move(_Mid); // the lowest element is now in position
+                if (_First == _Mid) {
+                    ++_Right_last; // to make [_Right_first, _Right_last) a half-open range
+                    _RANGES _Move_backward_common(_Right_first, _Right_last, _STD move(_Last));
+                    return;
+                }
+                --_Mid;
+            } else {
+                *--_Last = _RANGES iter_move(_Right_last);
+                --_Right_last;
+                if (_Right_first == _Right_last) { // we can't compare with *_Right_first, but we know it is lowest
+                    ++_Mid; // restore half-open range [_First, _Mid)
+                    _RANGES _Move_backward_common(_First, _STD move(_Mid), _STD move(_Last));
+                    *_First = _RANGES iter_move(_Right_first);
+                    return;
+                }
+            }
+        }
+    }
+
+    template <bidirectional_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    void _Buffered_inplace_merge_common(_It _First, _It _Mid, _It _Last, iter_difference_t<_It> _Count1,
+        iter_difference_t<_It> _Count2, iter_value_t<_It>* _Temp_ptr, ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj);
+
+    template <bidirectional_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    void _Buffered_inplace_merge_divide_and_conquer2(_It _First, _It _Mid, _It _Last,
+        const iter_difference_t<_It> _Count1, const iter_difference_t<_It> _Count2, iter_value_t<_It>* const _Temp_ptr,
+        const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj, _It _Firstn, _It _Lastn, const iter_difference_t<_It> _Count1n,
+        const iter_difference_t<_It> _Count2n) {
+        // common block of _Buffered_inplace_merge_divide_and_conquer, below
+        _It _Midn = _RANGES _Buffered_rotate_common(_Firstn, _Mid, _Lastn,
+            static_cast<iter_difference_t<_It>>(_Count1 - _Count1n), _Count2n, _Temp_ptr,
+            _Capacity); // rearrange middle
+        _RANGES _Buffered_inplace_merge_common(
+            _First, _Firstn, _Midn, _Count1n, _Count2n, _Temp_ptr, _Capacity, _Pred, _Proj); // merge each new part
+        _RANGES _Buffered_inplace_merge_common(_Midn, _Lastn, _Last,
+            static_cast<iter_difference_t<_It>>(_Count1 - _Count1n),
+            static_cast<iter_difference_t<_It>>(_Count2 - _Count2n), _Temp_ptr, _Capacity, _Pred, _Proj);
+    }
+
+    template <bidirectional_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    void _Buffered_inplace_merge_divide_and_conquer(_It _First, _It _Mid, _It _Last,
+        const iter_difference_t<_It> _Count1, const iter_difference_t<_It> _Count2, iter_value_t<_It>* const _Temp_ptr,
+        const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj) {
+        // merge sorted [_First, _Mid) with sorted [_Mid, _Last)
+        // usual invariants apply
+        if (_Count1 <= _Count2) {
+            const iter_difference_t<_It> _Count1n = _Count1 >> 1; // shift for codegen
+            _It _Firstn                           = _RANGES next(_First, _Count1n);
+            _It _Lastn = _RANGES _Lower_bound_unchecked(_Mid, _Count1, _STD invoke(_Proj, *_Firstn), _Pred, _Proj);
+            const auto _Count2n = _RANGES distance(_Mid, _Lastn);
+            _RANGES _Buffered_inplace_merge_divide_and_conquer2(_STD move(_First), _STD move(_Mid), _STD move(_Last),
+                _Count1, _Count2, _Temp_ptr, _Capacity, _Pred, _Proj, _STD move(_Firstn), _STD move(_Lastn), _Count1n,
+                _Count2n);
+        } else {
+            const iter_difference_t<_It> _Count2n = _Count2 >> 1; // shift for codegen
+            _It _Lastn                            = _RANGES next(_Mid, _Count2n);
+            _It _Firstn = _RANGES _Upper_bound_unchecked(_First, _Count2, _STD invoke(_Proj, *_Lastn), _Pred, _Proj);
+            const auto _Count1n = _RANGES distance(_First, _Firstn);
+            _RANGES _Buffered_inplace_merge_divide_and_conquer2(_STD move(_First), _STD move(_Mid), _STD move(_Last),
+                _Count1, _Count2, _Temp_ptr, _Capacity, _Pred, _Proj, _STD move(_Firstn), _STD move(_Lastn), _Count1n,
+                _Count2n);
+        }
+    }
+
+    template <bidirectional_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    void _Buffered_inplace_merge_common(_It _First, _It _Mid, _It _Last, iter_difference_t<_It> _Count1,
+        iter_difference_t<_It> _Count2, iter_value_t<_It>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred,
+        _Pj _Proj) {
+        // merge sorted [_First, _Mid) with sorted [_Mid, _Last)
+        // usual invariants *do not* apply; only sortedness applies
+        // establish the usual invariants
+        if (_First == _Mid || _Mid == _Last) {
+            return;
+        }
+
+        // Find first element in [_First, _Mid) that is greater than *_Mid
+        while (!_STD invoke(_Pred, _STD invoke(_Proj, *_Mid), _STD invoke(_Proj, *_First))) {
+            --_Count1;
+            if (++_First == _Mid) {
+                return;
+            }
+        }
+
+        // Find last element in [_Mid, _Last) that is less than *--_Mid
+        const auto _Highest = _RANGES prev(_Mid);
+        do {
+            // Fast early return if there is only one element to be moved
+            if (_Mid == --_Last) {
+                // rotate only element remaining in right partition to the beginning, without allocating
+                _RANGES _Rotate_one_right(_STD move(_First), _STD move(_Mid), _STD move(++_Last));
+                return;
+            }
+            --_Count2;
+        } while (!_STD invoke(_Pred, _STD invoke(_Proj, *_Last), _STD invoke(_Proj, *_Highest)));
+        ++_Last;
+        ++_Count2;
+
+        if (_Count1 == 1) {
+            _RANGES _Rotate_one_left(_STD move(_First), _STD move(_Mid), _STD move(_Last));
+            return;
+        }
+
+        if (_Count1 <= _Count2 && _Count1 <= _Capacity) {
+            _RANGES _Inplace_merge_buffer_left(
+                _STD move(_First), _STD move(_Mid), _STD move(_Last), _Temp_ptr, _Capacity, _Pred, _Proj);
+        } else if (_Count2 <= _Capacity) {
+            _RANGES _Inplace_merge_buffer_right(
+                _STD move(_First), _STD move(_Mid), _STD move(_Last), _Temp_ptr, _Capacity, _Pred, _Proj);
+        } else {
+            _RANGES _Buffered_inplace_merge_divide_and_conquer(_STD move(_First), _STD move(_Mid), _STD move(_Last),
+                _Count1, _Count2, _Temp_ptr, _Capacity, _Pred, _Proj);
+        }
+    }
+
+    class _Inplace_merge_fn {
+    public:
+        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static _It operator()(_It _First, _It _Mid, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Mid);
+            _STD _Adl_verify_range(_Mid, _Last);
+
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+
+            _Inplace_merge_common(_STD move(_UFirst), _RANGES _Unwrap_iter<_Se>(_STD move(_Mid)), _STD move(_ULast),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _First;
+        }
+
+        template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, iterator_t<_Rng> _Mid, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _First = _RANGES begin(_Range);
+            auto _Last  = _RANGES end(_Range);
+
+            _STD _Adl_verify_range(_First, _Mid);
+            _STD _Adl_verify_range(_Mid, _Last);
+
+            auto _UFirst = _RANGES _Unwrap_range_iter<_Rng>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<iterator_t<_Rng>>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+
+            _Inplace_merge_common(_STD move(_UFirst), _RANGES _Unwrap_range_iter<_Rng>(_STD move(_Mid)),
+                _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _First;
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        static void _Inplace_merge_common(_It _First, _It _Mid, _It _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+
+            if (_First == _Mid || _Mid == _Last) {
+                return;
+            }
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _STL_VERIFY(_RANGES _Is_sorted_until_unchecked(_First, _Mid, _Pred, _Proj) == _Mid,
+                "ranges::inplace_merge requires the range [first, middle) to be sorted");
+            _STL_VERIFY(_RANGES _Is_sorted_until_unchecked(_Mid, _Last, _Pred, _Proj) == _Last,
+                "ranges::inplace_merge requires the range [middle, last) to be sorted");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+            // Find first element in [_First, _Mid) that is greater than *_Mid
+            while (!_STD invoke(_Pred, _STD invoke(_Proj, *_Mid), _STD invoke(_Proj, *_First))) {
+                if (++_First == _Mid) {
+                    return;
+                }
+            }
+
+            // Fast early return if there is only one element to be moved
+            if (_Mid == --_Last) {
+                // rotate only element remaining in right partition to the beginning, without allocating
+                _RANGES _Rotate_one_right(_STD move(_First), _STD move(_Mid), _STD move(++_Last));
+                return;
+            }
+
+            // Find last element in [_Mid, _Last) that is less than *--_Mid
+            const auto _Highest = _RANGES prev(_Mid);
+            while (!_STD invoke(_Pred, _STD invoke(_Proj, *_Last), _STD invoke(_Proj, *_Highest))) {
+                if (_Mid == --_Last) {
+                    // rotate only element remaining in right partition to the beginning, without allocating
+                    _RANGES _Rotate_one_right(_STD move(_First), _STD move(_Mid), _STD move(++_Last));
+                    return;
+                }
+            }
+            ++_Last;
+
+            const iter_difference_t<_It> _Count1 = _RANGES distance(_First, _Mid);
+            if (_Count1 == 1) { // rotate only element remaining in left partition to the end, without allocating
+                _RANGES _Rotate_one_left(_STD move(_First), _STD move(_Mid), _STD move(_Last));
+                return;
+            }
+
+            const iter_difference_t<_It> _Count2 = _RANGES distance(_Mid, _Last);
+            _Optimistic_temporary_buffer2<iter_value_t<_It>> _Temp_buf{(_STD min) (_Count1, _Count2)};
+            if (_Count1 <= _Count2 && _Count1 <= _Temp_buf._Capacity) {
+                _RANGES _Inplace_merge_buffer_left(_STD move(_First), _STD move(_Mid), _STD move(_Last),
+                    _Temp_buf._Data, _Temp_buf._Capacity, _Pred, _Proj);
+            } else if (_Count2 <= _Temp_buf._Capacity) {
+                _RANGES _Inplace_merge_buffer_right(_STD move(_First), _STD move(_Mid), _STD move(_Last),
+                    _Temp_buf._Data, _Temp_buf._Capacity, _Pred, _Proj);
+            } else {
+                _RANGES _Buffered_inplace_merge_divide_and_conquer(_STD move(_First), _STD move(_Mid), _STD move(_Last),
+                    _Count1, _Count2, _Temp_buf._Data, _Temp_buf._Capacity, _Pred, _Proj);
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Inplace_merge_fn inplace_merge;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _BidIt, class _Pr>
+_CONSTEXPR20 _BidIt _Insertion_sort_unchecked(const _BidIt _First, const _BidIt _Last, _Pr _Pred) {
+    // insertion sort [_First, _Last)
+    if (_First != _Last) {
+        for (_BidIt _Mid = _First; ++_Mid != _Last;) { // order next element
+            _BidIt _Hole = _Mid;
+            _Iter_value_t<_BidIt> _Val(_STD move(*_Mid));
+
+            if (_DEBUG_LT_PRED(_Pred, _Val, *_First)) { // found new earliest element, move to front
+                _STD _Move_backward_unchecked(_First, _Mid, ++_Hole);
+                *_First = _STD move(_Val);
+            } else { // look for insertion point after first
+                for (_BidIt _Prev = _Hole; _DEBUG_LT_PRED(_Pred, _Val, *--_Prev); _Hole = _Prev) {
+                    *_Hole = _STD move(*_Prev); // move hole down
+                }
+
+                *_Hole = _STD move(_Val); // insert element in hole
+            }
+        }
+    }
+
+    return _Last;
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Med3_unchecked(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) {
+    // sort median of three elements to middle
+    if (_DEBUG_LT_PRED(_Pred, *_Mid, *_First)) {
+        swap(*_Mid, *_First); // intentional ADL
+    }
+
+    if (_DEBUG_LT_PRED(_Pred, *_Last, *_Mid)) { // swap middle and last, then test first again
+        swap(*_Last, *_Mid); // intentional ADL
+
+        if (_DEBUG_LT_PRED(_Pred, *_Mid, *_First)) {
+            swap(*_Mid, *_First); // intentional ADL
+        }
+    }
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Guess_median_unchecked(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) {
+    // sort median element to middle
+    using _Diff        = _Iter_diff_t<_RanIt>;
+    const _Diff _Count = _Last - _First;
+    if (40 < _Count) { // Tukey's ninther
+        const _Diff _Step     = (_Count + 1) >> 3; // +1 can't overflow because range was made inclusive in caller
+        const _Diff _Two_step = _Step << 1; // note: intentionally discards low-order bit
+        _STD _Med3_unchecked(_First, _First + _Step, _First + _Two_step, _Pred);
+        _STD _Med3_unchecked(_Mid - _Step, _Mid, _Mid + _Step, _Pred);
+        _STD _Med3_unchecked(_Last - _Two_step, _Last - _Step, _Last, _Pred);
+        _STD _Med3_unchecked(_First + _Step, _Mid, _Last - _Step, _Pred);
+    } else {
+        _STD _Med3_unchecked(_First, _Mid, _Last, _Pred);
+    }
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 pair<_RanIt, _RanIt> _Partition_by_pivot_unchecked(
+    _RanIt _First, _RanIt _Pfirst, _RanIt _Last, _Pr _Pred) {
+    // partition [_First, _Last) by pivot _Pfirst
+    _RanIt _Plast = _STD _Next_iter(_Pfirst);
+
+    while (_First < _Pfirst && !_DEBUG_LT_PRED(_Pred, *_STD _Prev_iter(_Pfirst), *_Pfirst)
+           && !_Pred(*_Pfirst, *_STD _Prev_iter(_Pfirst))) {
+        --_Pfirst;
+    }
+
+    while (_Plast < _Last && !_DEBUG_LT_PRED(_Pred, *_Plast, *_Pfirst) && !_Pred(*_Pfirst, *_Plast)) {
+        ++_Plast;
+    }
+
+    _RanIt _Gfirst = _Plast;
+    _RanIt _Glast  = _Pfirst;
+
+    for (;;) { // partition
+        for (; _Gfirst < _Last; ++_Gfirst) {
+            if (_DEBUG_LT_PRED(_Pred, *_Pfirst, *_Gfirst)) {
+                continue;
+            } else if (_Pred(*_Gfirst, *_Pfirst)) {
+                break;
+            } else if (_Plast != _Gfirst) {
+                swap(*_Plast, *_Gfirst); // intentional ADL
+                ++_Plast;
+            } else {
+                ++_Plast;
+            }
+        }
+
+        for (; _First < _Glast; --_Glast) {
+            const auto _Glast_prev = _STD _Prev_iter(_Glast);
+            if (_DEBUG_LT_PRED(_Pred, *_Glast_prev, *_Pfirst)) {
+                continue;
+            } else if (_Pred(*_Pfirst, *_Glast_prev)) {
+                break;
+            } else if (--_Pfirst != _Glast_prev) {
+                swap(*_Pfirst, *_Glast_prev); // intentional ADL
+            }
+        }
+
+        if (_Glast == _First && _Gfirst == _Last) {
+            return pair<_RanIt, _RanIt>(_Pfirst, _Plast);
+        }
+
+        if (_Glast == _First) { // no room at bottom, rotate pivot upward
+            if (_Plast != _Gfirst) {
+                swap(*_Pfirst, *_Plast); // intentional ADL
+            }
+
+            ++_Plast;
+            swap(*_Pfirst, *_Gfirst); // intentional ADL
+            ++_Pfirst;
+            ++_Gfirst;
+        } else if (_Gfirst == _Last) { // no room at top, rotate pivot downward
+            if (--_Glast != --_Pfirst) {
+                swap(*_Glast, *_Pfirst); // intentional ADL
+            }
+
+            swap(*_Pfirst, *--_Plast); // intentional ADL
+        } else {
+            swap(*_Gfirst, *--_Glast); // intentional ADL
+            ++_Gfirst;
+        }
+    }
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 pair<_RanIt, _RanIt> _Partition_by_median_guess_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
+    // partition [_First, _Last)
+    _RanIt _Mid = _First + ((_Last - _First) >> 1); // shift for codegen
+    _STD _Guess_median_unchecked(_First, _Mid, _STD _Prev_iter(_Last), _Pred);
+
+    return _STD _Partition_by_pivot_unchecked(_First, _Mid, _Last, _Pred);
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_RanIt> _Ideal, _Pr _Pred) {
+    // order [_First, _Last)
+    for (;;) {
+        if (_Last - _First <= _ISORT_MAX) { // small
+            _STD _Insertion_sort_unchecked(_First, _Last, _Pred);
+            return;
+        }
+
+        if (_Ideal <= 0) { // heap sort if too many divisions
+            _STD _Make_heap_unchecked(_First, _Last, _Pred);
+            _STD _Sort_heap_unchecked(_First, _Last, _Pred);
+            return;
+        }
+
+        // divide and conquer by quicksort
+        auto _Mid = _STD _Partition_by_median_guess_unchecked(_First, _Last, _Pred);
+
+        _Ideal = (_Ideal >> 1) + (_Ideal >> 2); // allow 1.5 log2(N) divisions
+
+        if (_Mid.first - _First < _Last - _Mid.second) { // loop on second half
+            _STD _Sort_unchecked(_First, _Mid.first, _Ideal, _Pred);
+            _First = _Mid.second;
+        } else { // loop on first half
+            _STD _Sort_unchecked(_Mid.second, _Last, _Ideal, _Pred);
+            _Last = _Mid.first;
+        }
+    }
+}
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) { // order [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    _STD _Sort_unchecked(_UFirst, _ULast, _ULast - _UFirst, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _RanIt>
+_CONSTEXPR20 void sort(const _RanIt _First, const _RanIt _Last) { // order [_First, _Last)
+    _STD sort(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+void sort(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void sort(_ExPo&& _Exec, const _RanIt _First, const _RanIt _Last) noexcept /* terminates */ {
+    // order [_First, _Last)
+    _STD sort(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <bidirectional_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    constexpr _It _Insertion_sort_common(const _It _First, const _It _Last, _Pr _Pred, _Pj _Proj) {
+        // insertion sort [_First, _Last)
+
+        if (_First == _Last) { // empty range is sorted
+            return _Last;
+        }
+
+        for (auto _Mid = _First; ++_Mid != _Last;) { // order next element
+            iter_value_t<_It> _Val(_RANGES iter_move(_Mid));
+            auto _Hole = _Mid;
+
+            for (auto _Prev = _Hole;;) {
+                --_Prev;
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, _Val), _STD invoke(_Proj, *_Prev))) {
+                    break;
+                }
+                *_Hole = _RANGES iter_move(_Prev); // move hole down
+                if (--_Hole == _First) {
+                    break;
+                }
+            }
+
+            *_Hole = _STD move(_Val); // insert element in hole
+        }
+        return _Last;
+    }
+
+    template <random_access_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    constexpr void _Med3_common(_It _First, _It _Mid, _It _Last, _Pr _Pred, _Pj _Proj) {
+        // sort median of three elements to middle
+        if (_STD invoke(_Pred, _STD invoke(_Proj, *_Mid), _STD invoke(_Proj, *_First))) {
+            _RANGES iter_swap(_Mid, _First);
+        }
+
+        if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Last), _STD invoke(_Proj, *_Mid))) {
+            return;
+        }
+
+        // swap middle and last, then test first again
+        _RANGES iter_swap(_Last, _Mid);
+
+        if (_STD invoke(_Pred, _STD invoke(_Proj, *_Mid), _STD invoke(_Proj, *_First))) {
+            _RANGES iter_swap(_Mid, _First);
+        }
+    }
+
+    template <random_access_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    constexpr void _Guess_median_common(_It _First, _It _Mid, _It _Last, _Pr _Pred, _Pj _Proj) {
+        // sort median element to middle
+        using _Diff        = iter_difference_t<_It>;
+        const _Diff _Count = _Last - _First;
+        if (_Count > 40) { // Tukey's ninther
+            const _Diff _Step     = (_Count + 1) >> 3; // +1 can't overflow because range was made inclusive in caller
+            const _Diff _Two_step = _Step << 1; // note: intentionally discards low-order bit
+            _RANGES _Med3_common(_First, _First + _Step, _First + _Two_step, _Pred, _Proj);
+            _RANGES _Med3_common(_Mid - _Step, _Mid, _Mid + _Step, _Pred, _Proj);
+            _RANGES _Med3_common(_Last - _Two_step, _Last - _Step, _Last, _Pred, _Proj);
+            _RANGES _Med3_common(_First + _Step, _Mid, _Last - _Step, _Pred, _Proj);
+        } else {
+            _RANGES _Med3_common(_First, _Mid, _Last, _Pred, _Proj);
+        }
+    }
+
+    template <random_access_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    _NODISCARD constexpr subrange<_It> _Partition_by_pivot_common(
+        _It _First, _It _Pfirst, _It _Last, _Pr _Pred, _Pj _Proj) {
+        // Partition [_First, _Last) by pivot _Pfirst into elements less than pivot, elements equal to pivot, and
+        // elements greater than pivot; return the equal partition as a subrange.
+
+        _It _Plast = _RANGES next(_Pfirst);
+
+        while (_First < _Pfirst
+               && !_STD invoke(_Pred, _STD invoke(_Proj, *_RANGES prev(_Pfirst)), _STD invoke(_Proj, *_Pfirst))
+               && !_STD invoke(_Pred, _STD invoke(_Proj, *_Pfirst), _STD invoke(_Proj, *_RANGES prev(_Pfirst)))) {
+            --_Pfirst;
+        }
+
+        while (_Plast < _Last && !_STD invoke(_Pred, _STD invoke(_Proj, *_Plast), _STD invoke(_Proj, *_Pfirst))
+               && !_STD invoke(_Pred, _STD invoke(_Proj, *_Pfirst), _STD invoke(_Proj, *_Plast))) {
+            ++_Plast;
+        }
+
+        _It _Gfirst = _Plast;
+        _It _Glast  = _Pfirst;
+
+        for (;;) { // partition
+            for (; _Gfirst < _Last; ++_Gfirst) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Pfirst), _STD invoke(_Proj, *_Gfirst))) {
+                    continue;
+                } else if (_STD invoke(_Pred, _STD invoke(_Proj, *_Gfirst), _STD invoke(_Proj, *_Pfirst))) {
+                    break;
+                } else if (_Plast != _Gfirst) {
+                    _RANGES iter_swap(_Plast, _Gfirst);
+                    ++_Plast;
+                } else {
+                    ++_Plast;
+                }
+            }
+
+            for (; _First < _Glast; --_Glast) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_RANGES prev(_Glast)), _STD invoke(_Proj, *_Pfirst))) {
+                    continue;
+                } else if (_STD invoke(
+                               _Pred, _STD invoke(_Proj, *_Pfirst), _STD invoke(_Proj, *_RANGES prev(_Glast)))) {
+                    break;
+                } else if (--_Pfirst != _RANGES prev(_Glast)) {
+                    _RANGES iter_swap(_Pfirst, _RANGES prev(_Glast));
+                }
+            }
+
+            if (_Glast == _First && _Gfirst == _Last) {
+                return {_STD move(_Pfirst), _STD move(_Plast)};
+            }
+
+            if (_Glast == _First) { // no room at bottom, rotate pivot upward
+                if (_Plast != _Gfirst) {
+                    _RANGES iter_swap(_Pfirst, _Plast);
+                }
+
+                ++_Plast;
+                _RANGES iter_swap(_Pfirst, _Gfirst);
+                ++_Pfirst;
+                ++_Gfirst;
+            } else if (_Gfirst == _Last) { // no room at top, rotate pivot downward
+                if (--_Glast != --_Pfirst) {
+                    _RANGES iter_swap(_Glast, _Pfirst);
+                }
+
+                _RANGES iter_swap(_Pfirst, --_Plast);
+            } else {
+                _RANGES iter_swap(_Gfirst, --_Glast);
+                ++_Gfirst;
+            }
+        }
+    }
+
+    template <random_access_iterator _It, class _Pr, class _Pj>
+        requires sortable<_It, _Pr, _Pj>
+    _NODISCARD constexpr subrange<_It> _Partition_by_median_guess_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
+        // Choose a pivot, partition [_First, _Last) into elements less than pivot, elements equal to pivot, and
+        // elements greater than pivot; return the equal partition as a subrange.
+
+        _It _Mid = _First + ((_Last - _First) >> 1); // shift for codegen
+        _RANGES _Guess_median_common(_First, _Mid, _RANGES prev(_Last), _Pred, _Proj);
+        return _RANGES _Partition_by_pivot_common(_First, _Mid, _Last, _Pred, _Proj);
+    }
+
+    class _Sort_fn {
+    public:
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            const auto _Count = _ULast - _UFirst;
+            _Sort_common(_STD move(_UFirst), _STD move(_ULast), _Count, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _First;
+        }
+
+        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UFirst      = _Ubegin(_Range);
+            auto _ULast       = _RANGES _Get_final_iterator_unwrapped(_Range);
+            const auto _Count = _ULast - _UFirst;
+            _Sort_common(_STD move(_UFirst), _ULast, _Count, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_ULast));
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        static constexpr void _Sort_common(_It _First, _It _Last, iter_difference_t<_It> _Ideal, _Pr _Pred, _Pj _Proj) {
+            // sort [_First, _Last) with respect to _Pred and _Proj
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+
+            for (;;) {
+                if (_Last - _First <= _ISORT_MAX) { // small
+                    _RANGES _Insertion_sort_common(_STD move(_First), _STD move(_Last), _Pred, _Proj);
+                    return;
+                }
+
+                if (_Ideal <= 0) { // heap sort if too many divisions
+                    _RANGES _Make_heap_common(_First, _Last, _Pred, _Proj);
+                    _RANGES _Sort_heap_common(_STD move(_First), _STD move(_Last), _Pred, _Proj);
+                    return;
+                }
+
+                // divide and conquer by quicksort
+                auto _Mid       = _RANGES _Partition_by_median_guess_common(_First, _Last, _Pred, _Proj);
+                auto _Mid_first = _Mid.begin();
+                auto _Mid_last  = _Mid.end();
+
+                _Ideal = (_Ideal >> 1) + (_Ideal >> 2); // allow 1.5 log2(N) divisions
+
+                if (_Mid_first - _First < _Last - _Mid_last) { // loop on second half
+                    _Sort_common(_First, _STD move(_Mid_first), _Ideal, _Pred, _Proj);
+                    _First = _STD move(_Mid_last);
+                } else { // loop on first half
+                    _Sort_common(_STD move(_Mid_last), _Last, _Ideal, _Pred, _Proj);
+                    _Last = _STD move(_Mid_first);
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Sort_fn sort;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _FwdIt, class _Ty, class _Pr>
+_Ty* _Uninitialized_merge_move(_FwdIt _First, const _FwdIt _Mid, const _FwdIt _Last, _Ty* const _Dest, _Pr _Pred) {
+    // move merging ranges to uninitialized storage
+    // pre: _First != _Mid && _Mid != _Last
+    _Uninitialized_backout<_Ty*> _Backout{_Dest};
+    _FwdIt _Next = _Mid;
+    for (;;) {
+        if (_DEBUG_LT_PRED(_Pred, *_Next, *_First)) {
+            _Backout._Emplace_back(_STD move(*_Next));
+            ++_Next;
+
+            if (_Next == _Last) {
+                _Backout._Last = _STD _Uninitialized_move_unchecked(_First, _Mid, _Backout._Last);
+                return _Backout._Release();
+            }
+        } else {
+            _Backout._Emplace_back(_STD move(*_First));
+            ++_First;
+
+            if (_First == _Mid) {
+                _Backout._Last = _STD _Uninitialized_move_unchecked(_Next, _Last, _Backout._Last);
+                return _Backout._Release();
+            }
+        }
+    }
+}
+
+template <class _InIt, class _OutIt, class _Pr>
+_OutIt _Merge_move_unchecked(_InIt _First, const _InIt _Mid, const _InIt _Last, _OutIt _Dest, _Pr _Pred) {
+    // move merging adjacent ranges [_First, _Mid) and [_Mid, _Last) to _Dest
+    // pre: _First != _Mid && _Mid != _Last
+    _InIt _Next = _Mid;
+    for (;;) {
+        if (_DEBUG_LT_PRED(_Pred, *_Next, *_First)) {
+            *_Dest = _STD move(*_Next);
+            ++_Dest;
+            ++_Next;
+
+            if (_Next == _Last) {
+                return _STD _Move_unchecked(_First, _Mid, _Dest);
+            }
+        } else {
+            *_Dest = _STD move(*_First);
+            ++_Dest;
+            ++_First;
+
+            if (_First == _Mid) {
+                return _STD _Move_unchecked(_Next, _Last, _Dest);
+            }
+        }
+    }
+}
+
+template <class _BidIt, class _Ty, class _Pr>
+void _Uninitialized_chunked_merge_unchecked2(
+    _BidIt _First, const _BidIt _Last, _Ty* _Dest, _Iter_diff_t<_BidIt> _Count, _Pr _Pred) {
+    // move to uninitialized merging adjacent chunks of distance _Isort_max<_BidIt>
+    // pre: _Count == distance(_First, _Last)
+    // pre: _Chunk > 0
+    _Uninitialized_backout<_Ty*> _Backout{_Dest};
+    while (_Count > _Isort_max<_BidIt>) {
+        _Count -= _Isort_max<_BidIt>;
+        const _BidIt _Mid1 = _STD next(_First, _Isort_max<_BidIt>);
+        const auto _Chunk2 = (_STD min) (_Isort_max<_BidIt>, _Count);
+        _Count -= _Chunk2;
+        const _BidIt _Mid2 = _STD next(_Mid1, _Chunk2);
+        _Backout._Last     = _STD _Uninitialized_merge_move(_First, _Mid1, _Mid2, _Backout._Last, _Pred);
+        _First             = _Mid2;
+    }
+
+    _STD _Uninitialized_move_unchecked(_First, _Last, _Backout._Last); // copy partial last chunk
+    _Backout._Release();
+}
+
+template <class _BidIt, class _OutIt, class _Pr>
+void _Chunked_merge_unchecked(_BidIt _First, const _BidIt _Last, _OutIt _Dest, const _Iter_diff_t<_BidIt> _Chunk,
+    _Iter_diff_t<_BidIt> _Count, _Pr _Pred) {
+    // move merging adjacent chunks of distance _Chunk
+    // pre: _Count == distance(_First, _Last)
+    // pre: _Chunk > 0
+    while (_Chunk < _Count) {
+        _Count -= _Chunk;
+        const _BidIt _Mid1 = _STD next(_First, _Chunk);
+        const auto _Chunk2 = (_STD min) (_Chunk, _Count);
+        _Count -= _Chunk2;
+        const _BidIt _Mid2 = _STD next(_Mid1, _Chunk2);
+        _Dest              = _STD _Merge_move_unchecked(_First, _Mid1, _Mid2, _Dest, _Pred);
+        _First             = _Mid2;
+    }
+
+    _STD _Move_unchecked(_First, _Last, _Dest); // copy partial last chunk
+}
+
+template <class _BidIt, class _Pr>
+void _Insertion_sort_isort_max_chunks(_BidIt _First, const _BidIt _Last, _Iter_diff_t<_BidIt> _Count, _Pr _Pred) {
+    // insertion sort every chunk of distance _Isort_max<_BidIt> in [_First, _Last)
+    // pre: _Count == distance(_First, _Last)
+    for (; _Isort_max<_BidIt> < _Count; _Count -= _Isort_max<_BidIt>) { // sort chunks
+        _First = _STD _Insertion_sort_unchecked(_First, _STD next(_First, _Isort_max<_BidIt>), _Pred);
+    }
+
+    _STD _Insertion_sort_unchecked(_First, _Last, _Pred); // sort partial last chunk
+}
+
+template <class _BidIt, class _Pr>
+void _Buffered_merge_sort_unchecked(const _BidIt _First, const _BidIt _Last, const _Iter_diff_t<_BidIt> _Count,
+    _Iter_value_t<_BidIt>* const _Temp_ptr, _Pr _Pred) {
+    // sort using temp buffer for merges
+    // pre: _Last - _First == _Count
+    // pre: _Count <= capacity of buffer at _Temp_ptr; also allows safe narrowing to ptrdiff_t
+    _STD _Insertion_sort_isort_max_chunks(_First, _Last, _Count, _Pred);
+    // merge adjacent pairs of chunks to and from temp buffer
+    if (_Count <= _Isort_max<_BidIt>) {
+        return;
+    }
+
+    // do the first merge, constructing elements in the temporary buffer
+    _STD _Uninitialized_chunked_merge_unchecked2(_First, _Last, _Temp_ptr, _Count, _Pred);
+    _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{_Temp_ptr, _Temp_ptr + _Count};
+    auto _Chunk = _Isort_max<_BidIt>;
+    for (;;) {
+        // unconditionally merge elements back into the source buffer
+
+        // _Chunk starts at 2^5 and is doubled twice in this loop.
+        // The first doubling (to 2^6, 2^8, 2^10, ...) doesn't check for overflow as it doesn't pose a risk.
+        // The second doubling (to 2^7, 2^9, 2^11, ..., 2^15, ..., 2^31, ...) defends against overflow below.
+        _Chunk <<= 1;
+        _STD _Chunked_merge_unchecked(_Temp_ptr, _Temp_ptr + _Count, _First, static_cast<ptrdiff_t>(_Chunk),
+            static_cast<ptrdiff_t>(_Count), _Pred);
+
+        // This is equivalent to doubling _Chunk followed by returning when `_Count <= _Chunk`,
+        // except that it doesn't risk overflowing.
+        // Note that returning when `_Count / 2 <= _Chunk` before doubling _Chunk
+        // would behave differently for odd _Count due to truncating integer division.
+        // Returning when `(_Count - 1) / 2 < _Chunk` correctly handles both even and odd _Count.
+        // We have an early return for small _Count above, so `_Count - 1` is safe to form.
+        if ((_Count - 1) / 2 < _Chunk) {
+            return; // if the input would be a single chunk, it's already sorted and we're done
+        }
+        _Chunk <<= 1;
+
+        // more merges necessary; merge to temporary buffer
+        _STD _Chunked_merge_unchecked(_First, _Last, _Temp_ptr, _Chunk, _Count, _Pred);
+    }
+}
+
+template <class _BidIt, class _Pr>
+void _Stable_sort_unchecked(const _BidIt _First, const _BidIt _Last, const _Iter_diff_t<_BidIt> _Count,
+    _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred) {
+    // sort preserving order of equivalents
+    using _Diff = _Iter_diff_t<_BidIt>;
+    if (_Count <= _ISORT_MAX) {
+        _STD _Insertion_sort_unchecked(_First, _Last, _Pred); // small
+    } else { // sort halves and merge
+        const auto _Half_count      = static_cast<_Diff>(_Count >> 1); // shift for codegen
+        const auto _Half_count_ceil = static_cast<_Diff>(_Count - _Half_count);
+        const _BidIt _Mid           = _STD next(_First, _Half_count_ceil);
+        if (_Half_count_ceil <= _Capacity) { // temp buffer big enough, sort each half using buffer
+            _STD _Buffered_merge_sort_unchecked(_First, _Mid, _Half_count_ceil, _Temp_ptr, _Pred);
+            _STD _Buffered_merge_sort_unchecked(_Mid, _Last, _Half_count, _Temp_ptr, _Pred);
+        } else { // temp buffer not big enough, divide and conquer
+            _STD _Stable_sort_unchecked(_First, _Mid, _Half_count_ceil, _Temp_ptr, _Capacity, _Pred);
+            _STD _Stable_sort_unchecked(_Mid, _Last, _Half_count, _Temp_ptr, _Capacity, _Pred);
+        }
+
+        _STD _Buffered_inplace_merge_unchecked(
+            _First, _Mid, _Last, _Half_count_ceil, _Half_count, _Temp_ptr, _Capacity, _Pred); // merge halves
+    }
+}
+
+_EXPORT_STD template <class _BidIt, class _Pr>
+void stable_sort(const _BidIt _First, const _BidIt _Last, _Pr _Pred) {
+    // sort preserving order of equivalents
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _Count  = _STD distance(_UFirst, _ULast);
+    if (_Count <= _ISORT_MAX) {
+        _STD _Insertion_sort_unchecked(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+        return;
+    }
+
+    _Optimistic_temporary_buffer2<_Iter_value_t<_BidIt>> _Temp_buf{_Count - _Count / 2};
+    _STD _Stable_sort_unchecked(_UFirst, _ULast, _Count, _Temp_buf._Data, _Temp_buf._Capacity, _STD _Pass_fn(_Pred));
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+void stable_sort(_ExPo&& _Exec, _BidIt _First, _BidIt _Last, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _BidIt>
+void stable_sort(const _BidIt _First, const _BidIt _Last) { // sort preserving order of equivalents
+    _STD stable_sort(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void stable_sort(_ExPo&& _Exec, _BidIt _First, _BidIt _Last) noexcept /* terminates */ {
+    // sort preserving order of equivalents
+    _STD stable_sort(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Stable_sort_fn {
+    public:
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+
+            const auto _Count = _ULast - _UFirst;
+            _Stable_sort_common(
+                _STD move(_UFirst), _STD move(_ULast), _Count, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _First;
+        }
+
+        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UFirst = _Ubegin(_Range);
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped(_Range);
+
+            const auto _Count = _ULast - _UFirst;
+            _Stable_sort_common(_STD move(_UFirst), _ULast, _Count, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_ULast));
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        static void _Stable_sort_common(
+            _It _First, _It _Last, const iter_difference_t<_It> _Count, _Pr _Pred, _Pj _Proj) {
+            // sort [_First, _Last) with respect to _Pred and _Proj
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First, _Last) == _Count);
+
+            if (_Count <= _Isort_max<_It>) {
+                _RANGES _Insertion_sort_common(_STD move(_First), _STD move(_Last), _Pred, _Proj);
+                return;
+            }
+
+            _Optimistic_temporary_buffer2<iter_value_t<_It>> _Temp_buf{_Count - _Count / 2};
+            _Stable_sort_common_buffered(
+                _STD move(_First), _STD move(_Last), _Count, _Temp_buf._Data, _Temp_buf._Capacity, _Pred, _Proj);
+        }
+
+        template <class _It, class _Pr, class _Pj>
+        static void _Stable_sort_common_buffered(_It _First, _It _Last, const iter_difference_t<_It> _Count,
+            iter_value_t<_It>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj) {
+            // sort [_First, _Last) with respect to _Pred and _Proj
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First, _Last) == _Count);
+            // Pre: _Temp_ptr points to empty storage for _Capacity objects
+
+            if (_Count <= _Isort_max<_It>) {
+                _RANGES _Insertion_sort_common(_STD move(_First), _STD move(_Last), _Pred, _Proj);
+            } else { // sort halves and merge
+                const iter_difference_t<_It> _Half_count      = _Count >> 1; // shift for codegen
+                const iter_difference_t<_It> _Half_count_ceil = _Count - _Half_count;
+                const _It _Mid                                = _First + _Half_count_ceil;
+                if (_Half_count_ceil <= _Capacity) { // temp buffer big enough, sort each half using buffer
+                    _Buffered_merge_sort_common(
+                        _First, _Mid, static_cast<ptrdiff_t>(_Half_count_ceil), _Temp_ptr, _Pred, _Proj);
+                    _Buffered_merge_sort_common(
+                        _Mid, _Last, static_cast<ptrdiff_t>(_Half_count), _Temp_ptr, _Pred, _Proj);
+                } else { // temp buffer not big enough, divide and conquer
+                    _Stable_sort_common_buffered(_First, _Mid, _Half_count_ceil, _Temp_ptr, _Capacity, _Pred, _Proj);
+                    _Stable_sort_common_buffered(_Mid, _Last, _Half_count, _Temp_ptr, _Capacity, _Pred, _Proj);
+                }
+                // merge halves
+                _RANGES _Buffered_inplace_merge_common(_STD move(_First), _STD move(_Mid), _STD move(_Last),
+                    _Half_count_ceil, _Half_count, _Temp_ptr, _Capacity, _Pred, _Proj);
+            }
+        }
+
+        template <class _It, class _Pr, class _Pj>
+        static void _Buffered_merge_sort_common(const _It _First, const _It _Last, const ptrdiff_t _Count,
+            iter_value_t<_It>* const _Temp_ptr, _Pr _Pred, _Pj _Proj) {
+            // sort using temp buffer for merges
+            // pre: _Count <= capacity of buffer at _Temp_ptr
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+            _STL_INTERNAL_CHECK(_Last - _First == _Count);
+
+            _Insertion_sort_isort_max_chunks(_First, _Last, _Count, _Pred, _Proj);
+            // merge adjacent pairs of chunks to and from temp buffer
+            if (_Count <= _ISORT_MAX) {
+                return;
+            }
+
+            // do the first merge, constructing elements in the temporary buffer
+            _Uninitialized_chunked_merge_common(_First, _Last, _Temp_ptr, _Count, _Pred, _Proj);
+            _Uninitialized_backout<iter_value_t<_It>*> _Backout{_Temp_ptr, _Temp_ptr + _Count};
+            ptrdiff_t _Chunk_size = _ISORT_MAX;
+            for (;;) {
+                // unconditionally merge elements back into the source buffer
+
+                // _Chunk_size starts at 2^5 and is doubled twice in this loop.
+                // The first doubling (to 2^6, 2^8, 2^10, ...) doesn't check for overflow as it doesn't pose a risk.
+                // The second doubling (to 2^7, 2^9, 2^11, ..., 2^15, ..., 2^31, ...) defends against overflow below.
+                _Chunk_size <<= 1;
+                _Chunked_merge_common(_Temp_ptr, _Temp_ptr + _Count, _First, _Chunk_size, _Count, _Pred, _Proj);
+
+                // This is equivalent to doubling _Chunk_size followed by returning when `_Count <= _Chunk_size`,
+                // except that it doesn't risk overflowing.
+                // Note that returning when `_Count / 2 <= _Chunk_size` before doubling _Chunk_size
+                // would behave differently for odd _Count due to truncating integer division.
+                // Returning when `(_Count - 1) / 2 < _Chunk_size` correctly handles both even and odd _Count.
+                // We have an early return for small _Count above, so `_Count - 1` is safe to form.
+                if ((_Count - 1) / 2 < _Chunk_size) {
+                    return; // if the input would be a single chunk, it's already sorted and we're done
+                }
+                _Chunk_size <<= 1;
+
+                // more merges necessary; merge to temporary buffer
+                _Chunked_merge_common(_First, _Last, _Temp_ptr, _Chunk_size, _Count, _Pred, _Proj);
+            }
+        }
+
+        template <class _It, class _Pr, class _Pj>
+        static void _Insertion_sort_isort_max_chunks(_It _First, _It _Last, ptrdiff_t _Count, _Pr _Pred, _Pj _Proj) {
+            // insertion sort every chunk of distance _Isort_max<_It> in [_First, _Last)
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First, _Last) == _Count);
+
+            for (; _ISORT_MAX < _Count; _Count -= _ISORT_MAX) { // sort chunks
+                _First = _RANGES _Insertion_sort_common(_First, _First + _Isort_max<_It>, _Pred, _Proj);
+            }
+
+            // sort partial last chunk
+            _RANGES _Insertion_sort_common(_STD move(_First), _STD move(_Last), _Pred, _Proj);
+        }
+
+        template <class _It, class _Pr, class _Pj>
+        static void _Uninitialized_chunked_merge_common(
+            _It _First, const _It _Last, iter_value_t<_It>* const _Dest, ptrdiff_t _Count, _Pr _Pred, _Pj _Proj) {
+            // move to uninitialized merging adjacent chunks of distance _Isort_max<_It>
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+            _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_It>, iter_rvalue_reference_t<_It>>);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First, _Last) == _Count);
+
+            _Uninitialized_backout<iter_value_t<_It>*> _Backout{_Dest};
+            const auto _Backout_end = _Dest + _Count;
+            while (_ISORT_MAX < _Count) {
+                _Count -= _ISORT_MAX;
+                const auto _Chunk2 = (_STD min) (static_cast<ptrdiff_t>(_ISORT_MAX), _Count);
+                _Count -= _Chunk2;
+
+                auto _Mid1     = _First + _Isort_max<_It>;
+                auto _Last1    = _Mid1 + static_cast<iter_difference_t<_It>>(_Chunk2);
+                auto _Last2    = _Backout._Last + _ISORT_MAX + _Chunk2;
+                _Backout._Last = _Uninitialized_merge_move(
+                    _STD move(_First), _STD move(_Mid1), _Last1, _Backout._Last, _Last2, _Pred, _Proj);
+                _First = _STD move(_Last1);
+            }
+
+            // move partial last chunk
+            _RANGES _Uninitialized_move_unchecked(_STD move(_First), _STD move(_Last), _Backout._Last, _Backout_end);
+            _Backout._Release();
+        }
+
+        template <class _It, class _Pr, class _Pj>
+        _NODISCARD static iter_value_t<_It>* _Uninitialized_merge_move(_It _First, _It _Mid, _It _Last,
+            iter_value_t<_It>* const _Dest, iter_value_t<_It>* const _Dest_last, _Pr _Pred, _Pj _Proj) {
+            // move merging ranges to uninitialized storage
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+            _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_It>, iter_rvalue_reference_t<_It>>);
+            _STL_INTERNAL_CHECK(_First != _Mid);
+            _STL_INTERNAL_CHECK(_Mid != _Last);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First, _Last) <= _RANGES distance(_Dest, _Dest_last));
+
+            _Uninitialized_backout<iter_value_t<_It>*> _Backout{_Dest};
+            _It _Next = _Mid;
+            for (;;) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Next), _STD invoke(_Proj, *_First))) {
+                    _Backout._Emplace_back(_RANGES iter_move(_Next));
+                    ++_Next;
+
+                    if (_Next == _Last) {
+                        _Backout._Last = _RANGES _Uninitialized_move_unchecked(
+                            _STD move(_First), _STD move(_Mid), _Backout._Last, _Dest_last)
+                                             .out;
+                        return _Backout._Release();
+                    }
+                } else {
+                    _Backout._Emplace_back(_RANGES iter_move(_First));
+                    ++_First;
+
+                    if (_First == _Mid) {
+                        _Backout._Last = _RANGES _Uninitialized_move_unchecked(
+                            _STD move(_Next), _STD move(_Last), _Backout._Last, _Dest_last)
+                                             .out;
+                        return _Backout._Release();
+                    }
+                }
+            }
+        }
+
+        template <class _InIt, class _OutIt, class _Pr, class _Pj>
+        _NODISCARD static _OutIt _Merge_move_common(
+            _InIt _First, _InIt _Mid, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Pj _Proj) {
+            // move merging adjacent ranges [_First, _Mid) and [_Mid, _Last) to _Dest
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_InIt, _Pr, _Pj>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_movable<_InIt, _OutIt>);
+            _STL_INTERNAL_CHECK(_First != _Mid);
+            _STL_INTERNAL_CHECK(_Mid != _Last);
+
+            _InIt _Next = _Mid;
+            for (;;) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Next), _STD invoke(_Proj, *_First))) {
+                    *_Dest = _RANGES iter_move(_Next);
+                    ++_Dest;
+                    ++_Next;
+
+                    if (_Next == _Last) {
+                        return _RANGES _Move_unchecked(_STD move(_First), _STD move(_Mid), _STD move(_Dest)).out;
+                    }
+                } else {
+                    *_Dest = _RANGES iter_move(_First);
+                    ++_Dest;
+                    ++_First;
+
+                    if (_First == _Mid) {
+                        return _RANGES _Move_unchecked(_STD move(_Next), _STD move(_Last), _STD move(_Dest)).out;
+                    }
+                }
+            }
+        }
+
+        template <class _It1, class _It2, class _Pr, class _Pj>
+        static void _Chunked_merge_common(_It1 _First, const _It1 _Last, _It2 _Dest, const ptrdiff_t _Chunk_size,
+            ptrdiff_t _Count, _Pr _Pred, _Pj _Proj) {
+            // move merging adjacent chunks of distance _Chunk_size
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It1, _Pr, _Pj>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_movable<_It1, _It2>);
+            _STL_INTERNAL_CHECK(_Last - _First == _Count);
+            _STL_INTERNAL_CHECK(_Chunk_size > 0);
+
+            while (_Chunk_size < _Count) {
+                _Count -= _Chunk_size;
+                const auto _Right_chunk_size = (_STD min) (_Chunk_size, _Count);
+                _Count -= _Right_chunk_size;
+
+                auto _Mid1  = _First + static_cast<iter_difference_t<_It1>>(_Chunk_size);
+                auto _Last1 = _Mid1 + static_cast<iter_difference_t<_It1>>(_Right_chunk_size);
+                _Dest       = _Merge_move_common(_STD move(_First), _STD move(_Mid1), _Last1, _Dest, _Pred, _Proj);
+                _First      = _STD move(_Last1);
+            }
+
+            // copy partial last chunk
+            _RANGES _Move_unchecked(_STD move(_First), _STD move(_Last), _STD move(_Dest));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Stable_sort_fn stable_sort;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_CONSTEXPR20 void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) {
+    // order [_First, _Last) up to _Mid
+    _STD _Adl_verify_range(_First, _Mid);
+    _STD _Adl_verify_range(_Mid, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _UMid  = _STD _Get_unwrapped(_Mid);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+    if (_UFirst == _UMid) {
+        return; // nothing to do, avoid violating _Pop_heap_hole_unchecked preconditions
+    }
+
+    _STD _Make_heap_unchecked(_UFirst, _UMid, _STD _Pass_fn(_Pred));
+    for (auto _UNext = _UMid; _UNext < _ULast; ++_UNext) {
+        if (_DEBUG_LT_PRED(_Pred, *_UNext, *_UFirst)) { // replace top with new largest
+            _Iter_value_t<_RanIt> _Val(_STD move(*_UNext));
+            _STD _Pop_heap_hole_unchecked(_UFirst, _UMid, _UNext, _STD move(_Val), _STD _Pass_fn(_Pred));
+        }
+    }
+
+    _STD _Sort_heap_unchecked(_UFirst, _UMid, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _RanIt>
+_CONSTEXPR20 void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last) {
+    // order [_First, _Last) up to _Mid
+    _STD partial_sort(_First, _Mid, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+void partial_sort(_ExPo&&, _RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // order [_First, _Last) up to _Mid
+    // parallelism suspected to be infeasible
+    _REQUIRE_CPP17_MUTABLE_RANDOM_ACCESS_ITERATOR(_RanIt);
+    return _STD partial_sort(_First, _Mid, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void partial_sort(_ExPo&&, _RanIt _First, _RanIt _Mid, _RanIt _Last) noexcept /* terminates */ {
+    // order [_First, _Last) up to _Mid
+    // parallelism suspected to be infeasible
+    _REQUIRE_CPP17_MUTABLE_RANDOM_ACCESS_ITERATOR(_RanIt);
+    return _STD partial_sort(_First, _Mid, _Last);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Partial_sort_fn {
+    public:
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr _It operator()(_It _First, _It _Mid, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Mid);
+            _STD _Adl_verify_range(_Mid, _Last);
+
+            if constexpr (is_same_v<_It, _Se>) {
+                _Partial_sort_common(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                    _RANGES _Unwrap_iter<_Se>(_STD move(_Mid)), _RANGES _Unwrap_sent<_It>(_Last), _STD _Pass_fn(_Pred),
+                    _STD _Pass_fn(_Proj));
+                return _Last;
+            } else {
+                auto _UMid  = _RANGES _Unwrap_iter<_Se>(_STD move(_Mid));
+                auto _ULast = _RANGES _Get_final_iterator_unwrapped<_It>(_UMid, _STD move(_Last));
+                _STD _Seek_wrapped(_Mid, _ULast);
+                _Partial_sort_common(_RANGES _Unwrap_iter<_Se>(_STD move(_First)), _STD move(_UMid), _STD move(_ULast),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _Mid;
+            }
+        }
+
+        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, iterator_t<_Rng> _Mid, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_RANGES begin(_Range), _Mid);
+            _STD _Adl_verify_range(_Mid, _RANGES end(_Range));
+
+            if constexpr (common_range<_Rng>) {
+                _Partial_sort_common(_Ubegin(_Range), _RANGES _Unwrap_range_iter<_Rng>(_STD move(_Mid)), _Uend(_Range),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _RANGES end(_Range);
+            } else {
+                auto _UMid  = _RANGES _Unwrap_range_iter<_Rng>(_STD move(_Mid));
+                auto _ULast = _RANGES _Get_final_iterator_unwrapped(_Range, _UMid);
+                _STD _Seek_wrapped(_Mid, _ULast);
+                _Partial_sort_common(
+                    _Ubegin(_Range), _STD move(_UMid), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+                return _Mid;
+            }
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        static constexpr void _Partial_sort_common(_It _First, _It _Mid, const _It _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+
+            if (_First == _Mid) {
+                return; // nothing to do
+            }
+
+            _RANGES _Make_heap_common(_First, _Mid, _Pred, _Proj);
+            for (auto _Next = _Mid; _Next != _Last; ++_Next) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Next), _STD invoke(_Proj, *_First))) {
+                    // replace top with new largest
+                    iter_value_t<_It> _Val(_RANGES iter_move(_Next));
+                    _RANGES _Pop_heap_hole_unchecked(_First, _Mid, _Next, _STD move(_Val), _Pred, _Proj, _Proj);
+                }
+            }
+
+            _RANGES _Sort_heap_common(_STD move(_First), _STD move(_Mid), _Pred, _Proj);
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Partial_sort_fn partial_sort;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt, class _RanIt, class _Pr>
+_CONSTEXPR20 _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred) {
+    // copy [_First1, _Last1) into [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    auto _UMid2        = _UFirst2;
+    if (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
+        for (; _UFirst1 != _ULast1 && _UMid2 != _ULast2; ++_UFirst1, (void) ++_UMid2) {
+            *_UMid2 = *_UFirst1; // copy min(_ULast1 - _UFirst1, _ULast2 - _UFirst2)
+        }
+
+        _STD _Make_heap_unchecked(_UFirst2, _UMid2, _STD _Pass_fn(_Pred));
+        for (; _UFirst1 != _ULast1; ++_UFirst1) {
+            if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) {
+                // replace top with new largest:
+                using _Diff = _Iter_diff_t<_RanIt>;
+                _STD _Pop_heap_hole_by_index(_UFirst2, static_cast<_Diff>(0), static_cast<_Diff>(_UMid2 - _UFirst2),
+                    *_UFirst1, _STD _Pass_fn(_Pred));
+            }
+        }
+
+        _STD _Sort_heap_unchecked(_UFirst2, _UMid2, _STD _Pass_fn(_Pred));
+    }
+
+    _STD _Seek_wrapped(_First2, _UMid2);
+    return _First2;
+}
+
+_EXPORT_STD template <class _InIt, class _RanIt>
+_CONSTEXPR20 _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2) {
+    // copy [_First1, _Last1) into [_First2, _Last2)
+    return _STD partial_sort_copy(_First1, _Last1, _First2, _Last2, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_RanIt partial_sort_copy(_ExPo&&, _FwdIt _First1, _FwdIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred) noexcept
+/* terminates */ {
+    // copy [_First1, _Last1) into [_First2, _Last2)
+    // parallelism suspected to be infeasible
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_RanIt);
+    return _STD partial_sort_copy(_First1, _Last1, _First2, _Last2, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_RanIt partial_sort_copy(_ExPo&&, _FwdIt _First1, _FwdIt _Last1, _RanIt _First2, _RanIt _Last2) noexcept
+/* terminates */ {
+    // copy [_First1, _Last1) into [_First2, _Last2)
+    // parallelism suspected to be infeasible
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_RanIt);
+    return _STD partial_sort_copy(_First1, _Last1, _First2, _Last2);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using partial_sort_copy_result = in_out_result<_In, _Out>;
+
+    class _Partial_sort_copy_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, random_access_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_copyable<_It1, _It2> && sortable<_It2, _Pr, _Pj2>
+                  && indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>
+        static constexpr partial_sort_copy_result<_It1, _It2> operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+
+            auto _UResult = _Partial_sort_copy_unchecked(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2)};
+        }
+
+        template <input_range _Rng1, random_access_range _Rng2, class _Pr = ranges::less, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_copyable<iterator_t<_Rng1>, iterator_t<_Rng2>> && sortable<iterator_t<_Rng2>, _Pr, _Pj2>
+                  && indirect_strict_weak_order<_Pr, projected<iterator_t<_Rng1>, _Pj1>,
+                      projected<iterator_t<_Rng2>, _Pj2>>
+        static constexpr partial_sort_copy_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            auto _First   = _RANGES begin(_Range1);
+            auto _UResult = _Partial_sort_copy_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First)),
+                _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            return {_STD move(_First), _RANGES _Rewrap_iterator(_Range2, _STD move(_UResult.out))};
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr partial_sort_copy_result<_It1, _It2> _Partial_sort_copy_unchecked(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_copyable<_It1, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It2, _Pr, _Pj2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>);
+
+            if (_First1 == _Last1 || _First2 == _Last2) {
+                _RANGES advance(_First1, _STD move(_Last1));
+                return {_STD move(_First1), _STD move(_First2)};
+            }
+
+            // copy N = min(distance(_First1, _Last1), distance(_First2, _Last2)) elements
+            auto _Mid2 = _First2;
+            do {
+                *_Mid2 = *_First1;
+                ++_First1;
+                ++_Mid2;
+            } while (_First1 != _Last1 && _Mid2 != _Last2);
+
+            _RANGES _Make_heap_common(_First2, _Mid2, _Pred, _Proj2); // Make a heap
+            for (; _First1 != _Last1; ++_First1) { // Scan the remaining elements...
+                // ... for values less than the largest in the heap ...
+                if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                    // ... to replace the largest, after which we restore the heap invariants.
+                    using _Diff = iter_difference_t<_It2>;
+                    _RANGES _Pop_heap_hole_by_index(_First2, static_cast<_Diff>(0), static_cast<_Diff>(_Mid2 - _First2),
+                        *_First1, _Pred, _Proj2, _Proj1);
+                }
+            }
+
+            // the heap contains the N smallest elements; sort them
+            _RANGES _Sort_heap_common(_STD move(_First2), _Mid2, _Pred, _Proj2);
+            return {_STD move(_First1), _STD move(_Mid2)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Partial_sort_copy_fn partial_sort_copy;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Swap_med5_unchecked(_RanIt _First, _RanIt _Dest, _Pr _Pred) {
+    _RanIt _Guess = _First;
+    ++_Guess;
+    _RanIt _Third = _Guess;
+    ++_Third;
+    _STD _Med3_unchecked(_First, _Guess, _Third, _Pred);
+
+    _RanIt _Fourth = _Third;
+    ++_Fourth;
+    _RanIt _Fifth = _Fourth;
+    ++_Fifth;
+    if (_DEBUG_LT_PRED(_Pred, *_Fifth, *_Fourth)) {
+        swap(*_Fourth, *_Fifth); // intentional ADL
+    }
+
+    // we have _First <= _Guess (second) <= _Third and _Fourth <= _Fifth
+    if (_DEBUG_LT_PRED(_Pred, *_Fifth, *_Guess)) {
+        if (_DEBUG_LT_PRED(_Pred, *_First, *_Fifth)) {
+            _Guess = _Fifth;
+        } else {
+            _Guess = _First;
+        }
+    } else if (_DEBUG_LT_PRED(_Pred, *_Guess, *_Fourth)) {
+        if (_DEBUG_LT_PRED(_Pred, *_Third, *_Fourth)) {
+            _Guess = _Third;
+        } else {
+            _Guess = _Fourth;
+        }
+    }
+
+    swap(*_Dest, *_Guess); // intentional ADL
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Nth_element_median_of_medians(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) {
+    using _Diff = _Iter_diff_t<_RanIt>;
+    for (;;) {
+        const auto _Length = _Last - _First;
+        if (_Length <= _ISORT_MAX) {
+            _STD _Insertion_sort_unchecked(_First, _Last, _Pred); // sort any remainder
+            return;
+        }
+
+        // collect the medians of five at the beginning of the range
+        const _Diff _Median_count = _Length / static_cast<_Diff>(5);
+        const auto _Median_last   = _First + _Median_count;
+        auto _Current             = _First;
+        for (auto _Median_dest = _First; _Median_dest != _Median_last; ++_Median_dest) {
+            _STD _Swap_med5_unchecked(_Current, _Median_dest, _Pred);
+            _Current += static_cast<_Diff>(5);
+        }
+
+        // find the median of medians
+        const auto _Median_mid = _First + (_Median_count >> 1);
+        _STD _Nth_element_median_of_medians(_First, _Median_mid, _Median_last, _Pred);
+
+        // The medians before and after _Median_mid are
+        // less-equal and greater-equal _Median_mid, respectively.
+        // Move the ones after _Median_mid near _Last and then partition
+        // the elements between the medians at front and back by the pivot _Median_mid
+        // so that they do not have to be considered or moved in the partitioning pass.
+        const _Diff _Median_greater_count = (_Median_last - _Median_mid) - 1;
+        const auto _Median_greater_first  = _Last - _Median_greater_count;
+        _STD _Swap_ranges_unchecked(_Median_mid + static_cast<_Diff>(1), _Median_last, _Median_greater_first);
+
+        // Swap the median of medians to the middle
+        // to reduce the number of times it will be moved by the partition function.
+        const auto _Middle = _First + (_Length >> 1);
+        swap(*_Median_mid, *_Middle); // intentional ADL
+
+        const auto _Mid = _STD _Partition_by_pivot_unchecked(_Median_mid, _Middle, _Median_greater_first, _Pred);
+
+        if (_Mid.second <= _Nth) {
+            _First = _Mid.second;
+        } else if (_Mid.first <= _Nth) {
+            return; // _Nth is in the subrange of elements equal to the pivot; done
+        } else {
+            _Last = _Mid.first;
+        }
+    }
+}
+
+template <class _RanIt, class _Pr>
+_CONSTEXPR20 void _Nth_element_unchecked(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) {
+    auto _Ideal = _Last - _First;
+
+    for (;;) {
+        const auto _Length = _Last - _First;
+        if (_Length <= _ISORT_MAX) {
+            _STD _Insertion_sort_unchecked(_First, _Last, _Pred); // sort any remainder
+            return;
+        }
+
+        if (_Ideal < (_Length >> 1)) {
+            // fall back to medians-of-medians-of-five algorithm to guarantee O(n) runtime performance
+            _STD _Nth_element_median_of_medians(_First, _Nth, _Last, _Pred);
+            return;
+        }
+
+        const auto _Mid = _STD _Partition_by_median_guess_unchecked(_First, _Last, _Pred);
+
+        if (_Mid.second <= _Nth) {
+            _First = _Mid.second;
+        } else if (_Mid.first <= _Nth) {
+            return; // _Nth is in the subrange of elements equal to the pivot; done
+        } else {
+            _Last = _Mid.first;
+        }
+
+        // processed range should be reduced by 25% per iteration on average
+        _Ideal = (_Ideal >> 1) + (_Ideal >> 2);
+    }
+}
+
+_EXPORT_STD template <class _RanIt, class _Pr>
+_CONSTEXPR20 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) {
+    // order Nth element
+    _STD _Adl_verify_range(_First, _Nth);
+    _STD _Adl_verify_range(_Nth, _Last);
+    auto _UFirst     = _STD _Get_unwrapped(_First);
+    const auto _UNth = _STD _Get_unwrapped(_Nth);
+    auto _ULast      = _STD _Get_unwrapped(_Last);
+    if (_UNth == _ULast) {
+        return; // nothing to do
+    }
+
+    _STD _Nth_element_unchecked(_UFirst, _UNth, _ULast, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _RanIt>
+_CONSTEXPR20 void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last) { // order Nth element
+    _STD nth_element(_First, _Nth, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+void nth_element(_ExPo&&, _RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // order Nth element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_CPP17_MUTABLE_RANDOM_ACCESS_ITERATOR(_RanIt);
+    _STD nth_element(_First, _Nth, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void nth_element(_ExPo&&, _RanIt _First, _RanIt _Nth, _RanIt _Last) noexcept /* terminates */ {
+    // order Nth element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_CPP17_MUTABLE_RANDOM_ACCESS_ITERATOR(_RanIt);
+    _STD nth_element(_First, _Nth, _Last);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Nth_element_fn {
+    public:
+        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr _It operator()(_It _First, _It _Nth, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Nth);
+            _STD _Adl_verify_range(_Nth, _Last);
+            auto _UNth   = _RANGES _Unwrap_iter<_Se>(_Nth);
+            auto _UFinal = _RANGES _Get_final_iterator_unwrapped<_It>(_UNth, _STD move(_Last));
+            _STD _Seek_wrapped(_Nth, _UFinal);
+
+            _Nth_element_common(_RANGES _Unwrap_iter<_Se>(_STD move(_First)), _STD move(_UNth), _STD move(_UFinal),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _Nth;
+        }
+
+        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, iterator_t<_Rng> _Nth, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_RANGES begin(_Range), _Nth);
+            _STD _Adl_verify_range(_Nth, _RANGES end(_Range));
+            auto _UNth   = _RANGES _Unwrap_range_iter<_Rng>(_Nth);
+            auto _UFinal = [&] {
+                if constexpr (common_range<_Rng>) {
+                    return _Uend(_Range);
+                } else if constexpr (sized_range<_Rng>) {
+                    return _RANGES next(_Ubegin(_Range), _RANGES distance(_Range));
+                } else {
+                    return _RANGES next(_UNth, _Uend(_Range));
+                }
+            }();
+            _STD _Seek_wrapped(_Nth, _UFinal);
+
+            _Nth_element_common(
+                _Ubegin(_Range), _STD move(_UNth), _STD move(_UFinal), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _Nth;
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        static constexpr void _Swap_med5(_It _First, _It _Dest, _Pr _Pred, _Pj _Proj) {
+            _It _Guess = _First;
+            ++_Guess;
+            _It _Third = _Guess;
+            ++_Third;
+            _RANGES _Med3_common(_First, _Guess, _Third, _Pred, _Proj);
+
+            _It _Fourth = _Third;
+            ++_Fourth;
+            _It _Fifth = _Fourth;
+            ++_Fifth;
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Fifth), _STD invoke(_Proj, *_Fourth))) {
+                _RANGES iter_swap(_Fourth, _Fifth);
+            }
+
+            // we have _First <= _Guess (second) <= _Third and _Fourth <= _Fifth
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Fifth), _STD invoke(_Proj, *_Guess))) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Fifth))) {
+                    _Guess = _STD move(_Fifth);
+                } else {
+                    _Guess = _STD move(_First);
+                }
+            } else if (_STD invoke(_Pred, _STD invoke(_Proj, *_Guess), _STD invoke(_Proj, *_Fourth))) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Third), _STD invoke(_Proj, *_Fourth))) {
+                    _Guess = _STD move(_Third);
+                } else {
+                    _Guess = _STD move(_Fourth);
+                }
+            }
+
+            _RANGES iter_swap(_Dest, _Guess);
+        }
+
+        template <class _It, class _Pr, class _Pj>
+        static constexpr void _Nth_element_median_of_medians_unchecked(
+            _It _First, _It _Nth, _It _Last, _Pr _Pred, _Pj _Proj) {
+
+            using _Diff = iter_difference_t<_It>;
+            for (;;) {
+                const auto _Length = _Last - _First;
+                if (_Length <= _ISORT_MAX) {
+                    // sort any remainder
+                    _RANGES _Insertion_sort_common(_STD move(_First), _STD move(_Last), _Pred, _Proj);
+                    return;
+                }
+
+                // collect the medians of five at the beginning of the range
+                const _Diff _Median_count = _Length / static_cast<_Diff>(5);
+                auto _Median_last         = _First + _Median_count;
+                auto _Current             = _First;
+                for (auto _Median_dest = _First; _Median_dest != _Median_last; ++_Median_dest) {
+                    _Swap_med5(_Current, _Median_dest, _Pred, _Proj);
+                    _Current += static_cast<_Diff>(5);
+                }
+
+                // find the median of medians
+                auto _Median_mid = _First + (_Median_count >> 1);
+                _Nth_element_median_of_medians_unchecked(_First, _Median_mid, _Median_last, _Pred, _Proj);
+
+                // The medians before and after _Median_mid are
+                // less-equal and greater-equal _Median_mid, respectively.
+                // Move the ones after _Median_mid near _Last and then partition
+                // the elements between the medians at front and back by the pivot _Median_mid
+                // so that they do not have to be considered or moved in the partitioning pass.
+                const _Diff _Median_greater_count = (_Median_last - _Median_mid) - 1;
+                auto _Median_greater_first        = _Last - _Median_greater_count;
+                (void) _RANGES _Swap_ranges_common(
+                    _Median_mid + static_cast<_Diff>(1), _STD move(_Median_last), _Median_greater_first, _Last);
+
+                // Swap the median of medians to the middle
+                // to reduce the number of times it will be moved by the partition function.
+                auto _Middle = _First + (_Length >> 1);
+                _RANGES iter_swap(_Median_mid, _Middle);
+
+                const subrange<_It> _Mid = _RANGES _Partition_by_pivot_common(
+                    _STD move(_Median_mid), _STD move(_Middle), _STD move(_Median_greater_first), _Pred, _Proj);
+
+                if (_Mid.end() <= _Nth) {
+                    _First = _Mid.end();
+                } else if (_Mid.begin() <= _Nth) {
+                    return; // _Nth is in the subrange of elements equal to the pivot; done
+                } else {
+                    _Last = _Mid.begin();
+                }
+            }
+        }
+
+        template <class _It, class _Pr, class _Pj>
+        static constexpr void _Nth_element_common(_It _First, _It _Nth, _It _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+
+            if (_Nth == _Last) {
+                return; // nothing to do
+            }
+
+            auto _Ideal = _Last - _First;
+
+            for (;;) {
+                const auto _Length = _Last - _First;
+                if (_Length <= _ISORT_MAX) {
+                    // sort any remainder
+                    _RANGES _Insertion_sort_common(_STD move(_First), _STD move(_Last), _Pred, _Proj);
+                    return;
+                }
+
+                if (_Ideal < (_Length >> 1)) {
+                    // fall back to medians-of-medians-of-five algorithm to guarantee O(n) runtime performance
+                    _Nth_element_median_of_medians_unchecked(
+                        _STD move(_First), _STD move(_Nth), _STD move(_Last), _Pred, _Proj);
+                    return;
+                }
+
+                const subrange<_It> _Mid = _RANGES _Partition_by_median_guess_common(_First, _Last, _Pred, _Proj);
+
+                if (_Mid.end() <= _Nth) {
+                    _First = _Mid.end();
+                } else if (_Mid.begin() <= _Nth) {
+                    return; // _Nth is in the subrange of elements equal to the pivot; done
+                } else {
+                    _Last = _Mid.begin();
+                }
+
+                // processed range should be reduced by 25% per iteration on average
+                _Ideal = (_Ideal >> 1) + (_Ideal >> 2);
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Nth_element_fn nth_element;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool includes(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred) {
+    // test if every element in sorted [_First2, _Last2) is in sorted [_First1, _Last1)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt2, _UFirst1, _ULast1, _Pred);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt1, _UFirst2, _ULast2, _Pred);
+
+    if (_UFirst2 == _ULast2) {
+        return true;
+    } else if (_UFirst1 == _ULast1) {
+        return false;
+    }
+
+#if _VECTORIZED_INCLUDES
+    if constexpr (_Vector_alg_includes_iterators_safe<_InIt1, _InIt2> && _Is_predicate_less<_InIt1, _Pr>) {
+        if (!_STD _Is_constant_evaluated()) {
+            return _STD _Includes_vectorized(_STD _To_address(_First1), _STD _To_address(_Last1),
+                _STD _To_address(_First2), _STD _To_address(_Last2));
+        }
+    }
+#endif // ^^^ _VECTORIZED_INCLUDES ^^^
+
+    for (;;) {
+        if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) {
+            ++_UFirst1;
+            if (_UFirst1 == _ULast1) {
+                return false;
+            }
+        } else if (_Pred(*_UFirst2, *_UFirst1)) {
+            return false;
+        } else {
+            ++_UFirst1;
+            ++_UFirst2;
+            if (_UFirst2 == _ULast2) {
+                return true;
+            } else if (_UFirst1 == _ULast1) {
+                return false;
+            }
+        }
+    }
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 bool includes(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
+    // test if every element in sorted [_First2, _Last2) is in sorted [_First1, _Last1)
+    return _STD includes(_First1, _Last1, _First2, _Last2, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool includes(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept
+/* terminates */ {
+    // test if every element in sorted [_First2, _Last2) is in sorted [_First1, _Last1)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    return _STD includes(_First1, _Last1, _First2, _Last2, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool includes(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept
+/* terminates */ {
+    // test if every element in sorted [_First2, _Last2) is in sorted [_First1, _Last1)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    return _STD includes(_First1, _Last1, _First2, _Last2);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Includes_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pj1 = identity, class _Pj2 = identity,
+            indirect_strict_weak_order<projected<_It1, _Pj1>, projected<_It2, _Pj2>> _Pr = ranges::less>
+        _NODISCARD static constexpr bool operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            return _Includes_unchecked(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+        }
+
+        template <input_range _Rng1, input_range _Rng2, class _Pj1 = identity, class _Pj2 = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng1>, _Pj1>, projected<iterator_t<_Rng2>, _Pj2>> _Pr =
+                ranges::less>
+        _NODISCARD static constexpr bool operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            return _Includes_unchecked(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Includes_unchecked(
+            _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>);
+
+            if (_First2 == _Last2) {
+                return true;
+            } else if (_First1 == _Last1) {
+                return false;
+            }
+
+#if _VECTORIZED_INCLUDES
+            if constexpr (_Vector_alg_includes_iterators_safe<_It1, _It2> && _Is_predicate_less<_It1, _Pr>
+                          && sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>
+                          && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _First1_ptr = _STD to_address(_First1);
+                    const auto _First2_ptr = _STD to_address(_First2);
+                    const auto _Last1_ptr  = _STD to_address(_First1 + (_Last1 - _First1));
+                    const auto _Last2_ptr  = _STD to_address(_First2 + (_Last2 - _First2));
+                    return _STD _Includes_vectorized(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr);
+                }
+            }
+#endif // ^^^ _VECTORIZED_INCLUDES ^^^
+
+            for (;;) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                    ++_First1;
+                    if (_First1 == _Last1) {
+                        return false;
+                    }
+                } else if (_STD invoke(_Pred, _STD invoke(_Proj2, *_First2), _STD invoke(_Proj1, *_First1))) {
+                    return false;
+                } else {
+                    ++_First1;
+                    ++_First2;
+                    if (_First2 == _Last2) {
+                        return true;
+                    } else if (_First1 == _Last1) {
+                        return false;
+                    }
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Includes_fn includes;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
+    // OR sets [_First1, _Last1) and [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt2, _UFirst1, _ULast1, _Pred);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt1, _UFirst2, _ULast2, _Pred);
+    auto _UDest = _STD _Get_unwrapped_unverified(_Dest);
+    for (; _UFirst1 != _ULast1 && _UFirst2 != _ULast2; ++_UDest) {
+        if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) { // copy first
+            *_UDest = *_UFirst1;
+            ++_UFirst1;
+        } else if (_Pred(*_UFirst2, *_UFirst1)) { // copy second
+            *_UDest = *_UFirst2;
+            ++_UFirst2;
+        } else { // advance both
+            *_UDest = *_UFirst1;
+            ++_UFirst1;
+            ++_UFirst2;
+        }
+    }
+
+    _UDest = _STD _Copy_unchecked(_UFirst1, _ULast1, _UDest);
+    _STD _Seek_wrapped(_Dest, _STD _Copy_unchecked(_UFirst2, _ULast2, _UDest));
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
+_CONSTEXPR20 _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
+    // OR sets [_First1, _Last1) and [_First2, _Last2)
+    return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 set_union(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
+    _Pr _Pred) noexcept /* terminates */ {
+    // OR sets [_First1, _Last1) and [_First2, _Last2)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 set_union(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest) noexcept
+/* terminates */ {
+    // OR sets [_First1, _Last1) and [_First2, _Last2)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    return _STD set_union(_First1, _Last1, _First2, _Last2, _Dest);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
+    using set_union_result = in_in_out_result<_In1, _In2, _Out>;
+
+    class _Set_union_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr set_union_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
+            _Se2 _Last2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UResult = _Set_union_unchecked(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Get_unwrapped_unverified(_STD move(_Output)),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
+            class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr set_union_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            auto _First1  = _RANGES begin(_Range1);
+            auto _First2  = _RANGES begin(_Range2);
+            auto _UResult = _Set_union_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)), _Uend(_Range1),
+                _RANGES _Unwrap_range_iter<_Rng2>(_STD move(_First2)), _Uend(_Range2),
+                _STD _Get_unwrapped_unverified(_STD move(_Output)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr set_union_result<_It1, _It2, _Out> _Set_union_unchecked(_It1 _First1,
+            const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Out _Output, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>);
+
+            for (; _First1 != _Last1 && _First2 != _Last2; ++_Output) {
+                if (_STD invoke(_Pred, _STD invoke(_Proj2, *_First2), _STD invoke(_Proj1, *_First1))) {
+                    *_Output = *_First2;
+                    ++_First2;
+                } else {
+                    *_Output = *_First1;
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                        ++_First2;
+                    }
+                    ++_First1;
+                }
+            }
+
+            auto _UResult1 = _RANGES _Copy_unchecked(_STD move(_First1), _STD move(_Last1), _STD move(_Output));
+            auto _UResult2 = _RANGES _Copy_unchecked(_STD move(_First2), _STD move(_Last2), _STD move(_UResult1.out));
+            return {_STD move(_UResult1.in), _STD move(_UResult2.in), _STD move(_UResult2.out)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Set_union_fn set_union;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_CONSTEXPR20 _OutIt set_intersection(
+    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
+    // AND sets [_First1, _Last1) and [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt2, _UFirst1, _ULast1, _Pred);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt1, _UFirst2, _ULast2, _Pred);
+    auto _UDest = _STD _Get_unwrapped_unverified(_Dest);
+    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
+        if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) {
+            ++_UFirst1;
+        } else if (_Pred(*_UFirst2, *_UFirst1)) {
+            ++_UFirst2;
+        } else {
+            *_UDest = *_UFirst1;
+            ++_UDest;
+            ++_UFirst1;
+            ++_UFirst2;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
+_CONSTEXPR20 _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
+    // AND sets [_First1, _Last1) and [_First2, _Last2)
+    return _STD set_intersection(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 set_intersection(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
+    _Pr _Pred) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 set_intersection(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
+    _FwdIt3 _Dest) noexcept /* terminates */ {
+    // AND sets [_First1, _Last1) and [_First2, _Last2)
+    return _STD set_intersection(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, _Dest, less{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
+    using set_intersection_result = in_in_out_result<_In1, _In2, _Out>;
+
+    class _Set_intersection_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr set_intersection_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
+            _Se2 _Last2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UResult = _Set_intersection_unchecked(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Get_unwrapped_unverified(_STD move(_Output)),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
+            class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr set_intersection_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out>
+            operator()(
+                _Rng1&& _Range1, _Rng2&& _Range2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            auto _First1  = _RANGES begin(_Range1);
+            auto _First2  = _RANGES begin(_Range2);
+            auto _UResult = _Set_intersection_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                _Uend(_Range1), _RANGES _Unwrap_range_iter<_Rng2>(_STD move(_First2)), _Uend(_Range2),
+                _STD _Get_unwrapped_unverified(_STD move(_Output)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr set_intersection_result<_It1, _It2, _Out> _Set_intersection_unchecked(_It1 _First1,
+            const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Out _Output, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>);
+
+            for (;;) {
+                if (_First1 == _Last1) {
+                    _RANGES advance(_First2, _Last2);
+                    break;
+                } else if (_First2 == _Last2) {
+                    _RANGES advance(_First1, _Last1);
+                    break;
+                }
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                    ++_First1;
+                } else if (_STD invoke(_Pred, _STD invoke(_Proj2, *_First2), _STD invoke(_Proj1, *_First1))) {
+                    ++_First2;
+                } else {
+                    *_Output = *_First1;
+                    ++_Output;
+                    ++_First1;
+                    ++_First2;
+                }
+            }
+
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Set_intersection_fn set_intersection;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_CONSTEXPR20 _OutIt set_difference(
+    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
+    // take set [_First2, _Last2) from [_First1, _Last1)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt2, _UFirst1, _ULast1, _Pred);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt1, _UFirst2, _ULast2, _Pred);
+    auto _UDest = _STD _Get_unwrapped_unverified(_Dest);
+    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
+        if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) { // copy first
+            *_UDest = *_UFirst1;
+            ++_UDest;
+            ++_UFirst1;
+        } else {
+            if (!_Pred(*_UFirst2, *_UFirst1)) {
+                ++_UFirst1;
+            }
+
+            ++_UFirst2;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _STD _Copy_unchecked(_UFirst1, _ULast1, _UDest));
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
+_CONSTEXPR20 _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
+    // take set [_First2, _Last2) from [_First1, _Last1)
+    return _STD set_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 set_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
+    _Pr _Pred) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 set_difference(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
+    _FwdIt3 _Dest) noexcept /* terminates */ {
+    // take set [_First2, _Last2) from [_First1, _Last1)
+    return _STD set_difference(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, _Dest, less{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using set_difference_result = in_out_result<_In, _Out>;
+
+    class _Set_difference_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr set_difference_result<_It1, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
+            _Se2 _Last2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UResult = _Set_difference_unchecked(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Get_unwrapped_unverified(_STD move(_Output)),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_Output)};
+        }
+
+        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
+            class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr set_difference_result<borrowed_iterator_t<_Rng1>, _Out> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            auto _First1  = _RANGES begin(_Range1);
+            auto _UResult = _Set_difference_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2), _STD _Get_unwrapped_unverified(_STD move(_Output)),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr set_difference_result<_It1, _Out> _Set_difference_unchecked(_It1 _First1,
+            const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Out _Output, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>);
+
+            for (;;) {
+                if (_First1 == _Last1) {
+                    return {_STD move(_First1), _STD move(_Output)};
+                }
+
+                if (_First2 == _Last2) {
+                    return _RANGES _Copy_unchecked(_STD move(_First1), _STD move(_Last1), _STD move(_Output));
+                }
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                    *_Output = *_First1;
+                    ++_Output;
+                    ++_First1;
+                } else {
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj2, *_First2), _STD invoke(_Proj1, *_First1))) {
+                        ++_First1;
+                    }
+
+                    ++_First2;
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Set_difference_fn set_difference;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
+_CONSTEXPR20 _OutIt set_symmetric_difference(
+    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
+    // XOR sets [_First1, _Last1) and [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt2, _UFirst1, _ULast1, _Pred);
+    _DEBUG_ORDER_SET_UNWRAPPED(_InIt1, _UFirst2, _ULast2, _Pred);
+    auto _UDest = _STD _Get_unwrapped_unverified(_Dest);
+    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
+        if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) { // copy first
+            *_UDest = *_UFirst1;
+            ++_UDest;
+            ++_UFirst1;
+        } else if (_Pred(*_UFirst2, *_UFirst1)) { // copy second
+            *_UDest = *_UFirst2;
+            ++_UDest;
+            ++_UFirst2;
+        } else { // advance both
+            ++_UFirst1;
+            ++_UFirst2;
+        }
+    }
+
+    _UDest = _STD _Copy_unchecked(_UFirst1, _ULast1, _UDest);
+    _STD _Seek_wrapped(_Dest, _STD _Copy_unchecked(_UFirst2, _ULast2, _UDest));
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt>
+_CONSTEXPR20 _OutIt set_symmetric_difference(
+    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
+    // XOR sets [_First1, _Last1) and [_First2, _Last2)
+    return _STD set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 set_symmetric_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
+    _FwdIt3 _Dest, _Pr _Pred) noexcept /* terminates */ {
+    // XOR sets [_First1, _Last1) and [_First2, _Last2)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    return _STD set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt3 set_symmetric_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
+    _FwdIt3 _Dest) noexcept /* terminates */ {
+    // XOR sets [_First1, _Last1) and [_First2, _Last2)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    return _STD set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In1, class _In2, class _Out>
+    using set_symmetric_difference_result = in_in_out_result<_In1, _In2, _Out>;
+
+    class _Set_symmetric_difference_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr set_symmetric_difference_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1,
+            _It2 _First2, _Se2 _Last2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UResult = _Set_symmetric_difference_unchecked(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Get_unwrapped_unverified(_STD move(_Output)),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
+            class _Pj1 = identity, class _Pj2 = identity>
+            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
+        static constexpr set_symmetric_difference_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out>
+            operator()(
+                _Rng1&& _Range1, _Rng2&& _Range2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            auto _First1  = _RANGES begin(_Range1);
+            auto _First2  = _RANGES begin(_Range2);
+            auto _UResult = _Set_symmetric_difference_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                _Uend(_Range1), _RANGES _Unwrap_range_iter<_Rng2>(_STD move(_First2)), _Uend(_Range2),
+                _STD _Get_unwrapped_unverified(_STD move(_Output)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in1));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.in2));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2), _STD move(_Output)};
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr set_symmetric_difference_result<_It1, _It2, _Out>
+            _Set_symmetric_difference_unchecked(_It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2,
+                _Out _Output, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>);
+
+            for (;;) {
+                if (_First1 == _Last1) {
+                    auto _UResult = _RANGES _Copy_unchecked(_STD move(_First2), _STD move(_Last2), _STD move(_Output));
+                    return {_STD move(_First1), _STD move(_UResult.in), _STD move(_UResult.out)};
+                }
+
+                if (_First2 == _Last2) {
+                    auto _UResult = _RANGES _Copy_unchecked(_STD move(_First1), _STD move(_Last1), _STD move(_Output));
+                    return {_STD move(_UResult.in), _STD move(_First2), _STD move(_UResult.out)};
+                }
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                    *_Output = *_First1;
+                    ++_Output;
+                    ++_First1;
+                } else if (_STD invoke(_Pred, _STD invoke(_Proj2, *_First2), _STD invoke(_Proj1, *_First1))) {
+                    *_Output = *_First2;
+                    ++_Output;
+                    ++_First2;
+                } else {
+                    ++_First1;
+                    ++_First2;
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Set_symmetric_difference_fn set_symmetric_difference;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+template <class _FwdIt, class _Pr>
+constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+#if _VECTORIZED_MINMAX_ELEMENT
+    if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            const auto _First_ptr = _STD _To_address(_First);
+            const auto _Result    = _STD _Minmax_element_vectorized(_First_ptr, _STD _To_address(_Last));
+            if constexpr (is_pointer_v<_FwdIt>) {
+                return _Result;
+            } else {
+                return {_First + static_cast<_Iter_diff_t<_FwdIt>>(_Result.first - _First_ptr),
+                    _First + static_cast<_Iter_diff_t<_FwdIt>>(_Result.second - _First_ptr)};
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+    // find smallest and largest elements
+    pair<_FwdIt, _FwdIt> _Found(_First, _First);
+
+    if (_First != _Last) {
+        while (++_First != _Last) { // process one or two elements
+            _FwdIt _Next = _First;
+            if (++_Next == _Last) { // process last element
+                if (_DEBUG_LT_PRED(_Pred, *_First, *_Found.first)) {
+                    _Found.first = _First;
+                } else if (!_DEBUG_LT_PRED(_Pred, *_First, *_Found.second)) {
+                    _Found.second = _First;
+                }
+            } else { // process next two elements
+                if (_DEBUG_LT_PRED(_Pred, *_Next, *_First)) { // test _Next for new smallest
+                    if (_DEBUG_LT_PRED(_Pred, *_Next, *_Found.first)) {
+                        _Found.first = _Next;
+                    }
+
+                    if (!_DEBUG_LT_PRED(_Pred, *_First, *_Found.second)) {
+                        _Found.second = _First;
+                    }
+                } else { // test _First for new smallest
+                    if (_DEBUG_LT_PRED(_Pred, *_First, *_Found.first)) {
+                        _Found.first = _First;
+                    }
+
+                    if (!_DEBUG_LT_PRED(_Pred, *_Next, *_Found.second)) {
+                        _Found.second = _Next;
+                    }
+                }
+                _First = _Next;
+            }
+        }
+    }
+
+    return _Found;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD constexpr pair<_FwdIt, _FwdIt> minmax_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+    // find smallest and largest elements
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _Result =
+        _STD _Minmax_element_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred));
+    _STD _Seek_wrapped(_Last, _Result.second);
+    _STD _Seek_wrapped(_First, _Result.first);
+    return {_First, _Last};
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD constexpr pair<_FwdIt, _FwdIt> minmax_element(_FwdIt _First, _FwdIt _Last) {
+    // find smallest and largest elements
+    return _STD minmax_element(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD pair<_FwdIt, _FwdIt> minmax_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept
+/* terminates */ {
+    // find smallest and largest elements
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD minmax_element(_First, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD pair<_FwdIt, _FwdIt> minmax_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
+    // find smallest and largest elements
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD minmax_element(_First, _Last);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _Ty>
+    using minmax_element_result = min_max_result<_Ty>;
+
+    class _Minmax_element_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr minmax_element_result<_It> operator()(
+            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Minmax_element_fwd_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.min));
+            auto _Second = _First;
+            _STD _Seek_wrapped(_Second, _STD move(_UResult.max));
+            return {_STD move(_First), _STD move(_Second)};
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr minmax_element_result<borrowed_iterator_t<_Rng>> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UResult = _Minmax_element_fwd_unchecked(
+                _RANGES _Ubegin(_Range), _RANGES _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return {_RANGES _Rewrap_iterator(_Range, _STD move(_UResult.min)),
+                _RANGES _Rewrap_iterator(_Range, _STD move(_UResult.max))};
+        }
+
+    private:
+        template <class _It, class _Se, class _Pr, class _Pj>
+        _NODISCARD static constexpr min_max_result<_It> _Minmax_element_fwd_unchecked(
+            _It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>);
+
+#if _VECTORIZED_MINMAX_ELEMENT
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
+                          && sized_sentinel_for<_Se, _It>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _First_ptr = _STD to_address(_First);
+                    const auto _Last_ptr  = _STD to_address(_First + (_Last - _First));
+                    const auto _Result    = _STD _Minmax_element_vectorized(_First_ptr, _Last_ptr);
+                    if constexpr (is_pointer_v<_It>) {
+                        return {_Result.first, _Result.second};
+                    } else {
+                        return {_First + static_cast<iter_difference_t<_It>>(_Result.first - _First_ptr),
+                            _First + static_cast<iter_difference_t<_It>>(_Result.second - _First_ptr)};
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+            min_max_result<_It> _Found{_First, _First};
+
+            if (_First == _Last) {
+                return _Found;
+            }
+
+            while (++_First != _Last) { // process one or two elements
+                _It _Prev = _First;
+                if (++_First == _Last) { // process last element
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_Prev), _STD invoke(_Proj, *_Found.min))) {
+                        _Found.min = _Prev;
+                    } else if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Prev), _STD invoke(_Proj, *_Found.max))) {
+                        _Found.max = _Prev;
+                    }
+
+                    break;
+                }
+
+                // process next two elements
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Prev))) {
+                    // test _First for new smallest
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Found.min))) {
+                        _Found.min = _First;
+                    }
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Prev), _STD invoke(_Proj, *_Found.max))) {
+                        _Found.max = _Prev;
+                    }
+                } else { // test _Prev for new smallest
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_Prev), _STD invoke(_Proj, *_Found.min))) {
+                        _Found.min = _Prev;
+                    }
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Found.max))) {
+                        _Found.max = _First;
+                    }
+                }
+            }
+
+            return _Found;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Minmax_element_fn minmax_element;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr pair<const _Ty&, const _Ty&> minmax(
+    const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred)
+    noexcept(noexcept(_DEBUG_LT_PRED(_Pred, _Right, _Left))) /* strengthened */ {
+    // return pair(leftmost/smaller, rightmost/larger) of _Left and _Right
+    if (_DEBUG_LT_PRED(_Pred, _Right, _Left)) {
+        return {_Right, _Left};
+    }
+
+    return {_Left, _Right};
+}
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist, _Pr _Pred) {
+    // return {leftmost/smallest, rightmost/largest}
+    _STL_ASSERT(
+        _Ilist.size() != 0, "An initializer_list passed to std::minmax must not be empty. (N4971 [alg.min.max]/21)");
+#if _VECTORIZED_MINMAX
+    if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+        if (!_STD _Is_constant_evaluated()) {
+            const auto _Result = _STD _Minmax_vectorized(_Ilist.begin(), _Ilist.end());
+            return {static_cast<_Ty>(_Result._Min), static_cast<_Ty>(_Result._Max)};
+        }
+    }
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+    pair<const _Ty*, const _Ty*> _Res =
+        _STD _Minmax_element_unchecked(_Ilist.begin(), _Ilist.end(), _STD _Pass_fn(_Pred));
+    return pair<_Ty, _Ty>(*_Res.first, *_Res.second);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr pair<const _Ty&, const _Ty&> minmax(const _Ty& _Left _MSVC_LIFETIMEBOUND,
+    const _Ty& _Right _MSVC_LIFETIMEBOUND) noexcept(noexcept(_Right < _Left)) /* strengthened */ {
+    // return pair(leftmost/smaller, rightmost/larger) of _Left and _Right
+    if (_Right < _Left) {
+        _STL_ASSERT(!(_Left < _Right), "invalid comparator");
+        return {_Right, _Left};
+    }
+
+    return {_Left, _Right};
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist) {
+    // return {leftmost/smallest, rightmost/largest}
+    return _STD minmax(_Ilist, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _Ty>
+    using minmax_result = min_max_result<_Ty>;
+
+    class _Minmax_fn {
+    public:
+        template <class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr minmax_result<const _Ty&> operator()(const _Ty& _Left _MSVC_LIFETIMEBOUND,
+            const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred = {}, _Pj _Proj = {}) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, _Right), _STD invoke(_Proj, _Left))) {
+                return {_Right, _Left};
+            } else {
+                return {_Left, _Right};
+            }
+        }
+
+        template <copyable _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr minmax_result<_Ty> operator()(
+            initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _First = _Range.begin();
+            const auto _Last  = _Range.end();
+            _STL_ASSERT(_First != _Last,
+                "An initializer_list passed to std::ranges::minmax must not be empty. (N4971 [alg.min.max]/21)");
+
+#if _VECTORIZED_MINMAX || _VECTORIZED_MINMAX_ELEMENT
+            if constexpr (is_same_v<_Pj, identity>) {
+#if _VECTORIZED_MINMAX
+                if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+                    if (!_STD is_constant_evaluated()) {
+                        const auto _Result = _STD _Minmax_vectorized(_First, _Last);
+                        return {static_cast<_Ty>(_Result._Min), static_cast<_Ty>(_Result._Max)};
+                    }
+                } else
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+                {
+#if _VECTORIZED_MINMAX_ELEMENT
+                    if constexpr (_Is_min_max_optimization_safe<const _Ty*, _Pr>) {
+                        if (!_STD is_constant_evaluated()) {
+                            const auto _Result = _STD _Minmax_element_vectorized(_First, _Last);
+                            return {*static_cast<const _Ty*>(_Result.first), *static_cast<const _Ty*>(_Result.second)};
+                        }
+                    }
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+                }
+            }
+#endif // ^^^ _VECTORIZED_MINMAX || _VECTORIZED_MINMAX_ELEMENT ^^^
+
+            return _Minmax_fwd_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+            requires indirectly_copyable_storable<iterator_t<_Rng>, range_value_t<_Rng>*>
+        _NODISCARD static constexpr minmax_result<range_value_t<_Rng>> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UFirst = _RANGES _Ubegin(_Range);
+            auto _ULast  = _RANGES _Uend(_Range);
+            _STL_ASSERT(
+                _UFirst != _ULast, "A range passed to std::ranges::minmax must not be empty. (N4971 [alg.min.max]/21)");
+            using _Vty = range_value_t<_Rng>;
+
+#if _VECTORIZED_MINMAX || _VECTORIZED_MINMAX_ELEMENT
+            if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
+#if _VECTORIZED_MINMAX
+                if constexpr (_Is_min_max_value_optimization_safe<decltype(_UFirst), _Pr>) {
+                    if (!_STD is_constant_evaluated()) {
+                        const auto _First_ptr = _STD to_address(_UFirst);
+                        const auto _Last_ptr  = _STD to_address(_UFirst + (_ULast - _UFirst));
+                        const auto _Result    = _STD _Minmax_vectorized(_First_ptr, _Last_ptr);
+                        return {static_cast<_Vty>(_Result._Min), static_cast<_Vty>(_Result._Max)};
+                    }
+                } else
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+                {
+#if _VECTORIZED_MINMAX_ELEMENT
+                    if constexpr (_Is_min_max_optimization_safe<decltype(_UFirst), _Pr>) {
+                        if (!_STD is_constant_evaluated()) {
+                            const auto _First_ptr = _STD to_address(_UFirst);
+                            const auto _Last_ptr  = _STD to_address(_UFirst + (_ULast - _UFirst));
+                            const auto _Result    = _STD _Minmax_element_vectorized(_First_ptr, _Last_ptr);
+                            return {
+                                *static_cast<const _Vty*>(_Result.first), *static_cast<const _Vty*>(_Result.second)};
+                        }
+                    }
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+                }
+            }
+#endif // ^^^ _VECTORIZED_MINMAX || _VECTORIZED_MINMAX_ELEMENT ^^^
+
+            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<decltype(_UFirst)>) {
+                return _Minmax_fwd_unchecked(
+                    _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            } else {
+                // This initialization is correct, similar to the N4950 [dcl.init.aggr]/6 example
+                minmax_result<_Vty> _Found = {static_cast<_Vty>(*_UFirst), _Found.min};
+                if (_UFirst == _ULast) {
+                    return _Found;
+                }
+
+                while (++_UFirst != _ULast) { // process one or two elements
+                    _Vty _Prev(*_UFirst);
+                    if (++_UFirst == _ULast) { // process last element
+                        if (_STD invoke(_Pred, _STD invoke(_Proj, _Prev), _STD invoke(_Proj, _Found.min))) {
+                            _Found.min = _STD move(_Prev);
+                        } else if (!_STD invoke(_Pred, _STD invoke(_Proj, _Prev), _STD invoke(_Proj, _Found.max))) {
+                            _Found.max = _STD move(_Prev);
+                        }
+
+                        break;
+                    }
+
+                    // process next two elements
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_UFirst), _STD invoke(_Proj, _Prev))) {
+                        // test _UFirst for new smallest
+                        if (_STD invoke(_Pred, _STD invoke(_Proj, *_UFirst), _STD invoke(_Proj, _Found.min))) {
+                            _Found.min = *_UFirst;
+                        }
+
+                        if (!_STD invoke(_Pred, _STD invoke(_Proj, _Prev), _STD invoke(_Proj, _Found.max))) {
+                            _Found.max = _STD move(_Prev);
+                        }
+                    } else { // test _Prev for new smallest
+                        if (_STD invoke(_Pred, _STD invoke(_Proj, _Prev), _STD invoke(_Proj, _Found.min))) {
+                            _Found.min = _STD move(_Prev);
+                        }
+
+                        if (!_STD invoke(_Pred, _STD invoke(_Proj, *_UFirst), _STD invoke(_Proj, _Found.max))) {
+                            _Found.max = *_UFirst;
+                        }
+                    }
+                }
+
+                return _Found;
+            }
+        }
+
+    private:
+        template <class _It, class _Se, class _Pr, class _Pj>
+        _NODISCARD static constexpr minmax_result<iter_value_t<_It>> _Minmax_fwd_unchecked(
+            _It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>);
+
+            _STL_INTERNAL_CHECK(_First != _Last);
+
+            using _Vty = iter_value_t<_It>;
+
+            auto _Found_min = _First;
+            if (++_First == _Last) {
+                // This initialization is correct, similar to the N4950 [dcl.init.aggr]/6 example
+                minmax_result<_Vty> _Result = {static_cast<_Vty>(*_Found_min), _Result.min};
+                return _Result;
+            }
+
+            auto _Found_max = _First;
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Found_max), _STD invoke(_Proj, *_Found_min))) {
+                _RANGES swap(_Found_min, _Found_max);
+            }
+
+            while (++_First != _Last) { // process one or two elements
+                _It _Prev = _First;
+                if (++_First == _Last) { // process last element
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_Prev), _STD invoke(_Proj, *_Found_min))) {
+                        _Found_min = _Prev;
+                    } else if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Prev), _STD invoke(_Proj, *_Found_max))) {
+                        _Found_max = _Prev;
+                    }
+
+                    break;
+                }
+
+                // process two elements
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Prev))) {
+                    // test _First for new smallest
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Found_min))) {
+                        _Found_min = _First;
+                    }
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj, *_Prev), _STD invoke(_Proj, *_Found_max))) {
+                        _Found_max = _Prev;
+                    }
+                } else { // test _Prev for new smallest
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_Prev), _STD invoke(_Proj, *_Found_min))) {
+                        _Found_min = _Prev;
+                    }
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Found_max))) {
+                        _Found_max = _First;
+                    }
+                }
+            }
+
+            return {static_cast<_Vty>(*_Found_min), static_cast<_Vty>(*_Found_max)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Minmax_fn minmax;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _BidIt, class _Pr>
+_CONSTEXPR20 bool next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred) {
+    // permute and test for pure ascending
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UNext       = _ULast;
+    if (_UFirst == _ULast || _UFirst == --_UNext) {
+        return false;
+    }
+
+    for (;;) { // find rightmost element smaller than successor
+        auto _UNext1 = _UNext;
+        if (_DEBUG_LT_PRED(_Pred, *--_UNext, *_UNext1)) { // swap with rightmost element that's smaller, flip suffix
+            auto _UMid = _ULast;
+            do {
+                --_UMid;
+            } while (!_DEBUG_LT_PRED(_Pred, *_UNext, *_UMid));
+
+            swap(*_UNext, *_UMid); // intentional ADL
+            _STD reverse(_UNext1, _ULast);
+            return true;
+        }
+
+        if (_UNext == _UFirst) { // pure descending, flip all
+            _STD reverse(_UFirst, _ULast);
+            return false;
+        }
+    }
+}
+
+_EXPORT_STD template <class _BidIt>
+_CONSTEXPR20 bool next_permutation(_BidIt _First, _BidIt _Last) {
+    // permute and test for pure ascending
+    return _STD next_permutation(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In>
+    using next_permutation_result = in_found_result<_In>;
+
+    class _Next_permutation_fn {
+    public:
+        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr next_permutation_result<_It> operator()(
+            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            const bool _Found = _Next_permutation_common(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return {_STD move(_First), _Found};
+        }
+
+        template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr next_permutation_result<borrowed_iterator_t<_Rng>> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _ULast = _RANGES _Get_final_iterator_unwrapped(_Range);
+            const bool _Found =
+                _Next_permutation_common(_Ubegin(_Range), _ULast, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return {_RANGES _Rewrap_iterator(_Range, _STD move(_ULast)), _Found};
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        _NODISCARD static constexpr bool _Next_permutation_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+
+            auto _Next = _Last;
+            if (_First == _Last || _First == --_Next) {
+                return false;
+            }
+
+            for (;;) { // find rightmost element smaller than successor
+                auto _Next1 = _Next;
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *--_Next), _STD invoke(_Proj, *_Next1))) {
+                    // swap with rightmost element that's smaller, flip suffix
+                    auto _Mid = _Last;
+                    do {
+                        --_Mid;
+                    } while (!_STD invoke(_Pred, _STD invoke(_Proj, *_Next), _STD invoke(_Proj, *_Mid)));
+
+                    _RANGES iter_swap(_Next, _Mid);
+                    _RANGES _Reverse_common(_STD move(_Next1), _STD move(_Last));
+                    return true;
+                }
+
+                if (_Next == _First) { // pure descending, flip all
+                    _RANGES _Reverse_common(_STD move(_First), _STD move(_Last));
+                    return false;
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Next_permutation_fn next_permutation;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _BidIt, class _Pr>
+_CONSTEXPR20 bool prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred) {
+    // reverse permute and test for pure descending
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UNext       = _ULast;
+    if (_UFirst == _ULast || _UFirst == --_UNext) {
+        return false;
+    }
+
+    for (;;) { // find rightmost element not smaller than successor
+        auto _UNext1 = _UNext;
+        if (_DEBUG_LT_PRED(_Pred, *_UNext1, *--_UNext)) { // swap with rightmost element that's not smaller, flip suffix
+            auto _UMid = _ULast;
+            do {
+                --_UMid;
+            } while (!_DEBUG_LT_PRED(_Pred, *_UMid, *_UNext));
+
+            swap(*_UNext, *_UMid); // intentional ADL
+            _STD reverse(_UNext1, _ULast);
+            return true;
+        }
+
+        if (_UNext == _UFirst) { // pure ascending, flip all
+            _STD reverse(_UFirst, _ULast);
+            return false;
+        }
+    }
+}
+
+_EXPORT_STD template <class _BidIt>
+_CONSTEXPR20 bool prev_permutation(_BidIt _First, _BidIt _Last) {
+    // reverse permute and test for pure descending
+    return _STD prev_permutation(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In>
+    using prev_permutation_result = in_found_result<_In>;
+
+    class _Prev_permutation_fn {
+    public:
+        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<_It, _Pr, _Pj>
+        static constexpr prev_permutation_result<_It> operator()(
+            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast  = _RANGES _Get_final_iterator_unwrapped<_It>(_UFirst, _STD move(_Last));
+            _STD _Seek_wrapped(_First, _ULast);
+            const bool _Found = _Prev_permutation_common(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return {_STD move(_First), _Found};
+        }
+
+        template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
+            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
+        static constexpr prev_permutation_result<borrowed_iterator_t<_Rng>> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _ULast = _RANGES _Get_final_iterator_unwrapped(_Range);
+            const bool _Found =
+                _Prev_permutation_common(_Ubegin(_Range), _ULast, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return {_RANGES _Rewrap_iterator(_Range, _STD move(_ULast)), _Found};
+        }
+
+    private:
+        template <class _It, class _Pr, class _Pj>
+        _NODISCARD static constexpr bool _Prev_permutation_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sortable<_It, _Pr, _Pj>);
+
+            auto _Next = _Last;
+            if (_First == _Last || _First == --_Next) {
+                return false;
+            }
+
+            for (;;) { // find rightmost element not smaller than successor
+                auto _Next1 = _Next;
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_Next1), _STD invoke(_Proj, *--_Next))) {
+                    // swap with rightmost element that's not smaller, flip suffix
+                    auto _Mid = _Last;
+                    do {
+                        --_Mid;
+                    } while (!_STD invoke(_Pred, _STD invoke(_Proj, *_Mid), _STD invoke(_Proj, *_Next)));
+
+                    _RANGES iter_swap(_Next, _Mid);
+                    _RANGES _Reverse_common(_STD move(_Next1), _STD move(_Last));
+                    return true;
+                }
+
+                if (_Next == _First) { // pure ascending, flip all
+                    _RANGES _Reverse_common(_STD move(_First), _STD move(_Last));
+                    return false;
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Prev_permutation_fn prev_permutation;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt is_sorted_until(const _FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+    // find extent of range that is ordered by predicate
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _ULast  = _STD _Get_unwrapped(_Last);
+
+#if _VECTORIZED_IS_SORTED_UNTIL
+    if constexpr (_Is_min_max_iterators_safe<decltype(_UFirst)>) {
+        constexpr bool _Is_greater = _Is_predicate_greater<decltype(_UFirst), _Pr>;
+        if constexpr (_Is_greater || _Is_predicate_less<decltype(_UFirst), _Pr>) {
+            if (!_STD _Is_constant_evaluated()) {
+                const auto _First_ptr = _STD _To_address(_UFirst);
+                const auto _Result =
+                    _STD _Is_sorted_until_vectorized(_First_ptr, _STD _To_address(_ULast), _Is_greater);
+
+                if constexpr (is_pointer_v<decltype(_UFirst)>) {
+                    _UFirst = _Result;
+                } else {
+                    _UFirst += static_cast<_Iter_diff_t<decltype(_UFirst)>>(_Result - _First_ptr);
+                }
+
+                _STD _Seek_wrapped(_Last, _UFirst);
+                return _Last;
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_IS_SORTED_UNTIL ^^^
+
+    if (_UFirst != _ULast) {
+        for (auto _UNext = _UFirst; ++_UNext != _ULast; ++_UFirst) {
+            if (_DEBUG_LT_PRED(_Pred, *_UNext, *_UFirst)) {
+                _ULast = _UNext;
+                break;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_Last, _ULast);
+    return _Last;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD _CONSTEXPR20 bool is_sorted(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+    // test if range is ordered by predicate
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    return _STD is_sorted_until(_UFirst, _ULast, _STD _Pass_fn(_Pred)) == _ULast;
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD _CONSTEXPR20 _FwdIt is_sorted_until(_FwdIt _First, _FwdIt _Last) {
+    // find extent of range that is ordered by operator<
+    return _STD is_sorted_until(_First, _Last, less<>{});
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD _CONSTEXPR20 bool is_sorted(_FwdIt _First, _FwdIt _Last) { // test if range is ordered by operator<
+    return _STD is_sorted(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt is_sorted_until(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool is_sorted(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // test if range is ordered by predicate
+    return _STD is_sorted_until(_STD forward<_ExPo>(_Exec), _First, _Last, _STD _Pass_fn(_Pred)) == _Last;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt is_sorted_until(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
+    // find extent of range that is ordered by operator<
+    return _STD is_sorted_until(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool is_sorted(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
+    // test if range is ordered by operator<
+    return _STD is_sorted(_STD forward<_ExPo>(_Exec), _First, _Last, less{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Is_sorted_fn {
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            const auto _ULast  = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _UFirst = _RANGES _Is_sorted_until_unchecked(
+                _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _ULast, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _UFirst == _ULast;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr bool operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _ULast = _Uend(_Range);
+            const auto _UFirst =
+                _RANGES _Is_sorted_until_unchecked(_Ubegin(_Range), _ULast, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _UFirst == _ULast;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Is_sorted_fn is_sorted;
+
+    struct _Is_sorted_until_fn {
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst = _RANGES _Is_sorted_until_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UResult = _RANGES _Is_sorted_until_unchecked(
+                _Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Is_sorted_until_fn is_sorted_until;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr const _Ty& clamp(const _Ty& _Val _MSVC_LIFETIMEBOUND, const _Ty& _Min_val _MSVC_LIFETIMEBOUND,
+    const _Ty& _Max_val _MSVC_LIFETIMEBOUND, _Pr _Pred) {
+    // returns _Val constrained to [_Min_val, _Max_val]
+#if _ITERATOR_DEBUG_LEVEL == 2
+    if (_DEBUG_LT_PRED(_Pred, _Max_val, _Min_val)) {
+        _STL_REPORT_ERROR("invalid bounds arguments passed to std::clamp");
+        return _Val;
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    if constexpr (conjunction_v<is_scalar<_Ty>, disjunction<is_same<_Pr, less<>>, is_same<_Pr, less<_Ty>>>>) {
+        // Avoid early return to promote branchless code generation; see GH-2334
+        const _Ty& _Tmp = _DEBUG_LT_PRED(_Pred, _Val, _Min_val) ? _Min_val : _Val;
+        return _DEBUG_LT_PRED(_Pred, _Max_val, _Val) ? _Max_val : _Tmp;
+    } else {
+        if (_DEBUG_LT_PRED(_Pred, _Max_val, _Val)) {
+            return _Max_val;
+        }
+
+        if (_DEBUG_LT_PRED(_Pred, _Val, _Min_val)) {
+            return _Min_val;
+        }
+
+        return _Val;
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr const _Ty& clamp(const _Ty& _Val _MSVC_LIFETIMEBOUND, const _Ty& _Min_val _MSVC_LIFETIMEBOUND,
+    const _Ty& _Max_val _MSVC_LIFETIMEBOUND) {
+    // returns _Val constrained to [_Min_val, _Max_val]
+    return _STD clamp(_Val, _Min_val, _Max_val, less{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Clamp_fn {
+        template <class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr const _Ty& operator()(const _Ty& _Val _MSVC_LIFETIMEBOUND,
+            const _Ty& _Lo _MSVC_LIFETIMEBOUND, const _Ty& _Hi _MSVC_LIFETIMEBOUND, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STL_ASSERT(!_STD invoke(_Pred, _STD invoke(_Proj, _Hi), _STD invoke(_Proj, _Lo)),
+                "The lower bound cannot be greater than the upper bound in a call to std::ranges::clamp "
+                "(N4950 [alg.clamp]/2).");
+
+            auto&& _Temp = _STD invoke(_Proj, _Val);
+            if (_STD invoke(_Pred, _STD forward<decltype(_Temp)>(_Temp), _STD invoke(_Proj, _Lo))) {
+                return _Lo;
+            }
+            // The double forward is safe because regular_invocable requires that the invocation of the predicate not
+            // modify _Temp in a manner observable to equality-preserving expressions.
+            if (_STD invoke(_Pred, _STD invoke(_Proj, _Hi), _STD forward<decltype(_Temp)>(_Temp))) {
+                return _Hi;
+            }
+
+            return _Val;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Clamp_fn clamp;
+
+    class _Lexicographical_compare_fn {
+    public:
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pj1 = identity, class _Pj2 = identity,
+            indirect_strict_weak_order<projected<_It1, _Pj1>, projected<_It2, _Pj2>> _Pr = ranges::less>
+        _NODISCARD static constexpr bool operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+
+            return _Lexicographical_compare_unchecked(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                _STD _Pass_fn(_Proj2));
+        }
+
+        template <input_range _Rng1, input_range _Rng2, class _Pj1 = identity, class _Pj2 = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng1>, _Pj1>, projected<iterator_t<_Rng2>, _Pj2>> _Pr =
+                ranges::less>
+        _NODISCARD static constexpr bool operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            return _Lexicographical_compare_unchecked(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2),
+                _Uend(_Range2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr bool _Lexicographical_compare_unchecked(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>);
+
+            using _Memcmp_classification_pred = _Lex_compare_memcmp_classify<_It1, _It2, _Pr>;
+            constexpr bool _Is_sized1         = sized_sentinel_for<_Se1, _It1>;
+            constexpr bool _Is_sized2         = sized_sentinel_for<_Se2, _It2>;
+            if constexpr (!is_void_v<_Memcmp_classification_pred> && _Sized_or_unreachable_sentinel_for<_Se1, _It1>
+                          && _Sized_or_unreachable_sentinel_for<_Se2, _It2> && same_as<_Pj1, identity>
+                          && same_as<_Pj2, identity> && (_Is_sized1 || _Is_sized2)) {
+                if (!_STD is_constant_evaluated()) {
+                    size_t _Num1;
+                    if constexpr (_Is_sized1) {
+                        _Num1 = static_cast<size_t>(_STD _Contiguous_iter_distance(_First1, _Last1));
+                    } else {
+                        _Num1 = SIZE_MAX;
+                    }
+
+                    size_t _Num2;
+                    if constexpr (_Is_sized2) {
+                        _Num2 = static_cast<size_t>(_STD _Contiguous_iter_distance(_First2, _Last2));
+                    } else {
+                        _Num2 = SIZE_MAX;
+                    }
+
+                    const size_t _Num = (_STD min) (_Num1, _Num2);
+#if _VECTORIZED_MISMATCH
+                    const auto _First1_ptr = _STD to_address(_First1);
+                    const auto _First2_ptr = _STD to_address(_First2);
+                    const size_t _Pos      = _Mismatch_vectorized<sizeof(*_First1_ptr)>(_First1_ptr, _First2_ptr, _Num);
+                    if (_Pos == _Num2) {
+                        return false;
+                    } else if (_Pos == _Num1) {
+                        return true;
+                    } else {
+                        return _STD invoke(_Pred, _First1_ptr[_Pos], _First2_ptr[_Pos]);
+                    }
+#else // ^^^ _VECTORIZED_MISMATCH / !_VECTORIZED_MISMATCH vvv
+                    const int _Ans = _STD _Memcmp_count(_First1, _First2, _Num);
+                    return _Memcmp_classification_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2);
+#endif // ^^^ !_VECTORIZED_MISMATCH ^^^
+                }
+            }
+
+            for (;; ++_First1, (void) ++_First2) {
+                if (_First2 == _Last2) {
+                    return false;
+                } else if (_First1 == _Last1) {
+                    return true;
+                } else if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                    return true;
+                } else if (_STD invoke(_Pred, _STD invoke(_Proj2, *_First2), _STD invoke(_Proj1, *_First1))) {
+                    return false;
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Lexicographical_compare_fn lexicographical_compare;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+#undef _REQUIRE_BIDIRECTIONAL_ITERATOR
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("lifetimebound")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _ALGORITHM_
diff --git a/msvc-stl/stl/inc/any b/msvc-stl/stl/inc/any
new file mode 100644
index 0000000..e9d7f07
--- /dev/null
+++ b/msvc-stl/stl/inc/any
@@ -0,0 +1,474 @@
+// any standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _ANY_
+#define _ANY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <any> are available only with C++17 or later.");
+#elif !_HAS_STATIC_RTTI // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+_EMIT_STL_WARNING(STL4040, "The contents of <any> require static RTTI.");
+#else // ^^^ !_HAS_STATIC_RTTI / _HAS_STATIC_RTTI vvv
+#include <initializer_list>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <xmemory>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_EXPORT_STD class _NODISCARD bad_any_cast : public bad_cast { // thrown by failed any_cast
+public:
+    _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
+        return "Bad any_cast";
+    }
+};
+
+[[noreturn]] inline void _Throw_bad_any_cast() {
+    _THROW(bad_any_cast{});
+}
+
+inline constexpr size_t _Any_trivial_space_size = (_Small_object_num_ptrs - 1) * sizeof(void*);
+
+template <class _Ty>
+constexpr bool _Any_is_trivial =
+    alignof(_Ty) <= alignof(max_align_t) && is_trivially_copyable_v<_Ty> && sizeof(_Ty) <= _Any_trivial_space_size;
+
+inline constexpr size_t _Any_small_space_size = (_Small_object_num_ptrs - 2) * sizeof(void*);
+
+template <class _Ty>
+constexpr bool _Any_is_small = alignof(_Ty) <= alignof(max_align_t)
+                            && is_nothrow_move_constructible_v<_Ty> && sizeof(_Ty) <= _Any_small_space_size;
+
+enum class _Any_representation : uintptr_t { _Trivial, _Big, _Small };
+
+struct _Any_big_RTTI { // Hand-rolled vtable for types that must be heap allocated in an any
+    using _Destroy_fn = void __CLRCALL_PURE_OR_CDECL(void*) _NOEXCEPT_FNPTR;
+    using _Copy_fn    = void* __CLRCALL_PURE_OR_CDECL(const void*);
+
+    template <class _Ty>
+    static void __CLRCALL_PURE_OR_CDECL _Destroy_impl(void* const _Target) noexcept {
+        ::delete static_cast<_Ty*>(_Target);
+    }
+
+    template <class _Ty>
+    _NODISCARD static void* __CLRCALL_PURE_OR_CDECL _Copy_impl(const void* const _Source) {
+        return ::new _Ty(*static_cast<const _Ty*>(_Source));
+    }
+
+    _Destroy_fn* _Destroy;
+    _Copy_fn* _Copy;
+};
+
+struct _Any_small_RTTI { // Hand-rolled vtable for nontrivial types that can be stored internally in an any
+    using _Destroy_fn = void __CLRCALL_PURE_OR_CDECL(void*) _NOEXCEPT_FNPTR;
+    using _Copy_fn    = void __CLRCALL_PURE_OR_CDECL(void*, const void*);
+    using _Move_fn    = void __CLRCALL_PURE_OR_CDECL(void*, void*) _NOEXCEPT_FNPTR;
+
+    template <class _Ty>
+    static void __CLRCALL_PURE_OR_CDECL _Destroy_impl(void* const _Target) noexcept {
+        _STD _Destroy_in_place(*static_cast<_Ty*>(_Target));
+    }
+
+    template <class _Ty>
+    static void __CLRCALL_PURE_OR_CDECL _Copy_impl(void* const _Target, const void* const _Source) {
+        _STD _Construct_in_place(*static_cast<_Ty*>(_Target), *static_cast<const _Ty*>(_Source));
+    }
+
+    template <class _Ty>
+    static void __CLRCALL_PURE_OR_CDECL _Move_impl(void* const _Target, void* const _Source) noexcept {
+        _STD _Construct_in_place(*static_cast<_Ty*>(_Target), _STD move(*static_cast<_Ty*>(_Source)));
+    }
+
+    _Destroy_fn* _Destroy;
+    _Copy_fn* _Copy;
+    _Move_fn* _Move;
+};
+
+template <class _Ty>
+constexpr _Any_big_RTTI _Any_big_RTTI_obj = {&_Any_big_RTTI::_Destroy_impl<_Ty>, &_Any_big_RTTI::_Copy_impl<_Ty>};
+
+template <class _Ty>
+constexpr _Any_small_RTTI _Any_small_RTTI_obj = {
+    &_Any_small_RTTI::_Destroy_impl<_Ty>, &_Any_small_RTTI::_Copy_impl<_Ty>, &_Any_small_RTTI::_Move_impl<_Ty>};
+
+_EXPORT_STD class any { // storage for any (CopyConstructible) type
+public:
+    // Construction and destruction [any.cons]
+    constexpr any() noexcept {}
+
+    any(const any& _That) {
+        _Storage._TypeData = _That._Storage._TypeData;
+        switch (_Rep()) {
+        case _Any_representation::_Small:
+            _Storage._SmallStorage._RTTI = _That._Storage._SmallStorage._RTTI;
+            _Storage._SmallStorage._RTTI->_Copy(&_Storage._SmallStorage._Data, &_That._Storage._SmallStorage._Data);
+            break;
+        case _Any_representation::_Big:
+            _Storage._BigStorage._RTTI = _That._Storage._BigStorage._RTTI;
+            _Storage._BigStorage._Ptr  = _Storage._BigStorage._RTTI->_Copy(_That._Storage._BigStorage._Ptr);
+            break;
+        case _Any_representation::_Trivial:
+        default:
+            _CSTD memcpy(_Storage._TrivialData, _That._Storage._TrivialData, sizeof(_Storage._TrivialData));
+            break;
+        }
+    }
+
+    any(any&& _That) noexcept {
+        _Move_from(_That);
+    }
+
+    template <class _ValueType,
+        enable_if_t<!is_same_v<decay_t<_ValueType>, any> && !_Is_specialization_v<decay_t<_ValueType>, in_place_type_t>,
+            int> = 0, // Separate these conditions into two `enable_if_t`s to avoid meta-recursion.
+                      // See LLVM-176877 and GH-6109. N5032 [temp.deduct.general]/7 guarantees:
+                      // "The substitution proceeds in lexical order and stops when
+                      // a condition that causes deduction to fail is encountered."
+        enable_if_t<is_copy_constructible_v<decay_t<_ValueType>>, int> = 0>
+    any(_ValueType&& _Value) { // initialize with _Value
+        _Emplace<decay_t<_ValueType>>(_STD forward<_ValueType>(_Value));
+    }
+
+    template <class _ValueType, class... _Types,
+        enable_if_t<
+            conjunction_v<is_constructible<decay_t<_ValueType>, _Types...>, is_copy_constructible<decay_t<_ValueType>>>,
+            int> = 0>
+    explicit any(in_place_type_t<_ValueType>, _Types&&... _Args) {
+        // in-place initialize a value of type decay_t<_ValueType> with _Args...
+        _Emplace<decay_t<_ValueType>>(_STD forward<_Types>(_Args)...);
+    }
+
+    template <class _ValueType, class _Elem, class... _Types,
+        enable_if_t<conjunction_v<is_constructible<decay_t<_ValueType>, initializer_list<_Elem>&, _Types...>,
+                        is_copy_constructible<decay_t<_ValueType>>>,
+            int> = 0>
+    explicit any(in_place_type_t<_ValueType>, initializer_list<_Elem> _Ilist, _Types&&... _Args) {
+        // in-place initialize a value of type decay_t<_ValueType> with _Ilist and _Args...
+        _Emplace<decay_t<_ValueType>>(_Ilist, _STD forward<_Types>(_Args)...);
+    }
+
+    ~any() noexcept {
+        reset();
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        // The two least significant bits (LSBs) of _Storage._TypeData encode whether we're in _Small, _Big,
+        // or _Trivial mode; see _Rep(). The rest of the bits encode the type_info pointer that's used
+        // to remember what type of object we're storing; see _TypeInfo(). So, we'll take the tombstone value,
+        // clear out the two LSBs with the _Rep_mask, then set the bits for _Small mode.
+        // _Small mode will prevent the most misuse, as the pseudo-vtable will be used for _Destroy, _Copy, and _Move.
+        // _Big mode wouldn't use the pseudo-vtable for _Move, and _Trivial mode doesn't have a pseudo-vtable at all.
+        const uintptr_t _Tombstone_value{_MSVC_STL_UINTPTR_TOMBSTONE_VALUE};
+        // Set the pseudo-vtable pointer:
+        _Storage._SmallStorage._RTTI = reinterpret_cast<const _Any_small_RTTI*>(_Tombstone_value);
+        // Set the combined type_info pointer and representation mode bits:
+        _Storage._TypeData = (_Tombstone_value & ~_Rep_mask) | static_cast<uintptr_t>(_Any_representation::_Small);
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    }
+
+    // Assignment [any.assign]
+    any& operator=(const any& _That) {
+        any _Tmp = _That;
+        _Reset_and_move_from(_Tmp);
+        return *this;
+    }
+
+    any& operator=(any&& _That) noexcept {
+        any _Tmp = _STD move(_That);
+        _Reset_and_move_from(_Tmp);
+        return *this;
+    }
+
+    template <class _ValueType, enable_if_t<conjunction_v<negation<is_same<decay_t<_ValueType>, any>>,
+                                                is_copy_constructible<decay_t<_ValueType>>>,
+                                    int> = 0>
+    any& operator=(_ValueType&& _Value) {
+        // replace contained value with an object of type decay_t<_ValueType> initialized from _Value
+        any _Tmp = _STD forward<_ValueType>(_Value);
+        _Reset_and_move_from(_Tmp);
+        return *this;
+    }
+
+    // Modifiers [any.modifiers]
+    template <class _ValueType, class... _Types,
+        enable_if_t<
+            conjunction_v<is_constructible<decay_t<_ValueType>, _Types...>, is_copy_constructible<decay_t<_ValueType>>>,
+            int> = 0>
+    decay_t<_ValueType>& emplace(_Types&&... _Args) {
+        // replace contained value with an object of type decay_t<_ValueType> initialized from _Args...
+        reset();
+        return _Emplace<decay_t<_ValueType>>(_STD forward<_Types>(_Args)...);
+    }
+    template <class _ValueType, class _Elem, class... _Types,
+        enable_if_t<conjunction_v<is_constructible<decay_t<_ValueType>, initializer_list<_Elem>&, _Types...>,
+                        is_copy_constructible<decay_t<_ValueType>>>,
+            int> = 0>
+    decay_t<_ValueType>& emplace(initializer_list<_Elem> _Ilist, _Types&&... _Args) {
+        // replace contained value with an object of type decay_t<_ValueType> initialized from _Ilist and _Args...
+        reset();
+        return _Emplace<decay_t<_ValueType>>(_Ilist, _STD forward<_Types>(_Args)...);
+    }
+
+    void reset() noexcept { // transition to the empty state
+        switch (_Rep()) {
+        case _Any_representation::_Small:
+            _Storage._SmallStorage._RTTI->_Destroy(&_Storage._SmallStorage._Data);
+            break;
+        case _Any_representation::_Big:
+            _Storage._BigStorage._RTTI->_Destroy(_Storage._BigStorage._Ptr);
+            break;
+        case _Any_representation::_Trivial:
+        default:
+            break;
+        }
+        _Storage._TypeData = 0;
+    }
+
+    void swap(any& _That) noexcept {
+        any _Tmp = _STD move(*this);
+        _Reset_and_move_from(_That);
+        _That._Reset_and_move_from(_Tmp);
+    }
+
+    // Observers [any.observers]
+    _NODISCARD bool has_value() const noexcept {
+        return _Storage._TypeData != 0;
+    }
+
+    _NODISCARD const type_info& type() const noexcept {
+        // if *this contains a value of type T, return typeid(T); otherwise typeid(void)
+        const type_info* const _Info = _TypeInfo();
+        if (_Info) {
+            return *_Info;
+        }
+
+        return typeid(void);
+    }
+
+    template <class _Decayed>
+    _NODISCARD const _Decayed* _Cast() const noexcept {
+        // if *this contains a value of type _Decayed, return a pointer to it
+        const type_info* const _Info = _TypeInfo();
+        if (!_Info || *_Info != typeid(_Decayed)) {
+            return nullptr;
+        }
+
+        if constexpr (_Any_is_trivial<_Decayed>) {
+            // get a pointer to the contained _Trivial value of type _Decayed
+            return reinterpret_cast<const _Decayed*>(&_Storage._TrivialData);
+        } else if constexpr (_Any_is_small<_Decayed>) {
+            // get a pointer to the contained _Small value of type _Decayed
+            return reinterpret_cast<const _Decayed*>(&_Storage._SmallStorage._Data);
+        } else {
+            // get a pointer to the contained _Big value of type _Decayed
+            return static_cast<const _Decayed*>(_Storage._BigStorage._Ptr);
+        }
+    }
+
+    template <class _Decayed>
+    _NODISCARD _Decayed* _Cast() noexcept { // if *this contains a value of type _Decayed, return a pointer to it
+        return const_cast<_Decayed*>(static_cast<const any*>(this)->_Cast<_Decayed>());
+    }
+
+private:
+    static constexpr uintptr_t _Rep_mask = 3;
+
+    _NODISCARD _Any_representation _Rep() const noexcept { // extract the representation format from _TypeData
+        return static_cast<_Any_representation>(_Storage._TypeData & _Rep_mask);
+    }
+    _NODISCARD const type_info* _TypeInfo() const noexcept { // extract the type_info from _TypeData
+        return reinterpret_cast<const type_info*>(_Storage._TypeData & ~_Rep_mask);
+    }
+
+    void _Move_from(any& _That) noexcept {
+        _STL_INTERNAL_CHECK(_Storage._TypeData == 0); // !has_value()
+        _Storage._TypeData = _That._Storage._TypeData;
+        switch (_Rep()) {
+        case _Any_representation::_Small:
+            _Storage._SmallStorage._RTTI = _That._Storage._SmallStorage._RTTI;
+            _Storage._SmallStorage._RTTI->_Move(&_Storage._SmallStorage._Data, &_That._Storage._SmallStorage._Data);
+            break;
+        case _Any_representation::_Big:
+            _Storage._BigStorage._RTTI = _That._Storage._BigStorage._RTTI;
+            _Storage._BigStorage._Ptr  = _That._Storage._BigStorage._Ptr;
+            _That._Storage._TypeData   = 0;
+            break;
+        case _Any_representation::_Trivial:
+        default:
+            _CSTD memcpy(_Storage._TrivialData, _That._Storage._TrivialData, sizeof(_Storage._TrivialData));
+            break;
+        }
+    }
+
+    void _Reset_and_move_from(any& _That) noexcept {
+        reset();
+        _Move_from(_That);
+    }
+
+    template <class _Decayed, class... _Types>
+    _Decayed& _Emplace(_Types&&... _Args) { // emplace construct _Decayed
+        _STL_INTERNAL_CHECK(_Storage._TypeData == 0); // !has_value()
+        if constexpr (_Any_is_trivial<_Decayed>) {
+            // using the _Trivial representation
+            auto& _Obj = reinterpret_cast<_Decayed&>(_Storage._TrivialData);
+            _STD _Construct_in_place(_Obj, _STD forward<_Types>(_Args)...);
+            _Storage._TypeData =
+                reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Trivial);
+            return _Obj;
+        } else if constexpr (_Any_is_small<_Decayed>) {
+            // using the _Small representation
+            auto& _Obj = reinterpret_cast<_Decayed&>(_Storage._SmallStorage._Data);
+            _STD _Construct_in_place(_Obj, _STD forward<_Types>(_Args)...);
+            _Storage._SmallStorage._RTTI = &_Any_small_RTTI_obj<_Decayed>;
+            _Storage._TypeData =
+                reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Small);
+            return _Obj;
+        } else {
+            // using the _Big representation
+            _Decayed* const _Ptr       = ::new _Decayed(_STD forward<_Types>(_Args)...);
+            _Storage._BigStorage._Ptr  = _Ptr;
+            _Storage._BigStorage._RTTI = &_Any_big_RTTI_obj<_Decayed>;
+            _Storage._TypeData =
+                reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Big);
+            return *_Ptr;
+        }
+    }
+
+    struct _Small_storage_t {
+        unsigned char _Data[_Any_small_space_size];
+        const _Any_small_RTTI* _RTTI;
+    };
+    static_assert(sizeof(_Small_storage_t) == _Any_trivial_space_size);
+
+    struct _Big_storage_t {
+        // Pad so that _Ptr and _RTTI might share _TypeData's cache line
+        unsigned char _Padding[_Any_small_space_size - sizeof(void*)];
+        void* _Ptr;
+        const _Any_big_RTTI* _RTTI;
+    };
+    static_assert(sizeof(_Big_storage_t) == _Any_trivial_space_size);
+
+    struct _Storage_t {
+        union {
+            unsigned char _TrivialData[_Any_trivial_space_size];
+            _Small_storage_t _SmallStorage;
+            _Big_storage_t _BigStorage;
+        };
+        uintptr_t _TypeData;
+    };
+    static_assert(sizeof(_Storage_t) == _Any_trivial_space_size + sizeof(void*));
+    static_assert(is_standard_layout_v<_Storage_t>);
+
+    union {
+        _Storage_t _Storage{};
+        max_align_t _Dummy;
+    };
+};
+
+// Non-member functions [any.nonmembers]
+_EXPORT_STD inline void swap(any& _Left, any& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _ValueType, class... _Types,
+    enable_if_t<is_constructible_v<any, in_place_type_t<_ValueType>, _Types...>, int> = 0>
+_NODISCARD any make_any(_Types&&... _Args) { // construct an any containing a _ValueType initialized with _Args...
+    return any{in_place_type<_ValueType>, _STD forward<_Types>(_Args)...};
+}
+_EXPORT_STD template <class _ValueType, class _Elem, class... _Types,
+    enable_if_t<is_constructible_v<any, in_place_type_t<_ValueType>, initializer_list<_Elem>&, _Types...>, int> = 0>
+_NODISCARD any make_any(initializer_list<_Elem> _Ilist, _Types&&... _Args) {
+    // construct an any containing a _ValueType initialized with _Ilist and _Args...
+    return any{in_place_type<_ValueType>, _Ilist, _STD forward<_Types>(_Args)...};
+}
+
+_EXPORT_STD template <class _ValueType>
+_NODISCARD const _ValueType* any_cast(const any* const _Any) noexcept {
+    // retrieve a pointer to the _ValueType contained in _Any, or null
+    static_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");
+
+    if constexpr (is_function_v<_ValueType> || is_array_v<_ValueType>) {
+        return nullptr;
+    } else {
+        if (!_Any) {
+            return nullptr;
+        }
+
+        return _Any->_Cast<_Remove_cvref_t<_ValueType>>();
+    }
+}
+_EXPORT_STD template <class _ValueType>
+_NODISCARD _ValueType* any_cast(any* const _Any) noexcept {
+    // retrieve a pointer to the _ValueType contained in _Any, or null
+    static_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");
+
+    if constexpr (is_function_v<_ValueType> || is_array_v<_ValueType>) {
+        return nullptr;
+    } else {
+        if (!_Any) {
+            return nullptr;
+        }
+
+        return _Any->_Cast<_Remove_cvref_t<_ValueType>>();
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD remove_cv_t<_Ty> any_cast(const any& _Any) {
+    static_assert(is_constructible_v<remove_cv_t<_Ty>, const _Remove_cvref_t<_Ty>&>,
+        "any_cast<T>(const any&) requires remove_cv_t<T> to be constructible from "
+        "const remove_cv_t<remove_reference_t<T>>&");
+
+    const auto _Ptr = _STD any_cast<_Remove_cvref_t<_Ty>>(&_Any);
+    if (!_Ptr) {
+        _Throw_bad_any_cast();
+    }
+
+    return static_cast<remove_cv_t<_Ty>>(*_Ptr);
+}
+_EXPORT_STD template <class _Ty>
+_NODISCARD remove_cv_t<_Ty> any_cast(any& _Any) {
+    static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>&>,
+        "any_cast<T>(any&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>&");
+
+    const auto _Ptr = _STD any_cast<_Remove_cvref_t<_Ty>>(&_Any);
+    if (!_Ptr) {
+        _Throw_bad_any_cast();
+    }
+
+    return static_cast<remove_cv_t<_Ty>>(*_Ptr);
+}
+_EXPORT_STD template <class _Ty>
+_NODISCARD remove_cv_t<_Ty> any_cast(any&& _Any) {
+    static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>>,
+        "any_cast<T>(any&&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>");
+
+    const auto _Ptr = _STD any_cast<_Remove_cvref_t<_Ty>>(&_Any);
+    if (!_Ptr) {
+        _Throw_bad_any_cast();
+    }
+
+    return static_cast<remove_cv_t<_Ty>>(_STD move(*_Ptr));
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_STATIC_RTTI ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _ANY_
diff --git a/msvc-stl/stl/inc/array b/msvc-stl/stl/inc/array
new file mode 100644
index 0000000..37bbd98
--- /dev/null
+++ b/msvc-stl/stl/inc/array
@@ -0,0 +1,896 @@
+// array standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _ARRAY_
+#define _ARRAY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#if _ITERATOR_DEBUG_LEVEL != 0
+struct _Iterator_base12_compatible { // TRANSITION, ABI
+    _Container_proxy* _Myproxy{};
+    _Iterator_base12* _Mynextiter{};
+};
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+template <class _Ty, size_t _Size>
+class _Array_const_iterator
+#if _ITERATOR_DEBUG_LEVEL != 0
+    : private _Iterator_base12_compatible
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+{
+public:
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = _Ty;
+    using difference_type   = ptrdiff_t;
+    using pointer           = const _Ty*;
+    using reference         = const _Ty&;
+
+    enum { _EEN_SIZE = _Size }; // helper for expression evaluator
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+    _CONSTEXPR17 _Array_const_iterator() noexcept : _Ptr() {}
+
+    _CONSTEXPR17 explicit _Array_const_iterator(pointer _Parg, size_t _Off = 0) noexcept : _Ptr(_Parg + _Off) {}
+
+    _NODISCARD _CONSTEXPR17 reference operator*() const noexcept {
+        return *_Ptr;
+    }
+
+    _NODISCARD _CONSTEXPR17 pointer operator->() const noexcept {
+        return _Ptr;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator& operator++() noexcept {
+        ++_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator operator++(int) noexcept {
+        _Array_const_iterator _Tmp = *this;
+        ++_Ptr;
+        return _Tmp;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator& operator--() noexcept {
+        --_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator operator--(int) noexcept {
+        _Array_const_iterator _Tmp = *this;
+        --_Ptr;
+        return _Tmp;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator& operator+=(const ptrdiff_t _Off) noexcept {
+        _Ptr += _Off;
+        return *this;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator& operator-=(const ptrdiff_t _Off) noexcept {
+        _Ptr -= _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 ptrdiff_t operator-(const _Array_const_iterator& _Right) const noexcept {
+        return _Ptr - _Right._Ptr;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator[](const ptrdiff_t _Off) const noexcept {
+        return _Ptr[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR17 bool operator==(const _Array_const_iterator& _Right) const noexcept {
+        return _Ptr == _Right._Ptr;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _Array_const_iterator& _Right) const noexcept {
+        return _Ptr <=> _Right._Ptr;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD _CONSTEXPR17 bool operator<(const _Array_const_iterator& _Right) const noexcept {
+        return _Ptr < _Right._Ptr;
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    using _Prevent_inheriting_unwrap = _Array_const_iterator;
+
+    _NODISCARD constexpr pointer _Unwrapped() const noexcept {
+        return _Ptr;
+    }
+
+    static constexpr bool _Unwrap_when_unverified = true;
+
+    constexpr void _Seek_to(pointer _It) noexcept {
+        _Ptr = _It;
+    }
+
+private:
+    pointer _Ptr; // beginning of array
+
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+    _CONSTEXPR17 _Array_const_iterator() noexcept : _Ptr(), _Idx(0) {}
+
+    _CONSTEXPR17 explicit _Array_const_iterator(pointer _Parg, size_t _Off = 0) noexcept : _Ptr(_Parg), _Idx(_Off) {}
+
+    _NODISCARD _CONSTEXPR17 reference operator*() const noexcept {
+        return *operator->();
+    }
+
+    _NODISCARD _CONSTEXPR17 pointer operator->() const noexcept {
+        _STL_VERIFY(_Ptr, "cannot dereference value-initialized array iterator");
+        _STL_VERIFY(_Idx < _Size, "cannot dereference out of range array iterator");
+        return _Ptr + _Idx;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator& operator++() noexcept {
+        _STL_VERIFY(_Ptr, "cannot increment value-initialized array iterator");
+        _STL_VERIFY(_Idx < _Size, "cannot increment array iterator past end");
+        ++_Idx;
+        return *this;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator operator++(int) noexcept {
+        _Array_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator& operator--() noexcept {
+        _STL_VERIFY(_Ptr, "cannot decrement value-initialized array iterator");
+        _STL_VERIFY(_Idx != 0, "cannot decrement array iterator before begin");
+        --_Idx;
+        return *this;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator operator--(int) noexcept {
+        _Array_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    constexpr void _Verify_offset(const ptrdiff_t _Off) const noexcept {
+        if (_Off != 0) {
+            _STL_VERIFY(_Ptr, "cannot seek value-initialized array iterator");
+        }
+
+        if (_Off < 0) {
+            _STL_VERIFY(_Idx >= size_t{0} - static_cast<size_t>(_Off), "cannot seek array iterator before begin");
+        }
+
+        if (_Off > 0) {
+            _STL_VERIFY(_Size - _Idx >= static_cast<size_t>(_Off), "cannot seek array iterator after end");
+        }
+    }
+
+    _CONSTEXPR17 _Array_const_iterator& operator+=(const ptrdiff_t _Off) noexcept {
+        _Verify_offset(_Off);
+        _Idx += static_cast<size_t>(_Off);
+        return *this;
+    }
+
+    _CONSTEXPR17 _Array_const_iterator& operator-=(const ptrdiff_t _Off) noexcept {
+        return *this += -_Off;
+    }
+
+    _NODISCARD _CONSTEXPR17 ptrdiff_t operator-(const _Array_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return static_cast<ptrdiff_t>(_Idx - _Right._Idx);
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator[](const ptrdiff_t _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD _CONSTEXPR17 bool operator==(const _Array_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Idx == _Right._Idx;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _Array_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Idx <=> _Right._Idx;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD _CONSTEXPR17 bool operator<(const _Array_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Idx < _Right._Idx;
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR17 void _Compat(const _Array_const_iterator& _Right) const noexcept { // test for compatible iterator pair
+        _STL_VERIFY(_Ptr == _Right._Ptr, "array iterators incompatible");
+    }
+
+    using _Prevent_inheriting_unwrap = _Array_const_iterator;
+
+    _NODISCARD constexpr pointer _Unwrapped() const noexcept {
+        return _Ptr + _Idx;
+    }
+
+    constexpr void _Verify_with(const _Array_const_iterator& _Last) const noexcept {
+        // note _Compat check inside operator<=
+        _STL_VERIFY(*this <= _Last, "array iterator range transposed");
+    }
+
+    friend constexpr void _Verify_range(
+        const _Array_const_iterator& _First, const _Array_const_iterator& _Last) noexcept {
+        _First._Verify_with(_Last);
+    }
+
+    constexpr void _Seek_to(pointer _It) noexcept {
+        _Idx = static_cast<size_t>(_It - _Ptr);
+    }
+
+private:
+    pointer _Ptr; // beginning of array
+    size_t _Idx; // offset into array
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+
+public:
+    _NODISCARD _CONSTEXPR17 _Array_const_iterator operator+(const ptrdiff_t _Off) const noexcept {
+        _Array_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR17 _Array_const_iterator operator-(const ptrdiff_t _Off) const noexcept {
+        _Array_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR17 _Array_const_iterator operator+(
+        const ptrdiff_t _Off, _Array_const_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD _CONSTEXPR17 bool operator!=(const _Array_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD _CONSTEXPR17 bool operator>(const _Array_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 bool operator<=(const _Array_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD _CONSTEXPR17 bool operator>=(const _Array_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // !_HAS_CXX20
+};
+
+#if _HAS_CXX20
+template <class _Ty, size_t _Size>
+struct pointer_traits<_Array_const_iterator<_Ty, _Size>> {
+    using pointer         = _Array_const_iterator<_Ty, _Size>;
+    using element_type    = const _Ty;
+    using difference_type = ptrdiff_t;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+        return _Iter._Unwrapped();
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Ty, size_t _Size>
+class _Array_iterator : public _Array_const_iterator<_Ty, _Size> {
+public:
+    using _Mybase = _Array_const_iterator<_Ty, _Size>;
+
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = _Ty;
+    using difference_type   = ptrdiff_t;
+    using pointer           = _Ty*;
+    using reference         = _Ty&;
+
+    enum { _EEN_SIZE = _Size }; // helper for expression evaluator
+
+    _CONSTEXPR17 _Array_iterator() noexcept {}
+
+    _CONSTEXPR17 explicit _Array_iterator(pointer _Parg, size_t _Off = 0) noexcept : _Mybase(_Parg, _Off) {}
+
+    _NODISCARD _CONSTEXPR17 reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD _CONSTEXPR17 pointer operator->() const noexcept {
+        return const_cast<pointer>(_Mybase::operator->());
+    }
+
+    _CONSTEXPR17 _Array_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _CONSTEXPR17 _Array_iterator operator++(int) noexcept {
+        _Array_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _CONSTEXPR17 _Array_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _CONSTEXPR17 _Array_iterator operator--(int) noexcept {
+        _Array_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _CONSTEXPR17 _Array_iterator& operator+=(const ptrdiff_t _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 _Array_iterator operator+(const ptrdiff_t _Off) const noexcept {
+        _Array_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR17 _Array_iterator operator+(const ptrdiff_t _Off, _Array_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR17 _Array_iterator& operator-=(const ptrdiff_t _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    using _Mybase::operator-;
+
+    _NODISCARD _CONSTEXPR17 _Array_iterator operator-(const ptrdiff_t _Off) const noexcept {
+        _Array_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator[](const ptrdiff_t _Off) const noexcept {
+        return const_cast<reference>(_Mybase::operator[](_Off));
+    }
+
+    using _Prevent_inheriting_unwrap = _Array_iterator;
+
+    _NODISCARD constexpr pointer _Unwrapped() const noexcept {
+        return const_cast<pointer>(_Mybase::_Unwrapped());
+    }
+};
+
+#if _HAS_CXX20
+template <class _Ty, size_t _Size>
+struct pointer_traits<_Array_iterator<_Ty, _Size>> {
+    using pointer         = _Array_iterator<_Ty, _Size>;
+    using element_type    = _Ty;
+    using difference_type = ptrdiff_t;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+        return _Iter._Unwrapped();
+    }
+};
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+class array { // fixed size array of values
+public:
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
+                                    "because of [container.requirements].");
+
+    using value_type      = _Ty;
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer         = _Ty*;
+    using const_pointer   = const _Ty*;
+    using reference       = _Ty&;
+    using const_reference = const _Ty&;
+
+    using iterator       = _Array_iterator<_Ty, _Size>;
+    using const_iterator = _Array_const_iterator<_Ty, _Size>;
+
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    using _Library_defined = array;
+
+    _CONSTEXPR20 void fill(const _Ty& _Value) {
+        _STD fill_n(_Elems, _Size, _Value);
+    }
+
+    _CONSTEXPR20 void swap(array& _Other) noexcept(_Is_nothrow_swappable<_Ty>::value) {
+        _STD _Swap_ranges_unchecked(_Elems, _Elems + _Size, _Other._Elems);
+    }
+
+    _NODISCARD _CONSTEXPR17 iterator begin() noexcept {
+        return iterator(_Elems, 0);
+    }
+
+    _NODISCARD _CONSTEXPR17 const_iterator begin() const noexcept {
+        return const_iterator(_Elems, 0);
+    }
+
+    _NODISCARD _CONSTEXPR17 iterator end() noexcept {
+        return iterator(_Elems, _Size);
+    }
+
+    _NODISCARD _CONSTEXPR17 const_iterator end() const noexcept {
+        return const_iterator(_Elems, _Size);
+    }
+
+    _NODISCARD _CONSTEXPR17 reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR17 const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR17 reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR17 const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR17 const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD _CONSTEXPR17 const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD _CONSTEXPR17 const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD _CONSTEXPR17 const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _CONSTEXPR17 _Ty* _Unchecked_begin() noexcept {
+        return _Elems;
+    }
+
+    _CONSTEXPR17 const _Ty* _Unchecked_begin() const noexcept {
+        return _Elems;
+    }
+
+    _CONSTEXPR17 _Ty* _Unchecked_end() noexcept {
+        return _Elems + _Size;
+    }
+
+    _CONSTEXPR17 const _Ty* _Unchecked_end() const noexcept {
+        return _Elems + _Size;
+    }
+
+    _NODISCARD _Ret_range_(==, _Size) constexpr size_type size() const noexcept {
+        return _Size;
+    }
+
+    _NODISCARD constexpr size_type max_size() const noexcept {
+        return _Size;
+    }
+
+    _NODISCARD_EMPTY_ARRAY_MEMBER constexpr bool empty() const noexcept {
+        return false;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference at(size_type _Pos) {
+        if (_Size <= _Pos) {
+            _Xran();
+        }
+
+        return _Elems[_Pos];
+    }
+
+    _NODISCARD constexpr const_reference at(size_type _Pos) const {
+        if (_Size <= _Pos) {
+            _Xran();
+        }
+
+        return _Elems[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator[](_In_range_(<, _Size) size_type _Pos) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Pos < _Size, "array subscript out of range");
+#endif
+
+        return _Elems[_Pos];
+    }
+
+    _NODISCARD constexpr const_reference operator[](_In_range_(<, _Size) size_type _Pos) const noexcept
+    /* strengthened */ {
+#if _MSVC_STL_HARDENING_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Pos < _Size, "array subscript out of range");
+#endif
+
+        return _Elems[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR17 reference front() noexcept /* strengthened */ {
+        return _Elems[0];
+    }
+
+    _NODISCARD constexpr const_reference front() const noexcept /* strengthened */ {
+        return _Elems[0];
+    }
+
+    _NODISCARD _CONSTEXPR17 reference back() noexcept /* strengthened */ {
+        return _Elems[_Size - 1];
+    }
+
+    _NODISCARD constexpr const_reference back() const noexcept /* strengthened */ {
+        return _Elems[_Size - 1];
+    }
+
+    _NODISCARD _CONSTEXPR17 _Ty* data() noexcept {
+        return _Elems;
+    }
+
+    _NODISCARD _CONSTEXPR17 const _Ty* data() const noexcept {
+        return _Elems;
+    }
+
+    _Ty _Elems[_Size];
+
+private:
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid array<T, N> subscript");
+    }
+};
+
+#if _HAS_CXX17
+template <class _First, class... _Rest>
+struct _Enforce_same {
+    static_assert(
+        conjunction_v<is_same<_First, _Rest>...>, "N4950 [array.cons]/2: Mandates: (is_same_v<T, U> && ...) is true.");
+    using type = _First;
+};
+
+template <class _First, class... _Rest>
+array(_First, _Rest...) -> array<typename _Enforce_same<_First, _Rest...>::type, 1 + sizeof...(_Rest)>;
+#endif // _HAS_CXX17
+
+struct _Empty_array_element {};
+
+template <class _Ty>
+class array<_Ty, 0> {
+public:
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
+                                    "because of [container.requirements].");
+
+    using value_type      = _Ty;
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer         = _Ty*;
+    using const_pointer   = const _Ty*;
+    using reference       = _Ty&;
+    using const_reference = const _Ty&;
+
+    using iterator               = _Array_iterator<_Ty, 0>;
+    using const_iterator         = _Array_const_iterator<_Ty, 0>;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    using _Library_defined = array;
+
+    _CONSTEXPR20 void fill(const _Ty&) {}
+
+    _CONSTEXPR20 void swap(array&) noexcept {}
+
+    _NODISCARD _CONSTEXPR17 iterator begin() noexcept {
+        return iterator{};
+    }
+
+    _NODISCARD _CONSTEXPR17 const_iterator begin() const noexcept {
+        return const_iterator{};
+    }
+
+    _NODISCARD _CONSTEXPR17 iterator end() noexcept {
+        return iterator{};
+    }
+
+    _NODISCARD _CONSTEXPR17 const_iterator end() const noexcept {
+        return const_iterator{};
+    }
+
+    _NODISCARD _CONSTEXPR17 reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR17 const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR17 reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR17 const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR17 const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD _CONSTEXPR17 const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD _CONSTEXPR17 const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD _CONSTEXPR17 const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _CONSTEXPR17 _Ty* _Unchecked_begin() noexcept {
+        return nullptr;
+    }
+
+    _CONSTEXPR17 const _Ty* _Unchecked_begin() const noexcept {
+        return nullptr;
+    }
+
+    _CONSTEXPR17 _Ty* _Unchecked_end() noexcept {
+        return nullptr;
+    }
+
+    _CONSTEXPR17 const _Ty* _Unchecked_end() const noexcept {
+        return nullptr;
+    }
+
+    _NODISCARD constexpr size_type size() const noexcept {
+        return 0;
+    }
+
+    _NODISCARD constexpr size_type max_size() const noexcept {
+        return 0;
+    }
+
+    _NODISCARD_EMPTY_ARRAY_MEMBER constexpr bool empty() const noexcept {
+        return true;
+    }
+
+    [[noreturn]] reference at(size_type) {
+        _Xran();
+    }
+
+    [[noreturn]] const_reference at(size_type) const {
+        _Xran();
+    }
+
+    _NODISCARD reference operator[](size_type) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_REPORT_ERROR("array<T, 0> subscript is invalid");
+#endif
+
+        return *data();
+    }
+
+    _NODISCARD const_reference operator[](size_type) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_REPORT_ERROR("array<T, 0> subscript is invalid");
+#endif
+
+        return *data();
+    }
+
+    _NODISCARD reference front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_REPORT_ERROR("array<T, 0>::front() is invalid");
+#endif
+
+        return *data();
+    }
+
+    _NODISCARD const_reference front() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_REPORT_ERROR("array<T, 0>::front() is invalid");
+#endif
+
+        return *data();
+    }
+
+    _NODISCARD reference back() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_REPORT_ERROR("array<T, 0>::back() is invalid");
+#endif
+
+        return *data();
+    }
+
+    _NODISCARD const_reference back() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_REPORT_ERROR("array<T, 0>::back() is invalid");
+#endif
+
+        return *data();
+    }
+
+    _NODISCARD _CONSTEXPR17 _Ty* data() noexcept {
+        return nullptr;
+    }
+
+    _NODISCARD _CONSTEXPR17 const _Ty* data() const noexcept {
+        return nullptr;
+    }
+
+    conditional_t<disjunction_v<is_default_constructible<_Ty>, _Is_implicitly_default_constructible<_Ty>>, _Ty,
+        _Empty_array_element>
+        _Elems[1]{};
+
+private:
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid array<T, 0> subscript");
+    }
+};
+
+_EXPORT_STD template <class _Ty, size_t _Size, enable_if_t<_Size == 0 || _Is_swappable<_Ty>::value, int> = 0>
+_CONSTEXPR20 void swap(array<_Ty, _Size>& _Left, array<_Ty, _Size>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR20 bool operator==(const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
+    return _STD equal(_Left.data(), _Left.data() + _Size, _Right.data());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr _Synth_three_way_result<_Ty> operator<=>(
+    const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
+    return _STD lexicographical_compare_three_way(
+        _Left.data(), _Left.data() + _Size, _Right.data(), _Right.data() + _Size, _Synth_three_way{});
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, size_t _Size>
+_NODISCARD bool operator!=(const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR20 bool operator<(const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
+    return _STD lexicographical_compare(_Left.data(), _Left.data() + _Size, _Right.data(), _Right.data() + _Size);
+}
+
+template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR20 bool operator>(const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR20 bool operator<=(const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR20 bool operator>=(const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX20
+template <class _Ty, size_t _Size, size_t... _Idx>
+_NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> _To_array_lvalue_impl(
+    _Ty (&_Array)[_Size], index_sequence<_Idx...>) {
+    return {{_Array[_Idx]...}};
+}
+
+template <class _Ty, size_t _Size, size_t... _Idx>
+_NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> _To_array_rvalue_impl(
+    _Ty (&&_Array)[_Size], index_sequence<_Idx...>) {
+    return {{_STD move(_Array[_Idx])...}};
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&_Array)[_Size]) {
+    static_assert(!is_array_v<_Ty>, "N4950 [array.creation]/1: "
+                                    "to_array does not accept multidimensional arrays.");
+    static_assert(is_constructible_v<_Ty, _Ty&>, "N4950 [array.creation]/1: "
+                                                 "to_array requires copy constructible elements.");
+    return _STD _To_array_lvalue_impl(_Array, make_index_sequence<_Size>{});
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&&_Array)[_Size]) {
+    static_assert(!is_array_v<_Ty>, "N4950 [array.creation]/4: "
+                                    "to_array does not accept multidimensional arrays.");
+    static_assert(is_move_constructible_v<_Ty>, "N4950 [array.creation]/4: "
+                                                "to_array requires move constructible elements.");
+    return _STD _To_array_rvalue_impl(_STD move(_Array), make_index_sequence<_Size>{});
+}
+#endif // _HAS_CXX20
+
+template <class _Ty, class _Enable = void>
+constexpr bool _Is_library_defined = false;
+template <class _Ty>
+constexpr bool _Is_library_defined<_Ty, enable_if_t<is_same_v<typename _Ty::_Library_defined, _Ty>>> = true;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty& get(array<_Ty, _Size>& _Arr) noexcept {
+    static_assert(_Idx < _Size, "array index out of bounds");
+    if constexpr (_Is_library_defined<array<_Ty, _Size>>) {
+        return _Arr._Elems[_Idx];
+    } else {
+#if _HAS_CXX17
+        return _Arr[_Idx];
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        return const_cast<_Ty&>(_STD as_const(_Arr)[_Idx]);
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr const _Ty& get(const array<_Ty, _Size>& _Arr) noexcept {
+    static_assert(_Idx < _Size, "array index out of bounds");
+    if constexpr (_Is_library_defined<array<_Ty, _Size>>) {
+        return _Arr._Elems[_Idx];
+    } else {
+        return _Arr[_Idx];
+    }
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty&& get(array<_Ty, _Size>&& _Arr) noexcept {
+    static_assert(_Idx < _Size, "array index out of bounds");
+    if constexpr (_Is_library_defined<array<_Ty, _Size>>) {
+        return _STD move(_Arr._Elems[_Idx]);
+    } else {
+#if _HAS_CXX17
+        return _STD move(_Arr[_Idx]);
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        return const_cast<_Ty&&>(_STD move(_STD as_const(_Arr)[_Idx]));
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr const _Ty&& get(const array<_Ty, _Size>&& _Arr) noexcept {
+    static_assert(_Idx < _Size, "array index out of bounds");
+    if constexpr (_Is_library_defined<array<_Ty, _Size>>) {
+        return _STD move(_Arr._Elems[_Idx]);
+    } else {
+        return _STD move(_Arr[_Idx]);
+    }
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _ARRAY_
diff --git a/msvc-stl/stl/inc/atomic b/msvc-stl/stl/inc/atomic
new file mode 100644
index 0000000..384ebd3
--- /dev/null
+++ b/msvc-stl/stl/inc/atomic
@@ -0,0 +1,3033 @@
+// atomic standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _ATOMIC_
+#define _ATOMIC_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <atomic> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <xatomic.h>
+#include <xthreads.h>
+
+#if _HAS_CXX20
+#include <xatomic_wait.h>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// Allow _InterlockedCompareExchange128 to be used:
+#if defined(__clang__) && defined(_M_X64) && !defined(_M_ARM64EC)
+#pragma clang attribute _STD_ATOMIC_HEADER.push([[gnu::target("cx16")]], apply_to = function)
+#endif // ^^^ defined(__clang__) && defined(_M_X64) && !defined(_M_ARM64EC) ^^^
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _STD_ATOMIC_USE_ARM64_LDAR_STLR 1
+#ifdef __clang__
+#define __LOAD_ACQUIRE_ARM64(_Width, _Ptr) \
+    static_cast<__int##_Width>(__atomic_load_n(reinterpret_cast<const volatile unsigned __int##_Width*>(_Ptr), 2))
+#define __STORE_RELEASE(_Width, _Ptr, _Desired) \
+    _Compiler_barrier();                        \
+    __atomic_store_n(                           \
+        reinterpret_cast<volatile unsigned __int##_Width*>(_Ptr), static_cast<unsigned __int##_Width>(_Desired), 3)
+#else // ^^^ Clang / MSVC vvv
+#define __LOAD_ACQUIRE_ARM64(_Width, _Ptr) \
+    static_cast<__int##_Width>(__load_acquire##_Width(reinterpret_cast<const volatile unsigned __int##_Width*>(_Ptr)))
+#define __STORE_RELEASE(_Width, _Ptr, _Desired) \
+    _Compiler_barrier();                        \
+    __stlr##_Width(                             \
+        reinterpret_cast<volatile unsigned __int##_Width*>(_Ptr), static_cast<unsigned __int##_Width>(_Desired))
+#endif // ^^^ MSVC ^^^
+#else // ^^^ ARM64/ARM64EC/HYBRID_X86_ARM64 / Other architectures vvv
+#define _STD_ATOMIC_USE_ARM64_LDAR_STLR 0
+#define __STORE_RELEASE(_Width, _Ptr, _Desired) \
+    _Compiler_or_memory_barrier();              \
+    __iso_volatile_store##_Width((_Ptr), (_Desired))
+#endif // ^^^ Other architectures ^^^
+
+#define ATOMIC_BOOL_LOCK_FREE 2
+#define ATOMIC_CHAR_LOCK_FREE 2
+#ifdef __cpp_lib_char8_t
+#define ATOMIC_CHAR8_T_LOCK_FREE 2
+#endif // defined(__cpp_lib_char8_t)
+#define ATOMIC_CHAR16_T_LOCK_FREE 2
+#define ATOMIC_CHAR32_T_LOCK_FREE 2
+#define ATOMIC_WCHAR_T_LOCK_FREE  2
+#define ATOMIC_SHORT_LOCK_FREE    2
+#define ATOMIC_INT_LOCK_FREE      2
+#define ATOMIC_LONG_LOCK_FREE     2
+#define ATOMIC_LLONG_LOCK_FREE    2
+#define ATOMIC_POINTER_LOCK_FREE  2
+
+// The following code is SHARED with vcruntime and any updates
+// should be mirrored. Also: if any macros are added they should be
+// #undefed in vcruntime as well
+
+extern "C" {
+enum {
+    _Atomic_memory_order_relaxed,
+    _Atomic_memory_order_consume,
+    _Atomic_memory_order_acquire,
+    _Atomic_memory_order_release,
+    _Atomic_memory_order_acq_rel,
+    _Atomic_memory_order_seq_cst,
+};
+} // extern "C"
+
+#ifndef _INVALID_MEMORY_ORDER
+#ifdef _DEBUG
+#define _INVALID_MEMORY_ORDER _STL_REPORT_ERROR("Invalid memory order")
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _INVALID_MEMORY_ORDER
+#endif // ^^^ !defined(_DEBUG) ^^^
+#endif // _INVALID_MEMORY_ORDER
+
+extern "C" inline void _Check_memory_order(const unsigned int _Order) noexcept {
+    if (_Order > _Atomic_memory_order_seq_cst) {
+        _INVALID_MEMORY_ORDER;
+    }
+}
+
+// note: these macros are _not_ always safe to use with a trailing semicolon,
+// we avoid wrapping them in do {} while (0) because MSVC generates code for such loops
+// in debug mode.
+
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
+    _Check_memory_order(_Order);                                   \
+    _Result = _Intrinsic(__VA_ARGS__)
+#elif defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
+    switch (_Order) {                                              \
+    case _Atomic_memory_order_relaxed:                             \
+        _Result = _INTRIN_RELAXED(_Intrinsic)(__VA_ARGS__);        \
+        break;                                                     \
+    case _Atomic_memory_order_consume:                             \
+    case _Atomic_memory_order_acquire:                             \
+        _Result = _INTRIN_ACQUIRE(_Intrinsic)(__VA_ARGS__);        \
+        break;                                                     \
+    case _Atomic_memory_order_release:                             \
+        _Result = _INTRIN_RELEASE(_Intrinsic)(__VA_ARGS__);        \
+        break;                                                     \
+    default:                                                       \
+        _INVALID_MEMORY_ORDER;                                     \
+        _FALLTHROUGH;                                              \
+    case _Atomic_memory_order_acq_rel:                             \
+    case _Atomic_memory_order_seq_cst:                             \
+        _Result = _Intrinsic(__VA_ARGS__);                         \
+        break;                                                     \
+    }
+#endif // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64) ^^^
+
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+
+#define _ATOMIC_LOAD_ARM64(_Result, _Width, _Ptr, _Order_var) \
+    _Check_load_memory_order(_Order_var);                     \
+    if (_Order_var == memory_order_relaxed) {                 \
+        _Result = __iso_volatile_load##_Width(_Ptr);          \
+    } else {                                                  \
+        _Result = __LOAD_ACQUIRE_ARM64(_Width, _Ptr);         \
+        _Compiler_barrier();                                  \
+    }
+
+#endif // _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+
+#define _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order_var) \
+    _Check_load_memory_order(_Order_var);               \
+    if (_Order_var != memory_order_relaxed) {           \
+        _Compiler_or_memory_barrier();                  \
+    }
+
+#define _ATOMIC_STORE_SEQ_CST_ARM64(_Width, _Ptr, _Desired) \
+    __STORE_RELEASE(_Width, _Ptr, _Desired);                \
+    _Memory_barrier();
+
+#define _ATOMIC_STORE_SEQ_CST_X86_X64(_Width, _Ptr, _Desired) (void) _InterlockedExchange##_Width((_Ptr), (_Desired));
+#define _ATOMIC_STORE_32_SEQ_CST_X86_X64(_Ptr, _Desired) \
+    (void) _InterlockedExchange(reinterpret_cast<volatile long*>(_Ptr), static_cast<long>(_Desired));
+
+#define _ATOMIC_STORE_64_SEQ_CST_IX86(_Ptr, _Desired) \
+    _Compiler_barrier();                              \
+    __iso_volatile_store64((_Ptr), (_Desired));       \
+    _Atomic_thread_fence(_Atomic_memory_order_seq_cst);
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _ATOMIC_STORE_SEQ_CST(_Width, _Ptr, _Desired) _ATOMIC_STORE_SEQ_CST_ARM64(_Width, (_Ptr), (_Desired))
+#define _ATOMIC_STORE_32_SEQ_CST(_Ptr, _Desired)      _ATOMIC_STORE_SEQ_CST_ARM64(32, (_Ptr), (_Desired))
+#define _ATOMIC_STORE_64_SEQ_CST(_Ptr, _Desired)      _ATOMIC_STORE_SEQ_CST_ARM64(64, (_Ptr), (_Desired))
+#elif defined(_M_IX86) || defined(_M_X64) // ^^^ ARM64/ARM64EC/HYBRID_X86_ARM64 / x86/x64 vvv
+#define _ATOMIC_STORE_SEQ_CST(_Width, _Ptr, _Desired) _ATOMIC_STORE_SEQ_CST_X86_X64(_Width, (_Ptr), (_Desired))
+#define _ATOMIC_STORE_32_SEQ_CST(_Ptr, _Desired)      _ATOMIC_STORE_32_SEQ_CST_X86_X64((_Ptr), (_Desired))
+#ifdef _WIN64
+#define _ATOMIC_STORE_64_SEQ_CST(_Ptr, _Desired) _ATOMIC_STORE_SEQ_CST_X86_X64(64, (_Ptr), (_Desired))
+#else // ^^^ 64-bit / 32-bit vvv
+#define _ATOMIC_STORE_64_SEQ_CST(_Ptr, _Desired) _ATOMIC_STORE_64_SEQ_CST_IX86((_Ptr), (_Desired))
+#endif // ^^^ 32-bit ^^^
+#else // ^^^ x86/x64 / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+
+#pragma warning(push)
+#pragma warning(disable : 6001) // "Using uninitialized memory '_Guard'"
+#pragma warning(disable : 28113) // "Accessing a local variable _Guard via an Interlocked function: This is an unusual
+                                 // usage which could be reconsidered."
+extern "C" inline void _Atomic_thread_fence(const unsigned int _Order) noexcept {
+    if (_Order == _Atomic_memory_order_relaxed) {
+        return;
+    }
+
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+    _Compiler_barrier();
+    if (_Order == _Atomic_memory_order_seq_cst) {
+        volatile long _Guard; // Not initialized to avoid an unnecessary operation; the value does not matter
+
+        // _mm_mfence could have been used, but it is slower on some CPUs.
+        // The memory fence provided by interlocked operations has some exceptions, but this is fine:
+        // std::atomic_thread_fence works with respect to other atomics only; it may not be a full fence for all ops.
+        (void) _InterlockedIncrement(&_Guard);
+        _Compiler_barrier();
+    }
+#elif defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    if (_Order == _Atomic_memory_order_acquire || _Order == _Atomic_memory_order_consume) {
+        _Memory_load_acquire_barrier();
+    } else {
+        _Memory_barrier();
+    }
+#else // ^^^ ARM64/ARM64EC/HYBRID_X86_ARM64 / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+}
+#pragma warning(pop)
+
+// End of code shared with vcruntime
+
+extern "C" {
+_Smtx_t* __stdcall __std_atomic_get_mutex(const void* _Key) noexcept;
+} // extern "C"
+// Padding bits should not participate in cmpxchg comparison starting in C++20.
+// Clang does not have __builtin_zero_non_value_bits to exclude these bits to implement this C++20 feature.
+// The EDG front-end substitutes everything and runs into incomplete types passed to atomic<T>.
+#if _HAS_CXX20 && !defined(__clang__) /* TRANSITION, LLVM-46685 */ && !defined(__EDG__)
+#define _CMPXCHG_MASK_OUT_PADDING_BITS 1
+#else
+#define _CMPXCHG_MASK_OUT_PADDING_BITS 0
+#endif
+
+_STD_BEGIN
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+struct _Form_mask_t {};
+inline constexpr _Form_mask_t _Form_mask{};
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+
+template <class _Ty>
+struct _Storage_for {
+    // uninitialized space to store a _Ty
+    alignas(_Ty) unsigned char _Storage[sizeof(_Ty)];
+
+    _Storage_for()                               = default;
+    _Storage_for(const _Storage_for&)            = delete;
+    _Storage_for& operator=(const _Storage_for&) = delete;
+
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+    explicit _Storage_for(_Form_mask_t) noexcept {
+        _CSTD memset(_Storage, 0xff, sizeof(_Ty));
+        ::__builtin_zero_non_value_bits(_Ptr()); // TRANSITION, DevCom-10456452
+    }
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+
+    _NODISCARD _Ty& _Ref() noexcept {
+        return reinterpret_cast<_Ty&>(_Storage);
+    }
+
+    _NODISCARD _Ty* _Ptr() noexcept {
+        return reinterpret_cast<_Ty*>(&_Storage);
+    }
+};
+
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+template <class _Ty>
+constexpr bool _Might_have_non_value_bits = !has_unique_object_representations_v<_Ty> && !is_floating_point_v<_Ty>;
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+
+_EXPORT_STD extern "C" inline void atomic_thread_fence(const memory_order _Order) noexcept {
+    ::_Atomic_thread_fence(static_cast<unsigned int>(_Order));
+}
+
+_EXPORT_STD extern "C" inline void atomic_signal_fence(const memory_order _Order) noexcept {
+    if (_Order != memory_order_relaxed) {
+        _Compiler_barrier();
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty kill_dependency(_Ty _Arg) noexcept { // "magic" template that kills dependency ordering when called
+    return _Arg;
+}
+
+inline void _Check_store_memory_order(const memory_order _Order) noexcept {
+    switch (_Order) {
+    case memory_order_relaxed:
+    case memory_order_release:
+    case memory_order_seq_cst:
+        // nothing to do
+        break;
+    case memory_order_consume:
+    case memory_order_acquire:
+    case memory_order_acq_rel:
+    default:
+        _INVALID_MEMORY_ORDER;
+        break;
+    }
+}
+
+inline void _Check_load_memory_order(const memory_order _Order) noexcept {
+    switch (_Order) {
+    case memory_order_relaxed:
+    case memory_order_consume:
+    case memory_order_acquire:
+    case memory_order_seq_cst:
+        // nothing to do
+        break;
+    case memory_order_release:
+    case memory_order_acq_rel:
+    default:
+        _INVALID_MEMORY_ORDER;
+        break;
+    }
+}
+
+_NODISCARD inline memory_order _Combine_cas_memory_orders(
+    const memory_order _Success, const memory_order _Failure) noexcept {
+    // Finds upper bound of a compare/exchange memory order
+    // pair, according to the following partial order:
+    //     seq_cst
+    //        |
+    //     acq_rel
+    //     /     \
+    // acquire  release
+    //    |       |
+    // consume    |
+    //     \     /
+    //     relaxed
+    static constexpr memory_order _Combined_memory_orders[6][6] = {// combined upper bounds
+        {memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel,
+            memory_order_seq_cst},
+        {memory_order_consume, memory_order_consume, memory_order_acquire, memory_order_acq_rel, memory_order_acq_rel,
+            memory_order_seq_cst},
+        {memory_order_acquire, memory_order_acquire, memory_order_acquire, memory_order_acq_rel, memory_order_acq_rel,
+            memory_order_seq_cst},
+        {memory_order_release, memory_order_acq_rel, memory_order_acq_rel, memory_order_release, memory_order_acq_rel,
+            memory_order_seq_cst},
+        {memory_order_acq_rel, memory_order_acq_rel, memory_order_acq_rel, memory_order_acq_rel, memory_order_acq_rel,
+            memory_order_seq_cst},
+        {memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst,
+            memory_order_seq_cst}};
+
+    _Check_memory_order(static_cast<unsigned int>(_Success));
+    _Check_load_memory_order(_Failure);
+    return _Combined_memory_orders[static_cast<int>(_Success)][static_cast<int>(_Failure)];
+}
+
+#if 1 // TRANSITION, ABI
+template <class _Ty>
+struct _Atomic_padded {
+    alignas(sizeof(_Ty)) mutable _Ty _Value; // align to sizeof(T); x86 stack aligns 8-byte objects on 4-byte boundaries
+};
+
+#else // ^^^ don't break ABI / break ABI vvv
+template <class _Ty>
+struct _Atomic_storage_traits { // properties for how _Ty is stored in an atomic
+    static constexpr size_t _Storage_size = sizeof(_Ty) == 1 ? 1
+                                          : sizeof(_Ty) == 2 ? 2
+                                          : sizeof(_Ty) <= 4 ? 4
+                                          : sizeof(_Ty) <= 8 ? 8
+#ifdef _WIN64
+                                          : sizeof(_Ty) <= 16 ? 16
+#endif // ^^^ 64-bit ^^^
+                                                              : sizeof(_Ty);
+
+    static constexpr size_t _Padding_size = _Storage_size - sizeof(_Ty);
+    static constexpr bool _Uses_padding   = _Padding_size != 0;
+};
+
+template <class _Ty>
+struct _Atomic_storage_traits<_Ty&> { // properties for how _Ty is stored in an atomic_ref
+    static constexpr size_t _Storage_size = sizeof(_Ty);
+    static constexpr bool _Uses_padding   = false;
+};
+
+template <class _Ty, bool = _Atomic_storage_traits<_Ty>::_Uses_padding>
+struct _Atomic_padded { // aggregate to allow explicit constexpr zeroing of padding
+    alignas(_Atomic_storage_traits<_Ty>::_Storage_size) mutable _Ty _Value;
+    mutable unsigned char _Padding[_Atomic_storage_traits<_Ty>::_Padding_size];
+};
+
+template <class _Ty>
+struct _Atomic_padded<_Ty, false> {
+    alignas(sizeof(_Ty)) mutable _Ty _Value; // align to sizeof(T); x86 stack aligns 8-byte objects on 4-byte boundaries
+};
+
+template <class _Ty>
+struct _Atomic_padded<_Ty&, false> {
+    _Ty& _Value;
+};
+
+#endif // ^^^ break ABI ^^^
+
+template <class _Ty>
+struct _Atomic_storage_types {
+    using _TStorage = _Atomic_padded<_Ty>;
+    using _Spinlock = long;
+};
+
+template <class _Ty>
+struct _Atomic_storage_types<_Ty&> {
+    using _TStorage = _Ty&;
+    using _Spinlock = _Smtx_t*; // POINTER TO mutex
+};
+
+#if 1 // TRANSITION, ABI
+template <class _Ty, size_t = sizeof(remove_reference_t<_Ty>)>
+#else // ^^^ don't break ABI / break ABI vvv
+template <class _Ty, size_t = _Atomic_storage_traits<_Ty>::_Storage_size>
+#endif // ^^^ break ABI ^^^
+struct _Atomic_storage;
+
+#if _HAS_CXX20
+template <class _Ty, class _Value_type>
+void _Atomic_wait_direct(
+    const _Atomic_storage<_Ty>* const _This, _Value_type _Expected_bytes, const memory_order _Order) noexcept {
+    const auto _Storage_ptr =
+        const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_This->_Storage)));
+    for (;;) {
+        const _Value_type _Observed_bytes = _STD _Bit_cast<_Value_type>(_This->load(_Order));
+        if (_Expected_bytes != _Observed_bytes) {
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+            using _TVal = _Remove_cvref_t<_Ty>;
+            if constexpr (_Might_have_non_value_bits<_TVal>) {
+                _Storage_for<_TVal> _Mask{_Form_mask};
+                const _Value_type _Mask_val = _STD _Bit_cast<_Value_type>(_Mask._Ref());
+
+                if (((_Expected_bytes ^ _Observed_bytes) & _Mask_val) == 0) {
+                    _Expected_bytes = _Observed_bytes;
+                    continue;
+                }
+            }
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+
+            return;
+        }
+
+        ::__std_atomic_wait_direct(_Storage_ptr, &_Expected_bytes, sizeof(_Value_type), __std_atomic_wait_no_timeout);
+    }
+}
+#endif // _HAS_CXX20
+
+#if 1 // TRANSITION, ABI, GH-1151
+inline void _Atomic_lock_acquire(long& _Spinlock) noexcept {
+#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
+    // Algorithm from Intel(R) 64 and IA-32 Architectures Optimization Reference Manual, May 2020
+    // Example 2-4. Contended Locks with Increasing Back-off Example - Improved Version, page 2-22
+    // The code in mentioned manual is covered by the 0BSD license.
+    int _Current_backoff       = 1;
+    constexpr int _Max_backoff = 64;
+    while (_InterlockedExchange(&_Spinlock, 1) != 0) {
+        while (__iso_volatile_load32(&reinterpret_cast<int&>(_Spinlock)) != 0) {
+            for (int _Count_down = _Current_backoff; _Count_down != 0; --_Count_down) {
+                _mm_pause();
+            }
+            _Current_backoff = _Current_backoff < _Max_backoff ? _Current_backoff << 1 : _Max_backoff;
+        }
+    }
+#elif defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+    while (_InterlockedExchange_acq(&_Spinlock, 1) != 0) {
+        while (__iso_volatile_load32(&reinterpret_cast<int&>(_Spinlock)) != 0) {
+            __yield();
+        }
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64) / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+}
+
+inline void _Atomic_lock_release(long& _Spinlock) noexcept {
+    __STORE_RELEASE(32, reinterpret_cast<int*>(&_Spinlock), 0);
+}
+
+inline void _Atomic_lock_acquire(_Smtx_t* _Spinlock) noexcept {
+    _Smtx_lock_exclusive(_Spinlock);
+}
+
+inline void _Atomic_lock_release(_Smtx_t* _Spinlock) noexcept {
+    _Smtx_unlock_exclusive(_Spinlock);
+}
+
+template <class _Spinlock_t>
+class _NODISCARD _Atomic_lock_guard {
+public:
+    explicit _Atomic_lock_guard(_Spinlock_t& _Spinlock_) noexcept : _Spinlock(_Spinlock_) {
+        _Atomic_lock_acquire(_Spinlock);
+    }
+
+    ~_Atomic_lock_guard() {
+        _Atomic_lock_release(_Spinlock);
+    }
+
+    _Atomic_lock_guard(const _Atomic_lock_guard&)            = delete;
+    _Atomic_lock_guard& operator=(const _Atomic_lock_guard&) = delete;
+
+private:
+    _Spinlock_t& _Spinlock;
+};
+
+#if _HAS_CXX20
+template <class _Spinlock_t>
+bool __stdcall _Atomic_wait_compare_non_lock_free(
+    const void* _Storage, void* _Comparand, size_t _Size, void* _Spinlock_raw) noexcept {
+    _Spinlock_t& _Spinlock = *static_cast<_Spinlock_t*>(_Spinlock_raw);
+    _Atomic_lock_acquire(_Spinlock);
+    const auto _Cmp_result = _CSTD memcmp(_Storage, _Comparand, _Size);
+    _Atomic_lock_release(_Spinlock);
+    return _Cmp_result == 0;
+}
+
+#ifdef _WIN64
+inline bool __stdcall _Atomic_wait_compare_16_bytes(const void* _Storage, void* _Comparand, size_t, void*) noexcept {
+    const auto _Dest              = static_cast<long long*>(const_cast<void*>(_Storage));
+    const auto _Cmp               = static_cast<const long long*>(_Comparand);
+    alignas(16) long long _Tmp[2] = {_Cmp[0], _Cmp[1]};
+#if defined(_M_X64) && !defined(_M_ARM64EC)
+    return _InterlockedCompareExchange128(_Dest, _Tmp[1], _Tmp[0], _Tmp) != 0;
+#else // ^^^ _M_X64 / ARM64, _M_ARM64EC vvv
+    return _InterlockedCompareExchange128_nf(_Dest, _Tmp[1], _Tmp[0], _Tmp) != 0;
+#endif // ^^^ ARM64, _M_ARM64EC ^^^
+}
+#endif // ^^^ 64-bit ^^^
+#endif // _HAS_CXX20
+#endif // TRANSITION, ABI
+
+#if _HAS_CXX20
+_EXPORT_STD template <class>
+struct atomic_ref;
+#endif // _HAS_CXX20
+
+template <class _Ty, size_t /* = ... */>
+struct _Atomic_storage {
+    // Provides operations common to all specializations of std::atomic, load, store, exchange, and CAS.
+    // Locking version used when hardware has no atomic operations for sizeof(_Ty).
+
+    using _TVal  = _Remove_cvref_t<_Ty>;
+    using _Guard = _Atomic_lock_guard<typename _Atomic_storage_types<_Ty>::_Spinlock>;
+
+    _Atomic_storage() = default;
+
+    /* implicit */ constexpr _Atomic_storage(const _Ty& _Value) noexcept : _Storage(_Value) {
+        // non-atomically initialize this atomic
+    }
+
+    void store(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // store with sequential consistency
+        _Check_store_memory_order(_Order);
+        _Guard _Lock{_Spinlock};
+        _Storage = _Value;
+    }
+
+    _NODISCARD _TVal load(const memory_order _Order = memory_order_seq_cst) const noexcept {
+        // load with sequential consistency
+        _Check_load_memory_order(_Order);
+        _Guard _Lock{_Spinlock};
+        _TVal _Local(_Storage);
+        return _Local;
+    }
+
+    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // exchange _Value with _Storage with sequential consistency
+        _Check_memory_order(static_cast<unsigned int>(_Order));
+        _Guard _Lock{_Spinlock};
+        _TVal _Result(_Storage);
+        _Storage = _Value;
+        return _Result;
+    }
+
+    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
+        const memory_order _Order = memory_order_seq_cst) noexcept { // CAS with sequential consistency, plain
+        _Check_memory_order(static_cast<unsigned int>(_Order));
+        const auto _Storage_ptr  = _STD addressof(_Storage);
+        const auto _Expected_ptr = _STD addressof(_Expected);
+        bool _Result;
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+        ::__builtin_zero_non_value_bits(_Expected_ptr); // TRANSITION, DevCom-10456452
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+        _Guard _Lock{_Spinlock};
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+        if constexpr (_Might_have_non_value_bits<_TVal>) {
+            _Storage_for<_TVal> _Local;
+            const auto _Local_ptr = _Local._Ptr();
+            _CSTD memcpy(_Local_ptr, _Storage_ptr, sizeof(_TVal));
+            ::__builtin_zero_non_value_bits(_Local_ptr); // TRANSITION, DevCom-10456452
+            _Result = _CSTD memcmp(_Local_ptr, _Expected_ptr, sizeof(_TVal)) == 0;
+        } else {
+            _Result = _CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) == 0;
+        }
+#else // ^^^ _CMPXCHG_MASK_OUT_PADDING_BITS / !_CMPXCHG_MASK_OUT_PADDING_BITS vvv
+        _Result = _CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) == 0;
+#endif // ^^^ !_CMPXCHG_MASK_OUT_PADDING_BITS ^^^
+        if (_Result) {
+            _CSTD memcpy(_Storage_ptr, _STD addressof(_Desired), sizeof(_TVal));
+        } else {
+            _CSTD memcpy(_Expected_ptr, _Storage_ptr, sizeof(_TVal));
+        }
+
+        return _Result;
+    }
+
+#if _HAS_CXX20
+    void wait(_TVal _Expected, memory_order = memory_order_seq_cst) const noexcept {
+        const auto _Storage_ptr  = _STD addressof(_Storage);
+        const auto _Expected_ptr = _STD addressof(_Expected);
+        for (;;) {
+            {
+                _Guard _Lock{_Spinlock};
+                if (_CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) != 0) {
+                    // contents differed, we might be done, check for padding
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+                    if constexpr (_Might_have_non_value_bits<_TVal>) {
+                        _Storage_for<_TVal> _Local;
+                        const auto _Local_ptr = _Local._Ptr();
+                        _CSTD memcpy(_Local_ptr, _Storage_ptr, sizeof(_TVal));
+                        ::__builtin_zero_non_value_bits(_Local_ptr); // TRANSITION, DevCom-10456452
+                        ::__builtin_zero_non_value_bits(_Expected_ptr); // TRANSITION, DevCom-10456452
+                        if (_CSTD memcmp(_Local_ptr, _Expected_ptr, sizeof(_TVal)) == 0) {
+                            // _Storage differs from _Expected only by padding; copy the padding from _Storage into
+                            // _Expected
+                            _CSTD memcpy(_Expected_ptr, _Storage_ptr, sizeof(_TVal));
+                        } else {
+                            // truly different, we're done
+                            return;
+                        }
+                    } else
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+                    {
+                        return;
+                    }
+                }
+            } // unlock
+
+            ::__std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), &_Spinlock,
+                &_Atomic_wait_compare_non_lock_free<decltype(_Spinlock)>, __std_atomic_wait_no_timeout);
+        }
+    }
+
+    void notify_one() noexcept {
+        ::__std_atomic_notify_one_indirect(_STD addressof(_Storage));
+    }
+
+    void notify_all() noexcept {
+        ::__std_atomic_notify_all_indirect(_STD addressof(_Storage));
+    }
+#endif // _HAS_CXX20
+
+#if 1 // TRANSITION, ABI
+protected:
+    void _Init_spinlock_for_ref() noexcept {
+        _Spinlock = ::__std_atomic_get_mutex(_STD addressof(_Storage));
+    }
+
+private:
+    // Spinlock integer for non-lock-free atomic. <xthreads.h> mutex pointer for non-lock-free atomic_ref
+    mutable typename _Atomic_storage_types<_Ty>::_Spinlock _Spinlock{};
+
+public:
+    _Ty _Storage{};
+
+#else // ^^^ don't break ABI / break ABI vvv
+    _Ty _Storage;
+    mutable _Smtx_t _Mutex{};
+#endif // ^^^ break ABI ^^^
+
+#if _HAS_CXX20
+    template <class>
+    friend struct atomic_ref;
+#endif // _HAS_CXX20
+};
+
+template <class _Ty>
+struct _Atomic_storage<_Ty, 1> { // lock-free using 1-byte intrinsics
+    using _TVal = _Remove_cvref_t<_Ty>;
+
+    _Atomic_storage() = default;
+
+    /* implicit */ constexpr _Atomic_storage(const _Ty& _Value) noexcept : _Storage{_Value} {
+        // non-atomically initialize this atomic
+    }
+
+    void store(const _TVal _Value) noexcept { // store with sequential consistency
+        const auto _Mem      = _STD _Atomic_address_as<char>(_Storage);
+        const char _As_bytes = _STD _Bit_cast<char>(_Value);
+        _ATOMIC_STORE_SEQ_CST(8, _Mem, _As_bytes)
+    }
+
+    void store(const _TVal _Value, const memory_order _Order) noexcept { // store with given memory order
+        const auto _Mem      = _STD _Atomic_address_as<char>(_Storage);
+        const char _As_bytes = _STD _Bit_cast<char>(_Value);
+
+        _Check_store_memory_order(_Order);
+
+        if (_Order == memory_order_relaxed) {
+            __iso_volatile_store8(_Mem, _As_bytes);
+        } else if (_Order == memory_order_release) {
+            __STORE_RELEASE(8, _Mem, _As_bytes);
+        } else {
+            store(_Value);
+        }
+    }
+
+    _NODISCARD _TVal load(
+        const memory_order _Order = memory_order_seq_cst) const noexcept { // load with given memory order
+        const auto _Mem = _STD _Atomic_address_as<char>(_Storage);
+        char _As_bytes;
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+        _ATOMIC_LOAD_ARM64(_As_bytes, 8, _Mem, _Order)
+#else // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1 / _STD_ATOMIC_USE_ARM64_LDAR_STLR == 0 vvv
+        _As_bytes = __iso_volatile_load8(_Mem);
+        _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order)
+#endif // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR == 0 ^^^
+        return reinterpret_cast<_TVal&>(_As_bytes);
+    }
+
+    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // exchange with given memory order
+        char _As_bytes;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _As_bytes, _InterlockedExchange8,
+            _STD _Atomic_address_as<char>(_Storage), _STD _Bit_cast<char>(_Value));
+        return reinterpret_cast<_TVal&>(_As_bytes);
+    }
+
+    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
+        const memory_order _Order = memory_order_seq_cst) noexcept { // CAS with given memory order
+        char _Expected_bytes = _STD _Bit_cast<char>(_Expected); // read before atomic operation
+        char _Prev_bytes;
+
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+        if constexpr (_Might_have_non_value_bits<_TVal>) {
+            _Storage_for<_TVal> _Mask{_Form_mask};
+            const char _Mask_val = _STD _Bit_cast<char>(_Mask._Ref());
+
+            for (;;) {
+                _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Prev_bytes, _InterlockedCompareExchange8,
+                    _STD _Atomic_address_as<char>(_Storage), _STD _Bit_cast<char>(_Desired), _Expected_bytes);
+                if (_Prev_bytes == _Expected_bytes) {
+                    return true;
+                }
+
+                if ((_Prev_bytes ^ _Expected_bytes) & _Mask_val) {
+                    reinterpret_cast<char&>(_Expected) = _Prev_bytes;
+                    return false;
+                }
+                _Expected_bytes = (_Expected_bytes & _Mask_val) | (_Prev_bytes & ~_Mask_val);
+            }
+        }
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Prev_bytes, _InterlockedCompareExchange8,
+            _STD _Atomic_address_as<char>(_Storage), _STD _Bit_cast<char>(_Desired), _Expected_bytes);
+        if (_Prev_bytes == _Expected_bytes) {
+            return true;
+        }
+
+        reinterpret_cast<char&>(_Expected) = _Prev_bytes;
+        return false;
+    }
+
+#if _HAS_CXX20
+    void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
+        _STD _Atomic_wait_direct(this, _STD _Bit_cast<char>(_Expected), _Order);
+    }
+
+    void notify_one() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_one_direct(_Storage_ptr);
+    }
+
+    void notify_all() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_all_direct(_Storage_ptr);
+    }
+#endif // _HAS_CXX20
+
+    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
+};
+
+template <class _Ty>
+struct _Atomic_storage<_Ty, 2> { // lock-free using 2-byte intrinsics
+    using _TVal = _Remove_cvref_t<_Ty>;
+
+    _Atomic_storage() = default;
+
+    /* implicit */ constexpr _Atomic_storage(const _Ty& _Value) noexcept : _Storage{_Value} {
+        // non-atomically initialize this atomic
+    }
+
+    void store(const _TVal _Value) noexcept { // store with sequential consistency
+        const auto _Mem       = _STD _Atomic_address_as<short>(_Storage);
+        const short _As_bytes = _STD _Bit_cast<short>(_Value);
+        _ATOMIC_STORE_SEQ_CST(16, _Mem, _As_bytes)
+    }
+
+    void store(const _TVal _Value, const memory_order _Order) noexcept { // store with given memory order
+        const auto _Mem       = _STD _Atomic_address_as<short>(_Storage);
+        const short _As_bytes = _STD _Bit_cast<short>(_Value);
+
+        _Check_store_memory_order(_Order);
+
+        if (_Order == memory_order_relaxed) {
+            __iso_volatile_store16(_Mem, _As_bytes);
+        } else if (_Order == memory_order_release) {
+            __STORE_RELEASE(16, _Mem, _As_bytes);
+        } else {
+            store(_Value);
+        }
+    }
+
+    _NODISCARD _TVal load(
+        const memory_order _Order = memory_order_seq_cst) const noexcept { // load with given memory order
+        const auto _Mem = _STD _Atomic_address_as<short>(_Storage);
+        short _As_bytes;
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+        _ATOMIC_LOAD_ARM64(_As_bytes, 16, _Mem, _Order)
+#else // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1 / _STD_ATOMIC_USE_ARM64_LDAR_STLR == 0 vvv
+        _As_bytes = __iso_volatile_load16(_Mem);
+        _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order)
+#endif // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR == 0 ^^^
+        return reinterpret_cast<_TVal&>(_As_bytes);
+    }
+
+    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // exchange with given memory order
+        short _As_bytes;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _As_bytes, _InterlockedExchange16,
+            _STD _Atomic_address_as<short>(_Storage), _STD _Bit_cast<short>(_Value));
+        return reinterpret_cast<_TVal&>(_As_bytes);
+    }
+
+    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
+        const memory_order _Order = memory_order_seq_cst) noexcept { // CAS with given memory order
+        short _Expected_bytes = _STD _Bit_cast<short>(_Expected); // read before atomic operation
+        short _Prev_bytes;
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+        if constexpr (_Might_have_non_value_bits<_Ty>) {
+            _Storage_for<_TVal> _Mask{_Form_mask};
+            const short _Mask_val = _STD _Bit_cast<short>(_Mask._Ref());
+
+            for (;;) {
+                _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Prev_bytes, _InterlockedCompareExchange16,
+                    _STD _Atomic_address_as<short>(_Storage), _STD _Bit_cast<short>(_Desired), _Expected_bytes);
+                if (_Prev_bytes == _Expected_bytes) {
+                    return true;
+                }
+
+                if ((_Prev_bytes ^ _Expected_bytes) & _Mask_val) {
+                    _CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
+                    return false;
+                }
+                _Expected_bytes = (_Expected_bytes & _Mask_val) | (_Prev_bytes & ~_Mask_val);
+            }
+        }
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Prev_bytes, _InterlockedCompareExchange16,
+            _STD _Atomic_address_as<short>(_Storage), _STD _Bit_cast<short>(_Desired), _Expected_bytes);
+        if (_Prev_bytes == _Expected_bytes) {
+            return true;
+        }
+
+        _CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_Ty));
+        return false;
+    }
+
+#if _HAS_CXX20
+    void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
+        _STD _Atomic_wait_direct(this, _STD _Bit_cast<short>(_Expected), _Order);
+    }
+
+    void notify_one() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_one_direct(_Storage_ptr);
+    }
+
+    void notify_all() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_all_direct(_Storage_ptr);
+    }
+#endif // _HAS_CXX20
+
+    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
+};
+
+template <class _Ty>
+struct _Atomic_storage<_Ty, 4> { // lock-free using 4-byte intrinsics
+    using _TVal = _Remove_cvref_t<_Ty>;
+
+    _Atomic_storage() = default;
+
+    /* implicit */ constexpr _Atomic_storage(const _Ty& _Value) noexcept : _Storage{_Value} {
+        // non-atomically initialize this atomic
+    }
+
+    void store(const _TVal _Value) noexcept { // store with sequential consistency
+        const auto _Mem     = _STD _Atomic_address_as<int>(_Storage);
+        const int _As_bytes = _STD _Bit_cast<int>(_Value);
+        _ATOMIC_STORE_32_SEQ_CST(_Mem, _As_bytes)
+    }
+
+    void store(const _TVal _Value, const memory_order _Order) noexcept { // store with given memory order
+        const auto _Mem     = _STD _Atomic_address_as<int>(_Storage);
+        const int _As_bytes = _STD _Bit_cast<int>(_Value);
+
+        _Check_store_memory_order(_Order);
+
+        if (_Order == memory_order_relaxed) {
+            __iso_volatile_store32(_Mem, _As_bytes);
+        } else if (_Order == memory_order_release) {
+            __STORE_RELEASE(32, _Mem, _As_bytes);
+        } else {
+            store(_Value);
+        }
+    }
+
+    _NODISCARD _TVal load(
+        const memory_order _Order = memory_order_seq_cst) const noexcept { // load with given memory order
+        const auto _Mem = _STD _Atomic_address_as<int>(_Storage);
+        int _As_bytes;
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+        _ATOMIC_LOAD_ARM64(_As_bytes, 32, _Mem, _Order)
+#else // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1 / _STD_ATOMIC_USE_ARM64_LDAR_STLR == 0 vvv
+        _As_bytes = __iso_volatile_load32(_Mem);
+        _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order)
+#endif // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR == 0 ^^^
+        return reinterpret_cast<_TVal&>(_As_bytes);
+    }
+
+    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // exchange with given memory order
+        long _As_bytes;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _As_bytes, _InterlockedExchange,
+            _STD _Atomic_address_as<long>(_Storage), _STD _Bit_cast<long>(_Value));
+        return reinterpret_cast<_TVal&>(_As_bytes);
+    }
+
+    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
+        const memory_order _Order = memory_order_seq_cst) noexcept { // CAS with given memory order
+        long _Expected_bytes = _STD _Bit_cast<long>(_Expected); // read before atomic operation
+        long _Prev_bytes;
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+        if constexpr (_Might_have_non_value_bits<_TVal>) {
+            _Storage_for<_TVal> _Mask{_Form_mask};
+            const long _Mask_val = _STD _Bit_cast<long>(_Mask._Ref());
+
+            for (;;) {
+                _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Prev_bytes, _InterlockedCompareExchange,
+                    _STD _Atomic_address_as<long>(_Storage), _STD _Bit_cast<long>(_Desired), _Expected_bytes);
+                if (_Prev_bytes == _Expected_bytes) {
+                    return true;
+                }
+
+                if ((_Prev_bytes ^ _Expected_bytes) & _Mask_val) {
+                    _CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
+                    return false;
+                }
+                _Expected_bytes = (_Expected_bytes & _Mask_val) | (_Prev_bytes & ~_Mask_val);
+            }
+        }
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Prev_bytes, _InterlockedCompareExchange,
+            _STD _Atomic_address_as<long>(_Storage), _STD _Bit_cast<long>(_Desired), _Expected_bytes);
+        if (_Prev_bytes == _Expected_bytes) {
+            return true;
+        }
+
+        _CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
+        return false;
+    }
+
+#if _HAS_CXX20
+    void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
+        _STD _Atomic_wait_direct(this, _STD _Bit_cast<long>(_Expected), _Order);
+    }
+
+    void notify_one() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_one_direct(_Storage_ptr);
+    }
+
+    void notify_all() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_all_direct(_Storage_ptr);
+    }
+#endif // _HAS_CXX20
+
+    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
+};
+
+template <class _Ty>
+struct _Atomic_storage<_Ty, 8> { // lock-free using 8-byte intrinsics
+    using _TVal = _Remove_cvref_t<_Ty>;
+
+    _Atomic_storage() = default;
+
+    /* implicit */ constexpr _Atomic_storage(const _Ty& _Value) noexcept : _Storage{_Value} {
+        // non-atomically initialize this atomic
+    }
+
+    void store(const _TVal _Value) noexcept { // store with sequential consistency
+        const auto _Mem           = _STD _Atomic_address_as<long long>(_Storage);
+        const long long _As_bytes = _STD _Bit_cast<long long>(_Value);
+        _ATOMIC_STORE_64_SEQ_CST(_Mem, _As_bytes);
+    }
+
+    void store(const _TVal _Value, const memory_order _Order) noexcept { // store with given memory order
+        const auto _Mem           = _STD _Atomic_address_as<long long>(_Storage);
+        const long long _As_bytes = _STD _Bit_cast<long long>(_Value);
+
+        _Check_store_memory_order(_Order);
+
+        if (_Order == memory_order_relaxed) {
+            __iso_volatile_store64(_Mem, _As_bytes);
+        } else if (_Order == memory_order_release) {
+            __STORE_RELEASE(64, _Mem, _As_bytes);
+        } else {
+            store(_Value);
+        }
+    }
+
+    _NODISCARD _TVal load(
+        const memory_order _Order = memory_order_seq_cst) const noexcept { // load with given memory order
+        const auto _Mem = _STD _Atomic_address_as<long long>(_Storage);
+        long long _As_bytes;
+#if _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1
+        _ATOMIC_LOAD_ARM64(_As_bytes, 64, _Mem, _Order)
+#else // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR == 1 / _STD_ATOMIC_USE_ARM64_LDAR_STLR != 1 vvv
+        _As_bytes = __iso_volatile_load64(_Mem);
+        _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED(_Order)
+#endif // ^^^ _STD_ATOMIC_USE_ARM64_LDAR_STLR != 1 ^^^
+        return reinterpret_cast<_TVal&>(_As_bytes);
+    }
+
+#ifdef _WIN64
+    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // exchange with given memory order
+        long long _As_bytes;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _As_bytes, _InterlockedExchange64,
+            _STD _Atomic_address_as<long long>(_Storage), _STD _Bit_cast<long long>(_Value));
+        return reinterpret_cast<_TVal&>(_As_bytes);
+    }
+#else // ^^^ 64-bit / 32-bit vvv
+    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // exchange with (effectively) sequential consistency
+        _TVal _Temp{load()};
+        while (!compare_exchange_strong(_Temp, _Value, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+#endif // ^^^ 32-bit ^^^
+
+    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
+        const memory_order _Order = memory_order_seq_cst) noexcept { // CAS with given memory order
+        long long _Expected_bytes = _STD _Bit_cast<long long>(_Expected); // read before atomic operation
+        long long _Prev_bytes;
+
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+        if constexpr (_Might_have_non_value_bits<_TVal>) {
+            _Storage_for<_TVal> _Mask{_Form_mask};
+            const long long _Mask_val = _STD _Bit_cast<long long>(_Mask._Ref());
+
+            for (;;) {
+                _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Prev_bytes, _InterlockedCompareExchange64,
+                    _STD _Atomic_address_as<long long>(_Storage), _STD _Bit_cast<long long>(_Desired), _Expected_bytes);
+                if (_Prev_bytes == _Expected_bytes) {
+                    return true;
+                }
+
+                if ((_Prev_bytes ^ _Expected_bytes) & _Mask_val) {
+                    _CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
+                    return false;
+                }
+                _Expected_bytes = (_Expected_bytes & _Mask_val) | (_Prev_bytes & ~_Mask_val);
+            }
+        }
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Prev_bytes, _InterlockedCompareExchange64,
+            _STD _Atomic_address_as<long long>(_Storage), _STD _Bit_cast<long long>(_Desired), _Expected_bytes);
+        if (_Prev_bytes == _Expected_bytes) {
+            return true;
+        }
+
+        _CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
+        return false;
+    }
+
+#if _HAS_CXX20
+    void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
+        _STD _Atomic_wait_direct(this, _STD _Bit_cast<long long>(_Expected), _Order);
+    }
+
+    void notify_one() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_one_direct(_Storage_ptr);
+    }
+
+    void notify_all() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_all_direct(_Storage_ptr);
+    }
+#endif // _HAS_CXX20
+
+    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
+};
+
+#ifdef _WIN64
+template <class _Ty>
+struct _Atomic_storage<_Ty&, 16> { // lock-free using 16-byte intrinsics
+    // TRANSITION, ABI: replace '_Ty&' with '_Ty' in this specialization
+    using _TVal = _Remove_cvref_t<_Ty&>;
+
+    _Atomic_storage() = default;
+
+    // TRANSITION, ABI: replace _this_ occurrence of '_Ty&' with 'const _Ty&'
+    /* implicit */ constexpr _Atomic_storage(_Ty& _Value) noexcept
+        : _Storage{_Value} {} // non-atomically initialize this atomic
+
+    void store(const _TVal _Value) noexcept { // store with sequential consistency
+        (void) exchange(_Value);
+    }
+
+    void store(const _TVal _Value, const memory_order _Order) noexcept { // store with given memory order
+        _Check_store_memory_order(_Order);
+        (void) exchange(_Value, _Order);
+    }
+
+    _NODISCARD _TVal load() const noexcept { // load with sequential consistency
+        long long* const _Storage_ptr = const_cast<long long*>(_STD _Atomic_address_as<const long long>(_Storage));
+        _Int128 _Result{}; // atomic CAS 0 with 0
+        (void) _InterlockedCompareExchange128(_Storage_ptr, 0, 0, &_Result._Low);
+        return reinterpret_cast<_TVal&>(_Result);
+    }
+
+    _NODISCARD _TVal load(const memory_order _Order) const noexcept { // load with given memory order
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        long long* const _Storage_ptr = const_cast<long long*>(_STD _Atomic_address_as<const long long>(_Storage));
+        _Int128 _Result{}; // atomic CAS 0 with 0
+        switch (_Order) {
+        case memory_order_relaxed:
+            (void) _INTRIN_RELAXED(_InterlockedCompareExchange128)(_Storage_ptr, 0, 0, &_Result._Low);
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            (void) _INTRIN_ACQUIRE(_InterlockedCompareExchange128)(_Storage_ptr, 0, 0, &_Result._Low);
+            break;
+        case memory_order_release:
+        case memory_order_acq_rel:
+        default:
+            _INVALID_MEMORY_ORDER;
+            _FALLTHROUGH;
+        case memory_order_seq_cst:
+            (void) _InterlockedCompareExchange128(_Storage_ptr, 0, 0, &_Result._Low);
+            break;
+        }
+
+        return reinterpret_cast<_TVal&>(_Result);
+#else // ^^^ _M_ARM64, _M_ARM64EC / _M_X64 vvv
+        _Check_load_memory_order(_Order);
+        return load();
+#endif // ^^^ _M_X64 ^^^
+    }
+
+    _TVal exchange(const _TVal _Value) noexcept { // exchange with sequential consistency
+        _TVal _Result{_Value};
+        while (!compare_exchange_strong(_Result, _Value)) { // keep trying
+        }
+
+        return _Result;
+    }
+
+    _TVal exchange(const _TVal _Value, const memory_order _Order) noexcept { // exchange with given memory order
+        _TVal _Result{_Value};
+        while (!compare_exchange_strong(_Result, _Value, _Order)) { // keep trying
+        }
+
+        return _Result;
+    }
+
+    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
+        const memory_order _Order = memory_order_seq_cst) noexcept { // CAS with given memory order
+        _Int128 _Desired_bytes{};
+        _CSTD memcpy(&_Desired_bytes, _STD addressof(_Desired), sizeof(_TVal));
+        _Int128 _Expected_temp{};
+        _CSTD memcpy(&_Expected_temp, _STD addressof(_Expected), sizeof(_TVal));
+        unsigned char _Result;
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+        if constexpr (_Might_have_non_value_bits<_TVal>) {
+            _Int128 _Expected_originally{};
+            _CSTD memcpy(&_Expected_originally, _STD addressof(_Expected), sizeof(_TVal));
+
+            _Storage_for<_TVal> _Mask{_Form_mask};
+            _Int128 _Mask_val{};
+            _CSTD memcpy(&_Mask_val, _Mask._Ptr(), sizeof(_TVal));
+            for (;;) {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+                _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedCompareExchange128,
+                    _STD _Atomic_address_as<long long>(_Storage), _Desired_bytes._High, _Desired_bytes._Low,
+                    &_Expected_temp._Low);
+#else // ^^^ _M_ARM64, _M_ARM64EC / _M_X64 vvv
+                (void) _Order;
+                _Result = _InterlockedCompareExchange128(&reinterpret_cast<long long&>(_Storage), _Desired_bytes._High,
+                    _Desired_bytes._Low, &_Expected_temp._Low);
+#endif // ^^^ _M_X64 ^^^
+                if (_Result) {
+                    return true;
+                }
+
+                if (((_Expected_temp._Low ^ _Expected_originally._Low) & _Mask_val._Low) != 0
+                    || ((_Expected_temp._High ^ _Expected_originally._High) & _Mask_val._High) != 0) {
+                    _CSTD memcpy(_STD addressof(_Expected), &_Expected_temp, sizeof(_TVal));
+                    return false;
+                }
+
+                _Expected_temp._Low =
+                    (_Expected_originally._Low & _Mask_val._Low) | (_Expected_temp._Low & ~_Mask_val._Low);
+                _Expected_temp._High =
+                    (_Expected_originally._High & _Mask_val._High) | (_Expected_temp._High & ~_Mask_val._High);
+            }
+        }
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedCompareExchange128,
+            _STD _Atomic_address_as<long long>(_Storage), _Desired_bytes._High, _Desired_bytes._Low,
+            &_Expected_temp._Low);
+#else // ^^^ _M_ARM64, _M_ARM64EC / _M_X64 vvv
+        (void) _Order;
+        _Result = _InterlockedCompareExchange128(&reinterpret_cast<volatile long long&>(_Storage), _Desired_bytes._High,
+            _Desired_bytes._Low, &_Expected_temp._Low);
+#endif // ^^^ _M_X64 ^^^
+        if (_Result == 0) {
+            _CSTD memcpy(_STD addressof(_Expected), &_Expected_temp, sizeof(_TVal));
+        }
+
+        return _Result != 0;
+    }
+
+#if _HAS_CXX20
+    void wait(_TVal _Expected, memory_order _Order = memory_order_seq_cst) const noexcept {
+        const auto _Storage_ptr  = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        const auto _Expected_ptr = _STD addressof(_Expected);
+        _Int128 _Expected_bytes  = reinterpret_cast<const _Int128&>(_Expected);
+
+        for (;;) {
+            const _TVal _Observed   = load(_Order);
+            _Int128 _Observed_bytes = reinterpret_cast<const _Int128&>(_Observed);
+            if (_Observed_bytes._Low != _Expected_bytes._Low || _Observed_bytes._High != _Expected_bytes._High) {
+#if _CMPXCHG_MASK_OUT_PADDING_BITS
+                if constexpr (_Might_have_non_value_bits<_TVal>) {
+                    _Storage_for<_TVal> _Mask{_Form_mask};
+                    const _Int128 _Mask_val = reinterpret_cast<const _Int128&>(_Mask._Ref());
+
+                    if (((_Expected_bytes._Low ^ _Observed_bytes._Low) & _Mask_val._Low) == 0
+                        && ((_Expected_bytes._High ^ _Observed_bytes._High) & _Mask_val._High) == 0) {
+                        _Expected_bytes = _Observed_bytes;
+                        continue;
+                    }
+                }
+#endif // _CMPXCHG_MASK_OUT_PADDING_BITS
+
+                return;
+            }
+
+            ::__std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), nullptr,
+                &_Atomic_wait_compare_16_bytes, __std_atomic_wait_no_timeout);
+        }
+    }
+
+    void notify_one() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_one_indirect(_Storage_ptr);
+    }
+
+    void notify_all() noexcept {
+        const auto _Storage_ptr = const_cast<const void*>(static_cast<const volatile void*>(_STD addressof(_Storage)));
+        ::__std_atomic_notify_all_indirect(_Storage_ptr);
+    }
+#endif // _HAS_CXX20
+
+    struct _Int128 {
+        alignas(16) long long _Low;
+        long long _High;
+    };
+
+    typename _Atomic_storage_types<_Ty&>::_TStorage _Storage;
+};
+#endif // ^^^ 64-bit ^^^
+
+template <class _Ty, size_t = sizeof(_Ty)>
+struct _Atomic_integral; // not defined
+
+template <class _Ty>
+struct _Atomic_integral<_Ty, 1> : _Atomic_storage<_Ty> { // atomic integral operations using 1-byte intrinsics
+    using _Base = _Atomic_storage<_Ty>;
+    using typename _Base::_TVal;
+
+    using _Base::_Base;
+
+    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        char _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedExchangeAdd8,
+            _STD _Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        char _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedAnd8,
+            _STD _Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        char _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedOr8,
+            _STD _Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        char _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedXor8,
+            _STD _Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal operator++(int) noexcept {
+        return static_cast<_TVal>(_InterlockedExchangeAdd8(_STD _Atomic_address_as<char>(this->_Storage), 1));
+    }
+
+    _TVal operator++() noexcept {
+        unsigned char _Before =
+            static_cast<unsigned char>(_InterlockedExchangeAdd8(_STD _Atomic_address_as<char>(this->_Storage), 1));
+        ++_Before;
+        return static_cast<_TVal>(_Before);
+    }
+
+    _TVal operator--(int) noexcept {
+        return static_cast<_TVal>(_InterlockedExchangeAdd8(_STD _Atomic_address_as<char>(this->_Storage), -1));
+    }
+
+    _TVal operator--() noexcept {
+        unsigned char _Before =
+            static_cast<unsigned char>(_InterlockedExchangeAdd8(_STD _Atomic_address_as<char>(this->_Storage), -1));
+        --_Before;
+        return static_cast<_TVal>(_Before);
+    }
+};
+
+template <class _Ty>
+struct _Atomic_integral<_Ty, 2> : _Atomic_storage<_Ty> { // atomic integral operations using 2-byte intrinsics
+    using _Base = _Atomic_storage<_Ty>;
+    using typename _Base::_TVal;
+
+    using _Base::_Base;
+
+    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        short _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedExchangeAdd16,
+            _STD _Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        short _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedAnd16,
+            _STD _Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        short _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedOr16,
+            _STD _Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        short _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedXor16,
+            _STD _Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal operator++(int) noexcept {
+        unsigned short _After =
+            static_cast<unsigned short>(_InterlockedIncrement16(_STD _Atomic_address_as<short>(this->_Storage)));
+        --_After;
+        return static_cast<_TVal>(_After);
+    }
+
+    _TVal operator++() noexcept {
+        return static_cast<_TVal>(_InterlockedIncrement16(_STD _Atomic_address_as<short>(this->_Storage)));
+    }
+
+    _TVal operator--(int) noexcept {
+        unsigned short _After =
+            static_cast<unsigned short>(_InterlockedDecrement16(_STD _Atomic_address_as<short>(this->_Storage)));
+        ++_After;
+        return static_cast<_TVal>(_After);
+    }
+
+    _TVal operator--() noexcept {
+        return static_cast<_TVal>(_InterlockedDecrement16(_STD _Atomic_address_as<short>(this->_Storage)));
+    }
+};
+
+template <class _Ty>
+struct _Atomic_integral<_Ty, 4> : _Atomic_storage<_Ty> { // atomic integral operations using 4-byte intrinsics
+    using _Base = _Atomic_storage<_Ty>;
+    using typename _Base::_TVal;
+
+    using _Base::_Base;
+
+    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        long _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedExchangeAdd,
+            _STD _Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        long _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedAnd,
+            _STD _Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        long _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedOr,
+            _STD _Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        long _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedXor,
+            _STD _Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal operator++(int) noexcept {
+        unsigned long _After =
+            static_cast<unsigned long>(_InterlockedIncrement(_STD _Atomic_address_as<long>(this->_Storage)));
+        --_After;
+        return static_cast<_TVal>(_After);
+    }
+
+    _TVal operator++() noexcept {
+        return static_cast<_TVal>(_InterlockedIncrement(_STD _Atomic_address_as<long>(this->_Storage)));
+    }
+
+    _TVal operator--(int) noexcept {
+        unsigned long _After =
+            static_cast<unsigned long>(_InterlockedDecrement(_STD _Atomic_address_as<long>(this->_Storage)));
+        ++_After;
+        return static_cast<_TVal>(_After);
+    }
+
+    _TVal operator--() noexcept {
+        return static_cast<_TVal>(_InterlockedDecrement(_STD _Atomic_address_as<long>(this->_Storage)));
+    }
+};
+
+template <class _Ty>
+struct _Atomic_integral<_Ty, 8> : _Atomic_storage<_Ty> { // atomic integral operations using 8-byte intrinsics
+    using _Base = _Atomic_storage<_Ty>;
+    using typename _Base::_TVal;
+
+    using _Base::_Base;
+
+#ifdef _WIN64
+    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        long long _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedExchangeAdd64,
+            _STD _Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        long long _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedAnd64,
+            _STD _Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        long long _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedOr64,
+            _STD _Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        long long _Result;
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedXor64,
+            _STD _Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
+        return static_cast<_TVal>(_Result);
+    }
+
+    _TVal operator++(int) noexcept {
+        unsigned long long _After = static_cast<unsigned long long>(
+            _InterlockedIncrement64(_STD _Atomic_address_as<long long>(this->_Storage)));
+        --_After;
+        return static_cast<_TVal>(_After);
+    }
+
+    _TVal operator++() noexcept {
+        return static_cast<_TVal>(_InterlockedIncrement64(_STD _Atomic_address_as<long long>(this->_Storage)));
+    }
+
+    _TVal operator--(int) noexcept {
+        unsigned long long _After = static_cast<unsigned long long>(
+            _InterlockedDecrement64(_STD _Atomic_address_as<long long>(this->_Storage)));
+        ++_After;
+        return static_cast<_TVal>(_After);
+    }
+
+    _TVal operator--() noexcept {
+        return static_cast<_TVal>(_InterlockedDecrement64(_STD _Atomic_address_as<long long>(this->_Storage)));
+    }
+#else // ^^^ 64-bit / 32-bit vvv
+    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // effectively sequential consistency
+        _TVal _Temp{this->load()};
+        while (!this->compare_exchange_strong(_Temp, _Temp + _Operand, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+
+    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // effectively sequential consistency
+        _TVal _Temp{this->load()};
+        while (!this->compare_exchange_strong(_Temp, _Temp & _Operand, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+
+    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // effectively sequential consistency
+        _TVal _Temp{this->load()};
+        while (!this->compare_exchange_strong(_Temp, _Temp | _Operand, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+
+    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        // effectively sequential consistency
+        _TVal _Temp{this->load()};
+        while (!this->compare_exchange_strong(_Temp, _Temp ^ _Operand, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+
+    _TVal operator++(int) noexcept {
+        return fetch_add(static_cast<_TVal>(1));
+    }
+
+    _TVal operator++() noexcept {
+        return fetch_add(static_cast<_TVal>(1)) + static_cast<_TVal>(1);
+    }
+
+    _TVal operator--(int) noexcept {
+        return fetch_add(static_cast<_TVal>(-1));
+    }
+
+    _TVal operator--() noexcept {
+        return fetch_add(static_cast<_TVal>(-1)) - static_cast<_TVal>(1);
+    }
+#endif // ^^^ 32-bit ^^^
+};
+
+#if 1 // TRANSITION, ABI
+template <size_t _TypeSize>
+constexpr bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;
+#else // ^^^ don't break ABI / break ABI vvv
+template <size_t _TypeSize>
+constexpr bool _Is_always_lock_free = _TypeSize <= 2 * sizeof(void*);
+#endif // ^^^ break ABI ^^^
+
+template <class _Ty, bool _Is_lock_free = _Is_always_lock_free<sizeof(_Ty)>>
+constexpr bool _Deprecate_non_lock_free_volatile = true;
+
+template <class _Ty>
+_CXX20_DEPRECATE_VOLATILE constexpr bool _Deprecate_non_lock_free_volatile<_Ty, false> = true;
+
+#if _HAS_CXX20
+#define _REQUIRES_CLAUSE(...) requires (__VA_ARGS__)
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+#define _REQUIRES_CLAUSE(...)
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Ty>
+struct _Atomic_integral_facade : _Atomic_integral<_Ty> {
+    // provides operator overloads and other support for atomic integral specializations
+    _STL_INTERNAL_STATIC_ASSERT(!is_const_v<_Ty>);
+    _STL_INTERNAL_STATIC_ASSERT(!is_volatile_v<_Ty>);
+
+    using _Base           = _Atomic_integral<_Ty>;
+    using difference_type = _Ty;
+
+    using _Base::_Base;
+
+    // _Deprecate_non_lock_free_volatile is unnecessary here.
+
+    // note: const_cast-ing away volatile is safe because all our intrinsics add volatile back on.
+    // We make the primary functions non-volatile for better debug codegen, as non-volatile atomics
+    // are far more common than volatile ones.
+    using _Base::fetch_add;
+    _Ty fetch_add(const _Ty _Operand) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand);
+    }
+
+    _Ty fetch_add(const _Ty _Operand, const memory_order _Order) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand, _Order);
+    }
+
+    _NODISCARD static _Ty _Negate(const _Ty _Value) noexcept { // returns two's complement negated value of _Value
+        return static_cast<_Ty>(0U - static_cast<make_unsigned_t<_Ty>>(_Value));
+    }
+
+    _Ty fetch_sub(const _Ty _Operand) noexcept {
+        return fetch_add(_Negate(_Operand));
+    }
+
+    _Ty fetch_sub(const _Ty _Operand) volatile noexcept {
+        return fetch_add(_Negate(_Operand));
+    }
+
+    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order) noexcept {
+        return fetch_add(_Negate(_Operand), _Order);
+    }
+
+    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order) volatile noexcept {
+        return fetch_add(_Negate(_Operand), _Order);
+    }
+
+    using _Base::fetch_and;
+    _Ty fetch_and(const _Ty _Operand) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand);
+    }
+
+    _Ty fetch_and(const _Ty _Operand, const memory_order _Order) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand, _Order);
+    }
+
+    using _Base::fetch_or;
+    _Ty fetch_or(const _Ty _Operand) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand);
+    }
+
+    _Ty fetch_or(const _Ty _Operand, const memory_order _Order) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand, _Order);
+    }
+
+    using _Base::fetch_xor;
+    _Ty fetch_xor(const _Ty _Operand) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand);
+    }
+
+    _Ty fetch_xor(const _Ty _Operand, const memory_order _Order) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand, _Order);
+    }
+
+    using _Base::operator++;
+    _Ty operator++(int) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++(0);
+    }
+
+    _Ty operator++() volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++();
+    }
+
+    using _Base::operator--;
+    _Ty operator--(int) volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--(0);
+    }
+
+    _Ty operator--() volatile noexcept {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--();
+    }
+
+    _Ty operator+=(const _Ty _Operand) noexcept {
+        return static_cast<_Ty>(this->_Base::fetch_add(_Operand) + _Operand);
+    }
+
+    _Ty operator+=(const _Ty _Operand) volatile noexcept {
+        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand) + _Operand);
+    }
+
+    _Ty operator-=(const _Ty _Operand) noexcept {
+        return static_cast<_Ty>(fetch_sub(_Operand) - _Operand);
+    }
+
+    _Ty operator-=(const _Ty _Operand) volatile noexcept {
+        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->fetch_sub(_Operand) - _Operand);
+    }
+
+    _Ty operator&=(const _Ty _Operand) noexcept {
+        return static_cast<_Ty>(this->_Base::fetch_and(_Operand) & _Operand);
+    }
+
+    _Ty operator&=(const _Ty _Operand) volatile noexcept {
+        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand) & _Operand);
+    }
+
+    _Ty operator|=(const _Ty _Operand) noexcept {
+        return static_cast<_Ty>(this->_Base::fetch_or(_Operand) | _Operand);
+    }
+
+    _Ty operator|=(const _Ty _Operand) volatile noexcept {
+        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand) | _Operand);
+    }
+
+    _Ty operator^=(const _Ty _Operand) noexcept {
+        return static_cast<_Ty>(this->_Base::fetch_xor(_Operand) ^ _Operand);
+    }
+
+    _Ty operator^=(const _Ty _Operand) volatile noexcept {
+        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand) ^ _Operand);
+    }
+};
+
+template <class _Ty>
+struct _Atomic_integral_facade<_Ty&> : _Atomic_integral<_Ty&> {
+    // provides operator overloads and other support for atomic integral specializations
+    using _Base           = _Atomic_integral<_Ty&>;
+    using difference_type = remove_cv_t<_Ty>;
+    using typename _Base::_TVal;
+
+    using _Base::_Base;
+
+    _NODISCARD static _TVal _Negate(const _TVal _Value) noexcept { // returns two's complement negated value of _Value
+        return static_cast<_TVal>(0U - static_cast<make_unsigned_t<_TVal>>(_Value));
+    }
+
+    _TVal fetch_add(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand);
+    }
+
+    _TVal fetch_add(const _TVal _Operand, const memory_order _Order) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand, _Order);
+    }
+
+    _TVal fetch_sub(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(_Negate(_Operand));
+    }
+
+    _TVal fetch_sub(const _TVal _Operand, const memory_order _Order) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(_Negate(_Operand), _Order);
+    }
+
+    _TVal operator++(int) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++(0);
+    }
+
+    _TVal operator++() const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++();
+    }
+
+    _TVal operator--(int) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--(0);
+    }
+
+    _TVal operator--() const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--();
+    }
+
+    _TVal operator+=(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return static_cast<_TVal>(fetch_add(_Operand) + _Operand);
+    }
+
+    _TVal operator-=(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return static_cast<_TVal>(fetch_sub(_Operand) - _Operand);
+    }
+
+    _TVal fetch_and(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand);
+    }
+
+    _TVal fetch_and(const _TVal _Operand, const memory_order _Order) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand, _Order);
+    }
+
+    _TVal fetch_or(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand);
+    }
+
+    _TVal fetch_or(const _TVal _Operand, const memory_order _Order) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand, _Order);
+    }
+
+    _TVal fetch_xor(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand);
+    }
+
+    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand, _Order);
+    }
+
+    _TVal operator&=(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return static_cast<_TVal>(fetch_and(_Operand) & _Operand);
+    }
+
+    _TVal operator|=(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return static_cast<_TVal>(fetch_or(_Operand) | _Operand);
+    }
+
+    _TVal operator^=(const _TVal _Operand) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return static_cast<_TVal>(fetch_xor(_Operand) ^ _Operand);
+    }
+};
+
+#if _HAS_CXX20
+template <class _Ty>
+struct _Atomic_floating : _Atomic_storage<_Ty> {
+    // provides atomic floating-point operations
+    _STL_INTERNAL_STATIC_ASSERT(!is_const_v<_Ty>);
+    _STL_INTERNAL_STATIC_ASSERT(!is_volatile_v<_Ty>);
+
+    using _Base           = _Atomic_storage<_Ty>;
+    using difference_type = _Ty;
+
+    using _Base::_Base;
+
+    _Ty fetch_add(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Ty _Temp{this->load(memory_order_relaxed)};
+        while (!this->compare_exchange_strong(_Temp, _Temp + _Operand, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+
+    // _Deprecate_non_lock_free_volatile is unnecessary here.
+
+    // note: const_cast-ing away volatile is safe because all our intrinsics add volatile back on.
+    // We make the primary functions non-volatile for better debug codegen, as non-volatile atomics
+    // are far more common than volatile ones.
+    _Ty fetch_add(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) volatile noexcept {
+        return const_cast<_Atomic_floating*>(this)->fetch_add(_Operand, _Order);
+    }
+
+    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Ty _Temp{this->load(memory_order_relaxed)};
+        while (!this->compare_exchange_strong(_Temp, _Temp - _Operand, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+
+    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) volatile noexcept {
+        return const_cast<_Atomic_floating*>(this)->fetch_sub(_Operand, _Order);
+    }
+
+    _Ty operator+=(const _Ty _Operand) noexcept {
+        return fetch_add(_Operand) + _Operand;
+    }
+
+    _Ty operator+=(const _Ty _Operand) volatile noexcept {
+        return const_cast<_Atomic_floating*>(this)->fetch_add(_Operand) + _Operand;
+    }
+
+    _Ty operator-=(const _Ty _Operand) noexcept {
+        return fetch_sub(_Operand) - _Operand;
+    }
+
+    _Ty operator-=(const _Ty _Operand) volatile noexcept {
+        return const_cast<_Atomic_floating*>(this)->fetch_sub(_Operand) - _Operand;
+    }
+};
+
+template <class _Ty>
+struct _Atomic_floating<_Ty&> : _Atomic_storage<_Ty&> {
+    // provides atomic floating-point operations
+    using _Base           = _Atomic_storage<_Ty&>;
+    using difference_type = remove_cv_t<_Ty>;
+    using typename _Base::_TVal;
+
+    using _Base::_Base;
+
+    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        _TVal _Temp{this->load(memory_order_relaxed)};
+        while (!const_cast<_Atomic_floating*>(this)->_Base::compare_exchange_strong(
+            _Temp, _Temp + _Operand, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+
+    _TVal fetch_sub(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        _TVal _Temp{this->load(memory_order_relaxed)};
+        while (!const_cast<_Atomic_floating*>(this)->_Base::compare_exchange_strong(
+            _Temp, _Temp - _Operand, _Order)) { // keep trying
+        }
+
+        return _Temp;
+    }
+
+    _TVal operator+=(const _TVal _Operand) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return fetch_add(_Operand) + _Operand;
+    }
+
+    _TVal operator-=(const _TVal _Operand) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return fetch_sub(_Operand) - _Operand;
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Ty>
+struct _Atomic_pointer : _Atomic_storage<_Ty> {
+    using _Base           = _Atomic_storage<_Ty>;
+    using difference_type = ptrdiff_t;
+
+    using _Base::_Base;
+
+    _Ty fetch_add(const ptrdiff_t _Diff, const memory_order _Order = memory_order_seq_cst) noexcept {
+        const ptrdiff_t _Shift_bytes =
+            static_cast<ptrdiff_t>(static_cast<size_t>(_Diff) * sizeof(remove_pointer_t<_Ty>));
+        ptrdiff_t _Result;
+#ifdef _WIN64
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedExchangeAdd64,
+            _STD _Atomic_address_as<long long>(this->_Storage), _Shift_bytes);
+#else // ^^^ 64-bit / 32-bit vvv
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedExchangeAdd,
+            _STD _Atomic_address_as<long>(this->_Storage), _Shift_bytes);
+#endif // ^^^ 32-bit ^^^
+        return reinterpret_cast<_Ty>(_Result);
+    }
+
+    // _Deprecate_non_lock_free_volatile is unnecessary here.
+
+    _Ty fetch_add(const ptrdiff_t _Diff) volatile noexcept {
+        return const_cast<_Atomic_pointer*>(this)->fetch_add(_Diff);
+    }
+
+    _Ty fetch_add(const ptrdiff_t _Diff, const memory_order _Order) volatile noexcept {
+        return const_cast<_Atomic_pointer*>(this)->fetch_add(_Diff, _Order);
+    }
+
+    _Ty fetch_sub(const ptrdiff_t _Diff) volatile noexcept {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
+    }
+
+    _Ty fetch_sub(const ptrdiff_t _Diff) noexcept {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
+    }
+
+    _Ty fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) volatile noexcept {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
+    }
+
+    _Ty fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) noexcept {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
+    }
+
+    _Ty operator++(int) volatile noexcept {
+        return fetch_add(1);
+    }
+
+    _Ty operator++(int) noexcept {
+        return fetch_add(1);
+    }
+
+    _Ty operator++() volatile noexcept {
+        return fetch_add(1) + 1;
+    }
+
+    _Ty operator++() noexcept {
+        return fetch_add(1) + 1;
+    }
+
+    _Ty operator--(int) volatile noexcept {
+        return fetch_add(-1);
+    }
+
+    _Ty operator--(int) noexcept {
+        return fetch_add(-1);
+    }
+
+    _Ty operator--() volatile noexcept {
+        return fetch_add(-1) - 1;
+    }
+
+    _Ty operator--() noexcept {
+        return fetch_add(-1) - 1;
+    }
+
+    _Ty operator+=(const ptrdiff_t _Diff) volatile noexcept {
+        return fetch_add(_Diff) + _Diff;
+    }
+
+    _Ty operator+=(const ptrdiff_t _Diff) noexcept {
+        return fetch_add(_Diff) + _Diff;
+    }
+
+    _Ty operator-=(const ptrdiff_t _Diff) volatile noexcept {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
+    }
+
+    _Ty operator-=(const ptrdiff_t _Diff) noexcept {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
+    }
+};
+
+template <class _Ty>
+struct _Atomic_pointer<_Ty&> : _Atomic_storage<_Ty&> {
+    using _Base           = _Atomic_storage<_Ty&>;
+    using difference_type = ptrdiff_t;
+    using typename _Base::_TVal;
+
+    using _Base::_Base;
+
+    _TVal fetch_add(const ptrdiff_t _Diff, const memory_order _Order = memory_order_seq_cst) const noexcept
+        _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        const ptrdiff_t _Shift_bytes =
+            static_cast<ptrdiff_t>(static_cast<size_t>(_Diff) * sizeof(remove_pointer_t<_Ty>));
+        ptrdiff_t _Result;
+#ifdef _WIN64
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedExchangeAdd64,
+            _STD _Atomic_address_as<long long>(this->_Storage), _Shift_bytes);
+#else // ^^^ 64-bit / 32-bit vvv
+        _ATOMIC_CHOOSE_INTRINSIC(static_cast<unsigned int>(_Order), _Result, _InterlockedExchangeAdd,
+            _STD _Atomic_address_as<long>(this->_Storage), _Shift_bytes);
+#endif // ^^^ 32-bit ^^^
+        return reinterpret_cast<_TVal>(_Result);
+    }
+
+    _TVal fetch_sub(const ptrdiff_t _Diff) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
+    }
+
+    _TVal fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) const noexcept
+        _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
+    }
+
+    _TVal operator++(int) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(1);
+    }
+
+    _TVal operator++() const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(1) + 1;
+    }
+
+    _TVal operator--(int) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(-1);
+    }
+
+    _TVal operator--() const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(-1) - 1;
+    }
+
+    _TVal operator+=(const ptrdiff_t _Diff) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(_Diff) + _Diff;
+    }
+
+    _TVal operator-=(const ptrdiff_t _Diff) const noexcept _REQUIRES_CLAUSE(!is_const_v<_Ty>) {
+        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
+    }
+};
+
+#undef _REQUIRES_CLAUSE
+
+template <class _Ty>
+struct _Atomic_nonobject_pointer : _Atomic_storage<_Ty> {
+    using _Base           = _Atomic_storage<_Ty>;
+    using difference_type = ptrdiff_t;
+
+    using _Base::_Base;
+};
+
+template <class _Ty>
+struct _Atomic_nonobject_pointer<_Ty&> : _Atomic_storage<_Ty&> {
+    using _Base = _Atomic_storage<_Ty&>;
+
+    using _Base::_Base;
+};
+
+#define ATOMIC_VAR_INIT(_Value) {_Value}
+
+template <class _TVal, class _Ty = _TVal>
+using _Choose_atomic_base2_t =
+    typename _Select<is_integral_v<_TVal> && !is_same_v<bool, remove_cv_t<_TVal>>>::template _Apply<
+        _Atomic_integral_facade<_Ty>, typename _Select<is_pointer_v<_TVal>>::template _Apply<
+                                          typename _Select<is_object_v<remove_pointer_t<_TVal>>>::template _Apply<
+                                              _Atomic_pointer<_Ty>, _Atomic_nonobject_pointer<_Ty>>,
+                                          _Atomic_storage<_Ty>>>;
+
+#if _HAS_CXX20
+template <class _TVal, class _Ty = _TVal>
+using _Choose_atomic_base_t =
+    _Select<is_floating_point_v<_TVal>>::template _Apply<_Atomic_floating<_Ty>, _Choose_atomic_base2_t<_TVal, _Ty>>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _TVal, class _Ty = _TVal>
+using _Choose_atomic_base_t = _Choose_atomic_base2_t<_TVal, _Ty>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Ty>
+struct atomic : _Choose_atomic_base_t<_Ty> { // atomic value
+private:
+    using _Base = _Choose_atomic_base_t<_Ty>;
+
+public:
+    static_assert(is_trivially_copyable_v<_Ty>, "atomic<T> requires T to be trivially copyable.");
+    static_assert(is_copy_constructible_v<_Ty>, "atomic<T> requires T to be copy constructible.");
+    static_assert(is_move_constructible_v<_Ty>, "atomic<T> requires T to be move constructible.");
+    static_assert(is_copy_assignable_v<_Ty>, "atomic<T> requires T to be copy assignable.");
+    static_assert(is_move_assignable_v<_Ty>, "atomic<T> requires T to be move assignable.");
+    static_assert(!is_const_v<_Ty>, "atomic<T> requires T to be non-const.");
+    static_assert(!is_volatile_v<_Ty>, "atomic<T> requires T to be non-volatile.");
+
+    using value_type = _Ty;
+
+    template <class _Uty = _Ty, enable_if_t<is_default_constructible_v<_Uty>, int> = 0>
+    constexpr atomic() noexcept(is_nothrow_default_constructible_v<_Ty>) : _Base() {}
+
+    /* implicit */ constexpr atomic(const _Ty _Value) noexcept : _Base(_Value) {}
+
+    atomic(const atomic&)                     = delete;
+    atomic& operator=(const atomic&)          = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+
+#if _HAS_CXX17
+    static constexpr bool is_always_lock_free = _Is_always_lock_free<sizeof(_Ty)>;
+#endif // _HAS_CXX17
+
+    _NODISCARD bool is_lock_free() const volatile noexcept {
+        return _Is_always_lock_free<sizeof(_Ty)>;
+    }
+
+    _NODISCARD bool is_lock_free() const noexcept {
+        return static_cast<const volatile atomic*>(this)->is_lock_free();
+    }
+
+    _Ty operator=(const _Ty _Value) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        this->store(_Value);
+        return _Value;
+    }
+
+    _Ty operator=(const _Ty _Value) noexcept {
+        this->store(_Value);
+        return _Value;
+    }
+
+    // For the following, we do the real implementation in the non-volatile function, and const_cast
+    // to call the non-volatile function in the volatile one. This is safe because all of the
+    // non-volatile functions reapply volatile, as all our intrinsics accept only volatile T *.
+    // We expect most atomic<T>s to be non-volatile, so making the real implementations
+    // non-volatile should result in better debug codegen.
+    using _Base::store;
+    void store(const _Ty _Value) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        const_cast<atomic*>(this)->_Base::store(_Value);
+    }
+
+    void store(const _Ty _Value, const memory_order _Order) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        const_cast<atomic*>(this)->_Base::store(_Value, _Order);
+    }
+
+    using _Base::load;
+    _NODISCARD _Ty load() const volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return const_cast<const atomic*>(this)->_Base::load();
+    }
+
+    _NODISCARD _Ty load(const memory_order _Order) const volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return const_cast<const atomic*>(this)->_Base::load(_Order);
+    }
+
+    using _Base::exchange;
+    _Ty exchange(const _Ty _Value) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return const_cast<atomic*>(this)->_Base::exchange(_Value);
+    }
+
+    _Ty exchange(const _Ty _Value, const memory_order _Order) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return const_cast<atomic*>(this)->_Base::exchange(_Value, _Order);
+    }
+
+    using _Base::compare_exchange_strong;
+    bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return const_cast<atomic*>(this)->_Base::compare_exchange_strong(_Expected, _Desired);
+    }
+
+    bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return const_cast<atomic*>(this)->_Base::compare_exchange_strong(_Expected, _Desired, _Order);
+    }
+
+    bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired, const memory_order _Success,
+        const memory_order _Failure) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    bool compare_exchange_strong(
+        _Ty& _Expected, const _Ty _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
+        return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired) volatile noexcept {
+        // we have no weak CAS intrinsics, even on ARM64, so fall back to strong
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return this->compare_exchange_strong(_Expected, _Desired);
+    }
+
+    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired) noexcept {
+        return this->compare_exchange_strong(_Expected, _Desired);
+    }
+
+    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return this->compare_exchange_strong(_Expected, _Desired, _Order);
+    }
+
+    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) noexcept {
+        return this->compare_exchange_strong(_Expected, _Desired, _Order);
+    }
+
+    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Success,
+        const memory_order _Failure) volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    bool compare_exchange_weak(
+        _Ty& _Expected, const _Ty _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
+        return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+#if _HAS_CXX20
+    using _Base::wait;
+    void wait(const _Ty _Expected, const memory_order _Order = memory_order_seq_cst) const volatile noexcept {
+        const_cast<const atomic*>(this)->_Base::wait(_Expected, _Order);
+    }
+
+    using _Base::notify_one;
+    void notify_one() volatile noexcept {
+        const_cast<atomic*>(this)->_Base::notify_one();
+    }
+
+    using _Base::notify_all;
+    void notify_all() volatile noexcept {
+        const_cast<atomic*>(this)->_Base::notify_all();
+    }
+#endif // _HAS_CXX20
+
+    operator _Ty() const volatile noexcept {
+        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+        return this->load();
+    }
+
+    operator _Ty() const noexcept {
+        return this->load();
+    }
+};
+
+#if _HAS_CXX17
+template <class _Ty>
+atomic(_Ty) -> atomic<_Ty>;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+struct atomic_ref : _Choose_atomic_base_t<_Ty, _Ty&> { // atomic reference
+private:
+    using _Base = _Choose_atomic_base_t<_Ty, _Ty&>;
+
+public:
+    static_assert(is_trivially_copyable_v<_Ty>, "atomic_ref<T> requires T to be trivially copyable.");
+
+    using value_type = remove_cv_t<_Ty>;
+
+    explicit atomic_ref(_Ty& _Value) noexcept /* strengthened */ : _Base(_Value) {
+        if constexpr (is_always_lock_free) {
+            _STL_ASSERT((reinterpret_cast<uintptr_t>(_STD addressof(_Value)) & (required_alignment - 1)) == 0,
+                "atomic_ref underlying object is not aligned as required_alignment");
+        } else {
+            this->_Init_spinlock_for_ref();
+        }
+    }
+
+    explicit atomic_ref(_Ty&&) = delete; // per LWG-4472
+
+    atomic_ref(const atomic_ref&) noexcept = default;
+
+    template <class _Uty>
+        requires is_convertible_v<_Uty (*)[], _Ty (*)[]>
+    atomic_ref(const atomic_ref<_Uty>& _Ref) noexcept : _Base(_Ref._Storage) {
+        if constexpr (!is_always_lock_free) {
+#if 1 // TRANSITION, ABI
+            this->_Spinlock = _Ref._Spinlock;
+#else // ^^^ don't break ABI / break ABI vvv
+            this->_Mutex = _Ref._Mutex;
+#endif // ^^^ break ABI ^^^
+        }
+    }
+
+    atomic_ref& operator=(const atomic_ref&) = delete;
+
+    static constexpr bool is_always_lock_free =
+        sizeof(_Ty) <= 2 * sizeof(void*) && (sizeof(_Ty) & (sizeof(_Ty) - 1)) == 0;
+
+    static constexpr size_t required_alignment = is_always_lock_free ? sizeof(_Ty) : alignof(_Ty);
+
+    static_assert(is_always_lock_free || !is_volatile_v<_Ty>,
+        "atomic_ref<T> requires T to be non-volatile when it is not always lock-free.");
+
+    _NODISCARD bool is_lock_free() const noexcept {
+        return is_always_lock_free;
+    }
+
+    void store(const value_type _Value) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        const_cast<atomic_ref*>(this)->_Base::store(_Value);
+    }
+
+    void store(const value_type _Value, const memory_order _Order) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        const_cast<atomic_ref*>(this)->_Base::store(_Value, _Order);
+    }
+
+    value_type operator=(const value_type _Value) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        store(_Value);
+        return _Value;
+    }
+
+    value_type exchange(const value_type _Value) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return const_cast<atomic_ref*>(this)->_Base::exchange(_Value);
+    }
+
+    value_type exchange(const value_type _Value, const memory_order _Order) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return const_cast<atomic_ref*>(this)->_Base::exchange(_Value, _Order);
+    }
+
+    bool compare_exchange_strong(value_type& _Expected, const value_type _Desired) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return const_cast<atomic_ref*>(this)->_Base::compare_exchange_strong(_Expected, _Desired);
+    }
+
+    bool compare_exchange_strong(
+        value_type& _Expected, const value_type _Desired, const memory_order _Order) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return const_cast<atomic_ref*>(this)->_Base::compare_exchange_strong(_Expected, _Desired, _Order);
+    }
+
+    bool compare_exchange_strong(value_type& _Expected, const value_type _Desired, const memory_order _Success,
+        const memory_order _Failure) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    bool compare_exchange_weak(value_type& _Expected, const value_type _Desired) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return compare_exchange_strong(_Expected, _Desired);
+    }
+
+    bool compare_exchange_weak(
+        value_type& _Expected, const value_type _Desired, const memory_order _Order) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return compare_exchange_strong(_Expected, _Desired, _Order);
+    }
+
+    bool compare_exchange_weak(value_type& _Expected, const value_type _Desired, const memory_order _Success,
+        const memory_order _Failure) const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        return compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    operator value_type() const noexcept {
+        return this->load();
+    }
+
+    void notify_one() const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        const_cast<atomic_ref*>(this)->_Base::notify_one();
+    }
+
+    void notify_all() const noexcept
+        requires (!is_const_v<_Ty>)
+    {
+        const_cast<atomic_ref*>(this)->_Base::notify_all();
+    }
+};
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD bool atomic_is_lock_free(const volatile atomic<_Ty>* _Mem) noexcept {
+    return _Mem->is_lock_free();
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD bool atomic_is_lock_free(const atomic<_Ty>* _Mem) noexcept {
+    return _Mem->is_lock_free();
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_store(volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    _Mem->store(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_store(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
+    _Mem->store(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_store_explicit(
+    volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    _Mem->store(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_store_explicit(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
+    _Mem->store(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_ATOMIC_INIT void atomic_init(
+    volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    _STD atomic_store_explicit(_Mem, _Value, memory_order_relaxed);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_ATOMIC_INIT void atomic_init(
+    atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
+    _STD atomic_store_explicit(_Mem, _Value, memory_order_relaxed);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Ty atomic_load(const volatile atomic<_Ty>* const _Mem) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->load();
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Ty atomic_load(const atomic<_Ty>* const _Mem) noexcept {
+    return _Mem->load();
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Ty atomic_load_explicit(const volatile atomic<_Ty>* const _Mem, const memory_order _Order) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->load(_Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Ty atomic_load_explicit(const atomic<_Ty>* const _Mem, const memory_order _Order) noexcept {
+    return _Mem->load(_Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_exchange(volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->exchange(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_exchange(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
+    return _Mem->exchange(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_exchange_explicit(
+    volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->exchange(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_exchange_explicit(
+    atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
+    return _Mem->exchange(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+bool atomic_compare_exchange_strong(
+    volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->compare_exchange_strong(*_Expected, _Desired);
+}
+
+_EXPORT_STD template <class _Ty>
+bool atomic_compare_exchange_strong(
+    atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
+    return _Mem->compare_exchange_strong(*_Expected, _Desired);
+}
+
+_EXPORT_STD template <class _Ty>
+bool atomic_compare_exchange_strong_explicit(volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
+    const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+}
+
+_EXPORT_STD template <class _Ty>
+bool atomic_compare_exchange_strong_explicit(atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
+    const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
+    return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+}
+
+_EXPORT_STD template <class _Ty>
+bool atomic_compare_exchange_weak(
+    volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->compare_exchange_strong(*_Expected, _Desired);
+}
+
+_EXPORT_STD template <class _Ty>
+bool atomic_compare_exchange_weak(
+    atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
+    return _Mem->compare_exchange_strong(*_Expected, _Desired);
+}
+
+_EXPORT_STD template <class _Ty>
+bool atomic_compare_exchange_weak_explicit(volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
+    const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+}
+
+_EXPORT_STD template <class _Ty>
+bool atomic_compare_exchange_weak_explicit(atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
+    const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
+    return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_add(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_add(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_add(atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
+    return _Mem->fetch_add(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_add_explicit(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value,
+    const memory_order _Order) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_add(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_add_explicit(
+    atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value, const memory_order _Order) noexcept {
+    return _Mem->fetch_add(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_sub(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_sub(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_sub(atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
+    return _Mem->fetch_sub(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_sub_explicit(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value,
+    const memory_order _Order) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_sub(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_sub_explicit(
+    atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value, const memory_order _Order) noexcept {
+    return _Mem->fetch_sub(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_and(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_and(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_and(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
+    return _Mem->fetch_and(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_and_explicit(
+    volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_and(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_and_explicit(
+    atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
+    return _Mem->fetch_and(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_or(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_or(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_or(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
+    return _Mem->fetch_or(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_or_explicit(
+    volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_or(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_or_explicit(
+    atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
+    return _Mem->fetch_or(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_xor(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_xor(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_xor(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
+    return _Mem->fetch_xor(_Value);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_xor_explicit(
+    volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
+    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
+    return _Mem->fetch_xor(_Value, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty atomic_fetch_xor_explicit(
+    atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
+    return _Mem->fetch_xor(_Value, _Order);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+void atomic_wait(const volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected) noexcept {
+    _Mem->wait(_Expected);
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_wait(const atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected) noexcept {
+    _Mem->wait(_Expected);
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_wait_explicit(const volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected,
+    const memory_order _Order) noexcept {
+    _Mem->wait(_Expected, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_wait_explicit(const atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected,
+    const memory_order _Order) noexcept {
+    _Mem->wait(_Expected, _Order);
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_notify_one(volatile atomic<_Ty>* const _Mem) noexcept {
+    _Mem->notify_one();
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_notify_one(atomic<_Ty>* const _Mem) noexcept {
+    _Mem->notify_one();
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_notify_all(volatile atomic<_Ty>* const _Mem) noexcept {
+    _Mem->notify_all();
+}
+
+_EXPORT_STD template <class _Ty>
+void atomic_notify_all(atomic<_Ty>* const _Mem) noexcept {
+    _Mem->notify_all();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD using atomic_bool = atomic<bool>;
+
+_EXPORT_STD using atomic_char   = atomic<char>;
+_EXPORT_STD using atomic_schar  = atomic<signed char>;
+_EXPORT_STD using atomic_uchar  = atomic<unsigned char>;
+_EXPORT_STD using atomic_short  = atomic<short>;
+_EXPORT_STD using atomic_ushort = atomic<unsigned short>;
+_EXPORT_STD using atomic_int    = atomic<int>;
+_EXPORT_STD using atomic_uint   = atomic<unsigned int>;
+_EXPORT_STD using atomic_long   = atomic<long>;
+_EXPORT_STD using atomic_ulong  = atomic<unsigned long>;
+_EXPORT_STD using atomic_llong  = atomic<long long>;
+_EXPORT_STD using atomic_ullong = atomic<unsigned long long>;
+
+#ifdef __cpp_lib_char8_t
+_EXPORT_STD using atomic_char8_t = atomic<char8_t>;
+#endif // defined(__cpp_lib_char8_t)
+_EXPORT_STD using atomic_char16_t = atomic<char16_t>;
+_EXPORT_STD using atomic_char32_t = atomic<char32_t>;
+_EXPORT_STD using atomic_wchar_t  = atomic<wchar_t>;
+
+_EXPORT_STD using atomic_int8_t   = atomic<int8_t>;
+_EXPORT_STD using atomic_uint8_t  = atomic<uint8_t>;
+_EXPORT_STD using atomic_int16_t  = atomic<int16_t>;
+_EXPORT_STD using atomic_uint16_t = atomic<uint16_t>;
+_EXPORT_STD using atomic_int32_t  = atomic<int32_t>;
+_EXPORT_STD using atomic_uint32_t = atomic<uint32_t>;
+_EXPORT_STD using atomic_int64_t  = atomic<int64_t>;
+_EXPORT_STD using atomic_uint64_t = atomic<uint64_t>;
+
+_EXPORT_STD using atomic_int_least8_t   = atomic<int_least8_t>;
+_EXPORT_STD using atomic_uint_least8_t  = atomic<uint_least8_t>;
+_EXPORT_STD using atomic_int_least16_t  = atomic<int_least16_t>;
+_EXPORT_STD using atomic_uint_least16_t = atomic<uint_least16_t>;
+_EXPORT_STD using atomic_int_least32_t  = atomic<int_least32_t>;
+_EXPORT_STD using atomic_uint_least32_t = atomic<uint_least32_t>;
+_EXPORT_STD using atomic_int_least64_t  = atomic<int_least64_t>;
+_EXPORT_STD using atomic_uint_least64_t = atomic<uint_least64_t>;
+
+_EXPORT_STD using atomic_int_fast8_t   = atomic<int_fast8_t>;
+_EXPORT_STD using atomic_uint_fast8_t  = atomic<uint_fast8_t>;
+_EXPORT_STD using atomic_int_fast16_t  = atomic<int_fast16_t>;
+_EXPORT_STD using atomic_uint_fast16_t = atomic<uint_fast16_t>;
+_EXPORT_STD using atomic_int_fast32_t  = atomic<int_fast32_t>;
+_EXPORT_STD using atomic_uint_fast32_t = atomic<uint_fast32_t>;
+_EXPORT_STD using atomic_int_fast64_t  = atomic<int_fast64_t>;
+_EXPORT_STD using atomic_uint_fast64_t = atomic<uint_fast64_t>;
+
+_EXPORT_STD using atomic_intptr_t  = atomic<intptr_t>;
+_EXPORT_STD using atomic_uintptr_t = atomic<uintptr_t>;
+_EXPORT_STD using atomic_size_t    = atomic<size_t>;
+_EXPORT_STD using atomic_ptrdiff_t = atomic<ptrdiff_t>;
+_EXPORT_STD using atomic_intmax_t  = atomic<intmax_t>;
+_EXPORT_STD using atomic_uintmax_t = atomic<uintmax_t>;
+
+#if _HAS_CXX20
+// Though there are CMPXCHG8B and CMPXCHG16B,
+// the largest atomics with a full set of efficient operations are pointer-sized.
+_EXPORT_STD using atomic_signed_lock_free   = atomic_intptr_t;
+_EXPORT_STD using atomic_unsigned_lock_free = atomic_uintptr_t;
+#endif // _HAS_CXX20
+
+#define ATOMIC_FLAG_INIT \
+    {                    \
+    }
+
+_EXPORT_STD struct atomic_flag { // flag with test-and-set semantics
+#if _HAS_CXX20
+    _NODISCARD bool test(const memory_order _Order = memory_order_seq_cst) const noexcept {
+        return _Storage.load(_Order) != 0;
+    }
+
+    _NODISCARD bool test(const memory_order _Order = memory_order_seq_cst) const volatile noexcept {
+        return _Storage.load(_Order) != 0;
+    }
+#endif // _HAS_CXX20
+
+    bool test_and_set(const memory_order _Order = memory_order_seq_cst) noexcept {
+        return _Storage.exchange(true, _Order) != 0;
+    }
+
+    bool test_and_set(const memory_order _Order = memory_order_seq_cst) volatile noexcept {
+        return _Storage.exchange(true, _Order) != 0;
+    }
+
+    void clear(const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Storage.store(false, _Order);
+    }
+
+    void clear(const memory_order _Order = memory_order_seq_cst) volatile noexcept {
+        _Storage.store(false, _Order);
+    }
+
+    constexpr atomic_flag() noexcept = default;
+
+#if _HAS_CXX20
+    void wait(const bool _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
+        _Storage.wait(static_cast<decltype(_Storage)::value_type>(_Expected), _Order);
+    }
+
+    void wait(const bool _Expected, const memory_order _Order = memory_order_seq_cst) const volatile noexcept {
+        _Storage.wait(static_cast<decltype(_Storage)::value_type>(_Expected), _Order);
+    }
+
+    void notify_one() noexcept {
+        _Storage.notify_one();
+    }
+
+    void notify_one() volatile noexcept {
+        _Storage.notify_one();
+    }
+
+    void notify_all() noexcept {
+        _Storage.notify_all();
+    }
+
+    void notify_all() volatile noexcept {
+        _Storage.notify_all();
+    }
+#endif // _HAS_CXX20
+
+#if 1 // TRANSITION, ABI
+    atomic<long> _Storage;
+#else // ^^^ don't break ABI / break ABI vvv
+    atomic<bool> _Storage;
+#endif // ^^^ break ABI ^^^
+};
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD inline bool atomic_flag_test(const volatile atomic_flag* const _Flag) noexcept {
+    return _Flag->test();
+}
+
+_EXPORT_STD _NODISCARD inline bool atomic_flag_test(const atomic_flag* const _Flag) noexcept {
+    return _Flag->test();
+}
+
+_EXPORT_STD _NODISCARD inline bool atomic_flag_test_explicit(
+    const volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
+    return _Flag->test(_Order);
+}
+
+_EXPORT_STD _NODISCARD inline bool atomic_flag_test_explicit(
+    const atomic_flag* const _Flag, const memory_order _Order) noexcept {
+    return _Flag->test(_Order);
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD inline bool atomic_flag_test_and_set(atomic_flag* const _Flag) noexcept {
+    return _Flag->test_and_set();
+}
+
+_EXPORT_STD inline bool atomic_flag_test_and_set(volatile atomic_flag* const _Flag) noexcept {
+    return _Flag->test_and_set();
+}
+
+_EXPORT_STD inline bool atomic_flag_test_and_set_explicit(
+    atomic_flag* const _Flag, const memory_order _Order) noexcept {
+    return _Flag->test_and_set(_Order);
+}
+
+_EXPORT_STD inline bool atomic_flag_test_and_set_explicit(
+    volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
+    return _Flag->test_and_set(_Order);
+}
+
+_EXPORT_STD inline void atomic_flag_clear(atomic_flag* const _Flag) noexcept {
+    _Flag->clear();
+}
+
+_EXPORT_STD inline void atomic_flag_clear(volatile atomic_flag* const _Flag) noexcept {
+    _Flag->clear();
+}
+
+_EXPORT_STD inline void atomic_flag_clear_explicit(atomic_flag* const _Flag, const memory_order _Order) noexcept {
+    _Flag->clear(_Order);
+}
+
+_EXPORT_STD inline void atomic_flag_clear_explicit(
+    volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
+    _Flag->clear(_Order);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD inline void atomic_flag_wait(const volatile atomic_flag* const _Flag, const bool _Expected) noexcept {
+    return _Flag->wait(_Expected);
+}
+
+_EXPORT_STD inline void atomic_flag_wait(const atomic_flag* const _Flag, const bool _Expected) noexcept {
+    return _Flag->wait(_Expected);
+}
+
+_EXPORT_STD inline void atomic_flag_wait_explicit(
+    const volatile atomic_flag* const _Flag, const bool _Expected, const memory_order _Order) noexcept {
+    return _Flag->wait(_Expected, _Order);
+}
+
+_EXPORT_STD inline void atomic_flag_wait_explicit(
+    const atomic_flag* const _Flag, const bool _Expected, const memory_order _Order) noexcept {
+    return _Flag->wait(_Expected, _Order);
+}
+
+_EXPORT_STD inline void atomic_flag_notify_one(volatile atomic_flag* const _Flag) noexcept {
+    return _Flag->notify_one();
+}
+
+_EXPORT_STD inline void atomic_flag_notify_one(atomic_flag* const _Flag) noexcept {
+    return _Flag->notify_one();
+}
+
+_EXPORT_STD inline void atomic_flag_notify_all(volatile atomic_flag* const _Flag) noexcept {
+    return _Flag->notify_all();
+}
+
+_EXPORT_STD inline void atomic_flag_notify_all(atomic_flag* const _Flag) noexcept {
+    return _Flag->notify_all();
+}
+
+template <class _Ty>
+class _Locked_pointer {
+public:
+    static_assert(alignof(_Ty) >= (1 << 2), "2 low order bits are needed by _Locked_pointer");
+    static constexpr uintptr_t _Lock_mask                = 3;
+    static constexpr uintptr_t _Not_locked               = 0;
+    static constexpr uintptr_t _Locked_notify_not_needed = 1;
+    static constexpr uintptr_t _Locked_notify_needed     = 2;
+    static constexpr uintptr_t _Ptr_value_mask           = ~_Lock_mask;
+
+    constexpr _Locked_pointer() noexcept : _Storage{} {}
+    explicit _Locked_pointer(_Ty* const _Ptr) noexcept : _Storage{reinterpret_cast<uintptr_t>(_Ptr)} {}
+
+    _Locked_pointer(const _Locked_pointer&)            = delete;
+    _Locked_pointer& operator=(const _Locked_pointer&) = delete;
+
+    _NODISCARD _Ty* _Lock_and_load() noexcept {
+        uintptr_t _Rep = _Storage.load(memory_order_relaxed);
+        for (;;) {
+            switch (_Rep & _Lock_mask) {
+            case _Not_locked: // Can try to lock now
+                if (_Storage.compare_exchange_weak(_Rep, _Rep | _Locked_notify_not_needed)) {
+                    return reinterpret_cast<_Ty*>(_Rep);
+                }
+                _YIELD_PROCESSOR();
+                break;
+
+            case _Locked_notify_not_needed: // Try to set "notify needed" and wait
+                if (!_Storage.compare_exchange_weak(_Rep, (_Rep & _Ptr_value_mask) | _Locked_notify_needed)) {
+                    // Failed to set notify needed flag, try again
+                    _YIELD_PROCESSOR();
+                    break;
+                }
+                _Rep = (_Rep & _Ptr_value_mask) | _Locked_notify_needed;
+                [[fallthrough]];
+
+            case _Locked_notify_needed: // "Notify needed" is already set, just wait
+                _Storage.wait(_Rep, memory_order_relaxed);
+                _Rep = _Storage.load(memory_order_relaxed);
+                break;
+
+            default: // Unrecognized bit pattern
+                _STL_REPORT_ERROR("atomic shared_ptr invariant broken");
+                break;
+            }
+        }
+    }
+
+    void _Store_and_unlock(_Ty* const _Value) noexcept {
+        const auto _Rep = _Storage.exchange(reinterpret_cast<uintptr_t>(_Value));
+        if ((_Rep & _Lock_mask) == _Locked_notify_needed) {
+            // As we don't count waiters, every waiter is notified, and then some may re-request notification
+            _Storage.notify_all();
+        }
+    }
+
+    _NODISCARD _Ty* _Unsafe_load_relaxed() const noexcept {
+        return reinterpret_cast<_Ty*>(_Storage.load(memory_order_relaxed));
+    }
+
+private:
+    atomic<uintptr_t> _Storage;
+};
+#endif // _HAS_CXX20
+
+_STD_END
+
+#undef _CMPXCHG_MASK_OUT_PADDING_BITS
+
+#undef _ATOMIC_CHOOSE_INTRINSIC
+#undef _ATOMIC_POST_LOAD_BARRIER_AS_NEEDED
+#undef _ATOMIC_STORE_SEQ_CST_X86_X64
+#undef _ATOMIC_STORE_32_SEQ_CST_X86_X64
+#undef _ATOMIC_STORE_SEQ_CST
+#undef _ATOMIC_STORE_32_SEQ_CST
+#undef _ATOMIC_STORE_64_SEQ_CST
+#undef _ATOMIC_STORE_64_SEQ_CST_IX86
+#undef _ATOMIC_STORE_SEQ_CST_ARM64
+#undef __LOAD_ACQUIRE_ARM64
+#undef _ATOMIC_LOAD_ARM64
+#undef __STORE_RELEASE
+#undef _STD_ATOMIC_USE_ARM64_LDAR_STLR
+
+#undef _INVALID_MEMORY_ORDER
+
+#if defined(__clang__) && defined(_M_X64) && !defined(_M_ARM64EC)
+#pragma clang attribute _STD_ATOMIC_HEADER.pop
+#endif // ^^^ defined(__clang__) && defined(_M_X64) && !defined(_M_ARM64EC) ^^^
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _ATOMIC_
diff --git a/msvc-stl/stl/inc/barrier b/msvc-stl/stl/inc/barrier
new file mode 100644
index 0000000..230fc36
--- /dev/null
+++ b/msvc-stl/stl/inc/barrier
@@ -0,0 +1,196 @@
+// barrier standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _BARRIER_
+#define _BARRIER_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <barrier> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <barrier> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+
+#include <atomic>
+#include <climits>
+#include <type_traits>
+#include <xmemory>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+struct _No_completion_function {
+    void operator()() noexcept {}
+};
+
+_EXPORT_STD template <class _Completion_function = _No_completion_function>
+class barrier;
+
+inline constexpr ptrdiff_t _Barrier_arrival_token_mask = 1;
+inline constexpr ptrdiff_t _Barrier_value_mask         = ~_Barrier_arrival_token_mask;
+inline constexpr ptrdiff_t _Barrier_value_shift        = 1;
+inline constexpr ptrdiff_t _Barrier_invalid_token      = 0;
+inline constexpr ptrdiff_t _Barrier_value_step         = 1 << _Barrier_value_shift;
+inline constexpr ptrdiff_t _Barrier_max                = PTRDIFF_MAX >> _Barrier_value_shift;
+
+template <class _Completion_function>
+class _Arrival_token {
+public:
+    _Arrival_token(_Arrival_token&& _Other) noexcept {
+        _Value        = _Other._Value;
+        _Other._Value = _Barrier_invalid_token;
+    }
+
+    _Arrival_token& operator=(_Arrival_token&& _Other) noexcept {
+        _Value        = _Other._Value;
+        _Other._Value = _Barrier_invalid_token;
+        return *this;
+    }
+
+private:
+    explicit _Arrival_token(ptrdiff_t _Value_) noexcept : _Value(_Value_) {}
+    friend barrier<_Completion_function>;
+
+    ptrdiff_t _Value;
+};
+
+_EXPORT_STD template <class _Completion_function>
+class barrier {
+public:
+    static_assert(
+#ifndef __cpp_noexcept_function_type
+        is_function_v<remove_pointer_t<_Completion_function>> ||
+#endif // !defined(__cpp_noexcept_function_type)
+            is_nothrow_invocable_v<_Completion_function&>,
+        "N4950 [thread.barrier.class]/5: is_nothrow_invocable_v<CompletionFunction&> shall be true");
+
+    using arrival_token = _Arrival_token<_Completion_function>;
+
+    constexpr explicit barrier(const ptrdiff_t _Expected, _Completion_function _Fn = _Completion_function())
+        noexcept(is_nothrow_move_constructible_v<_Completion_function>) // strengthened
+        : _Val(_One_then_variadic_args_t{}, _STD move(_Fn), _Expected << _Barrier_value_shift) {
+        _STL_VERIFY(_Expected >= 0 && _Expected <= (max) (),
+            "Precondition: expected >= 0 and expected <= max() (N4950 [thread.barrier.class]/9)");
+    }
+
+    barrier(const barrier&)            = delete;
+    barrier& operator=(const barrier&) = delete;
+
+    _NODISCARD static constexpr ptrdiff_t(max)() noexcept {
+        return _Barrier_max;
+    }
+
+    _NODISCARD_BARRIER_TOKEN arrival_token arrive(ptrdiff_t _Update = 1) noexcept /* strengthened */ {
+        _STL_VERIFY(_Update > 0 && _Update <= (max) (), "Precondition: update > 0 (N4950 [thread.barrier.class]/12)");
+        _Update <<= _Barrier_value_shift;
+        // TRANSITION, GH-1133: should be memory_order_release
+        ptrdiff_t _Current = _Val._Myval2._Current.fetch_sub(_Update) - _Update;
+        _STL_VERIFY(_Current >= 0, "Precondition: update is less than or equal to the expected count "
+                                   "for the current barrier phase (N4950 [thread.barrier.class]/12)");
+        if ((_Current & _Barrier_value_mask) == 0) {
+            // TRANSITION, GH-1133: should have this fence:
+            // atomic_thread_fence(memory_order_acquire);
+            _Completion(_Current);
+        }
+        // Embedding this into the token to provide an additional correctness check that the token is from the same
+        // barrier and wasn't used. All bits of this fit, as barrier should be aligned to at least the size of an
+        // atomic counter.
+        return arrival_token{(_Current & _Barrier_arrival_token_mask) | reinterpret_cast<intptr_t>(this)};
+    }
+
+    void wait(arrival_token&& _Arrival) const noexcept /* strengthened */ {
+        _STL_VERIFY((_Arrival._Value & _Barrier_value_mask) == reinterpret_cast<intptr_t>(this),
+            "Preconditions: arrival is associated with the phase synchronization point for the current phase "
+            "or the immediately preceding phase of the same barrier object (N4950 [thread.barrier.class]/19)");
+        const ptrdiff_t _Arrival_value = _Arrival._Value & _Barrier_arrival_token_mask;
+        _Arrival._Value                = _Barrier_invalid_token;
+        for (;;) {
+            // TRANSITION, GH-1133: should be memory_order_acquire
+            const ptrdiff_t _Current = _Val._Myval2._Current.load();
+            _STL_VERIFY(_Current >= 0, "Invariant counter >= 0, possibly caused by preconditions violation "
+                                       "(N4950 [thread.barrier.class]/12)");
+            if ((_Current & _Barrier_arrival_token_mask) != _Arrival_value) {
+                break;
+            }
+            _Val._Myval2._Current.wait(_Current, memory_order_relaxed);
+        }
+    }
+
+    void arrive_and_wait() noexcept /* strengthened */ {
+        // TRANSITION, GH-1133: should be memory_order_acq_rel
+        ptrdiff_t _Current       = _Val._Myval2._Current.fetch_sub(_Barrier_value_step) - _Barrier_value_step;
+        const ptrdiff_t _Arrival = _Current & _Barrier_arrival_token_mask;
+        _STL_VERIFY(_Current >= 0, "Precondition: update is less than or equal to the expected count "
+                                   "for the current barrier phase (N4950 [thread.barrier.class]/12)");
+        if ((_Current & _Barrier_value_mask) == 0) {
+            _Completion(_Current);
+            return;
+        }
+
+        for (;;) {
+            _Val._Myval2._Current.wait(_Current, memory_order_relaxed);
+            // TRANSITION, GH-1133: should be memory_order_acquire
+            _Current = _Val._Myval2._Current.load();
+            _STL_VERIFY(_Current >= 0, "Invariant counter >= 0, possibly caused by preconditions violation "
+                                       "(N4950 [thread.barrier.class]/12)");
+            if ((_Current & _Barrier_arrival_token_mask) != _Arrival) {
+                break;
+            }
+        }
+    }
+
+    void arrive_and_drop() noexcept /* strengthened */ {
+        const ptrdiff_t _Rem_count =
+            _Val._Myval2._Total.fetch_sub(_Barrier_value_step, memory_order_relaxed) - _Barrier_value_step;
+        _STL_VERIFY(_Rem_count >= 0, "Precondition: The expected count for the current barrier phase "
+                                     "is greater than zero (N4950 [thread.barrier.class]/24) "
+                                     "(checked initial expected count, which is not less than the current)");
+        (void) arrive(1);
+    }
+
+private:
+    void _Completion(const ptrdiff_t _Current) noexcept {
+        const ptrdiff_t _Rem_count = _Val._Myval2._Total.load(memory_order_relaxed);
+        _STL_VERIFY(_Rem_count >= 0, "Invariant: initial expected count less than zero, "
+                                     "possibly caused by preconditions violation "
+                                     "(N4950 [thread.barrier.class]/24)");
+        _Val._Get_first()();
+        const ptrdiff_t _New_phase_count = _Rem_count | ((_Current + 1) & _Barrier_arrival_token_mask);
+        // TRANSITION, GH-1133: should be memory_order_release
+        _Val._Myval2._Current.store(_New_phase_count);
+        _Val._Myval2._Current.notify_all();
+    }
+
+    struct _Counter_t {
+        constexpr explicit _Counter_t(ptrdiff_t _Initial) : _Current(_Initial), _Total(_Initial) {}
+        // wait(arrival_token&&) accepts a token from the current phase or the immediately preceding phase; this means
+        // we can track which phase is the current phase using 1 bit which alternates between each phase. For this
+        // purpose we use the low order bit of _Current.
+        atomic<ptrdiff_t> _Current;
+        atomic<ptrdiff_t> _Total;
+    };
+
+    _Compressed_pair<_Completion_function, _Counter_t> _Val;
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _BARRIER_
diff --git a/msvc-stl/stl/inc/bit b/msvc-stl/stl/inc/bit
new file mode 100644
index 0000000..4f7e6bd
--- /dev/null
+++ b/msvc-stl/stl/inc/bit
@@ -0,0 +1,233 @@
+// bit standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _BIT_
+#define _BIT_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <bit> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+
+#include <__msvc_bit_utils.hpp>
+#include <cstdlib>
+#include <type_traits>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_EXPORT_STD template <class _To, class _From>
+    requires (sizeof(_To) == sizeof(_From)) && is_trivially_copyable_v<_To> && is_trivially_copyable_v<_From>
+_NODISCARD constexpr _To bit_cast(const _From& _Val) noexcept {
+    return __builtin_bit_cast(_To, _Val);
+}
+
+#if _HAS_CXX23
+_NODISCARD constexpr unsigned short _Byteswap_ushort(const unsigned short _Val) noexcept {
+    if (_STD is_constant_evaluated()) {
+        return static_cast<unsigned short>((_Val << 8) | (_Val >> 8));
+    } else {
+        return _byteswap_ushort(_Val);
+    }
+}
+
+_NODISCARD constexpr unsigned long _Byteswap_ulong(const unsigned long _Val) noexcept {
+    if (_STD is_constant_evaluated()) {
+        return (_Val << 24) | ((_Val << 8) & 0x00FF'0000) | ((_Val >> 8) & 0x0000'FF00) | (_Val >> 24);
+    } else {
+        return _byteswap_ulong(_Val);
+    }
+}
+
+_NODISCARD constexpr unsigned long long _Byteswap_uint64(const unsigned long long _Val) noexcept {
+    if (_STD is_constant_evaluated()) {
+        return (_Val << 56) | ((_Val << 40) & 0x00FF'0000'0000'0000) | ((_Val << 24) & 0x0000'FF00'0000'0000)
+             | ((_Val << 8) & 0x0000'00FF'0000'0000) | ((_Val >> 8) & 0x0000'0000'FF00'0000)
+             | ((_Val >> 24) & 0x0000'0000'00FF'0000) | ((_Val >> 40) & 0x0000'0000'0000'FF00) | (_Val >> 56);
+    } else {
+        return _byteswap_uint64(_Val);
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+    requires is_integral_v<_Ty>
+_NODISCARD constexpr _Ty byteswap(const _Ty _Val) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return _Val;
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return static_cast<_Ty>(_Byteswap_ushort(static_cast<unsigned short>(_Val)));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return static_cast<_Ty>(_Byteswap_ulong(static_cast<unsigned long>(_Val)));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return static_cast<_Ty>(_Byteswap_uint64(static_cast<unsigned long long>(_Val)));
+    } else {
+        static_assert(false); // unexpected size
+    }
+}
+#endif // _HAS_CXX23
+
+template <class _Ty>
+concept _Standard_unsigned_integral = _Is_standard_unsigned_integer<_Ty>;
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr int countl_zero(_Ty _Val) noexcept;
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr bool has_single_bit(const _Ty _Val) noexcept {
+#if _POPCNT_INTRINSICS_ALWAYS_AVAILABLE
+    if (!_STD is_constant_evaluated()) {
+        return _Unchecked_popcount(_Val) == 1;
+    }
+#endif // ^^^ _POPCNT_INTRINSICS_ALWAYS_AVAILABLE ^^^
+
+    return (_Val ^ (_Val - 1)) > _Val - 1;
+}
+
+inline void _Precondition_violation_in_bit_ceil() noexcept {}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr _Ty bit_ceil(const _Ty _Val) noexcept /* strengthened */ {
+    if (_Val <= 1u) {
+        return _Ty{1};
+    }
+
+    const int _Num = _Unsigned_integer_digits<_Ty> - _STD countl_zero(static_cast<_Ty>(_Val - 1));
+
+    if constexpr (sizeof(_Ty) < sizeof(unsigned int)) { // for types subject to integral promotion
+        if (_STD is_constant_evaluated()) {
+            // Because N4950 [expr.shift]/1 "integral promotions are performed"
+            // the compiler will not generate a compile time error for
+            // uint8_t{1} << 8
+            // or
+            // uint16_t{1} << 16
+            // so we must manually enforce N4950 [bit.pow.two]/5, 8:
+            // "Preconditions: N is representable as a value of type T."
+            // "Remarks: A function call expression that violates the precondition in the Preconditions: element
+            // is not a core constant expression (7.7)."
+            if (_Num == _Unsigned_integer_digits<_Ty>) {
+                _Precondition_violation_in_bit_ceil();
+            }
+        }
+    }
+
+    return static_cast<_Ty>(_Ty{1} << _Num);
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr _Ty bit_floor(const _Ty _Val) noexcept {
+    if (_Val == 0) {
+        return 0;
+    }
+
+    return static_cast<_Ty>(_Ty{1} << (_Unsigned_integer_digits<_Ty> - 1 - _STD countl_zero(_Val)));
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr int bit_width(const _Ty _Val) noexcept {
+    return _Unsigned_integer_digits<_Ty> - _STD countl_zero(_Val);
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr _Ty rotr(_Ty _Val, int _Rotation) noexcept;
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr _Ty rotl(const _Ty _Val, const int _Rotation) noexcept {
+    constexpr auto _Digits = _Unsigned_integer_digits<_Ty>;
+
+    if (!_STD is_constant_evaluated()) {
+        if constexpr (_Digits == 64) {
+            return _rotl64(_Val, _Rotation);
+        } else if constexpr (_Digits == 32) {
+            return _rotl(_Val, _Rotation);
+        } else if constexpr (_Digits == 16) {
+            return _rotl16(_Val, static_cast<unsigned char>(_Rotation));
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(_Digits == 8);
+            return _rotl8(_Val, static_cast<unsigned char>(_Rotation));
+        }
+    }
+
+    const auto _Remainder = _Rotation % _Digits;
+    if (_Remainder > 0) {
+        return static_cast<_Ty>(
+            static_cast<_Ty>(_Val << _Remainder) | static_cast<_Ty>(_Val >> (_Digits - _Remainder)));
+    } else if (_Remainder == 0) {
+        return _Val;
+    } else { // _Remainder < 0
+        return _STD rotr(_Val, -_Remainder);
+    }
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr _Ty rotr(const _Ty _Val, const int _Rotation) noexcept {
+    constexpr auto _Digits = _Unsigned_integer_digits<_Ty>;
+
+    if (!_STD is_constant_evaluated()) {
+        if constexpr (_Digits == 64) {
+            return _rotr64(_Val, _Rotation);
+        } else if constexpr (_Digits == 32) {
+            return _rotr(_Val, _Rotation);
+        } else if constexpr (_Digits == 16) {
+            return _rotr16(_Val, static_cast<unsigned char>(_Rotation));
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(_Digits == 8);
+            return _rotr8(_Val, static_cast<unsigned char>(_Rotation));
+        }
+    }
+
+    const auto _Remainder = _Rotation % _Digits;
+    if (_Remainder > 0) {
+        return static_cast<_Ty>(
+            static_cast<_Ty>(_Val >> _Remainder) | static_cast<_Ty>(_Val << (_Digits - _Remainder)));
+    } else if (_Remainder == 0) {
+        return _Val;
+    } else { // _Remainder < 0
+        return _STD rotl(_Val, -_Remainder);
+    }
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr int countl_zero(const _Ty _Val) noexcept {
+    return _Countl_zero(_Val);
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr int countl_one(const _Ty _Val) noexcept {
+    return _Countl_zero(static_cast<_Ty>(~_Val));
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr int countr_zero(const _Ty _Val) noexcept {
+    return _Countr_zero(_Val);
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr int countr_one(const _Ty _Val) noexcept {
+    return _Countr_zero(static_cast<_Ty>(~_Val));
+}
+
+_EXPORT_STD template <_Standard_unsigned_integral _Ty>
+_NODISCARD constexpr int popcount(const _Ty _Val) noexcept {
+    return _Popcount(_Val);
+}
+
+_EXPORT_STD enum class endian { little = 0, big = 1, native = little };
+
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _HAS_CXX20
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _BIT_
diff --git a/msvc-stl/stl/inc/bitset b/msvc-stl/stl/inc/bitset
new file mode 100644
index 0000000..68b5480
--- /dev/null
+++ b/msvc-stl/stl/inc/bitset
@@ -0,0 +1,726 @@
+// bitset standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _BITSET_
+#define _BITSET_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_bit_utils.hpp>
+#include <iosfwd>
+#include <xstring>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+#ifndef _STD_BITSET_TO_STREAM_STACK_RESERVATION
+#define _STD_BITSET_TO_STREAM_STACK_RESERVATION 128
+#endif // !defined(_STD_BITSET_TO_STREAM_STACK_RESERVATION)
+
+extern "C" {
+// These bitset functions sometimes assume that the bit array has zero padding to a multiple of 2 or 4 bytes.
+// The assumptions hold true even for the vNext suggestion to use smaller types for small bitsets (see GH-1498)
+// due to vectorization thresholds.
+
+#if _VECTORIZED_BITSET_TO_STRING
+__declspec(noalias) void __stdcall __std_bitset_to_string_1(
+    char* _Dest, const void* _Src, size_t _Size_bits, char _Elem0, char _Elem1) noexcept;
+__declspec(noalias) void __stdcall __std_bitset_to_string_2(
+    wchar_t* _Dest, const void* _Src, size_t _Size_bits, wchar_t _Elem0, wchar_t _Elem1) noexcept;
+#endif // ^^^ _VECTORIZED_BITSET_TO_STRING ^^^
+
+#if _VECTORIZED_BITSET_FROM_STRING
+__declspec(noalias) bool __stdcall __std_bitset_from_string_1(void* _Dest, const char* _Src, size_t _Size_bytes,
+    size_t _Size_bits, size_t _Size_chars, char _Elem0, char _Elem1) noexcept;
+__declspec(noalias) bool __stdcall __std_bitset_from_string_2(void* _Dest, const wchar_t* _Src, size_t _Size_bytes,
+    size_t _Size_bits, size_t _Size_chars, wchar_t _Elem0, wchar_t _Elem1) noexcept;
+#endif // ^^^ _VECTORIZED_BITSET_FROM_STRING ^^^
+
+} // extern "C"
+
+_STD_BEGIN
+template <class _Elem, size_t _Bits, bool _Dynamic = (_Bits * sizeof(_Elem) > _STD_BITSET_TO_STREAM_STACK_RESERVATION)>
+struct _Buffer_for_bitset {
+    _Buffer_for_bitset() noexcept                            = default;
+    _Buffer_for_bitset(const _Buffer_for_bitset&)            = delete;
+    _Buffer_for_bitset& operator=(const _Buffer_for_bitset&) = delete;
+
+    ~_Buffer_for_bitset() {
+        delete[] _Buf;
+    }
+
+    void _Allocate() {
+        _Buf = new _Elem[_Bits];
+    }
+
+    _Elem* _Buf = nullptr;
+};
+
+template <class _Elem, size_t _Bits>
+struct _Buffer_for_bitset<_Elem, _Bits, false> {
+    _Buffer_for_bitset() noexcept { /* intentionally not initializing _Buf */ }
+    _Buffer_for_bitset(const _Buffer_for_bitset&)            = delete;
+    _Buffer_for_bitset& operator=(const _Buffer_for_bitset&) = delete;
+
+    void _Allocate() noexcept {}
+
+    _Elem _Buf[(_Bits != 0) ? _Bits : 1];
+};
+
+_EXPORT_STD template <size_t _Bits> // store fixed-length sequence of Boolean elements
+class _NO_SPECIALIZATIONS_CITING("N5014 [namespace.std]/2.1") bitset {
+private:
+#pragma warning(push)
+#pragma warning(disable : 4296) // expression is always true (/Wall)
+    using _Ty = conditional_t<_Bits <= sizeof(unsigned long) * CHAR_BIT, unsigned long, unsigned long long>;
+#pragma warning(pop)
+
+public:
+    class reference { // proxy for an element
+        friend bitset;
+
+    public:
+        _CONSTEXPR23 reference(const reference&) noexcept = default;
+
+        _CONSTEXPR23 ~reference() noexcept {} // TRANSITION, ABI
+
+        _CONSTEXPR23 reference& operator=(const bool _Val) noexcept {
+            _Pbitset->_Set_unchecked(_Mypos, _Val);
+            return *this;
+        }
+
+        _CONSTEXPR23 reference& operator=(const reference& _Bitref) noexcept {
+            _Pbitset->_Set_unchecked(_Mypos, static_cast<bool>(_Bitref));
+            return *this;
+        }
+
+        _CONSTEXPR23 const reference& operator=(const bool _Val) const noexcept {
+            _Pbitset->_Set_unchecked(_Mypos, _Val);
+            return *this;
+        }
+
+        _NODISCARD _CONSTEXPR23 bool operator~() const noexcept {
+            return !_Pbitset->_Subscript(_Mypos);
+        }
+
+        _CONSTEXPR23 operator bool() const noexcept {
+            return _Pbitset->_Subscript(_Mypos);
+        }
+
+        _CONSTEXPR23 reference& flip() noexcept {
+            _Pbitset->_Flip_unchecked(_Mypos);
+            return *this;
+        }
+
+        friend constexpr void swap(reference _Left, reference _Right) noexcept {
+            bool _Val = _Left; // NOT _STD swap
+            _Left     = _Right;
+            _Right    = _Val;
+        }
+
+        friend constexpr void swap(reference _Left, bool& _Right) noexcept {
+            bool _Val = _Left; // NOT _STD swap
+            _Left     = _Right;
+            _Right    = _Val;
+        }
+
+        friend constexpr void swap(bool& _Left, reference _Right) noexcept {
+            swap(_Right, _Left);
+        }
+
+    private:
+        _CONSTEXPR23 reference(bitset<_Bits>& _Bitset, const size_t _Pos) noexcept : _Pbitset(&_Bitset), _Mypos(_Pos) {}
+
+        bitset<_Bits>* _Pbitset;
+        size_t _Mypos; // position of element in bitset
+    };
+
+private:
+    constexpr bool _Subscript(size_t _Pos) const noexcept {
+        return (_Array[_Pos / _Bitsperword] & (_Ty{1} << _Pos % _Bitsperword)) != 0;
+    }
+
+    static constexpr bool _Need_mask          = _Bits < CHAR_BIT * sizeof(unsigned long long);
+    static constexpr unsigned long long _Mask = (1ULL << (_Need_mask ? _Bits : 0)) - 1ULL;
+
+public:
+    _NODISCARD constexpr bool operator[](const size_t _Pos) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BITSET || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Pos < _Bits, "bitset subscript out of range");
+#endif
+
+        return _Subscript(_Pos);
+    }
+
+    _NODISCARD _CONSTEXPR23 reference operator[](const size_t _Pos) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BITSET || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Pos < _Bits, "bitset subscript out of range");
+#endif
+
+        return reference(*this, _Pos);
+    }
+
+    constexpr bitset() noexcept : _Array() {} // construct with all false values
+
+    constexpr bitset(unsigned long long _Val) noexcept : _Array{static_cast<_Ty>(_Need_mask ? _Val & _Mask : _Val)} {}
+
+private:
+    template <class _Traits, class _Elem>
+    _CONSTEXPR23 void _Construct(const _Elem* const _Ptr, size_t _Count, const _Elem _Elem0, const _Elem _Elem1) {
+#if _VECTORIZED_BITSET_FROM_STRING
+        constexpr size_t _Bitset_from_string_vector_threshold = 16;
+        if constexpr (_Bits >= _Bitset_from_string_vector_threshold
+                      && _Is_implementation_handled_char_traits<_Traits> && sizeof(_Elem) <= 2) {
+            if (!_STD _Is_constant_evaluated()) {
+                bool _Result;
+
+                if constexpr (sizeof(_Elem) == 1) {
+                    _Result = __std_bitset_from_string_1(_Array, reinterpret_cast<const char*>(_Ptr), sizeof(_Array),
+                        _Bits, _Count, static_cast<char>(_Elem0), static_cast<char>(_Elem1));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Elem) == 2);
+                    _Result = __std_bitset_from_string_2(_Array, reinterpret_cast<const wchar_t*>(_Ptr), sizeof(_Array),
+                        _Bits, _Count, static_cast<wchar_t>(_Elem0), static_cast<wchar_t>(_Elem1));
+                }
+
+                if (!_Result) {
+                    _Xinv();
+                }
+
+                return;
+            }
+        }
+#endif // ^^^ _VECTORIZED_BITSET_FROM_STRING ^^^
+
+        if (_Count > _Bits) {
+            for (size_t _Idx = _Bits; _Idx < _Count; ++_Idx) {
+                const auto _Ch = _Ptr[_Idx];
+                if (!_Traits::eq(_Elem1, _Ch) && !_Traits::eq(_Elem0, _Ch)) {
+                    _Xinv();
+                }
+            }
+
+            _Count = _Bits;
+        }
+
+        size_t _Wpos = 0;
+        if (_Count != 0) {
+            size_t _Bits_used_in_word = 0;
+            auto _Last                = _Ptr + _Count;
+            _Ty _This_word            = 0;
+            do {
+                --_Last;
+                const auto _Ch = *_Last;
+                _This_word |= static_cast<_Ty>(_Traits::eq(_Elem1, _Ch)) << _Bits_used_in_word;
+                if (!_Traits::eq(_Elem1, _Ch) && !_Traits::eq(_Elem0, _Ch)) {
+                    _Xinv();
+                }
+
+                if (++_Bits_used_in_word == _Bitsperword) {
+                    _Array[_Wpos] = _This_word;
+                    ++_Wpos;
+                    _This_word         = 0;
+                    _Bits_used_in_word = 0;
+                }
+            } while (_Ptr != _Last);
+
+            if (_Bits_used_in_word != 0) {
+                _Array[_Wpos] = _This_word;
+                ++_Wpos;
+            }
+        }
+
+        for (; _Wpos <= _Words; ++_Wpos) {
+            _Array[_Wpos] = 0;
+        }
+    }
+
+public:
+    template <class _Elem, class _Traits, class _Alloc>
+    _CONSTEXPR23 explicit bitset(const basic_string<_Elem, _Traits, _Alloc>& _Str,
+        typename basic_string<_Elem, _Traits, _Alloc>::size_type _Pos   = 0,
+        typename basic_string<_Elem, _Traits, _Alloc>::size_type _Count = basic_string<_Elem, _Traits, _Alloc>::npos,
+        _Elem _Elem0 = static_cast<_Elem>('0'), _Elem _Elem1 = static_cast<_Elem>('1')) {
+        // construct from [_Pos, _Pos + _Count) elements in string
+        if (_Str.size() < _Pos) {
+            _Xran(); // _Pos off end
+        }
+
+        if (_Str.size() - _Pos < _Count) {
+            _Count = _Str.size() - _Pos; // trim _Count to size
+        }
+
+        _Construct<_Traits>(_Str.data() + _Pos, _Count, _Elem0, _Elem1);
+    }
+
+    template <class _Elem, enable_if_t<conjunction_v<negation<is_array<_Elem>>, is_trivially_copyable<_Elem>,
+                                           is_standard_layout<_Elem>, is_trivially_default_constructible<_Elem>>,
+                               int> = 0>
+    _CONSTEXPR23 explicit bitset(const _Elem* _Ntcts,
+        typename basic_string<_Elem>::size_type _Count = basic_string<_Elem>::npos,
+        _Elem _Elem0 = static_cast<_Elem>('0'), _Elem _Elem1 = static_cast<_Elem>('1')) {
+        if (_Count == basic_string<_Elem>::npos) {
+            _Count = char_traits<_Elem>::length(_Ntcts);
+        }
+
+        _Construct<char_traits<_Elem>>(_Ntcts, _Count, _Elem0, _Elem1);
+    }
+
+    _CONSTEXPR23 bitset& operator&=(const bitset& _Right) noexcept {
+        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
+            _Array[_Wpos] &= _Right._Array[_Wpos];
+        }
+
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& operator|=(const bitset& _Right) noexcept {
+        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
+            _Array[_Wpos] |= _Right._Array[_Wpos];
+        }
+
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& operator^=(const bitset& _Right) noexcept {
+        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
+            _Array[_Wpos] ^= _Right._Array[_Wpos];
+        }
+
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& operator<<=(size_t _Pos) noexcept { // shift left by _Pos, first by words then by bits
+        const auto _Wordshift = static_cast<ptrdiff_t>(_Pos / _Bitsperword);
+        if (_Wordshift != 0) {
+            for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos) {
+                _Array[_Wpos] = _Wordshift <= _Wpos ? _Array[_Wpos - _Wordshift] : 0;
+            }
+        }
+
+        if ((_Pos %= _Bitsperword) != 0) { // 0 < _Pos < _Bitsperword, shift by bits
+            for (ptrdiff_t _Wpos = _Words; 0 < _Wpos; --_Wpos) {
+                _Array[_Wpos] = (_Array[_Wpos] << _Pos) | (_Array[_Wpos - 1] >> (_Bitsperword - _Pos));
+            }
+
+            _Array[0] <<= _Pos;
+        }
+        _Trim();
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& operator>>=(size_t _Pos) noexcept { // shift right by _Pos, first by words then by bits
+        const auto _Wordshift = static_cast<ptrdiff_t>(_Pos / _Bitsperword);
+        if (_Wordshift != 0) {
+            for (ptrdiff_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
+                _Array[_Wpos] = _Wordshift <= _Words - _Wpos ? _Array[_Wpos + _Wordshift] : 0;
+            }
+        }
+
+        if ((_Pos %= _Bitsperword) != 0) { // 0 < _Pos < _Bitsperword, shift by bits
+            for (ptrdiff_t _Wpos = 0; _Wpos < _Words; ++_Wpos) {
+                _Array[_Wpos] = (_Array[_Wpos] >> _Pos) | (_Array[_Wpos + 1] << (_Bitsperword - _Pos));
+            }
+
+            _Array[_Words] >>= _Pos;
+        }
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& set() noexcept { // set all bits true
+#if _HAS_CXX23
+        if (_STD is_constant_evaluated()) {
+            for (auto& _El : _Array) {
+                _El = static_cast<_Ty>(-1);
+            }
+        } else
+#endif // _HAS_CXX23
+        {
+            _CSTD memset(&_Array, 0xFF, sizeof(_Array));
+        }
+        _Trim();
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& set(const size_t _Pos, bool _Val = true) { // set bit at _Pos to _Val
+        if (_Bits <= _Pos) {
+            _Xran(); // _Pos off end
+        }
+
+        return _Set_unchecked(_Pos, _Val);
+    }
+
+    _CONSTEXPR23 bitset& reset() noexcept { // set all bits false
+#if _HAS_CXX23
+        if (_STD is_constant_evaluated()) {
+            for (auto& _El : _Array) {
+                _El = 0;
+            }
+        } else
+#endif // _HAS_CXX23
+        {
+            _CSTD memset(&_Array, 0, sizeof(_Array));
+        }
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& reset(const size_t _Pos) { // set bit at _Pos to false
+        return set(_Pos, false);
+    }
+
+    _NODISCARD _CONSTEXPR23 bitset operator~() const noexcept { // flip all bits
+        bitset _Tmp = *this;
+        _Tmp.flip();
+        return _Tmp;
+    }
+
+    _CONSTEXPR23 bitset& flip() noexcept { // flip all bits
+        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
+            _Array[_Wpos] = ~_Array[_Wpos];
+        }
+
+        _Trim();
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& flip(const size_t _Pos) { // flip bit at _Pos
+        if (_Bits <= _Pos) {
+            _Xran(); // _Pos off end
+        }
+
+        return _Flip_unchecked(_Pos);
+    }
+
+    _NODISCARD _CONSTEXPR23 unsigned long to_ulong() const noexcept(_Bits <= 32) /* strengthened */ {
+        constexpr bool _Bits_zero  = _Bits == 0;
+        constexpr bool _Bits_small = _Bits <= 32;
+        constexpr bool _Bits_large = _Bits > 64;
+        if constexpr (_Bits_zero) {
+            return 0;
+        } else if constexpr (_Bits_small) {
+            return static_cast<unsigned long>(_Array[0]);
+        } else {
+            if constexpr (_Bits_large) {
+                for (size_t _Idx = 1; _Idx <= _Words; ++_Idx) {
+                    if (_Array[_Idx] != 0) {
+                        _Xoflo(); // fail if any high-order words are nonzero
+                    }
+                }
+            }
+
+            if (!_STD _In_range<unsigned long>(_Array[0])) {
+                _Xoflo();
+            }
+
+            return static_cast<unsigned long>(_Array[0]);
+        }
+    }
+
+    _NODISCARD _CONSTEXPR23 unsigned long long to_ullong() const noexcept(_Bits <= 64) /* strengthened */ {
+        constexpr bool _Bits_zero  = _Bits == 0;
+        constexpr bool _Bits_large = _Bits > 64;
+        if constexpr (_Bits_zero) {
+            return 0;
+        } else {
+            if constexpr (_Bits_large) {
+                for (size_t _Idx = 1; _Idx <= _Words; ++_Idx) {
+                    if (_Array[_Idx] != 0) {
+                        _Xoflo(); // fail if any high-order words are nonzero
+                    }
+                }
+            }
+
+            return _Array[0];
+        }
+    }
+
+    template <class _Elem = char, class _Tr = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+    _NODISCARD _CONSTEXPR23 basic_string<_Elem, _Tr, _Alloc> to_string(
+        const _Elem _Elem0 = static_cast<_Elem>('0'), const _Elem _Elem1 = static_cast<_Elem>('1')) const {
+        // convert bitset to string
+        basic_string<_Elem, _Tr, _Alloc> _Str;
+        _Str._Resize_and_overwrite(_Bits, [this, _Elem0, _Elem1](_Elem* _Buf, size_t _Len) {
+            _To_string(_Buf, _Len, _Elem0, _Elem1);
+            return _Len;
+        });
+        return _Str;
+    }
+
+    _NODISCARD _CONSTEXPR23 size_t count() const noexcept { // count number of set bits
+        return _Select_popcount_impl<_Ty>([this](auto _Popcount_impl) {
+            size_t _Val = 0;
+            for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
+                _Val += _Popcount_impl(_Array[_Wpos]);
+            }
+
+            return _Val;
+        });
+    }
+
+    _NODISCARD constexpr size_t size() const noexcept {
+        return _Bits;
+    }
+
+    _NODISCARD _CONSTEXPR23 bool operator==(const bitset& _Right) const noexcept {
+#if _HAS_CXX23
+        if (_STD is_constant_evaluated()) {
+            for (size_t _Index = 0; _Index <= _Words; ++_Index) {
+                if (_Array[_Index] != _Right._Array[_Index]) {
+                    return false;
+                }
+            }
+            return true;
+        } else
+#endif // _HAS_CXX23
+        {
+            return _CSTD memcmp(&_Array[0], &_Right._Array[0], sizeof(_Array)) == 0;
+        }
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const bitset& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _NODISCARD _CONSTEXPR23 bool test(const size_t _Pos) const {
+        if (_Bits <= _Pos) {
+            _Xran(); // _Pos off end
+        }
+
+        return _Subscript(_Pos);
+    }
+
+    _NODISCARD _CONSTEXPR23 bool any() const noexcept {
+        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
+            if (_Array[_Wpos] != 0) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    _NODISCARD _CONSTEXPR23 bool none() const noexcept {
+        return !any();
+    }
+
+    _NODISCARD _CONSTEXPR23 bool all() const noexcept {
+        if constexpr (_Bits == 0) { // must test for this, otherwise would count one full word
+            return true;
+        }
+
+        constexpr bool _No_padding = _Bits % _Bitsperword == 0;
+        for (size_t _Wpos = 0; _Wpos < _Words + _No_padding; ++_Wpos) {
+            if (_Array[_Wpos] != ~static_cast<_Ty>(0)) {
+                return false;
+            }
+        }
+
+        return _No_padding || _Array[_Words] == (static_cast<_Ty>(1) << (_Bits % _Bitsperword)) - 1;
+    }
+
+    _NODISCARD _CONSTEXPR23 bitset operator<<(const size_t _Pos) const noexcept {
+        bitset _Tmp = *this;
+        _Tmp <<= _Pos;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR23 bitset operator>>(const size_t _Pos) const noexcept {
+        bitset _Tmp = *this;
+        _Tmp >>= _Pos;
+        return _Tmp;
+    }
+
+    _NODISCARD _Ty _Getword(size_t _Wpos) const noexcept { // nonstandard extension; get underlying word
+        return _Array[_Wpos];
+    }
+
+    template <class _Elem>
+    _CONSTEXPR23 void _To_string(
+        _Elem* const _Buf, const size_t _Len, const _Elem _Elem0, const _Elem _Elem1) const noexcept {
+#if _VECTORIZED_BITSET_TO_STRING
+        constexpr size_t _Bitset_to_string_vector_threshold = 32;
+        if constexpr (_Bits >= _Bitset_to_string_vector_threshold && is_integral_v<_Elem> && sizeof(_Elem) <= 2) {
+            if (!_Is_constant_evaluated()) {
+                if constexpr (sizeof(_Elem) == 1) {
+                    __std_bitset_to_string_1(reinterpret_cast<char*>(_Buf), _Array, _Len, static_cast<char>(_Elem0),
+                        static_cast<char>(_Elem1));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Elem) == 2);
+                    __std_bitset_to_string_2(reinterpret_cast<wchar_t*>(_Buf), _Array, _Len,
+                        static_cast<wchar_t>(_Elem0), static_cast<wchar_t>(_Elem1));
+                }
+
+                return;
+            }
+        }
+#endif // ^^^ _VECTORIZED_BITSET_TO_STRING ^^^
+
+        for (size_t _Pos = 0; _Pos < _Len; ++_Pos) {
+            _Buf[_Pos] = _Subscript(_Len - 1 - _Pos) ? _Elem1 : _Elem0;
+        }
+    }
+
+private:
+    friend hash<bitset<_Bits>>;
+
+    static constexpr ptrdiff_t _Bitsperword = CHAR_BIT * sizeof(_Ty);
+    static constexpr ptrdiff_t _Words       = _Bits == 0 ? 0 : (_Bits - 1) / _Bitsperword; // NB: number of words - 1
+
+    _CONSTEXPR23 void _Trim() noexcept { // clear any trailing bits in last word
+        constexpr bool _Work_to_do = _Bits == 0 || _Bits % _Bitsperword != 0;
+        if constexpr (_Work_to_do) {
+            _Array[_Words] &= (_Ty{1} << _Bits % _Bitsperword) - 1;
+        }
+    }
+
+    _CONSTEXPR23 bitset& _Set_unchecked(const size_t _Pos, const bool _Val) noexcept {
+        // set bit at _Pos to _Val, no checking
+        auto& _Selected_word = _Array[_Pos / _Bitsperword];
+        const auto _Bit      = _Ty{1} << _Pos % _Bitsperword;
+        if (_Val) {
+            _Selected_word |= _Bit;
+        } else {
+            _Selected_word &= ~_Bit;
+        }
+
+        return *this;
+    }
+
+    _CONSTEXPR23 bitset& _Flip_unchecked(const size_t _Pos) noexcept { // flip bit at _Pos, no checking
+        _Array[_Pos / _Bitsperword] ^= _Ty{1} << _Pos % _Bitsperword;
+        return *this;
+    }
+
+    [[noreturn]] static void _Xinv() {
+        _Xinvalid_argument("invalid bitset char");
+    }
+
+    [[noreturn]] static void _Xoflo() {
+        _Xoverflow_error("bitset overflow");
+    }
+
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid bitset position");
+    }
+
+    _Ty _Array[_Words + 1];
+};
+
+_EXPORT_STD template <size_t _Bits>
+_NODISCARD _CONSTEXPR23 bitset<_Bits> operator&(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
+    bitset<_Bits> _Ans = _Left;
+    _Ans &= _Right;
+    return _Ans;
+}
+
+_EXPORT_STD template <size_t _Bits>
+_NODISCARD _CONSTEXPR23 bitset<_Bits> operator|(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
+    bitset<_Bits> _Ans = _Left;
+    _Ans |= _Right;
+    return _Ans;
+}
+
+_EXPORT_STD template <size_t _Bits>
+_NODISCARD _CONSTEXPR23 bitset<_Bits> operator^(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
+    bitset<_Bits> _Ans = _Left;
+    _Ans ^= _Right;
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Elem, class _Tr, size_t _Bits>
+basic_ostream<_Elem, _Tr>& operator<<(basic_ostream<_Elem, _Tr>& _Ostr, const bitset<_Bits>& _Right) {
+    using _Ctype             = typename basic_ostream<_Elem, _Tr>::_Ctype;
+    const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Ostr.getloc());
+    const _Elem _Elem0       = _Ctype_fac.widen('0');
+    const _Elem _Elem1       = _Ctype_fac.widen('1');
+
+    _Buffer_for_bitset<_Elem, _Bits> _Buf;
+    _Buf._Allocate();
+    _Right._To_string(_Buf._Buf, _Bits, _Elem0, _Elem1);
+    _Ostr.write(_Buf._Buf, _Bits);
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Tr, size_t _Bits>
+basic_istream<_Elem, _Tr>& operator>>(basic_istream<_Elem, _Tr>& _Istr, bitset<_Bits>& _Right) {
+    using _Istr_t                    = basic_istream<_Elem, _Tr>;
+    using _Ctype                     = typename _Istr_t::_Ctype;
+    const _Ctype& _Ctype_fac         = _STD use_facet<_Ctype>(_Istr.getloc());
+    const _Elem _Elem0               = _Ctype_fac.widen('0');
+    const _Elem _Elem1               = _Ctype_fac.widen('1');
+    typename _Istr_t::iostate _State = _Istr_t::goodbit;
+    size_t _Count                    = 0;
+    _Buffer_for_bitset<_Elem, _Bits> _Buf;
+    const typename _Istr_t::sentry _Ok(_Istr);
+
+    if (_Ok) { // valid stream, extract elements
+        _TRY_IO_BEGIN
+        _Buf._Allocate();
+        typename _Tr::int_type _Meta = _Istr.rdbuf()->sgetc();
+        for (; _Count < _Bits; ++_Count, _Meta = _Istr.rdbuf()->snextc()) {
+            // test _Meta
+            if (_Tr::eq_int_type(_Tr::eof(), _Meta)) { // end of file, quit
+                _State |= _Istr_t::eofbit;
+                break;
+            }
+
+            const _Elem _Char = _Tr::to_char_type(_Meta);
+
+            if (!_Tr::eq(_Char, _Elem0) && !_Tr::eq(_Char, _Elem1)) {
+                break; // invalid element
+            }
+
+            // valid, append '0' or '1'
+            _Buf._Buf[_Count] = '0' + _Tr::eq(_Char, _Elem1);
+        }
+
+        _CATCH_IO_(_Istr_t, _Istr)
+    }
+
+    constexpr bool _Has_bits = _Bits > 0;
+
+    if constexpr (_Has_bits) {
+        if (_Count == 0) {
+            _State |= _Istr_t::failbit;
+        }
+    }
+
+    _Istr.setstate(_State);
+    _Right = bitset<_Bits>{_Buf._Buf, _Count}; // convert string and store
+    return _Istr;
+}
+
+template <size_t _Bits>
+struct hash<bitset<_Bits>> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = bitset<_Bits>;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(const bitset<_Bits>& _Keyval) noexcept {
+        return _Hash_representation(_Keyval._Array);
+    }
+};
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _BITSET_
diff --git a/msvc-stl/stl/inc/cassert b/msvc-stl/stl/inc/cassert
new file mode 100644
index 0000000..cf8f3ce
--- /dev/null
+++ b/msvc-stl/stl/inc/cassert
@@ -0,0 +1,9 @@
+// cassert standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// NOTE: no include guard
+#include <yvals_core.h>
+
+#include <assert.h>
diff --git a/msvc-stl/stl/inc/ccomplex b/msvc-stl/stl/inc/ccomplex
new file mode 100644
index 0000000..b60309d
--- /dev/null
+++ b/msvc-stl/stl/inc/ccomplex
@@ -0,0 +1,29 @@
+// ccomplex standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CCOMPLEX_
+#define _CCOMPLEX_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <complex>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+using _Header_ccomplex _CXX17_DEPRECATE_C_HEADER = int;
+using _Hdr_ccomplex                              = _Header_ccomplex;
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CCOMPLEX_
diff --git a/msvc-stl/stl/inc/cctype b/msvc-stl/stl/inc/cctype
new file mode 100644
index 0000000..bf10605
--- /dev/null
+++ b/msvc-stl/stl/inc/cctype
@@ -0,0 +1,44 @@
+// cctype standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CCTYPE_
+#define _CCTYPE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <ctype.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD isalnum;
+_EXPORT_STD using _CSTD isalpha;
+_EXPORT_STD using _CSTD iscntrl;
+_EXPORT_STD using _CSTD isdigit;
+_EXPORT_STD using _CSTD isgraph;
+_EXPORT_STD using _CSTD islower;
+_EXPORT_STD using _CSTD isprint;
+_EXPORT_STD using _CSTD ispunct;
+_EXPORT_STD using _CSTD isspace;
+_EXPORT_STD using _CSTD isupper;
+_EXPORT_STD using _CSTD isxdigit;
+_EXPORT_STD using _CSTD tolower;
+_EXPORT_STD using _CSTD toupper;
+
+_EXPORT_STD using _CSTD isblank;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CCTYPE_
diff --git a/msvc-stl/stl/inc/cerrno b/msvc-stl/stl/inc/cerrno
new file mode 100644
index 0000000..7dabd29
--- /dev/null
+++ b/msvc-stl/stl/inc/cerrno
@@ -0,0 +1,14 @@
+// cerrno standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CERRNO_
+#define _CERRNO_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <errno.h>
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CERRNO_
diff --git a/msvc-stl/stl/inc/cfenv b/msvc-stl/stl/inc/cfenv
new file mode 100644
index 0000000..da59fe6
--- /dev/null
+++ b/msvc-stl/stl/inc/cfenv
@@ -0,0 +1,48 @@
+// cfenv standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CFENV_
+#define _CFENV_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <fenv.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD fegetround;
+_EXPORT_STD using _CSTD fesetround;
+
+#if !defined(_M_CEE) || defined(_CRTBLD)
+_EXPORT_STD using _CSTD feclearexcept;
+_EXPORT_STD using _CSTD fegetenv;
+_EXPORT_STD using _CSTD fegetexceptflag;
+_EXPORT_STD using _CSTD feholdexcept;
+_EXPORT_STD using _CSTD fenv_t;
+_EXPORT_STD using _CSTD fesetenv;
+_EXPORT_STD using _CSTD fesetexceptflag;
+_EXPORT_STD using _CSTD fetestexcept;
+_EXPORT_STD using _CSTD fexcept_t;
+#endif // !defined(_M_CEE) || defined(_CRTBLD)
+
+#if !defined(_M_CEE) && !defined(_CRTBLD)
+_EXPORT_STD using _CSTD feraiseexcept;
+_EXPORT_STD using _CSTD feupdateenv;
+#endif // !defined(_M_CEE) && !defined(_CRTBLD)
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CFENV_
diff --git a/msvc-stl/stl/inc/cfloat b/msvc-stl/stl/inc/cfloat
new file mode 100644
index 0000000..0623f9c
--- /dev/null
+++ b/msvc-stl/stl/inc/cfloat
@@ -0,0 +1,11 @@
+// cfloat standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CFLOAT_
+#define _CFLOAT_
+#include <yvals_core.h>
+
+#include <float.h>
+#endif // _CFLOAT_
diff --git a/msvc-stl/stl/inc/charconv b/msvc-stl/stl/inc/charconv
new file mode 100644
index 0000000..ed715a0
--- /dev/null
+++ b/msvc-stl/stl/inc/charconv
@@ -0,0 +1,2646 @@
+// charconv standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CHARCONV_
+#define _CHARCONV_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <charconv> are available only with C++17 or later.");
+#else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#include <cstring>
+#include <xbit_ops.h>
+#include <xcharconv.h>
+#include <xcharconv_ryu.h>
+#include <xcharconv_tables.h>
+#include <xutility>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// This implementation is dedicated to the memory of Mary and Thavatchai.
+
+_STD_BEGIN
+inline constexpr char _Charconv_digits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
+    'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
+_STL_INTERNAL_STATIC_ASSERT(_STD size(_Charconv_digits) == 36);
+
+template <class _RawTy>
+_NODISCARD _CONSTEXPR23 to_chars_result _Integer_to_chars(
+    char* _First, char* const _Last, const _RawTy _Raw_value, const int _Base) noexcept {
+    _Adl_verify_range(_First, _Last);
+    _STL_ASSERT(_Base >= 2 && _Base <= 36, "invalid base in to_chars()");
+
+    using _Unsigned = make_unsigned_t<_RawTy>;
+
+    _Unsigned _Value = static_cast<_Unsigned>(_Raw_value);
+
+    if constexpr (is_signed_v<_RawTy>) {
+        if (_Raw_value < 0) {
+            if (_First == _Last) {
+                return {_Last, errc::value_too_large};
+            }
+
+            *_First++ = '-';
+
+            _Value = static_cast<_Unsigned>(0 - _Value);
+        }
+    }
+
+    constexpr size_t _Buff_size = sizeof(_Unsigned) * CHAR_BIT; // enough for base 2
+    char _Buff[_Buff_size];
+    char* const _Buff_end = _Buff + _Buff_size;
+    char* _RNext          = _Buff_end;
+
+    switch (_Base) {
+    case 10:
+        { // Derived from _UIntegral_to_buff()
+#ifdef _WIN64
+            auto _Trunc = _Value;
+#else // ^^^ 64-bit / 32-bit vvv
+            if constexpr (sizeof(_Unsigned) > 4) { // For 64-bit numbers, work in chunks to avoid 64-bit divisions.
+                while (_Value > 0xFFFFFFFFU) {
+                    auto _Value_chunk = static_cast<unsigned long>(_Value % 100000000);
+                    _Value /= 100000000;
+
+                    for (int _Idx = 0; _Idx != 3; ++_Idx) {
+                        const unsigned long _Value_chunk_part = _Value_chunk % 100;
+                        _Value_chunk /= 100;
+                        _RNext -= 2;
+                        if (!_STD _Is_constant_evaluated()) {
+                            _CSTD memcpy(_RNext, _Digit_pairs<char>._Data[_Value_chunk_part], 2);
+                        } else {
+                            _RNext[0] = _Digit_pairs<char>._Data[_Value_chunk_part][0];
+                            _RNext[1] = _Digit_pairs<char>._Data[_Value_chunk_part][1];
+                        }
+                    }
+
+                    _RNext -= 2;
+                    if (!_STD _Is_constant_evaluated()) {
+                        _CSTD memcpy(_RNext, _Digit_pairs<char>._Data[_Value_chunk], 2);
+                    } else {
+                        _RNext[0] = _Digit_pairs<char>._Data[_Value_chunk][0];
+                        _RNext[1] = _Digit_pairs<char>._Data[_Value_chunk][1];
+                    }
+                }
+            }
+
+            auto _Trunc = static_cast<unsigned long>(_Value);
+#endif // ^^^ 32-bit ^^^
+
+            // If we have a single digit, print [0, 9] and return. (This is necessary to correctly handle 0.)
+            if (_Trunc < 10) {
+                *--_RNext = static_cast<char>('0' + _Trunc);
+                break;
+            }
+
+            // Print one or more pairs of digits.
+            do {
+                const auto _Trunc_part = static_cast<unsigned long>(_Trunc % 100);
+                _Trunc /= 100;
+                _RNext -= 2;
+                if (!_STD _Is_constant_evaluated()) {
+                    _CSTD memcpy(_RNext, _Digit_pairs<char>._Data[_Trunc_part], 2);
+                } else {
+                    _RNext[0] = _Digit_pairs<char>._Data[_Trunc_part][0];
+                    _RNext[1] = _Digit_pairs<char>._Data[_Trunc_part][1];
+                }
+            } while (_Trunc >= 10);
+
+            // If we have an unpaired digit, print it.
+            // For example, 1729 is printed as 17 29, and 19937 is printed as 1 99 37.
+            if (_Trunc != 0) {
+                *--_RNext = static_cast<char>('0' + _Trunc);
+            }
+            break;
+        }
+
+    case 2:
+        do {
+            *--_RNext = static_cast<char>('0' + (_Value & 0b1));
+            _Value >>= 1;
+        } while (_Value != 0);
+        break;
+
+    case 4:
+        do {
+            *--_RNext = static_cast<char>('0' + (_Value & 0b11));
+            _Value >>= 2;
+        } while (_Value != 0);
+        break;
+
+    case 8:
+        do {
+            *--_RNext = static_cast<char>('0' + (_Value & 0b111));
+            _Value >>= 3;
+        } while (_Value != 0);
+        break;
+
+    case 16:
+        do {
+            *--_RNext = _Charconv_digits[_Value & 0b1111];
+            _Value >>= 4;
+        } while (_Value != 0);
+        break;
+
+    case 32:
+        do {
+            *--_RNext = _Charconv_digits[_Value & 0b11111];
+            _Value >>= 5;
+        } while (_Value != 0);
+        break;
+
+    case 3:
+    case 5:
+    case 6:
+    case 7:
+    case 9:
+        do {
+            *--_RNext = static_cast<char>('0' + _Value % _Base);
+            _Value    = static_cast<_Unsigned>(_Value / _Base);
+        } while (_Value != 0);
+        break;
+
+    default:
+        do {
+            *--_RNext = _Charconv_digits[_Value % _Base];
+            _Value    = static_cast<_Unsigned>(_Value / _Base);
+        } while (_Value != 0);
+        break;
+    }
+
+    const ptrdiff_t _Digits_written = _Buff_end - _RNext;
+
+    if (_Last - _First < _Digits_written) {
+        return {_Last, errc::value_too_large};
+    }
+
+    _Copy_n_unchecked4(_RNext, _Digits_written, _First);
+
+    return {_First + _Digits_written, errc{}};
+}
+
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
+    char* const _First, char* const _Last, const char _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
+    char* const _First, char* const _Last, const signed char _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned char _Value,
+    const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
+    char* const _First, char* const _Last, const short _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned short _Value,
+    const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
+    char* const _First, char* const _Last, const int _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned int _Value,
+    const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
+    char* const _First, char* const _Last, const long _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last, const unsigned long _Value,
+    const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(
+    char* const _First, char* const _Last, const long long _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 to_chars_result to_chars(char* const _First, char* const _Last,
+    const unsigned long long _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_to_chars(_First, _Last, _Value, _Base);
+}
+
+_EXPORT_STD to_chars_result to_chars(char* _First, char* _Last, bool _Value, int _Base = 10) = delete;
+
+_EXPORT_STD struct from_chars_result {
+    const char* ptr;
+    errc ec;
+#if _HAS_CXX20
+    _NODISCARD friend bool operator==(const from_chars_result&, const from_chars_result&) = default;
+#endif // _HAS_CXX20
+};
+
+// convert ['0', '9'] ['A', 'Z'] ['a', 'z'] to [0, 35], everything else to 255
+inline constexpr unsigned char _Digit_from_byte[] = {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, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255,
+    255, 255, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+    255, 255, 255, 255, 255, 255, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+    31, 32, 33, 34, 35, 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, 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, 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, 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, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255};
+_STL_INTERNAL_STATIC_ASSERT(_STD size(_Digit_from_byte) == 256);
+
+_NODISCARD _CONSTEXPR23 unsigned char _Digit_from_char(const char _Ch) noexcept {
+    // convert ['0', '9'] ['A', 'Z'] ['a', 'z'] to [0, 35], everything else to 255
+
+    // CodeQL [SM01954] This index is valid: we cast to unsigned char and the array has 256 elements.
+    return _Digit_from_byte[static_cast<unsigned char>(_Ch)];
+}
+
+template <class _RawTy>
+_NODISCARD _CONSTEXPR23 from_chars_result _Integer_from_chars(
+    const char* const _First, const char* const _Last, _RawTy& _Raw_value, const int _Base) noexcept {
+    _Adl_verify_range(_First, _Last);
+    _STL_ASSERT(_Base >= 2 && _Base <= 36, "invalid base in from_chars()");
+
+    bool _Minus_sign = false;
+
+    const char* _Next = _First;
+
+    if constexpr (is_signed_v<_RawTy>) {
+        if (_Next != _Last && *_Next == '-') {
+            _Minus_sign = true;
+            ++_Next;
+        }
+    }
+
+    using _Unsigned = make_unsigned_t<_RawTy>;
+
+    constexpr _Unsigned _Uint_max    = static_cast<_Unsigned>(-1);
+    constexpr _Unsigned _Int_max     = static_cast<_Unsigned>(_Uint_max >> 1);
+#pragma warning(push)
+#pragma warning(disable : 26450) // TRANSITION, VSO-1828677
+    constexpr _Unsigned _Abs_int_min = static_cast<_Unsigned>(_Int_max + 1);
+#pragma warning(pop)
+
+    _Unsigned _Risky_val;
+    _Unsigned _Max_digit;
+
+    if constexpr (is_signed_v<_RawTy>) {
+        if (_Minus_sign) {
+            _Risky_val = static_cast<_Unsigned>(_Abs_int_min / _Base);
+            _Max_digit = static_cast<_Unsigned>(_Abs_int_min % _Base);
+        } else {
+            _Risky_val = static_cast<_Unsigned>(_Int_max / _Base);
+            _Max_digit = static_cast<_Unsigned>(_Int_max % _Base);
+        }
+    } else {
+        _Risky_val = static_cast<_Unsigned>(_Uint_max / _Base);
+        _Max_digit = static_cast<_Unsigned>(_Uint_max % _Base);
+    }
+
+    _Unsigned _Value = 0;
+
+    bool _Overflowed = false;
+
+    for (; _Next != _Last; ++_Next) {
+        const unsigned char _Digit = _Digit_from_char(*_Next);
+
+        if (_Digit >= _Base) {
+            break;
+        }
+
+        if (_Value < _Risky_val // never overflows
+            || (_Value == _Risky_val && _Digit <= _Max_digit)) { // overflows for certain digits
+            _Value = static_cast<_Unsigned>(_Value * _Base + _Digit);
+        } else { // _Value > _Risky_val always overflows
+            _Overflowed = true; // keep going, _Next still needs to be updated, _Value is now irrelevant
+        }
+    }
+
+    if (_Next - _First == static_cast<ptrdiff_t>(_Minus_sign)) {
+        return {_First, errc::invalid_argument};
+    }
+
+    if (_Overflowed) {
+        return {_Next, errc::result_out_of_range};
+    }
+
+    if constexpr (is_signed_v<_RawTy>) {
+        if (_Minus_sign) {
+            _Value = static_cast<_Unsigned>(0 - _Value);
+        }
+    }
+
+    _Raw_value = static_cast<_RawTy>(_Value); // congruent to _Value modulo 2^N for negative, N4950 [conv.integral]/3
+
+    return {_Next, errc{}};
+}
+
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(
+    const char* const _First, const char* const _Last, char& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    signed char& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned char& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last, short& _Value,
+    const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned short& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(
+    const char* const _First, const char* const _Last, int& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned int& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(
+    const char* const _First, const char* const _Last, long& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned long& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    long long& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+_EXPORT_STD _CONSTEXPR23 from_chars_result from_chars(const char* const _First, const char* const _Last,
+    unsigned long long& _Value, const int _Base = 10) noexcept /* strengthened */ {
+    return _Integer_from_chars(_First, _Last, _Value, _Base);
+}
+
+// vvvvvvvvvv DERIVED FROM corecrt_internal_big_integer.h vvvvvvvvvv
+
+// A lightweight, sufficiently functional high-precision integer type for use in the binary floating-point <=> decimal
+// string conversions. We define only the operations (and in some cases, parts of operations) that are actually used.
+
+// We require sufficient precision to represent the reciprocal of the smallest representable value (the smallest
+// denormal, 2^-1074). During parsing, we may also consider up to 768 decimal digits. For this, we require an
+// additional log2(10^768) bits of precision. Finally, we require 54 bits of space for pre-division numerator shifting,
+// because double explicitly stores 52 bits, implicitly stores 1 bit, and we need 1 more bit for rounding.
+
+// PERFORMANCE NOTE: We intentionally do not initialize the _Mydata array when a _Big_integer_flt object is constructed.
+// Profiling showed that zero-initialization caused a substantial performance hit. Initialization of the _Mydata
+// array is not necessary: all operations on the _Big_integer_flt type are carefully written to only access elements at
+// indices [0, _Myused), and all operations correctly update _Myused as the utilized size increases.
+
+// _Big_integer_flt _Xval{}; is direct-list-initialization (N4950 [dcl.init.list]/1).
+// N4950 [dcl.init.list]/3.5:
+// "Otherwise, if the initializer list has no elements and T is a class type with a default constructor,
+// the object is value-initialized."
+// N4950 [dcl.init.general]/9, /9.1, /9.1.1:
+// "To value-initialize an object of type T means:
+// - if T is a (possibly cv-qualified) class type ([class]), then
+//   - if T has either no default constructor ([class.default.ctor]) or a default constructor
+//   that is user-provided or deleted, then the object is default-initialized;"
+// N4950 [dcl.init.general]/7, /7.1:
+// "To default-initialize an object of type T means:
+// - If T is a (possibly cv-qualified) class type ([class]), constructors are considered. The applicable constructors
+// are enumerated ([over.match.ctor]), and the best one for the initializer () is chosen through overload resolution
+// ([over.match]).
+// The constructor thus selected is called, with an empty argument list, to initialize the object."
+// N4950 [class.base.init]/9, /9.3:
+// "In a non-delegating constructor other than an implicitly-defined copy/move constructor ([class.copy.ctor]),
+// if a given potentially constructed subobject is not designated by a mem-initializer-id (including the case
+// where there is no mem-initializer-list because the constructor has no ctor-initializer), then [...]
+// - otherwise, the entity is default-initialized ([dcl.init])."
+// N4950 [dcl.init.general]/7, /7.2, /7.3:
+// "To default-initialize an object of type T means: [...]
+// - If T is an array type, each element is default-initialized.
+// - Otherwise, no initialization is performed."
+// Therefore, _Mydata's elements are not initialized.
+struct _Big_integer_flt {
+#pragma warning(push)
+#pragma warning(disable : 26495) // Variable 'std::_Big_integer_flt::_Mydata' is uninitialized.
+                                 // Always initialize a member variable (type.6).
+    _Big_integer_flt() noexcept : _Myused(0) {}
+#pragma warning(pop)
+
+    _Big_integer_flt(const _Big_integer_flt& _Other) noexcept : _Myused(_Other._Myused) {
+        _CSTD memcpy(_Mydata, _Other._Mydata, _Other._Myused * sizeof(uint32_t));
+    }
+
+    _Big_integer_flt& operator=(const _Big_integer_flt& _Other) noexcept {
+        _Myused = _Other._Myused;
+        _CSTD memmove(_Mydata, _Other._Mydata, _Other._Myused * sizeof(uint32_t));
+        return *this;
+    }
+
+    _NODISCARD bool operator<(const _Big_integer_flt& _Rhs) const noexcept {
+        if (_Myused != _Rhs._Myused) {
+            return _Myused < _Rhs._Myused;
+        }
+
+        for (uint32_t _Ix = _Myused - 1; _Ix != static_cast<uint32_t>(-1); --_Ix) {
+            if (_Mydata[_Ix] != _Rhs._Mydata[_Ix]) {
+                return _Mydata[_Ix] < _Rhs._Mydata[_Ix];
+            }
+        }
+
+        return false;
+    }
+
+    static constexpr uint32_t _Maximum_bits = 1074 // 1074 bits required to represent 2^1074
+                                            + 2552 // ceil(log2(10^768))
+                                            + 54; // shift space
+
+    static constexpr uint32_t _Element_bits = 32;
+
+    static constexpr uint32_t _Element_count = (_Maximum_bits + _Element_bits - 1) / _Element_bits;
+
+    uint32_t _Myused; // The number of elements currently in use
+    uint32_t _Mydata[_Element_count]; // The number, stored in little-endian form
+};
+
+_NODISCARD inline _Big_integer_flt _Make_big_integer_flt_one() noexcept {
+    _Big_integer_flt _Xval{};
+    _Xval._Mydata[0] = 1;
+    _Xval._Myused    = 1;
+    return _Xval;
+}
+
+_NODISCARD inline uint32_t _Bit_scan_reverse(const _Big_integer_flt& _Xval) noexcept {
+    if (_Xval._Myused == 0) {
+        return 0;
+    }
+
+    const uint32_t _Bx = _Xval._Myused - 1;
+
+    unsigned long _Index; // Intentionally uninitialized for better codegen
+
+    _STL_INTERNAL_CHECK(_Xval._Mydata[_Bx] != 0); // _Big_integer_flt should always be trimmed
+
+    // CodeQL [SM02313] _Index is always initialized: we've guaranteed that _Xval._Mydata[_Bx] is non-zero.
+    _BitScanReverse(&_Index, _Xval._Mydata[_Bx]);
+
+    return _Index + 1 + _Bx * _Big_integer_flt::_Element_bits;
+}
+
+// Shifts the high-precision integer _Xval by _Nx bits to the left. Returns true if the left shift was successful;
+// false if it overflowed. When overflow occurs, the high-precision integer is reset to zero.
+_NODISCARD inline bool _Shift_left(_Big_integer_flt& _Xval, const uint32_t _Nx) noexcept {
+    if (_Xval._Myused == 0) {
+        return true;
+    }
+
+    const uint32_t _Unit_shift = _Nx / _Big_integer_flt::_Element_bits;
+    const uint32_t _Bit_shift  = _Nx % _Big_integer_flt::_Element_bits;
+
+    if (_Xval._Myused + _Unit_shift > _Big_integer_flt::_Element_count) {
+        // Unit shift will overflow.
+        _Xval._Myused = 0;
+        return false;
+    }
+
+    if (_Bit_shift == 0) {
+        _CSTD memmove(_Xval._Mydata + _Unit_shift, _Xval._Mydata, _Xval._Myused * sizeof(uint32_t));
+        _Xval._Myused += _Unit_shift;
+    } else {
+        const bool _Bit_shifts_into_next_unit =
+            _Bit_shift > (_Big_integer_flt::_Element_bits - _Bit_scan_reverse(_Xval._Mydata[_Xval._Myused - 1]));
+
+        const uint32_t _New_used = _Xval._Myused + _Unit_shift + static_cast<uint32_t>(_Bit_shifts_into_next_unit);
+
+        if (_New_used > _Big_integer_flt::_Element_count) {
+            // Bit shift will overflow.
+            _Xval._Myused = 0;
+            return false;
+        }
+
+        const uint32_t _Msb_bits = _Bit_shift;
+        const uint32_t _Lsb_bits = _Big_integer_flt::_Element_bits - _Msb_bits;
+
+        const uint32_t _Lsb_mask = (1UL << _Lsb_bits) - 1UL;
+        const uint32_t _Msb_mask = ~_Lsb_mask;
+
+        // If _Unit_shift == 0, this will wraparound, which is okay.
+        for (uint32_t _Dest_index = _New_used - 1; _Dest_index != _Unit_shift - 1; --_Dest_index) {
+            // performance note: PSLLDQ and PALIGNR instructions could be more efficient here
+
+            // If _Bit_shifts_into_next_unit, the first iteration will trigger the bounds check below, which is okay.
+            const uint32_t _Upper_source_index = _Dest_index - _Unit_shift;
+
+            // When _Dest_index == _Unit_shift, this will wraparound, which is okay (see bounds check below).
+            const uint32_t _Lower_source_index = _Dest_index - _Unit_shift - 1;
+
+            const uint32_t _Upper_source = _Upper_source_index < _Xval._Myused ? _Xval._Mydata[_Upper_source_index] : 0;
+            const uint32_t _Lower_source = _Lower_source_index < _Xval._Myused ? _Xval._Mydata[_Lower_source_index] : 0;
+
+            const uint32_t _Shifted_upper_source = (_Upper_source & _Lsb_mask) << _Msb_bits;
+            const uint32_t _Shifted_lower_source = (_Lower_source & _Msb_mask) >> _Lsb_bits;
+
+            const uint32_t _Combined_shifted_source = _Shifted_upper_source | _Shifted_lower_source;
+
+            _Xval._Mydata[_Dest_index] = _Combined_shifted_source;
+        }
+
+        _Xval._Myused = _New_used;
+    }
+
+    _CSTD memset(_Xval._Mydata, 0, _Unit_shift * sizeof(uint32_t));
+
+    return true;
+}
+
+// Adds a 32-bit _Value to the high-precision integer _Xval. Returns true if the addition was successful;
+// false if it overflowed. When overflow occurs, the high-precision integer is reset to zero.
+_NODISCARD inline bool _Add(_Big_integer_flt& _Xval, const uint32_t _Value) noexcept {
+    if (_Value == 0) {
+        return true;
+    }
+
+    uint32_t _Carry = _Value;
+    for (uint32_t _Ix = 0; _Ix != _Xval._Myused; ++_Ix) {
+        const uint64_t _Result = static_cast<uint64_t>(_Xval._Mydata[_Ix]) + _Carry;
+        _Xval._Mydata[_Ix]     = static_cast<uint32_t>(_Result);
+        _Carry                 = static_cast<uint32_t>(_Result >> 32);
+    }
+
+    if (_Carry != 0) {
+        if (_Xval._Myused < _Big_integer_flt::_Element_count) {
+            _Xval._Mydata[_Xval._Myused] = _Carry;
+            ++_Xval._Myused;
+        } else {
+            _Xval._Myused = 0;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+_NODISCARD inline uint32_t _Add_carry(uint32_t& _Ux1, const uint32_t _Ux2, const uint32_t _U_carry) noexcept {
+    const uint64_t _Uu = static_cast<uint64_t>(_Ux1) + _Ux2 + _U_carry;
+    _Ux1               = static_cast<uint32_t>(_Uu);
+    return static_cast<uint32_t>(_Uu >> 32);
+}
+
+_NODISCARD inline uint32_t _Add_multiply_carry(
+    uint32_t& _U_add, const uint32_t _U_mul_1, const uint32_t _U_mul_2, const uint32_t _U_carry) noexcept {
+    const uint64_t _Uu_res = static_cast<uint64_t>(_U_mul_1) * _U_mul_2 + _U_add + _U_carry;
+    _U_add                 = static_cast<uint32_t>(_Uu_res);
+    return static_cast<uint32_t>(_Uu_res >> 32);
+}
+
+_NODISCARD inline uint32_t _Multiply_core(
+    uint32_t* const _Multiplicand, const uint32_t _Multiplicand_count, const uint32_t _Multiplier) noexcept {
+    uint32_t _Carry = 0;
+    for (uint32_t _Ix = 0; _Ix != _Multiplicand_count; ++_Ix) {
+        const uint64_t _Result = static_cast<uint64_t>(_Multiplicand[_Ix]) * _Multiplier + _Carry;
+        _Multiplicand[_Ix]     = static_cast<uint32_t>(_Result);
+        _Carry                 = static_cast<uint32_t>(_Result >> 32);
+    }
+
+    return _Carry;
+}
+
+// Multiplies the high-precision _Multiplicand by a 32-bit _Multiplier. Returns true if the multiplication
+// was successful; false if it overflowed. When overflow occurs, the _Multiplicand is reset to zero.
+_NODISCARD inline bool _Multiply(_Big_integer_flt& _Multiplicand, const uint32_t _Multiplier) noexcept {
+    if (_Multiplier == 0) {
+        _Multiplicand._Myused = 0;
+        return true;
+    }
+
+    if (_Multiplier == 1) {
+        return true;
+    }
+
+    if (_Multiplicand._Myused == 0) {
+        return true;
+    }
+
+    const uint32_t _Carry = _Multiply_core(_Multiplicand._Mydata, _Multiplicand._Myused, _Multiplier);
+    if (_Carry != 0) {
+        if (_Multiplicand._Myused < _Big_integer_flt::_Element_count) {
+            _Multiplicand._Mydata[_Multiplicand._Myused] = _Carry;
+            ++_Multiplicand._Myused;
+        } else {
+            _Multiplicand._Myused = 0;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// This high-precision integer multiplication implementation was translated from the implementation of
+// System.Numerics.BigIntegerBuilder.Mul in the .NET Framework sources. It multiplies the _Multiplicand
+// by the _Multiplier and returns true if the multiplication was successful; false if it overflowed.
+// When overflow occurs, the _Multiplicand is reset to zero.
+_NODISCARD inline bool _Multiply(_Big_integer_flt& _Multiplicand, const _Big_integer_flt& _Multiplier) noexcept {
+    if (_Multiplicand._Myused == 0) {
+        return true;
+    }
+
+    if (_Multiplier._Myused == 0) {
+        _Multiplicand._Myused = 0;
+        return true;
+    }
+
+    if (_Multiplier._Myused == 1) {
+        return _Multiply(_Multiplicand, _Multiplier._Mydata[0]); // when overflow occurs, resets to zero
+    }
+
+    if (_Multiplicand._Myused == 1) {
+        const uint32_t _Small_multiplier = _Multiplicand._Mydata[0];
+        _Multiplicand                    = _Multiplier;
+        return _Multiply(_Multiplicand, _Small_multiplier); // when overflow occurs, resets to zero
+    }
+
+    // We prefer more iterations on the inner loop and fewer on the outer:
+    const bool _Multiplier_is_shorter = _Multiplier._Myused < _Multiplicand._Myused;
+    const uint32_t* const _Rgu1       = _Multiplier_is_shorter ? _Multiplier._Mydata : _Multiplicand._Mydata;
+    const uint32_t* const _Rgu2       = _Multiplier_is_shorter ? _Multiplicand._Mydata : _Multiplier._Mydata;
+
+    const uint32_t _Cu1 = _Multiplier_is_shorter ? _Multiplier._Myused : _Multiplicand._Myused;
+    const uint32_t _Cu2 = _Multiplier_is_shorter ? _Multiplicand._Myused : _Multiplier._Myused;
+
+    _Big_integer_flt _Result{};
+    for (uint32_t _Iu1 = 0; _Iu1 != _Cu1; ++_Iu1) {
+        const uint32_t _U_cur = _Rgu1[_Iu1];
+        if (_U_cur == 0) {
+            if (_Iu1 == _Result._Myused) {
+                _Result._Mydata[_Iu1] = 0;
+                _Result._Myused       = _Iu1 + 1;
+            }
+
+            continue;
+        }
+
+        uint32_t _U_carry = 0;
+        uint32_t _Iu_res  = _Iu1;
+        for (uint32_t _Iu2 = 0; _Iu2 != _Cu2 && _Iu_res != _Big_integer_flt::_Element_count; ++_Iu2, ++_Iu_res) {
+            if (_Iu_res == _Result._Myused) {
+                _Result._Mydata[_Iu_res] = 0;
+                _Result._Myused          = _Iu_res + 1;
+            }
+
+            _U_carry = _Add_multiply_carry(_Result._Mydata[_Iu_res], _U_cur, _Rgu2[_Iu2], _U_carry);
+        }
+
+        while (_U_carry != 0 && _Iu_res != _Big_integer_flt::_Element_count) {
+            if (_Iu_res == _Result._Myused) {
+                _Result._Mydata[_Iu_res] = 0;
+                _Result._Myused          = _Iu_res + 1;
+            }
+
+            _U_carry = _Add_carry(_Result._Mydata[_Iu_res++], 0, _U_carry);
+        }
+
+        if (_Iu_res == _Big_integer_flt::_Element_count) {
+            _Multiplicand._Myused = 0;
+            return false;
+        }
+    }
+
+    // Store the _Result in the _Multiplicand and compute the actual number of elements used:
+    _Multiplicand = _Result;
+    return true;
+}
+
+extern const uint32_t _Large_power_data[578];
+
+// Multiplies the high-precision integer _Xval by 10^_Power. Returns true if the multiplication was successful;
+// false if it overflowed. When overflow occurs, the high-precision integer is reset to zero.
+_NODISCARD inline bool _Multiply_by_power_of_ten(_Big_integer_flt& _Xval, const uint32_t _Power) noexcept {
+    // To improve performance, we use a table of precomputed powers of ten, from 10^10 through 10^380, in increments
+    // of ten. In its unpacked form, as an array of _Big_integer_flt objects, this table consists mostly of zero
+    // elements. Thus, we store the table in a packed form, trimming leading and trailing zero elements. We provide an
+    // index that is used to unpack powers from the table, using the function that appears after this function in this
+    // file.
+
+    // The minimum value representable with double-precision is 5E-324.
+    // With the _Large_power_data table we can thus compute most multiplications with a single multiply.
+
+    struct _Unpack_index {
+        uint16_t _Offset; // The offset of this power's initial element in the array
+        uint8_t _Zeroes; // The number of omitted leading zero elements
+        uint8_t _Size; // The number of elements present for this power
+    };
+
+    static constexpr _Unpack_index _Large_power_indices[] = {{0, 0, 2}, {2, 0, 3}, {5, 0, 4}, {9, 1, 4}, {13, 1, 5},
+        {18, 1, 6}, {24, 2, 6}, {30, 2, 7}, {37, 2, 8}, {45, 3, 8}, {53, 3, 9}, {62, 3, 10}, {72, 4, 10}, {82, 4, 11},
+        {93, 4, 12}, {105, 5, 12}, {117, 5, 13}, {130, 5, 14}, {144, 5, 15}, {159, 6, 15}, {174, 6, 16}, {190, 6, 17},
+        {207, 7, 17}, {224, 7, 18}, {242, 7, 19}, {261, 8, 19}, {280, 8, 21}, {301, 8, 22}, {323, 9, 22}, {345, 9, 23},
+        {368, 9, 24}, {392, 10, 24}, {416, 10, 25}, {441, 10, 26}, {467, 10, 27}, {494, 11, 27}, {521, 11, 28},
+        {549, 11, 29}};
+
+    for (uint32_t _Large_power = _Power / 10; _Large_power != 0;) {
+        const uint32_t _Current_power =
+            (_STD min) (_Large_power, static_cast<uint32_t>(_STD size(_Large_power_indices)));
+
+        const _Unpack_index& _Index = _Large_power_indices[_Current_power - 1];
+        _Big_integer_flt _Multiplier{};
+        _Multiplier._Myused = static_cast<uint32_t>(_Index._Size + _Index._Zeroes);
+
+        const uint32_t* const _Source = _Large_power_data + _Index._Offset;
+
+        _CSTD memset(_Multiplier._Mydata, 0, _Index._Zeroes * sizeof(uint32_t));
+        _CSTD memcpy(_Multiplier._Mydata + _Index._Zeroes, _Source, _Index._Size * sizeof(uint32_t));
+
+        if (!_Multiply(_Xval, _Multiplier)) { // when overflow occurs, resets to zero
+            return false;
+        }
+
+        _Large_power -= _Current_power;
+    }
+
+    static constexpr uint32_t _Small_powers_of_ten[9] = {
+        10, 100, 1'000, 10'000, 100'000, 1'000'000, 10'000'000, 100'000'000, 1'000'000'000};
+
+    const uint32_t _Small_power = _Power % 10;
+
+    if (_Small_power == 0) {
+        return true;
+    }
+
+    return _Multiply(_Xval, _Small_powers_of_ten[_Small_power - 1]); // when overflow occurs, resets to zero
+}
+
+// Computes the number of zeroes higher than the most significant set bit in _Ux
+_NODISCARD inline uint32_t _Count_sequential_high_zeroes(const uint32_t _Ux) noexcept {
+    unsigned long _Index; // Intentionally uninitialized for better codegen
+    return _BitScanReverse(&_Index, _Ux) ? 31 - _Index : 32;
+}
+
+// This high-precision integer division implementation was translated from the implementation of
+// System.Numerics.BigIntegerBuilder.ModDivCore in the .NET Framework sources.
+// It computes both quotient and remainder: the remainder is stored in the _Numerator argument,
+// and the least significant 64 bits of the quotient are returned from the function.
+_NODISCARD inline uint64_t _Divide(_Big_integer_flt& _Numerator, const _Big_integer_flt& _Denominator) noexcept {
+    // If the _Numerator is zero, then both the quotient and remainder are zero:
+    if (_Numerator._Myused == 0) {
+        return 0;
+    }
+
+    // If the _Denominator is zero, then uh oh. We can't divide by zero:
+    _STL_INTERNAL_CHECK(_Denominator._Myused != 0); // Division by zero
+
+    uint32_t _Max_numerator_element_index         = _Numerator._Myused - 1;
+    const uint32_t _Max_denominator_element_index = _Denominator._Myused - 1;
+
+    // The _Numerator and _Denominator are both nonzero.
+    // If the _Denominator is only one element wide, we can take the fast route:
+    if (_Max_denominator_element_index == 0) {
+        const uint32_t _Small_denominator = _Denominator._Mydata[0];
+
+        if (_Max_numerator_element_index == 0) {
+            const uint32_t _Small_numerator = _Numerator._Mydata[0];
+
+            if (_Small_denominator == 1) {
+                _Numerator._Myused = 0;
+                return _Small_numerator;
+            }
+
+            _Numerator._Mydata[0] = _Small_numerator % _Small_denominator;
+            _Numerator._Myused    = _Numerator._Mydata[0] > 0 ? 1u : 0u;
+            return _Small_numerator / _Small_denominator;
+        }
+
+        if (_Small_denominator == 1) {
+            uint64_t _Quotient = _Numerator._Mydata[1];
+            _Quotient <<= 32;
+            _Quotient |= _Numerator._Mydata[0];
+            _Numerator._Myused = 0;
+            return _Quotient;
+        }
+
+        // We count down in the next loop, so the last assignment to _Quotient will be the correct one.
+        uint64_t _Quotient = 0;
+
+        uint64_t _Uu = 0;
+        for (uint32_t _Iv = _Max_numerator_element_index; _Iv != static_cast<uint32_t>(-1); --_Iv) {
+            _Uu       = (_Uu << 32) | _Numerator._Mydata[_Iv];
+            _Quotient = (_Quotient << 32) + static_cast<uint32_t>(_Uu / _Small_denominator);
+            _Uu %= _Small_denominator;
+        }
+
+        _Numerator._Mydata[1] = static_cast<uint32_t>(_Uu >> 32);
+        _Numerator._Mydata[0] = static_cast<uint32_t>(_Uu);
+
+        if (_Numerator._Mydata[1] > 0) {
+            _Numerator._Myused = 2u;
+        } else if (_Numerator._Mydata[0] > 0) {
+            _Numerator._Myused = 1u;
+        } else {
+            _Numerator._Myused = 0u;
+        }
+
+        return _Quotient;
+    }
+
+    if (_Max_denominator_element_index > _Max_numerator_element_index) {
+        return 0;
+    }
+
+    const uint32_t _Cu_den = _Max_denominator_element_index + 1;
+    const int32_t _Cu_diff = static_cast<int32_t>(_Max_numerator_element_index - _Max_denominator_element_index);
+
+    // Determine whether the result will have _Cu_diff or _Cu_diff + 1 digits:
+    int32_t _Cu_quo = _Cu_diff;
+    for (int32_t _Iu = static_cast<int32_t>(_Max_numerator_element_index);; --_Iu) {
+        if (_Iu < _Cu_diff) {
+            ++_Cu_quo;
+            break;
+        }
+
+        if (_Denominator._Mydata[_Iu - _Cu_diff] != _Numerator._Mydata[_Iu]) {
+            if (_Denominator._Mydata[_Iu - _Cu_diff] < _Numerator._Mydata[_Iu]) {
+                ++_Cu_quo;
+            }
+
+            break;
+        }
+    }
+
+    if (_Cu_quo == 0) {
+        return 0;
+    }
+
+    // Get the uint to use for the trial divisions. We normalize so the high bit is set:
+    uint32_t _U_den      = _Denominator._Mydata[_Cu_den - 1];
+    uint32_t _U_den_next = _Denominator._Mydata[_Cu_den - 2];
+
+    const uint32_t _Cbit_shift_left  = _Count_sequential_high_zeroes(_U_den);
+    const uint32_t _Cbit_shift_right = 32 - _Cbit_shift_left;
+    if (_Cbit_shift_left > 0) {
+        _U_den = (_U_den << _Cbit_shift_left) | (_U_den_next >> _Cbit_shift_right);
+        _U_den_next <<= _Cbit_shift_left;
+
+        if (_Cu_den > 2) {
+            _U_den_next |= _Denominator._Mydata[_Cu_den - 3] >> _Cbit_shift_right;
+        }
+    }
+
+    uint64_t _Quotient = 0;
+    for (int32_t _Iu = _Cu_quo; --_Iu >= 0;) {
+        // Get the high (normalized) bits of the _Numerator:
+        const uint32_t _U_num_hi =
+            (_Iu + _Cu_den <= _Max_numerator_element_index) ? _Numerator._Mydata[_Iu + _Cu_den] : 0;
+
+        uint64_t _Uu_num =
+            (static_cast<uint64_t>(_U_num_hi) << 32) | static_cast<uint64_t>(_Numerator._Mydata[_Iu + _Cu_den - 1]);
+
+        uint32_t _U_num_next = _Numerator._Mydata[_Iu + _Cu_den - 2];
+        if (_Cbit_shift_left > 0) {
+            _Uu_num = (_Uu_num << _Cbit_shift_left) | (_U_num_next >> _Cbit_shift_right);
+            _U_num_next <<= _Cbit_shift_left;
+
+            if (_Iu + _Cu_den >= 3) {
+                _U_num_next |= _Numerator._Mydata[_Iu + _Cu_den - 3] >> _Cbit_shift_right;
+            }
+        }
+
+        // Divide to get the quotient digit:
+        uint64_t _Uu_quo = _Uu_num / _U_den;
+        uint64_t _Uu_rem = static_cast<uint32_t>(_Uu_num % _U_den);
+
+        if (_Uu_quo > UINT32_MAX) {
+            _Uu_rem += _U_den * (_Uu_quo - UINT32_MAX);
+            _Uu_quo = UINT32_MAX;
+        }
+
+        while (_Uu_rem <= UINT32_MAX && _Uu_quo * _U_den_next > ((_Uu_rem << 32) | _U_num_next)) {
+            --_Uu_quo;
+            _Uu_rem += _U_den;
+        }
+
+        // Multiply and subtract. Note that _Uu_quo may be one too large.
+        // If we have a borrow at the end, we'll add the _Denominator back on and decrement _Uu_quo.
+        if (_Uu_quo > 0) {
+            uint64_t _Uu_borrow = 0;
+
+            for (uint32_t _Iu2 = 0; _Iu2 < _Cu_den; ++_Iu2) {
+                _Uu_borrow += _Uu_quo * _Denominator._Mydata[_Iu2];
+
+                const uint32_t _U_sub = static_cast<uint32_t>(_Uu_borrow);
+                _Uu_borrow >>= 32;
+                if (_Numerator._Mydata[_Iu + _Iu2] < _U_sub) {
+                    ++_Uu_borrow;
+                }
+
+                _Numerator._Mydata[_Iu + _Iu2] -= _U_sub;
+            }
+
+            if (_U_num_hi < _Uu_borrow) {
+                // Add, tracking carry:
+                uint32_t _U_carry = 0;
+                for (uint32_t _Iu2 = 0; _Iu2 < _Cu_den; ++_Iu2) {
+                    const uint64_t _Sum = static_cast<uint64_t>(_Numerator._Mydata[_Iu + _Iu2])
+                                        + static_cast<uint64_t>(_Denominator._Mydata[_Iu2]) + _U_carry;
+
+                    _Numerator._Mydata[_Iu + _Iu2] = static_cast<uint32_t>(_Sum);
+                    _U_carry                       = static_cast<uint32_t>(_Sum >> 32);
+                }
+
+                --_Uu_quo;
+            }
+
+            _Max_numerator_element_index = _Iu + _Cu_den - 1;
+        }
+
+        _Quotient = (_Quotient << 32) + static_cast<uint32_t>(_Uu_quo);
+    }
+
+    // Trim the remainder:
+    uint32_t _Used = _Max_numerator_element_index + 1;
+
+    while (_Used != 0 && _Numerator._Mydata[_Used - 1] == 0) {
+        --_Used;
+    }
+
+    _Numerator._Myused = _Used;
+
+    return _Quotient;
+}
+
+// ^^^^^^^^^^ DERIVED FROM corecrt_internal_big_integer.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM corecrt_internal_strtox.h vvvvvvvvvv
+
+// This type is used to hold a partially-parsed string representation of a floating-point number.
+// The number is stored in the following form:
+
+// [sign] 0._Mymantissa * B^_Myexponent
+
+// The _Mymantissa buffer stores the mantissa digits in big-endian, binary-coded decimal form. The _Mymantissa_count
+// stores the number of digits present in the _Mymantissa buffer. The base B is not stored; it must be tracked
+// separately. Note that the base of the mantissa digits may not be the same as B (e.g., for hexadecimal
+// floating-point, the mantissa digits are in base 16 but the exponent is a base 2 exponent).
+
+// We consider up to 768 decimal digits during conversion. In most cases, we require nowhere near this many digits
+// of precision to compute the correctly rounded binary floating-point value for the input string. The worst case is
+// (2 - 3 * 2^-53) * 2^-1022, which has an exact decimal representation of 768 decimal digits after trimming zeroes.
+// This value is exactly between 0x1.ffffffffffffep-1022 and 0x1.fffffffffffffp-1022. For round-to-nearest,
+// ties-to-even behavior, we also need to consider whether there are any nonzero trailing decimal digits.
+
+// NOTE: The mantissa buffer count here must be kept in sync with the precision of the _Big_integer_flt type.
+struct _Floating_point_string {
+    bool _Myis_negative;
+    int32_t _Myexponent;
+    uint32_t _Mymantissa_count;
+    uint8_t _Mymantissa[768];
+};
+
+// Stores a positive or negative zero into the _Result object
+template <class _FloatingType>
+void _Assemble_floating_point_zero(const bool _Is_negative, _FloatingType& _Result) noexcept {
+    using _Floating_traits = _Floating_type_traits<_FloatingType>;
+    using _Uint_type       = typename _Floating_traits::_Uint_type;
+
+    _Uint_type _Sign_component = _Is_negative;
+    _Sign_component <<= _Floating_traits::_Sign_shift;
+
+    _Result = _Bit_cast<_FloatingType>(_Sign_component);
+}
+
+// Stores a positive or negative infinity into the _Result object
+template <class _FloatingType>
+void _Assemble_floating_point_infinity(const bool _Is_negative, _FloatingType& _Result) noexcept {
+    using _Floating_traits = _Floating_type_traits<_FloatingType>;
+    using _Uint_type       = typename _Floating_traits::_Uint_type;
+
+    _Uint_type _Sign_component = _Is_negative;
+    _Sign_component <<= _Floating_traits::_Sign_shift;
+
+    constexpr _Uint_type _Exponent_component = _Floating_traits::_Shifted_exponent_mask;
+
+    _Result = _Bit_cast<_FloatingType>(_Sign_component | _Exponent_component);
+}
+
+// Determines whether a mantissa should be rounded up according to round_to_nearest given [1] the value of the least
+// significant bit of the mantissa, [2] the value of the next bit after the least significant bit (the "round" bit)
+// and [3] whether any trailing bits after the round bit are set.
+
+// The mantissa is treated as an unsigned integer magnitude.
+
+// For this function, "round up" is defined as "increase the magnitude" of the mantissa. (Note that this means that
+// if we need to round a negative value to the next largest representable value, we return false, because the next
+// largest representable value has a smaller magnitude.)
+_NODISCARD inline bool _Should_round_up(
+    const bool _Lsb_bit, const bool _Round_bit, const bool _Has_tail_bits) noexcept {
+    // If there are no insignificant set bits, the value is exactly-representable and should not be rounded.
+    // We could detect this with:
+    // const bool _Is_exactly_representable = !_Round_bit && !_Has_tail_bits;
+    // if (_Is_exactly_representable) { return false; }
+    // However, this is unnecessary given the logic below.
+
+    // If there are insignificant set bits, we need to round according to round_to_nearest.
+    // We need to handle two cases: we round up if either [1] the value is slightly greater
+    // than the midpoint between two exactly-representable values or [2] the value is exactly the midpoint
+    // between two exactly-representable values and the greater of the two is even (this is "round-to-even").
+    return _Round_bit && (_Has_tail_bits || _Lsb_bit);
+}
+
+// Computes _Value / 2^_Shift, then rounds the result according to round_to_nearest.
+// By the time we call this function, we will already have discarded most digits.
+// The caller must pass true for _Has_zero_tail if all discarded bits were zeroes.
+_NODISCARD inline uint64_t _Right_shift_with_rounding(
+    const uint64_t _Value, const uint32_t _Shift, const bool _Has_zero_tail) noexcept {
+    constexpr uint32_t _Total_number_of_bits = 64;
+    if (_Shift >= _Total_number_of_bits) {
+        if (_Shift == _Total_number_of_bits) {
+            constexpr uint64_t _Extra_bits_mask = (1ULL << (_Total_number_of_bits - 1)) - 1;
+            constexpr uint64_t _Round_bit_mask  = (1ULL << (_Total_number_of_bits - 1));
+
+            const bool _Round_bit = (_Value & _Round_bit_mask) != 0;
+            const bool _Tail_bits = !_Has_zero_tail || (_Value & _Extra_bits_mask) != 0;
+
+            // We round up the answer to 1 if the answer is greater than 0.5. Otherwise, we round down the answer to 0
+            // if either [1] the answer is less than 0.5 or [2] the answer is exactly 0.5.
+            return static_cast<uint64_t>(_Round_bit && _Tail_bits);
+        } else {
+            // If we'd need to shift 65 or more bits, the answer is less than 0.5 and is always rounded to zero:
+            return 0;
+        }
+    }
+
+    // Reference implementation with suboptimal codegen:
+    // const uint64_t _Extra_bits_mask = (1ULL << (_Shift - 1)) - 1;
+    // const uint64_t _Round_bit_mask  = (1ULL << (_Shift - 1));
+    // const uint64_t _Lsb_bit_mask    = 1ULL << _Shift;
+
+    // const bool _Lsb_bit   = (_Value & _Lsb_bit_mask) != 0;
+    // const bool _Round_bit = (_Value & _Round_bit_mask) != 0;
+    // const bool _Tail_bits = !_Has_zero_tail || (_Value & _Extra_bits_mask) != 0;
+
+    // return (_Value >> _Shift) + _Should_round_up(_Lsb_bit, _Round_bit, _Tail_bits);
+
+    // Example for optimized implementation: Let _Shift be 8.
+    // Bit index: ...[8]76543210
+    //    _Value: ...[L]RTTTTTTT
+    // By focusing on the bit at index _Shift, we can avoid unnecessary branching and shifting.
+
+    // Bit index: ...[8]76543210
+    //  _Lsb_bit: ...[L]RTTTTTTT
+    const uint64_t _Lsb_bit = _Value;
+
+    //  Bit index: ...9[8]76543210
+    // _Round_bit: ...L[R]TTTTTTT0
+    const uint64_t _Round_bit = _Value << 1;
+
+    // We can detect (without branching) whether any of the trailing bits are set.
+    // Due to _Should_round below, this computation will be used if and only if R is 1, so we can assume that here.
+    //      Bit index: ...9[8]76543210
+    //     _Round_bit: ...L[1]TTTTTTT0
+    // _Has_tail_bits: ....[H]........
+
+    // If all of the trailing bits T are 0, and _Has_zero_tail is true,
+    // then `_Round_bit - static_cast<uint64_t>(_Has_zero_tail)` will produce 0 for H (due to R being 1).
+    // If any of the trailing bits T are 1, or _Has_zero_tail is false,
+    // then `_Round_bit - static_cast<uint64_t>(_Has_zero_tail)` will produce 1 for H (due to R being 1).
+    const uint64_t _Has_tail_bits = _Round_bit - static_cast<uint64_t>(_Has_zero_tail);
+
+    // Finally, we can use _Should_round_up() logic with bitwise-AND and bitwise-OR,
+    // selecting just the bit at index _Shift.
+    const uint64_t _Should_round = ((_Round_bit & (_Has_tail_bits | _Lsb_bit)) >> _Shift) & uint64_t{1};
+
+    // This rounding technique is dedicated to the memory of Peppermint. =^..^=
+    return (_Value >> _Shift) + _Should_round;
+}
+
+// Converts the floating-point value [sign] (mantissa / 2^(precision-1)) * 2^exponent into the correct form for
+// _FloatingType and stores the result into the _Result object.
+// The caller must ensure that the mantissa and exponent are correctly computed such that either:
+// [1] min_exponent <= exponent <= max_exponent && 2^(precision-1) <= mantissa <= 2^precision, or
+// [2] exponent == min_exponent && 0 < mantissa <= 2^(precision-1).
+// (The caller should round the mantissa before calling this function. The caller doesn't need to renormalize the
+// mantissa when the mantissa carries over to a higher bit after rounding up.)
+
+// This function correctly handles overflow and stores an infinity in the _Result object.
+// (The result overflows if and only if exponent == max_exponent && mantissa == 2^precision)
+template <class _FloatingType>
+void _Assemble_floating_point_value_no_shift(const bool _Is_negative, const int32_t _Exponent,
+    const typename _Floating_type_traits<_FloatingType>::_Uint_type _Mantissa, _FloatingType& _Result) noexcept {
+    // The following code assembles floating-point values based on an alternative interpretation of the IEEE 754 binary
+    // floating-point format. It is valid for all of the following cases:
+    // [1] normal value,
+    // [2] normal value, needs renormalization and exponent increment after rounding up the mantissa,
+    // [3] normal value, overflows after rounding up the mantissa,
+    // [4] subnormal value,
+    // [5] subnormal value, becomes a normal value after rounding up the mantissa.
+
+    // Examples for float:
+    // | Case |     Input     | Exponent |  Exponent  |  Exponent  |  Rounded  | Result Bits |     Result      |
+    // |      |               |          | + Bias - 1 |  Component |  Mantissa |             |                 |
+    // | ---- | ------------- | -------- | ---------- | ---------- | --------- | ----------- | --------------- |
+    // | [1]  | 1.000000p+0   |     +0   |    126     | 0x3f000000 |  0x800000 | 0x3f800000  | 0x1.000000p+0   |
+    // | [2]  | 1.ffffffp+0   |     +0   |    126     | 0x3f000000 | 0x1000000 | 0x40000000  | 0x1.000000p+1   |
+    // | [3]  | 1.ffffffp+127 |   +127   |    253     | 0x7e800000 | 0x1000000 | 0x7f800000  |     inf         |
+    // | [4]  | 0.fffffep-126 |   -126   |      0     | 0x00000000 |  0x7fffff | 0x007fffff  | 0x0.fffffep-126 |
+    // | [5]  | 0.ffffffp-126 |   -126   |      0     | 0x00000000 |  0x800000 | 0x00800000  | 0x1.000000p-126 |
+    using _Floating_traits = _Floating_type_traits<_FloatingType>;
+    using _Uint_type       = typename _Floating_traits::_Uint_type;
+
+    _Uint_type _Sign_component = _Is_negative;
+    _Sign_component <<= _Floating_traits::_Sign_shift;
+
+    _Uint_type _Exponent_component = static_cast<uint32_t>(_Exponent + (_Floating_traits::_Exponent_bias - 1));
+    _Exponent_component <<= _Floating_traits::_Exponent_shift;
+
+    _Result = _Bit_cast<_FloatingType>(_Sign_component | (_Exponent_component + _Mantissa));
+}
+
+// Converts the floating-point value [sign] (mantissa / 2^(precision-1)) * 2^exponent into the correct form for
+// _FloatingType and stores the result into the _Result object. The caller must ensure that the mantissa and exponent
+// are correctly computed such that either [1] the most significant bit of the mantissa is in the correct position for
+// the _FloatingType, or [2] the exponent has been correctly adjusted to account for the shift of the mantissa that will
+// be required.
+
+// This function correctly handles range errors and stores a zero or infinity in the _Result object
+// on underflow and overflow errors, respectively. This function correctly forms denormal numbers when required.
+
+// If the provided mantissa has more bits of precision than can be stored in the _Result object, the mantissa is
+// rounded to the available precision. Thus, if possible, the caller should provide a mantissa with at least one
+// more bit of precision than is required, to ensure that the mantissa is correctly rounded.
+// (The caller should not round the mantissa before calling this function.)
+template <class _FloatingType>
+_NODISCARD errc _Assemble_floating_point_value(const uint64_t _Initial_mantissa, const int32_t _Initial_exponent,
+    const bool _Is_negative, const bool _Has_zero_tail, _FloatingType& _Result) noexcept {
+    using _Traits = _Floating_type_traits<_FloatingType>;
+
+    // Assume that the number is representable as a normal value.
+    // Compute the number of bits by which we must adjust the mantissa to shift it into the correct position,
+    // and compute the resulting base two exponent for the normalized mantissa:
+    const uint32_t _Initial_mantissa_bits = _Bit_scan_reverse(_Initial_mantissa);
+    const int32_t _Normal_mantissa_shift  = static_cast<int32_t>(_Traits::_Mantissa_bits - _Initial_mantissa_bits);
+    const int32_t _Normal_exponent        = _Initial_exponent - _Normal_mantissa_shift;
+
+    if (_Normal_exponent > _Traits::_Maximum_binary_exponent) {
+        // The exponent is too large to be represented by the floating-point type; report the overflow condition:
+        _Assemble_floating_point_infinity(_Is_negative, _Result);
+        return errc::result_out_of_range; // Overflow example: "1e+1000"
+    }
+
+    uint64_t _Mantissa = _Initial_mantissa;
+    int32_t _Exponent  = _Normal_exponent;
+    errc _Error_code{};
+
+    if (_Normal_exponent < _Traits::_Minimum_binary_exponent) {
+        // The exponent is too small to be represented by the floating-point type as a normal value, but it may be
+        // representable as a denormal value.
+
+        // The exponent of subnormal values (as defined by the mathematical model of floating-point numbers, not the
+        // exponent field in the bit representation) is equal to the minimum exponent of normal values.
+        _Exponent = _Traits::_Minimum_binary_exponent;
+
+        // Compute the number of bits by which we need to shift the mantissa in order to form a denormal number.
+        const int32_t _Denormal_mantissa_shift = _Initial_exponent - _Exponent;
+
+        if (_Denormal_mantissa_shift < 0) {
+            _Mantissa =
+                _Right_shift_with_rounding(_Mantissa, static_cast<uint32_t>(-_Denormal_mantissa_shift), _Has_zero_tail);
+
+            // from_chars in MSVC STL and strto[f|d|ld] in UCRT reports underflow only when the result is zero after
+            // rounding to the floating-point format. This behavior is different from IEEE 754 underflow exception.
+            if (_Mantissa == 0) {
+                _Error_code = errc::result_out_of_range; // Underflow example: "1e-1000"
+            }
+
+            // When we round the mantissa, the result may be so large that the number becomes a normal value.
+            // For example, consider the single-precision case where the mantissa is 0x01ffffff and a right shift
+            // of 2 is required to shift the value into position. We perform the shift in two steps: we shift by
+            // one bit, then we shift again and round using the dropped bit. The initial shift yields 0x00ffffff.
+            // The rounding shift then yields 0x007fffff and because the least significant bit was 1, we add 1
+            // to this number to round it. The final result is 0x00800000.
+
+            // 0x00800000 is 24 bits, which is more than the 23 bits available in the mantissa.
+            // Thus, we have rounded our denormal number into a normal number.
+
+            // We detect this case here and re-adjust the mantissa and exponent appropriately, to form a normal number.
+            // This is handled by _Assemble_floating_point_value_no_shift.
+        } else {
+            _Mantissa <<= _Denormal_mantissa_shift;
+        }
+    } else {
+        if (_Normal_mantissa_shift < 0) {
+            _Mantissa =
+                _Right_shift_with_rounding(_Mantissa, static_cast<uint32_t>(-_Normal_mantissa_shift), _Has_zero_tail);
+
+            // When we round the mantissa, it may produce a result that is too large. In this case,
+            // we divide the mantissa by two and increment the exponent (this does not change the value).
+            // This is handled by _Assemble_floating_point_value_no_shift.
+
+            // The increment of the exponent may have generated a value too large to be represented.
+            // In this case, report the overflow:
+            if (_Mantissa > _Traits::_Normal_mantissa_mask && _Exponent == _Traits::_Maximum_binary_exponent) {
+                _Error_code = errc::result_out_of_range; // Overflow example: "1.ffffffp+127" for float
+                                                         // Overflow example: "1.fffffffffffff8p+1023" for double
+            }
+        } else {
+            _Mantissa <<= _Normal_mantissa_shift;
+        }
+    }
+
+    // Assemble the floating-point value from the computed components:
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    _Assemble_floating_point_value_no_shift(_Is_negative, _Exponent, static_cast<_Uint_type>(_Mantissa), _Result);
+
+    return _Error_code;
+}
+
+// This function is part of the fast track for integer floating-point strings. It takes an integer and a sign and
+// converts the value into its _FloatingType representation, storing the result in the _Result object. If the value
+// is not representable, +/-infinity is stored and overflow is reported (since this function deals with only integers,
+// underflow is impossible).
+template <class _FloatingType>
+_NODISCARD errc _Assemble_floating_point_value_from_big_integer_flt(const _Big_integer_flt& _Integer_value,
+    const uint32_t _Integer_bits_of_precision, const bool _Is_negative, const bool _Has_nonzero_fractional_part,
+    _FloatingType& _Result) noexcept {
+    using _Traits = _Floating_type_traits<_FloatingType>;
+
+    constexpr int32_t _Base_exponent = _Traits::_Mantissa_bits - 1;
+
+    // Very fast case: If we have 64 bits of precision or fewer,
+    // we can just take the two low order elements from the _Big_integer_flt:
+    if (_Integer_bits_of_precision <= 64) {
+        constexpr int32_t _Exponent = _Base_exponent;
+
+        const uint32_t _Mantissa_low  = _Integer_value._Myused > 0 ? _Integer_value._Mydata[0] : 0;
+        const uint32_t _Mantissa_high = _Integer_value._Myused > 1 ? _Integer_value._Mydata[1] : 0;
+        const uint64_t _Mantissa      = _Mantissa_low + (static_cast<uint64_t>(_Mantissa_high) << 32);
+
+        return _Assemble_floating_point_value(
+            _Mantissa, _Exponent, _Is_negative, !_Has_nonzero_fractional_part, _Result);
+    }
+
+    const uint32_t _Top_element_bits  = _Integer_bits_of_precision % 32;
+    const uint32_t _Top_element_index = _Integer_bits_of_precision / 32;
+
+    const uint32_t _Middle_element_index = _Top_element_index - 1;
+    const uint32_t _Bottom_element_index = _Top_element_index - 2;
+
+    // Pretty fast case: If the top 64 bits occupy only two elements, we can just combine those two elements:
+    if (_Top_element_bits == 0) {
+        const int32_t _Exponent = static_cast<int32_t>(_Base_exponent + _Bottom_element_index * 32);
+
+        const uint64_t _Mantissa = _Integer_value._Mydata[_Bottom_element_index]
+                                 + (static_cast<uint64_t>(_Integer_value._Mydata[_Middle_element_index]) << 32);
+
+        bool _Has_zero_tail = !_Has_nonzero_fractional_part;
+        for (uint32_t _Ix = 0; _Has_zero_tail && _Ix != _Bottom_element_index; ++_Ix) {
+            _Has_zero_tail = _Integer_value._Mydata[_Ix] == 0;
+        }
+
+        return _Assemble_floating_point_value(_Mantissa, _Exponent, _Is_negative, _Has_zero_tail, _Result);
+    }
+
+    // Not quite so fast case: The top 64 bits span three elements in the _Big_integer_flt. Assemble the three pieces:
+    const uint32_t _Top_element_mask  = (1u << _Top_element_bits) - 1;
+    const uint32_t _Top_element_shift = 64 - _Top_element_bits; // Left
+
+    const uint32_t _Middle_element_shift = _Top_element_shift - 32; // Left
+
+    const uint32_t _Bottom_element_bits  = 32 - _Top_element_bits;
+    const uint32_t _Bottom_element_mask  = ~_Top_element_mask;
+    const uint32_t _Bottom_element_shift = 32 - _Bottom_element_bits; // Right
+
+    const int32_t _Exponent = static_cast<int32_t>(_Base_exponent + _Bottom_element_index * 32 + _Top_element_bits);
+
+    const uint64_t _Mantissa =
+        (static_cast<uint64_t>(_Integer_value._Mydata[_Top_element_index] & _Top_element_mask) << _Top_element_shift)
+        + (static_cast<uint64_t>(_Integer_value._Mydata[_Middle_element_index]) << _Middle_element_shift)
+        + (static_cast<uint64_t>(_Integer_value._Mydata[_Bottom_element_index] & _Bottom_element_mask)
+            >> _Bottom_element_shift);
+
+    bool _Has_zero_tail =
+        !_Has_nonzero_fractional_part && (_Integer_value._Mydata[_Bottom_element_index] & _Top_element_mask) == 0;
+
+    for (uint32_t _Ix = 0; _Has_zero_tail && _Ix != _Bottom_element_index; ++_Ix) {
+        _Has_zero_tail = _Integer_value._Mydata[_Ix] == 0;
+    }
+
+    return _Assemble_floating_point_value(_Mantissa, _Exponent, _Is_negative, _Has_zero_tail, _Result);
+}
+
+// Accumulates the decimal digits in [_First_digit, _Last_digit) into the _Result high-precision integer.
+// This function assumes that no overflow will occur.
+inline void _Accumulate_decimal_digits_into_big_integer_flt(
+    const uint8_t* const _First_digit, const uint8_t* const _Last_digit, _Big_integer_flt& _Result) noexcept {
+    // We accumulate nine digit chunks, transforming the base ten string into base one billion on the fly,
+    // allowing us to reduce the number of high-precision multiplication and addition operations by 8/9.
+    uint32_t _Accumulator       = 0;
+    uint32_t _Accumulator_count = 0;
+    for (const uint8_t* _It = _First_digit; _It != _Last_digit; ++_It) {
+        if (_Accumulator_count == 9) {
+            [[maybe_unused]] const bool _Success1 = _Multiply(_Result, 1'000'000'000); // assumes no overflow
+            _STL_INTERNAL_CHECK(_Success1);
+            [[maybe_unused]] const bool _Success2 = _Add(_Result, _Accumulator); // assumes no overflow
+            _STL_INTERNAL_CHECK(_Success2);
+
+            _Accumulator       = 0;
+            _Accumulator_count = 0;
+        }
+
+        _Accumulator *= 10;
+        _Accumulator += *_It;
+        ++_Accumulator_count;
+    }
+
+    if (_Accumulator_count != 0) {
+        [[maybe_unused]] const bool _Success3 =
+            _Multiply_by_power_of_ten(_Result, _Accumulator_count); // assumes no overflow
+        _STL_INTERNAL_CHECK(_Success3);
+        [[maybe_unused]] const bool _Success4 = _Add(_Result, _Accumulator); // assumes no overflow
+        _STL_INTERNAL_CHECK(_Success4);
+    }
+}
+
+// The core floating-point string parser for decimal strings. After a subject string is parsed and converted
+// into a _Floating_point_string object, if the subject string was determined to be a decimal string,
+// the object is passed to this function. This function converts the decimal real value to floating-point.
+template <class _FloatingType>
+_NODISCARD errc _Convert_decimal_string_to_floating_type(
+    const _Floating_point_string& _Data, _FloatingType& _Result, bool _Has_zero_tail) noexcept {
+    using _Traits = _Floating_type_traits<_FloatingType>;
+
+    // To generate an N bit mantissa we require N + 1 bits of precision. The extra bit is used to correctly round
+    // the mantissa (if there are fewer bits than this available, then that's totally okay;
+    // in that case we use what we have and we don't need to round).
+    constexpr uint32_t _Required_bits_of_precision = static_cast<uint32_t>(_Traits::_Mantissa_bits + 1);
+
+    // The input is of the form 0.mantissa * 10^exponent, where 'mantissa' are the decimal digits of the mantissa
+    // and 'exponent' is the decimal exponent. We decompose the mantissa into two parts: an integer part and a
+    // fractional part. If the exponent is positive, then the integer part consists of the first 'exponent' digits,
+    // or all present digits if there are fewer digits. If the exponent is zero or negative, then the integer part
+    // is empty. In either case, the remaining digits form the fractional part of the mantissa.
+    const uint32_t _Positive_exponent      = static_cast<uint32_t>((_STD max) (0, _Data._Myexponent));
+    const uint32_t _Integer_digits_present = (_STD min) (_Positive_exponent, _Data._Mymantissa_count);
+    const uint32_t _Integer_digits_missing = _Positive_exponent - _Integer_digits_present;
+    const uint8_t* const _Integer_first    = _Data._Mymantissa;
+    const uint8_t* const _Integer_last     = _Data._Mymantissa + _Integer_digits_present;
+
+    const uint8_t* const _Fractional_first    = _Integer_last;
+    const uint8_t* const _Fractional_last     = _Data._Mymantissa + _Data._Mymantissa_count;
+    const uint32_t _Fractional_digits_present = static_cast<uint32_t>(_Fractional_last - _Fractional_first);
+
+    // First, we accumulate the integer part of the mantissa into a _Big_integer_flt:
+    _Big_integer_flt _Integer_value{};
+    _Accumulate_decimal_digits_into_big_integer_flt(_Integer_first, _Integer_last, _Integer_value);
+
+    if (_Integer_digits_missing > 0) {
+        if (!_Multiply_by_power_of_ten(_Integer_value, _Integer_digits_missing)) {
+            _Assemble_floating_point_infinity(_Data._Myis_negative, _Result);
+            return errc::result_out_of_range; // Overflow example: "1e+2000"
+        }
+    }
+
+    // At this point, the _Integer_value contains the value of the integer part of the mantissa. If either
+    // [1] this number has more than the required number of bits of precision or
+    // [2] the mantissa has no fractional part, then we can assemble the result immediately:
+    const uint32_t _Integer_bits_of_precision = _Bit_scan_reverse(_Integer_value);
+    {
+        const bool _Has_zero_fractional_part = _Fractional_digits_present == 0 && _Has_zero_tail;
+
+        if (_Integer_bits_of_precision >= _Required_bits_of_precision || _Has_zero_fractional_part) {
+            return _Assemble_floating_point_value_from_big_integer_flt(
+                _Integer_value, _Integer_bits_of_precision, _Data._Myis_negative, !_Has_zero_fractional_part, _Result);
+        }
+    }
+
+    // Otherwise, we did not get enough bits of precision from the integer part, and the mantissa has a fractional
+    // part. We parse the fractional part of the mantissa to obtain more bits of precision. To do this, we convert
+    // the fractional part into an actual fraction N/M, where the numerator N is computed from the digits of the
+    // fractional part, and the denominator M is computed as the power of 10 such that N/M is equal to the value
+    // of the fractional part of the mantissa.
+    _Big_integer_flt _Fractional_numerator{};
+    _Accumulate_decimal_digits_into_big_integer_flt(_Fractional_first, _Fractional_last, _Fractional_numerator);
+
+    const uint32_t _Fractional_denominator_exponent =
+        _Data._Myexponent < 0 ? _Fractional_digits_present + static_cast<uint32_t>(-_Data._Myexponent)
+                              : _Fractional_digits_present;
+
+    _Big_integer_flt _Fractional_denominator = _Make_big_integer_flt_one();
+    if (!_Multiply_by_power_of_ten(_Fractional_denominator, _Fractional_denominator_exponent)) {
+        // If there were any digits in the integer part, it is impossible to underflow (because the exponent
+        // cannot possibly be small enough), so if we underflow here it is a true underflow and we return zero.
+        _Assemble_floating_point_zero(_Data._Myis_negative, _Result);
+        return errc::result_out_of_range; // Underflow example: "1e-2000"
+    }
+
+    // Because we are using only the fractional part of the mantissa here, the numerator is guaranteed to be smaller
+    // than the denominator. We normalize the fraction such that the most significant bit of the numerator is in the
+    // same position as the most significant bit in the denominator. This ensures that when we later shift the
+    // numerator N bits to the left, we will produce N bits of precision.
+    const uint32_t _Fractional_numerator_bits   = _Bit_scan_reverse(_Fractional_numerator);
+    const uint32_t _Fractional_denominator_bits = _Bit_scan_reverse(_Fractional_denominator);
+
+    const uint32_t _Fractional_shift = _Fractional_denominator_bits > _Fractional_numerator_bits
+                                         ? _Fractional_denominator_bits - _Fractional_numerator_bits
+                                         : 0;
+
+    if (_Fractional_shift > 0) {
+        [[maybe_unused]] const bool _Shift_success1 =
+            _Shift_left(_Fractional_numerator, _Fractional_shift); // assumes no overflow
+        _STL_INTERNAL_CHECK(_Shift_success1);
+    }
+
+    const uint32_t _Required_fractional_bits_of_precision = _Required_bits_of_precision - _Integer_bits_of_precision;
+
+    uint32_t _Remaining_bits_of_precision_required = _Required_fractional_bits_of_precision;
+    if (_Integer_bits_of_precision > 0) {
+        // If the fractional part of the mantissa provides no bits of precision and cannot affect rounding,
+        // we can just take whatever bits we got from the integer part of the mantissa. This is the case for numbers
+        // like 5.0000000000000000000001, where the significant digits of the fractional part start so far to the
+        // right that they do not affect the floating-point representation.
+
+        // If the fractional shift is exactly equal to the number of bits of precision that we require,
+        // then no fractional bits will be part of the result, but the result may affect rounding.
+        // This is e.g. the case for large, odd integers with a fractional part greater than or equal to .5.
+        // Thus, we need to do the division to correctly round the result.
+        if (_Fractional_shift > _Remaining_bits_of_precision_required) {
+            return _Assemble_floating_point_value_from_big_integer_flt(_Integer_value, _Integer_bits_of_precision,
+                _Data._Myis_negative, _Fractional_digits_present != 0 || !_Has_zero_tail, _Result);
+        }
+
+        _Remaining_bits_of_precision_required -= _Fractional_shift;
+    }
+
+    // If there was no integer part of the mantissa, we will need to compute the exponent from the fractional part.
+    // The fractional exponent is the power of two by which we must multiply the fractional part to move it into the
+    // range [1.0, 2.0). This will either be the same as the shift we computed earlier, or one greater than that shift:
+    const uint32_t _Fractional_exponent =
+        _Fractional_numerator < _Fractional_denominator ? _Fractional_shift + 1 : _Fractional_shift;
+
+    [[maybe_unused]] const bool _Shift_success2 =
+        _Shift_left(_Fractional_numerator, _Remaining_bits_of_precision_required); // assumes no overflow
+    _STL_INTERNAL_CHECK(_Shift_success2);
+
+    uint64_t _Fractional_mantissa = _Divide(_Fractional_numerator, _Fractional_denominator);
+
+    _Has_zero_tail = _Has_zero_tail && _Fractional_numerator._Myused == 0;
+
+    // We may have produced more bits of precision than were required. Check, and remove any "extra" bits:
+    const uint32_t _Fractional_mantissa_bits = _Bit_scan_reverse(_Fractional_mantissa);
+    if (_Fractional_mantissa_bits > _Required_fractional_bits_of_precision) {
+        const uint32_t _Shift = _Fractional_mantissa_bits - _Required_fractional_bits_of_precision;
+        _Has_zero_tail        = _Has_zero_tail && (_Fractional_mantissa & ((1ULL << _Shift) - 1)) == 0;
+        _Fractional_mantissa >>= _Shift;
+    }
+
+    // Compose the mantissa from the integer and fractional parts:
+    const uint32_t _Integer_mantissa_low  = _Integer_value._Myused > 0 ? _Integer_value._Mydata[0] : 0;
+    const uint32_t _Integer_mantissa_high = _Integer_value._Myused > 1 ? _Integer_value._Mydata[1] : 0;
+    const uint64_t _Integer_mantissa = _Integer_mantissa_low + (static_cast<uint64_t>(_Integer_mantissa_high) << 32);
+
+    const uint64_t _Complete_mantissa =
+        (_Integer_mantissa << _Required_fractional_bits_of_precision) + _Fractional_mantissa;
+
+    // Compute the final exponent:
+    // * If the mantissa had an integer part, then the exponent is one less than the number of bits we obtained
+    // from the integer part. (It's one less because we are converting to the form 1.11111,
+    // with one 1 to the left of the decimal point.)
+    // * If the mantissa had no integer part, then the exponent is the fractional exponent that we computed.
+    // Then, in both cases, we subtract an additional one from the exponent,
+    // to account for the fact that we've generated an extra bit of precision, for use in rounding.
+    const int32_t _Final_exponent = _Integer_bits_of_precision > 0
+                                      ? static_cast<int32_t>(_Integer_bits_of_precision - 2)
+                                      : -static_cast<int32_t>(_Fractional_exponent) - 1;
+
+    return _Assemble_floating_point_value(
+        _Complete_mantissa, _Final_exponent, _Data._Myis_negative, _Has_zero_tail, _Result);
+}
+
+template <class _FloatingType>
+_NODISCARD errc _Convert_hexadecimal_string_to_floating_type(
+    const _Floating_point_string& _Data, _FloatingType& _Result, bool _Has_zero_tail) noexcept {
+    using _Traits = _Floating_type_traits<_FloatingType>;
+
+    uint64_t _Mantissa = 0;
+    int32_t _Exponent  = _Data._Myexponent + _Traits::_Mantissa_bits - 1;
+
+    // Accumulate bits into the mantissa buffer
+    const uint8_t* const _Mantissa_last = _Data._Mymantissa + _Data._Mymantissa_count;
+    const uint8_t* _Mantissa_it         = _Data._Mymantissa;
+    while (_Mantissa_it != _Mantissa_last && _Mantissa <= _Traits::_Normal_mantissa_mask) {
+        _Mantissa *= 16;
+        _Mantissa += *_Mantissa_it++;
+        _Exponent -= 4; // The exponent is in binary; log2(16) == 4
+    }
+
+    while (_Has_zero_tail && _Mantissa_it != _Mantissa_last) {
+        _Has_zero_tail = *_Mantissa_it++ == 0;
+    }
+
+    return _Assemble_floating_point_value(_Mantissa, _Exponent, _Data._Myis_negative, _Has_zero_tail, _Result);
+}
+
+// ^^^^^^^^^^ DERIVED FROM corecrt_internal_strtox.h ^^^^^^^^^^
+
+// C11 6.4.2.1 "General"
+// digit: one of
+//     0 1 2 3 4 5 6 7 8 9
+
+// C11 6.4.4.1 "Integer constants"
+// hexadecimal-digit: one of
+//     0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F
+
+// C11 6.4.4.2 "Floating constants" (without floating-suffix, hexadecimal-prefix)
+// amended by C11 7.22.1.3 "The strtod, strtof, and strtold functions" making exponents optional
+// LWG-3080: "the sign '+' may only appear in the exponent part"
+
+// digit-sequence:
+//     digit
+//     digit-sequence digit
+
+// hexadecimal-digit-sequence:
+//     hexadecimal-digit
+//     hexadecimal-digit-sequence hexadecimal-digit
+
+// sign: one of
+//     + -
+
+// decimal-floating-constant:
+//     fractional-constant exponent-part[opt]
+//     digit-sequence exponent-part[opt]
+
+// fractional-constant:
+//     digit-sequence[opt] . digit-sequence
+//     digit-sequence .
+
+// exponent-part:
+//     e sign[opt] digit-sequence
+//     E sign[opt] digit-sequence
+
+// hexadecimal-floating-constant:
+//     hexadecimal-fractional-constant binary-exponent-part[opt]
+//     hexadecimal-digit-sequence binary-exponent-part[opt]
+
+// hexadecimal-fractional-constant:
+//     hexadecimal-digit-sequence[opt] . hexadecimal-digit-sequence
+//     hexadecimal-digit-sequence .
+
+// binary-exponent-part:
+//     p sign[opt] digit-sequence
+//     P sign[opt] digit-sequence
+
+template <class _Floating>
+_NODISCARD from_chars_result _Ordinary_floating_from_chars(const char* const _First, const char* const _Last,
+    _Floating& _Value, const chars_format _Fmt, const bool _Minus_sign, const char* _Next) noexcept {
+    // vvvvvvvvvv DERIVED FROM corecrt_internal_strtox.h WITH SIGNIFICANT MODIFICATIONS vvvvvvvvvv
+
+    const bool _Is_hexadecimal = _Fmt == chars_format::hex;
+    const int _Base{_Is_hexadecimal ? 16 : 10};
+
+    // PERFORMANCE NOTE: _Fp_string is intentionally left uninitialized. Zero-initialization is quite expensive
+    // and is unnecessary. The benefit of not zero-initializing is greatest for short inputs.
+    _Floating_point_string _Fp_string;
+
+    // Record the optional minus sign:
+    _Fp_string._Myis_negative = _Minus_sign;
+
+    uint8_t* const _Mantissa_first = _Fp_string._Mymantissa;
+    uint8_t* const _Mantissa_last  = _STD end(_Fp_string._Mymantissa);
+    uint8_t* _Mantissa_it          = _Mantissa_first;
+
+    // [_Whole_begin, _Whole_end) will contain 0 or more digits/hexits
+    const char* const _Whole_begin = _Next;
+
+    // Skip past any leading zeroes in the mantissa:
+    for (; _Next != _Last && *_Next == '0'; ++_Next) {
+    }
+    const char* const _Leading_zero_end = _Next;
+
+    bool _Has_zero_tail = true;
+
+    // Scan the integer part of the mantissa:
+    for (; _Next != _Last; ++_Next) {
+        const unsigned char _Digit_value = _Digit_from_char(*_Next);
+
+        if (_Digit_value >= _Base) {
+            break;
+        }
+
+        if (_Mantissa_it != _Mantissa_last) {
+            *_Mantissa_it++ = _Digit_value;
+        } else {
+            _Has_zero_tail = _Has_zero_tail && _Digit_value == 0;
+        }
+    }
+    const char* const _Whole_end = _Next;
+
+    // The exponent adjustment holds the number of digits in the mantissa buffer that appeared before the radix point.
+    // It can be negative, and leading zeroes in the integer part are ignored. Examples:
+    // For "03333.111", it is 4.
+    // For "00000.111", it is 0.
+    // For "00000.001", it is -2.
+    ptrdiff_t _Exponent_adjustment = _Whole_end - _Leading_zero_end;
+
+    // [_Whole_end, _Dot_end) will contain 0 or 1 '.' characters
+    if (_Next != _Last && *_Next == '.') {
+        ++_Next;
+    }
+    const char* const _Dot_end = _Next;
+
+    // [_Dot_end, _Frac_end) will contain 0 or more digits/hexits
+
+    // If we haven't yet scanned any nonzero digits, continue skipping over zeroes,
+    // updating the exponent adjustment to account for the zeroes we are skipping:
+    if (_Exponent_adjustment == 0) {
+        for (; _Next != _Last && *_Next == '0'; ++_Next) {
+        }
+
+        _Exponent_adjustment = _Dot_end - _Next;
+    }
+
+    // Scan the fractional part of the mantissa:
+    for (; _Next != _Last; ++_Next) {
+        const unsigned char _Digit_value = _Digit_from_char(*_Next);
+
+        if (_Digit_value >= _Base) {
+            break;
+        }
+
+        if (_Mantissa_it != _Mantissa_last) {
+            *_Mantissa_it++ = _Digit_value;
+        } else {
+            _Has_zero_tail = _Has_zero_tail && _Digit_value == 0;
+        }
+    }
+    const char* const _Frac_end = _Next;
+
+    // We must have at least 1 digit/hexit
+    if (_Whole_begin == _Whole_end && _Dot_end == _Frac_end) {
+        return {_First, errc::invalid_argument};
+    }
+
+    const char _Exponent_prefix{_Is_hexadecimal ? 'p' : 'e'};
+
+    bool _Exponent_is_negative = false;
+    bool _Exp_abs_too_large    = false;
+    ptrdiff_t _Exponent        = 0;
+
+    constexpr int _Maximum_temporary_decimal_exponent = 5200;
+    constexpr int _Minimum_temporary_decimal_exponent = -5200;
+
+    if (_Fmt != chars_format::fixed // N4950 [charconv.from.chars]/6.3
+                                    // "if fmt has chars_format::fixed set but not chars_format::scientific,
+                                    // the optional exponent part shall not appear"
+        && _Next != _Last && (static_cast<unsigned char>(*_Next) | 0x20) == _Exponent_prefix) { // found exponent prefix
+        const char* _Unread = _Next + 1;
+
+        if (_Unread != _Last && (*_Unread == '+' || *_Unread == '-')) { // found optional sign
+            _Exponent_is_negative = *_Unread == '-';
+            ++_Unread;
+        }
+
+        while (_Unread != _Last) {
+            const unsigned char _Digit_value = _Digit_from_char(*_Unread);
+
+            if (_Digit_value >= 10) {
+                break;
+            }
+
+            // found decimal digit
+
+            if (_Exponent < PTRDIFF_MAX / 10 || (_Exponent == PTRDIFF_MAX / 10 && _Digit_value <= PTRDIFF_MAX % 10)) {
+                _Exponent = _Exponent * 10 + _Digit_value;
+            } else {
+                _Exp_abs_too_large = true;
+            }
+
+            ++_Unread;
+            _Next = _Unread; // consume exponent-part/binary-exponent-part
+        }
+
+        if (_Exponent_is_negative) {
+            _Exponent = -_Exponent;
+        }
+    }
+
+    // [_Frac_end, _Exponent_end) will either be empty or contain "[EPep] sign[opt] digit-sequence"
+    const char* const _Exponent_end = _Next;
+
+    if (_Fmt == chars_format::scientific
+        && _Frac_end == _Exponent_end) { // N4950 [charconv.from.chars]/6.2
+                                         // "if fmt has chars_format::scientific set but not chars_format::fixed,
+                                         // the otherwise optional exponent part shall appear"
+        return {_First, errc::invalid_argument};
+    }
+
+    // Remove trailing zeroes from mantissa:
+    while (_Mantissa_it != _Mantissa_first && *(_Mantissa_it - 1) == 0) {
+        --_Mantissa_it;
+    }
+
+    // If the mantissa buffer is empty, the mantissa was composed of all zeroes (so the mantissa is 0).
+    // All such strings have the value zero, regardless of what the exponent is (because 0 * b^n == 0 for all b and n).
+    // We can return now. Note that we defer this check until after we scan the exponent, so that we can correctly
+    // update _Next to point past the end of the exponent.
+    if (_Mantissa_it == _Mantissa_first) {
+        _STL_INTERNAL_CHECK(_Has_zero_tail);
+        _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
+        return {_Next, errc{}};
+    }
+
+    // Handle exponent of an overly large absolute value.
+    if (_Exp_abs_too_large) {
+        if (_Exponent > 0) {
+            _Assemble_floating_point_infinity(_Fp_string._Myis_negative, _Value);
+            return {_Next, errc::result_out_of_range};
+        } else {
+            _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
+            return {_Next, errc::result_out_of_range};
+        }
+    }
+
+    // Adjust _Exponent and _Exponent_adjustment when they have different signedness to avoid overflow.
+    if (_Exponent > 0 && _Exponent_adjustment < 0) {
+        if (_Is_hexadecimal) {
+            const ptrdiff_t _Further_adjustment = (_STD max) (-((_Exponent - 1) / 4 + 1), _Exponent_adjustment);
+            _Exponent += _Further_adjustment * 4;
+            _Exponent_adjustment -= _Further_adjustment;
+        } else {
+            const ptrdiff_t _Further_adjustment = (_STD max) (-_Exponent, _Exponent_adjustment);
+            _Exponent += _Further_adjustment;
+            _Exponent_adjustment -= _Further_adjustment;
+        }
+    } else if (_Exponent < 0 && _Exponent_adjustment > 0) {
+        if (_Is_hexadecimal) {
+            const ptrdiff_t _Further_adjustment = (_STD min) ((-_Exponent - 1) / 4 + 1, _Exponent_adjustment);
+            _Exponent += _Further_adjustment * 4;
+            _Exponent_adjustment -= _Further_adjustment;
+        } else {
+            const ptrdiff_t _Further_adjustment = (_STD min) (-_Exponent, _Exponent_adjustment);
+            _Exponent += _Further_adjustment;
+            _Exponent_adjustment -= _Further_adjustment;
+        }
+    }
+
+    // In hexadecimal floating constants, the exponent is a base 2 exponent. The exponent adjustment computed during
+    // parsing has the same base as the mantissa (so, 16 for hexadecimal floating constants).
+    // We therefore need to scale the base 16 multiplier to base 2 by multiplying by log2(16):
+    const int _Exponent_adjustment_multiplier{_Is_hexadecimal ? 4 : 1};
+
+    // And then _Exponent and _Exponent_adjustment are either both non-negative or both non-positive.
+    // So we can detect out-of-range cases directly.
+    if (_Exponent > _Maximum_temporary_decimal_exponent
+        || _Exponent_adjustment > _Maximum_temporary_decimal_exponent / _Exponent_adjustment_multiplier) {
+        _Assemble_floating_point_infinity(_Fp_string._Myis_negative, _Value);
+        return {_Next, errc::result_out_of_range}; // Overflow example: "1e+9999"
+    }
+
+    if (_Exponent < _Minimum_temporary_decimal_exponent
+        || _Exponent_adjustment < _Minimum_temporary_decimal_exponent / _Exponent_adjustment_multiplier) {
+        _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
+        return {_Next, errc::result_out_of_range}; // Underflow example: "1e-9999"
+    }
+
+    _Exponent += _Exponent_adjustment * _Exponent_adjustment_multiplier;
+
+    // Verify that after adjustment the exponent isn't wildly out of range (if it is, it isn't representable
+    // in any supported floating-point format).
+    if (_Exponent > _Maximum_temporary_decimal_exponent) {
+        _Assemble_floating_point_infinity(_Fp_string._Myis_negative, _Value);
+        return {_Next, errc::result_out_of_range}; // Overflow example: "10e+5199"
+    }
+
+    if (_Exponent < _Minimum_temporary_decimal_exponent) {
+        _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
+        return {_Next, errc::result_out_of_range}; // Underflow example: "0.001e-5199"
+    }
+
+    _Fp_string._Myexponent       = static_cast<int32_t>(_Exponent);
+    _Fp_string._Mymantissa_count = static_cast<uint32_t>(_Mantissa_it - _Mantissa_first);
+
+    if (_Is_hexadecimal) {
+        const errc _Ec = _Convert_hexadecimal_string_to_floating_type(_Fp_string, _Value, _Has_zero_tail);
+        return {_Next, _Ec};
+    } else {
+        const errc _Ec = _Convert_decimal_string_to_floating_type(_Fp_string, _Value, _Has_zero_tail);
+        return {_Next, _Ec};
+    }
+
+    // ^^^^^^^^^^ DERIVED FROM corecrt_internal_strtox.h WITH SIGNIFICANT MODIFICATIONS ^^^^^^^^^^
+}
+
+_NODISCARD inline bool _Starts_with_case_insensitive(
+    const char* _First, const char* const _Last, const char* _Lowercase) noexcept {
+    // pre: _Lowercase contains only ['a', 'z'] and is null-terminated
+    for (; _First != _Last && *_Lowercase != '\0'; ++_First, ++_Lowercase) {
+        if ((static_cast<unsigned char>(*_First) | 0x20) != *_Lowercase) {
+            return false;
+        }
+    }
+
+    return *_Lowercase == '\0';
+}
+
+template <class _Floating>
+_NODISCARD from_chars_result _Infinity_from_chars(const char* const _First, const char* const _Last, _Floating& _Value,
+    const bool _Minus_sign, const char* _Next) noexcept {
+    // pre: _Next points at 'i' (case-insensitively)
+    if (!_Starts_with_case_insensitive(_Next + 1, _Last, "nf")) { // definitely invalid
+        return {_First, errc::invalid_argument};
+    }
+
+    // definitely inf
+    _Next += 3;
+
+    if (_Starts_with_case_insensitive(_Next, _Last, "inity")) { // definitely infinity
+        _Next += 5;
+    }
+
+    _Assemble_floating_point_infinity(_Minus_sign, _Value);
+
+    return {_Next, errc{}};
+}
+
+template <class _Floating>
+_NODISCARD from_chars_result _Nan_from_chars(const char* const _First, const char* const _Last, _Floating& _Value,
+    bool _Minus_sign, const char* _Next) noexcept {
+    // pre: _Next points at 'n' (case-insensitively)
+    if (!_Starts_with_case_insensitive(_Next + 1, _Last, "an")) { // definitely invalid
+        return {_First, errc::invalid_argument};
+    }
+
+    // definitely nan
+    _Next += 3;
+
+    bool _Quiet = true;
+
+    if (_Next != _Last && *_Next == '(') { // possibly nan(n-char-sequence[opt])
+        const char* const _Seq_begin = _Next + 1;
+
+        for (const char* _Temp = _Seq_begin; _Temp != _Last; ++_Temp) {
+            if (*_Temp == ')') { // definitely nan(n-char-sequence[opt])
+                _Next = _Temp + 1;
+
+                if (_Temp - _Seq_begin == 3
+                    && _Starts_with_case_insensitive(_Seq_begin, _Temp, "ind")) { // definitely nan(ind)
+                    // The UCRT considers indeterminate NaN to be negative quiet NaN with no payload bits set.
+                    // It parses "nan(ind)" and "-nan(ind)" identically.
+                    _Minus_sign = true;
+                } else if (_Temp - _Seq_begin == 4
+                           && _Starts_with_case_insensitive(_Seq_begin, _Temp, "snan")) { // definitely nan(snan)
+                    _Quiet = false;
+                }
+
+                break;
+            } else if (*_Temp == '_' || ('0' <= *_Temp && *_Temp <= '9') || ('A' <= *_Temp && *_Temp <= 'Z')
+                       || ('a' <= *_Temp && *_Temp <= 'z')) { // possibly nan(n-char-sequence[opt]), keep going
+            } else { // definitely nan, not nan(n-char-sequence[opt])
+                break;
+            }
+        }
+    }
+
+    // Intentional behavior difference between the UCRT and the STL:
+    // strtod()/strtof() parse plain "nan" as being a quiet NaN with all payload bits set.
+    // numeric_limits::quiet_NaN() returns a quiet NaN with no payload bits set.
+    // This implementation of from_chars() has chosen to be consistent with numeric_limits.
+
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    _Uint_type _Uint_value = _Traits::_Shifted_exponent_mask;
+
+    if (_Minus_sign) {
+        _Uint_value |= _Traits::_Shifted_sign_mask;
+    }
+
+    if (_Quiet) {
+        _Uint_value |= _Traits::_Special_nan_mantissa_mask;
+    } else {
+        _Uint_value |= 1;
+    }
+
+    _Value = _Bit_cast<_Floating>(_Uint_value);
+
+    return {_Next, errc{}};
+}
+
+template <class _Floating>
+_NODISCARD from_chars_result _Floating_from_chars(
+    const char* const _First, const char* const _Last, _Floating& _Value, const chars_format _Fmt) noexcept {
+    _Adl_verify_range(_First, _Last);
+
+    _STL_ASSERT(_Fmt == chars_format::general || _Fmt == chars_format::scientific || _Fmt == chars_format::fixed
+                    || _Fmt == chars_format::hex,
+        "invalid format in from_chars()");
+
+    bool _Minus_sign = false;
+
+    const char* _Next = _First;
+
+    if (_Next == _Last) {
+        return {_First, errc::invalid_argument};
+    }
+
+    if (*_Next == '-') {
+        _Minus_sign = true;
+        ++_Next;
+
+        if (_Next == _Last) {
+            return {_First, errc::invalid_argument};
+        }
+    }
+
+    // Distinguish ordinary numbers versus inf/nan with a single test.
+    // ordinary numbers start with ['.'] ['0', '9'] ['A', 'F'] ['a', 'f']
+    // inf/nan start with ['I'] ['N'] ['i'] ['n']
+    // All other starting characters are invalid.
+    // Setting the 0x20 bit folds these ranges in a useful manner.
+    // ordinary (and some invalid) starting characters are folded to ['.'] ['0', '9'] ['a', 'f']
+    // inf/nan starting characters are folded to ['i'] ['n']
+    // These are ordered: ['.'] ['0', '9'] ['a', 'f'] < ['i'] ['n']
+    // Note that invalid starting characters end up on both sides of this test.
+    const unsigned char _Folded_start = static_cast<unsigned char>(static_cast<unsigned char>(*_Next) | 0x20);
+
+    if (_Folded_start <= 'f') { // possibly an ordinary number
+        return _Ordinary_floating_from_chars(_First, _Last, _Value, _Fmt, _Minus_sign, _Next);
+    } else if (_Folded_start == 'i') { // possibly inf
+        return _Infinity_from_chars(_First, _Last, _Value, _Minus_sign, _Next);
+    } else if (_Folded_start == 'n') { // possibly nan
+        return _Nan_from_chars(_First, _Last, _Value, _Minus_sign, _Next);
+    } else { // definitely invalid
+        return {_First, errc::invalid_argument};
+    }
+}
+
+_EXPORT_STD inline from_chars_result from_chars(const char* const _First, const char* const _Last, float& _Value,
+    const chars_format _Fmt = chars_format::general) noexcept /* strengthened */ {
+    return _Floating_from_chars(_First, _Last, _Value, _Fmt);
+}
+_EXPORT_STD inline from_chars_result from_chars(const char* const _First, const char* const _Last, double& _Value,
+    const chars_format _Fmt = chars_format::general) noexcept /* strengthened */ {
+    return _Floating_from_chars(_First, _Last, _Value, _Fmt);
+}
+_EXPORT_STD inline from_chars_result from_chars(const char* const _First, const char* const _Last, long double& _Value,
+    const chars_format _Fmt = chars_format::general) noexcept /* strengthened */ {
+    double _Dbl; // intentionally default-init
+    const from_chars_result _Result = _Floating_from_chars(_First, _Last, _Dbl, _Fmt);
+
+    if (_Result.ec == errc{}) {
+        _Value = _Dbl;
+    }
+
+    return _Result;
+}
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_hex_precision(
+    char* _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
+
+    // * Determine the effective _Precision.
+    // * Later, we'll decrement _Precision when printing each hexit after the decimal point.
+
+    // The hexits after the decimal point correspond to the explicitly stored fraction bits.
+    // float explicitly stores 23 fraction bits. 23 / 4 == 5.75, which is 6 hexits.
+    // double explicitly stores 52 fraction bits. 52 / 4 == 13, which is 13 hexits.
+    constexpr int _Full_precision         = is_same_v<_Floating, float> ? 6 : 13;
+    constexpr int _Adjusted_explicit_bits = _Full_precision * 4;
+
+    if (_Precision < 0) {
+        // C11 7.21.6.1 "The fprintf function"/5: "A negative precision argument is taken as if the precision were
+        // omitted." /8: "if the precision is missing and FLT_RADIX is a power of 2, then the precision is sufficient
+        // for an exact representation of the value"
+        _Precision = _Full_precision;
+    }
+
+    // * Extract the _Ieee_mantissa and _Ieee_exponent.
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    const _Uint_type _Uint_value    = _Bit_cast<_Uint_type>(_Value);
+    const _Uint_type _Ieee_mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
+    const int32_t _Ieee_exponent    = static_cast<int32_t>(_Uint_value >> _Traits::_Exponent_shift);
+
+    // * Prepare the _Adjusted_mantissa. This is aligned to hexit boundaries,
+    // * with the implicit bit restored (0 for zero values and subnormal values, 1 for normal values).
+    // * Also calculate the _Unbiased_exponent. This unifies the processing of zero, subnormal, and normal values.
+    _Uint_type _Adjusted_mantissa;
+
+    if constexpr (is_same_v<_Floating, float>) {
+        _Adjusted_mantissa = _Ieee_mantissa << 1; // align to hexit boundary (23 isn't divisible by 4)
+    } else {
+        _Adjusted_mantissa = _Ieee_mantissa; // already aligned (52 is divisible by 4)
+    }
+
+    int32_t _Unbiased_exponent;
+
+    if (_Ieee_exponent == 0) { // zero or subnormal
+        // implicit bit is 0
+
+        if (_Ieee_mantissa == 0) { // zero
+            // C11 7.21.6.1 "The fprintf function"/8: "If the value is zero, the exponent is zero."
+            _Unbiased_exponent = 0;
+        } else { // subnormal
+            _Unbiased_exponent = 1 - _Traits::_Exponent_bias;
+        }
+    } else { // normal
+        _Adjusted_mantissa |= _Uint_type{1} << _Adjusted_explicit_bits; // implicit bit is 1
+        _Unbiased_exponent = _Ieee_exponent - _Traits::_Exponent_bias;
+    }
+
+    // _Unbiased_exponent is within [-126, 127] for float, [-1022, 1023] for double.
+
+    // * Decompose _Unbiased_exponent into _Sign_character and _Absolute_exponent.
+    char _Sign_character;
+    uint32_t _Absolute_exponent;
+
+    if (_Unbiased_exponent < 0) {
+        _Sign_character    = '-';
+        _Absolute_exponent = static_cast<uint32_t>(-_Unbiased_exponent);
+    } else {
+        _Sign_character    = '+';
+        _Absolute_exponent = static_cast<uint32_t>(_Unbiased_exponent);
+    }
+
+    // _Absolute_exponent is within [0, 127] for float, [0, 1023] for double.
+
+    // * Perform a single bounds check.
+    {
+        int32_t _Exponent_length;
+
+        if (_Absolute_exponent < 10) {
+            _Exponent_length = 1;
+        } else if (_Absolute_exponent < 100) {
+            _Exponent_length = 2;
+        } else if constexpr (is_same_v<_Floating, float>) {
+            _Exponent_length = 3;
+        } else if (_Absolute_exponent < 1000) {
+            _Exponent_length = 3;
+        } else {
+            _Exponent_length = 4;
+        }
+
+        // _Precision might be enormous; avoid integer overflow by testing it separately.
+        ptrdiff_t _Buffer_size = _Last - _First;
+
+        if (_Buffer_size < _Precision) {
+            return {_Last, errc::value_too_large};
+        }
+
+        _Buffer_size -= _Precision;
+
+        const int32_t _Length_excluding_precision = 1 // leading hexit
+                                                  + static_cast<int32_t>(_Precision > 0) // possible decimal point
+                                                  // excluding `+ _Precision`, hexits after decimal point
+                                                  + 2 // "p+" or "p-"
+                                                  + _Exponent_length; // exponent
+
+        if (_Buffer_size < _Length_excluding_precision) {
+            return {_Last, errc::value_too_large};
+        }
+    }
+
+    // * Perform rounding when we've been asked to omit hexits.
+    if (_Precision < _Full_precision) {
+        // _Precision is within [0, 5] for float, [0, 12] for double.
+
+        // _Dropped_bits is within [4, 24] for float, [4, 52] for double.
+        const int _Dropped_bits = (_Full_precision - _Precision) * 4;
+
+        // Perform rounding by adding an appropriately-shifted bit.
+
+        // This can propagate carries all the way into the leading hexit. Examples:
+        // "0.ff9" rounded to a precision of 2 is "1.00".
+        // "1.ff9" rounded to a precision of 2 is "2.00".
+
+        // Note that the leading hexit participates in the rounding decision. Examples:
+        // "0.8" rounded to a precision of 0 is "0".
+        // "1.8" rounded to a precision of 0 is "2".
+
+        // Reference implementation with suboptimal codegen:
+        // const bool _Lsb_bit       = (_Adjusted_mantissa & (_Uint_type{1} << _Dropped_bits)) != 0;
+        // const bool _Round_bit     = (_Adjusted_mantissa & (_Uint_type{1} << (_Dropped_bits - 1))) != 0;
+        // const bool _Has_tail_bits = (_Adjusted_mantissa & ((_Uint_type{1} << (_Dropped_bits - 1)) - 1)) != 0;
+        // const bool _Should_round = _Should_round_up(_Lsb_bit, _Round_bit, _Has_tail_bits);
+        // _Adjusted_mantissa += _Uint_type{_Should_round} << _Dropped_bits;
+
+        // Example for optimized implementation: Let _Dropped_bits be 8.
+        //          Bit index: ...[8]76543210
+        // _Adjusted_mantissa: ...[L]RTTTTTTT (not depicting known details, like hexit alignment)
+        // By focusing on the bit at index _Dropped_bits, we can avoid unnecessary branching and shifting.
+
+        // Bit index: ...[8]76543210
+        //  _Lsb_bit: ...[L]RTTTTTTT
+        const _Uint_type _Lsb_bit = _Adjusted_mantissa;
+
+        //  Bit index: ...9[8]76543210
+        // _Round_bit: ...L[R]TTTTTTT0
+        const _Uint_type _Round_bit = _Adjusted_mantissa << 1;
+
+        // We can detect (without branching) whether any of the trailing bits are set.
+        // Due to _Should_round below, this computation will be used if and only if R is 1, so we can assume that here.
+        //      Bit index: ...9[8]76543210
+        //     _Round_bit: ...L[1]TTTTTTT0
+        // _Has_tail_bits: ....[H]........
+
+        // If all of the trailing bits T are 0, then `_Round_bit - 1` will produce 0 for H (due to R being 1).
+        // If any of the trailing bits T are 1, then `_Round_bit - 1` will produce 1 for H (due to R being 1).
+        const _Uint_type _Has_tail_bits = _Round_bit - 1;
+
+        // Finally, we can use _Should_round_up() logic with bitwise-AND and bitwise-OR,
+        // selecting just the bit at index _Dropped_bits. This is the appropriately-shifted bit that we want.
+        const _Uint_type _Should_round = _Round_bit & (_Has_tail_bits | _Lsb_bit) & (_Uint_type{1} << _Dropped_bits);
+
+        // This rounding technique is dedicated to the memory of Peppermint. =^..^=
+        _Adjusted_mantissa += _Should_round;
+    }
+
+    // * Print the leading hexit, then mask it away.
+    {
+        const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Adjusted_explicit_bits);
+        _STL_INTERNAL_CHECK(_Nibble < 3);
+        const char _Leading_hexit = static_cast<char>('0' + _Nibble);
+
+        *_First++ = _Leading_hexit;
+
+        constexpr _Uint_type _Mask = (_Uint_type{1} << _Adjusted_explicit_bits) - 1;
+        _Adjusted_mantissa &= _Mask;
+    }
+
+    // * Print the decimal point and trailing hexits.
+
+    // C11 7.21.6.1 "The fprintf function"/8:
+    // "if the precision is zero and the # flag is not specified, no decimal-point character appears."
+    if (_Precision > 0) {
+        *_First++ = '.';
+
+        int32_t _Number_of_bits_remaining = _Adjusted_explicit_bits; // 24 for float, 52 for double
+
+        for (;;) {
+            _STL_INTERNAL_CHECK(_Number_of_bits_remaining >= 4);
+            _STL_INTERNAL_CHECK(_Number_of_bits_remaining % 4 == 0);
+            _Number_of_bits_remaining -= 4;
+
+            const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Number_of_bits_remaining);
+            _STL_INTERNAL_CHECK(_Nibble < 16);
+            const char _Hexit = _Charconv_digits[_Nibble];
+
+            *_First++ = _Hexit;
+
+            // _Precision is the number of hexits that still need to be printed.
+            --_Precision;
+            if (_Precision == 0) {
+                break; // We're completely done with this phase.
+            }
+            // Otherwise, we need to keep printing hexits.
+
+            if (_Number_of_bits_remaining == 0) {
+                // We've finished printing _Adjusted_mantissa, so all remaining hexits are '0'.
+                _CSTD memset(_First, '0', static_cast<size_t>(_Precision));
+                _First += _Precision;
+                break;
+            }
+
+            // Mask away the hexit that we just printed, then keep looping.
+            // (We skip this when breaking out of the loop above, because _Adjusted_mantissa isn't used later.)
+            const _Uint_type _Mask = (_Uint_type{1} << _Number_of_bits_remaining) - 1;
+            _Adjusted_mantissa &= _Mask;
+        }
+    }
+
+    // * Print the exponent.
+
+    // C11 7.21.6.1 "The fprintf function"/8: "The exponent always contains at least one digit, and only as many more
+    // digits as necessary to represent the decimal exponent of 2."
+
+    // Performance note: We should take advantage of the known ranges of possible exponents.
+
+    *_First++ = 'p';
+    *_First++ = _Sign_character;
+
+    // We've already printed '-' if necessary, so uint32_t _Absolute_exponent avoids testing that again.
+    return _STD to_chars(_First, _Last, _Absolute_exponent);
+}
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_hex_shortest(
+    char* _First, char* const _Last, const _Floating _Value) noexcept {
+
+    // This prints "1.728p+0" instead of "2.e5p-1".
+    // This prints "0.000002p-126" instead of "1p-149" for float.
+    // This prints "0.0000000000001p-1022" instead of "1p-1074" for double.
+    // This prioritizes being consistent with printf's de facto behavior (and hex-precision's behavior)
+    // over minimizing the number of characters printed.
+
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    const _Uint_type _Uint_value = _Bit_cast<_Uint_type>(_Value);
+
+    if (_Uint_value == 0) { // zero detected; write "0p+0" and return
+        // C11 7.21.6.1 "The fprintf function"/8: "If the value is zero, the exponent is zero."
+        // Special-casing zero is necessary because of the exponent.
+        const char* const _Str = "0p+0";
+        constexpr size_t _Len  = 4;
+
+        if (_Last - _First < static_cast<ptrdiff_t>(_Len)) {
+            return {_Last, errc::value_too_large};
+        }
+
+        _CSTD memcpy(_First, _Str, _Len);
+
+        return {_First + _Len, errc{}};
+    }
+
+    const _Uint_type _Ieee_mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
+    const int32_t _Ieee_exponent    = static_cast<int32_t>(_Uint_value >> _Traits::_Exponent_shift);
+
+    char _Leading_hexit; // implicit bit
+    int32_t _Unbiased_exponent;
+
+    if (_Ieee_exponent == 0) { // subnormal
+        _Leading_hexit     = '0';
+        _Unbiased_exponent = 1 - _Traits::_Exponent_bias;
+    } else { // normal
+        _Leading_hexit     = '1';
+        _Unbiased_exponent = _Ieee_exponent - _Traits::_Exponent_bias;
+    }
+
+    // Performance note: Consider avoiding per-character bounds checking when there's plenty of space.
+
+    if (_First == _Last) {
+        return {_Last, errc::value_too_large};
+    }
+
+    *_First++ = _Leading_hexit;
+
+    if (_Ieee_mantissa == 0) {
+        // The fraction bits are all 0. Trim them away, including the decimal point.
+    } else {
+        if (_First == _Last) {
+            return {_Last, errc::value_too_large};
+        }
+
+        *_First++ = '.';
+
+        // The hexits after the decimal point correspond to the explicitly stored fraction bits.
+        // float explicitly stores 23 fraction bits. 23 / 4 == 5.75, so we'll print at most 6 hexits.
+        // double explicitly stores 52 fraction bits. 52 / 4 == 13, so we'll print at most 13 hexits.
+        _Uint_type _Adjusted_mantissa;
+        int32_t _Number_of_bits_remaining;
+
+        if constexpr (is_same_v<_Floating, float>) {
+            _Adjusted_mantissa        = _Ieee_mantissa << 1; // align to hexit boundary (23 isn't divisible by 4)
+            _Number_of_bits_remaining = 24; // 23 fraction bits + 1 alignment bit
+        } else {
+            _Adjusted_mantissa        = _Ieee_mantissa; // already aligned (52 is divisible by 4)
+            _Number_of_bits_remaining = 52; // 52 fraction bits
+        }
+
+        // do-while: The condition _Adjusted_mantissa != 0 is initially true - we have nonzero fraction bits and we've
+        // printed the decimal point. Each iteration, we print a hexit, mask it away, and keep looping if we still have
+        // nonzero fraction bits. If there would be trailing '0' hexits, this trims them. If there wouldn't be trailing
+        // '0' hexits, the same condition works (as we print the final hexit and mask it away); we don't need to test
+        // _Number_of_bits_remaining.
+        do {
+            _STL_INTERNAL_CHECK(_Number_of_bits_remaining >= 4);
+            _STL_INTERNAL_CHECK(_Number_of_bits_remaining % 4 == 0);
+            _Number_of_bits_remaining -= 4;
+
+            const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Number_of_bits_remaining);
+            _STL_INTERNAL_CHECK(_Nibble < 16);
+            const char _Hexit = _Charconv_digits[_Nibble];
+
+            if (_First == _Last) {
+                return {_Last, errc::value_too_large};
+            }
+
+            *_First++ = _Hexit;
+
+            const _Uint_type _Mask = (_Uint_type{1} << _Number_of_bits_remaining) - 1;
+            _Adjusted_mantissa &= _Mask;
+        } while (_Adjusted_mantissa != 0);
+    }
+
+    // C11 7.21.6.1 "The fprintf function"/8: "The exponent always contains at least one digit, and only as many more
+    // digits as necessary to represent the decimal exponent of 2."
+
+    // Performance note: We should take advantage of the known ranges of possible exponents.
+
+    // float: _Unbiased_exponent is within [-126, 127].
+    // double: _Unbiased_exponent is within [-1022, 1023].
+
+    if (_Last - _First < 2) {
+        return {_Last, errc::value_too_large};
+    }
+
+    *_First++ = 'p';
+
+    if (_Unbiased_exponent < 0) {
+        *_First++          = '-';
+        _Unbiased_exponent = -_Unbiased_exponent;
+    } else {
+        *_First++ = '+';
+    }
+
+    // We've already printed '-' if necessary, so static_cast<uint32_t> avoids testing that again.
+    return _STD to_chars(_First, _Last, static_cast<uint32_t>(_Unbiased_exponent));
+}
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_general_precision(
+    char* _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
+
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    const _Uint_type _Uint_value = _Bit_cast<_Uint_type>(_Value);
+
+    if (_Uint_value == 0) { // zero detected; write "0" and return; _Precision is irrelevant due to zero-trimming
+        if (_First == _Last) {
+            return {_Last, errc::value_too_large};
+        }
+
+        *_First++ = '0';
+
+        return {_First, errc{}};
+    }
+
+    // C11 7.21.6.1 "The fprintf function"/5:
+    // "A negative precision argument is taken as if the precision were omitted."
+    // /8: "g,G [...] Let P equal the precision if nonzero, 6 if the precision is omitted,
+    // or 1 if the precision is zero."
+
+    // Performance note: It's possible to rewrite this for branchless codegen,
+    // but profiling will be necessary to determine whether that's faster.
+    if (_Precision < 0) {
+        _Precision = 6;
+    } else if (_Precision == 0) {
+        _Precision = 1;
+    } else if (_Precision < 1'000'000) {
+        // _Precision is ok.
+    } else {
+        // Avoid integer overflow.
+        // Due to general notation's zero-trimming behavior, we can simply clamp _Precision.
+        // This is further clamped below.
+        _Precision = 1'000'000;
+    }
+
+    // _Precision is now the Standard's P.
+
+    // /8: "Then, if a conversion with style E would have an exponent of X:
+    // - if P > X >= -4, the conversion is with style f (or F) and precision P - (X + 1).
+    // - otherwise, the conversion is with style e (or E) and precision P - 1."
+
+    // /8: "Finally, [...] any trailing zeros are removed from the fractional portion of the result
+    // and the decimal-point character is removed if there is no fractional portion remaining."
+
+    using _Tables = _General_precision_tables_2<_Floating>;
+
+    const _Uint_type* _Table_begin;
+    const _Uint_type* _Table_end;
+
+    if (_Precision <= _Tables::_Max_special_P) {
+        _Table_begin = _Tables::_Special_X_table + (_Precision - 1) * (_Precision + 10) / 2;
+        _Table_end   = _Table_begin + _Precision + 5;
+    } else {
+        _Table_begin = _Tables::_Ordinary_X_table;
+        _Table_end   = _Table_begin + (_STD min) (_Precision, _Tables::_Max_P) + 5;
+    }
+
+    // Profiling indicates that linear search is faster than binary search for small tables.
+    // Performance note: lambda captures may have a small performance cost.
+    const _Uint_type* const _Table_lower_bound = [=] {
+        if constexpr (!is_same_v<_Floating, float>) {
+            if (_Precision > 155) { // threshold determined via profiling
+                return _STD lower_bound(_Table_begin, _Table_end, _Uint_value, less{});
+            }
+        }
+
+        return _STD find_if(_Table_begin, _Table_end, [=](const _Uint_type _Elem) { return _Uint_value <= _Elem; });
+    }();
+
+    const ptrdiff_t _Table_index     = _Table_lower_bound - _Table_begin;
+    const int _Scientific_exponent_X = static_cast<int>(_Table_index - 5);
+    const bool _Use_fixed_notation   = _Precision > _Scientific_exponent_X && _Scientific_exponent_X >= -4;
+
+    // Performance note: it might (or might not) be faster to modify Ryu Printf to perform zero-trimming.
+    // Such modifications would involve a fairly complicated state machine (notably, both '0' and '9' digits would
+    // need to be buffered, due to rounding), and that would have performance costs due to increased branching.
+    // Here, we're using a simpler approach: writing into a local buffer, manually zero-trimming, and then copying into
+    // the output range. The necessary buffer size is reasonably small, the zero-trimming logic is simple and fast,
+    // and the final copying is also fast.
+
+    constexpr int _Max_output_length =
+        is_same_v<_Floating, float> ? 117 : 773; // cases: 0x1.fffffep-126f and 0x1.fffffffffffffp-1022
+    constexpr int _Max_fixed_precision =
+        is_same_v<_Floating, float> ? 37 : 66; // cases: 0x1.fffffep-14f and 0x1.fffffffffffffp-14
+    constexpr int _Max_scientific_precision =
+        is_same_v<_Floating, float> ? 111 : 766; // cases: 0x1.fffffep-126f and 0x1.fffffffffffffp-1022
+
+    // Note that _Max_output_length is determined by scientific notation and is more than enough for fixed notation.
+    // 0x1.fffffep+127f is 39 digits, plus 1 for '.', plus _Max_fixed_precision for '0' digits, equals 77.
+    // 0x1.fffffffffffffp+1023 is 309 digits, plus 1 for '.', plus _Max_fixed_precision for '0' digits, equals 376.
+
+    char _Buffer[_Max_output_length];
+    const char* const _Significand_first = _Buffer; // e.g. "1.234"
+    const char* _Significand_last        = nullptr;
+    const char* _Exponent_first          = nullptr; // e.g. "e-05"
+    const char* _Exponent_last           = nullptr;
+    int _Effective_precision; // number of digits printed after the decimal point, before trimming
+
+    // Write into the local buffer.
+    // Clamping _Effective_precision allows _Buffer to be as small as possible, and increases efficiency.
+    if (_Use_fixed_notation) {
+        _Effective_precision = (_STD min) (_Precision - (_Scientific_exponent_X + 1), _Max_fixed_precision);
+        const to_chars_result _Buf_result =
+            _Floating_to_chars_fixed_precision(_Buffer, _STD end(_Buffer), _Value, _Effective_precision);
+        _STL_INTERNAL_CHECK(_Buf_result.ec == errc{});
+        _Significand_last = _Buf_result.ptr;
+    } else {
+        _Effective_precision = (_STD min) (_Precision - 1, _Max_scientific_precision);
+        const to_chars_result _Buf_result =
+            _Floating_to_chars_scientific_precision(_Buffer, _STD end(_Buffer), _Value, _Effective_precision);
+        _STL_INTERNAL_CHECK(_Buf_result.ec == errc{});
+        _Significand_last = _STD find(_Buffer, _Buf_result.ptr, 'e');
+        _Exponent_first   = _Significand_last;
+        _Exponent_last    = _Buf_result.ptr;
+    }
+
+    // If we printed a decimal point followed by digits, perform zero-trimming.
+    if (_Effective_precision > 0) {
+        while (_Significand_last[-1] == '0') { // will stop at '.' or a nonzero digit
+            --_Significand_last;
+        }
+
+        if (_Significand_last[-1] == '.') {
+            --_Significand_last;
+        }
+    }
+
+    // Copy the significand to the output range.
+    const ptrdiff_t _Significand_distance = _Significand_last - _Significand_first;
+    if (_Last - _First < _Significand_distance) {
+        return {_Last, errc::value_too_large};
+    }
+    _CSTD memcpy(_First, _Significand_first, static_cast<size_t>(_Significand_distance));
+    _First += _Significand_distance;
+
+    // Copy the exponent to the output range.
+    if (!_Use_fixed_notation) {
+        const ptrdiff_t _Exponent_distance = _Exponent_last - _Exponent_first;
+        if (_Last - _First < _Exponent_distance) {
+            return {_Last, errc::value_too_large};
+        }
+        _CSTD memcpy(_First, _Exponent_first, static_cast<size_t>(_Exponent_distance));
+        _First += _Exponent_distance;
+    }
+
+    return {_First, errc{}};
+}
+
+enum class _Floating_to_chars_overload { _Plain, _Format_only, _Format_precision };
+
+template <_Floating_to_chars_overload _Overload, class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars(
+    char* _First, char* const _Last, _Floating _Value, const chars_format _Fmt, const int _Precision) noexcept {
+    _Adl_verify_range(_First, _Last);
+
+    if constexpr (_Overload == _Floating_to_chars_overload::_Plain) {
+        _STL_INTERNAL_CHECK(_Fmt == chars_format{}); // plain overload must pass chars_format{} internally
+    } else {
+        _STL_ASSERT(_Fmt == chars_format::general || _Fmt == chars_format::scientific || _Fmt == chars_format::fixed
+                        || _Fmt == chars_format::hex,
+            "invalid format in to_chars()");
+    }
+
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    _Uint_type _Uint_value = _Bit_cast<_Uint_type>(_Value);
+
+    const bool _Was_negative = (_Uint_value & _Traits::_Shifted_sign_mask) != 0;
+
+    if (_Was_negative) { // sign bit detected; write minus sign and clear sign bit
+        if (_First == _Last) {
+            return {_Last, errc::value_too_large};
+        }
+
+        *_First++ = '-';
+
+        _Uint_value &= ~_Traits::_Shifted_sign_mask;
+        _Value = _Bit_cast<_Floating>(_Uint_value);
+    }
+
+    if ((_Uint_value & _Traits::_Shifted_exponent_mask) == _Traits::_Shifted_exponent_mask) {
+        // inf/nan detected; write appropriate string and return
+        const char* _Str;
+        size_t _Len;
+
+        const _Uint_type _Mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
+
+        if (_Mantissa == 0) {
+            _Str = "inf";
+            _Len = 3;
+        } else if (_Was_negative && _Mantissa == _Traits::_Special_nan_mantissa_mask) {
+            // When a NaN value has the sign bit set, the quiet bit set, and all other mantissa bits cleared,
+            // the UCRT interprets it to mean "indeterminate", and indicates this by printing "-nan(ind)".
+            _Str = "nan(ind)";
+            _Len = 8;
+        } else if ((_Mantissa & _Traits::_Special_nan_mantissa_mask) != 0) {
+            _Str = "nan";
+            _Len = 3;
+        } else {
+            _Str = "nan(snan)";
+            _Len = 9;
+        }
+
+        if (_Last - _First < static_cast<ptrdiff_t>(_Len)) {
+            return {_Last, errc::value_too_large};
+        }
+
+        _CSTD memcpy(_First, _Str, _Len);
+
+        return {_First + _Len, errc{}};
+    }
+
+    if constexpr (_Overload == _Floating_to_chars_overload::_Plain) {
+        return _Floating_to_chars_ryu(_First, _Last, _Value, chars_format{});
+    } else if constexpr (_Overload == _Floating_to_chars_overload::_Format_only) {
+        if (_Fmt == chars_format::hex) {
+            return _Floating_to_chars_hex_shortest(_First, _Last, _Value);
+        }
+
+        return _Floating_to_chars_ryu(_First, _Last, _Value, _Fmt);
+    } else if constexpr (_Overload == _Floating_to_chars_overload::_Format_precision) {
+        switch (_Fmt) {
+        case chars_format::scientific:
+            return _Floating_to_chars_scientific_precision(_First, _Last, _Value, _Precision);
+        case chars_format::fixed:
+            return _Floating_to_chars_fixed_precision(_First, _Last, _Value, _Precision);
+        case chars_format::general:
+            return _Floating_to_chars_general_precision(_First, _Last, _Value, _Precision);
+        case chars_format::hex:
+        default: // avoid warning C4715: not all control paths return a value
+            return _Floating_to_chars_hex_precision(_First, _Last, _Value, _Precision);
+        }
+    }
+}
+
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const float _Value) noexcept
+/* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(_First, _Last, _Value, chars_format{}, 0);
+}
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const double _Value) noexcept
+/* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(_First, _Last, _Value, chars_format{}, 0);
+}
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value) noexcept
+/* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(
+        _First, _Last, static_cast<double>(_Value), chars_format{}, 0);
+}
+_EXPORT_STD inline to_chars_result to_chars(
+    char* const _First, char* const _Last, const float _Value, const chars_format _Fmt) noexcept /* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(_First, _Last, _Value, _Fmt, 0);
+}
+_EXPORT_STD inline to_chars_result to_chars(
+    char* const _First, char* const _Last, const double _Value, const chars_format _Fmt) noexcept /* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(_First, _Last, _Value, _Fmt, 0);
+}
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value,
+    const chars_format _Fmt) noexcept /* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(
+        _First, _Last, static_cast<double>(_Value), _Fmt, 0);
+}
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const float _Value,
+    const chars_format _Fmt, const int _Precision) noexcept /* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(_First, _Last, _Value, _Fmt, _Precision);
+}
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const double _Value,
+    const chars_format _Fmt, const int _Precision) noexcept /* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(_First, _Last, _Value, _Fmt, _Precision);
+}
+_EXPORT_STD inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value,
+    const chars_format _Fmt, const int _Precision) noexcept /* strengthened */ {
+    return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(
+        _First, _Last, static_cast<double>(_Value), _Fmt, _Precision);
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX17 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CHARCONV_
diff --git a/msvc-stl/stl/inc/chrono b/msvc-stl/stl/inc/chrono
new file mode 100644
index 0000000..c062544
--- /dev/null
+++ b/msvc-stl/stl/inc/chrono
@@ -0,0 +1,6283 @@
+// chrono standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CHRONO_
+#define _CHRONO_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_chrono.hpp>
+
+#if _HAS_CXX17
+#include <system_error>
+#include <xfilesystem_abi.h>
+#include <xstring>
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+#include <__msvc_tzdb.hpp>
+#include <atomic>
+#include <cmath>
+#include <compare>
+#include <concepts>
+#include <cstdint>
+#include <format>
+#include <forward_list>
+#include <iomanip>
+#include <istream>
+#include <memory>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <xloctime>
+#include <xthreads.h>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#if _HAS_CXX17
+_NODISCARD inline int _Check_convert_result(const __std_fs_convert_result _Result) {
+    if (_Result._Err != __std_win_error::_Success) {
+        _STD _Throw_system_error_from_std_win_error(_Result._Err);
+    }
+
+    return _Result._Len;
+}
+
+template <class _Traits, class _Alloc>
+_NODISCARD basic_string<typename _Traits::char_type, _Traits, _Alloc> _Convert_wide_to_narrow(
+    const __std_code_page _Code_page, const wstring_view _Input, const _Alloc& _Al) {
+    basic_string<typename _Traits::char_type, _Traits, _Alloc> _Output(_Al);
+
+    if (!_Input.empty()) {
+        if (!_STD _In_range<int>(_Input.size())) {
+            _STD _Throw_system_error(errc::invalid_argument);
+        }
+
+        const int _Len = _STD _Check_convert_result(
+            ::__std_fs_convert_wide_to_narrow(_Code_page, _Input.data(), static_cast<int>(_Input.size()), nullptr, 0));
+
+        _Output.resize(static_cast<size_t>(_Len));
+
+        const auto _Data_as_char = reinterpret_cast<char*>(_Output.data());
+
+        (void) _STD _Check_convert_result(::__std_fs_convert_wide_to_narrow(
+            _Code_page, _Input.data(), static_cast<int>(_Input.size()), _Data_as_char, _Len));
+    }
+
+    return _Output;
+}
+#endif // _HAS_CXX17
+
+namespace chrono {
+    _EXPORT_STD struct system_clock { // wraps GetSystemTimePreciseAsFileTime
+        using rep                       = long long;
+        using period                    = ratio<1, 10'000'000>; // 100 nanoseconds
+        using duration                  = _CHRONO duration<rep, period>;
+        using time_point                = _CHRONO time_point<system_clock>;
+        static constexpr bool is_steady = false;
+
+        _NODISCARD static time_point now() noexcept { // get current time
+            return time_point(duration(::_Xtime_get_ticks()));
+        }
+
+        _NODISCARD static __time64_t to_time_t(const time_point& _Time) noexcept { // convert to __time64_t
+            return duration_cast<seconds>(_Time.time_since_epoch()).count();
+        }
+
+        _NODISCARD static time_point from_time_t(__time64_t _Tm) noexcept { // convert from __time64_t
+            return time_point{seconds{_Tm}};
+        }
+    };
+
+#if _HAS_CXX20
+    _EXPORT_STD template <class _Duration>
+    using sys_time                = time_point<system_clock, _Duration>;
+    _EXPORT_STD using sys_seconds = sys_time<seconds>;
+    _EXPORT_STD using sys_days    = sys_time<days>;
+#endif // _HAS_CXX20
+
+    _EXPORT_STD using high_resolution_clock = steady_clock;
+
+#if _HAS_CXX20
+    // [time.duration.io]
+
+#define _IF_PERIOD_RETURN_SUFFIX_ELSE(_TYPE, _SUFFIX) \
+    if constexpr (is_same_v<_Period, _TYPE>) {        \
+        if constexpr (is_same_v<_CharT, char>) {      \
+            return _SUFFIX;                           \
+        } else {                                      \
+            return L##_SUFFIX;                        \
+        }                                             \
+    } else
+
+    template <class _CharT, class _Period>
+    _NODISCARD constexpr const _CharT* _Get_literal_unit_suffix() {
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(atto, "as")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(femto, "fs")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(pico, "ps")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(nano, "ns")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(micro, "us")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(milli, "ms")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(centi, "cs")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(deci, "ds")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(seconds::period, "s")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(deca, "das")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(hecto, "hs")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(kilo, "ks")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(mega, "Ms")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(giga, "Gs")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(tera, "Ts")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(peta, "Ps")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(exa, "Es")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(minutes::period, "min")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(hours::period, "h")
+        _IF_PERIOD_RETURN_SUFFIX_ELSE(ratio<86400>, "d")
+
+        {
+            return nullptr;
+        }
+    }
+
+#undef _IF_PERIOD_RETURN_SUFFIX_ELSE
+
+    template <class _CharT>
+    _NODISCARD _CharT* _Get_general_unit_suffix(_CharT* _Rnext, const intmax_t _Num, const intmax_t _Den) {
+        // Returns the head pointer of the string, built in reverse.
+        _STL_INTERNAL_CHECK(_Num > 0 && _Den > 0);
+        *--_Rnext = '\0';
+        *--_Rnext = 's';
+        *--_Rnext = ']';
+        if (_Den != 1) {
+            _Rnext    = _STD _UIntegral_to_buff(_Rnext, static_cast<uintmax_t>(_Den));
+            *--_Rnext = '/';
+        }
+
+        _Rnext    = _STD _UIntegral_to_buff(_Rnext, static_cast<uintmax_t>(_Num));
+        *--_Rnext = '[';
+        return _Rnext;
+    }
+
+    template <class _Period, class _CharT, class _Traits>
+    void _Write_unit_suffix(basic_ostream<_CharT, _Traits>& _Os) {
+        constexpr auto _Suffix = _CHRONO _Get_literal_unit_suffix<_CharT, _Period>();
+        if constexpr (_Suffix == nullptr) {
+            _CharT _Buffer[2 * (numeric_limits<intmax_t>::digits10 + 1) + 5] = {}; // 2 numbers + "[/]s\0"
+            const _CharT* const _Begin =
+                _CHRONO _Get_general_unit_suffix<_CharT>(_STD end(_Buffer), _Period::num, _Period::den);
+            _Os << _Begin;
+        } else {
+            _Os << _Suffix;
+        }
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Rep, class _Period>
+    basic_ostream<_CharT, _Traits>& operator<<(
+        basic_ostream<_CharT, _Traits>& _Os, const duration<_Rep, _Period>& _Dur) {
+        basic_ostringstream<_CharT, _Traits> _Sstr;
+        _Sstr.flags(_Os.flags());
+        _Sstr.imbue(_Os.getloc());
+        _Sstr.precision(_Os.precision());
+        _Sstr << _Dur.count();
+        _CHRONO _Write_unit_suffix<_Period>(_Sstr);
+
+        return _Os << _Sstr.str();
+    }
+
+    _EXPORT_STD struct local_t {};
+
+    _EXPORT_STD template <class _Duration>
+    using local_time                = time_point<local_t, _Duration>;
+    _EXPORT_STD using local_seconds = local_time<seconds>;
+    _EXPORT_STD using local_days    = local_time<days>;
+
+    _EXPORT_STD struct last_spec {
+        explicit last_spec() = default;
+    };
+    _EXPORT_STD inline constexpr last_spec last{};
+
+    _EXPORT_STD class day {
+    public:
+        day() = default;
+        constexpr explicit day(unsigned int _Val) noexcept : _Day{static_cast<unsigned char>(_Val)} {}
+
+        constexpr day& operator++() noexcept {
+            ++_Day;
+            return *this;
+        }
+        constexpr day operator++(int) noexcept {
+            return day{_Day++};
+        }
+        constexpr day& operator--() noexcept {
+            --_Day;
+            return *this;
+        }
+        constexpr day operator--(int) noexcept {
+            return day{_Day--};
+        }
+
+        constexpr day& operator+=(const days& _Days) noexcept {
+            _Day += static_cast<unsigned char>(_Days.count());
+            return *this;
+        }
+        constexpr day& operator-=(const days& _Days) noexcept {
+            _Day -= static_cast<unsigned char>(_Days.count());
+            return *this;
+        }
+
+        _NODISCARD constexpr explicit operator unsigned int() const noexcept {
+            return _Day;
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Day >= 1 && _Day <= 31;
+        }
+
+    private:
+        unsigned char _Day;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const day& _Left, const day& _Right) noexcept {
+        return static_cast<unsigned int>(_Left) == static_cast<unsigned int>(_Right);
+    }
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept {
+        return static_cast<unsigned int>(_Left) <=> static_cast<unsigned int>(_Right);
+    }
+
+    _EXPORT_STD _NODISCARD constexpr day operator+(const day& _Left, const days& _Right) noexcept {
+        return day{static_cast<unsigned int>(_Left) + _Right.count()};
+    }
+    _EXPORT_STD _NODISCARD constexpr day operator+(const days& _Left, const day& _Right) noexcept {
+        return _Right + _Left;
+    }
+    _EXPORT_STD _NODISCARD constexpr day operator-(const day& _Left, const days& _Right) noexcept {
+        return day{static_cast<unsigned int>(_Left) - _Right.count()};
+    }
+    _EXPORT_STD _NODISCARD constexpr days operator-(const day& _Left, const day& _Right) noexcept {
+        return days{
+            static_cast<int>(static_cast<unsigned int>(_Left)) - static_cast<int>(static_cast<unsigned int>(_Right))};
+    }
+
+    _EXPORT_STD class month {
+    public:
+        month() = default;
+        constexpr explicit month(unsigned int _Val) noexcept : _Month{static_cast<unsigned char>(_Val)} {}
+
+        constexpr month& operator++() noexcept {
+            *this += months{1};
+            return *this;
+        }
+        constexpr month operator++(int) noexcept {
+            month _Temp{*this};
+            ++*this;
+            return _Temp;
+        }
+        constexpr month& operator--() noexcept {
+            *this -= months{1};
+            return *this;
+        }
+        constexpr month operator--(int) noexcept {
+            month _Temp{*this};
+            --*this;
+            return _Temp;
+        }
+
+        constexpr month& operator+=(const months& _Months) noexcept;
+        constexpr month& operator-=(const months& _Months) noexcept;
+
+        _NODISCARD constexpr explicit operator unsigned int() const noexcept {
+            return _Month;
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Month >= 1 && _Month <= 12;
+        }
+
+    private:
+        unsigned char _Month;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const month& _Left, const month& _Right) noexcept {
+        return static_cast<unsigned int>(_Left) == static_cast<unsigned int>(_Right);
+    }
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept {
+        return static_cast<unsigned int>(_Left) <=> static_cast<unsigned int>(_Right);
+    }
+
+    _EXPORT_STD _NODISCARD constexpr month operator+(const month& _Left, const months& _Right) noexcept {
+        const auto _Mo  = static_cast<long long>(static_cast<unsigned int>(_Left)) + (_Right.count() - 1);
+        const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12;
+        return month{static_cast<unsigned int>(_Mo - _Div * 12 + 1)};
+    }
+    _EXPORT_STD _NODISCARD constexpr month operator+(const months& _Left, const month& _Right) noexcept {
+        return _Right + _Left;
+    }
+    _EXPORT_STD _NODISCARD constexpr month operator-(const month& _Left, const months& _Right) noexcept {
+        return _Left + -_Right;
+    }
+    _EXPORT_STD _NODISCARD constexpr months operator-(const month& _Left, const month& _Right) noexcept {
+        const auto _Mo = static_cast<unsigned int>(_Left) - static_cast<unsigned int>(_Right);
+        return months{_Mo <= 11 ? _Mo : _Mo + 12};
+    }
+
+    constexpr month& month::operator+=(const months& _Months) noexcept {
+        *this = *this + _Months;
+        return *this;
+    }
+    constexpr month& month::operator-=(const months& _Months) noexcept {
+        *this = *this - _Months;
+        return *this;
+    }
+
+    _EXPORT_STD class year {
+    public:
+        year() = default;
+        constexpr explicit year(int _Val) noexcept : _Year{static_cast<short>(_Val)} {}
+
+        constexpr year& operator++() noexcept {
+            ++_Year;
+            return *this;
+        }
+        constexpr year operator++(int) noexcept {
+            return year{_Year++};
+        }
+        constexpr year& operator--() noexcept {
+            --_Year;
+            return *this;
+        }
+        constexpr year operator--(int) noexcept {
+            return year{_Year--};
+        }
+
+        constexpr year& operator+=(const years& _Years) noexcept {
+#ifdef __EDG__ // TRANSITION, VSO-1271098
+            _Year = static_cast<short>(_Year + _Years.count());
+#else // ^^^ workaround / no workaround vvv
+            _Year += static_cast<short>(_Years.count());
+#endif // ^^^ no workaround ^^^
+            return *this;
+        }
+        constexpr year& operator-=(const years& _Years) noexcept {
+#ifdef __EDG__ // TRANSITION, VSO-1271098
+            _Year = static_cast<short>(_Year - _Years.count());
+#else // ^^^ workaround / no workaround vvv
+            _Year -= static_cast<short>(_Years.count());
+#endif // ^^^ no workaround ^^^
+            return *this;
+        }
+
+        _NODISCARD constexpr year operator+() const noexcept {
+            return *this;
+        }
+        _NODISCARD constexpr year operator-() const noexcept {
+            return year{-_Year};
+        }
+
+        _NODISCARD constexpr bool is_leap() const noexcept {
+            return _Year % 4 == 0 && (_Year % 100 != 0 || _Year % 400 == 0);
+        }
+
+        _NODISCARD constexpr explicit operator int() const noexcept {
+            return _Year;
+        }
+
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Year_min <= _Year && _Year <= _Year_max;
+        }
+
+        _NODISCARD static constexpr year(min)() noexcept {
+            return year{_Year_min};
+        }
+        _NODISCARD static constexpr year(max)() noexcept {
+            return year{_Year_max};
+        }
+
+    private:
+        short _Year;
+        static constexpr int _Year_min = -32767;
+        static constexpr int _Year_max = 32767;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const year& _Left, const year& _Right) noexcept {
+        return static_cast<int>(_Left) == static_cast<int>(_Right);
+    }
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept {
+        return static_cast<int>(_Left) <=> static_cast<int>(_Right);
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year operator+(const year& _Left, const years& _Right) noexcept {
+        return year{static_cast<int>(_Left) + _Right.count()};
+    }
+    _EXPORT_STD _NODISCARD constexpr year operator+(const years& _Left, const year& _Right) noexcept {
+        return _Right + _Left;
+    }
+    _EXPORT_STD _NODISCARD constexpr year operator-(const year& _Left, const years& _Right) noexcept {
+        return _Left + -_Right;
+    }
+    _EXPORT_STD _NODISCARD constexpr years operator-(const year& _Left, const year& _Right) noexcept {
+        return years{static_cast<int>(_Left) - static_cast<int>(_Right)};
+    }
+
+    _EXPORT_STD class weekday_indexed;
+    _EXPORT_STD class weekday_last;
+
+    _EXPORT_STD class weekday {
+    public:
+        weekday() = default;
+        constexpr explicit weekday(unsigned int _Val) noexcept
+            : _Weekday{static_cast<unsigned char>(_Val == 7 ? 0 : _Val)} {}
+        constexpr weekday(const sys_days& _Sys_day) noexcept
+            : _Weekday{static_cast<unsigned char>(_Weekday_from_days(_Sys_day.time_since_epoch().count()))} {}
+        constexpr explicit weekday(const local_days& _Local_day) noexcept
+            : _Weekday{static_cast<unsigned char>(_Weekday_from_days(_Local_day.time_since_epoch().count()))} {}
+
+        constexpr weekday& operator++() noexcept {
+            return *this += days{1};
+        }
+        constexpr weekday operator++(int) noexcept {
+            weekday _Temp{*this};
+            ++*this;
+            return _Temp;
+        }
+        constexpr weekday& operator--() noexcept {
+            return *this -= days{1};
+        }
+        constexpr weekday operator--(int) noexcept {
+            weekday _Temp{*this};
+            --*this;
+            return _Temp;
+        }
+
+        constexpr weekday& operator+=(const days& _Days) noexcept;
+        constexpr weekday& operator-=(const days& _Days) noexcept;
+
+        _NODISCARD constexpr unsigned int c_encoding() const noexcept {
+            return _Weekday;
+        }
+        _NODISCARD constexpr unsigned int iso_encoding() const noexcept {
+            return _Weekday == 0u ? 7u : _Weekday;
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Weekday <= 6;
+        }
+
+        _NODISCARD constexpr weekday_indexed operator[](unsigned int _Index) const noexcept;
+        _NODISCARD constexpr weekday_last operator[](last_spec) const noexcept;
+
+    private:
+        unsigned char _Weekday;
+
+        // courtesy of Howard Hinnant (modified to avoid overflow)
+        // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days
+        _NODISCARD static constexpr unsigned int _Weekday_from_days(int _Tp) noexcept {
+            _STL_INTERNAL_STATIC_ASSERT(~0u % 7u == 3u); // offset for `_Tp < 0` needs to change
+            const auto _Before_modulo = static_cast<unsigned int>(_Tp) + (_Tp >= 0 ? 4u : 0u);
+            return _Before_modulo % 7u; // separate expression for MSVC codegen, see GH-5153
+        }
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept {
+        return _Left.c_encoding() == _Right.c_encoding();
+    }
+
+    _EXPORT_STD _NODISCARD constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept {
+        const auto _Wd  = static_cast<long long>(_Left.c_encoding()) + _Right.count();
+        const auto _Div = (_Wd >= 0 ? _Wd : _Wd - 6) / 7;
+        return weekday{static_cast<unsigned int>(_Wd - _Div * 7)};
+    }
+    _EXPORT_STD _NODISCARD constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept {
+        return _Right + _Left;
+    }
+    _EXPORT_STD _NODISCARD constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept {
+        return _Left + -_Right;
+    }
+    _EXPORT_STD _NODISCARD constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept {
+        const auto _Wd = _Left.c_encoding() - _Right.c_encoding();
+        const auto _Wk = _Wd <= 6 ? _Wd : _Wd + 7;
+        return days{_Wk};
+    }
+
+    constexpr weekday& weekday::operator+=(const days& _Days) noexcept {
+        *this = *this + _Days;
+        return *this;
+    }
+    constexpr weekday& weekday::operator-=(const days& _Days) noexcept {
+        *this = *this - _Days;
+        return *this;
+    }
+
+    _EXPORT_STD class weekday_indexed {
+    public:
+        weekday_indexed() = default;
+        constexpr weekday_indexed(const weekday& _Wd, unsigned int _Idx) noexcept
+            : _Weekday{_Wd}, _Index{static_cast<unsigned char>(_Idx)} {}
+
+        _NODISCARD constexpr weekday weekday() const noexcept {
+            return _Weekday;
+        }
+        _NODISCARD constexpr unsigned int index() const noexcept {
+            return _Index;
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Weekday.ok() && _Index >= 1 && _Index <= 5;
+        }
+
+    private:
+        _CHRONO weekday _Weekday;
+        unsigned char _Index;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept {
+        return _Left.weekday() == _Right.weekday() && _Left.index() == _Right.index();
+    }
+
+    _EXPORT_STD class weekday_last {
+    public:
+        constexpr explicit weekday_last(const weekday& _Wd) noexcept : _Weekday{_Wd} {}
+
+        _NODISCARD constexpr weekday weekday() const noexcept {
+            return _Weekday;
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Weekday.ok();
+        }
+
+    private:
+        _CHRONO weekday _Weekday;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept {
+        return _Left.weekday() == _Right.weekday();
+    }
+
+    _NODISCARD constexpr weekday_indexed weekday::operator[](unsigned int _Index) const noexcept {
+        return {*this, _Index};
+    }
+    _NODISCARD constexpr weekday_last weekday::operator[](last_spec) const noexcept {
+        return weekday_last{*this};
+    }
+
+    _EXPORT_STD class month_day {
+    public:
+        month_day() = default;
+        constexpr month_day(const month& _Month_, const day& _Day_) noexcept : _Month{_Month_}, _Day{_Day_} {}
+
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month;
+        }
+        _NODISCARD constexpr day day() const noexcept {
+            return _Day;
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            if (!_Month.ok() || !_Day.ok()) {
+                return false;
+            }
+
+            const auto _Da = static_cast<unsigned int>(_Day);
+            const auto _Mo = static_cast<unsigned int>(_Month);
+            if (_Mo == 2) {
+                return _Da <= 29;
+            }
+
+            if (_Mo == 4 || _Mo == 6 || _Mo == 9 || _Mo == 11) {
+                return _Da <= 30;
+            }
+            return true;
+        }
+
+    private:
+        _CHRONO month _Month;
+        _CHRONO day _Day;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept {
+        return _Left.month() == _Right.month() && _Left.day() == _Right.day();
+    }
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+        const month_day& _Left, const month_day& _Right) noexcept {
+        const auto _Comp = _Left.month() <=> _Right.month();
+        if (_Comp != 0) {
+            return _Comp;
+        }
+
+        return _Left.day() <=> _Right.day();
+    }
+
+    _EXPORT_STD class month_day_last {
+    public:
+        constexpr explicit month_day_last(const month& _Month_) noexcept : _Month{_Month_} {}
+
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month;
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Month.ok();
+        }
+
+    private:
+        _CHRONO month _Month;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const month_day_last& _Left, const month_day_last& _Right) noexcept {
+        return _Left.month() == _Right.month();
+    }
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+        const month_day_last& _Left, const month_day_last& _Right) noexcept {
+        return _Left.month() <=> _Right.month();
+    }
+
+    _EXPORT_STD class month_weekday {
+    public:
+        constexpr month_weekday(const month& _Month_, const weekday_indexed& _Wdi) noexcept
+            : _Month{_Month_}, _Weekday_index{_Wdi} {}
+
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month;
+        }
+        _NODISCARD constexpr weekday_indexed weekday_indexed() const noexcept {
+            return _Weekday_index;
+        }
+
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Month.ok() && _Weekday_index.ok();
+        }
+
+    private:
+        _CHRONO month _Month;
+        _CHRONO weekday_indexed _Weekday_index;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept {
+        return _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed();
+    }
+
+    _EXPORT_STD class month_weekday_last {
+    public:
+        constexpr month_weekday_last(const month& _Month_, const weekday_last& _Wdl) noexcept
+            : _Month{_Month_}, _Weekday_last{_Wdl} {}
+
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month;
+        }
+        _NODISCARD constexpr weekday_last weekday_last() const noexcept {
+            return _Weekday_last;
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Month.ok() && _Weekday_last.ok();
+        }
+
+    private:
+        _CHRONO month _Month;
+        _CHRONO weekday_last _Weekday_last;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept {
+        return _Left.month() == _Right.month() && _Left.weekday_last() == _Right.weekday_last();
+    }
+
+    _EXPORT_STD class year_month {
+    public:
+        year_month() = default;
+        constexpr year_month(const year& _Year_, const month& _Month_) noexcept : _Year{_Year_}, _Month{_Month_} {}
+
+        _NODISCARD constexpr year year() const noexcept {
+            return _Year;
+        }
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month;
+        }
+
+        template <int = 0>
+        constexpr year_month& operator+=(const months& _Months) noexcept;
+        template <int = 0>
+        constexpr year_month& operator-=(const months& _Months) noexcept;
+        constexpr year_month& operator+=(const years& _Years) noexcept;
+        constexpr year_month& operator-=(const years& _Years) noexcept;
+
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Year.ok() && _Month.ok();
+        }
+
+    private:
+        _CHRONO year _Year;
+        _CHRONO month _Month;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept {
+        return _Left.year() == _Right.year() && _Left.month() == _Right.month();
+    }
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+        const year_month& _Left, const year_month& _Right) noexcept {
+        const auto _Comp = _Left.year() <=> _Right.year();
+        if (_Comp != 0) {
+            return _Comp;
+        }
+
+        return _Left.month() <=> _Right.month();
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept {
+        const auto _Mo  = static_cast<long long>(static_cast<unsigned int>(_Left.month())) + (_Right.count() - 1);
+        const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12;
+        return year_month{_Left.year() + years{_Div}, month{static_cast<unsigned int>(_Mo - _Div * 12 + 1)}};
+    }
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept {
+        return _Left.year() - _Right.year()
+             + months{static_cast<int>(static_cast<unsigned int>(_Left.month()))
+                      - static_cast<int>(static_cast<unsigned int>(_Right.month()))};
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept {
+        return {year{_Left.year() + _Right}, _Left.month()};
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    template <int>
+    constexpr year_month& year_month::operator+=(const months& _Months) noexcept {
+        *this = *this + _Months;
+        return *this;
+    }
+    template <int>
+    constexpr year_month& year_month::operator-=(const months& _Months) noexcept {
+        *this = *this - _Months;
+        return *this;
+    }
+    constexpr year_month& year_month::operator+=(const years& _Years) noexcept {
+        *this = *this + _Years;
+        return *this;
+    }
+    constexpr year_month& year_month::operator-=(const years& _Years) noexcept {
+        *this = *this - _Years;
+        return *this;
+    }
+
+    // To prevent UB by going out of bounds, four extra days with an invalid day are added.
+    inline constexpr day _Last_day_table[] = {day{31}, day{28}, day{31}, day{30}, day{31}, day{30}, day{31}, day{31},
+        day{30}, day{31}, day{30}, day{31}, day{255}, day{255}, day{255}, day{255}};
+
+    _NODISCARD constexpr day _Last_day(const year& _Year, const month& _Month) {
+        if (_Month == month{2} && _Year.is_leap()) {
+            return day{29};
+        }
+
+        return _Last_day_table[(static_cast<unsigned int>(_Month) - 1) & 0xF];
+    }
+
+    _EXPORT_STD class year_month_day_last;
+
+    _EXPORT_STD class year_month_day {
+    public:
+        year_month_day() = default;
+        constexpr year_month_day(const year& _Year_, const month& _Month_, const day& _Day_) noexcept
+            : _Year{_Year_}, _Month{_Month_}, _Day{_Day_} {}
+        constexpr year_month_day(const year_month_day_last& _Ymdl) noexcept;
+        constexpr year_month_day(const sys_days& _Sys_days) noexcept
+            : year_month_day{_Civil_from_days(_Sys_days.time_since_epoch().count())} {}
+        constexpr explicit year_month_day(const local_days& _Local_days) noexcept
+            : year_month_day{_Civil_from_days(_Local_days.time_since_epoch().count())} {}
+
+        template <int = 0>
+        constexpr year_month_day& operator+=(const months& _Months) noexcept;
+        template <int = 0>
+        constexpr year_month_day& operator-=(const months& _Months) noexcept;
+        constexpr year_month_day& operator+=(const years& _Years) noexcept;
+        constexpr year_month_day& operator-=(const years& _Years) noexcept;
+
+        _NODISCARD constexpr year year() const noexcept {
+            return _Year;
+        }
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month;
+        }
+        _NODISCARD constexpr day day() const noexcept {
+            return _Day;
+        }
+
+        _NODISCARD constexpr operator sys_days() const noexcept {
+            return sys_days{_Days_from_civil()};
+        }
+        _NODISCARD constexpr explicit operator local_days() const noexcept {
+            return local_days{static_cast<sys_days>(*this).time_since_epoch()};
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            if (!_Year.ok() || !_Month.ok()) {
+                return false;
+            }
+
+            return _Day >= _CHRONO day{1} && _Day <= _CHRONO _Last_day(_Year, _Month);
+        }
+
+        _NODISCARD constexpr int _Calculate_weekday() const noexcept {
+            const int _Day_int   = static_cast<int>(static_cast<unsigned int>(_Day));
+            const int _Month_int = static_cast<int>(static_cast<unsigned int>(_Month));
+
+            const int _Era_year = static_cast<int>(_Year) - (_Month_int <= 2);
+            const int _Era      = (_Era_year >= 0 ? _Era_year : _Era_year - 399) / 400;
+            const int _Yoe      = _Era_year - _Era * 400;
+            const int _Yday_era = ((979 * (_Month_int + (_Month_int > 2 ? -3 : 9)) + 19) >> 5) + _Day_int - 1;
+            const int _Doe      = ((1461 * _Yoe) >> 2) - _Yoe / 100 + _Yday_era;
+            return (_Doe + 3) % 7; // the era began on a Wednesday
+        }
+
+    private:
+        _CHRONO year _Year;
+        _CHRONO month _Month;
+        _CHRONO day _Day;
+
+        // _Civil_from_days and _Days_from_civil perform conversions between the dates in the (proleptic) Gregorian
+        // calendar and the continuous count of days since 1970-01-01.
+
+        // To simplify the handling of leap days (February 29th), the algorithm below uses a modified calendar
+        // internally, in which each year begins on March 1st, while January and February belong to the previous year.
+        // We denote the modified year and month number as _Yp and _Mp. We also define modified centuries that begin on
+        // each modified year whose _Yp is a multiple of 100.
+
+        // _Mp | Month     | Day of Year
+        // --- | --------- | -----------
+        //  0  | March     | [  0,  30]
+        //  1  | April     | [ 31,  60]
+        //  2  | May       | [ 61,  91]
+        //  3  | June      | [ 92, 121]
+        //  4  | July      | [122, 152]
+        //  5  | August    | [153, 183]
+        //  6  | September | [184, 213]
+        //  7  | October   | [214, 244]
+        //  8  | November  | [245, 274]
+        //  9  | December  | [275, 305]
+        // 10  | January   | [306, 336]
+        // 11  | February  | [337, 365] on leap years, [337, 364] on regular years
+
+        // _Yp |  First Day  | Last Day (inclusive) | Leap Year?
+        // --- | ----------- | -------------------- | ----------
+        //  -4 | -0004-03-01 |     -0003-02-28      |     No
+        //  -3 | -0003-03-01 |     -0002-02-28      |     No
+        //  -2 | -0002-03-01 |     -0001-02-28      |     No
+        //  -1 | -0001-03-01 |      0000-02-29      |     Yes
+        //   0 |  0000-03-01 |      0001-02-28      |     No
+        //   1 |  0001-03-01 |      0002-02-28      |     No
+        //   2 |  0002-03-01 |      0003-02-28      |     No
+        //   3 |  0003-03-01 |      0004-02-29      |     Yes
+
+        // _Century |  First Day  | Last Day (inclusive) | Long Century?
+        // -------- | ----------- | -------------------- | -------------
+        //    -4    | -0400-03-01 |     -0300-02-28      |      No
+        //    -3    | -0300-03-01 |     -0200-02-28      |      No
+        //    -2    | -0200-03-01 |     -0100-02-28      |      No
+        //    -1    | -0100-03-01 |      0000-02-29      |      Yes
+        //     0    |  0000-03-01 |      0100-02-28      |      No
+        //     1    |  0100-03-01 |      0200-02-28      |      No
+        //     2    |  0200-03-01 |      0300-02-28      |      No
+        //     3    |  0300-03-01 |      0400-02-29      |      Yes
+
+        // The structure of the modified calendar:
+        // 1 ) It has a period of 4 centuries.
+        // 2 ) Each calendar period (146097 days) contains 3 regular centuries followed by a long century (36525 days).
+        // 3 ) Each regular century (36524 days) contains 24 regular 4-year spans followed by a short 4-year span.
+        // 3') Each long century (36525 days) contains 25 regular 4-year spans.
+        // 4 ) Each regular 4-year span (1461 days) contains 3 regular years followed by a leap year.
+        // 4') Each short 4-year span (1460 days) contains 4 regular years.
+
+        // Formula 1: Compute _Day_of_year of the first day of month _Mp
+        //
+        //   _Day_of_year = (979 * _Mp + 19) >> 5
+        //
+        // A more well-known formula is 30 * _Mp + floor((3 * _Mp + 2) / 5) or floor((153 * _Mp + 2) / 5), which is used
+        // in Howard Hinnant's paper.
+        //
+        // The formula above returns the same result for all _Mp in [0, 11].
+        // Note that 979 / 2^5 = 30.59375 ~= 30.6 = 153 / 5.
+
+        // Formula 1': Compute _Mp from _Day_of_year
+        //
+        //   _Mp = (535 * _Day_of_year + 333) >> 14
+        //
+        // Howard Hinnant's paper uses floor((5 * _Day_of_year + 2) / 153), the inverse of floor((153 * _Mp + 2) / 5) or
+        // ceil((153 * _Mp - 2) / 5).
+        //
+        // The formula above returns the same result for all _Day_of_year in [0, 365].
+        // Note that 2^14 / 535 = 30.624... ~= 30.6 = 153 / 5.
+
+        // Formula 2: Compute _Zx of the first day of year _Yp, where _Zx is the continuous count of days since
+        // 0000-03-01.
+        //
+        //   _Zx = ((1461 * _Yp) >> 2) - _Century + (_Century >> 2)
+        //
+        // Start with multiplying by the number of days in regular years (365), add one day for the leap year in each
+        // 4-year span, subtract one day for the short 4-year span in each century, and finally add one day for the long
+        // century in each calendar period. This gives us 365 * _Yp + floor(_Yp / 4) - _Century + floor(_Century / 4).
+
+        // Formula 2-1: Compute _Day_of_century of the first day of year _Year_of_century
+        //
+        //   _Day_of_century = (1461 * _Year_of_century) >> 2
+        //
+        // Start with multiplying by the number of days in regular years (365), add one day for the leap year in each
+        // 4-year span. This gives us 365 * _Year_of_century + floor(_Year_of_century / 4)
+        // == floor(1461 * _Year_of_century / 4).
+
+        // Formula 2-1': Compute _Year_of_century from _Day_of_century
+        //
+        //   _Year_of_century = (91867 * (_Day_of_century + 1)) >> 25
+        //
+        // The inverse of floor(1461 * _Year_of_century / 4) or ceil((1461 * _Year_of_century - 3) / 4) is
+        // floor((4 * _Day_of_century + 3) / 1461).
+        //
+        // The formula above returns the same result for all _Day_of_century in [0, 36524].
+        // Note that 2^25 / 91867 = 365.2501... ~= 365.25 = 1461 / 4.
+
+        // Formula 2-2: Compute _Zx of the first day of century _Century, where _Zx is the continuous count of days
+        // since 0000-03-01.
+        //
+        //   _Zx = (146097 * _Century) >> 2
+        //
+        // Start with multiplying by the number of days in regular centuries (36524), add one day for the long century
+        // in each calendar period. This gives us 36524 * _Century + floor(_Century / 4) = floor(146097 * _Century / 4).
+
+        // Formula 2-2': Compute _Century from _Zx, where _Zx is the continuous count of days since 0000-03-01.
+        //
+        //   _Century = floor((4 * _Zx + 3) / 146097)
+        //
+        // This is the inverse of floor(146097 * _Year_of_century / 4) or ceil((146097 * _Year_of_century - 3) / 4)
+
+        // courtesy of Howard Hinnant
+        // https://howardhinnant.github.io/date_algorithms.html#civil_from_days
+        _NODISCARD static constexpr year_month_day _Civil_from_days(int _Tp) noexcept {
+            static_assert(numeric_limits<unsigned int>::digits >= 32);
+            static_assert(numeric_limits<int>::digits >= 26);
+            const int _Zx = _Tp + 719468; // Shift epoch to 0000-03-01
+            // Formula 2-2'
+            const int _Century = (_Zx >= 0 ? 4 * _Zx + 3 : 4 * _Zx - 146093) / 146097;
+            // Formula 2-2
+            const unsigned int _Day_of_century =
+                static_cast<unsigned int>(_Zx - ((146097 * _Century) >> 2)); // [0, 36524]
+            // Formula 2-1'
+            const unsigned int _Year_of_century = (91867 * (_Day_of_century + 1)) >> 25; // [0, 99]
+            const int _Yp = static_cast<int>(_Year_of_century) + _Century * 100; // Where March is the first month
+            // Formula 2-1
+            const unsigned int _Day_of_year = _Day_of_century - ((1461 * _Year_of_century) >> 2); // [0, 365]
+            // Formula 1'
+            const unsigned int _Mp = (535 * _Day_of_year + 333) >> 14; // [0, 11]
+            // Formula 1
+            const unsigned int _Day   = _Day_of_year - ((979 * _Mp + 19) >> 5) + 1; // [1, 31]
+            const unsigned int _Month = _Mp + (_Mp < 10 ? 3 : static_cast<unsigned int>(-9)); // [1, 12]
+            return year_month_day{_CHRONO year{_Yp + (_Month <= 2)}, _CHRONO month{_Month}, _CHRONO day{_Day}};
+        }
+        // courtesy of Howard Hinnant
+        // https://howardhinnant.github.io/date_algorithms.html#days_from_civil
+        _NODISCARD constexpr days _Days_from_civil() const noexcept {
+            static_assert(numeric_limits<unsigned int>::digits >= 18);
+            static_assert(numeric_limits<int>::digits >= 26);
+            const unsigned int _Mo = static_cast<unsigned int>(_Month); // [1, 12]
+            const int _Yp          = static_cast<int>(_Year) - (_Mo <= 2);
+            const int _Century     = (_Yp >= 0 ? _Yp : _Yp - 99) / 100;
+            const unsigned int _Mp = _Mo + (_Mo > 2 ? static_cast<unsigned int>(-3) : 9); // [0, 11]
+            // Formula 1
+            const int _Day_of_year = static_cast<int>(((979 * _Mp + 19) >> 5) + static_cast<unsigned int>(_Day)) - 1;
+            // Formula 2
+            return days{((1461 * _Yp) >> 2) - _Century + (_Century >> 2) + _Day_of_year - 719468};
+        }
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const year_month_day& _Left, const year_month_day& _Right) noexcept {
+        return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.day() == _Right.day();
+    }
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+        const year_month_day& _Left, const year_month_day& _Right) noexcept {
+        auto _Comp = _Left.year() <=> _Right.year();
+        if (_Comp != 0) {
+            return _Comp;
+        }
+
+        _Comp = _Left.month() <=> _Right.month();
+        if (_Comp != 0) {
+            return _Comp;
+        }
+
+        return _Left.day() <=> _Right.day();
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept {
+        const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
+        return {_Ym.year(), _Ym.month(), _Left.day()};
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator+(
+        const year_month_day& _Left, const years& _Right) noexcept {
+        return {_Left.year() + _Right, _Left.month(), _Left.day()};
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator+(
+        const years& _Left, const year_month_day& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator-(
+        const year_month_day& _Left, const years& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    template <int>
+    constexpr year_month_day& year_month_day::operator+=(const months& _Months) noexcept {
+        *this = *this + _Months;
+        return *this;
+    }
+    template <int>
+    constexpr year_month_day& year_month_day::operator-=(const months& _Months) noexcept {
+        *this = *this - _Months;
+        return *this;
+    }
+    constexpr year_month_day& year_month_day::operator+=(const years& _Years) noexcept {
+        *this = *this + _Years;
+        return *this;
+    }
+    constexpr year_month_day& year_month_day::operator-=(const years& _Years) noexcept {
+        *this = *this - _Years;
+        return *this;
+    }
+
+    _EXPORT_STD class year_month_day_last {
+    public:
+        constexpr year_month_day_last(const year& _Year_, const month_day_last& _Mdl) noexcept
+            : _Year{_Year_}, _Month_day_last{_Mdl} {}
+
+        template <int = 0>
+        constexpr year_month_day_last& operator+=(const months& _Months) noexcept;
+        template <int = 0>
+        constexpr year_month_day_last& operator-=(const months& _Months) noexcept;
+        constexpr year_month_day_last& operator+=(const years& _Years) noexcept;
+        constexpr year_month_day_last& operator-=(const years& _Years) noexcept;
+
+        _NODISCARD constexpr year year() const noexcept {
+            return _Year;
+        }
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month_day_last.month();
+        }
+        _NODISCARD constexpr month_day_last month_day_last() const noexcept {
+            return _Month_day_last;
+        }
+        _NODISCARD constexpr day day() const noexcept {
+            return _CHRONO _Last_day(year(), month());
+        }
+
+        _NODISCARD constexpr operator sys_days() const noexcept {
+            return sys_days{year_month_day{year(), month(), day()}};
+        }
+        _NODISCARD constexpr explicit operator local_days() const noexcept {
+            return local_days{static_cast<sys_days>(*this).time_since_epoch()};
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Year.ok() && _Month_day_last.ok();
+        }
+
+    private:
+        _CHRONO year _Year;
+        _CHRONO month_day_last _Month_day_last;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept {
+        return _Left.year() == _Right.year() && _Left.month_day_last() == _Right.month_day_last();
+    }
+    _EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+        const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept {
+        const auto _Comp = _Left.year() <=> _Right.year();
+        if (_Comp != 0) {
+            return _Comp;
+        }
+
+        return _Left.month_day_last() <=> _Right.month_day_last();
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_day_last operator+(
+        const year_month_day_last& _Left, const months& _Right) noexcept {
+        const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
+        return {_Ym.year(), month_day_last{_Ym.month()}};
+    }
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_day_last operator+(
+        const months& _Left, const year_month_day_last& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_day_last operator-(
+        const year_month_day_last& _Left, const months& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator+(
+        const year_month_day_last& _Left, const years& _Right) noexcept {
+        return {_Left.year() + _Right, _Left.month_day_last()};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator+(
+        const years& _Left, const year_month_day_last& _Right) noexcept {
+        return _Right + _Left;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator-(
+        const year_month_day_last& _Left, const years& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    template <int>
+    constexpr year_month_day_last& year_month_day_last::operator+=(const months& _Months) noexcept {
+        *this = *this + _Months;
+        return *this;
+    }
+    template <int>
+    constexpr year_month_day_last& year_month_day_last::operator-=(const months& _Months) noexcept {
+        *this = *this - _Months;
+        return *this;
+    }
+    constexpr year_month_day_last& year_month_day_last::operator+=(const years& _Years) noexcept {
+        *this = *this + _Years;
+        return *this;
+    }
+    constexpr year_month_day_last& year_month_day_last::operator-=(const years& _Years) noexcept {
+        *this = *this - _Years;
+        return *this;
+    }
+
+    constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept
+        : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {}
+
+    _EXPORT_STD class year_month_weekday {
+    public:
+        year_month_weekday() = default;
+        constexpr year_month_weekday(const year& _Year_, const month& _Month_, const weekday_indexed& _Wdi) noexcept
+            : _Year{_Year_}, _Month{_Month_}, _Weekday_index{_Wdi} {}
+        constexpr year_month_weekday(const sys_days& _Sys_days) noexcept
+            : year_month_weekday{_Ymwd_from_days(_Sys_days.time_since_epoch())} {}
+        constexpr explicit year_month_weekday(const local_days& _Local_days) noexcept
+            : year_month_weekday{_Ymwd_from_days(_Local_days.time_since_epoch())} {}
+
+        template <int = 0>
+        constexpr year_month_weekday& operator+=(const months& _Months) noexcept;
+        template <int = 0>
+        constexpr year_month_weekday& operator-=(const months& _Months) noexcept;
+        constexpr year_month_weekday& operator+=(const years& _Years) noexcept;
+        constexpr year_month_weekday& operator-=(const years& _Years) noexcept;
+
+        _NODISCARD constexpr year year() const noexcept {
+            return _Year;
+        }
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month;
+        }
+        _NODISCARD constexpr weekday weekday() const noexcept {
+            return _Weekday_index.weekday();
+        }
+        _NODISCARD constexpr unsigned int index() const noexcept {
+            return _Weekday_index.index();
+        }
+        _NODISCARD constexpr weekday_indexed weekday_indexed() const noexcept {
+            return _Weekday_index;
+        }
+
+        _NODISCARD constexpr operator sys_days() const noexcept {
+            const sys_days _First = year_month_day{_Year, _Month, day{1}};
+            const days _Diff      = weekday() - _CHRONO weekday{_First};
+            const days _Days      = _Diff + days{(static_cast<int>(index()) - 1) * 7};
+            return _First + _Days;
+        }
+        _NODISCARD constexpr explicit operator local_days() const noexcept {
+            return local_days{static_cast<sys_days>(*this).time_since_epoch()};
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            if (!_Year.ok() || !_Month.ok() || !_Weekday_index.ok()) {
+                return false;
+            }
+
+            if (_Weekday_index.index() <= 4) {
+                return true;
+            }
+
+            // As index() == 5 is not always valid
+            // Determine the date of the first weekday and check if + days{28} is <= last day of the month
+            const sys_days _First_of_month = year_month_day{_Year, _Month, day{1}};
+            const days _First_weekday      = weekday() - _CHRONO weekday{_First_of_month} + days{1};
+            const days _Last               = _First_weekday + days{28};
+            return static_cast<unsigned int>(_Last.count())
+                <= static_cast<unsigned int>(_CHRONO _Last_day(_Year, _Month));
+        }
+
+    private:
+        _CHRONO year _Year;
+        _CHRONO month _Month;
+        _CHRONO weekday_indexed _Weekday_index;
+
+        _NODISCARD static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept {
+            const _CHRONO year_month_day _Ymd = sys_days{_Dp};
+            const _CHRONO weekday _Wd         = sys_days{_Dp};
+            const auto _Idx                   = ((static_cast<unsigned int>(_Ymd.day()) - 1) / 7) + 1;
+            return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]};
+        }
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept {
+        return _Left.year() == _Right.year() && _Left.month() == _Right.month()
+            && _Left.weekday_indexed() == _Right.weekday_indexed();
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept {
+        const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
+        return {_Ym.year(), _Ym.month(), _Left.weekday_indexed()};
+    }
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator+(
+        const year_month_weekday& _Left, const years& _Right) noexcept {
+        return year_month_weekday{_Left.year() + _Right, _Left.month(), _Left.weekday_indexed()};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator+(
+        const years& _Left, const year_month_weekday& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator-(
+        const year_month_weekday& _Left, const years& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    template <int>
+    constexpr year_month_weekday& year_month_weekday::operator+=(const months& _Months) noexcept {
+        *this = *this + _Months;
+        return *this;
+    }
+    template <int>
+    constexpr year_month_weekday& year_month_weekday::operator-=(const months& _Months) noexcept {
+        *this = *this - _Months;
+        return *this;
+    }
+    constexpr year_month_weekday& year_month_weekday::operator+=(const years& _Years) noexcept {
+        *this = *this + _Years;
+        return *this;
+    }
+    constexpr year_month_weekday& year_month_weekday::operator-=(const years& _Years) noexcept {
+        *this = *this - _Years;
+        return *this;
+    }
+
+    _EXPORT_STD class year_month_weekday_last {
+    public:
+        constexpr year_month_weekday_last(const year& _Year_, const month& _Month_, const weekday_last& _Wdl) noexcept
+            : _Year{_Year_}, _Month{_Month_}, _Weekday_last{_Wdl} {}
+
+        template <int = 0>
+        constexpr year_month_weekday_last& operator+=(const months& _Months) noexcept;
+        template <int = 0>
+        constexpr year_month_weekday_last& operator-=(const months& _Months) noexcept;
+        constexpr year_month_weekday_last& operator+=(const years& _Years) noexcept;
+        constexpr year_month_weekday_last& operator-=(const years& _Years) noexcept;
+
+        _NODISCARD constexpr year year() const noexcept {
+            return _Year;
+        }
+        _NODISCARD constexpr month month() const noexcept {
+            return _Month;
+        }
+        _NODISCARD constexpr weekday weekday() const noexcept {
+            return _Weekday_last.weekday();
+        }
+
+        _NODISCARD constexpr weekday_last weekday_last() const noexcept {
+            return _Weekday_last;
+        }
+
+        _NODISCARD constexpr operator sys_days() const noexcept {
+            const sys_days _Last = year_month_day_last{_Year, month_day_last{_Month}};
+            const auto _Diff     = _CHRONO weekday{_Last} - weekday();
+            return _Last - _Diff;
+        }
+        _NODISCARD constexpr explicit operator local_days() const noexcept {
+            return local_days{static_cast<sys_days>(*this).time_since_epoch()};
+        }
+        _NODISCARD constexpr bool ok() const noexcept {
+            return _Year.ok() && _Month.ok() && _Weekday_last.ok();
+        }
+
+    private:
+        _CHRONO year _Year;
+        _CHRONO month _Month;
+        _CHRONO weekday_last _Weekday_last;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool operator==(
+        const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept {
+        return _Left.year() == _Right.year() && _Left.month() == _Right.month()
+            && _Left.weekday_last() == _Right.weekday_last();
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_weekday_last operator+(
+        const year_month_weekday_last& _Left, const months& _Right) noexcept {
+        const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
+        return {_Ym.year(), _Ym.month(), _Left.weekday_last()};
+    }
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_weekday_last operator+(
+        const months& _Left, const year_month_weekday_last& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD template <int = 0>
+    _NODISCARD constexpr year_month_weekday_last operator-(
+        const year_month_weekday_last& _Left, const months& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator+(
+        const year_month_weekday_last& _Left, const years& _Right) noexcept {
+        return {_Left.year() + _Right, _Left.month(), _Left.weekday_last()};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator+(
+        const years& _Left, const year_month_weekday_last& _Right) noexcept {
+        return _Right + _Left;
+    }
+
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator-(
+        const year_month_weekday_last& _Left, const years& _Right) noexcept {
+        return _Left + -_Right;
+    }
+
+    template <int>
+    constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const months& _Months) noexcept {
+        *this = *this + _Months;
+        return *this;
+    }
+    template <int>
+    constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& _Months) noexcept {
+        *this = *this - _Months;
+        return *this;
+    }
+    constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& _Years) noexcept {
+        *this = *this + _Years;
+        return *this;
+    }
+    constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& _Years) noexcept {
+        *this = *this - _Years;
+        return *this;
+    }
+
+    // Civil calendar conventional syntax operators
+    _EXPORT_STD _NODISCARD constexpr year_month operator/(const year& _Year, const month& _Month) noexcept {
+        return {_Year, _Month};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month operator/(const year& _Year, int _Month) noexcept {
+        return _Year / month{static_cast<unsigned int>(_Month)};
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(const month& _Month, const day& _Day) noexcept {
+        return {_Month, _Day};
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(const month& _Month, int _Day) noexcept {
+        return _Month / day{static_cast<unsigned int>(_Day)};
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(int _Month, const day& _Day) noexcept {
+        return month{static_cast<unsigned int>(_Month)} / _Day;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(const day& _Day, const month& _Month) noexcept {
+        return _Month / _Day;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day operator/(const day& _Day, int _Month) noexcept {
+        return month{static_cast<unsigned int>(_Month)} / _Day;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day_last operator/(const month& _Month, last_spec) noexcept {
+        return month_day_last{_Month};
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day_last operator/(int _Month, last_spec) noexcept {
+        return month{static_cast<unsigned int>(_Month)} / last;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day_last operator/(last_spec, const month& _Month) noexcept {
+        return _Month / last;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_day_last operator/(last_spec, int _Month) noexcept {
+        return month{static_cast<unsigned int>(_Month)} / last;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_weekday operator/(
+        const month& _Month, const weekday_indexed& _Wdi) noexcept {
+        return {_Month, _Wdi};
+    }
+    _EXPORT_STD _NODISCARD constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept {
+        return month{static_cast<unsigned int>(_Month)} / _Wdi;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_weekday operator/(
+        const weekday_indexed& _Wdi, const month& _Month) noexcept {
+        return _Month / _Wdi;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept {
+        return month{static_cast<unsigned int>(_Month)} / _Wdi;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_weekday_last operator/(
+        const month& _Month, const weekday_last& _Wdl) noexcept {
+        return {_Month, _Wdl};
+    }
+    _EXPORT_STD _NODISCARD constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept {
+        return month{static_cast<unsigned int>(_Month)} / _Wdl;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_weekday_last operator/(
+        const weekday_last& _Wdl, const month& _Month) noexcept {
+        return _Month / _Wdl;
+    }
+    _EXPORT_STD _NODISCARD constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept {
+        return month{static_cast<unsigned int>(_Month)} / _Wdl;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept {
+        return {_Ym.year(), _Ym.month(), _Day};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept {
+        return _Ym / day{static_cast<unsigned int>(_Day)};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept {
+        return _Year / _Md.month() / _Md.day();
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept {
+        return year{_Year} / _Md.month() / _Md.day();
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept {
+        return _Year / _Md.month() / _Md.day();
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept {
+        return year{_Year} / _Md.month() / _Md.day();
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept {
+        return {_Ym.year(), month_day_last{_Ym.month()}};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(
+        const year& _Year, const month_day_last& _Mdl) noexcept {
+        return {_Year, _Mdl};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept {
+        return year{_Year} / _Mdl;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(
+        const month_day_last& _Mdl, const year& _Year) noexcept {
+        return _Year / _Mdl;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept {
+        return year{_Year} / _Mdl;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(
+        const year_month& _Ym, const weekday_indexed& _Wdi) noexcept {
+        return year_month_weekday{_Ym.year(), _Ym.month(), _Wdi};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(
+        const year& _Year, const month_weekday& _Mwd) noexcept {
+        return year_month_weekday{_Year, _Mwd.month(), _Mwd.weekday_indexed()};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept {
+        return year{_Year} / _Mwd;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(
+        const month_weekday& _Mwd, const year& _Year) noexcept {
+        return _Year / _Mwd;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept {
+        return year{_Year} / _Mwd;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
+        const year_month& _Ym, const weekday_last& _Wdl) noexcept {
+        return {_Ym.year(), _Ym.month(), _Wdl};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
+        const year& _Year, const month_weekday_last& _Mwdl) noexcept {
+        return {_Year, _Mwdl.month(), _Mwdl.weekday_last()};
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
+        int _Year, const month_weekday_last& _Mwdl) noexcept {
+        return year{_Year} / _Mwdl;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
+        const month_weekday_last& _Mwdl, const year& _Year) noexcept {
+        return _Year / _Mwdl;
+    }
+    _EXPORT_STD _NODISCARD constexpr year_month_weekday_last operator/(
+        const month_weekday_last& _Mwdl, int _Year) noexcept {
+        return year{_Year} / _Mwdl;
+    }
+
+    // Calendrical constants
+    _EXPORT_STD inline constexpr weekday Sunday{0};
+    _EXPORT_STD inline constexpr weekday Monday{1};
+    _EXPORT_STD inline constexpr weekday Tuesday{2};
+    _EXPORT_STD inline constexpr weekday Wednesday{3};
+    _EXPORT_STD inline constexpr weekday Thursday{4};
+    _EXPORT_STD inline constexpr weekday Friday{5};
+    _EXPORT_STD inline constexpr weekday Saturday{6};
+
+    _EXPORT_STD inline constexpr month January{1};
+    _EXPORT_STD inline constexpr month February{2};
+    _EXPORT_STD inline constexpr month March{3};
+    _EXPORT_STD inline constexpr month April{4};
+    _EXPORT_STD inline constexpr month May{5};
+    _EXPORT_STD inline constexpr month June{6};
+    _EXPORT_STD inline constexpr month July{7};
+    _EXPORT_STD inline constexpr month August{8};
+    _EXPORT_STD inline constexpr month September{9};
+    _EXPORT_STD inline constexpr month October{10};
+    _EXPORT_STD inline constexpr month November{11};
+    _EXPORT_STD inline constexpr month December{12};
+
+    _NODISCARD constexpr intmax_t _Pow10(const unsigned int _Exp) {
+        intmax_t _Result = 1;
+        for (unsigned int _Ix = 0; _Ix < _Exp; ++_Ix) {
+            _Result *= 10;
+        }
+        return _Result;
+    }
+
+    template <class _To, class _From>
+    constexpr bool _Duration_underflows_with =
+        !treat_as_floating_point_v<typename _From::rep>
+        && _From::period::den / _STD _Gcd(_From::period::den, _To::period::den)
+               > INTMAX_MAX / (_To::period::num / _STD _Gcd(_From::period::num, _To::period::num));
+
+    template <class _To, class _From>
+    _NODISCARD constexpr _To _Duration_cast_underflow_to_zero(const _From& _Dur) {
+        if constexpr (_Duration_underflows_with<_To, _From>) {
+            return _To{};
+        } else {
+            return _CHRONO duration_cast<_To>(_Dur);
+        }
+    }
+
+    template <class _To, class _From>
+    _NODISCARD constexpr common_type_t<_To, _From> _Remove_duration_part(const _From& _Val) {
+        if constexpr (_Duration_underflows_with<_To, _From>) {
+            return _Val;
+        } else {
+            const auto _Dp = _CHRONO duration_cast<_To>(_Val);
+            return _Val - _Dp;
+        }
+    }
+
+    _EXPORT_STD template <class _Duration>
+    class hh_mm_ss {
+    public:
+        static_assert(_Is_duration_v<_Duration>,
+            "N4950 [time.hms.overview]/2 mandates Duration to be a specialization of chrono::duration.");
+
+        static constexpr unsigned int fractional_width = [] {
+            // Returns the number of fractional digits of _Num / _Den in the range [0, 18].
+            // If it can't be represented, 6 is returned.
+            // Example: _Fractional_width(1, 8) would return 3 for 0.125.
+
+            _STL_INTERNAL_STATIC_ASSERT(_Duration::period::num > 0); // N5001 [time.duration.general]/3
+            _STL_INTERNAL_STATIC_ASSERT(_Duration::period::den > 0); // N5001 [ratio.ratio]/1, /2.2
+
+            auto _Den                       = _Duration::period::den;
+            unsigned int _Power_of_2_in_den = 0u;
+            unsigned int _Power_of_5_in_den = 0u;
+            for (; _Den % 2 == 0; _Den /= 2, ++_Power_of_2_in_den) {
+            }
+            for (; _Den % 5 == 0; _Den /= 5, ++_Power_of_5_in_den) {
+            }
+
+            if (_Den != 1) {
+                return 6u;
+            }
+            const auto _Result = (_STD max) (_Power_of_2_in_den, _Power_of_5_in_den);
+            return _Result > 18u ? 6u : _Result;
+        }();
+        using precision =
+            duration<common_type_t<typename _Duration::rep, seconds::rep>, ratio<1, _CHRONO _Pow10(fractional_width)>>;
+
+        constexpr hh_mm_ss() noexcept : hh_mm_ss{_Duration::zero()} {}
+        constexpr explicit hh_mm_ss(_Duration _Dur)
+            : _Is_neg{_Dur < _Duration::zero()},
+              _Hours{_CHRONO _Duration_cast_underflow_to_zero<_CHRONO hours>(_Abs_if_needed(_Dur, _Is_neg))},
+              _Mins{_CHRONO _Duration_cast_underflow_to_zero<_CHRONO minutes>(
+                  _CHRONO _Remove_duration_part<_CHRONO hours>(_Abs_if_needed(_Dur, _Is_neg)))},
+              _Secs{_CHRONO _Duration_cast_underflow_to_zero<_CHRONO seconds>(
+                  _CHRONO _Remove_duration_part<_CHRONO minutes>(
+                      _CHRONO _Remove_duration_part<_CHRONO hours>(_Abs_if_needed(_Dur, _Is_neg))))} {
+            if constexpr (treat_as_floating_point_v<typename precision::rep>) {
+                // no need to deal with underflow here, because floating durations allow it
+                _Sub_secs = _Abs_if_needed(_Dur, _Is_neg) - hours() - minutes() - seconds();
+            } else {
+                _Sub_secs = _CHRONO duration_cast<precision>(
+                    _CHRONO _Remove_duration_part<_CHRONO seconds>(_Abs_if_needed(_Dur, _Is_neg)));
+            }
+        }
+
+        _NODISCARD constexpr bool is_negative() const noexcept {
+            return _Is_neg;
+        }
+        _NODISCARD constexpr hours hours() const noexcept {
+            return _Hours;
+        }
+        _NODISCARD constexpr minutes minutes() const noexcept {
+            return _Mins;
+        }
+        _NODISCARD constexpr seconds seconds() const noexcept {
+            return _Secs;
+        }
+        _NODISCARD constexpr precision subseconds() const noexcept {
+            return _Sub_secs;
+        }
+
+        _NODISCARD constexpr explicit operator precision() const noexcept {
+            return to_duration();
+        }
+        _NODISCARD constexpr precision to_duration() const noexcept {
+            const auto _Dur = _Hours + _Mins + _Secs + _Sub_secs;
+            return _Is_neg ? -_Dur : _Dur;
+        }
+
+    private:
+        _NODISCARD static constexpr _Duration _Abs_if_needed(_Duration _Dur, bool _Is_neg) {
+            if constexpr (is_unsigned_v<typename _Duration::rep>) {
+                return _Dur;
+            } else {
+                return _Is_neg ? -_Dur : _Dur;
+            }
+        }
+
+        bool _Is_neg;
+        _CHRONO hours _Hours;
+        _CHRONO minutes _Mins;
+        _CHRONO seconds _Secs;
+        precision _Sub_secs;
+    };
+
+    _EXPORT_STD _NODISCARD constexpr bool is_am(const hours& _Hours) noexcept {
+        return _Hours >= hours{0} && _Hours <= hours{11};
+    }
+    _EXPORT_STD _NODISCARD constexpr bool is_pm(const hours& _Hours) noexcept {
+        return _Hours >= hours{12} && _Hours <= hours{23};
+    }
+
+    _EXPORT_STD _NODISCARD constexpr hours make12(const hours& _Hours) noexcept {
+        const auto _H_count{_Hours.count()};
+        auto _Ret{_H_count == 0 ? 12 : _H_count};
+        if (_Ret > 12) {
+            _Ret -= 12;
+        }
+
+        return hours{_Ret};
+    }
+    _EXPORT_STD _NODISCARD constexpr hours make24(const hours& _Hours, bool _Is_pm) noexcept {
+        const auto _H_count{_Hours.count()};
+        auto _Ret{_H_count == 12 ? 0 : _H_count};
+        if (_Is_pm) {
+            _Ret += 12;
+        }
+
+        return hours{_Ret};
+    }
+
+    // [time.zone.info]
+
+    _EXPORT_STD struct sys_info {
+        sys_seconds begin;
+        sys_seconds end;
+        seconds offset;
+        minutes save;
+        string abbrev;
+    };
+
+    _EXPORT_STD struct local_info {
+        static constexpr int unique      = 0;
+        static constexpr int nonexistent = 1;
+        static constexpr int ambiguous   = 2;
+
+        int result;
+        sys_info first;
+        sys_info second;
+    };
+
+    _EXPORT_STD class _NODISCARD nonexistent_local_time : public runtime_error {
+    public:
+#if _HAS_EXCEPTIONS
+        template <class _Duration>
+        nonexistent_local_time(const local_time<_Duration>& _Tp, const local_info& _Info)
+            : runtime_error(_Make_string(_Tp, _Info)) {}
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+        template <class _Duration>
+        nonexistent_local_time(const local_time<_Duration>&, const local_info&)
+            : runtime_error("nonexistent local time") {}
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+
+    private:
+        template <class _Duration>
+        _NODISCARD static string _Make_string(const local_time<_Duration>& _Tp, const local_info& _Info);
+    };
+
+    template <class _Duration>
+    [[noreturn]] void _Throw_nonexistent_local_time(const local_time<_Duration>& _Tp, const local_info& _Info) {
+        _THROW(nonexistent_local_time{_Tp, _Info});
+    }
+
+    _EXPORT_STD class _NODISCARD ambiguous_local_time : public runtime_error {
+    public:
+#if _HAS_EXCEPTIONS
+        template <class _Duration>
+        ambiguous_local_time(const local_time<_Duration>& _Tp, const local_info& _Info)
+            : runtime_error(_Make_string(_Tp, _Info)) {}
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+        template <class _Duration>
+        ambiguous_local_time(const local_time<_Duration>&, const local_info&) : runtime_error("ambiguous local time") {}
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+
+    private:
+        template <class _Duration>
+        _NODISCARD static string _Make_string(const local_time<_Duration>& _Tp, const local_info& _Info);
+    };
+
+    template <class _Duration>
+    [[noreturn]] void _Throw_ambiguous_local_time(const local_time<_Duration>& _Tp, const local_info& _Info) {
+        _THROW(ambiguous_local_time{_Tp, _Info});
+    }
+
+    // [time.zone.timezone]
+
+    template <auto& _Get_tzdb_info, class... _Types>
+    _NODISCARD auto _Make_unique_tzdb_info(_Types&&... _Args) {
+        const auto _Raw_ptr = _Get_tzdb_info(_STD forward<_Types>(_Args)...);
+
+        using _Tzdb_info = remove_pointer_t<decltype(_Raw_ptr)>;
+
+        unique_ptr<_Tzdb_info, _Tzdb_deleter<_Tzdb_info>> _Info{_Raw_ptr};
+
+        if (_Info == nullptr) {
+            _STD _Xbad_alloc();
+        } else if (_Info->_Err == __std_tzdb_error::_Win_error) {
+            _STD _XGetLastError();
+        } else if (_Info->_Err == __std_tzdb_error::_Icu_error) {
+            _STD _Xruntime_error("Internal error loading IANA database information");
+        }
+
+        return _Info;
+    }
+
+    _EXPORT_STD enum class choose { earliest, latest };
+
+    struct _Secret_time_zone_construct_tag {
+        explicit _Secret_time_zone_construct_tag() = default;
+    };
+
+    _EXPORT_STD class time_zone {
+    public:
+        explicit time_zone(_Secret_time_zone_construct_tag, string_view _Name_) : _Name(_Name_) {}
+
+        time_zone(time_zone&&)            = default;
+        time_zone& operator=(time_zone&&) = default;
+
+        _NODISCARD string_view name() const noexcept {
+            return _Name;
+        }
+
+        template <class _Duration>
+        _NODISCARD sys_info get_info(const sys_time<_Duration>& _Sys) const {
+            return _Get_info(_Sys.time_since_epoch(), __std_tzdb_sys_info_type::_Full);
+        }
+
+        template <class _Duration>
+        _NODISCARD local_info get_info(const local_time<_Duration>& _Local) const {
+            return _Get_local_info(_Local, __std_tzdb_sys_info_type::_Full);
+        }
+
+        template <class _Duration>
+        _NODISCARD sys_time<common_type_t<_Duration, seconds>> to_sys(const local_time<_Duration>& _Local) const {
+            const auto _Info = get_info(_Local);
+            if (_Info.result == local_info::nonexistent) {
+                _CHRONO _Throw_nonexistent_local_time(_Local, _Info);
+            } else if (_Info.result == local_info::ambiguous) {
+                _CHRONO _Throw_ambiguous_local_time(_Local, _Info);
+            }
+
+            return sys_time<common_type_t<_Duration, seconds>>{_Local.time_since_epoch() - _Info.first.offset};
+        }
+
+        template <class _Duration>
+        _NODISCARD sys_time<common_type_t<_Duration, seconds>> to_sys(
+            const local_time<_Duration>& _Local, const choose _Choose) const {
+            const auto _Info = _Get_local_info(_Local, __std_tzdb_sys_info_type::_Offset_and_range);
+            if (_Info.result == local_info::nonexistent) {
+                return _Info.first.end;
+            }
+
+            const auto _Offset = (_Info.result == local_info::unique || _Choose == choose::earliest)
+                                   ? _Info.first.offset
+                                   : _Info.second.offset;
+            return sys_time<common_type_t<_Duration, seconds>>{_Local.time_since_epoch() - _Offset};
+        }
+
+        template <class _Duration>
+        _NODISCARD local_time<common_type_t<_Duration, seconds>> to_local(const sys_time<_Duration>& _Sys) const {
+            const auto _Info = _Get_info(_Sys.time_since_epoch(), __std_tzdb_sys_info_type::_Offset_only);
+            return local_time<common_type_t<_Duration, seconds>>{_Sys.time_since_epoch() + _Info.offset};
+        }
+
+        static constexpr sys_seconds _Min_seconds{sys_days{(year::min) () / January / 1}};
+        static constexpr sys_seconds _Max_seconds{sys_seconds{sys_days{(year::max) () / December / 32}} - seconds{1}};
+
+    private:
+        template <class _Duration>
+        _NODISCARD sys_info _Get_info(const _Duration& _Dur, __std_tzdb_sys_info_type _Type) const {
+            using _Internal_duration = duration<__std_tzdb_epoch_milli, milli>;
+            const auto _Internal_dur = _CHRONO duration_cast<_Internal_duration>(_Dur);
+
+            // TRANSITION, ABI
+            // Because the signature of __std_tzdb_get_sys_info cannot be changed, _Type is encoded in the
+            // time zone name. In vNext, this should be a dedicated argument.
+            const string _Tz_arg = _Name + static_cast<char>(_Type);
+
+            const auto _Tz_len = _Name.size();
+
+            const auto _Info = _CHRONO _Make_unique_tzdb_info<__std_tzdb_get_sys_info>(
+                _Tz_arg.c_str(), _Tz_len, _Internal_dur.count());
+
+            constexpr auto _Min_internal =
+                _CHRONO duration_cast<_Internal_duration>(_Min_seconds.time_since_epoch()).count();
+            constexpr auto _Max_internal =
+                _CHRONO duration_cast<_Internal_duration>(_Max_seconds.time_since_epoch()).count();
+            const auto _Begin =
+                _Info->_Begin <= _Min_internal
+                    ? _Min_seconds
+                    : sys_seconds{_CHRONO duration_cast<sys_seconds::duration>(_Internal_duration{_Info->_Begin})};
+            const auto _End =
+                _Info->_End >= _Max_internal
+                    ? _Max_seconds
+                    : sys_seconds{_CHRONO duration_cast<sys_seconds::duration>(_Internal_duration{_Info->_End})};
+            return {.begin = _Begin,
+                .end       = _End,
+                .offset    = _CHRONO duration_cast<seconds>(_Internal_duration{_Info->_Offset}),
+                .save      = _CHRONO duration_cast<minutes>(_Internal_duration{_Info->_Save}),
+                .abbrev    = _Info->_Abbrev ? _Info->_Abbrev : ""};
+        }
+
+        template <class _Duration>
+        _NODISCARD local_info _Get_local_info(
+            const local_time<_Duration>& _Local, __std_tzdb_sys_info_type _Type) const {
+            local_info _Info{};
+            const auto _Time_since_ep = _Local.time_since_epoch();
+            _Info.first               = _Get_info(_Time_since_ep, _Type);
+
+            const sys_seconds _Local_sys{_CHRONO duration_cast<sys_seconds::duration>(_Time_since_ep)};
+            const auto _Curr_sys = _Local_sys - _Info.first.offset;
+            if (_Info.first.begin != _Min_seconds && _Curr_sys < _Info.first.begin + days{1}) {
+                // get previous transition information
+                _Info.second = _Get_info((_Info.first.begin - seconds{1}).time_since_epoch(), _Type);
+
+                const auto _Transition = _Info.first.begin;
+                const auto _Prev_sys   = _Local_sys - _Info.second.offset;
+                if (_Curr_sys >= _Transition) {
+                    if (_Prev_sys < _Transition) {
+                        _Info.result = local_info::ambiguous;
+                        _STD swap(_Info.first, _Info.second);
+                    } else {
+                        _Info.result = local_info::unique;
+                        _Info.second = {};
+                    }
+                } else {
+                    if (_Prev_sys >= _Transition) {
+                        _Info.result = local_info::nonexistent;
+                        _STD swap(_Info.first, _Info.second);
+                    } else {
+                        _Info.result = local_info::unique;
+                        _Info.first  = _STD move(_Info.second);
+                        _Info.second = {};
+                    }
+                }
+            } else if (_Info.first.end != _Max_seconds && _Curr_sys > _Info.first.end - days{1}) {
+                // get next transition information
+                _Info.second = _Get_info((_Info.first.end + seconds{1}).time_since_epoch(), _Type);
+
+                const auto _Transition = _Info.first.end;
+                const auto _Next_sys   = _Local_sys - _Info.second.offset;
+                if (_Curr_sys < _Transition) {
+                    if (_Next_sys >= _Transition) {
+                        _Info.result = local_info::ambiguous;
+                    } else {
+                        _Info.result = local_info::unique;
+                        _Info.second = {};
+                    }
+                } else {
+                    if (_Next_sys < _Transition) {
+                        _Info.result = local_info::nonexistent;
+                    } else {
+                        _Info.result = local_info::unique;
+                        _Info.first  = _STD move(_Info.second);
+                        _Info.second = {};
+                    }
+                }
+            } else {
+                // local time is contained inside of first transition boundaries by at least 1 day
+                _Info.result = local_info::unique;
+                _Info.second = {};
+            }
+
+            return _Info;
+        }
+
+        string _Name;
+    };
+
+    _EXPORT_STD _NODISCARD inline bool operator==(const time_zone& _Left, const time_zone& _Right) noexcept {
+        return _Left.name() == _Right.name();
+    }
+
+    _EXPORT_STD _NODISCARD inline strong_ordering operator<=>(
+        const time_zone& _Left, const time_zone& _Right) noexcept {
+        return _Left.name() <=> _Right.name();
+    }
+
+    // [time.zone.leap]
+
+    _EXPORT_STD class leap_second {
+    public:
+        leap_second(const leap_second&)            = default;
+        leap_second& operator=(const leap_second&) = default;
+
+        constexpr leap_second(
+            const sys_seconds& _Date_, const bool _Is_positive_, const seconds& _Prev_elapsed) noexcept
+            : _Date{_Date_}, _Is_positive{_Is_positive_} {
+            _Elapsed_offset = _Prev_elapsed + value();
+        }
+
+        _NODISCARD constexpr sys_seconds date() const noexcept {
+            return _Date;
+        }
+
+        _NODISCARD constexpr seconds value() const noexcept {
+            return _Is_positive ? seconds{1} : seconds{-1};
+        }
+
+        _NODISCARD constexpr bool _Positive() const noexcept {
+            return _Is_positive;
+        }
+
+        _NODISCARD constexpr seconds _Elapsed() const noexcept {
+            return _Elapsed_offset;
+        }
+
+        _NODISCARD friend constexpr bool operator==(const leap_second& _Left, const leap_second& _Right) noexcept {
+            return _Left.date() == _Right.date();
+        }
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator==(
+            const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
+            return _Left.date() == _Right;
+        }
+
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator<(
+            const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
+            return _Left.date() < _Right;
+        }
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator<(
+            const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
+            return _Left < _Right.date();
+        }
+
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator>(
+            const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
+            return _Right < _Left.date();
+        }
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator>(
+            const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
+            return _Right.date() < _Left;
+        }
+
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator<=(
+            const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
+            return !(_Right < _Left.date());
+        }
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator<=(
+            const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
+            return !(_Right.date() < _Left);
+        }
+
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator>=(
+            const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
+            return !(_Left.date() < _Right);
+        }
+        template <class _Duration>
+        _NODISCARD friend constexpr bool operator>=(
+            const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
+            return !(_Left < _Right.date());
+        }
+
+        template <class _Duration>
+            requires three_way_comparable_with<sys_seconds, sys_time<_Duration>>
+        _NODISCARD friend constexpr auto operator<=>(
+            const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
+            return _Left.date() <=> _Right;
+        }
+        _NODISCARD friend constexpr strong_ordering operator<=>(
+            const leap_second& _Left, const leap_second& _Right) noexcept {
+            return _Left.date() <=> _Right.date();
+        }
+
+    private:
+        sys_seconds _Date;
+        bool _Is_positive;
+        seconds _Elapsed_offset;
+    };
+
+    // [time.zone.link]
+
+    struct _Secret_time_zone_link_construct_tag {
+        explicit _Secret_time_zone_link_construct_tag() = default;
+    };
+
+    _EXPORT_STD class time_zone_link {
+    public:
+        explicit time_zone_link(_Secret_time_zone_link_construct_tag, string_view _Name_, string_view _Target_)
+            : _Name(_Name_), _Target(_Target_) {}
+
+        time_zone_link(time_zone_link&&)            = default;
+        time_zone_link& operator=(time_zone_link&&) = default;
+
+        _NODISCARD string_view name() const noexcept {
+            return _Name;
+        }
+
+        _NODISCARD string_view target() const noexcept {
+            return _Target;
+        }
+
+    private:
+        string _Name;
+        string _Target;
+    };
+
+    _EXPORT_STD _NODISCARD inline bool operator==(const time_zone_link& _Left, const time_zone_link& _Right) noexcept {
+        return _Left.name() == _Right.name();
+    }
+
+    _EXPORT_STD _NODISCARD inline strong_ordering operator<=>(
+        const time_zone_link& _Left, const time_zone_link& _Right) noexcept {
+        return _Left.name() <=> _Right.name();
+    }
+
+    // [time.zone.db]
+
+    _NODISCARD inline string _Tzdb_generate_current_zone() {
+        auto _Info = _CHRONO _Make_unique_tzdb_info<__std_tzdb_get_current_zone>();
+
+        return _Info->_Tz_name;
+    }
+
+    template <class _Ty>
+    _NODISCARD const _Ty* _Locate_zone_impl(const vector<_Ty>& _Vec, string_view _Name) {
+        // N5008 [time.zone.db.tzdb]/1: "Each vector in a tzdb object is sorted to enable fast lookup."
+        const auto _Result = _STD lower_bound(
+            _Vec.begin(), _Vec.end(), _Name, [](const auto& _Tz, const auto& _Sv) static { return _Tz.name() < _Sv; });
+        if (_Result != _Vec.end() && _Result->name() == _Name) {
+            return &*_Result;
+        } else {
+            return nullptr;
+        }
+    }
+
+    _EXPORT_STD struct tzdb {
+        string version;
+        vector<time_zone> zones;
+        vector<time_zone_link> links;
+        vector<leap_second> leap_seconds;
+        bool _All_ls_positive;
+
+        _NODISCARD const time_zone* locate_zone(string_view _Tz_name) const {
+            auto _Tz = _CHRONO _Locate_zone_impl(zones, _Tz_name);
+            if (_Tz != nullptr) {
+                return _Tz;
+            }
+
+            const auto _Link = _CHRONO _Locate_zone_impl(links, _Tz_name);
+            if (_Link != nullptr) {
+                _Tz = _CHRONO _Locate_zone_impl(zones, _Link->target());
+                if (_Tz != nullptr) {
+                    return _Tz;
+                }
+            }
+
+            _STD _Xruntime_error("unable to locate time_zone with given name");
+        }
+
+        _NODISCARD const time_zone* current_zone() const {
+            return locate_zone(_CHRONO _Tzdb_generate_current_zone());
+        }
+    };
+
+    _NODISCARD inline tuple<string, vector<time_zone>, vector<time_zone_link>> _Tzdb_generate_time_zones() {
+        auto _Info = _CHRONO _Make_unique_tzdb_info<__std_tzdb_get_time_zones>();
+
+        vector<time_zone> _Time_zones;
+        vector<time_zone_link> _Time_zone_links;
+        for (size_t _Idx = 0; _Idx < _Info->_Num_time_zones; ++_Idx) {
+            const string_view _Name{_Info->_Names[_Idx]};
+            if (_Info->_Links[_Idx] == nullptr) {
+                _Time_zones.emplace_back(_Secret_time_zone_construct_tag{}, _Name);
+            } else {
+                const string_view _Target{_Info->_Links[_Idx]};
+                _Time_zone_links.emplace_back(_Secret_time_zone_link_construct_tag{}, _Name, _Target);
+            }
+        }
+
+        return {_Info->_Version, _STD move(_Time_zones), _STD move(_Time_zone_links)};
+    }
+
+    _NODISCARD inline pair<vector<leap_second>, bool> _Tzdb_generate_leap_seconds(const size_t _Current_size) {
+        // Returns empty vector if no new leap seconds are found.
+        static constexpr leap_second _Known_leap_seconds[]{
+            {sys_seconds{seconds{78796800}}, true, seconds{0}},
+            {sys_seconds{seconds{94694400}}, true, seconds{1}},
+            {sys_seconds{seconds{126230400}}, true, seconds{2}},
+            {sys_seconds{seconds{157766400}}, true, seconds{3}},
+            {sys_seconds{seconds{189302400}}, true, seconds{4}},
+            {sys_seconds{seconds{220924800}}, true, seconds{5}},
+            {sys_seconds{seconds{252460800}}, true, seconds{6}},
+            {sys_seconds{seconds{283996800}}, true, seconds{7}},
+            {sys_seconds{seconds{315532800}}, true, seconds{8}},
+            {sys_seconds{seconds{362793600}}, true, seconds{9}},
+            {sys_seconds{seconds{394329600}}, true, seconds{10}},
+            {sys_seconds{seconds{425865600}}, true, seconds{11}},
+            {sys_seconds{seconds{489024000}}, true, seconds{12}},
+            {sys_seconds{seconds{567993600}}, true, seconds{13}},
+            {sys_seconds{seconds{631152000}}, true, seconds{14}},
+            {sys_seconds{seconds{662688000}}, true, seconds{15}},
+            {sys_seconds{seconds{709948800}}, true, seconds{16}},
+            {sys_seconds{seconds{741484800}}, true, seconds{17}},
+            {sys_seconds{seconds{773020800}}, true, seconds{18}},
+            {sys_seconds{seconds{820454400}}, true, seconds{19}},
+            {sys_seconds{seconds{867715200}}, true, seconds{20}},
+            {sys_seconds{seconds{915148800}}, true, seconds{21}},
+            {sys_seconds{seconds{1136073600}}, true, seconds{22}},
+            {sys_seconds{seconds{1230768000}}, true, seconds{23}},
+            {sys_seconds{seconds{1341100800}}, true, seconds{24}},
+            {sys_seconds{seconds{1435708800}}, true, seconds{25}},
+            {sys_seconds{seconds{1483228800}}, true, seconds{26}},
+        };
+
+        // __std_tzdb_get_leap_seconds gets leap second (LS) data from the registry, but only if it contains more
+        // LSs than we already know about. The registry only contains LSs after 2018, so we need to tell it how many of
+        // *those* we already know about. The *total* number of LSs known at this point is a combination of what the
+        // caller knows (_Current_size, 0 on first call) and the _Known_leap_seconds entries.
+        constexpr size_t _Pre_2018_count = 27;
+        const size_t _Known_post_2018_ls_size =
+            (_STD max) (_Current_size, _STD size(_Known_leap_seconds)) - _Pre_2018_count;
+
+        size_t _Reg_post_2018_ls_size; // number of post-2018 LSs found in the registry
+        unique_ptr<__std_tzdb_leap_info[], _Tzdb_deleter<__std_tzdb_leap_info[]>> _Reg_ls_data{
+            ::__std_tzdb_get_leap_seconds(_Known_post_2018_ls_size, &_Reg_post_2018_ls_size)};
+
+        if (_Reg_post_2018_ls_size > _Known_post_2018_ls_size && !_Reg_ls_data) {
+            _STD _Xbad_alloc(); // registry has new data, but failed to allocate storage
+        } else if (_Reg_post_2018_ls_size == 0 && _Reg_ls_data) {
+            _STD _XGetLastError(); // allocated storage for registry data, but failed to read
+        }
+
+        const size_t _New_size = _Pre_2018_count + _Reg_post_2018_ls_size; // total size with registry data
+        vector<leap_second> _Leap_sec_info;
+        bool _All_ls_positive = true;
+
+        if (_New_size > _Current_size) {
+            _Leap_sec_info.reserve(_New_size);
+            _Leap_sec_info.assign(_STD cbegin(_Known_leap_seconds), _STD cend(_Known_leap_seconds));
+
+            for (size_t _Idx = 0; _Idx < _Reg_post_2018_ls_size; ++_Idx) {
+                // Leap seconds occur at _Ls._Hour:59:59. We store the next second after, so we need to add an entire
+                // hour.
+                const auto& _Ls = _Reg_ls_data[_Idx];
+                const auto _Date =
+                    static_cast<sys_days>(year_month_day{year{_Ls._Year}, month{_Ls._Month}, day{_Ls._Day}})
+                    + hours{_Ls._Hour + 1};
+                _Leap_sec_info.emplace_back(_Date, !_Ls._Negative, _Leap_sec_info.back()._Elapsed());
+                _All_ls_positive = _All_ls_positive && !_Ls._Negative;
+            }
+        }
+
+        return {_STD move(_Leap_sec_info), _All_ls_positive};
+    }
+
+    _NODISCARD inline string _Tzdb_update_version(const string_view _Version, const size_t _Num_leap_seconds) {
+        string _Icu_version{_Version.substr(0, _Version.find_last_of('.'))};
+        _Icu_version += '.';
+        _Icu_version += _STD to_string(_Num_leap_seconds);
+        return _Icu_version;
+    }
+
+    struct _Secret_tzdb_list_construct_tag {
+        explicit _Secret_tzdb_list_construct_tag() = default;
+    };
+
+    _EXPORT_STD class tzdb_list {
+    private:
+        using _ListType = forward_list<tzdb, _Crt_allocator<tzdb>>;
+
+    public:
+        using const_iterator = _ListType::const_iterator;
+
+        tzdb_list(const tzdb_list&)            = delete;
+        tzdb_list& operator=(const tzdb_list&) = delete;
+
+        explicit tzdb_list(_Secret_tzdb_list_construct_tag) {
+            auto [_Icu_version, _Zones, _Links] = _CHRONO _Tzdb_generate_time_zones();
+            auto [_Leap_sec, _All_ls_positive]  = _CHRONO _Tzdb_generate_leap_seconds(0);
+            auto _Version                       = _Icu_version + "." + _STD to_string(_Leap_sec.size());
+            _Tzdb_list.emplace_front(
+                _STD move(_Version), _STD move(_Zones), _STD move(_Links), _STD move(_Leap_sec), _All_ls_positive);
+        }
+
+        _NODISCARD const tzdb& front() const noexcept {
+            _Shared_lock _Lk(_Tzdb_mutex);
+            return _Tzdb_list.front();
+        }
+
+        const_iterator erase_after(const_iterator _Where) noexcept /* strengthened */ {
+            _Unique_lock _Lk(_Tzdb_mutex);
+            return _Tzdb_list.erase_after(_Where);
+        }
+
+        _NODISCARD const_iterator begin() const noexcept {
+            _Shared_lock _Lk(_Tzdb_mutex);
+            return _Tzdb_list.begin();
+        }
+
+        _NODISCARD const_iterator end() const noexcept {
+            return _Tzdb_list.end(); // no lock necessary for forward_list::end()
+        }
+
+        _NODISCARD const_iterator cbegin() const noexcept {
+            _Shared_lock _Lk(_Tzdb_mutex);
+            return _Tzdb_list.cbegin();
+        }
+
+        _NODISCARD const_iterator cend() const noexcept {
+            return _Tzdb_list.cend(); // no lock necessary for forward_list::cend()
+        }
+
+        template <class... _ArgsTy>
+        void _Emplace_front(_ArgsTy&&... _Args) {
+            _Unique_lock _Lk(_Tzdb_mutex);
+            _Tzdb_list.emplace_front(_STD forward<_ArgsTy>(_Args)...);
+        }
+
+        const tzdb& _Reload() {
+            _Unique_lock _Lk(_Tzdb_mutex);
+            auto [_Leap_sec, _All_ls_positive] =
+                _CHRONO _Tzdb_generate_leap_seconds(_Tzdb_list.front().leap_seconds.size());
+            if (!_Leap_sec.empty()) {
+                const auto& _Tzdb = _Tzdb_list.front();
+
+                vector<time_zone> _Zones;
+                _Zones.reserve(_Tzdb.zones.size());
+                for (const auto& _Tz : _Tzdb.zones) {
+                    _Zones.emplace_back(_Secret_time_zone_construct_tag{}, _Tz.name());
+                }
+
+                vector<time_zone_link> _Links;
+                _Links.reserve(_Tzdb.links.size());
+                for (const auto& _Link : _Tzdb.links) {
+                    _Links.emplace_back(_Secret_time_zone_link_construct_tag{}, _Link.name(), _Link.target());
+                }
+
+                auto _Version = _CHRONO _Tzdb_update_version(_Tzdb.version, _Leap_sec.size());
+                _Tzdb_list.emplace_front(
+                    _STD move(_Version), _STD move(_Zones), _STD move(_Links), _STD move(_Leap_sec), _All_ls_positive);
+            }
+            return _Tzdb_list.front();
+        }
+
+    private:
+        _ListType _Tzdb_list;
+        mutable _Smtx_t _Tzdb_mutex = {};
+
+        struct _NODISCARD _Shared_lock {
+            explicit _Shared_lock(_Smtx_t& _Mtx_) : _Mtx{&_Mtx_} {
+                ::_Smtx_lock_shared(_Mtx);
+            }
+
+            _Shared_lock(const _Shared_lock&)            = delete;
+            _Shared_lock& operator=(const _Shared_lock&) = delete;
+
+            ~_Shared_lock() {
+                ::_Smtx_unlock_shared(_Mtx);
+            }
+
+            _Smtx_t* _Mtx;
+        };
+
+        struct _NODISCARD _Unique_lock {
+            explicit _Unique_lock(_Smtx_t& _Mtx_) : _Mtx{&_Mtx_} {
+                ::_Smtx_lock_exclusive(_Mtx);
+            }
+
+            _Unique_lock(const _Unique_lock&)            = delete;
+            _Unique_lock& operator=(const _Unique_lock&) = delete;
+
+            ~_Unique_lock() {
+                ::_Smtx_unlock_exclusive(_Mtx);
+            }
+
+            _Smtx_t* _Mtx;
+        };
+    };
+
+    inline atomic<tzdb_list*> _Global_tzdb_list;
+
+    _EXPORT_STD _NODISCARD inline tzdb_list& get_tzdb_list() {
+        auto _Tzdb_ptr = _Global_tzdb_list.load();
+        if (_Tzdb_ptr != nullptr) {
+            return *_Tzdb_ptr;
+        }
+
+        auto _My_tzdb = static_cast<tzdb_list*>(::__std_calloc_crt(1, sizeof(tzdb_list)));
+        if (_My_tzdb == nullptr) {
+            _STD _Xruntime_error("bad allocation"); // not bad_alloc, see N4950 [time.zone.db.access]/4
+        }
+
+        _TRY_BEGIN
+        _STD construct_at(_My_tzdb, _Secret_tzdb_list_construct_tag{});
+        _CATCH(const runtime_error&)
+        ::__std_free_crt(_My_tzdb);
+        _RERAISE;
+        _CATCH(const exception& _Except)
+#if _HAS_EXCEPTIONS
+        ::__std_free_crt(_My_tzdb);
+        _STD _Xruntime_error(_Except.what());
+#endif // _HAS_EXCEPTIONS
+        _CATCH_END
+
+        if (_Global_tzdb_list.compare_exchange_strong(_Tzdb_ptr, _My_tzdb)) {
+            _Tzdb_ptr = _My_tzdb;
+        } else {
+            _STD destroy_at(_My_tzdb);
+            ::__std_free_crt(_My_tzdb);
+        }
+
+        return *_Tzdb_ptr;
+    }
+
+    _EXPORT_STD _NODISCARD inline const tzdb& get_tzdb() {
+        return _CHRONO get_tzdb_list().front();
+    }
+
+    _EXPORT_STD _NODISCARD inline const time_zone* locate_zone(string_view _Tz_name) {
+        return _CHRONO get_tzdb().locate_zone(_Tz_name);
+    }
+
+    _EXPORT_STD _NODISCARD inline const time_zone* current_zone() {
+        return _CHRONO get_tzdb().current_zone();
+    }
+
+    _EXPORT_STD inline const tzdb& reload_tzdb() {
+        _TRY_BEGIN
+        return _CHRONO get_tzdb_list()._Reload();
+        _CATCH(const runtime_error&)
+        _RERAISE;
+        _CATCH(const exception& _Except)
+#if _HAS_EXCEPTIONS
+        _STD _Xruntime_error(_Except.what());
+#endif // _HAS_EXCEPTIONS
+        _CATCH_END
+    }
+
+    _EXPORT_STD _NODISCARD inline string remote_version() {
+        const auto& _Tzdb                = _CHRONO get_tzdb();
+        const auto& _Version             = _Tzdb.version;
+        const auto [_Leap_sec, _Ignored] = _CHRONO _Tzdb_generate_leap_seconds(_Tzdb.leap_seconds.size());
+        return _Leap_sec.empty() ? _Version : _CHRONO _Tzdb_update_version(_Version, _Leap_sec.size());
+    }
+
+    // [time.zone.zonedtraits]
+
+    _EXPORT_STD template <class _Ty>
+    struct zoned_traits {};
+
+    template <>
+    struct zoned_traits<const time_zone*> {
+        _NODISCARD static const time_zone* default_zone() {
+            return _CHRONO get_tzdb().locate_zone("UTC");
+        }
+
+        _NODISCARD static const time_zone* locate_zone(string_view _Name) {
+            return _CHRONO get_tzdb().locate_zone(_Name);
+        }
+    };
+
+    // [time.zone.zonedtime]
+
+    _EXPORT_STD template <class _Duration, class _TimeZonePtr = const time_zone*>
+    class zoned_time {
+    private:
+        static_assert(_Is_duration_v<_Duration>,
+            "N4950 [time.zone.zonedtime.overview]/2 mandates Duration to be a specialization of chrono::duration.");
+
+        using _Traits = zoned_traits<_TimeZonePtr>;
+
+    public:
+        using duration = common_type_t<_Duration, seconds>;
+
+        zoned_time()
+            requires requires { _Traits::default_zone(); }
+            : _Zone{_Traits::default_zone()} {}
+
+        zoned_time(const zoned_time&)            = default;
+        zoned_time& operator=(const zoned_time&) = default;
+
+        zoned_time(const sys_time<_Duration>& _Sys)
+            requires requires { _Traits::default_zone(); }
+            : _Zone{_Traits::default_zone()}, _Tp{_Sys} {}
+
+        explicit zoned_time(_TimeZonePtr _Tz) noexcept /* strengthened */ : _Zone{_STD move(_Tz)} {}
+
+        explicit zoned_time(string_view _Name)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+            }
+            : _Zone{_Traits::locate_zone(_Name)} {}
+
+        template <class _Duration2>
+            requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+        zoned_time(const zoned_time<_Duration2, _TimeZonePtr>& _Zt) noexcept /* strengthened */
+            : _Zone{_Zt.get_time_zone()}, _Tp{_Zt.get_sys_time()} {}
+
+        zoned_time(_TimeZonePtr _Tz, const sys_time<_Duration>& _Sys) : _Zone{_STD move(_Tz)}, _Tp{_Sys} {}
+
+        zoned_time(string_view _Name, type_identity_t<const sys_time<_Duration>&> _Sys)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+            }
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Sys} {}
+
+        zoned_time(_TimeZonePtr _Tz, const local_time<_Duration>& _Local)
+            requires requires {
+                { _Tz->to_sys(_Local) } -> convertible_to<sys_time<duration>>;
+            }
+            : _Zone{_STD move(_Tz)}, _Tp{_Zone->to_sys(_Local)} {}
+
+        zoned_time(string_view _Name, type_identity_t<const local_time<_Duration>&> _Local)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+                { _STD declval<_TimeZonePtr&>() -> to_sys(_Local) } -> convertible_to<sys_time<duration>>;
+            }
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Zone->to_sys(_Local)} {}
+
+        zoned_time(_TimeZonePtr _Tz, const local_time<_Duration>& _Local, choose _Choose)
+            requires requires {
+                { _Tz->to_sys(_Local, _Choose) } -> convertible_to<sys_time<duration>>;
+            }
+            : _Zone{_STD move(_Tz)}, _Tp{_Zone->to_sys(_Local, _Choose)} {}
+
+        zoned_time(string_view _Name, type_identity_t<const local_time<_Duration>&> _Local, choose _Choose)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+                { _STD declval<_TimeZonePtr&>() -> to_sys(_Local, _Choose) } -> convertible_to<sys_time<duration>>;
+            }
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Zone->to_sys(_Local, _Choose)} {}
+
+        template <class _Duration2, class _TimeZonePtr2>
+            requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+        zoned_time(_TimeZonePtr _Tz, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt) noexcept /* strengthened */
+            : _Zone{_STD move(_Tz)}, _Tp{_Zt.get_sys_time()} {}
+
+        template <class _Duration2, class _TimeZonePtr2>
+            requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+        zoned_time(
+            _TimeZonePtr _Tz, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt, choose) noexcept /* strengthened */
+            : _Zone{_STD move(_Tz)}, _Tp{_Zt.get_sys_time()} {}
+
+        template <class _Duration2, class _TimeZonePtr2>
+        zoned_time(string_view _Name, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+            } && is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Zt.get_sys_time()} {}
+
+        template <class _Duration2, class _TimeZonePtr2>
+        zoned_time(string_view _Name, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt, choose)
+            requires requires {
+                { _Traits::locate_zone(_Name) } -> convertible_to<_TimeZonePtr>;
+            } && is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+            : _Zone{_Traits::locate_zone(_Name)}, _Tp{_Zt.get_sys_time()} {}
+
+        zoned_time& operator=(const sys_time<_Duration>& _Sys) noexcept /* strengthened */ {
+            _Tp = _Sys;
+            return *this;
+        }
+
+        zoned_time& operator=(const local_time<_Duration>& _Local) {
+            _Tp = _Zone->to_sys(_Local);
+            return *this;
+        }
+
+        operator sys_time<duration>() const noexcept /* strengthened */ {
+            return get_sys_time();
+        }
+
+        explicit operator local_time<duration>() const {
+            return get_local_time();
+        }
+
+        _NODISCARD _TimeZonePtr get_time_zone() const noexcept /* strengthened */ {
+            return _Zone;
+        }
+
+        _NODISCARD local_time<duration> get_local_time() const {
+            return _Zone->to_local(_Tp);
+        }
+
+        _NODISCARD sys_time<duration> get_sys_time() const noexcept /* strengthened */ {
+            return _Tp;
+        }
+
+        _NODISCARD sys_info get_info() const {
+            return _Zone->get_info(_Tp);
+        }
+
+    private:
+        _TimeZonePtr _Zone;
+        sys_time<duration> _Tp{};
+    };
+
+    zoned_time() -> zoned_time<seconds>;
+
+    template <class _Duration>
+    zoned_time(sys_time<_Duration>) -> zoned_time<common_type_t<_Duration, seconds>>;
+
+    template <class _TimeZonePtrOrName>
+    using _Time_zone_representation = conditional_t<is_convertible_v<_TimeZonePtrOrName, string_view>, const time_zone*,
+        remove_cvref_t<_TimeZonePtrOrName>>;
+
+    template <class _TimeZonePtrOrName>
+    zoned_time(_TimeZonePtrOrName&&) -> zoned_time<seconds, _Time_zone_representation<_TimeZonePtrOrName>>;
+
+    template <class _TimeZonePtrOrName, class _Duration>
+    zoned_time(_TimeZonePtrOrName&&, sys_time<_Duration>)
+        -> zoned_time<common_type_t<_Duration, seconds>, _Time_zone_representation<_TimeZonePtrOrName>>;
+
+    template <class _TimeZonePtrOrName, class _Duration>
+    zoned_time(_TimeZonePtrOrName&&, local_time<_Duration>, choose = choose::earliest)
+        -> zoned_time<common_type_t<_Duration, seconds>, _Time_zone_representation<_TimeZonePtrOrName>>;
+
+    template <class _Duration, class _TimeZonePtrOrName, class _TimeZonePtr2>
+    zoned_time(_TimeZonePtrOrName&&, zoned_time<_Duration, _TimeZonePtr2>, choose = choose::earliest)
+        -> zoned_time<common_type_t<_Duration, seconds>, _Time_zone_representation<_TimeZonePtrOrName>>;
+
+    _EXPORT_STD using zoned_seconds = zoned_time<seconds>;
+
+    _EXPORT_STD template <class _Duration1, class _Duration2, class _TimeZonePtr>
+    _NODISCARD bool operator==(
+        const zoned_time<_Duration1, _TimeZonePtr>& _Left, const zoned_time<_Duration2, _TimeZonePtr>& _Right) {
+        return _Left.get_time_zone() == _Right.get_time_zone() && _Left.get_sys_time() == _Right.get_sys_time();
+    }
+
+    // [time.clock.utc]
+
+    _EXPORT_STD class utc_clock;
+    _EXPORT_STD template <class _Duration>
+    using utc_time                = time_point<utc_clock, _Duration>;
+    _EXPORT_STD using utc_seconds = utc_time<seconds>;
+
+    _EXPORT_STD struct leap_second_info {
+        bool is_leap_second;
+        seconds elapsed;
+    };
+
+    _EXPORT_STD template <class _Duration>
+    _NODISCARD leap_second_info get_leap_second_info(const utc_time<_Duration>& _Time) {
+        const utc_seconds _Time_floor = _CHRONO floor<seconds>(_Time);
+        const auto& _Tzdb             = _CHRONO get_tzdb();
+        const auto& _Ls_vector        = _Tzdb.leap_seconds;
+
+        // Find first leap second after _Time.
+        vector<leap_second>::const_iterator _It;
+        if (_Tzdb._All_ls_positive) {
+            // Where "target_ls" is the next leap second at or after _Time, _It either points to:
+            //    (1) The 2nd leap second after _Time if _Time_floor is in the range [target_ls - _Elapsed() - 1,
+            //    target_ls), or
+            //    (2) The leap second just after _Time otherwise.
+            // Note that we can always use prev(_It) to determine whether _Time is *during* a leap second insertion,
+            // since that falls under case (2) above. However, when we fall under case (1), we need to execute an
+            // additional decrement to get the correct elapsed offset. For example, if leap seconds are inserted at
+            // seconds {100, 200, 300, 400}, we have:
+            //
+            //  UTC   sys   *_It
+            //   99    99    100
+            //  100     X    200
+            //  101   100    200
+            //  102   101    200
+            //  ...
+            //  199   198    200
+            //  200   199    300^
+            //  201     X    300
+            //  202   200    300
+            //  ...
+            //  299   297    300
+            //  300   298    400^
+            //  301   299    400^
+            //  302     X    400
+            //  303   300    400
+            //
+            //  ^_It points to 2nd leap second
+
+            _It = _STD upper_bound(_Ls_vector.begin(), _Ls_vector.end(), sys_seconds{_Time_floor.time_since_epoch()});
+        } else {
+            seconds _Prev_elapsed{0};
+            for (_It = _Ls_vector.begin(); _It != _Ls_vector.end(); ++_It) {
+                // UTC time when leap second insertion begins. In all cases, _It->date() + _It->_Elapsed() is the *end*
+                // of the insertion. For a negative leap that's also the beginning, but for a positive one, insertion
+                // begins 1 second earlier.
+                const utc_seconds _This_ls_begin{
+                    _It->date().time_since_epoch() + (_It->_Positive() ? _Prev_elapsed : _It->_Elapsed())};
+                if (_This_ls_begin > _Time_floor) {
+                    break;
+                }
+                _Prev_elapsed = _It->_Elapsed();
+            }
+        }
+
+        if (_It == _Ls_vector.begin()) {
+            return {false, seconds{0}};
+        } else {
+            // Convert to the last leap second before or equal to _Time.
+            const auto& _Last_leap = *--_It;
+            const utc_seconds _Utc_leap_second{_Last_leap.date().time_since_epoch() + _It->_Elapsed() - seconds{1}};
+            const auto _Leap_cmp = _Utc_leap_second <=> _Time_floor;
+            if (_Tzdb._All_ls_positive && _STD is_gt(_Leap_cmp)) { // Case (1)
+                --_It;
+            }
+            return {_Last_leap._Positive() && _STD is_eq(_Leap_cmp), _It->_Elapsed()};
+        }
+    }
+
+    _EXPORT_STD class utc_clock {
+    public:
+        using rep                       = system_clock::rep;
+        using period                    = system_clock::period;
+        using duration                  = _CHRONO duration<rep, period>;
+        using time_point                = _CHRONO time_point<utc_clock>;
+        static constexpr bool is_steady = system_clock::is_steady;
+
+        _NODISCARD static time_point now() {
+            return from_sys(system_clock::now());
+        }
+
+        template <class _Duration>
+        _NODISCARD static sys_time<common_type_t<_Duration, seconds>> to_sys(const utc_time<_Duration>& _Utc_time) {
+            using _CommonType = common_type_t<_Duration, seconds>;
+            const auto _Lsi{_CHRONO get_leap_second_info(_Utc_time)};
+            _CommonType _Ticks;
+            if (_Lsi.is_leap_second) {
+                const auto _Leap_sec_minus_one = _CHRONO floor<seconds>(_Utc_time.time_since_epoch()) - _Lsi.elapsed;
+                if constexpr (is_integral_v<typename _Duration::rep>) {
+                    constexpr auto _Delta{seconds{1} - _CommonType{1}};
+                    _Ticks = _Leap_sec_minus_one + _Delta;
+                } else {
+                    const auto _Leap_sec_begin = _CHRONO ceil<_CommonType>(_Leap_sec_minus_one + seconds{1});
+                    _Ticks = _CommonType{_STD nextafter(_Leap_sec_begin.count(), typename _CommonType::rep{0})};
+                }
+            } else {
+                _Ticks = _Utc_time.time_since_epoch() - _Lsi.elapsed;
+            }
+            return sys_time<_CommonType>{_Ticks};
+        }
+
+        template <class _Duration>
+        _NODISCARD static utc_time<common_type_t<_Duration, seconds>> from_sys(const sys_time<_Duration>& _Sys_time) {
+            const auto& _Tzdb      = _CHRONO get_tzdb();
+            const auto& _Ls_vector = _Tzdb.leap_seconds;
+            auto _It = _STD upper_bound(_Ls_vector.begin(), _Ls_vector.end(), _CHRONO floor<seconds>(_Sys_time));
+            const auto _Offset = _It == _Ls_vector.begin() ? seconds{0} : (--_It)->_Elapsed();
+            return utc_time<common_type_t<_Duration, seconds>>{_Sys_time.time_since_epoch() + _Offset};
+        }
+    };
+
+    // [time.clock.tai]
+
+    _EXPORT_STD class tai_clock;
+
+    _EXPORT_STD template <class _Duration>
+    using tai_time                = time_point<tai_clock, _Duration>;
+    _EXPORT_STD using tai_seconds = tai_time<seconds>;
+
+    _EXPORT_STD class tai_clock {
+    public:
+        using rep                       = system_clock::rep;
+        using period                    = system_clock::period;
+        using duration                  = _CHRONO duration<rep, period>;
+        using time_point                = _CHRONO time_point<tai_clock>;
+        static constexpr bool is_steady = system_clock::is_steady;
+
+        static constexpr seconds _Tai_epoch_adjust{378691210};
+
+        _NODISCARD static time_point now() {
+            return from_utc(utc_clock::now());
+        }
+
+        template <class _Duration>
+        _NODISCARD static utc_time<common_type_t<_Duration, seconds>> to_utc(
+            const tai_time<_Duration>& _Time) noexcept {
+            return utc_time<common_type_t<_Duration, seconds>>{_Time.time_since_epoch()} - _Tai_epoch_adjust;
+        }
+
+        template <class _Duration>
+        _NODISCARD static tai_time<common_type_t<_Duration, seconds>> from_utc(
+            const utc_time<_Duration>& _Time) noexcept {
+            return tai_time<common_type_t<_Duration, seconds>>{_Time.time_since_epoch()} + _Tai_epoch_adjust;
+        }
+    };
+
+    // [time.clock.gps]
+
+    _EXPORT_STD class gps_clock;
+
+    _EXPORT_STD template <class _Duration>
+    using gps_time                = time_point<gps_clock, _Duration>;
+    _EXPORT_STD using gps_seconds = gps_time<seconds>;
+
+    _EXPORT_STD class gps_clock {
+    public:
+        using rep                       = system_clock::rep;
+        using period                    = system_clock::period;
+        using duration                  = _CHRONO duration<rep, period>;
+        using time_point                = _CHRONO time_point<gps_clock>;
+        static constexpr bool is_steady = system_clock::is_steady;
+
+        static constexpr seconds _Gps_epoch_adjust{-315964809};
+
+        _NODISCARD static time_point now() {
+            return from_utc(utc_clock::now());
+        }
+
+        template <class _Duration>
+        _NODISCARD static utc_time<common_type_t<_Duration, seconds>> to_utc(
+            const gps_time<_Duration>& _Time) noexcept {
+            return utc_time<common_type_t<_Duration, seconds>>{_Time.time_since_epoch()} - _Gps_epoch_adjust;
+        }
+
+        template <class _Duration>
+        _NODISCARD static gps_time<common_type_t<_Duration, seconds>> from_utc(
+            const utc_time<_Duration>& _Time) noexcept {
+            return gps_time<common_type_t<_Duration, seconds>>{_Time.time_since_epoch()} + _Gps_epoch_adjust;
+        }
+    };
+#endif // _HAS_CXX20
+} // namespace chrono
+
+#if _HAS_CXX20
+namespace filesystem {
+    struct _File_time_clock;
+} // namespace filesystem
+
+namespace chrono {
+    _EXPORT_STD using file_clock = filesystem::_File_time_clock;
+
+    _EXPORT_STD template <class _Duration>
+    using file_time = time_point<file_clock, _Duration>;
+} // namespace chrono
+#endif // ^^^ _HAS_CXX20 ^^^
+
+#if _HAS_CXX17
+namespace filesystem {
+    inline constexpr long long __std_fs_file_time_epoch_adjustment = 0x19DB1DED53E8000LL; // TRANSITION, ABI
+
+    struct _File_time_clock { // Implementation of trivial-clock
+        using rep                       = long long;
+        using period                    = chrono::system_clock::period;
+        using duration                  = chrono::duration<rep, period>;
+        using time_point                = chrono::time_point<_File_time_clock>;
+        static constexpr bool is_steady = false;
+
+        _NODISCARD static time_point now() noexcept { // get current time; undo epoch adjustment
+            return time_point(duration(::_Xtime_get_ticks() + __std_fs_file_time_epoch_adjustment)); // TRANSITION, ABI
+        }
+
+#if _HAS_CXX20
+        // Assumes that FILETIME counts leap seconds since 2018-06-01 (i.e., after the first 27 leap seconds), even
+        // though systems can opt out of this behavior.
+        static constexpr chrono::seconds _Skipped_filetime_leap_seconds{27};
+        static constexpr chrono::sys_days _Cutoff{
+            chrono::year_month_day{chrono::year{2018}, chrono::June, chrono::day{1}}};
+
+        template <class _Duration>
+        _NODISCARD static chrono::utc_time<common_type_t<_Duration, chrono::seconds>> to_utc(
+            const chrono::file_time<_Duration>& _File_time) {
+            using namespace chrono;
+            using _CommonType = common_type_t<_Duration, seconds>;
+            const auto _Ticks = _File_time.time_since_epoch()
+                              - _CHRONO duration_cast<seconds>(duration{__std_fs_file_time_epoch_adjustment});
+
+            if (_Ticks < _Cutoff.time_since_epoch()) {
+                return utc_clock::from_sys(sys_time<_CommonType>{_Ticks});
+            } else {
+                return utc_time<_CommonType>{_Ticks + _Skipped_filetime_leap_seconds};
+            }
+        }
+
+        template <class _Duration>
+        _NODISCARD static chrono::file_time<common_type_t<_Duration, chrono::seconds>> from_utc(
+            const chrono::utc_time<_Duration>& _Utc_time) {
+            using namespace chrono;
+            file_time<common_type_t<_Duration, seconds>> _File_time{
+                _CHRONO duration_cast<seconds>(duration{__std_fs_file_time_epoch_adjustment})};
+
+            if (_Utc_time < utc_seconds{_Cutoff.time_since_epoch()} + _Skipped_filetime_leap_seconds) {
+                _File_time += utc_clock::to_sys(_Utc_time).time_since_epoch();
+            } else {
+                _File_time += _Utc_time.time_since_epoch() - _Skipped_filetime_leap_seconds;
+            }
+
+            return _File_time;
+        }
+#endif // ^^^ _HAS_CXX20 ^^^
+    };
+} // namespace filesystem
+#endif // ^^^ _HAS_CXX17 ^^^
+
+#if _HAS_CXX20
+namespace chrono {
+    // [time.clock.conv]
+
+    _EXPORT_STD template <class _DestClock, class _SourceClock>
+    struct clock_time_conversion {};
+
+    // [time.clock.cast.id]
+
+    template <class _Clock>
+    struct clock_time_conversion<_Clock, _Clock> {
+        template <class _Duration>
+        _NODISCARD time_point<_Clock, _Duration> operator()(const time_point<_Clock, _Duration>& _Time) const
+            noexcept(is_arithmetic_v<typename _Duration::rep>) /* strengthened */ {
+            return _Time;
+        }
+    };
+
+    template <>
+    struct clock_time_conversion<system_clock, system_clock> {
+        template <class _Duration>
+        _NODISCARD sys_time<_Duration> operator()(const sys_time<_Duration>& _Time) const
+            noexcept(is_arithmetic_v<typename _Duration::rep>) /* strengthened */ {
+            return _Time;
+        }
+    };
+
+    template <>
+    struct clock_time_conversion<utc_clock, utc_clock> {
+        template <class _Duration>
+        _NODISCARD utc_time<_Duration> operator()(const utc_time<_Duration>& _Time) const
+            noexcept(is_arithmetic_v<typename _Duration::rep>) /* strengthened */ {
+            return _Time;
+        }
+    };
+
+    // [time.clock.cast.sys.utc]
+
+    template <>
+    struct clock_time_conversion<utc_clock, system_clock> {
+        template <class _Duration>
+        _NODISCARD utc_time<common_type_t<_Duration, seconds>> operator()(const sys_time<_Duration>& _Sys_time) const {
+            return utc_clock::from_sys(_Sys_time);
+        }
+    };
+
+    template <>
+    struct clock_time_conversion<system_clock, utc_clock> {
+        template <class _Duration>
+        _NODISCARD sys_time<common_type_t<_Duration, seconds>> operator()(const utc_time<_Duration>& _Utc_time) const {
+            return utc_clock::to_sys(_Utc_time);
+        }
+    };
+
+    // [time.clock.cast.sys]
+
+    template <class _TimePoint, class _Clock>
+    constexpr bool _Is_time_point_for_clock = false;
+
+    template <class _Clock, class _Duration>
+    constexpr bool _Is_time_point_for_clock<time_point<_Clock, _Duration>, _Clock> = true;
+
+    template <class _SourceClock>
+    struct clock_time_conversion<system_clock, _SourceClock> {
+        template <class _Duration>
+            requires requires(const time_point<_SourceClock, _Duration>& _Time) { _SourceClock::to_sys(_Time); }
+        _NODISCARD auto operator()(const time_point<_SourceClock, _Duration>& _Time) const
+            noexcept(noexcept(_SourceClock::to_sys(_Time))) /* strengthened */ {
+            static_assert(_Is_time_point_for_clock<decltype(_SourceClock::to_sys(_Time)), system_clock>,
+                "N4950 [time.clock.cast.sys]/2: Mandates: SourceClock::to_sys(t) "
+                "returns a sys_time<Duration2> for some type Duration2");
+            return _SourceClock::to_sys(_Time);
+        }
+    };
+
+    template <class _DestClock>
+    struct clock_time_conversion<_DestClock, system_clock> {
+        template <class _Duration>
+            requires requires(const sys_time<_Duration>& _Time) { _DestClock::from_sys(_Time); }
+        _NODISCARD auto operator()(const sys_time<_Duration>& _Time) const
+            noexcept(noexcept(_DestClock::from_sys(_Time))) /* strengthened */ {
+            static_assert(_Is_time_point_for_clock<decltype(_DestClock::from_sys(_Time)), _DestClock>,
+                "N4950 [time.clock.cast.sys]/5: Mandates: DestClock::from_sys(t) "
+                "returns a time_point<DestClock, Duration2> for some type Duration2");
+            return _DestClock::from_sys(_Time);
+        }
+    };
+
+    // [time.clock.cast.utc]
+
+    template <class _SourceClock>
+    struct clock_time_conversion<utc_clock, _SourceClock> {
+        template <class _Duration>
+            requires requires(const time_point<_SourceClock, _Duration>& _Time) { _SourceClock::to_utc(_Time); }
+        _NODISCARD auto operator()(const time_point<_SourceClock, _Duration>& _Time) const
+            noexcept(noexcept(_SourceClock::to_utc(_Time))) /* strengthened */ {
+            static_assert(_Is_time_point_for_clock<decltype(_SourceClock::to_utc(_Time)), utc_clock>,
+                "N4950 [time.clock.cast.utc]/2: Mandates: SourceClock::to_utc(t) "
+                "returns a utc_time<Duration2> for some type Duration2");
+            return _SourceClock::to_utc(_Time);
+        }
+    };
+
+    template <class _DestClock>
+    struct clock_time_conversion<_DestClock, utc_clock> {
+        template <class _Duration>
+            requires requires(const utc_time<_Duration>& _Time) { _DestClock::from_utc(_Time); }
+        _NODISCARD auto operator()(const utc_time<_Duration>& _Time) const
+            noexcept(noexcept(_DestClock::from_utc(_Time))) /* strengthened */ {
+            static_assert(_Is_time_point_for_clock<decltype(_DestClock::from_utc(_Time)), _DestClock>,
+                "N4950 [time.clock.cast.utc]/5: Mandates: DestClock::from_utc(t) "
+                "returns a time_point<DestClock, Duration2> for some type Duration2");
+            return _DestClock::from_utc(_Time);
+        }
+    };
+
+    // [time.clock.cast.fn]
+
+    enum class _Clock_cast_strategy {
+        _Direct,
+        _Via_sys,
+        _Via_utc,
+        _Via_utc_from_sys,
+        _Via_sys_from_utc,
+        _Two_step_ambiguous,
+        _Three_step_ambiguous,
+        _None,
+    };
+
+    template <class _Conv1, class _Conv2, class _Tp>
+    constexpr bool _Has_two_step_conversion = requires { _Conv1{}(_Conv2{}(_STD declval<_Tp>())); };
+
+    template <class _Conv1, class _Conv2, class _Conv3, class _Tp>
+    constexpr bool _Has_three_step_conversion = requires { _Conv1{}(_Conv2{}(_Conv3{}(_STD declval<_Tp>()))); };
+
+    template <class _DestClock, class _SourceClock, class _Duration>
+    _NODISCARD consteval _Clock_cast_strategy _Choose_clock_cast() noexcept {
+        using _Tp = const time_point<_SourceClock, _Duration>&;
+
+        if constexpr (is_invocable_v<clock_time_conversion<_DestClock, _SourceClock>, _Tp>) {
+            return _Clock_cast_strategy::_Direct;
+        } else {
+            constexpr bool _Has_sys = _Has_two_step_conversion<clock_time_conversion<_DestClock, system_clock>,
+                clock_time_conversion<system_clock, _SourceClock>, _Tp>;
+
+            constexpr bool _Has_utc = _Has_two_step_conversion<clock_time_conversion<_DestClock, utc_clock>,
+                clock_time_conversion<utc_clock, _SourceClock>, _Tp>;
+
+            if constexpr (_Has_sys && _Has_utc) {
+                return _Clock_cast_strategy::_Two_step_ambiguous;
+            } else if constexpr (_Has_sys) {
+                return _Clock_cast_strategy::_Via_sys;
+            } else if constexpr (_Has_utc) {
+                return _Clock_cast_strategy::_Via_utc;
+            } else {
+                constexpr bool _Has_utc_from_sys = _Has_three_step_conversion< //
+                    clock_time_conversion<_DestClock, utc_clock>, //
+                    clock_time_conversion<utc_clock, system_clock>, //
+                    clock_time_conversion<system_clock, _SourceClock>, _Tp>;
+
+                constexpr bool _Has_sys_from_utc = _Has_three_step_conversion< //
+                    clock_time_conversion<_DestClock, system_clock>, //
+                    clock_time_conversion<system_clock, utc_clock>, //
+                    clock_time_conversion<utc_clock, _SourceClock>, _Tp>;
+
+                if constexpr (_Has_utc_from_sys && _Has_sys_from_utc) {
+                    return _Clock_cast_strategy::_Three_step_ambiguous;
+                } else if constexpr (_Has_utc_from_sys) {
+                    return _Clock_cast_strategy::_Via_utc_from_sys;
+                } else if constexpr (_Has_sys_from_utc) {
+                    return _Clock_cast_strategy::_Via_sys_from_utc;
+                } else {
+                    return _Clock_cast_strategy::_None;
+                }
+            }
+        }
+    }
+
+    template <class _DestClock, class _SourceClock, class _Duration>
+    constexpr auto _Clock_cast_choice = _CHRONO _Choose_clock_cast<_DestClock, _SourceClock, _Duration>();
+
+    _EXPORT_STD template <class _DestClock, class _SourceClock, class _Duration>
+        requires (_Clock_cast_choice<_DestClock, _SourceClock, _Duration> != _Clock_cast_strategy::_None)
+    _NODISCARD auto clock_cast(const time_point<_SourceClock, _Duration>& _Time) {
+        constexpr auto _Strat = _Clock_cast_choice<_DestClock, _SourceClock, _Duration>;
+
+        if constexpr (_Strat == _Clock_cast_strategy::_Direct) {
+            return clock_time_conversion<_DestClock, _SourceClock>{}(_Time);
+        } else if constexpr (_Strat == _Clock_cast_strategy::_Via_sys) {
+            return clock_time_conversion<_DestClock, system_clock>{}(
+                clock_time_conversion<system_clock, _SourceClock>{}(_Time));
+        } else if constexpr (_Strat == _Clock_cast_strategy::_Via_utc) {
+            return clock_time_conversion<_DestClock, utc_clock>{}(
+                clock_time_conversion<utc_clock, _SourceClock>{}(_Time));
+        } else if constexpr (_Strat == _Clock_cast_strategy::_Via_utc_from_sys) {
+            return clock_time_conversion<_DestClock, utc_clock>{}( //
+                clock_time_conversion<utc_clock, system_clock>{}(
+                    clock_time_conversion<system_clock, _SourceClock>{}(_Time)));
+        } else if constexpr (_Strat == _Clock_cast_strategy::_Via_sys_from_utc) {
+            return clock_time_conversion<_DestClock, system_clock>{}( //
+                clock_time_conversion<system_clock, utc_clock>{}(
+                    clock_time_conversion<utc_clock, _SourceClock>{}(_Time)));
+        } else if constexpr (_Strat == _Clock_cast_strategy::_Two_step_ambiguous) {
+            static_assert(false,
+                "A two-step clock time conversion is required to be unique, "
+                "either through utc_clock or system_clock, but not both (N4950 [time.clock.cast.fn]/2).");
+        } else if constexpr (_Strat == _Clock_cast_strategy::_Three_step_ambiguous) {
+            static_assert(false, "A three-step clock time conversion is required to be unique, "
+                                 "either utc-to-system or system-to-utc, but not both (N4950 [time.clock.cast.fn]/2).");
+        } else {
+            static_assert(false); // unexpected strategy
+        }
+    }
+
+    // [time.parse]
+    struct _Time_parse_fields {
+        using _SubsecondType = duration<int64_t, atto>;
+
+        // These are the primary fields, used to set the chrono type being parsed.
+        optional<int64_t> _Subsecond;
+        optional<int> _Second;
+        optional<int> _Minute;
+        optional<int> _Hour_24;
+        optional<int> _Weekday; // 0-based, starts Sunday
+        optional<int> _Day; // 1-based
+        optional<int> _Month; // 1-based
+        optional<int> _Day_of_year; // 1-based
+        optional<int> _Two_dig_year;
+        optional<int> _Century;
+        optional<int> _Utc_offset; // in minutes
+        optional<string> _Tz_name;
+
+        // These are the secondary fields, used to store parsed data. They must be converted to primary fields and
+        // checked for consistency.
+        optional<int> _Hour_12;
+        optional<int> _Ampm;
+        optional<int> _Iso_year;
+        optional<int> _Two_dig_iso_year;
+        optional<int> _Iso_week; // 1-based
+        optional<int> _Week_u; // week number, W01 begins on first Sunday
+        optional<int> _Week_w; // week number, W01 begins on first Monday
+
+        enum _FieldFlags : unsigned int {
+            _F_sec   = 0x01,
+            _F_min   = 0x02,
+            _F_hr    = 0x04,
+            _F_day   = 0x08,
+            _F_wkday = 0x10,
+            _F_mon   = 0x20,
+            _F_doy   = 0x40,
+            _F_year  = 0x80,
+        };
+
+        _NODISCARD unsigned int _Used_fields() const {
+            unsigned int _Ret{0};
+            if (_Second || _Subsecond) {
+                _Ret |= _F_sec;
+            }
+
+            if (_Minute) {
+                _Ret |= _F_min;
+            }
+
+            if (_Hour_24) {
+                _Ret |= _F_hr;
+            }
+
+            if (_Day) {
+                _Ret |= _F_day;
+            }
+
+            if (_Weekday) {
+                _Ret |= _F_wkday;
+            }
+
+            if (_Month) {
+                _Ret |= _F_mon;
+            }
+
+            if (_Day_of_year) {
+                _Ret |= _F_doy;
+            }
+
+            if (_Two_dig_year && _Century) {
+                _Ret |= _F_year;
+            }
+            return _Ret;
+        }
+
+        _NODISCARD static bool _Test_bits(
+            const unsigned int _Bits, const unsigned int _Must_set, const unsigned int _Optional = 0) {
+            return (_Bits & ~_Optional) == _Must_set;
+        }
+
+        template <class _Ty>
+        static constexpr _Ty _Invalid_time_field{numeric_limits<_Ty>::lowest()};
+
+        static void _Initialize_time_point(tm& _Tp) {
+            _Tp.tm_sec  = _Invalid_time_field<int>;
+            _Tp.tm_min  = _Invalid_time_field<int>;
+            _Tp.tm_hour = _Invalid_time_field<int>;
+            _Tp.tm_wday = _Invalid_time_field<int>;
+            _Tp.tm_mday = _Invalid_time_field<int>;
+            _Tp.tm_mon  = _Invalid_time_field<int>;
+            _Tp.tm_yday = _Invalid_time_field<int>;
+            _Tp.tm_year = _Invalid_time_field<int>;
+        }
+
+        template <class _Ty>
+        _NODISCARD static bool _Update(optional<_Ty>& _Val, const _Ty& _New) {
+            // Update a field. Ignores invalid values. If _Val already has a value, returns true or false according to
+            // whether the new value matches the current one or not, so that inconsistencies can be detected.
+
+            if constexpr (!is_same_v<_Ty, string>) {
+                if (_New == _Invalid_time_field<_Ty>) {
+                    return true;
+                }
+            }
+
+            if (_Val.has_value()) {
+                return _STD exchange(*_Val, _New) == _New;
+            }
+
+            _Val = _New;
+            return true;
+        }
+
+        _NODISCARD static pair<int, int> _Decompose_year(const int _Year) {
+            // LWG-3831: the two-digit year is taken without regard to the sign of the whole year number.
+            pair<int, int> _Result(_Year, _Year % 100);
+            _Result.first -= _Result.second;
+            if (_Result.second < 0) {
+                _Result.first -= 100;
+                _Result.second = -_Result.second;
+            }
+
+            return _Result;
+        }
+
+        _NODISCARD static int _Compose_year(const int _Century, const int _Two_d_year) {
+            if (_Century >= 0 || _Two_d_year == 0) {
+                return _Century + _Two_d_year;
+            } else {
+                return _Century + (100 - _Two_d_year);
+            }
+        }
+
+        _NODISCARD bool _Update_if_valid(const tm& _Tp, const bool _Full_year) {
+            bool _No_err{true};
+            if (_Tp.tm_hour != _Invalid_time_field<int>) {
+                _No_err = _No_err && _Update(_Hour_24, _Tp.tm_hour);
+                _No_err = _No_err && _Update(_Ampm, _Hour_24 >= 12 ? 1 : 0);
+                _No_err = _No_err && _Update(_Hour_12, _CHRONO make12(hours{*_Hour_24}).count());
+            }
+
+            _No_err = _No_err && _Update(_Minute, _Tp.tm_min);
+            _No_err = _No_err && _Update(_Second, _Tp.tm_sec);
+            _No_err = _No_err && _Update(_Day, _Tp.tm_mday);
+            _No_err = _No_err && _Update(_Weekday, _Tp.tm_wday);
+
+            if (_Tp.tm_mon != _Invalid_time_field<int>) {
+                _No_err = _No_err && _Update(_Month, _Tp.tm_mon + 1);
+            }
+
+            if (_Tp.tm_yday != _Invalid_time_field<int>) {
+                _No_err = _No_err && _Update(_Day_of_year, _Tp.tm_yday + 1);
+            }
+
+            if (_Tp.tm_year != _Invalid_time_field<int>) {
+                // Sometimes we expect only the last two digits.
+                const auto _Year_parts = _Decompose_year(_Tp.tm_year + 1900);
+                _No_err                = _No_err && _Update(_Two_dig_year, _Year_parts.second);
+                if (_Full_year) {
+                    _No_err = _No_err && _Update(_Century, _Year_parts.first);
+                }
+            }
+
+            return _No_err;
+        }
+
+        _NODISCARD bool _Yday_to_month_day(const int _Yday, const int _Year) {
+            // A day-of-year that's February 28 or earlier, by itself, is a valid month_day. Any later day is
+            // ambiguous without a year.
+            if (_Out_of_range(_Day_of_year, 1, _Two_dig_year || _Iso_year ? _Days_in_year(_Year) : 59)) {
+                return false;
+            }
+
+            if (_Day_of_year <= 31) {
+                return _Update(_Day, _Yday) && _Update(_Month, 1);
+            }
+
+            const int _Feb_end{_Is_leap(_Year) ? 60 : 59};
+            if (_Day_of_year <= _Feb_end) {
+                return _Update(_Day, _Yday - 31) && _Update(_Month, 2);
+            }
+
+            // Shift day-of-year so that 1 == March 1. This is the same as year_month_day::_Civil_from_days, except
+            // _Day_of_year --> _Shifted_yday-1 and _Mp --> _Month - 3.
+            const int _Shifted_yday{*_Day_of_year - _Feb_end};
+            return _Update(_Month, (535 * _Shifted_yday + 48950) >> 14)
+                && _Update(_Day, _Shifted_yday - ((979 * *_Month - 2918) >> 5));
+        }
+
+        static constexpr int _Era_begin_wday{3}; // Wednesday
+
+        _NODISCARD static constexpr int _Jan1_weekday(int _Year) {
+            --_Year;
+            const int _Era = (_Year >= 0 ? _Year : _Year - 399) / 400;
+            const int _Yoe = _Year - _Era * 400;
+            // Jan. 1 is always day 306 of the shifted [Mar, ..., Dec, Jan, Feb] year.
+            const int _Doe = ((1461 * _Yoe) >> 2) - _Yoe / 100 + 306;
+            return (_Doe + _Era_begin_wday) % 7;
+        }
+
+        _NODISCARD static constexpr int _Iso8601_weeks(int _Year) {
+            const int _P_y = (_Year + _Year / 4 - _Year / 100 + _Year / 400) % 7;
+            --_Year;
+            const int _P_ym1 = (_Year + _Year / 4 - _Year / 100 + _Year / 400) % 7;
+            return 52 + (_P_y == 4 || _P_ym1 == 3);
+        }
+
+        _NODISCARD static constexpr int _Iso8601_week(const int _Day_of_year, const int _Weekday, const int _Year) {
+            // Jan. 4 is always week 1; rollover to next week always happens on Monday.
+            const auto _Week{(_Day_of_year + 9 - _Prev_weekday(_Weekday, 1)) / 7};
+            if (_Week < 1) {
+                return _Iso8601_weeks(_Year - 1);
+            } else if (_Week > _Iso8601_weeks(_Year)) {
+                return 1;
+            } else {
+                return _Week;
+            }
+        }
+
+        _NODISCARD static constexpr bool _Is_leap(const int _Year) {
+            return _Year % 4 == 0 && (_Year % 100 != 0 || _Year % 400 == 0);
+        }
+
+        _NODISCARD static constexpr int _Days_in_year(const int _Year) {
+            return _Is_leap(_Year) ? 366 : 365;
+        }
+
+        _NODISCARD static constexpr int _Next_weekday(const int _Wday, const int _Shift) {
+            // 0 <= _Shift <= 6
+            int _Result = _Wday + _Shift;
+            if (_Result >= 7) {
+                _Result -= 7;
+            }
+            return _Result;
+        }
+
+        _NODISCARD static constexpr int _Prev_weekday(const int _Wday, const int _Shift) {
+            // 0 <= _Shift <= 6
+            return (_Wday >= _Shift ? 0 : 7) + (_Wday - _Shift);
+        }
+
+        _NODISCARD bool _Calculate_ymd_from_week_date(const int _Starting_wday, const int _Week, const int _Year) {
+            // (a) Calculate day-of-year of first _Starting_wday in January.
+            // (b) Shift *_Weekday so that it's relative to _Starting_wday.
+            // (c) Offset to desired week.
+            const int _Jan1_wday = _Jan1_weekday(_Year);
+            const int _Yday      = 1 + _Prev_weekday(_Starting_wday, _Jan1_wday) // (a)
+                                 + _Prev_weekday(*_Weekday, _Starting_wday) // (b)
+                                 + 7 * (_Week - 1); // (c)
+            return _Update(_Day_of_year, _Yday) && !_Out_of_range(_Day_of_year, 1, _Days_in_year(_Year))
+                && _Yday_to_month_day(*_Day_of_year, _Year);
+        }
+
+        _NODISCARD bool _Calculate_ymd() {
+            bool _No_err = true;
+            // Flags to indicate if a field should be checked for consistency with other data. Set to false when the
+            // field is used to calculate the date, as it's necessarily self-consistent in that case (barring a bug).
+            bool _Check_u    = true;
+            bool _Check_w    = true;
+            bool _Check_iso  = true;
+            bool _Check_wday = true;
+
+            if (_Day_of_year && _Out_of_range(_Day_of_year, 1, 366)) {
+                return false;
+            }
+
+            bool _Have_year = false;
+            int _Year{0};
+            if (_Two_dig_year) {
+                _Year      = _Compose_year(*_Century, *_Two_dig_year);
+                _Have_year = true;
+                if (_Day_of_year) {
+                    _No_err = _No_err && _Yday_to_month_day(*_Day_of_year, _Year);
+                } else if (_Week_u || _Week_w) {
+                    _Check_wday = false;
+                    if (_Week_u) {
+                        _Check_u = false;
+                        _No_err  = _No_err && _Calculate_ymd_from_week_date(0 /*Sunday*/, *_Week_u, _Year);
+                    }
+
+                    if (_Week_w) {
+                        _Check_w = false;
+                        _No_err  = _No_err && _Calculate_ymd_from_week_date(1 /*Monday*/, *_Week_w, _Year);
+                    }
+                }
+            }
+
+            if (_Iso_year) {
+                // ISO weeks begin on Monday. W01 always contains January 4. There is no W00, so the beginning of
+                // January can be in W52 or W53 of the previous year. Likewise, the end of December can occur at the
+                // beginning of W01 of the following year, depending on where in the week Jan. 4 falls.
+                _Check_wday = false;
+                _Check_iso  = false;
+                _Year       = *_Iso_year;
+                _Have_year  = true;
+
+                // Shift weekdays to Monday-based. Jan. 4 is the anchor of week 1, so calculate where the parsed weekday
+                // is relative to that point.
+                const int _Jan4_wday        = _Next_weekday(_Jan1_weekday(_Year), 3 - 1);
+                const int _Offset_from_jan4 = _Prev_weekday(*_Weekday, 1) - _Jan4_wday;
+                int _Trial_yday             = 4 + 7 * (*_Iso_week - 1) + _Offset_from_jan4;
+                const int _Ref_num_days     = _Trial_yday < 1 ? _Days_in_year(_Year - 1) : _Days_in_year(_Year);
+                if (_Trial_yday < 1) {
+                    _Trial_yday += _Ref_num_days;
+                    --_Year;
+                } else if (_Trial_yday > _Ref_num_days) {
+                    _Trial_yday -= _Ref_num_days;
+                    ++_Year;
+                }
+
+                const auto _Year_parts = _Decompose_year(_Year);
+                _No_err = _No_err && _Update(_Day_of_year, _Trial_yday) && _Yday_to_month_day(*_Day_of_year, _Year)
+                       && _Update(_Century, _Year_parts.first) && _Update(_Two_dig_year, _Year_parts.second);
+            }
+
+            // Must have YMD by this point, either parsed directly or calculated above.
+            if (!_Have_year || !_Month || !_Day || !_No_err) {
+                return false;
+            }
+
+            // consistency checks
+            if (_Check_wday && _Weekday) {
+                const auto _Era_year = _Year - (*_Month <= 2);
+                const int _Era       = (_Era_year >= 0 ? _Era_year : _Era_year - 399) / 400;
+                const int _Yoe       = _Era_year - _Era * 400;
+                const int _Yday_era  = ((979 * (*_Month + (*_Month > 2 ? -3 : 9)) + 19) >> 5) + *_Day - 1;
+                const int _Doe       = ((1461 * _Yoe) >> 2) - _Yoe / 100 + _Yday_era;
+                _No_err              = _No_err && _Update(_Weekday, (_Doe + _Era_begin_wday) % 7);
+            }
+
+            if (_Check_u && _Week_u) {
+                _No_err = _No_err && _Update(_Week_u, (*_Day_of_year + 6 - *_Weekday) / 7);
+            }
+
+            if (_Check_w && _Week_w) {
+                _No_err = _No_err && _Update(_Week_w, (*_Day_of_year + 6 - _Prev_weekday(*_Weekday, 1)) / 7);
+            }
+
+            if (_Check_iso && _Iso_week) {
+                _No_err = _No_err && _Update(_Iso_week, _Iso8601_week(*_Day_of_year, *_Weekday, _Year));
+            }
+
+            return _No_err;
+        }
+
+        _NODISCARD bool _Calculate_hour24() {
+            if (_Hour_12) {
+                return _Update(
+                    _Hour_24, _CHRONO make24(hours{*_Hour_12}, static_cast<bool>(_Ampm.value_or(0))).count());
+            } else {
+                return true;
+            }
+        }
+
+        _NODISCARD bool _Calculate_year_fields() {
+            bool _No_err = true;
+            // The order of these updates is significant. Updating the ISO date second allows
+            // formats with %g and %y, but not %C, to get the century implicitly from %y.
+            if (_Two_dig_year && !_Century) {
+                _No_err = _No_err && _Update(_Century, _Two_dig_year >= 69 ? 1900 : 2000);
+            }
+
+            // %C is only combined with %g if %G is missing, to avoid an unnecessary parse failure when the ISO and
+            // Gregorian years are in different centuries.
+            if (_Two_dig_iso_year && _Century && !_Iso_year) {
+                _No_err = _No_err && _Update(_Iso_year, _Compose_year(*_Century, *_Two_dig_iso_year));
+            }
+
+            return _No_err;
+        }
+
+        _NODISCARD static bool _Out_of_range(const optional<int>& _Field, const int _Min, const int _Max) {
+            return _Field && (_Field < _Min || _Max < _Field);
+        }
+
+        _NODISCARD bool _Is_complete() const {
+            // Check for data that is incomplete, ambiguous, or obviously out-of-range. The exception is 12-hour time
+            // without am/pm. Most strptime implementations will assume am in this case, so we'll do that too. Don't
+            // check for consistency yet, because the data might not even be representable by the type being parsed,
+            // and calendar computations are relatively expensive.
+
+            // Most time-of-day fields are deferred until we know if we're parsing a time_point.
+            if (_Out_of_range(_Hour_12, 1, 12) || _Out_of_range(_Weekday, 0, 6) || _Out_of_range(_Day, 1, 31)
+                || _Out_of_range(_Month, 1, 12)) {
+                return false;
+            }
+
+            if (_Iso_year || _Two_dig_iso_year || _Iso_week) {
+                // Need to have %G or %C+%g. The century can be parsed explicitly, or derived implicitly from %y.
+                const bool _Has_complete_year{_Iso_year || ((_Century || _Two_dig_year) && _Two_dig_iso_year)};
+                if (!_Has_complete_year || !_Iso_week || !_Weekday || _Out_of_range(_Iso_week, 1, 53)) {
+                    return false;
+                }
+            }
+
+            if (_Week_u || _Week_w) {
+                // Need a weekday and year to be complete.
+                if (!_Weekday || !_Two_dig_year) {
+                    return false;
+                }
+
+                if (_Out_of_range(_Week_u, 0, 53) || _Out_of_range(_Week_w, 0, 53)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        template <class _Duration1, class _Duration2>
+        _NODISCARD static constexpr bool _Can_represent() {
+            using _Rep1    = _Duration1::rep;
+            using _Period1 = _Duration1::period;
+            using _Period2 = _Duration2::period;
+
+            // Returns whether _Duration1 can represent _Duration2{1}. Assumes 1 <= _Period2 <=
+            // 86,400, i.e., we're interested in time periods between seconds and days.
+            if constexpr (is_integral_v<_Rep1>) {
+                // Must have _Period1 <= _Period2 and numeric_limits<_Rep1>::max() >= _Period2 / _Period1. For example,
+                // std::days can't represent std::seconds, and duration<int, atto>::max() is ~9.2 seconds.
+                constexpr auto _Max_tick = static_cast<intmax_t>((numeric_limits<make_signed_t<_Rep1>>::max)());
+
+                return ratio_less_equal_v<_Period1, _Period2>
+                    && ratio_greater_equal_v<ratio<_Max_tick, _Period2::num>, ratio_divide<ratio<1>, _Period1>>;
+            } else if constexpr (is_floating_point_v<_Rep1>) {
+                // With the smallest possible _Period1, ratio<1,INTMAX_MAX>, one day has a tick count of
+                // 86,400*INTMAX_MAX ~= 7.97e23. This is representable by float and double, so they can always represent
+                // at least one day. On the other hand, one second with the largest possible _Period1 needs a tick count
+                // of 1/(INTMAX_MAX) ~= 1.08e-19, which is also representable in both float and double. So, both
+                // floating-point types can represent durations between one second and one day, regardless of _Period1.
+                return true;
+            } else {
+                // TRANSITION: user-defined arithmetic-like types
+                return true;
+            }
+        }
+
+        enum class _Parse_tp_or_duration { _Time_point, _Duration };
+
+        template <_Parse_tp_or_duration _Parse_type, class _DurationType>
+        _NODISCARD bool _Apply_duration_fields(_DurationType& _Result) {
+            constexpr bool _Can_rep_sec    = _Can_represent<_DurationType, seconds>();
+            constexpr bool _Can_rep_min    = _Can_represent<_DurationType, minutes>();
+            constexpr bool _Can_rep_hr     = _Can_represent<_DurationType, hours>();
+            constexpr bool _Can_rep_day    = _Can_represent<_DurationType, days>();
+            constexpr bool _For_time_point = _Parse_type == _Parse_tp_or_duration::_Time_point;
+
+            const auto _Required{(_For_time_point ? _F_day | _F_mon | _F_year : 0)};
+            const auto _Optional{(_For_time_point ? _F_wkday : 0) | (_Can_rep_sec ? _F_sec : 0)
+                                 | (_Can_rep_min ? _F_min : 0) | (_Can_rep_hr ? _F_hr : 0)
+                                 | (_Can_rep_day ? _F_doy : 0)};
+
+            const auto _Used{_Used_fields()};
+            const auto _Time_out_of_range{
+                _For_time_point
+                && (_Out_of_range(_Second, 0, 60) || _Out_of_range(_Minute, 0, 59) || _Out_of_range(_Hour_24, 0, 23))};
+
+            if (_Time_out_of_range || !_Test_bits(_Used, _Required, _Optional)) {
+                return false;
+            }
+
+            _Result = _DurationType::zero();
+            if constexpr (_Can_rep_sec) {
+                if (_Used & _F_sec) {
+                    if (_Subsecond) {
+                        const _SubsecondType _Sub{*_Subsecond};
+
+                        if constexpr (!treat_as_floating_point_v<typename _DurationType::rep>) {
+                            using _CastedType = duration<int64_t, typename _DurationType::period>;
+                            if (_CHRONO duration_cast<_CastedType>(_Sub) != _Sub) {
+                                return false;
+                            }
+                        }
+
+                        _Result += _CHRONO duration_cast<_DurationType>(_Sub);
+                    }
+
+                    if (_Second) {
+                        _Result += _CHRONO duration_cast<_DurationType>(seconds{*_Second});
+                    }
+                }
+            }
+
+            if constexpr (_Can_rep_min) {
+                if (_Used & _F_min) {
+                    _Result += _CHRONO duration_cast<_DurationType>(minutes{*_Minute});
+                }
+
+                if (_Utc_offset) {
+                    _Result -= _CHRONO duration_cast<_DurationType>(minutes{*_Utc_offset});
+                }
+            }
+
+            if constexpr (_Can_rep_hr) {
+                if (_Used & _F_hr) {
+                    _Result += _CHRONO duration_cast<_DurationType>(hours{*_Hour_24});
+                }
+            }
+
+            if constexpr (_Can_rep_day) {
+                if (_For_time_point) {
+                    const year_month_day _Ymd{year{_Compose_year(*_Century, *_Two_dig_year)},
+                        month{static_cast<unsigned int>(*_Month)}, day{static_cast<unsigned int>(*_Day)}};
+                    _Result += _CHRONO duration_cast<_DurationType>(static_cast<sys_days>(_Ymd).time_since_epoch());
+                } else if (_Used & _F_doy) {
+                    _Result += _CHRONO duration_cast<_DurationType>(days{*_Day_of_year});
+                }
+            }
+
+            return true;
+        }
+
+        template <class _Rep, class _Period>
+        _NODISCARD bool _Make_duration(duration<_Rep, _Period>& _Duration_result) {
+            const bool _Consistent = _Calculate_hour24();
+            if (_Consistent) {
+                return _Apply_duration_fields<_Parse_tp_or_duration::_Duration>(_Duration_result);
+            }
+
+            return false;
+        }
+
+        enum class _Leap_second_rep : unsigned int {
+            _None, // system_clock, tai_clock, gps_clock; oblivious to leap seconds
+            _All, // utc_clock
+            _File_time // _None before 2018-06-01, _All afterwards.
+        };
+
+        template <class _DurationType>
+        _NODISCARD bool _Make_time_point(_DurationType& _Dur, _Leap_second_rep _Leap) {
+            const bool _Consistent{_Calculate_hour24() && _Calculate_year_fields() && _Calculate_ymd()};
+            if (!_Consistent || !_Apply_duration_fields<_Parse_tp_or_duration::_Time_point>(_Dur)) {
+                return false;
+            }
+
+            const _Leap_second_rep _Original_leap{_Leap};
+            if (_Leap == _Leap_second_rep::_File_time) {
+                _Leap =
+                    _Dur < file_clock::_Cutoff.time_since_epoch() ? _Leap_second_rep::_None : _Leap_second_rep::_All;
+            }
+
+            if (_Second > (_Leap == _Leap_second_rep::_All ? 60 : 59)) {
+                return false;
+            }
+
+            // A distinction has to be made here between clocks that always count 86,400 seconds/day (system_clock,
+            // tai_clock, and gps_clock) and ones that count leap seconds (utc_clock and, since 2018-06-01, file_clock).
+            // The correct tick count for the clocks that always count 86,400 seconds/day can be determined without
+            // knowing whether any leap seconds have occurred, and there aren't any invalid times due to negative leap
+            // second deletions.
+
+            if (_Leap == _Leap_second_rep::_All) {
+                if constexpr (!_Can_represent<_DurationType, seconds>()) {
+                    // Error if _Dur can't represent the adjustment below.
+                    return false;
+                } else {
+                    // It's possible that the parsed time doesn't exist because (a) _Seconds == 60 and there *isn't* a
+                    // leap second insertion or (b) _Seconds >= 59 and there *is* a leap second deletion.
+                    const auto& _Tzdb{_CHRONO get_tzdb()};
+
+                    const bool _Possible_insertion{_Second == 60};
+                    const sys_seconds _Target_sys_time{
+                        _CHRONO floor<seconds>(_Dur) - (_Possible_insertion ? seconds{1} : seconds{0})};
+                    const auto& _Ls_vector{_Tzdb.leap_seconds};
+                    const auto _It{_STD upper_bound(_Ls_vector.begin(), _Ls_vector.end(), _Target_sys_time)};
+                    const bool _Match_leap{_It != _Ls_vector.end() && *_It == _Target_sys_time + seconds{1}};
+
+                    if (_Match_leap) {
+                        if (!_It->_Positive()) { // negative leap second
+                            if (_Second >= 59) {
+                                return false;
+                            }
+                        }
+                    } else { // no leap second
+                        if (_Possible_insertion) {
+                            return false;
+                        }
+                    }
+
+                    const auto _Offset = _It == _Ls_vector.begin() ? seconds{0} : _STD _Prev_iter(_It)->_Elapsed();
+                    _Dur += _CHRONO duration_cast<_DurationType>(_Offset);
+
+                    if (_Original_leap == _Leap_second_rep::_File_time) {
+                        _Dur -= _CHRONO duration_cast<_DurationType>(
+                            filesystem::_File_time_clock::_Skipped_filetime_leap_seconds);
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        _NODISCARD bool _Make_day(day& _Day_result) {
+            if (_Used_fields() == _F_day) {
+                _Day_result = day{static_cast<unsigned int>(*_Day)};
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        _NODISCARD bool _Make_weekday(weekday& _Weekday_result) {
+            if (_Used_fields() == _F_wkday) {
+                _Weekday_result = weekday{static_cast<unsigned int>(*_Weekday)};
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        _NODISCARD bool _Make_month(month& _Month_result) {
+            if (_Used_fields() == _F_mon) {
+                _Month_result = month{static_cast<unsigned int>(*_Month)};
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        _NODISCARD bool _Make_month_day(month_day& _Month_day_result) {
+            if (_Day_of_year && !_Yday_to_month_day(*_Day_of_year, 0)) {
+                return false;
+            }
+
+            constexpr auto _Required = _F_mon | _F_day;
+            constexpr auto _Optional = _F_doy;
+            if (_Test_bits(_Used_fields(), _Required, _Optional)) {
+                _Month_day_result =
+                    month_day{month{static_cast<unsigned int>(*_Month)}, day{static_cast<unsigned int>(*_Day)}};
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        _NODISCARD bool _Make_year(year& _Year_result) {
+            if (_Calculate_year_fields() && _Used_fields() == _F_year) {
+                _Year_result = year{_Compose_year(*_Century, *_Two_dig_year)};
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        _NODISCARD bool _Make_year_month(year_month& _Year_month_result) {
+            if (_Calculate_year_fields() && _Used_fields() == (_F_mon | _F_year)) {
+                _Year_month_result = year_month{
+                    year{_Compose_year(*_Century, *_Two_dig_year)}, month{static_cast<unsigned int>(*_Month)}};
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        _NODISCARD bool _Make_year_month_day(
+            year_month_day& _Year_month_day_result, const bool _For_time_point = false) {
+            const bool _Consistent   = _Calculate_year_fields() && _Calculate_ymd();
+            constexpr auto _Required = _F_day | _F_mon | _F_year;
+            auto _Optional           = _F_wkday | _F_doy;
+            if (_For_time_point) {
+                // These fields aren't used here, but they might be used later if converting to a time_point.
+                _Optional |= _F_sec | _F_min | _F_hr;
+            }
+
+            if (_Consistent && _Test_bits(_Used_fields(), _Required, _Optional)) {
+                _Year_month_day_result = year_month_day{year{_Compose_year(*_Century, *_Two_dig_year)},
+                    month{static_cast<unsigned int>(*_Month)}, day{static_cast<unsigned int>(*_Day)}};
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        template <class _CharT, class _Traits>
+        _NODISCARD istreambuf_iterator<_CharT, _Traits> _Parse_time_field(istreambuf_iterator<_CharT, _Traits> _First,
+            ios_base& _Iosbase, ios_base::iostate& _State, const char _Flag, const char _Modifier,
+            const unsigned int _Width, const unsigned int _Subsecond_precision) {
+
+            const auto& _Ctype_fac = _STD use_facet<ctype<_CharT>>(_Iosbase.getloc());
+            const auto& _Time_fac  = _STD use_facet<time_get<_CharT>>(_Iosbase.getloc());
+            constexpr istreambuf_iterator<_CharT, _Traits> _Last{};
+
+            int _Val{0};
+            switch (_Flag) {
+            case 'a':
+            case 'A':
+                {
+                    tm _Tp;
+                    _Tp.tm_wday = _Invalid_time_field<int>;
+                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'a');
+                    if (!_Update(_Weekday, _Tp.tm_wday)) {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            case 'b':
+            case 'B':
+            case 'h':
+                {
+                    tm _Tp;
+                    _Tp.tm_mon = _Invalid_time_field<int>;
+                    _First     = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'b');
+                    if (_Tp.tm_mon == _Invalid_time_field<int> || !_Update(_Month, ++_Tp.tm_mon)) {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            case 'C':
+                if (_Modifier != 'E') {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                    _Val *= 100;
+                } else {
+                    tm _Tp;
+                    _Tp.tm_year = _Invalid_time_field<int>;
+                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'C', 'E');
+                    _Val        = _Tp.tm_year;
+                    if (_Tp.tm_year != _Invalid_time_field<int>) {
+                        _Val += 1900;
+                    }
+                }
+
+                if (!_Update(_Century, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'd':
+            case 'e':
+                if (_Modifier != 'O') {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                } else {
+                    tm _Tp;
+                    _Tp.tm_mday = _Invalid_time_field<int>;
+                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'd', 'O');
+                    _Val        = _Tp.tm_mday;
+                }
+
+                if (!_Update(_Day, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'D':
+                _First = _Parse_time_field_restricted(_First, _Iosbase, _State, "%m/%d/%y");
+                break;
+
+            case 'F':
+                {
+                    // If modified with a width N, the width is applied to only %Y.
+                    _State |= _Get_int(_First, _Width == 0 ? 4u : _Width, _Val, _Ctype_fac);
+                    const auto _Year_parts = _Decompose_year(_Val);
+                    if (_Update(_Century, _Year_parts.first) && _Update(_Two_dig_year, _Year_parts.second)) {
+                        _First = _Parse_time_field_restricted(_First, _Iosbase, _State, "-%m-%d");
+                    } else {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            case 'g':
+                _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                if (!_Update(_Two_dig_iso_year, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'G':
+                {
+                    _State |= _Get_int(_First, _Width == 0 ? 4u : _Width, _Val, _Ctype_fac);
+                    const auto _Year_parts = _Decompose_year(_Val);
+                    if (!_Update(_Iso_year, _Val) || !_Update(_Two_dig_iso_year, _Year_parts.second)) {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            case 'H':
+                if (_Modifier != 'O') {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                } else {
+                    tm _Tp;
+                    _Tp.tm_hour = _Invalid_time_field<int>;
+                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'H', 'O');
+                    _Val        = _Tp.tm_hour;
+                }
+
+                if (!_Update(_Hour_24, _Val)
+                    || (_Val < 24
+                        && (!_Update(_Ampm, _Val >= 12 ? 1 : 0)
+                            || !_Update(_Hour_12, _CHRONO make12(hours{_Val}).count())))) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'I':
+                if (_Modifier != 'O') {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                } else {
+                    tm _Tp;
+                    _Tp.tm_hour = _Invalid_time_field<int>;
+                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'I', 'O');
+                    _Val        = (_Tp.tm_hour == 0) ? 12 : _Tp.tm_hour;
+                }
+
+                if (!_Update(_Hour_12, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'j':
+                _State |= _Get_int(_First, _Width == 0 ? 3u : _Width, _Val, _Ctype_fac);
+                if (!_Update(_Day_of_year, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'M':
+                if (_Modifier != 'O') {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                } else {
+                    tm _Tp;
+                    _Tp.tm_min = _Invalid_time_field<int>;
+                    _First     = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'M', 'O');
+                    _Val       = _Tp.tm_min;
+                }
+
+                if (!_Update(_Minute, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'm':
+                if (_Modifier != 'O') {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                } else {
+                    tm _Tp;
+                    _Initialize_time_point(_Tp);
+                    _First = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'm', 'O');
+                    _Val   = _Tp.tm_mon;
+                    if (_Tp.tm_mon != _Invalid_time_field<int>) {
+                        ++_Val;
+                    }
+                }
+
+                if (!_Update(_Month, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'p':
+                {
+                    tm _Tp;
+                    _Tp.tm_hour = 0;
+                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'p');
+                    if (!_Update(_Ampm, _Tp.tm_hour == 0 ? 0 : 1)) {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            case 'c':
+            case 'r':
+            case 'x':
+            case 'X':
+                {
+                    tm _Tp;
+                    _Initialize_time_point(_Tp);
+                    const bool _Full_year = (_Flag == 'c'); // 'x' reads two-digit year, 'r' and 'X' read times
+                    _First                = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, _Flag, _Modifier);
+                    if (!_Update_if_valid(_Tp, _Full_year)) {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            case 'R':
+                _First = _Parse_time_field_restricted(_First, _Iosbase, _State, "%H:%M");
+                break;
+
+            case 'T':
+                _First = _Parse_time_field_restricted(_First, _Iosbase, _State, "%H:%M:%S", _Subsecond_precision);
+                break;
+
+            case 'S':
+                if (_Subsecond_precision == 0) {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                    if (!_Update(_Second, _Val)) {
+                        _State |= ios_base::failbit;
+                    }
+                } else {
+                    const auto& _Numpunct_fac = _STD use_facet<numpunct<_CharT>>(_Iosbase.getloc());
+                    _State |=
+                        _Get_fixed(_First, _Width == 0 ? 3 + _Subsecond_precision : _Width, _Ctype_fac, _Numpunct_fac);
+                }
+                break;
+
+            case 'u':
+            case 'w':
+                if (_Flag == 'w' && _Modifier == 'O') {
+                    tm _Tp;
+                    _Tp.tm_wday = _Invalid_time_field<int>;
+                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'w', 'O');
+                    _Val        = _Tp.tm_wday;
+                } else {
+                    _State |= _Get_int(_First, _Width == 0 ? 1u : _Width, _Val, _Ctype_fac);
+                    if (_Flag == 'u') {
+                        // ISO weekday: [1,7], 7 == Sunday
+                        if (_Val == 7) {
+                            _Val = 0;
+                        } else if (_Val == 0) {
+                            _Val = 7; // out of range
+                        }
+                    }
+                }
+
+                if (!_Update(_Weekday, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'U':
+            case 'V':
+            case 'W':
+                {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                    auto& _Field{(_Flag == 'U') ? _Week_u : (_Flag == 'W' ? _Week_w : _Iso_week)};
+                    if (!_Update(_Field, _Val)) {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            case 'y':
+                if (_Modifier == '\0') {
+                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
+                } else {
+                    tm _Tp;
+                    _Tp.tm_year = _Invalid_time_field<int>;
+                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'y', _Modifier);
+                    if (_Modifier == 'E') {
+                        _Val = _Tp.tm_year + 1900; // offset from %EC base year
+                    } else {
+                        const auto _Year_parts = _Decompose_year(_Tp.tm_year);
+                        _Val                   = _Year_parts.second;
+                    }
+                }
+
+                if (!_Update(_Two_dig_year, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'Y':
+                {
+                    if (_Modifier == 'E') {
+                        tm _Tp;
+                        _Tp.tm_year = _Invalid_time_field<int>;
+                        _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'Y', 'E');
+                        _Val        = _Tp.tm_year + 1900;
+                    } else {
+                        _State |= _Get_int(_First, _Width == 0 ? 4u : _Width, _Val, _Ctype_fac);
+                    }
+
+                    const auto _Year_parts = _Decompose_year(_Val);
+                    if (!_Update(_Century, _Year_parts.first) || !_Update(_Two_dig_year, _Year_parts.second)) {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            case 'z':
+                _State |= _Get_tz_offset(_First, _Ctype_fac, _Modifier == 'E' || _Modifier == 'O', _Val);
+                if (!_Update(_Utc_offset, _Val)) {
+                    _State |= ios_base::failbit;
+                }
+                break;
+
+            case 'Z':
+                {
+                    string _Name;
+                    _State |= _Get_tz_name(_First, _Ctype_fac, _Name);
+                    if (!_Update(_Tz_name, _Name)) {
+                        _State |= ios_base::failbit;
+                    }
+                    break;
+                }
+
+            default:
+                // Invalid flag
+                _State |= ios_base::failbit;
+                break;
+            }
+
+            return _First;
+        }
+
+        template <class _CharT, class _Traits>
+        _NODISCARD istreambuf_iterator<_CharT, _Traits> _Parse_time_field_restricted(
+            istreambuf_iterator<_CharT, _Traits> _First, ios_base& _Iosbase, ios_base::iostate& _State,
+            const char* _Fmt, const unsigned int _Subsecond_precision = 0) {
+            // Parses a restricted format string. It generally doesn't handle anything parsed outside of
+            // _Parse_time_field:
+            //   (a) any whitespace (' ', %n, %t)
+            //   (b) %% literal (other literals are parsed, however)
+            //   (c) E or O modifiers
+            //   (d) width parameter
+            // It also assumes a valid format string, specifically that '%' is always followed by a flag.
+            const auto& _Ctype_fac{_STD use_facet<ctype<_CharT>>(_Iosbase.getloc())};
+            constexpr istreambuf_iterator<_CharT, _Traits> _Last{};
+
+            while (*_Fmt != '\0' && (_State & ~ios_base::eofbit) == ios_base::goodbit) {
+                if (_First == _Last) {
+                    _State |= ios_base::failbit | ios_base::eofbit;
+                    break;
+                } else if (*_Fmt == '%') {
+                    _First = _Parse_time_field(_First, _Iosbase, _State, *++_Fmt, '\0', 0, _Subsecond_precision);
+                } else if (_Ctype_fac.narrow(*_First++) != *_Fmt) {
+                    _State |= ios_base::failbit;
+                }
+                ++_Fmt;
+            }
+            return _First;
+        }
+
+        template <class _CharT, class _Traits>
+        _NODISCARD ios_base::iostate _Get_fixed(istreambuf_iterator<_CharT, _Traits>& _First, unsigned int _Width,
+            const ctype<_CharT>& _Ctype_fac, const numpunct<_CharT>& _Numpunct_fac) {
+            constexpr istreambuf_iterator<_CharT, _Traits> _Last{};
+
+            while (_First != _Last && _Ctype_fac.is(ctype_base::space, *_First) && _Width > 0) {
+                ++_First;
+                --_Width;
+            }
+
+            int _Second_        = 0;
+            int64_t _Subsecond_ = 0;
+            int64_t _Multiplier = _SubsecondType::period::den;
+            bool _Found_point   = false;
+            bool _Found_digit   = false;
+
+            while (_First != _Last && _Width > 0 && _Multiplier >= 10) {
+                const auto _Ch = *_First;
+                if (_Ch == _Numpunct_fac.decimal_point() && !_Found_point) {
+                    _Found_point = true;
+                } else if (_Ctype_fac.is(ctype_base::digit, _Ch)) {
+                    _Found_digit      = true;
+                    const auto _Digit = _Ctype_fac.narrow(_Ch) - '0';
+                    if (_Found_point) {
+                        _Multiplier /= 10;
+                        _Subsecond_ += _Digit * _Multiplier;
+                    } else {
+                        if (_Second_ > ((numeric_limits<int>::max)() - _Digit) / 10) {
+                            return ios_base::failbit;
+                        }
+
+                        _Second_ = _Second_ * 10 + _Digit;
+                    }
+                } else {
+                    break;
+                }
+                ++_First;
+                --_Width;
+            }
+
+            ios_base::iostate _State = ios_base::goodbit;
+            if (_First == _Last) {
+                _State |= ios_base::eofbit;
+            }
+
+            if (!(_Found_digit && _Update(_Second, _Second_) && _Update(_Subsecond, _Subsecond_))) {
+                _State |= ios_base::failbit;
+            }
+
+            return _State;
+        }
+
+        template <class _CharT, class _Traits>
+        _NODISCARD ios_base::iostate _Get_int(istreambuf_iterator<_CharT, _Traits>& _First, unsigned int _Width,
+            int& _Val, const ctype<_CharT>& _Ctype_fac) {
+            constexpr istreambuf_iterator<_CharT, _Traits> _Last{};
+
+            while (_First != _Last && _Ctype_fac.is(ctype_base::space, *_First) && _Width > 0) {
+                ++_First;
+                --_Width;
+            }
+
+            char _Ac[_Max_int_dig];
+            char* _Ptr = _Ac;
+            if (_First != _Last && _Width > 0) {
+                const char _Ch = _Ctype_fac.narrow(*_First);
+                if (_Ch == '+' || _Ch == '-') { // copy sign
+                    *_Ptr++ = _Ch;
+                    ++_First;
+                    --_Width;
+                }
+            }
+
+            bool _Has_leading_zero = false;
+            while (_First != _Last && _Width > 0 && _Ctype_fac.narrow(*_First) == '0') { // strip leading zeros
+                ++_First;
+                --_Width;
+                _Has_leading_zero = true;
+            }
+
+            if (_Has_leading_zero) {
+                *_Ptr++ = '0';
+            }
+
+            char _Ch;
+            while (_First != _Last && _Width > 0 && '0' <= (_Ch = _Ctype_fac.narrow(*_First))
+                   && _Ch <= '9') { // copy digits
+                if (_Ptr < _STD cend(_Ac) - 1) { // preserve room for the null terminator written below
+                    *_Ptr = _Ch;
+                    ++_Ptr; // drop trailing digits if already too large
+                }
+                ++_First;
+                --_Width;
+            }
+
+            *_Ptr      = '\0';
+            int _Errno = 0;
+            char* _Ep;
+            const long _Ans          = _CSTD _Stolx(_Ac, &_Ep, 10, &_Errno);
+            ios_base::iostate _State = ios_base::goodbit;
+
+            if (_First == _Last) {
+                _State |= ios_base::eofbit;
+            }
+
+            if (_Ep == _Ac || _Errno != 0) {
+                _State |= ios_base::failbit; // bad conversion
+            } else {
+                _Val = _Ans; // store valid result
+            }
+
+            return _State;
+        }
+
+        template <class _CharT, class _Traits>
+        _NODISCARD ios_base::iostate _Get_tz_offset(istreambuf_iterator<_CharT, _Traits>& _First,
+            const ctype<_CharT>& _Ctype_fac, const bool _Is_modified, int& _Offset) {
+            constexpr istreambuf_iterator<_CharT, _Traits> _Last{};
+            if (_First == _Last) {
+                return ios_base::eofbit;
+            }
+
+            bool _Negative = false;
+            switch (_Ctype_fac.narrow(*_First)) {
+            case '-':
+                _Negative = true;
+                [[fallthrough]];
+            case '+':
+                ++_First;
+                break;
+            default:
+                break;
+            }
+
+            // For a regular offset hh[mm], simply read four digits, with the option of an EOF or non-digit after
+            // reading two. The modified form h[h][:mm] is similar, except for the following points:
+            //  (a) an EOF or non-digit is allowable after reading *one* digit, not two.
+            //  (b) after reading one digit, another optional digit keeps us in the same state, except for decrementing
+            //      the number of optional digits allowed. In this state, reading a ':' allows parsing to continue.
+
+            int _Tz_hours        = 0;
+            int _Tz_minutes      = 0;
+            int _Optional_digits = 1;
+            for (int _Count = 0; _Count < 4; ++_Count) {
+                const bool _Allow_match_fail{_Count == (_Is_modified ? 1 : 2)};
+
+                if (_First == _Last) {
+                    if (_Allow_match_fail) {
+                        break;
+                    } else {
+                        return ios_base::eofbit | ios_base::failbit;
+                    }
+                }
+
+                const char _Ch       = _Ctype_fac.narrow(*_First++);
+                const bool _Is_digit = ('0' <= _Ch && _Ch <= '9');
+                if (_Is_modified && _Count == 1) {
+                    if (_Ch == ':') {
+                        continue;
+                    } else if (_Is_digit && _Optional_digits > 0) {
+                        _Tz_hours = 10 * _Tz_hours + (_Ch - '0');
+                        --_Optional_digits;
+                        --_Count;
+                    } else {
+                        if (_Allow_match_fail) {
+                            break;
+                        } else {
+                            return ios_base::failbit;
+                        }
+                    }
+                } else if (_Is_digit) {
+                    auto& _Part = _Count < 2 ? _Tz_hours : _Tz_minutes;
+                    _Part       = 10 * _Part + (_Ch - '0');
+                } else {
+                    if (_Allow_match_fail) {
+                        break;
+                    } else {
+                        return ios_base::failbit;
+                    }
+                }
+            }
+
+            _Offset = 60 * _Tz_hours + _Tz_minutes;
+            if (_Negative) {
+                _Offset = -_Offset;
+            }
+            return ios_base::goodbit;
+        }
+
+        template <class _CharT, class _Traits>
+        _NODISCARD ios_base::iostate _Get_tz_name(
+            istreambuf_iterator<_CharT, _Traits>& _First, const ctype<_CharT>& _Ctype_fac, string& _Tz_name) {
+            constexpr istreambuf_iterator<_CharT, _Traits> _Last{};
+            _Tz_name.clear();
+            while (_First != _Last) {
+                const char _Ch{_Ctype_fac.narrow(*_First)};
+                if (_STD isalnum(static_cast<unsigned char>(_Ch)) || _Ch == '_' || _Ch == '/' || _Ch == '-'
+                    || _Ch == '+') {
+                    _Tz_name.push_back(_Ch);
+                    ++_First;
+                } else {
+                    break;
+                }
+            }
+            return _First == _Last ? ios_base::eofbit : ios_base::goodbit;
+        }
+
+        template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+        _Time_parse_fields(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _FmtFirst,
+            basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr,
+            unsigned int _Subsecond_precision = 0) {
+
+            using _Myis = basic_istream<_CharT, _Traits>;
+
+            const auto& _Ctype_fac       = _STD use_facet<ctype<_CharT>>(_Istr.getloc());
+            ios_base::iostate _State     = ios_base::goodbit;
+            const _CharT* const _FmtLast = _FmtFirst + _Traits::length(_FmtFirst);
+            const typename _Myis::sentry _Ok{_Istr, true};
+
+            istreambuf_iterator _First{_Istr};
+            constexpr decltype(_First) _Last{};
+
+            if (_Ok) {
+                _TRY_IO_BEGIN
+                for (; _FmtFirst != _FmtLast && (_State & ~ios_base::eofbit) == ios_base::goodbit; ++_FmtFirst) {
+                    if (_First == _Last) {
+                        // EOF is not an error if the remaining flags can match zero characters.
+                        for (; _FmtFirst != _FmtLast; ++_FmtFirst) {
+                            char _Flag{};
+                            if (_Ctype_fac.is(ctype_base::space, *_FmtFirst)) {
+                                _Flag = ' ';
+                            } else {
+                                if (_Ctype_fac.narrow(*_FmtFirst) == '%' && ++_FmtFirst != _FmtLast) {
+                                    _Flag = _Ctype_fac.narrow(*_FmtFirst);
+                                }
+                            }
+
+                            if (_Flag != ' ' && _Flag != 't') {
+                                _State |= ios_base::failbit | ios_base::eofbit;
+                                break;
+                            }
+                        }
+                        break;
+                    } else if (_Ctype_fac.narrow(*_FmtFirst) != '%') { // match literal element
+                        if (_Ctype_fac.is(ctype_base::space, *_FmtFirst)) {
+                            while (_First != _Last && _Ctype_fac.is(ctype_base::space, *_First)) {
+                                ++_First;
+                            }
+                        } else if (*_First == *_FmtFirst) {
+                            ++_First;
+                        } else {
+                            _State |= ios_base::failbit; // bad literal match
+                        }
+                    } else if (++_FmtFirst == _FmtLast) { // not enough for a valid flag
+                        _State |= ios_base::failbit;
+                    } else { // get flag after %
+                        char _Flag          = _Ctype_fac.narrow(*_FmtFirst);
+                        char _Modifier      = '\0';
+                        unsigned int _Width = 0;
+
+                        if (_Flag == 'E' || _Flag == 'O') {
+                            if (++_FmtFirst == _FmtLast) {
+                                _State |= ios_base::failbit;
+                                break;
+                            }
+                            _Modifier = _STD exchange(_Flag, _Ctype_fac.narrow(*_FmtFirst));
+                        } else if ('0' <= _Flag && _Flag <= '9') {
+                            _Width = static_cast<unsigned int>(_Flag - '0');
+                            while (++_FmtFirst != _FmtLast && _Ctype_fac.is(ctype_base::digit, *_FmtFirst)) {
+                                const auto _Digit = static_cast<unsigned int>(_Ctype_fac.narrow(*_FmtFirst) - '0');
+                                if (_Width > ((numeric_limits<unsigned int>::max)() - _Digit) / 10) {
+                                    _State |= ios_base::failbit;
+                                    break;
+                                }
+                                _Width = 10 * _Width + _Digit;
+                            }
+                            if (_FmtFirst == _FmtLast) {
+                                _State |= ios_base::failbit;
+                                break;
+                            }
+                            _Flag = _Ctype_fac.narrow(*_FmtFirst);
+                        }
+
+                        switch (_Flag) {
+                        case 'n': // exactly one space
+                            if (!_Ctype_fac.is(ctype_base::space, *_First++)) {
+                                _State |= ios_base::failbit;
+                            }
+                            break;
+
+                        case 't': // zero or one space
+                            if (_Ctype_fac.is(ctype_base::space, *_First)) {
+                                ++_First;
+                            }
+                            break;
+
+                        case '%':
+                            if (_Ctype_fac.narrow(*_First++) != '%') {
+                                _State |= ios_base::failbit;
+                            }
+                            break;
+
+                        default:
+                            _First = _Parse_time_field(_First, _Istr, _State, _Flag, _Modifier, _Width,
+                                _Subsecond_precision); // convert a single field
+                            break;
+                        }
+                    }
+                }
+
+                _CATCH_IO_(ios_base, _Istr)
+            }
+
+            if (!_Is_complete()) {
+                _State |= ios_base::failbit;
+            }
+
+            if (!(_State & ios_base::failbit)) {
+                if (_Offset != nullptr && _Utc_offset) {
+                    *_Offset = minutes{*_Utc_offset};
+                }
+
+                if (_Abbrev != nullptr && _Tz_name) {
+                    if constexpr (is_same_v<decltype(_Abbrev), string*>) {
+                        *_Abbrev = _STD move(*_Tz_name);
+                    } else {
+                        _Abbrev->clear();
+                        for (const char& _Ch : *_Tz_name) {
+                            _Abbrev->push_back(_Ctype_fac.widen(_Ch));
+                        }
+                    }
+                }
+            }
+
+            _Istr.setstate(_State);
+        }
+    };
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Rep, class _Period, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        duration<_Rep, _Period>& _Duration, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
+        minutes* _Offset = nullptr) {
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, hh_mm_ss<duration<_Rep, _Period>>::fractional_width};
+        if (_Istr && !_Time._Make_duration(_Duration)) {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, weekday& _Wd,
+        basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
+        if (_Istr && !_Time._Make_weekday(_Wd)) {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, day& _Day,
+        basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
+        if (_Istr && !_Time._Make_day(_Day)) {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        month& _Month, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
+        if (_Istr && !_Time._Make_month(_Month)) {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        month_day& _Md, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
+        if (_Istr && !_Time._Make_month_day(_Md)) {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, year& _Year,
+        basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
+        if (_Istr && !_Time._Make_year(_Year)) {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        year_month& _Ym, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
+        if (_Istr && !_Time._Make_year_month(_Ym)) {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        year_month_day& _Ymd, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
+        if (_Istr && !_Time._Make_year_month_day(_Ymd)) {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        utc_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
+        minutes* _Offset = nullptr) {
+        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
+        _Duration _Dur;
+        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_Leap_second_rep::_All)) {
+            _Tp = utc_time<_Duration>{_Dur};
+        } else {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        sys_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
+        minutes* _Offset = nullptr) {
+        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
+        _Duration _Dur;
+        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_Leap_second_rep::_None)) {
+            _Tp = sys_time<_Duration>{_Dur};
+        } else {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        tai_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
+        minutes* _Offset = nullptr) {
+        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
+        _Duration _Dur;
+        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_Leap_second_rep::_None)) {
+            _Tp = tai_time<_Duration>{_Dur + _CHRONO duration_cast<_Duration>(days{4383})};
+        } else {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        gps_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
+        chrono::minutes* _Offset = nullptr) {
+        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
+        _Duration _Dur;
+        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_Leap_second_rep::_None)) {
+            _Tp = gps_time<_Duration>{_Dur - _CHRONO duration_cast<_Duration>(days{3657})};
+        } else {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        file_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
+        chrono::minutes* _Offset = nullptr) {
+        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
+        _Duration _Dur;
+        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_Leap_second_rep::_File_time)) {
+            constexpr auto _File_clock_adj{_CHRONO duration_cast<_Duration>(
+                filesystem::_File_time_clock::duration{filesystem::__std_fs_file_time_epoch_adjustment})};
+            _Tp = file_time<_Duration>{_Dur} + _File_clock_adj;
+        } else {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
+    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
+        local_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
+        minutes* _Offset = nullptr) {
+        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
+        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
+        // *_Offset is not subtracted from local_time, see N4950 [time.clock.local]/4.
+        _Time._Utc_offset.reset();
+        _Duration _Dur;
+        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_Leap_second_rep::_None)) {
+            _Tp = local_time<_Duration>{_Dur};
+        } else {
+            _Istr.setstate(ios_base::failbit);
+        }
+        return _Istr;
+    }
+
+    namespace _From_stream_adl_only {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void from_stream() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void from_stream();
+#endif // ^^^ workaround ^^^
+
+        template <class _Parsable, class _CharT, class _Traits, class... _Rest>
+        concept _Can_from_stream = requires(
+            basic_istream<_CharT, _Traits>& __istr, const _CharT* __s, _Parsable& __parsed, _Rest&&... __rest_args) {
+            from_stream(__istr, +__s, __parsed, _STD forward<_Rest>(__rest_args)...); // intentional ADL
+        };
+    } // namespace _From_stream_adl_only
+
+    using _From_stream_adl_only::_Can_from_stream;
+
+    template <class _CharT, class _Traits, class _Alloc, class _Parsable>
+    struct _Time_parse_iomanip_c_str {
+        _Time_parse_iomanip_c_str(const _CharT* _Fmt_, _Parsable& _Tp_,
+            basic_string<_CharT, _Traits, _Alloc>* _Abbrev_ = nullptr, minutes* _Offset_ = nullptr)
+            : _Fmt{_Fmt_}, _Tp{_Tp_}, _Abbrev{_Abbrev_}, _Offset{_Offset_} {}
+
+        _Time_parse_iomanip_c_str(_Time_parse_iomanip_c_str&&) = delete;
+
+        friend basic_istream<_CharT, _Traits>& operator>>(
+            basic_istream<_CharT, _Traits>& _Is, _Time_parse_iomanip_c_str&& _Tpi) {
+            using _From_stream_adl_only::from_stream;
+            from_stream(_Is, _Tpi._Fmt, _Tpi._Tp, _Tpi._Abbrev, _Tpi._Offset); // intentional ADL
+            return _Is;
+        }
+
+        const _CharT* _Fmt;
+        _Parsable& _Tp;
+        basic_string<_CharT, _Traits, _Alloc>* _Abbrev;
+        minutes* _Offset;
+    };
+
+    template <class _CharT, class _Traits, class _Alloc, class _Parsable>
+    struct _Time_parse_iomanip {
+        _Time_parse_iomanip(const basic_string<_CharT, _Traits, _Alloc>& _Fmt_, _Parsable& _Tp_,
+            basic_string<_CharT, _Traits, _Alloc>* _Abbrev_ = nullptr, minutes* _Offset_ = nullptr)
+            : _Fmt{_Fmt_}, _Tp{_Tp_}, _Abbrev{_Abbrev_}, _Offset{_Offset_} {}
+
+        _Time_parse_iomanip(_Time_parse_iomanip&&) = delete;
+
+        friend basic_istream<_CharT, _Traits>& operator>>(
+            basic_istream<_CharT, _Traits>& _Is, _Time_parse_iomanip&& _Tpi) {
+            using _From_stream_adl_only::from_stream;
+            from_stream(_Is, _Tpi._Fmt.c_str(), _Tpi._Tp, _Tpi._Abbrev, _Tpi._Offset); // intentional ADL
+            return _Is;
+        }
+
+        const basic_string<_CharT, _Traits, _Alloc>& _Fmt;
+        _Parsable& _Tp;
+        basic_string<_CharT, _Traits, _Alloc>* _Abbrev;
+        minutes* _Offset;
+    };
+
+    _EXPORT_STD template <class _CharT, _Can_from_stream<_CharT, char_traits<_CharT>> _Parsable>
+    _NODISCARD auto parse(const _CharT* _Fmt, _Parsable& _Tp) {
+        return _Time_parse_iomanip_c_str<_CharT, char_traits<_CharT>, allocator<_CharT>, _Parsable>{_Fmt, _Tp};
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc, _Can_from_stream<_CharT, _Traits> _Parsable>
+    _NODISCARD auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp) {
+        return _Time_parse_iomanip{_Fmt, _Tp};
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc,
+        _Can_from_stream<_CharT, _Traits, basic_string<_CharT, _Traits, _Alloc>*> _Parsable>
+    _NODISCARD auto parse(const _CharT* _Fmt, _Parsable& _Tp, basic_string<_CharT, _Traits, _Alloc>& _Abbrev) {
+        return _Time_parse_iomanip_c_str{_Fmt, _Tp, _STD addressof(_Abbrev)};
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc,
+        _Can_from_stream<_CharT, _Traits, basic_string<_CharT, _Traits, _Alloc>*> _Parsable>
+    _NODISCARD auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp,
+        basic_string<_CharT, _Traits, _Alloc>& _Abbrev) {
+        return _Time_parse_iomanip{_Fmt, _Tp, _STD addressof(_Abbrev)};
+    }
+
+    _EXPORT_STD template <class _CharT,
+        _Can_from_stream<_CharT, char_traits<_CharT>, basic_string<_CharT>*, minutes*> _Parsable>
+    _NODISCARD auto parse(const _CharT* _Fmt, _Parsable& _Tp, minutes& _Offset) {
+        return _Time_parse_iomanip_c_str{_Fmt, _Tp, static_cast<basic_string<_CharT>*>(nullptr), &_Offset};
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc,
+        _Can_from_stream<_CharT, _Traits, basic_string<_CharT, _Traits, _Alloc>*, minutes*> _Parsable>
+    _NODISCARD auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp, minutes& _Offset) {
+        return _Time_parse_iomanip{_Fmt, _Tp, static_cast<basic_string<_CharT, _Traits, _Alloc>*>(nullptr), &_Offset};
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc,
+        _Can_from_stream<_CharT, _Traits, basic_string<_CharT, _Traits, _Alloc>*, minutes*> _Parsable>
+    _NODISCARD auto parse(
+        const _CharT* _Fmt, _Parsable& _Tp, basic_string<_CharT, _Traits, _Alloc>& _Abbrev, minutes& _Offset) {
+        return _Time_parse_iomanip_c_str{_Fmt, _Tp, _STD addressof(_Abbrev), &_Offset};
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Alloc,
+        _Can_from_stream<_CharT, _Traits, basic_string<_CharT, _Traits, _Alloc>*, minutes*> _Parsable>
+    _NODISCARD auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp,
+        basic_string<_CharT, _Traits, _Alloc>& _Abbrev, minutes& _Offset) {
+        return _Time_parse_iomanip{_Fmt, _Tp, _STD addressof(_Abbrev), &_Offset};
+    }
+} // namespace chrono
+
+// [time.format]
+
+template <class _Ty, class _CharT>
+concept _Chrono_parse_spec_callbacks =
+    _Parse_align_callbacks<_Ty, _CharT> && _Parse_width_callbacks<_Ty, _CharT>
+    && _Parse_precision_callbacks<_Ty, _CharT> && _Width_adapter_callbacks<_Ty, _CharT>
+    && _Precision_adapter_callbacks<_Ty, _CharT> && requires(_Ty _At, basic_string_view<_CharT> _Sv, _Fmt_align _Aln) {
+           { _At._On_conversion_spec(char{}, _CharT{}) } -> same_as<void>;
+           { _At._On_lit_char(_CharT{}) } -> same_as<void>;
+       };
+
+template <class _Ty>
+concept _Has_ok = requires(_Ty _At) {
+    { _At.ok() } -> same_as<bool>;
+};
+
+// A chrono spec is either a type (with an optional modifier), OR a literal character, never both.
+template <class _CharT>
+struct _Chrono_spec {
+    _CharT _Lit_char{'\0'}; // any character other than '{', '}', or '%'
+    char _Modifier = '\0'; // either 'E' or 'O'
+    char _Type     = '\0';
+};
+
+template <class _CharT>
+struct _Chrono_format_specs {
+    int _Width                   = 0;
+    int _Precision               = -1;
+    int _Dynamic_width_index     = -1;
+    int _Dynamic_precision_index = -1;
+    _Fmt_align _Alignment        = _Fmt_align::_None;
+    uint8_t _Fill_length         = 1;
+    bool _Localized              = false;
+    // At most one codepoint (so one char32_t or four utf-8 char8_t)
+    _CharT _Fill[4 / sizeof(_CharT)] = {_CharT{' '}};
+    // recursive definition in grammar, so could have any number of these
+    vector<_Chrono_spec<_CharT>> _Chrono_specs_list;
+};
+
+// Model of _Chrono_parse_spec_callbacks that fills a _Chrono_format_specs with the parsed data
+template <class _CharT, class _ParseContext>
+class _Chrono_specs_setter {
+public:
+    constexpr explicit _Chrono_specs_setter(_Chrono_format_specs<_CharT>& _Specs_, _ParseContext& _Parse_ctx_)
+        : _Specs(_Specs_), _Parse_ctx(_Parse_ctx_) {}
+
+    // same as _Specs_setter
+    constexpr void _On_align(_Fmt_align _Aln) {
+        _Specs._Alignment = _Aln;
+    }
+
+    // same as _Specs_setter
+    constexpr void _On_fill(basic_string_view<_CharT> _Sv) {
+        if (_Sv.size() > _STD size(_Specs._Fill)) {
+            _STD _Throw_format_error("Invalid fill (too long).");
+        }
+
+        const auto _Pos = _STD _Copy_unchecked(_Sv._Unchecked_begin(), _Sv._Unchecked_end(), _Specs._Fill);
+        _STD fill(_Pos, _STD end(_Specs._Fill), _CharT{});
+        _Specs._Fill_length = static_cast<uint8_t>(_Sv.size());
+    }
+
+    constexpr void _On_width(int _Width) {
+        _Specs._Width = _Width;
+    }
+
+    constexpr void _On_precision(int _Prec) {
+        _Specs._Precision = _Prec;
+    }
+
+    constexpr void _On_dynamic_width(const size_t _Arg_id) {
+        _Parse_ctx.check_arg_id(_Arg_id);
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_dynamic_width(_Auto_id_tag) {
+        const size_t _Arg_id = _Parse_ctx.next_arg_id();
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_dynamic_precision(const size_t _Arg_id) {
+        _Parse_ctx.check_arg_id(_Arg_id);
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Specs._Dynamic_precision_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_dynamic_precision(_Auto_id_tag) {
+        const size_t _Arg_id = _Parse_ctx.next_arg_id();
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Specs._Dynamic_precision_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_localized() {
+        _Specs._Localized = true;
+    }
+
+    constexpr void _On_conversion_spec(char _Modifier, _CharT _Type) {
+        if (_Modifier != '\0' && _Modifier != 'E' && _Modifier != 'O') {
+            _STD _Throw_format_error("Invalid modifier specification.");
+        }
+
+        if (_Type < 0 || _Type > (numeric_limits<signed char>::max)()) {
+            _STD _Throw_format_error("Invalid type specification.");
+        }
+
+        _Chrono_spec<_CharT> _Conv_spec{._Modifier = _Modifier, ._Type = static_cast<char>(_Type)};
+        _Specs._Chrono_specs_list.push_back(_Conv_spec);
+    }
+
+    constexpr void _On_lit_char(_CharT _Lit_ch) {
+        _Chrono_spec<_CharT> _Lit_char_spec{._Lit_char = _Lit_ch};
+        _Specs._Chrono_specs_list.push_back(_Lit_char_spec);
+    }
+
+private:
+    _Chrono_format_specs<_CharT>& _Specs;
+    _ParseContext& _Parse_ctx;
+
+    _NODISCARD static constexpr int _Verify_dynamic_arg_index_in_range(const size_t _Idx) {
+        if (!_STD in_range<int>(_Idx)) {
+            _STD _Throw_format_error("Dynamic width or precision index too large.");
+        }
+
+        return static_cast<int>(_Idx);
+    }
+};
+
+// assumes that the required '%' at the beginning of a conversion-spec has already been consumed
+template <class _CharT, _Chrono_parse_spec_callbacks<_CharT> _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_conversion_specs(
+    const _CharT* _Begin, const _CharT* _End, _Callbacks_type&& _Callbacks) {
+    if (_Begin == _End || *_Begin == '}') {
+        _STD _Throw_format_error("Invalid format string.");
+    }
+
+    char _Mod  = '\0';
+    _CharT _Ch = *_Begin;
+
+    if (_Ch == 'E' || _Ch == 'O') { // includes modifier
+        _Mod = static_cast<char>(_Ch);
+        ++_Begin;
+        if (_Begin == _End || *_Begin == '}') {
+            _STD _Throw_format_error("Invalid format string - missing type after modifier.");
+        }
+    }
+
+    _CharT _Type = *_Begin;
+    _Callbacks._On_conversion_spec(_Mod, _Type);
+
+    return ++_Begin;
+}
+
+template <class _CharT, _Chrono_parse_spec_callbacks<_CharT> _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_chrono_format_specs(
+    const _CharT* _Begin, const _CharT* _End, _Callbacks_type&& _Callbacks) {
+    if (_Begin == _End || *_Begin == '}') {
+        return _Begin;
+    }
+
+    _Begin = _STD _Parse_align(_Begin, _End, _Callbacks);
+    if (_Begin == _End) {
+        return _Begin;
+    }
+
+    _Begin = _STD _Parse_width(_Begin, _End, _Callbacks);
+    if (_Begin == _End) {
+        return _Begin;
+    }
+
+    if (*_Begin == '.') {
+        _Begin = _STD _Parse_precision(_Begin, _End, _Callbacks);
+        if (_Begin == _End) {
+            return _Begin;
+        }
+    }
+
+    if (*_Begin == 'L') {
+        _Callbacks._On_localized();
+        ++_Begin;
+        if (_Begin == _End) {
+            return _Begin;
+        }
+    }
+
+    if (*_Begin != '}' && *_Begin != '%') {
+        _STD _Throw_format_error("Invalid format string - chrono-specs must begin with conversion-spec");
+    }
+
+    // chrono-spec
+    while (_Begin != _End && *_Begin != '}') {
+        // Note that in this loop, ++_Begin is safe (and we don't need _Fmt_codec)
+        // because '%' isn't used as a non-lead-byte in any supported multibyte encoding.
+        if (*_Begin == '%') { // conversion-spec
+            if (++_Begin == _End) {
+                _STD _Throw_format_error("Invalid format string - missing type after %");
+            }
+
+            switch (*_Begin) {
+            case 'n':
+                _Callbacks._On_lit_char('\n');
+                ++_Begin;
+                break;
+            case 't':
+                _Callbacks._On_lit_char('\t');
+                ++_Begin;
+                break;
+            case '%':
+                _Callbacks._On_lit_char('%');
+                ++_Begin;
+                break;
+            default: // some other type
+                _Begin = _STD _Parse_conversion_specs(_Begin, _End, _Callbacks);
+                break;
+            }
+        } else { // literal-char
+            _Callbacks._On_lit_char(*_Begin);
+            ++_Begin;
+        }
+    }
+
+    return _Begin;
+}
+
+namespace chrono {
+    template <class _Duration>
+    struct _Local_time_format_t {
+        local_time<_Duration> _Time;
+        const string* _Abbrev      = nullptr;
+        const seconds* _Offset_sec = nullptr;
+
+        template <class _CharT, class _Traits>
+        friend basic_ostream<_CharT, _Traits>& operator<<(
+            basic_ostream<_CharT, _Traits>& _Os, const _Local_time_format_t& _Val) {
+            // Doesn't appear in the Standard, but allowed by N4950 [global.functions]/2.
+            // Implements N4950 [time.zone.zonedtime.nonmembers]/2 for zoned_time.
+            return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T %Z}"), _Val);
+        }
+    };
+
+    _EXPORT_STD template <class _Duration>
+    _NODISCARD _Local_time_format_t<_Duration> local_time_format(const local_time<_Duration> _Time,
+        const string* const _Abbrev = nullptr, const seconds* const _Offset_sec = nullptr) {
+        return {_Time, _Abbrev, _Offset_sec};
+    }
+
+    // Replacement for %S, as put_time does not honor writing fractional seconds.
+    template <class _CharT, class _Traits, class _Ty>
+    void _Write_seconds(basic_ostream<_CharT, _Traits>&, const _Ty&) {
+        _STL_INTERNAL_CHECK(false);
+    }
+
+    template <unsigned int _Fractional_width, class _CharT, class _Traits, class _Precision>
+    void _Write_fractional_seconds(
+        basic_ostream<_CharT, _Traits>& _Os, const seconds& _Seconds, const _Precision& _Subseconds) {
+        _Os << _STD format(_STATICALLY_WIDEN(_CharT, "{:02}"), _Seconds.count());
+        if constexpr (_Fractional_width > 0) {
+            _Os << _STD use_facet<numpunct<_CharT>>(_Os.getloc()).decimal_point();
+            if constexpr (treat_as_floating_point_v<typename _Precision::rep>) {
+                _Os << _STD format(
+                    _STATICALLY_WIDEN(_CharT, "{:0{}.0f}"), _STD floor(_Subseconds.count()), _Fractional_width);
+            } else {
+                _Os << _STD format(_STATICALLY_WIDEN(_CharT, "{:0{}}"), _Subseconds.count(), _Fractional_width);
+            }
+        }
+    }
+
+    template <class _CharT, class _Traits, class _Duration>
+    void _Write_seconds(basic_ostream<_CharT, _Traits>& _Os, const hh_mm_ss<_Duration>& _Val) {
+        _CHRONO _Write_fractional_seconds<hh_mm_ss<_Duration>::fractional_width>(
+            _Os, _Val.seconds(), _Val.subseconds());
+    }
+
+    template <class _CharT, class _Traits, class _Clock, class _Duration>
+    void _Write_seconds(basic_ostream<_CharT, _Traits>& _Os, const time_point<_Clock, _Duration>& _Val) {
+        if constexpr (is_same_v<_Clock, utc_clock>) {
+            const auto _Lsi = _CHRONO get_leap_second_info(_Val);
+            const auto _Dp =
+                _CHRONO floor<days>(_Val - _Lsi.elapsed) + _Lsi.elapsed - seconds{_Lsi.is_leap_second ? 1 : 0};
+            const hh_mm_ss _Hms{_Val - _Dp};
+            constexpr auto _Fractional_width = decltype(_Hms)::fractional_width;
+            if (_Lsi.is_leap_second) {
+                _CHRONO _Write_fractional_seconds<_Fractional_width>(
+                    _Os, _Hms.seconds() + seconds{60}, _Hms.subseconds());
+            } else {
+                _CHRONO _Write_fractional_seconds<_Fractional_width>(_Os, _Hms.seconds(), _Hms.subseconds());
+            }
+        } else {
+            const auto _Dp = _CHRONO floor<days>(_Val);
+            _CHRONO _Write_seconds(_Os, hh_mm_ss{_Val - _Dp});
+        }
+    }
+
+    template <class _CharT, class _Traits, class _Duration>
+    void _Write_seconds(basic_ostream<_CharT, _Traits>& _Os, const _Local_time_format_t<_Duration>& _Val) {
+        _CHRONO _Write_seconds(_Os, _Val._Time);
+    }
+
+    template <class _CharT, class _Traits, class _Rep, class _Period>
+    void _Write_seconds(basic_ostream<_CharT, _Traits>& _Os, const duration<_Rep, _Period>& _Val) {
+        _CHRONO _Write_seconds(_Os, hh_mm_ss{_Val});
+    }
+
+    template <class _Ty>
+    _NODISCARD tm _Fill_tm(const _Ty& _Val) {
+        if constexpr (_Is_specialization_v<_Ty, duration>) {
+            return _CHRONO _Fill_tm(hh_mm_ss{_Val});
+        } else if constexpr (_Is_specialization_v<_Ty, _Local_time_format_t>) {
+            return _CHRONO _Fill_tm(_Val._Time);
+        } else if constexpr (_Is_any_of_v<_Ty, year_month_weekday, year_month_weekday_last>) {
+            auto _Tm    = _CHRONO _Fill_tm(year_month_day{_Val});
+            _Tm.tm_wday = static_cast<int>(_Val.weekday().c_encoding());
+            return _Tm;
+        } else if constexpr (_Is_any_of_v<_Ty, sys_info, local_info>) {
+            return {}; // none of the valid conversion specifiers need tm fields
+        } else if constexpr (_Is_specialization_v<_Ty, time_point>) {
+            const auto _Dp = _CHRONO floor<days>(_Val);
+            const year_month_day _Ymd{_Dp};
+            const hh_mm_ss _Time{_Val - _Dp};
+            const auto _Hms = _CHRONO _Fill_tm(_Time);
+            auto _Tm        = _CHRONO _Fill_tm(_Ymd);
+            _Tm.tm_sec      = _Hms.tm_sec;
+            _Tm.tm_min      = _Hms.tm_min;
+            _Tm.tm_hour     = _Hms.tm_hour;
+            return _Tm;
+        } else {
+            unsigned int _Day   = 0;
+            unsigned int _Month = 0;
+            int _Year           = 0;
+            int _Yearday        = 0;
+            int _Weekday        = 0;
+            int _Hours          = 0;
+            int _Minutes        = 0;
+            int _Seconds        = 0;
+
+            if constexpr (is_same_v<_Ty, day>) {
+                _Day = static_cast<unsigned int>(_Val);
+            } else if constexpr (is_same_v<_Ty, month>) {
+                _Month = static_cast<unsigned int>(_Val);
+            } else if constexpr (is_same_v<_Ty, year>) {
+                _Year = static_cast<int>(_Val);
+            } else if constexpr (is_same_v<_Ty, weekday>) {
+                _Weekday = static_cast<int>(_Val.c_encoding());
+            } else if constexpr (_Is_any_of_v<_Ty, weekday_indexed, weekday_last>) {
+                _Weekday = static_cast<int>(_Val.weekday().c_encoding());
+            } else if constexpr (is_same_v<_Ty, month_day>) {
+                _Day   = static_cast<unsigned int>(_Val.day());
+                _Month = static_cast<unsigned int>(_Val.month());
+                if (_Val.month() == January) {
+                    _Yearday = static_cast<int>(_Day) - 1;
+                } else if (_Val.month() == February) {
+                    _Yearday = 31 + static_cast<int>(_Day) - 1;
+                }
+            } else if constexpr (is_same_v<_Ty, month_day_last>) {
+                _Month = static_cast<unsigned int>(_Val.month());
+                _Day   = static_cast<unsigned int>(_Last_day_table[(_Month - 1) & 0xF]);
+                if (_Val.month() == January) {
+                    _Yearday = 30;
+                }
+            } else if constexpr (is_same_v<_Ty, month_weekday>) {
+                _Month   = static_cast<unsigned int>(_Val.month());
+                _Weekday = static_cast<int>(_Val.weekday_indexed().weekday().c_encoding());
+            } else if constexpr (is_same_v<_Ty, month_weekday_last>) {
+                _Month   = static_cast<unsigned int>(_Val.month());
+                _Weekday = static_cast<int>(_Val.weekday_last().weekday().c_encoding());
+            } else if constexpr (is_same_v<_Ty, year_month>) {
+                _Month = static_cast<unsigned int>(_Val.month());
+                _Year  = static_cast<int>(_Val.year());
+            } else if constexpr (_Is_any_of_v<_Ty, year_month_day, year_month_day_last>) {
+                _Day   = static_cast<unsigned int>(_Val.day());
+                _Month = static_cast<unsigned int>(_Val.month());
+                _Year  = static_cast<int>(_Val.year());
+                if (_Val.ok()) {
+                    const year_month_day& _Ymd = _Val;
+                    _Weekday                   = _Ymd._Calculate_weekday();
+                    _Yearday = (static_cast<sys_days>(_Val) - static_cast<sys_days>(_Val.year() / January / 1)).count();
+                }
+            } else if constexpr (_Is_specialization_v<_Ty, hh_mm_ss>) {
+                _Hours   = _Val.hours().count();
+                _Minutes = _Val.minutes().count();
+                _Seconds = static_cast<int>(_Val.seconds().count());
+            }
+
+            tm _Tm{};
+            _Tm.tm_sec  = _Seconds;
+            _Tm.tm_min  = _Minutes;
+            _Tm.tm_hour = _Hours;
+            _Tm.tm_mday = static_cast<int>(_Day);
+            _Tm.tm_mon  = static_cast<int>(_Month) - 1;
+            _Tm.tm_year = _Year - 1900;
+            _Tm.tm_wday = _Weekday;
+            _Tm.tm_yday = _Yearday;
+            return _Tm;
+        }
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const day& _Val) {
+        return _Os << (_Val.ok() ? _STD format(_STATICALLY_WIDEN(_CharT, "{:%d}"), _Val)
+                                 : _STD format(_STATICALLY_WIDEN(_CharT, "{:%d} is not a valid day"), _Val));
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month& _Val) {
+        return _Os << (_Val.ok() ? _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%b}"), _Val)
+                                 : _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{} is not a valid month"),
+                                       static_cast<unsigned int>(_Val)));
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year& _Val) {
+        return _Os << (_Val.ok() ? _STD format(_STATICALLY_WIDEN(_CharT, "{:%Y}"), _Val)
+                                 : _STD format(_STATICALLY_WIDEN(_CharT, "{:%Y} is not a valid year"), _Val));
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday& _Val) {
+        return _Os << (_Val.ok() ? _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%a}"), _Val)
+                                 : _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{} is not a valid weekday"),
+                                       _Val.c_encoding()));
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday_indexed& _Val) {
+        const auto _Idx = _Val.index();
+        return _Os << (_Idx >= 1 && _Idx <= 5
+                           ? _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}[{}]"), _Val.weekday(), _Idx)
+                           : _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}[{} is not a valid index]"),
+                                 _Val.weekday(), _Idx));
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday_last& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}[last]"), _Val.weekday());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_day& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}/{}"), _Val.month(), _Val.day());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_day_last& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}/last"), _Val.month());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_weekday& _Val) {
+        return _Os << _STD format(
+                   _Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}/{:L}"), _Val.month(), _Val.weekday_indexed());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_weekday_last& _Val) {
+        return _Os << _STD format(
+                   _Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L}/{:L}"), _Val.month(), _Val.weekday_last());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{}/{:L}"), _Val.year(), _Val.month());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_day& _Val) {
+        return _Os << (_Val.ok() ? _STD format(_STATICALLY_WIDEN(_CharT, "{:%F}"), _Val)
+                                 : _STD format(_STATICALLY_WIDEN(_CharT, "{:%F} is not a valid date"), _Val));
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_day_last& _Val) {
+        return _Os << _STD format(
+                   _Os.getloc(), _STATICALLY_WIDEN(_CharT, "{}/{:L}"), _Val.year(), _Val.month_day_last());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_weekday& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{}/{:L}/{:L}"), _Val.year(), _Val.month(),
+                   _Val.weekday_indexed());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(
+        basic_ostream<_CharT, _Traits>& _Os, const year_month_weekday_last& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{}/{:L}/{:L}"), _Val.year(), _Val.month(),
+                   _Val.weekday_last());
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const hh_mm_ss<_Duration>& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%T}"), _Val);
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 4365) // 'argument': conversion from 'char' to 'const wchar_t', signed/unsigned mismatch
+    template <class _CharT>
+    _NODISCARD decltype(auto) _Widen_string(const string& _Str) {
+        if constexpr (is_same_v<_CharT, char>) {
+            return _Str;
+        } else {
+            return wstring{_Str.begin(), _Str.end()}; // TRANSITION, should probably use ctype::widen
+        }
+    }
+#pragma warning(pop)
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_info& _Val) {
+        return _Os << _STD format(_Os.getloc(),
+                   _STATICALLY_WIDEN(_CharT, "begin: {}, end: {}, offset: {}, save: {}, abbrev: {}"), //
+                   _Val.begin, _Val.end, _Val.offset, _Val.save, _CHRONO _Widen_string<_CharT>(_Val.abbrev));
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const local_info& _Val) {
+        switch (_Val.result) {
+        case local_info::unique:
+            return _Os << _STD format(_Os.getloc(), //
+                       _STATICALLY_WIDEN(_CharT, "result: unique, first: ({})"), //
+                       _Val.first);
+        case local_info::nonexistent:
+            return _Os << _STD format(_Os.getloc(),
+                       _STATICALLY_WIDEN(_CharT, "result: nonexistent, first: ({}), second: ({})"), //
+                       _Val.first, _Val.second);
+        case local_info::ambiguous:
+            return _Os << _STD format(_Os.getloc(),
+                       _STATICALLY_WIDEN(_CharT, "result: ambiguous, first: ({}), second: ({})"), //
+                       _Val.first, _Val.second);
+        default:
+            return _Os << _STD format(_Os.getloc(), //
+                       _STATICALLY_WIDEN(_CharT, "result: {}, first: ({}), second: ({})"), //
+                       _Val.result, _Val.first, _Val.second);
+        }
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
+        requires (!treat_as_floating_point_v<typename _Duration::rep> && _Duration{1} < days{1})
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_time<_Duration>& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_days& _Val) {
+        return _Os << year_month_day{_Val};
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const utc_time<_Duration>& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const tai_time<_Duration>& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const gps_time<_Duration>& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const file_time<_Duration>& _Val) {
+        return _Os << _STD format(_Os.getloc(), _STATICALLY_WIDEN(_CharT, "{:L%F %T}"), _Val);
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration>
+    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const local_time<_Duration>& _Val)
+        requires requires { _Os << sys_time<_Duration>{_Val.time_since_epoch()}; }
+    {
+        return _Os << sys_time<_Duration>{_Val.time_since_epoch()};
+    }
+
+    _EXPORT_STD template <class _CharT, class _Traits, class _Duration, class _TimeZonePtr>
+    basic_ostream<_CharT, _Traits>& operator<<(
+        basic_ostream<_CharT, _Traits>& _Os, const zoned_time<_Duration, _TimeZonePtr>& _Val) {
+        const auto _Info = _Val.get_info();
+        return _Os << _Local_time_format_t<common_type_t<_Duration, seconds>>{_Val.get_local_time(), &_Info.abbrev};
+    }
+
+    template <class _CharT>
+    _NODISCARD const _CharT* _Fmt_string(const _Chrono_spec<_CharT>& _Spec, _CharT (&_Fmt_str)[4]) {
+        size_t _Next_idx      = 0;
+        _Fmt_str[_Next_idx++] = _CharT{'%'};
+        if (_Spec._Modifier != '\0') {
+            _Fmt_str[_Next_idx++] = static_cast<_CharT>(_Spec._Modifier);
+        }
+        _Fmt_str[_Next_idx++] = static_cast<_CharT>(_Spec._Type);
+        _Fmt_str[_Next_idx]   = _CharT{'\0'};
+        return _Fmt_str;
+    }
+
+    template <class _CharT>
+    struct _Chrono_formatter {
+        _Chrono_formatter() = default;
+
+        constexpr explicit _Chrono_formatter(const basic_string_view<_CharT> _Time_zone_abbreviation_)
+            : _Time_zone_abbreviation{_Time_zone_abbreviation_} {}
+
+        template <class _Ty>
+        _NODISCARD constexpr auto _Parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
+            _Chrono_specs_setter<_CharT, basic_format_parse_context<_CharT>> _Callback{_Specs, _Parse_ctx};
+            const auto _It =
+                _STD _Parse_chrono_format_specs(_Parse_ctx._Unchecked_begin(), _Parse_ctx._Unchecked_end(), _Callback);
+            const auto _Res_iter = _Parse_ctx.begin() + (_It - _Parse_ctx._Unchecked_begin());
+
+            if (_It != _Parse_ctx._Unchecked_end() && *_It != '}') {
+                _STD _Throw_format_error("Missing '}' in format string.");
+            }
+
+            if constexpr (_Is_specialization_v<_Ty, duration>) {
+                if constexpr (!treat_as_floating_point_v<typename _Ty::rep>) {
+                    if (_Specs._Precision != -1) {
+                        _STD _Throw_format_error("Precision specification invalid for chrono::duration type with "
+                                                 "integral representation type, see N4950 [time.format]/1.");
+                    }
+                }
+            } else {
+                if (_Specs._Precision != -1) {
+                    _STD _Throw_format_error("Precision specification invalid for non-chrono::duration type, "
+                                             "see N4950 [time.format]/1.");
+                }
+            }
+
+            for (const auto& _Spec : _Specs._Chrono_specs_list) {
+                if (_Spec._Type != '\0' && !_Is_valid_type<_Ty>(_Spec._Type)) {
+                    _STD _Throw_format_error("Invalid type.");
+                }
+
+                if (!_Valid_modifier(_Spec._Type, _Spec._Modifier)) {
+                    _STD _Throw_format_error("Incompatible modifier for type");
+                }
+            }
+
+            return _Res_iter;
+        }
+
+        static constexpr bool _Valid_modifier(const char _Type, const char _Modifier) {
+            // N5014 [tab:time.format.spec] lists modified commands.
+            if (_Modifier == '\0') {
+                return true;
+            }
+
+            _STL_INTERNAL_CHECK(_Modifier == 'E' || _Modifier == 'O');
+
+            switch (_Type) {
+            case 'c':
+            case 'C':
+            case 'x':
+            case 'X':
+            case 'Y':
+                return _Modifier == 'E';
+
+            case 'd':
+            case 'e':
+            case 'H':
+            case 'I':
+            case 'm':
+            case 'M':
+            case 'S':
+            case 'u':
+            case 'U':
+            case 'V':
+            case 'w':
+            case 'W':
+                return _Modifier == 'O';
+
+            case 'y':
+            case 'z':
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        template <class _Ty>
+        _NODISCARD static constexpr bool _Is_valid_type(const char _Type) noexcept {
+            if constexpr (_Is_specialization_v<_Ty, duration>) {
+                return _Type == 'j' || _Type == 'q' || _Type == 'Q' || _Is_valid_type<hh_mm_ss<seconds>>(_Type);
+            } else if constexpr (is_same_v<_Ty, day>) {
+                return _Type == 'd' || _Type == 'e';
+            } else if constexpr (is_same_v<_Ty, month>) {
+                return _Type == 'b' || _Type == 'B' || _Type == 'h' || _Type == 'm';
+            } else if constexpr (is_same_v<_Ty, year>) {
+                return _Type == 'Y' || _Type == 'y' || _Type == 'C';
+            } else if constexpr (_Is_any_of_v<_Ty, weekday, weekday_indexed, weekday_last>) {
+                return _Type == 'a' || _Type == 'A' || _Type == 'u' || _Type == 'w';
+            } else if constexpr (_Is_any_of_v<_Ty, month_day, month_day_last>) {
+                return _Type == 'j' || _Is_valid_type<month>(_Type) || _Is_valid_type<day>(_Type);
+            } else if constexpr (_Is_any_of_v<_Ty, month_weekday, month_weekday_last>) {
+                return _Is_valid_type<month>(_Type) || _Is_valid_type<weekday>(_Type);
+            } else if constexpr (is_same_v<_Ty, year_month>) {
+                return _Type == 'g' || _Type == 'G' || _Is_valid_type<year>(_Type) || _Is_valid_type<month>(_Type);
+            } else if constexpr (_Is_any_of_v<_Ty, year_month_day, year_month_day_last, year_month_weekday,
+                                     year_month_weekday_last>) {
+                return _Type == 'D' || _Type == 'F' || _Type == 'g' || _Type == 'G' || _Type == 'j' || _Type == 'U'
+                    || _Type == 'V' || _Type == 'W' || _Type == 'x' || _Is_valid_type<year>(_Type)
+                    || _Is_valid_type<month>(_Type) || _Is_valid_type<day>(_Type) || _Is_valid_type<weekday>(_Type);
+            } else if constexpr (_Is_specialization_v<_Ty, hh_mm_ss>) {
+                return _Type == 'H' || _Type == 'I' || _Type == 'M' || _Type == 'S' || _Type == 'r' || _Type == 'R'
+                    || _Type == 'T' || _Type == 'p' || _Type == 'X';
+            } else if constexpr (_Is_any_of_v<_Ty, sys_info, local_info>) {
+                return _Type == 'z' || _Type == 'Z';
+            } else if constexpr (_Is_specialization_v<_Ty, time_point>) {
+                if constexpr (!is_same_v<typename _Ty::clock, local_t>) {
+                    if (_Type == 'z' || _Type == 'Z') {
+                        return true;
+                    }
+                }
+                return _Type == 'c' || _Is_valid_type<year_month_day>(_Type)
+                    || _Is_valid_type<hh_mm_ss<seconds>>(_Type);
+            } else if constexpr (_Is_specialization_v<_Ty, _Local_time_format_t>) {
+                return _Type == 'z' || _Type == 'Z' || _Is_valid_type<decltype(_Ty::_Time)>(_Type);
+            } else {
+                static_assert(false); // unexpected type
+            }
+        }
+
+        template <class _FormatContext, class _Ty>
+        _NODISCARD auto _Write(_FormatContext& _Format_ctx, const _Ty& _Val, const tm& _Time) const {
+            basic_ostringstream<_CharT> _Stream;
+
+            _Stream.imbue(_Specs._Localized ? _Format_ctx.locale() : locale::classic());
+            if (_Specs._Chrono_specs_list.empty()) {
+                _Stream << _Val; // N4950 [time.format]/7
+            } else {
+                if constexpr (_Is_specialization_v<_Ty, hh_mm_ss>) {
+                    if (_Val.is_negative()) {
+                        _Stream << _CharT{'-'};
+                    }
+                } else if constexpr (_Is_specialization_v<_Ty, duration>) {
+                    if (_Val < _Ty::zero()) {
+                        _Stream << _CharT{'-'};
+                    }
+                }
+
+                for (const auto& _Spec : _Specs._Chrono_specs_list) {
+                    if (_Spec._Lit_char != _CharT{'\0'}) {
+                        _Stream << _Spec._Lit_char;
+                        continue;
+                    }
+
+                    // We need to manually do certain writes, either because the specification is different from
+                    // put_time or custom logic is needed.
+                    if (_Custom_write(_Stream, _Spec, _Time, _Val)) {
+                        continue;
+                    }
+
+                    _Validate_specifiers(_Spec, _Val);
+
+#if defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET == 65001 // TRANSITION, VSO-1468747 (EDG)
+                    if constexpr (is_same_v<_CharT, char>) {
+                        if (_Specs._Localized) {
+                            wostringstream _Wstream;
+                            _Wstream.imbue(_Format_ctx.locale());
+
+                            wchar_t _Fmt_str[4];
+                            _Chrono_spec<wchar_t> _Wspec{._Modifier = _Spec._Modifier, ._Type = _Spec._Type};
+                            _Wstream << _STD put_time<wchar_t>(&_Time, _CHRONO _Fmt_string(_Wspec, _Fmt_str));
+
+                            _Stream << _STD _Convert_wide_to_narrow<char_traits<char>>(
+                                __std_code_page::_Utf8, _Wstream.view(), allocator<char>{});
+
+                            continue;
+                        }
+                    }
+#endif // ^^^ no workaround ^^^
+
+                    _CharT _Fmt_str[4];
+                    _Stream << _STD put_time<_CharT>(&_Time, _CHRONO _Fmt_string(_Spec, _Fmt_str));
+                }
+            }
+
+            int _Estimated_width = -1;
+            (void) _STD _Measure_string_prefix(_Stream.view(), _Estimated_width);
+
+            auto _Format_specs = _Specs;
+            if (_Specs._Dynamic_width_index >= 0) {
+                _Format_specs._Width = _STD _Get_dynamic_specs<_Width_checker>(
+                    _Format_ctx.arg(static_cast<size_t>(_Specs._Dynamic_width_index)));
+            }
+
+            return _STD _Write_aligned(_STD move(_Format_ctx.out()), _Estimated_width, _Format_specs, _Fmt_align::_Left,
+                [&](auto _Out) { return _STD _Fmt_write(_STD move(_Out), _Stream.view()); });
+        }
+
+        // This echoes the functionality of put_time, but is able to handle invalid dates (when !ok()) since the
+        // Standard mandates that invalid dates still be formatted properly.  For example, put_time isn't able to handle
+        // a tm_mday of 40, but format("{:%d}", day{40}) should return "40" and operator<< for day prints
+        // "40 is not a valid day".
+        template <class _Ty>
+        bool _Custom_write(
+            basic_ostream<_CharT>& _Os, const _Chrono_spec<_CharT>& _Spec, const tm& _Time, const _Ty& _Val) const {
+            if constexpr (is_same_v<_Ty, local_info>) {
+                if (_Val.result != local_info::unique) {
+                    _STD _Throw_format_error("Cannot print non-unique local_info");
+                }
+            }
+
+            const auto _Year         = _Time.tm_year + 1900;
+            const auto _Month        = _Time.tm_mon + 1;
+            const bool _Has_modifier = _Spec._Modifier != '\0';
+            switch (_Spec._Type) {
+            case 'd': // Print days as a decimal, even if invalid.
+            case 'e':
+                // Most months have a proper last day, but February depends on the year.
+                if constexpr (is_same_v<_Ty, month_day_last>) {
+                    if (_Val.month() == February) {
+                        _STD _Throw_format_error("Cannot print the last day of February without a year");
+                    }
+
+                    if (!_Val.ok()) {
+                        return false;
+                    }
+                }
+
+                if (_Has_modifier) {
+                    return false;
+                }
+
+                if (_Time.tm_mday < 10) {
+                    _Os << (_Spec._Type == 'd' ? _CharT{'0'} : _CharT{' '});
+                }
+                _Os << _Time.tm_mday;
+                return true;
+            case 'g':
+            case 'G':
+                if constexpr (is_same_v<_Ty, year_month>) {
+                    if (_Val.month() == January || _Val.month() == December) {
+                        _STD _Throw_format_error(
+                            "The ISO week-based year for a year_month of January or December is ambiguous.");
+                    }
+
+                    if (!_Val.ok()) {
+                        _STD _Throw_format_error(
+                            "The ISO week-based year for an out-of-bounds year_month is ambiguous.");
+                    }
+
+                    const char _Gregorian_type = _Spec._Type == 'g' ? 'y' : 'Y';
+                    _CharT _Fmt_str[4];
+                    _Os << _STD put_time(&_Time, _CHRONO _Fmt_string({._Type = _Gregorian_type}, _Fmt_str));
+                    return true;
+                } else {
+                    return false;
+                }
+            case 'r':
+                // put_time uses _Strftime in order to bypass reference-counting that locale uses. This function
+                // takes the locale information by pointer, but the pointer (from _Gettnames) returns a copy.
+                // _Strftime delegates to other functions but eventually (for the C locale) has the %r specifier
+                // rewritten. It checks for the locale by comparing pointers, which do not compare equal as we have
+                // a copy of the pointer instead of the original. Therefore, we replace %r for the C locale
+                // ourselves.
+                if (_Os.getloc() == locale::classic()) {
+                    _Os << _STD put_time(&_Time, _STATICALLY_WIDEN(_CharT, "%I:%M:%S %p"));
+                    return true;
+                }
+
+                return false;
+            case 'j':
+                if constexpr (_Is_specialization_v<_Ty, duration>) {
+                    _Os << _STD abs(_CHRONO _Duration_cast_underflow_to_zero<days>(_Val).count());
+                    return true;
+                } else {
+                    return false;
+                }
+            case 'q':
+                if constexpr (_Is_specialization_v<_Ty, duration>) {
+                    _CHRONO _Write_unit_suffix<typename _Ty::period>(_Os);
+                } else {
+                    _STL_INTERNAL_CHECK(false);
+                }
+                return true;
+            case 'Q':
+                if constexpr (_Is_specialization_v<_Ty, duration>) {
+                    if constexpr (is_unsigned_v<typename _Ty::rep>) {
+                        _Os << _Val.count();
+                    } else {
+                        _Os << _STD abs(_Val.count());
+                    }
+                } else {
+                    _STL_INTERNAL_CHECK(false);
+                }
+                return true;
+            case 'm': // Print months as a decimal, even if invalid.
+                if (_Has_modifier) {
+                    return false;
+                }
+
+                if (_Month < 10) {
+                    _Os << _CharT{'0'};
+                }
+                _Os << _Month;
+                return true;
+            case 'Y': // Print years as a decimal, even if invalid.
+                if (_Has_modifier) {
+                    return false;
+                }
+
+                if (_Year < 0) {
+                    _Os << _CharT{'-'};
+                }
+                _Os << _STD format(_STATICALLY_WIDEN(_CharT, "{:04}"), _STD abs(_Year));
+                return true;
+            case 'y': // Print the two-digit year as a decimal, even if invalid.
+                if (_Has_modifier) {
+                    return false;
+                }
+                _Os << _STD format(
+                    _STATICALLY_WIDEN(_CharT, "{:02}"), _Time_parse_fields::_Decompose_year(_Year).second);
+                return true;
+            case 'C': // Print the century as a decimal, even if invalid.
+                if (_Has_modifier) {
+                    return false;
+                }
+
+                if (_Year < 0) {
+                    _Os << _CharT{'-'};
+                }
+                _Os << _STD format(_STATICALLY_WIDEN(_CharT, "{:02}"),
+                    _STD abs(_Time_parse_fields::_Decompose_year(_Year).first) / 100);
+                return true;
+            case 'F': // Print YMD even if invalid.
+                _Custom_write(_Os, {._Type = 'Y'}, _Time, _Val);
+                _Os << _CharT{'-'};
+                _Custom_write(_Os, {._Type = 'm'}, _Time, _Val);
+                _Os << _CharT{'-'};
+                _Custom_write(_Os, {._Type = 'd'}, _Time, _Val);
+                return true;
+            case 'D': // Print YMD even if invalid.
+                _Custom_write(_Os, {._Type = 'm'}, _Time, _Val);
+                _Os << _CharT{'/'};
+                _Custom_write(_Os, {._Type = 'd'}, _Time, _Val);
+                _Os << _CharT{'/'};
+                _Custom_write(_Os, {._Type = 'y'}, _Time, _Val);
+                return true;
+            case 'H':
+                // Print hour even if >= 24.
+                _Os << _STD format(_STATICALLY_WIDEN(_CharT, "{:02}"), _Time.tm_hour);
+                return true;
+            case 'T':
+                // Alias for %H:%M:%S but we allow hours > 23 and rewrite %S to display fractions of a second.
+                _Os << _STD format(_STATICALLY_WIDEN(_CharT, "{:02}:{:02}:"), _Time.tm_hour, _Time.tm_min);
+                [[fallthrough]];
+            case 'S':
+                if (_Has_modifier) {
+                    return false;
+                }
+                _CHRONO _Write_seconds(_Os, _Val);
+                return true;
+            case 'Z':
+                if constexpr (is_same_v<_Ty, sys_info>) {
+                    _Os << _CHRONO _Widen_string<_CharT>(_Val.abbrev);
+                } else if constexpr (is_same_v<_Ty, local_info>) {
+                    _Os << _CHRONO _Widen_string<_CharT>(_Val.first.abbrev);
+                } else if constexpr (_Is_specialization_v<_Ty, _Local_time_format_t>) {
+                    if (_Val._Abbrev == nullptr) {
+                        _STD _Throw_format_error("Cannot print local-time-format-t with null abbrev.");
+                    }
+                    _Os << _CHRONO _Widen_string<_CharT>(*_Val._Abbrev);
+                } else {
+                    _Os << _Time_zone_abbreviation;
+                }
+                return true;
+            case 'z':
+                {
+                    hh_mm_ss<seconds> _Offset;
+
+                    if constexpr (is_same_v<_Ty, sys_info>) {
+                        _Offset = hh_mm_ss<seconds>{_Val.offset};
+                    } else if constexpr (is_same_v<_Ty, local_info>) {
+                        _Offset = hh_mm_ss<seconds>{_Val.first.offset};
+                    } else if constexpr (_Is_specialization_v<_Ty, _Local_time_format_t>) {
+                        if (_Val._Offset_sec == nullptr) {
+                            _STD _Throw_format_error("Cannot print local-time-format-t with null offset_sec.");
+                        }
+                        _Offset = hh_mm_ss<seconds>{*_Val._Offset_sec};
+                    } else {
+                        _Offset = hh_mm_ss<seconds>{};
+                    }
+
+                    const auto _Sign = _Offset.is_negative() ? _CharT{'-'} : _CharT{'+'};
+                    const auto _Separator =
+                        _Has_modifier ? _STATICALLY_WIDEN(_CharT, ":") : _STATICALLY_WIDEN(_CharT, "");
+
+                    _Os << _STD format(_STATICALLY_WIDEN(_CharT, "{}{:02}{}{:02}"), _Sign, _Offset.hours().count(),
+                        _Separator, _Offset.minutes().count());
+                    return true;
+                }
+            default:
+                return false;
+            }
+        }
+
+        template <class _Ty>
+        static void _Validate_specifiers(const _Chrono_spec<_CharT>& _Spec, const _Ty& _Val) {
+            if constexpr (_Is_specialization_v<_Ty, duration> || is_same_v<_Ty, sys_info>
+                          || _Is_specialization_v<_Ty, time_point> || _Is_specialization_v<_Ty, _Local_time_format_t>
+                          || _Is_specialization_v<_Ty, hh_mm_ss>) {
+                return;
+            } else {
+                const auto _Validate = [&] {
+                    constexpr bool _Is_ymd = _Is_any_of_v<_Ty, year_month_day, year_month_day_last, year_month_weekday,
+                        year_month_weekday_last>;
+
+                    switch (_Spec._Type) {
+                    case 'a':
+                    case 'A':
+                    case 'u':
+                    case 'w':
+                        if constexpr (_Is_any_of_v<_Ty, weekday, weekday_last>) {
+                            return _Val.ok();
+                        } else if constexpr (_Is_any_of_v<_Ty, weekday_indexed, year_month_weekday,
+                                                 year_month_weekday_last>) {
+                            return _Val.weekday().ok();
+                        } else if constexpr (is_same_v<_Ty, month_weekday>) {
+                            return _Val.weekday_indexed().weekday().ok();
+                        } else if constexpr (is_same_v<_Ty, month_weekday_last>) {
+                            return _Val.weekday_last().ok();
+                        } else if constexpr (_Is_any_of_v<_Ty, year_month_day, year_month_day_last>) {
+                            return _Val.ok();
+                        }
+                        break;
+
+                    case 'b':
+                    case 'B':
+                    case 'h':
+                    case 'm':
+                        if constexpr (is_same_v<_Ty, month>) {
+                            return _Val.ok();
+                        } else if constexpr (_Is_any_of_v<_Ty, month_day, month_day_last, month_weekday,
+                                                 month_weekday_last, year_month>
+                                             || _Is_ymd) {
+                            return _Val.month().ok();
+                        }
+                        break;
+
+                    case 'C':
+                    case 'y':
+                    case 'Y':
+                        if constexpr (is_same_v<_Ty, year>) {
+                            return _Val.ok();
+                        } else if constexpr (is_same_v<_Ty, year_month> || _Is_ymd) {
+                            return _Val.year().ok();
+                        }
+                        break;
+
+                    case 'd':
+                    case 'e':
+                        if constexpr (_Is_any_of_v<_Ty, day, month_day_last>) {
+                            return _Val.ok();
+                        } else if constexpr (is_same_v<_Ty, month_day>) {
+                            return _Val.day().ok();
+                        } else if constexpr (_Is_ymd) {
+                            const year_month_day& _Ymd{_Val};
+                            return _Ymd.day().ok();
+                        }
+                        break;
+
+                    case 'D':
+                    case 'F':
+                        if constexpr (_Has_ok<_Ty>) {
+                            return _Val.ok();
+                        }
+                        break;
+
+                    case 'j':
+                        if constexpr (is_same_v<_Ty, month_day>) {
+                            if (_Val.month() > February) {
+                                _STD _Throw_format_error("The day of year for a month_day past February is ambiguous.");
+                            }
+                            return true;
+                        } else if constexpr (is_same_v<_Ty, month_day_last>) {
+                            if (_Val.month() >= February) {
+                                _STD _Throw_format_error(
+                                    "The day of year for a month_day_last other than January is ambiguous");
+                            }
+                            return true;
+                        } else if constexpr (_Is_ymd) {
+                            return _Val.ok();
+                        }
+                        break;
+
+                    case 'g':
+                    case 'G':
+                    case 'U':
+                    case 'V':
+                    case 'W':
+                        if constexpr (_Is_ymd) {
+                            return _Val.ok();
+                        }
+                        break;
+
+                    default:
+                        if constexpr (_Has_ok<_Ty>) {
+                            return _Val.ok();
+                        }
+                        return true;
+                    }
+                    _STL_INTERNAL_CHECK(false);
+                    return false;
+                };
+                if (!_Validate()) {
+                    _STD _Throw_format_error("Cannot localize out-of-bounds time point.");
+                }
+            }
+        }
+
+        _Chrono_format_specs<_CharT> _Specs{};
+        basic_string_view<_CharT> _Time_zone_abbreviation{};
+    };
+} // namespace chrono
+
+template <class _Ty, class _CharT>
+struct _Fill_tm_formatter {
+    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
+        return _Impl.template _Parse<_Ty>(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    auto format(const _Ty& _Val, _FormatContext& _Format_ctx) const {
+        return _Impl._Write(_Format_ctx, _Val, _CHRONO _Fill_tm(_Val));
+    }
+
+private:
+    _CHRONO _Chrono_formatter<_CharT> _Impl;
+};
+
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+
+template <class _Rep, class _Period, _Format_supported_charT _CharT>
+struct formatter<_CHRONO duration<_Rep, _Period>, _CharT>
+    : _Fill_tm_formatter<_CHRONO duration<_Rep, _Period>, _CharT> {};
+
+#if _HAS_CXX23
+template <class _Rep, class _Period>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO duration<_Rep, _Period>> =
+    enable_nonlocking_formatter_optimization<_Rep>;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO day, _CharT> : _Fill_tm_formatter<_CHRONO day, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO day> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO month, _CharT> : _Fill_tm_formatter<_CHRONO month, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO month> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO year, _CharT> : _Fill_tm_formatter<_CHRONO year, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO year> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO weekday, _CharT> : _Fill_tm_formatter<_CHRONO weekday, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO weekday> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO weekday_indexed, _CharT> : _Fill_tm_formatter<_CHRONO weekday_indexed, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO weekday_indexed> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO weekday_last, _CharT> : _Fill_tm_formatter<_CHRONO weekday_last, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO weekday_last> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO month_day, _CharT> : _Fill_tm_formatter<_CHRONO month_day, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO month_day> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO month_day_last, _CharT> : _Fill_tm_formatter<_CHRONO month_day_last, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO month_day_last> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO month_weekday, _CharT> : _Fill_tm_formatter<_CHRONO month_weekday, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO month_weekday> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO month_weekday_last, _CharT> : _Fill_tm_formatter<_CHRONO month_weekday_last, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO month_weekday_last> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO year_month, _CharT> : _Fill_tm_formatter<_CHRONO year_month, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO year_month> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO year_month_day, _CharT> : _Fill_tm_formatter<_CHRONO year_month_day, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO year_month_day> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO year_month_day_last, _CharT> : _Fill_tm_formatter<_CHRONO year_month_day_last, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO year_month_day_last> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO year_month_weekday, _CharT> : _Fill_tm_formatter<_CHRONO year_month_weekday, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO year_month_weekday> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO year_month_weekday_last, _CharT>
+    : _Fill_tm_formatter<_CHRONO year_month_weekday_last, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO year_month_weekday_last> = true;
+#endif // _HAS_CXX23
+
+template <class _Rep, class _Period, _Format_supported_charT _CharT>
+struct formatter<_CHRONO hh_mm_ss<_CHRONO duration<_Rep, _Period>>, _CharT>
+    : _Fill_tm_formatter<_CHRONO hh_mm_ss<_CHRONO duration<_Rep, _Period>>, _CharT> {};
+
+#if _HAS_CXX23
+template <class _Rep, class _Period>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO hh_mm_ss<_CHRONO duration<_Rep, _Period>>> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO sys_info, _CharT> : _Fill_tm_formatter<_CHRONO sys_info, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO sys_info> = true;
+#endif // _HAS_CXX23
+
+template <_Format_supported_charT _CharT>
+struct formatter<_CHRONO local_info, _CharT> : _Fill_tm_formatter<_CHRONO local_info, _CharT> {};
+
+#if _HAS_CXX23
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<_CHRONO local_info> = true;
+#endif // _HAS_CXX23
+
+template <class _Duration, _Format_supported_charT _CharT>
+struct formatter<_CHRONO sys_time<_Duration>, _CharT> {
+    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
+        return _Impl.template _Parse<_CHRONO sys_time<_Duration>>(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    auto format(const _CHRONO sys_time<_Duration>& _Val, _FormatContext& _Format_ctx) const {
+        return _Impl._Write(_Format_ctx, _Val, _CHRONO _Fill_tm(_Val));
+    }
+
+private:
+    _CHRONO _Chrono_formatter<_CharT> _Impl{_STATICALLY_WIDEN(_CharT, "UTC")};
+};
+
+#if _HAS_CXX23
+template <class _Duration>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO sys_time<_Duration>> = true;
+#endif // _HAS_CXX23
+
+template <class _Duration, _Format_supported_charT _CharT>
+struct formatter<_CHRONO utc_time<_Duration>, _CharT> {
+    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
+        return _Impl.template _Parse<_CHRONO utc_time<_Duration>>(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    auto format(const _CHRONO utc_time<_Duration>& _Val, _FormatContext& _Format_ctx) const {
+        const auto _Sys = _CHRONO utc_clock::to_sys(_Val);
+        return _Impl._Write(_Format_ctx, _Val, _CHRONO _Fill_tm(_Sys));
+    }
+
+private:
+    _CHRONO _Chrono_formatter<_CharT> _Impl{_STATICALLY_WIDEN(_CharT, "UTC")};
+};
+
+#if _HAS_CXX23
+template <class _Duration>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO utc_time<_Duration>> = true;
+#endif // _HAS_CXX23
+
+template <class _Duration, _Format_supported_charT _CharT>
+struct formatter<_CHRONO tai_time<_Duration>, _CharT> {
+    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
+        return _Impl.template _Parse<_CHRONO tai_time<_Duration>>(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    auto format(const _CHRONO tai_time<_Duration>& _Val, _FormatContext& _Format_ctx) const {
+        using namespace chrono;
+        using _Common = common_type_t<_Duration, days>; // slightly optimize by performing conversion at compile time
+        constexpr _Common _Offset{sys_days{year{1970} / January / 1} - sys_days{year{1958} / January / 1}};
+        const auto _Sys = sys_time<_Duration>{_Val.time_since_epoch()} - _Offset;
+        return _Impl._Write(_Format_ctx, _Val, _CHRONO _Fill_tm(_Sys));
+    }
+
+private:
+    _CHRONO _Chrono_formatter<_CharT> _Impl{_STATICALLY_WIDEN(_CharT, "TAI")};
+};
+
+#if _HAS_CXX23
+template <class _Duration>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO tai_time<_Duration>> = true;
+#endif // _HAS_CXX23
+
+template <class _Duration, _Format_supported_charT _CharT>
+struct formatter<_CHRONO gps_time<_Duration>, _CharT> {
+    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
+        return _Impl.template _Parse<_CHRONO gps_time<_Duration>>(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    auto format(const _CHRONO gps_time<_Duration>& _Val, _FormatContext& _Format_ctx) const {
+        using namespace chrono;
+        using _Common = common_type_t<_Duration, days>; // slightly optimize by performing conversion at compile time
+        constexpr _Common _Offset{sys_days{year{1980} / January / Sunday[1]} - sys_days{year{1970} / January / 1}};
+        const auto _Sys = sys_time<_Duration>{_Val.time_since_epoch()} + _Offset;
+        return _Impl._Write(_Format_ctx, _Val, _CHRONO _Fill_tm(_Sys));
+    }
+
+private:
+    _CHRONO _Chrono_formatter<_CharT> _Impl{_STATICALLY_WIDEN(_CharT, "GPS")};
+};
+
+#if _HAS_CXX23
+template <class _Duration>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO gps_time<_Duration>> = true;
+#endif // _HAS_CXX23
+
+template <class _Duration, _Format_supported_charT _CharT>
+struct formatter<_CHRONO file_time<_Duration>, _CharT> {
+    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
+        return _Impl.template _Parse<_CHRONO file_time<_Duration>>(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    auto format(const _CHRONO file_time<_Duration>& _Val, _FormatContext& _Format_ctx) const {
+        const auto _Utc = _CHRONO file_clock::to_utc(_Val);
+        const auto _Sys = _CHRONO utc_clock::to_sys(_Utc);
+        return _Impl._Write(_Format_ctx, _Utc, _CHRONO _Fill_tm(_Sys));
+    }
+
+private:
+    _CHRONO _Chrono_formatter<_CharT> _Impl{_STATICALLY_WIDEN(_CharT, "UTC")};
+};
+
+#if _HAS_CXX23
+template <class _Duration>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO file_time<_Duration>> = true;
+#endif // _HAS_CXX23
+
+template <class _Duration, _Format_supported_charT _CharT>
+struct formatter<_CHRONO local_time<_Duration>, _CharT> : _Fill_tm_formatter<_CHRONO local_time<_Duration>, _CharT> {};
+
+#if _HAS_CXX23
+template <class _Duration>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO local_time<_Duration>> = true;
+#endif // _HAS_CXX23
+
+template <class _Duration, _Format_supported_charT _CharT>
+struct formatter<_CHRONO _Local_time_format_t<_Duration>, _CharT>
+    : _Fill_tm_formatter<_CHRONO _Local_time_format_t<_Duration>, _CharT> {};
+
+#if _HAS_CXX23
+template <class _Duration>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO _Local_time_format_t<_Duration>> = true;
+#endif // _HAS_CXX23
+
+template <class _Duration, class _TimeZonePtr, _Format_supported_charT _CharT>
+struct formatter<_CHRONO zoned_time<_Duration, _TimeZonePtr>, _CharT>
+    : formatter<_CHRONO _Local_time_format_t<common_type_t<_Duration, _CHRONO seconds>>, _CharT> {
+    template <class _FormatContext>
+    auto format(const _CHRONO zoned_time<_Duration, _TimeZonePtr>& _Val, _FormatContext& _Format_ctx) const {
+        using _Mybase    = formatter<_CHRONO _Local_time_format_t<common_type_t<_Duration, _CHRONO seconds>>, _CharT>;
+        const auto _Info = _Val.get_info();
+        return _Mybase::format({_Val.get_local_time(), &_Info.abbrev, &_Info.offset}, _Format_ctx);
+    }
+};
+
+#if _HAS_CXX23
+template <class _Duration>
+constexpr bool enable_nonlocking_formatter_optimization<_CHRONO zoned_time<_Duration, const _CHRONO time_zone*>> = true;
+#endif // _HAS_CXX23
+
+namespace chrono {
+    template <class _Duration>
+    _NODISCARD string nonexistent_local_time::_Make_string(const local_time<_Duration>& _Tp, const local_info& _Info) {
+        ostringstream _Os;
+        _Os << _Tp << " is in a gap between\n"
+            << local_seconds{_Info.first.end.time_since_epoch()} + _Info.first.offset << ' ' << _Info.first.abbrev
+            << " and\n"
+            << local_seconds{_Info.second.begin.time_since_epoch()} + _Info.second.offset << ' ' << _Info.second.abbrev
+            << " which are both equivalent to\n"
+            << _Info.first.end << " UTC";
+        return _STD move(_Os).str();
+    }
+
+    template <class _Duration>
+    _NODISCARD string ambiguous_local_time::_Make_string(const local_time<_Duration>& _Tp, const local_info& _Info) {
+        ostringstream _Os;
+        _Os << _Tp << " is ambiguous.  It could be\n"
+            << _Tp << ' ' << _Info.first.abbrev << " == " << _Tp - _Info.first.offset << " UTC or\n"
+            << _Tp << ' ' << _Info.second.abbrev << " == " << _Tp - _Info.second.offset << " UTC";
+        return _STD move(_Os).str();
+    }
+} // namespace chrono
+#endif // _HAS_CXX20
+
+inline namespace literals {
+    inline namespace chrono_literals {
+        _EXPORT_STD _NODISCARD constexpr _CHRONO hours operator""h(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO hours(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, ratio<3600>> operator""h(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, ratio<3600>>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO minutes operator""min(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO minutes(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, ratio<60>> operator""min(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, ratio<60>>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO seconds operator""s(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO seconds(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double> operator""s(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO milliseconds operator""ms(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO milliseconds(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, milli> operator""ms(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, milli>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO microseconds operator""us(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO microseconds(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, micro> operator""us(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, micro>(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO nanoseconds operator""ns(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO nanoseconds(_Val);
+        }
+
+        _EXPORT_STD _NODISCARD constexpr _CHRONO duration<double, nano> operator""ns(long double _Val) noexcept
+        /* strengthened */ {
+            return _CHRONO duration<double, nano>(_Val);
+        }
+
+#if _HAS_CXX20
+        _EXPORT_STD _NODISCARD constexpr _CHRONO day operator""d(unsigned long long _Day) noexcept {
+            return _CHRONO day{static_cast<unsigned int>(_Day)};
+        }
+        _EXPORT_STD _NODISCARD constexpr _CHRONO year operator""y(unsigned long long _Year) noexcept {
+            return _CHRONO year{static_cast<int>(_Year)};
+        }
+#endif // _HAS_CXX20
+    } // namespace chrono_literals
+} // namespace literals
+
+namespace chrono {
+    _EXPORT_STD using namespace literals::chrono_literals;
+} // namespace chrono
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CHRONO_
diff --git a/msvc-stl/stl/inc/cinttypes b/msvc-stl/stl/inc/cinttypes
new file mode 100644
index 0000000..d85558b
--- /dev/null
+++ b/msvc-stl/stl/inc/cinttypes
@@ -0,0 +1,38 @@
+// cinttypes standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CINTTYPES_
+#define _CINTTYPES_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdint>
+#include <inttypes.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD imaxdiv_t; // from <inttypes.h>
+
+_EXPORT_STD using _CSTD imaxabs;
+_EXPORT_STD using _CSTD imaxdiv;
+_EXPORT_STD using _CSTD strtoimax;
+_EXPORT_STD using _CSTD strtoumax;
+_EXPORT_STD using _CSTD wcstoimax;
+_EXPORT_STD using _CSTD wcstoumax;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CINTTYPES_
diff --git a/msvc-stl/stl/inc/ciso646 b/msvc-stl/stl/inc/ciso646
new file mode 100644
index 0000000..3b73c8d
--- /dev/null
+++ b/msvc-stl/stl/inc/ciso646
@@ -0,0 +1,17 @@
+// ciso646 standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CISO646_
+#define _CISO646_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <iso646.h>
+
+using _Header_ciso646 _CXX20_REMOVE_CISO646 = int;
+using _Hdr_ciso646                          = _Header_ciso646;
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CISO646_
diff --git a/msvc-stl/stl/inc/climits b/msvc-stl/stl/inc/climits
new file mode 100644
index 0000000..20b85bd
--- /dev/null
+++ b/msvc-stl/stl/inc/climits
@@ -0,0 +1,14 @@
+// climits standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CLIMITS_
+#define _CLIMITS_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <limits.h>
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CLIMITS_
diff --git a/msvc-stl/stl/inc/clocale b/msvc-stl/stl/inc/clocale
new file mode 100644
index 0000000..1f12e04
--- /dev/null
+++ b/msvc-stl/stl/inc/clocale
@@ -0,0 +1,32 @@
+// clocale standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CLOCALE_
+#define _CLOCALE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <locale.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD lconv;
+_EXPORT_STD using _CSTD localeconv;
+_EXPORT_STD using _CSTD setlocale;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CLOCALE_
diff --git a/msvc-stl/stl/inc/cmath b/msvc-stl/stl/inc/cmath
new file mode 100644
index 0000000..3b89d78
--- /dev/null
+++ b/msvc-stl/stl/inc/cmath
@@ -0,0 +1,1709 @@
+// cmath standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CMATH_
+#define _CMATH_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdlib>
+#include <xtr1common>
+
+#if !defined(__clang__) && !defined(_M_CEE) // TRANSITION, VSO-1663104
+#define _HAS_CMATH_INTRINSICS 1
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_CMATH_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_CMATH_INTRINSICS
+#include _STL_INTRIN_HEADER
+#endif // _HAS_CMATH_INTRINSICS
+
+#if _HAS_CXX20
+#include <type_traits>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_EXTERN_CXX_WORKAROUND
+_NODISCARD _Check_return_ inline float acos(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD acosf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float acosh(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD acoshf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float asin(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD asinf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float asinh(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD asinhf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float atan(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD atanf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float atanh(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD atanhf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float atan2(_In_ float _Yx, _In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD atan2f(_Yx, _Xx);
+}
+
+_NODISCARD _Check_return_ inline float cbrt(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD cbrtf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float ceil(_In_ float _Xx) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __ceilf(_Xx);
+#elif defined(__clang__)
+    return __builtin_ceilf(_Xx);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD ceilf(_Xx);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline float copysign(_In_ float _Number, _In_ float _Sign) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __copysignf(_Number, _Sign);
+#elif defined(__clang__)
+    return __builtin_copysignf(_Number, _Sign);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD copysignf(_Number, _Sign);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline float cos(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD cosf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float cosh(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD coshf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float erf(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD erff(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float erfc(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD erfcf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float exp(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD expf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float exp2(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD exp2f(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float expm1(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD expm1f(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float fabs(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD fabsf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float fdim(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
+    return _CSTD fdimf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float floor(_In_ float _Xx) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __floorf(_Xx);
+#elif defined(__clang__)
+    return __builtin_floorf(_Xx);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD floorf(_Xx);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline float fma(_In_ float _Xx, _In_ float _Yx, _In_ float _Zx) noexcept /* strengthened */ {
+    return _CSTD fmaf(_Xx, _Yx, _Zx);
+}
+
+_NODISCARD _Check_return_ inline float fmax(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
+    return _CSTD fmaxf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float fmin(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
+    return _CSTD fminf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float fmod(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
+    return _CSTD fmodf(_Xx, _Yx);
+}
+
+inline float frexp(_In_ float _Xx, _Out_ int* _Yx) noexcept /* strengthened */ {
+    return _CSTD frexpf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float hypot(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
+    return _CSTD hypotf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline int ilogb(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD ilogbf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float ldexp(_In_ float _Xx, _In_ int _Yx) noexcept /* strengthened */ {
+    return _CSTD ldexpf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float lgamma(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD lgammaf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long long llrint(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD llrintf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long long llround(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD llroundf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float log(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD logf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float log10(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD log10f(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float log1p(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD log1pf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float log2(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD log2f(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float logb(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD logbf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long lrint(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD lrintf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long lround(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD lroundf(_Xx);
+}
+
+inline float modf(_In_ float _Xx, _Out_ float* _Yx) noexcept /* strengthened */ {
+    return _CSTD modff(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float nearbyint(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD nearbyintf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float nextafter(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
+    return _CSTD nextafterf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float nexttoward(_In_ float _Xx, _In_ long double _Yx) noexcept /* strengthened */ {
+    return _CSTD nexttowardf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float pow(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
+    return _CSTD powf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float remainder(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
+    return _CSTD remainderf(_Xx, _Yx);
+}
+
+inline float remquo(_In_ float _Xx, _In_ float _Yx, _Out_ int* _Zx) noexcept /* strengthened */ {
+    return _CSTD remquof(_Xx, _Yx, _Zx);
+}
+
+_NODISCARD _Check_return_ inline float rint(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD rintf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float round(_In_ float _Xx) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __roundf(_Xx);
+#elif defined(__clang__)
+    return __builtin_roundf(_Xx);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD roundf(_Xx);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline float scalbln(_In_ float _Xx, _In_ long _Yx) noexcept /* strengthened */ {
+    return _CSTD scalblnf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float scalbn(_In_ float _Xx, _In_ int _Yx) noexcept /* strengthened */ {
+    return _CSTD scalbnf(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline float sin(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD sinf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float sinh(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD sinhf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float sqrt(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD sqrtf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float tan(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD tanf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float tanh(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD tanhf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float tgamma(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD tgammaf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float trunc(_In_ float _Xx) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __truncf(_Xx);
+#elif defined(__clang__)
+    return __builtin_truncf(_Xx);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD truncf(_Xx);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline long double acos(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD acosl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double acosh(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD acoshl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double asin(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD asinl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double asinh(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD asinhl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double atan(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD atanl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double atanh(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD atanhl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double atan2(_In_ long double _Yx, _In_ long double _Xx) noexcept
+/* strengthened */ {
+    return _CSTD atan2l(_Yx, _Xx);
+}
+
+_NODISCARD _Check_return_ inline long double cbrt(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD cbrtl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double ceil(_In_ long double _Xx) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __ceil(static_cast<double>(_Xx));
+#elif defined(__clang__)
+    return __builtin_ceill(_Xx);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD ceill(_Xx);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline long double copysign(_In_ long double _Number, _In_ long double _Sign) noexcept
+/* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __copysign(static_cast<double>(_Number), static_cast<double>(_Sign));
+#elif defined(__clang__)
+    return __builtin_copysignl(_Number, _Sign);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD copysignl(_Number, _Sign);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline long double cos(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD cosl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double cosh(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD coshl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double erf(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD erfl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double erfc(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD erfcl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double exp(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD expl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double exp2(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD exp2l(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double expm1(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD expm1l(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double fabs(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD fabsl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double fdim(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD fdiml(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double floor(_In_ long double _Xx) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __floor(static_cast<double>(_Xx));
+#elif defined(__clang__)
+    return __builtin_floorl(_Xx);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD floorl(_Xx);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline long double fma(
+    _In_ long double _Xx, _In_ long double _Yx, _In_ long double _Zx) noexcept /* strengthened */ {
+    return _CSTD fmal(_Xx, _Yx, _Zx);
+}
+
+_NODISCARD _Check_return_ inline long double fmax(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD fmaxl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double fmin(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD fminl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double fmod(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD fmodl(_Xx, _Yx);
+}
+
+inline long double frexp(_In_ long double _Xx, _Out_ int* _Yx) noexcept /* strengthened */ {
+    return _CSTD frexpl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double hypot(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD hypotl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline int ilogb(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD ilogbl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double ldexp(_In_ long double _Xx, _In_ int _Yx) noexcept /* strengthened */ {
+    return _CSTD ldexpl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double lgamma(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD lgammal(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long long llrint(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD llrintl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long long llround(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD llroundl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double log(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD logl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double log10(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD log10l(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double log1p(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD log1pl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double log2(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD log2l(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double logb(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD logbl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long lrint(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD lrintl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long lround(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD lroundl(_Xx);
+}
+
+inline long double modf(_In_ long double _Xx, _Out_ long double* _Yx) noexcept /* strengthened */ {
+    return _CSTD modfl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double nearbyint(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD nearbyintl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double nextafter(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD nextafterl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double nexttoward(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD nexttowardl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double pow(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD powl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double remainder(_In_ long double _Xx, _In_ long double _Yx) noexcept
+/* strengthened */ {
+    return _CSTD remainderl(_Xx, _Yx);
+}
+
+inline long double remquo(_In_ long double _Xx, _In_ long double _Yx, _Out_ int* _Zx) noexcept /* strengthened */ {
+    return _CSTD remquol(_Xx, _Yx, _Zx);
+}
+
+_NODISCARD _Check_return_ inline long double rint(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD rintl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double round(_In_ long double _Xx) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __round(static_cast<double>(_Xx));
+#elif defined(__clang__)
+    return __builtin_roundl(_Xx);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD roundl(_Xx);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+_NODISCARD _Check_return_ inline long double scalbln(_In_ long double _Xx, _In_ long _Yx) noexcept /* strengthened */ {
+    return _CSTD scalblnl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double scalbn(_In_ long double _Xx, _In_ int _Yx) noexcept /* strengthened */ {
+    return _CSTD scalbnl(_Xx, _Yx);
+}
+
+_NODISCARD _Check_return_ inline long double sin(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD sinl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double sinh(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD sinhl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double sqrt(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD sqrtl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double tan(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD tanl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double tanh(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD tanhl(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double tgamma(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD tgammal(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double trunc(_In_ long double _Xx) noexcept /* strengthened */ {
+#if _HAS_CMATH_INTRINSICS
+    return __trunc(static_cast<double>(_Xx));
+#elif defined(__clang__)
+    return __builtin_truncl(_Xx);
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+    return _CSTD truncl(_Xx);
+#endif // ^^^ intrinsics unavailable ^^^
+}
+_END_EXTERN_CXX_WORKAROUND
+
+_STD_BEGIN
+template <class _Ty1, class _Ty2>
+using _Common_float_type_t = conditional_t<is_same_v<_Ty1, long double> || is_same_v<_Ty2, long double>, long double,
+    conditional_t<is_same_v<_Ty1, float> && is_same_v<_Ty2, float>, float,
+        double>>; // find type for two-argument math function
+_STD_END
+
+_EXTERN_CXX_WORKAROUND
+template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0>
+double frexp(_Ty _Value, _Out_ int* const _Exp) noexcept /* strengthened */ {
+    return _CSTD frexp(static_cast<double>(_Value), _Exp);
+}
+
+template <class _Ty1, class _Ty2, _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>, int> = 0>
+_NODISCARD _STD _Common_float_type_t<_Ty1, _Ty2> pow(_Ty1 _Left, _Ty2 _Right) noexcept /* strengthened */ {
+    if constexpr (_STD _Is_nonbool_integral<_Ty2>) {
+        if (_Right == 2) {
+            return static_cast<double>(_Left) * static_cast<double>(_Left); // TRANSITION, see GH-5768
+        }
+    }
+
+    return _CSTD pow(static_cast<double>(_Left), static_cast<double>(_Right));
+}
+
+template <class _Ty1, class _Ty2, class _Ty3,
+    _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2> && _STD is_arithmetic_v<_Ty3>, int> = 0>
+_NODISCARD _STD _Common_float_type_t<_Ty1, _STD _Common_float_type_t<_Ty2, _Ty3>> fma(
+    _Ty1 _Left, _Ty2 _Middle, _Ty3 _Right) noexcept /* strengthened */ {
+    using _Common = _STD _Common_float_type_t<_Ty1, _STD _Common_float_type_t<_Ty2, _Ty3>>;
+    if constexpr (_STD is_same_v<_Common, float>) {
+        return _CSTD fmaf(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
+    } else if constexpr (_STD is_same_v<_Common, double>) {
+        return _CSTD fma(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
+    } else {
+        return _CSTD fmal(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
+    }
+}
+
+template <class _Ty1, class _Ty2, _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>, int> = 0>
+_STD _Common_float_type_t<_Ty1, _Ty2> remquo(_Ty1 _Left, _Ty2 _Right, int* _Pquo) noexcept /* strengthened */ {
+    using _Common = _STD _Common_float_type_t<_Ty1, _Ty2>;
+    if constexpr (_STD is_same_v<_Common, float>) {
+        return _CSTD remquof(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
+    } else if constexpr (_STD is_same_v<_Common, double>) {
+        return _CSTD remquo(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
+    } else {
+        return _CSTD remquol(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
+    }
+}
+
+#ifdef __clang__
+// Clang provides efficient builtins; see GH-4609.
+// TRANSITION, the UCRT's function templates should take advantage of these builtins.
+// As a workaround, we can provide additional overloads that will be
+// preferred by overload resolution when the types exactly match.
+
+#define _CLANG_BUILTIN1_ARG(NAME, ARG)                                                           \
+    _NODISCARD _Check_return_ _CONSTEXPR23 bool NAME(_In_ ARG _Xx) noexcept /* strengthened */ { \
+        return __builtin_##NAME(_Xx);                                                            \
+    }
+
+// Updated by P0533R9 "constexpr For <cmath> And <cstdlib>".
+#define _CLANG_BUILTIN2_ARG(NAME, ARG)                                                                      \
+    _NODISCARD _Check_return_ constexpr bool NAME(_In_ ARG _Xx, _In_ ARG _Yx) noexcept /* strengthened */ { \
+        return __builtin_##NAME(_Xx, _Yx);                                                                  \
+    }
+
+#define _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, ARG)                                                            \
+    template <class _Ty, _STD enable_if_t<_STD is_arithmetic_v<_Ty>, int> = 0>                              \
+    _NODISCARD _Check_return_ constexpr bool NAME(_In_ ARG _Xx, _In_ _Ty _Yx) noexcept /* strengthened */ { \
+        return __builtin_##NAME(static_cast<double>(_Xx), static_cast<double>(_Yx));                        \
+    }
+
+#ifdef __cpp_char8_t
+#define _CLANG_BUILTIN2_ARG_TEMPLATED_CHAR8_T(NAME)                                                             \
+    template <class _Ty, _STD enable_if_t<_STD is_arithmetic_v<_Ty>, int> = 0>                                  \
+    _NODISCARD _Check_return_ constexpr bool NAME(_In_ char8_t _Xx, _In_ _Ty _Yx) noexcept /* strengthened */ { \
+        return __builtin_##NAME(static_cast<double>(_Xx), static_cast<double>(_Yx));                            \
+    }
+#else // ^^^ defined(__cpp_char8_t) / !defined(__cpp_char8_t) vvv
+#define _CLANG_BUILTIN2_ARG_TEMPLATED_CHAR8_T(NAME)
+#endif // ^^^ !defined(__cpp_char8_t) ^^^
+
+#ifdef _NATIVE_WCHAR_T_DEFINED
+#define _CLANG_BUILTIN2_ARG_TEMPLATED_WCHAR_T(NAME)                                                             \
+    template <class _Ty, _STD enable_if_t<_STD is_arithmetic_v<_Ty>, int> = 0>                                  \
+    _NODISCARD _Check_return_ constexpr bool NAME(_In_ wchar_t _Xx, _In_ _Ty _Yx) noexcept /* strengthened */ { \
+        return __builtin_##NAME(static_cast<double>(_Xx), static_cast<double>(_Yx));                            \
+    }
+#else // ^^^ defined(_NATIVE_WCHAR_T_DEFINED) / !defined(_NATIVE_WCHAR_T_DEFINED) vvv
+#define _CLANG_BUILTIN2_ARG_TEMPLATED_WCHAR_T(NAME)
+#endif // ^^^ !defined(_NATIVE_WCHAR_T_DEFINED) ^^^
+
+#define _CLANG_BUILTIN2_TEMPLATED(NAME)                     \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, float)              \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, double)             \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, long double)        \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, signed char)        \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, short)              \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, int)                \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, long)               \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, long long)          \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, unsigned char)      \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, unsigned short)     \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, unsigned int)       \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, unsigned long)      \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, unsigned long long) \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, bool)               \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, char)               \
+    _CLANG_BUILTIN2_ARG_TEMPLATED_CHAR8_T(NAME)             \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, char16_t)           \
+    _CLANG_BUILTIN2_ARG_TEMPLATED(NAME, char32_t)           \
+    _CLANG_BUILTIN2_ARG_TEMPLATED_WCHAR_T(NAME)
+
+#define _CLANG_BUILTIN1(NAME)         \
+    _CLANG_BUILTIN1_ARG(NAME, float)  \
+    _CLANG_BUILTIN1_ARG(NAME, double) \
+    _CLANG_BUILTIN1_ARG(NAME, long double)
+
+#define _CLANG_BUILTIN2(NAME)         \
+    _CLANG_BUILTIN2_ARG(NAME, float)  \
+    _CLANG_BUILTIN2_ARG(NAME, double) \
+    _CLANG_BUILTIN2_ARG(NAME, long double)
+
+_STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED
+_CLANG_BUILTIN1(isfinite)
+_CLANG_BUILTIN1(isinf)
+_CLANG_BUILTIN1(isnan)
+_STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED
+_CLANG_BUILTIN1(isnormal)
+
+_CLANG_BUILTIN2(isgreater)
+_CLANG_BUILTIN2(isgreaterequal)
+_CLANG_BUILTIN2(isless)
+_CLANG_BUILTIN2(islessequal)
+_CLANG_BUILTIN2(islessgreater)
+_STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED
+_CLANG_BUILTIN2(isunordered)
+_STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED
+
+_CLANG_BUILTIN2_TEMPLATED(isgreater)
+_CLANG_BUILTIN2_TEMPLATED(isgreaterequal)
+_CLANG_BUILTIN2_TEMPLATED(isless)
+_CLANG_BUILTIN2_TEMPLATED(islessequal)
+_CLANG_BUILTIN2_TEMPLATED(islessgreater)
+_STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED
+_CLANG_BUILTIN2_TEMPLATED(isunordered)
+_STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED
+
+#undef _CLANG_BUILTIN1_ARG
+#undef _CLANG_BUILTIN2_ARG
+#undef _CLANG_BUILTIN1
+#undef _CLANG_BUILTIN2
+#undef _CLANG_BUILTIN2_ARG_TEMPLATED
+#undef _CLANG_BUILTIN2_ARG_TEMPLATED_CHAR8_T
+#undef _CLANG_BUILTIN2_ARG_TEMPLATED_WCHAR_T
+#undef _CLANG_BUILTIN2_TEMPLATED
+#endif // ^^^ defined(__clang__) ^^^
+
+// TRANSITION, DevCom-10294165, should be provided by UCRT
+template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0>
+_NODISCARD _Check_return_ _CONSTEXPR23 int fpclassify(_In_ const _Ty _Ix) noexcept /* strengthened */ {
+    return _Ix == 0 ? FP_ZERO : FP_NORMAL;
+}
+
+// TRANSITION, DevCom-10294165, should be provided by UCRT
+template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0>
+_NODISCARD _Check_return_ _CONSTEXPR23 bool signbit(_In_ const _Ty _Ix) noexcept /* strengthened */ {
+    if constexpr (static_cast<_Ty>(-1) < _Ty{}) {
+        return _Ix < 0;
+    } else {
+        return false;
+    }
+}
+
+// TRANSITION, DevCom-10294165, additional overloads are not templated to avoid ambiguity with the overload in UCRT
+#define _GENERIC_MATH_ISNORMAL(TYPE)                                                                        \
+    _NODISCARD _Check_return_ _CONSTEXPR23 bool isnormal(_In_ const TYPE _Ix) noexcept /* strengthened */ { \
+        return _Ix != 0;                                                                                    \
+    }
+
+_GENERIC_MATH_ISNORMAL(signed char)
+_GENERIC_MATH_ISNORMAL(unsigned char)
+_GENERIC_MATH_ISNORMAL(short)
+_GENERIC_MATH_ISNORMAL(unsigned short)
+_GENERIC_MATH_ISNORMAL(int)
+_GENERIC_MATH_ISNORMAL(unsigned int)
+_GENERIC_MATH_ISNORMAL(long)
+_GENERIC_MATH_ISNORMAL(unsigned long)
+_GENERIC_MATH_ISNORMAL(long long)
+_GENERIC_MATH_ISNORMAL(unsigned long long)
+_GENERIC_MATH_ISNORMAL(bool)
+_GENERIC_MATH_ISNORMAL(char)
+#ifdef __cpp_char8_t
+_GENERIC_MATH_ISNORMAL(char8_t)
+#endif // defined(__cpp_char8_t)
+_GENERIC_MATH_ISNORMAL(char16_t)
+_GENERIC_MATH_ISNORMAL(char32_t)
+#ifdef _NATIVE_WCHAR_T_DEFINED
+_GENERIC_MATH_ISNORMAL(wchar_t)
+#endif // defined(_NATIVE_WCHAR_T_DEFINED)
+#undef _GENERIC_MATH_ISNORMAL
+
+#define _GENERIC_MATH1_BASE(NAME, RET, FUN)                                  \
+    template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0> \
+    _NODISCARD RET NAME(_Ty _Left) noexcept /* strengthened */ {             \
+        return FUN(static_cast<double>(_Left));                              \
+    }
+
+#define _GENERIC_MATH1R(FUN, RET) _GENERIC_MATH1_BASE(FUN, RET, _CSTD FUN)
+#define _GENERIC_MATH1(FUN)       _GENERIC_MATH1R(FUN, double)
+
+#if _HAS_CMATH_INTRINSICS
+#define _GENERIC_MATH1I(FUN, CLANG_INTRIN, MSVC_INTRIN) _GENERIC_MATH1_BASE(FUN, double, MSVC_INTRIN)
+#elif defined(__clang__)
+#define _GENERIC_MATH1I(FUN, CLANG_INTRIN, MSVC_INTRIN) _GENERIC_MATH1_BASE(FUN, double, CLANG_INTRIN)
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+#define _GENERIC_MATH1I(FUN, CLANG_INTRIN, MSVC_INTRIN) _GENERIC_MATH1_BASE(FUN, double, _CSTD FUN)
+#endif // ^^^ intrinsics unavailable ^^^
+
+#define _GENERIC_MATH1X(FUN, ARG2)                                             \
+    template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0>   \
+    _NODISCARD double FUN(_Ty _Left, ARG2 _Arg2) noexcept /* strengthened */ { \
+        return _CSTD FUN(static_cast<double>(_Left), _Arg2);                   \
+    }
+
+// When the arguments are both floats or both long doubles, overload resolution prefers the
+// non-template overloads to the templates generated from this macro. The templates generated from
+// this macro are only selected by overload resolution when both arguments have integral type, or
+// when the types of the two arguments differ, in which case _Common_float_type_t is either double
+// or long double. Note that double and long double have the same underlying representation on our
+// supported platforms.
+#define _GENERIC_MATH2_BASE(NAME, FUN)                                                                           \
+    template <class _Ty1, class _Ty2,                                                                            \
+        _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>, int> = 0>                     \
+    _NODISCARD _STD _Common_float_type_t<_Ty1, _Ty2> NAME(_Ty1 _Left, _Ty2 _Right) noexcept /* strengthened */ { \
+        return FUN(static_cast<double>(_Left), static_cast<double>(_Right));                                     \
+    }
+
+#define _GENERIC_MATH2(FUN) _GENERIC_MATH2_BASE(FUN, _CSTD FUN)
+
+#if _HAS_CMATH_INTRINSICS
+#define _GENERIC_MATH2I(FUN, CLANG_INTRIN, MSVC_INTRIN) _GENERIC_MATH2_BASE(FUN, MSVC_INTRIN)
+#elif defined(__clang__)
+#define _GENERIC_MATH2I(FUN, CLANG_INTRIN, MSVC_INTRIN) _GENERIC_MATH2_BASE(FUN, CLANG_INTRIN)
+#else // ^^^ defined(__clang__) / intrinsics unavailable vvv
+#define _GENERIC_MATH2I(FUN, CLANG_INTRIN, MSVC_INTRIN) _GENERIC_MATH2_BASE(FUN, _CSTD FUN)
+#endif // ^^^ intrinsics unavailable ^^^
+
+// TRANSITION, DevCom-10294165, additional overloads are not templated to avoid ambiguity with the overload in UCRT
+#define _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, TYPE)                                \
+    _NODISCARD _Check_return_ _CONSTEXPR23 bool FUN(_In_ TYPE) noexcept /* strengthened */ { \
+        return RETV;                                                                         \
+    }
+
+#ifdef __cpp_char8_t
+#define _GENERIC_MATH_CLASSIFY1_RETV_CHAR8_T(FUN, RETV) _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, char8_t)
+#else // ^^^ defined(__cpp_char8_t) / !defined(__cpp_char8_t) vvv
+#define _GENERIC_MATH_CLASSIFY1_RETV_CHAR8_T(FUN, RETV)
+#endif // ^^^ !defined(__cpp_char8_t) ^^^
+
+#ifdef _NATIVE_WCHAR_T_DEFINED
+#define _GENERIC_MATH_CLASSIFY1_RETV_WCHAR_T(FUN, RETV) _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, wchar_t)
+#else // ^^^ defined(_NATIVE_WCHAR_T_DEFINED) / !defined(_NATIVE_WCHAR_T_DEFINED) vvv
+#define _GENERIC_MATH_CLASSIFY1_RETV_WCHAR_T(FUN, RETV)
+#endif // ^^^ !defined(_NATIVE_WCHAR_T_DEFINED) ^^^
+
+#define _GENERIC_MATH_CLASSIFY1_RETV(FUN, RETV)                         \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, signed char)        \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned char)      \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, short)              \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned short)     \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, int)                \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned int)       \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, long)               \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned long)      \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, long long)          \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned long long) \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, bool)               \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, char)               \
+    _GENERIC_MATH_CLASSIFY1_RETV_CHAR8_T(FUN, RETV)                     \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, char16_t)           \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, char32_t)           \
+    _GENERIC_MATH_CLASSIFY1_RETV_WCHAR_T(FUN, RETV)
+
+// The following order matches N4950 [cmath.syn].
+_GENERIC_MATH1(acos)
+_GENERIC_MATH1(asin)
+_GENERIC_MATH1(atan)
+_GENERIC_MATH2(atan2)
+_GENERIC_MATH1(cos)
+_GENERIC_MATH1(sin)
+_GENERIC_MATH1(tan)
+_GENERIC_MATH1(acosh)
+_GENERIC_MATH1(asinh)
+_GENERIC_MATH1(atanh)
+_GENERIC_MATH1(cosh)
+_GENERIC_MATH1(sinh)
+_GENERIC_MATH1(tanh)
+_GENERIC_MATH1(exp)
+_GENERIC_MATH1(exp2)
+_GENERIC_MATH1(expm1)
+// frexp() is hand-crafted
+_GENERIC_MATH1R(ilogb, int)
+_GENERIC_MATH1X(ldexp, int)
+_GENERIC_MATH1(log)
+_GENERIC_MATH1(log10)
+_GENERIC_MATH1(log1p)
+_GENERIC_MATH1(log2)
+_GENERIC_MATH1(logb)
+// No modf(), types must match
+_GENERIC_MATH1X(scalbn, int)
+_GENERIC_MATH1X(scalbln, long)
+_GENERIC_MATH1(cbrt)
+// abs() has integer overloads
+_GENERIC_MATH1(fabs)
+_GENERIC_MATH2(hypot)
+// 3-arg hypot() is hand-crafted
+// pow() is hand-crafted
+_GENERIC_MATH1(sqrt)
+_GENERIC_MATH1(erf)
+_GENERIC_MATH1(erfc)
+_GENERIC_MATH1(lgamma)
+_GENERIC_MATH1(tgamma)
+_GENERIC_MATH1I(ceil, __builtin_ceil, __ceil)
+_GENERIC_MATH1I(floor, __builtin_floor, __floor)
+_GENERIC_MATH1(nearbyint)
+_GENERIC_MATH1(rint)
+_GENERIC_MATH1R(lrint, long)
+_GENERIC_MATH1R(llrint, long long)
+_GENERIC_MATH1I(round, __builtin_round, __round)
+_GENERIC_MATH1R(lround, long)
+_GENERIC_MATH1R(llround, long long)
+_GENERIC_MATH1I(trunc, __builtin_trunc, __trunc)
+_GENERIC_MATH2(fmod)
+_GENERIC_MATH2(remainder)
+// remquo() is hand-crafted
+_GENERIC_MATH2I(copysign, __builtin_copysign, __copysign)
+// nan(const char*) is exempt
+_GENERIC_MATH2(nextafter)
+_GENERIC_MATH1X(nexttoward, long double)
+_GENERIC_MATH2(fdim)
+_GENERIC_MATH2(fmax)
+_GENERIC_MATH2(fmin)
+// fma() is hand-crafted
+// lerp() is hand-crafted
+// fpclassify() is hand-crafted
+_GENERIC_MATH_CLASSIFY1_RETV(isfinite, true)
+_GENERIC_MATH_CLASSIFY1_RETV(isinf, false)
+_GENERIC_MATH_CLASSIFY1_RETV(isnan, false)
+// isnormal() is half-hand-crafted
+// signbit() is hand-crafted
+
+#undef _GENERIC_MATH1_BASE
+#undef _GENERIC_MATH1R
+#undef _GENERIC_MATH1
+#undef _GENERIC_MATH1I
+#undef _GENERIC_MATH1X
+#undef _GENERIC_MATH2_BASE
+#undef _GENERIC_MATH2
+#undef _GENERIC_MATH2I
+#undef _GENERIC_MATH_CLASSIFY1_RETV_INTEGER
+#undef _GENERIC_MATH_CLASSIFY1_RETV_WCHAR_T
+#undef _GENERIC_MATH_CLASSIFY1_RETV_CHAR8_T
+#undef _GENERIC_MATH_CLASSIFY1_RETV
+#undef _HAS_CMATH_INTRINSICS
+_END_EXTERN_CXX_WORKAROUND
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD abs;
+_EXPORT_STD using _CSTD acos;
+_EXPORT_STD using _CSTD asin;
+_EXPORT_STD using _CSTD atan;
+_EXPORT_STD using _CSTD atan2;
+_EXPORT_STD using _CSTD ceil;
+_EXPORT_STD using _CSTD cos;
+_EXPORT_STD using _CSTD cosh;
+_EXPORT_STD using _CSTD exp;
+_EXPORT_STD using _CSTD fabs;
+_EXPORT_STD using _CSTD floor;
+_EXPORT_STD using _CSTD fmod;
+_EXPORT_STD using _CSTD frexp;
+_EXPORT_STD using _CSTD ldexp;
+_EXPORT_STD using _CSTD log;
+_EXPORT_STD using _CSTD log10;
+_EXPORT_STD using _CSTD modf;
+_EXPORT_STD using _CSTD pow;
+_EXPORT_STD using _CSTD sin;
+_EXPORT_STD using _CSTD sinh;
+_EXPORT_STD using _CSTD sqrt;
+_EXPORT_STD using _CSTD tan;
+_EXPORT_STD using _CSTD tanh;
+
+_EXPORT_STD using _CSTD acosf;
+_EXPORT_STD using _CSTD asinf;
+_EXPORT_STD using _CSTD atanf;
+_EXPORT_STD using _CSTD atan2f;
+_EXPORT_STD using _CSTD ceilf;
+_EXPORT_STD using _CSTD cosf;
+_EXPORT_STD using _CSTD coshf;
+_EXPORT_STD using _CSTD expf;
+_EXPORT_STD using _CSTD fabsf;
+_EXPORT_STD using _CSTD floorf;
+_EXPORT_STD using _CSTD fmodf;
+_EXPORT_STD using _CSTD frexpf;
+_EXPORT_STD using _CSTD ldexpf;
+_EXPORT_STD using _CSTD logf;
+_EXPORT_STD using _CSTD log10f;
+_EXPORT_STD using _CSTD modff;
+_EXPORT_STD using _CSTD powf;
+_EXPORT_STD using _CSTD sinf;
+_EXPORT_STD using _CSTD sinhf;
+_EXPORT_STD using _CSTD sqrtf;
+_EXPORT_STD using _CSTD tanf;
+_EXPORT_STD using _CSTD tanhf;
+
+_EXPORT_STD using _CSTD acosl;
+_EXPORT_STD using _CSTD asinl;
+_EXPORT_STD using _CSTD atanl;
+_EXPORT_STD using _CSTD atan2l;
+_EXPORT_STD using _CSTD ceill;
+_EXPORT_STD using _CSTD cosl;
+_EXPORT_STD using _CSTD coshl;
+_EXPORT_STD using _CSTD expl;
+_EXPORT_STD using _CSTD fabsl;
+_EXPORT_STD using _CSTD floorl;
+_EXPORT_STD using _CSTD fmodl;
+_EXPORT_STD using _CSTD frexpl;
+_EXPORT_STD using _CSTD ldexpl;
+_EXPORT_STD using _CSTD logl;
+_EXPORT_STD using _CSTD log10l;
+_EXPORT_STD using _CSTD modfl;
+_EXPORT_STD using _CSTD powl;
+_EXPORT_STD using _CSTD sinl;
+_EXPORT_STD using _CSTD sinhl;
+_EXPORT_STD using _CSTD sqrtl;
+_EXPORT_STD using _CSTD tanl;
+_EXPORT_STD using _CSTD tanhl;
+
+_EXPORT_STD using _CSTD float_t;
+_EXPORT_STD using _CSTD double_t;
+
+_EXPORT_STD using _CSTD acosh;
+_EXPORT_STD using _CSTD asinh;
+_EXPORT_STD using _CSTD atanh;
+_EXPORT_STD using _CSTD cbrt;
+_EXPORT_STD using _CSTD erf;
+_EXPORT_STD using _CSTD erfc;
+_EXPORT_STD using _CSTD expm1;
+_EXPORT_STD using _CSTD exp2;
+
+inline namespace _Binary_hypot {
+    _EXPORT_STD using _CSTD hypot;
+} // namespace _Binary_hypot
+
+_EXPORT_STD using _CSTD ilogb;
+_EXPORT_STD using _CSTD lgamma;
+_EXPORT_STD using _CSTD log1p;
+_EXPORT_STD using _CSTD log2;
+_EXPORT_STD using _CSTD logb;
+_EXPORT_STD using _CSTD llrint;
+_EXPORT_STD using _CSTD lrint;
+_EXPORT_STD using _CSTD nearbyint;
+_EXPORT_STD using _CSTD rint;
+_EXPORT_STD using _CSTD llround;
+_EXPORT_STD using _CSTD lround;
+_EXPORT_STD using _CSTD fdim;
+_EXPORT_STD using _CSTD fma;
+_EXPORT_STD using _CSTD fmax;
+_EXPORT_STD using _CSTD fmin;
+_EXPORT_STD using _CSTD round;
+_EXPORT_STD using _CSTD trunc;
+_EXPORT_STD using _CSTD remainder;
+_EXPORT_STD using _CSTD remquo;
+_EXPORT_STD using _CSTD copysign;
+_EXPORT_STD using _CSTD nan;
+_EXPORT_STD using _CSTD nextafter;
+_EXPORT_STD using _CSTD scalbn;
+_EXPORT_STD using _CSTD scalbln;
+_EXPORT_STD using _CSTD nexttoward;
+_EXPORT_STD using _CSTD tgamma;
+
+_EXPORT_STD using _CSTD acoshf;
+_EXPORT_STD using _CSTD asinhf;
+_EXPORT_STD using _CSTD atanhf;
+_EXPORT_STD using _CSTD cbrtf;
+_EXPORT_STD using _CSTD erff;
+_EXPORT_STD using _CSTD erfcf;
+_EXPORT_STD using _CSTD expm1f;
+_EXPORT_STD using _CSTD exp2f;
+_EXPORT_STD using _CSTD hypotf;
+_EXPORT_STD using _CSTD ilogbf;
+_EXPORT_STD using _CSTD lgammaf;
+_EXPORT_STD using _CSTD log1pf;
+_EXPORT_STD using _CSTD log2f;
+_EXPORT_STD using _CSTD logbf;
+_EXPORT_STD using _CSTD llrintf;
+_EXPORT_STD using _CSTD lrintf;
+_EXPORT_STD using _CSTD nearbyintf;
+_EXPORT_STD using _CSTD rintf;
+_EXPORT_STD using _CSTD llroundf;
+_EXPORT_STD using _CSTD lroundf;
+_EXPORT_STD using _CSTD fdimf;
+_EXPORT_STD using _CSTD fmaf;
+_EXPORT_STD using _CSTD fmaxf;
+_EXPORT_STD using _CSTD fminf;
+_EXPORT_STD using _CSTD roundf;
+_EXPORT_STD using _CSTD truncf;
+_EXPORT_STD using _CSTD remainderf;
+_EXPORT_STD using _CSTD remquof;
+_EXPORT_STD using _CSTD copysignf;
+_EXPORT_STD using _CSTD nanf;
+_EXPORT_STD using _CSTD nextafterf;
+_EXPORT_STD using _CSTD scalbnf;
+_EXPORT_STD using _CSTD scalblnf;
+_EXPORT_STD using _CSTD nexttowardf;
+_EXPORT_STD using _CSTD tgammaf;
+
+_EXPORT_STD using _CSTD acoshl;
+_EXPORT_STD using _CSTD asinhl;
+_EXPORT_STD using _CSTD atanhl;
+_EXPORT_STD using _CSTD cbrtl;
+_EXPORT_STD using _CSTD erfl;
+_EXPORT_STD using _CSTD erfcl;
+_EXPORT_STD using _CSTD expm1l;
+_EXPORT_STD using _CSTD exp2l;
+_EXPORT_STD using _CSTD hypotl;
+_EXPORT_STD using _CSTD ilogbl;
+_EXPORT_STD using _CSTD lgammal;
+_EXPORT_STD using _CSTD log1pl;
+_EXPORT_STD using _CSTD log2l;
+_EXPORT_STD using _CSTD logbl;
+_EXPORT_STD using _CSTD llrintl;
+_EXPORT_STD using _CSTD lrintl;
+_EXPORT_STD using _CSTD nearbyintl;
+_EXPORT_STD using _CSTD rintl;
+_EXPORT_STD using _CSTD llroundl;
+_EXPORT_STD using _CSTD lroundl;
+_EXPORT_STD using _CSTD fdiml;
+_EXPORT_STD using _CSTD fmal;
+_EXPORT_STD using _CSTD fmaxl;
+_EXPORT_STD using _CSTD fminl;
+_EXPORT_STD using _CSTD roundl;
+_EXPORT_STD using _CSTD truncl;
+_EXPORT_STD using _CSTD remainderl;
+_EXPORT_STD using _CSTD remquol;
+_EXPORT_STD using _CSTD copysignl;
+_EXPORT_STD using _CSTD nanl;
+_EXPORT_STD using _CSTD nextafterl;
+_EXPORT_STD using _CSTD scalbnl;
+_EXPORT_STD using _CSTD scalblnl;
+_EXPORT_STD using _CSTD nexttowardl;
+_EXPORT_STD using _CSTD tgammal;
+
+_EXPORT_STD using _CSTD fpclassify;
+_EXPORT_STD using _CSTD signbit;
+_EXPORT_STD using _CSTD isfinite;
+_EXPORT_STD using _CSTD isinf;
+_EXPORT_STD using _CSTD isnan;
+_EXPORT_STD using _CSTD isnormal;
+_EXPORT_STD using _CSTD isgreater;
+_EXPORT_STD using _CSTD isgreaterequal;
+_EXPORT_STD using _CSTD isless;
+_EXPORT_STD using _CSTD islessequal;
+_EXPORT_STD using _CSTD islessgreater;
+_EXPORT_STD using _CSTD isunordered;
+_STD_END
+
+#if _HAS_CXX17
+extern "C" {
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_assoc_laguerre(unsigned int, unsigned int, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_assoc_laguerref(unsigned int, unsigned int, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_assoc_legendre(unsigned int, unsigned int, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_assoc_legendref(unsigned int, unsigned int, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_beta(double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_betaf(float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_comp_ellint_1(double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_comp_ellint_1f(float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_comp_ellint_2(double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_comp_ellint_2f(float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_comp_ellint_3(double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_comp_ellint_3f(float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_cyl_bessel_i(double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_cyl_bessel_if(float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_cyl_bessel_j(double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_cyl_bessel_jf(float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_cyl_bessel_k(double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_cyl_bessel_kf(float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_cyl_neumann(double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_cyl_neumannf(float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_ellint_1(double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_ellint_1f(float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_ellint_2(double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_ellint_2f(float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_ellint_3(double, double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_ellint_3f(float, float, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_expint(double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_expintf(float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_hermite(unsigned int, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_hermitef(unsigned int, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_laguerre(unsigned int, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_laguerref(unsigned int, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_legendre(unsigned int, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_legendref(unsigned int, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_riemann_zeta(double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_riemann_zetaf(float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_sph_bessel(unsigned int, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_sph_besself(unsigned int, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_sph_legendre(unsigned int, unsigned int, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_sph_legendref(unsigned int, unsigned int, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_sph_neumann(unsigned int, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_sph_neumannf(unsigned int, float) noexcept;
+_NODISCARD _CRT_SATELLITE_2 double __stdcall __std_smf_hypot3(double, double, double) noexcept;
+_NODISCARD _CRT_SATELLITE_2 float __stdcall __std_smf_hypot3f(float, float, float) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+_EXPORT_STD _NODISCARD inline double assoc_laguerre(
+    const unsigned int _Degree, const unsigned int _Order, const double _Value) noexcept /* strengthened */ {
+    return __std_smf_assoc_laguerre(_Degree, _Order, _Value);
+}
+
+_EXPORT_STD _NODISCARD inline float assoc_laguerref(
+    const unsigned int _Degree, const unsigned int _Order, const float _Value) noexcept /* strengthened */ {
+    return __std_smf_assoc_laguerref(_Degree, _Order, _Value);
+}
+
+_EXPORT_STD _NODISCARD inline long double assoc_laguerrel(
+    const unsigned int _Degree, const unsigned int _Order, const long double _Value) noexcept /* strengthened */ {
+    return __std_smf_assoc_laguerre(_Degree, _Order, static_cast<double>(_Value));
+}
+
+_EXPORT_STD _NODISCARD inline double assoc_legendre(
+    const unsigned int _Degree, const unsigned int _Order, const double _Value) noexcept /* strengthened */ {
+    return __std_smf_assoc_legendre(_Degree, _Order, _Value);
+}
+
+_EXPORT_STD _NODISCARD inline float assoc_legendref(
+    const unsigned int _Degree, const unsigned int _Order, const float _Value) noexcept /* strengthened */ {
+    return __std_smf_assoc_legendref(_Degree, _Order, _Value);
+}
+
+_EXPORT_STD _NODISCARD inline long double assoc_legendrel(
+    const unsigned int _Degree, const unsigned int _Order, const long double _Value) noexcept /* strengthened */ {
+    return __std_smf_assoc_legendre(_Degree, _Order, static_cast<double>(_Value));
+}
+
+_EXPORT_STD _NODISCARD inline double beta(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_beta(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float betaf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_betaf(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double betal(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_beta(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double comp_ellint_1(const double _Arg) noexcept /* strengthened */ {
+    return __std_smf_comp_ellint_1(_Arg);
+}
+
+_EXPORT_STD _NODISCARD inline float comp_ellint_1f(const float _Arg) noexcept /* strengthened */ {
+    return __std_smf_comp_ellint_1f(_Arg);
+}
+
+_EXPORT_STD _NODISCARD inline long double comp_ellint_1l(const long double _Arg) noexcept /* strengthened */ {
+    return __std_smf_comp_ellint_1(static_cast<double>(_Arg));
+}
+
+_EXPORT_STD _NODISCARD inline double comp_ellint_2(const double _Arg) noexcept /* strengthened */ {
+    return __std_smf_comp_ellint_2(_Arg);
+}
+
+_EXPORT_STD _NODISCARD inline float comp_ellint_2f(const float _Arg) noexcept /* strengthened */ {
+    return __std_smf_comp_ellint_2f(_Arg);
+}
+
+_EXPORT_STD _NODISCARD inline long double comp_ellint_2l(const long double _Arg) noexcept /* strengthened */ {
+    return __std_smf_comp_ellint_2(static_cast<double>(_Arg));
+}
+
+_EXPORT_STD _NODISCARD inline double comp_ellint_3(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_comp_ellint_3(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float comp_ellint_3f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_comp_ellint_3f(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double comp_ellint_3l(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_comp_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double cyl_bessel_i(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_cyl_bessel_i(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float cyl_bessel_if(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_cyl_bessel_if(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double cyl_bessel_il(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_cyl_bessel_i(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double cyl_bessel_j(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_cyl_bessel_j(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float cyl_bessel_jf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_cyl_bessel_jf(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double cyl_bessel_jl(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_cyl_bessel_j(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double cyl_bessel_k(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_cyl_bessel_k(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float cyl_bessel_kf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_cyl_bessel_kf(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double cyl_bessel_kl(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_cyl_bessel_k(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double cyl_neumann(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_cyl_neumann(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float cyl_neumannf(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_cyl_neumannf(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double cyl_neumannl(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_cyl_neumann(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double ellint_1(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_ellint_1(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float ellint_1f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_ellint_1f(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double ellint_1l(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_ellint_1(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double ellint_2(const double _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_ellint_2(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float ellint_2f(const float _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_ellint_2f(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double ellint_2l(const long double _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_ellint_2(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double ellint_3(const double _Arg1, const double _Arg2, const double _Arg3) noexcept
+/* strengthened */ {
+    return __std_smf_ellint_3(_Arg1, _Arg2, _Arg3);
+}
+
+_EXPORT_STD _NODISCARD inline float ellint_3f(const float _Arg1, const float _Arg2, const float _Arg3) noexcept
+/* strengthened */ {
+    return __std_smf_ellint_3f(_Arg1, _Arg2, _Arg3);
+}
+
+_EXPORT_STD _NODISCARD inline long double ellint_3l(
+    const long double _Arg1, const long double _Arg2, const long double _Arg3) noexcept /* strengthened */ {
+    return __std_smf_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2), static_cast<double>(_Arg3));
+}
+
+_EXPORT_STD _NODISCARD inline double expint(const double _Arg) noexcept /* strengthened */ {
+    return __std_smf_expint(_Arg);
+}
+
+_EXPORT_STD _NODISCARD inline float expintf(const float _Arg) noexcept /* strengthened */ {
+    return __std_smf_expintf(_Arg);
+}
+
+_EXPORT_STD _NODISCARD inline long double expintl(const long double _Arg) noexcept /* strengthened */ {
+    return __std_smf_expint(static_cast<double>(_Arg));
+}
+
+_EXPORT_STD _NODISCARD inline double hermite(const unsigned int _Arg1, const double _Arg2) noexcept /* strengthened */ {
+    return __std_smf_hermite(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float hermitef(const unsigned int _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_hermitef(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double hermitel(const unsigned int _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_hermite(_Arg1, static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double laguerre(const unsigned int _Arg1, const double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_laguerre(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float laguerref(const unsigned int _Arg1, const float _Arg2) noexcept /* strengthened */ {
+    return __std_smf_laguerref(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double laguerrel(const unsigned int _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_laguerre(_Arg1, static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double legendre(const unsigned int _Degree, const double _Value) noexcept
+/* strengthened */ {
+    return __std_smf_legendre(_Degree, _Value);
+}
+
+_EXPORT_STD _NODISCARD inline float legendref(const unsigned int _Degree, const float _Value) noexcept
+/* strengthened */ {
+    return __std_smf_legendref(_Degree, _Value);
+}
+
+_EXPORT_STD _NODISCARD inline long double legendrel(const unsigned int _Degree, const long double _Value) noexcept
+/* strengthened */ {
+    return __std_smf_legendre(_Degree, static_cast<double>(_Value));
+}
+
+_EXPORT_STD _NODISCARD inline double riemann_zeta(const double _Arg) noexcept /* strengthened */ {
+    return __std_smf_riemann_zeta(_Arg);
+}
+_EXPORT_STD _NODISCARD inline float riemann_zetaf(const float _Arg) noexcept /* strengthened */ {
+    return __std_smf_riemann_zetaf(_Arg);
+}
+
+_EXPORT_STD _NODISCARD inline long double riemann_zetal(const long double _Arg) noexcept /* strengthened */ {
+    return __std_smf_riemann_zeta(static_cast<double>(_Arg));
+}
+
+_EXPORT_STD _NODISCARD inline double sph_bessel(const unsigned int _Arg1, const double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_sph_bessel(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float sph_besself(const unsigned int _Arg1, const float _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_sph_besself(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double sph_bessell(const unsigned int _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_sph_bessel(_Arg1, static_cast<double>(_Arg2));
+}
+
+_EXPORT_STD _NODISCARD inline double sph_legendre(
+    const unsigned int _Arg1, const unsigned int _Arg2, const double _Theta) noexcept /* strengthened */ {
+    return __std_smf_sph_legendre(_Arg1, _Arg2, _Theta);
+}
+
+_EXPORT_STD _NODISCARD inline float sph_legendref(
+    const unsigned int _Arg1, const unsigned int _Arg2, const float _Theta) noexcept /* strengthened */ {
+    return __std_smf_sph_legendref(_Arg1, _Arg2, _Theta);
+}
+
+_EXPORT_STD _NODISCARD inline long double sph_legendrel(
+    const unsigned int _Arg1, const unsigned int _Arg2, const long double _Theta) noexcept /* strengthened */ {
+    return __std_smf_sph_legendre(_Arg1, _Arg2, static_cast<double>(_Theta));
+}
+
+_EXPORT_STD _NODISCARD inline double sph_neumann(const unsigned int _Arg1, const double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_sph_neumann(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline float sph_neumannf(const unsigned int _Arg1, const float _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_sph_neumannf(_Arg1, _Arg2);
+}
+
+_EXPORT_STD _NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long double _Arg2) noexcept
+/* strengthened */ {
+    return __std_smf_sph_neumann(_Arg1, static_cast<double>(_Arg2));
+}
+
+#define _GENERIC_MATH_SPECIAL1(NAME)                                                  \
+    _EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>      \
+    _NODISCARD auto NAME(const _Ty _Arg) noexcept /* strengthened */ {                \
+        using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>;               \
+        if constexpr (is_same_v<_Common, float>) {                                    \
+            return __std_smf_##NAME##f(_Arg);                                         \
+        } else {                                                                      \
+            return static_cast<_Common>(__std_smf_##NAME(static_cast<double>(_Arg))); \
+        }                                                                             \
+    }
+
+#define _GENERIC_MATH_SPECIAL2(NAME)                                                                               \
+    _EXPORT_STD template <class _Ty1, class _Ty2,                                                                  \
+        enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2>, int> = 0>                                      \
+    _NODISCARD auto NAME(const _Ty1 _Arg1, const _Ty2 _Arg2) noexcept /* strengthened */ {                         \
+        using _Common = _Common_float_type_t<_Ty1, _Ty2>;                                                          \
+        if constexpr (is_same_v<_Common, float>) {                                                                 \
+            return __std_smf_##NAME##f(_Arg1, _Arg2);                                                              \
+        } else {                                                                                                   \
+            return static_cast<_Common>(__std_smf_##NAME(static_cast<double>(_Arg1), static_cast<double>(_Arg2))); \
+        }                                                                                                          \
+    }
+
+#define _GENERIC_MATH_SPECIAL3(NAME)                                                                                   \
+    _EXPORT_STD template <class _Ty1, class _Ty2, class _Ty3,                                                          \
+        enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>, int> = 0>                 \
+    _NODISCARD auto NAME(const _Ty1 _Arg1, const _Ty2 _Arg2, const _Ty3 _Arg3) noexcept /* strengthened */ {           \
+        using _Common = _Common_float_type_t<_Ty1, _Common_float_type_t<_Ty2, _Ty3>>;                                  \
+        if constexpr (is_same_v<_Common, float>) {                                                                     \
+            return __std_smf_##NAME##f(_Arg1, _Arg2, _Arg3);                                                           \
+        } else {                                                                                                       \
+            return static_cast<_Common>(                                                                               \
+                __std_smf_##NAME(static_cast<double>(_Arg1), static_cast<double>(_Arg2), static_cast<double>(_Arg3))); \
+        }                                                                                                              \
+    }
+
+#define _GENERIC_MATH_SPECIAL_UINT1(NAME)                                                         \
+    _EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>                  \
+    _NODISCARD auto NAME(const unsigned int _Arg1, const _Ty _Arg2) noexcept /* strengthened */ { \
+        using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>;                           \
+        if constexpr (is_same_v<_Common, float>) {                                                \
+            return __std_smf_##NAME##f(_Arg1, _Arg2);                                             \
+        } else {                                                                                  \
+            return static_cast<_Common>(__std_smf_##NAME(_Arg1, static_cast<double>(_Arg2)));     \
+        }                                                                                         \
+    }
+
+#define _GENERIC_MATH_SPECIAL_UINT2(NAME)                                                                  \
+    _EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>                           \
+    _NODISCARD auto NAME(                                                                                  \
+        const unsigned int _Arg1, const unsigned int _Arg2, const _Ty _Arg3) noexcept /* strengthened */ { \
+        using _Common = conditional_t<is_integral_v<_Ty>, double, _Ty>;                                    \
+        if constexpr (is_same_v<_Common, float>) {                                                         \
+            return __std_smf_##NAME##f(_Arg1, _Arg2, _Arg3);                                               \
+        } else {                                                                                           \
+            return static_cast<_Common>(__std_smf_##NAME(_Arg1, _Arg2, static_cast<double>(_Arg3)));       \
+        }                                                                                                  \
+    }
+
+// per LWG-3234 and LWG-3693
+_GENERIC_MATH_SPECIAL_UINT2(assoc_laguerre)
+_GENERIC_MATH_SPECIAL_UINT2(assoc_legendre)
+_GENERIC_MATH_SPECIAL2(beta)
+_GENERIC_MATH_SPECIAL1(comp_ellint_1)
+_GENERIC_MATH_SPECIAL1(comp_ellint_2)
+_GENERIC_MATH_SPECIAL2(comp_ellint_3)
+_GENERIC_MATH_SPECIAL2(cyl_bessel_i)
+_GENERIC_MATH_SPECIAL2(cyl_bessel_j)
+_GENERIC_MATH_SPECIAL2(cyl_bessel_k)
+_GENERIC_MATH_SPECIAL2(cyl_neumann)
+_GENERIC_MATH_SPECIAL2(ellint_1)
+_GENERIC_MATH_SPECIAL2(ellint_2)
+_GENERIC_MATH_SPECIAL3(ellint_3)
+_GENERIC_MATH_SPECIAL1(expint)
+_GENERIC_MATH_SPECIAL_UINT1(hermite)
+_GENERIC_MATH_SPECIAL_UINT1(laguerre)
+_GENERIC_MATH_SPECIAL_UINT1(legendre)
+_GENERIC_MATH_SPECIAL1(riemann_zeta)
+_GENERIC_MATH_SPECIAL_UINT1(sph_bessel)
+_GENERIC_MATH_SPECIAL_UINT2(sph_legendre)
+_GENERIC_MATH_SPECIAL_UINT1(sph_neumann)
+
+#undef _GENERIC_MATH_SPECIAL1
+#undef _GENERIC_MATH_SPECIAL2
+#undef _GENERIC_MATH_SPECIAL3
+#undef _GENERIC_MATH_SPECIAL_UINT1
+#undef _GENERIC_MATH_SPECIAL_UINT2
+
+_EXPORT_STD _NODISCARD inline double hypot(const double _Dx, const double _Dy, const double _Dz) noexcept
+/* strengthened */ {
+    return __std_smf_hypot3(_Dx, _Dy, _Dz);
+}
+
+_EXPORT_STD _NODISCARD inline float hypot(const float _Dx, const float _Dy, const float _Dz) noexcept
+/* strengthened */ {
+    return __std_smf_hypot3f(_Dx, _Dy, _Dz);
+}
+
+_EXPORT_STD _NODISCARD inline long double hypot(
+    const long double _Dx, const long double _Dy, const long double _Dz) noexcept /* strengthened */ {
+    return __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Ty3,
+    enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>, int> = 0>
+_NODISCARD auto hypot(const _Ty1 _Dx, const _Ty2 _Dy, const _Ty3 _Dz) noexcept /* strengthened */ {
+    // N4950 [cmath.syn]/3 "Sufficient additional overloads"
+    // Note that this template is selected by overload resolution only when at least one
+    // argument is double/long double/integral but not all three are double or long double.
+    using _Common      = _Common_float_type_t<_Ty1, _Common_float_type_t<_Ty2, _Ty3>>; // TRANSITION, fold expressions
+    const auto _Result = __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
+    return static_cast<_Common>(_Result);
+}
+
+#if _HAS_CXX20
+template <class _Ty>
+_NODISCARD constexpr _Ty _Linear_for_lerp(const _Ty _ArgA, const _Ty _ArgB, const _Ty _ArgT) noexcept {
+    if (_STD is_constant_evaluated()) {
+        auto _Smaller     = _ArgT;
+        auto _Larger      = _ArgB - _ArgA;
+        auto _Abs_smaller = _Float_abs(_Smaller);
+        auto _Abs_larger  = _Float_abs(_Larger);
+        if (_Abs_larger < _Abs_smaller) {
+            _Ty _Tmp = _Smaller;
+            _Smaller = _Larger;
+            _Larger  = _Tmp;
+
+            _Tmp         = _Abs_smaller;
+            _Abs_smaller = _Abs_larger;
+            _Abs_larger  = _Tmp;
+        }
+
+        if (_Abs_smaller > 1) {
+            // _Larger is too large to be subnormal, so scaling by 0.5 is exact, and the product _Smaller * _Larger is
+            // large enough that if _ArgA is subnormal, it will be too small to contribute anyway and this way can
+            // sometimes avoid overflow problems.
+            return 2 * (_Ty{0.5} * _ArgA + _Smaller * (_Ty{0.5} * _Larger));
+        } else {
+            return _ArgA + _Smaller * _Larger;
+        }
+    }
+
+    return _STD fma(_ArgT, _ArgB - _ArgA, _ArgA);
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty _Common_lerp(const _Ty _ArgA, const _Ty _ArgB, const _Ty _ArgT) noexcept {
+    // on a line intersecting {(0.0, _ArgA), (1.0, _ArgB)}, return the Y value for X == _ArgT
+
+    const bool _T_is_finite = _Is_finite(_ArgT);
+    if (_T_is_finite && _Is_finite(_ArgA) && _Is_finite(_ArgB)) {
+        // 99% case, put it first; this block comes from P0811R3
+        if ((_ArgA <= 0 && _ArgB >= 0) || (_ArgA >= 0 && _ArgB <= 0)) {
+            // exact, monotonic, bounded, determinate, and (for _ArgA == _ArgB == 0) consistent:
+            return _ArgT * _ArgB + (1 - _ArgT) * _ArgA;
+        }
+
+        if (_ArgT == 1) {
+            // exact
+            return _ArgB;
+        }
+
+        // exact at _ArgT == 0, monotonic except near _ArgT == 1, bounded, determinate, and consistent:
+        const auto _Candidate = _Linear_for_lerp(_ArgA, _ArgB, _ArgT);
+        // monotonic near _ArgT == 1:
+        if ((_ArgT > 1) == (_ArgB > _ArgA)) {
+            if (_ArgB > _Candidate) {
+                return _ArgB;
+            }
+        } else {
+            if (_Candidate > _ArgB) {
+                return _ArgB;
+            }
+        }
+
+        return _Candidate;
+    }
+
+    if (_STD is_constant_evaluated()) {
+        if (_Is_nan(_ArgA)) {
+            return _ArgA;
+        }
+
+        if (_Is_nan(_ArgB)) {
+            return _ArgB;
+        }
+
+        if (_Is_nan(_ArgT)) {
+            return _ArgT;
+        }
+    } else {
+        // raise FE_INVALID if at least one of _ArgA, _ArgB, and _ArgT is signaling NaN
+        if (_Is_nan(_ArgA) || _Is_nan(_ArgB)) {
+            return (_ArgA + _ArgB) + _ArgT;
+        }
+
+        if (_Is_nan(_ArgT)) {
+            return _ArgT + _ArgT;
+        }
+    }
+
+    if (_T_is_finite) {
+        // _ArgT is finite, _ArgA and/or _ArgB is infinity
+        if (_ArgT < 0) {
+            // if _ArgT < 0:     return infinity in the "direction" of _ArgA if that exists, NaN otherwise
+            return _ArgA - _ArgB;
+        } else if (_ArgT <= 1) {
+            // if _ArgT == 0:    return _ArgA (infinity) if _ArgB is finite, NaN otherwise
+            // if 0 < _ArgT < 1: return infinity "between" _ArgA and _ArgB if that exists, NaN otherwise
+            // if _ArgT == 1:    return _ArgB (infinity) if _ArgA is finite, NaN otherwise
+            return _ArgT * _ArgB + (1 - _ArgT) * _ArgA;
+        } else {
+            // if _ArgT > 1:     return infinity in the "direction" of _ArgB if that exists, NaN otherwise
+            return _ArgB - _ArgA;
+        }
+    } else {
+        // _ArgT is an infinity; return infinity in the "direction" of _ArgA and _ArgB if that exists, NaN otherwise
+        return _ArgT * (_ArgB - _ArgA);
+    }
+}
+
+_EXPORT_STD _NODISCARD constexpr inline float lerp(const float _ArgA, const float _ArgB, const float _ArgT) noexcept {
+    return _Common_lerp(_ArgA, _ArgB, _ArgT);
+}
+
+_EXPORT_STD _NODISCARD constexpr inline double lerp(
+    const double _ArgA, const double _ArgB, const double _ArgT) noexcept {
+    return _Common_lerp(_ArgA, _ArgB, _ArgT);
+}
+
+_EXPORT_STD _NODISCARD constexpr inline long double lerp(
+    const long double _ArgA, const long double _ArgB, const long double _ArgT) noexcept {
+    return _Common_lerp(static_cast<double>(_ArgA), static_cast<double>(_ArgB), static_cast<double>(_ArgT));
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Ty3>
+    requires is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>
+_NODISCARD constexpr auto lerp(const _Ty1 _ArgA, const _Ty2 _ArgB, const _Ty3 _ArgT) noexcept {
+    using _Common = _Common_float_type_t<_Ty1, _Common_float_type_t<_Ty2, _Ty3>>;
+    return static_cast<_Common>(
+        _Common_lerp(static_cast<double>(_ArgA), static_cast<double>(_ArgB), static_cast<double>(_ArgT)));
+}
+#endif // _HAS_CXX20
+_STD_END
+#endif // _HAS_CXX17
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CMATH_
diff --git a/msvc-stl/stl/inc/codecvt b/msvc-stl/stl/inc/codecvt
new file mode 100644
index 0000000..c46df0d
--- /dev/null
+++ b/msvc-stl/stl/inc/codecvt
@@ -0,0 +1,689 @@
+// codecvt standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CODECVT_
+#define _CODECVT_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cwchar>
+#include <locale>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_INLINE_VAR constexpr int _Little_first = 1;
+_INLINE_VAR constexpr int _Big_first    = 2;
+
+_EXPORT_STD enum _CXX17_DEPRECATE_CODECVT_HEADER codecvt_mode {
+    consume_header  = 4,
+    generate_header = 2,
+    little_endian   = 1
+};
+
+using _Statype = _CSTD mbstate_t;
+
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
+class _CXX17_DEPRECATE_CODECVT_HEADER codecvt_utf8 : public codecvt<_Elem, char, _Statype> {
+    // facet for converting between _Elem and UTF-8 byte sequences
+public:
+    using _Mybase     = codecvt<_Elem, char, _Statype>;
+    using result      = typename _Mybase::result;
+    using _Byte       = char;
+    using intern_type = _Elem;
+    using extern_type = _Byte;
+    using state_type  = _Statype;
+
+    explicit codecvt_utf8(size_t _Refs = 0) : _Mybase(_Refs) {}
+
+    __CLR_OR_THIS_CALL ~codecvt_utf8() noexcept override {}
+
+protected:
+    result __CLR_OR_THIS_CALL do_in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
+        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const override {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        char* _Pstate = reinterpret_cast<char*>(&_State);
+        _Mid1         = _First1;
+        _Mid2         = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert a multibyte sequence
+            unsigned long _By = static_cast<unsigned char>(*_Mid1);
+            unsigned long _Ch;
+            int _Nextra;
+
+            if (_By < 0x80u) {
+                _Ch     = _By;
+                _Nextra = 0;
+            } else if (_By < 0xc0u) { // 0x80-0xbf not first byte
+                ++_Mid1;
+                return _Mybase::error;
+            } else if (_By < 0xe0u) {
+                _Ch     = _By & 0x1f;
+                _Nextra = 1;
+            } else if (_By < 0xf0u) {
+                _Ch     = _By & 0x0f;
+                _Nextra = 2;
+            } else if (_By < 0xf8u) {
+                _Ch     = _By & 0x07;
+                _Nextra = 3;
+            } else {
+                _Ch     = _By & 0x03;
+                _Nextra = _By < 0xfc ? 4 : 5;
+            }
+
+            if (_Nextra == 0) {
+                ++_Mid1;
+            } else if (_Last1 - _Mid1 < _Nextra + 1) {
+                break; // not enough input
+            } else {
+                for (++_Mid1; 0 < _Nextra; --_Nextra, ++_Mid1) {
+                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
+                        return _Mybase::error; // not continuation byte
+                    } else {
+                        _Ch = _Ch << 6 | (_By & 0x3f);
+                    }
+                }
+            }
+
+            if (*_Pstate == 0) { // first time, maybe look for and consume header
+                *_Pstate = 1;
+
+                if constexpr ((_Mymode & consume_header) != 0) {
+                    if (_Ch == 0xfeff) { // drop header and retry
+                        const result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+
+                        if (_Ans == _Mybase::partial) { // roll back header determination
+                            *_Pstate = 0;
+                            _Mid1    = _First1;
+                        }
+
+                        return _Ans;
+                    }
+                }
+            }
+
+            if (_Mymax < _Ch) {
+                return _Mybase::error; // code too large
+            }
+
+            *_Mid2++ = static_cast<_Elem>(_Ch);
+        }
+
+        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
+    }
+
+    result __CLR_OR_THIS_CALL do_out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
+        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const override {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        char* _Pstate = reinterpret_cast<char*>(&_State);
+        _Mid1         = _First1;
+        _Mid2         = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert and put a wide char
+            _Byte _By;
+            int _Nextra;
+            unsigned long _Ch = static_cast<unsigned long>(*_Mid1);
+
+            if (_Mymax < _Ch) {
+                return _Mybase::error;
+            }
+
+            if (_Ch < 0x0080u) {
+                _By     = static_cast<_Byte>(_Ch);
+                _Nextra = 0;
+            } else if (_Ch < 0x0800u) {
+                _By     = static_cast<_Byte>(0xc0 | _Ch >> 6);
+                _Nextra = 1;
+            } else if (_Ch < 0x00010000u) {
+                _By     = static_cast<_Byte>(0xe0 | _Ch >> 12);
+                _Nextra = 2;
+            } else if (_Ch < 0x00200000u) {
+                _By     = static_cast<_Byte>(0xf0 | _Ch >> 18);
+                _Nextra = 3;
+            } else if (_Ch < 0x04000000u) {
+                _By     = static_cast<_Byte>(0xf8 | _Ch >> 24);
+                _Nextra = 4;
+            } else {
+                _By     = static_cast<_Byte>(0xfc | (_Ch >> 30 & 0x03));
+                _Nextra = 5;
+            }
+
+            if (*_Pstate == 0) { // first time, maybe generate header
+                *_Pstate = 1;
+
+                if constexpr ((_Mymode & generate_header) != 0) {
+                    if (_Last2 - _Mid2 < 3 + 1 + _Nextra) {
+                        return _Mybase::partial; // not enough room for both
+                    }
+
+                    // prepend header
+                    *_Mid2++ = '\xef';
+                    *_Mid2++ = '\xbb';
+                    *_Mid2++ = '\xbf';
+                }
+            }
+
+            if (_Last2 - _Mid2 < 1 + _Nextra) {
+                break; // not enough room for output
+            }
+
+            ++_Mid1;
+            for (*_Mid2++ = _By; 0 < _Nextra;) {
+                *_Mid2++ = static_cast<_Byte>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
+            }
+        }
+
+        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
+    }
+
+    result __CLR_OR_THIS_CALL do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const override {
+        // generate bytes to return to default shift state
+        _Mid2 = _First2;
+        return _Mybase::noconv;
+    }
+
+    friend int _Codecvt_do_length<>(const codecvt_utf8&, _Statype&, const _Byte*, const _Byte*, size_t);
+
+    int __CLR_OR_THIS_CALL do_length(
+        _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const noexcept override {
+        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        if constexpr ((_Mymode & (consume_header | generate_header)) != 0) {
+            return 9;
+        } else {
+            return 6;
+        }
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        if constexpr ((_Mymode & (consume_header | generate_header)) != 0) {
+            return -1; // -1 => state dependent
+        } else {
+            return 0; // 0 => varying length
+        }
+    }
+};
+
+_EXPORT_STD template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
+class _CXX17_DEPRECATE_CODECVT_HEADER codecvt_utf16 : public codecvt<_Elem, char, _Statype> {
+    // facet for converting between _Elem and UTF-16 multibyte sequences
+private:
+    enum { _Bytes_per_word = 2 };
+
+public:
+    using _Mybase     = codecvt<_Elem, char, _Statype>;
+    using result      = typename _Mybase::result;
+    using _Byte       = char;
+    using intern_type = _Elem;
+    using extern_type = _Byte;
+    using state_type  = _Statype;
+
+    explicit codecvt_utf16(size_t _Refs = 0) : _Mybase(_Refs) {}
+
+    __CLR_OR_THIS_CALL ~codecvt_utf16() noexcept override {}
+
+protected:
+    result __CLR_OR_THIS_CALL do_in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
+        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const override {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        char* _Pstate = reinterpret_cast<char*>(&_State);
+        _Mid1         = _First1;
+        _Mid2         = _First2;
+
+        while (_Bytes_per_word <= _Last1 - _Mid1 && _Mid2 != _Last2) { // convert a multibyte sequence
+            const auto _Ptr = reinterpret_cast<const unsigned char*>(_Mid1);
+            unsigned long _Ch;
+            unsigned short _Ch0;
+            unsigned short _Ch1;
+
+            if (*_Pstate == _Little_first) {
+                _Ch0 = static_cast<unsigned short>(_Ptr[1] << 8 | _Ptr[0]);
+            } else if (*_Pstate == _Big_first) {
+                _Ch0 = static_cast<unsigned short>(_Ptr[0] << 8 | _Ptr[1]);
+            } else { // no header seen yet, try preferred mode
+                constexpr bool _Prefer_LE      = (_Mymode & little_endian) != 0;
+                constexpr char _Default_endian = _Prefer_LE ? _Little_first : _Big_first;
+
+                if constexpr (_Prefer_LE) {
+                    _Ch0 = static_cast<unsigned short>(_Ptr[1] << 8 | _Ptr[0]);
+                } else {
+                    _Ch0 = static_cast<unsigned short>(_Ptr[0] << 8 | _Ptr[1]);
+                }
+
+                *_Pstate = _Default_endian;
+
+                if constexpr ((_Mymode & consume_header) != 0) {
+                    if (_Ch0 == 0xfffeu) {
+                        *_Pstate = 3 - _Default_endian;
+                    }
+
+                    if (_Ch0 == 0xfffeu || _Ch0 == 0xfeffu) { // consume header, fixate on endianness, and retry
+                        _Mid1 += _Bytes_per_word;
+                        result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+
+                        if (_Ans == _Mybase::partial) { // not enough bytes, roll back header
+                            *_Pstate = 0;
+                            _Mid1    = _First1;
+                        }
+
+                        return _Ans;
+                    }
+                }
+            }
+
+            if (_Ch0 < 0xd800u || 0xdc00u <= _Ch0) { // one word, consume bytes
+                _Mid1 += _Bytes_per_word;
+                _Ch = _Ch0;
+            } else if (_Last1 - _Mid1 < 2 * _Bytes_per_word) {
+                break;
+            } else { // get second word
+                if (*_Pstate == _Little_first) {
+                    _Ch1 = static_cast<unsigned short>(_Ptr[3] << 8 | _Ptr[2]);
+                } else {
+                    _Ch1 = static_cast<unsigned short>(_Ptr[2] << 8 | _Ptr[3]);
+                }
+
+                if (_Ch1 < 0xdc00u || 0xe000u <= _Ch1) {
+                    return _Mybase::error;
+                }
+
+                _Mid1 += 2 * _Bytes_per_word;
+                _Ch = static_cast<unsigned long>(_Ch0 - 0xd800 + 0x0040) << 10 | (_Ch1 - 0xdc00);
+            }
+
+            if (_Mymax < _Ch) {
+                return _Mybase::error; // code too large
+            }
+
+            *_Mid2++ = static_cast<_Elem>(_Ch);
+        }
+
+        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
+    }
+
+    result __CLR_OR_THIS_CALL do_out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
+        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const override {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        char* _Pstate = reinterpret_cast<char*>(&_State);
+        _Mid1         = _First1;
+        _Mid2         = _First2;
+
+        if (*_Pstate == 0) { // determine endianness once, maybe generate header
+            if constexpr ((_Mymode & little_endian) != 0) {
+                *_Pstate = _Little_first;
+            } else {
+                *_Pstate = _Big_first;
+            }
+
+            if constexpr ((_Mymode & generate_header) != 0) {
+                if (_Last2 - _Mid2 < 3 * _Bytes_per_word) {
+                    return _Mybase::partial; // not enough room for all
+                }
+
+                if (*_Pstate == _Little_first) { // put header LS byte first
+                    *_Mid2++ = '\xff';
+                    *_Mid2++ = '\xfe';
+                } else { // put header MS byte first
+                    *_Mid2++ = '\xfe';
+                    *_Mid2++ = '\xff';
+                }
+            }
+        }
+
+        while (_Mid1 != _Last1 && _Bytes_per_word <= _Last2 - _Mid2) { // convert and put a wide char
+            bool _Extra       = false;
+            unsigned long _Ch = static_cast<unsigned long>(*_Mid1++);
+
+            if ((_Mymax < 0x10ffffu ? _Mymax : 0x10ffffu) < _Ch) {
+                return _Mybase::error; // value too large
+            }
+
+            if (_Ch <= 0xffffu) { // one word, can't be code for first of two
+                if (0xd800u <= _Ch && _Ch < 0xdc00u) {
+                    return _Mybase::error;
+                }
+            } else if (_Last2 - _Mid2 < 2 * _Bytes_per_word) { // not enough room for two-word output, back up
+                --_Mid1;
+                return _Mybase::partial;
+            } else {
+                _Extra = true;
+            }
+
+            if (*_Pstate == _Little_first) {
+                if (_Extra) { // put a pair of words LS byte first
+                    unsigned short _Ch0 =
+                        static_cast<unsigned short>(0xd800 | static_cast<unsigned short>(_Ch >> 10) - 0x0040);
+                    *_Mid2++ = static_cast<_Byte>(_Ch0);
+                    *_Mid2++ = static_cast<_Byte>(_Ch0 >> 8);
+
+                    _Ch0     = static_cast<unsigned short>(0xdc00 | (static_cast<unsigned short>(_Ch) & 0x03ff));
+                    *_Mid2++ = static_cast<_Byte>(_Ch0);
+                    *_Mid2++ = static_cast<_Byte>(_Ch0 >> 8);
+                } else { // put a single word LS byte first
+                    *_Mid2++ = static_cast<_Byte>(_Ch);
+                    *_Mid2++ = static_cast<_Byte>(_Ch >> 8);
+                }
+            } else {
+                if (_Extra) { // put a pair of words MS byte first
+                    unsigned short _Ch0 =
+                        static_cast<unsigned short>(0xd800 | static_cast<unsigned short>(_Ch >> 10) - 0x0040);
+                    *_Mid2++ = static_cast<_Byte>(_Ch0 >> 8);
+                    *_Mid2++ = static_cast<_Byte>(_Ch0);
+
+                    _Ch0     = static_cast<unsigned short>(0xdc00 | (static_cast<unsigned short>(_Ch) & 0x03ff));
+                    *_Mid2++ = static_cast<_Byte>(_Ch0 >> 8);
+                    *_Mid2++ = static_cast<_Byte>(_Ch0);
+                } else { // put a single word MS byte first
+                    *_Mid2++ = static_cast<_Byte>(_Ch >> 8);
+                    *_Mid2++ = static_cast<_Byte>(_Ch);
+                }
+            }
+        }
+
+        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
+    }
+
+    result __CLR_OR_THIS_CALL do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const override {
+        // generate bytes to return to default shift state
+        _Mid2 = _First2;
+        return _Mybase::noconv;
+    }
+
+    friend int _Codecvt_do_length<>(const codecvt_utf16&, _Statype&, const _Byte*, const _Byte*, size_t);
+
+    int __CLR_OR_THIS_CALL do_length(
+        _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const noexcept override {
+        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        if constexpr ((_Mymode & (consume_header | generate_header)) != 0) {
+            return 3 * _Bytes_per_word;
+        } else {
+            return 6 * _Bytes_per_word;
+        }
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        if constexpr ((_Mymode & (consume_header | generate_header)) != 0) {
+            return -1; // -1 => state dependent
+        } else {
+            return 0; // 0 => varying length
+        }
+    }
+};
+
+_EXPORT_STD template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
+class _CXX17_DEPRECATE_CODECVT_HEADER codecvt_utf8_utf16
+    : public codecvt<_Elem, char, _Statype> { // facet for converting between UTF-16 _Elem and UTF-8 byte sequences
+public:
+    using _Mybase     = codecvt<_Elem, char, _Statype>;
+    using result      = typename _Mybase::result;
+    using _Byte       = char;
+    using intern_type = _Elem;
+    using extern_type = _Byte;
+    using state_type  = _Statype;
+
+    static_assert(sizeof(unsigned short) <= sizeof(state_type), "state_type too small");
+
+    explicit codecvt_utf8_utf16(size_t _Refs = 0) : _Mybase(_Refs) {}
+
+    __CLR_OR_THIS_CALL ~codecvt_utf8_utf16() noexcept override {}
+
+protected:
+    result __CLR_OR_THIS_CALL do_in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
+        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const override {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
+        _Mid1                   = _First1;
+        _Mid2                   = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert a multibyte sequence
+            unsigned long _By = static_cast<unsigned char>(*_Mid1);
+            unsigned long _Ch;
+            int _Nextra;
+            int _Nskip;
+
+            if (*_Pstate > 1u) {
+                if (_By < 0x80u || 0xc0u <= _By) {
+                    return _Mybase::error; // not continuation byte
+                }
+
+                // deliver second half of two-word value
+                ++_Mid1;
+                *_Mid2++ = static_cast<_Elem>(*_Pstate | (_By & 0x3f));
+                *_Pstate = 1;
+                continue;
+            }
+
+            if (_By < 0x80u) {
+                _Ch     = _By;
+                _Nextra = 0;
+            } else if (_By < 0xc0u) { // 0x80-0xbf not first byte
+                ++_Mid1;
+                return _Mybase::error;
+            } else if (_By < 0xe0u) {
+                _Ch     = _By & 0x1f;
+                _Nextra = 1;
+            } else if (_By < 0xf0u) {
+                _Ch     = _By & 0x0f;
+                _Nextra = 2;
+            } else if (_By < 0xf8u) {
+                _Ch     = _By & 0x07;
+                _Nextra = 3;
+            } else {
+                _Ch     = _By & 0x03;
+                _Nextra = _By < 0xfc ? 4 : 5;
+            }
+
+            _Nskip  = _Nextra < 3 ? 0 : 1; // leave a byte for 2nd word
+            _First1 = _Mid1; // roll back point
+
+            if (_Nextra == 0) {
+                ++_Mid1;
+            } else if (_Last1 - _Mid1 < _Nextra + 1 - _Nskip) {
+                break; // not enough input
+            } else {
+                for (++_Mid1; _Nskip < _Nextra; --_Nextra, ++_Mid1) {
+                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
+                        return _Mybase::error; // not continuation byte
+                    }
+
+                    _Ch = _Ch << 6 | (_By & 0x3f);
+                }
+            }
+
+            if (0 < _Nskip) {
+                _Ch <<= 6; // get last byte on next call
+            }
+
+            if ((_Mymax < 0x10ffffu ? _Mymax : 0x10ffffu) < _Ch) {
+                return _Mybase::error; // value too large
+            }
+
+            if (0xffffu < _Ch) { // deliver first half of two-word value, save second word
+                unsigned short _Ch0 = static_cast<unsigned short>(0xd800 | (_Ch >> 10) - 0x0040);
+
+                *_Mid2++ = static_cast<_Elem>(_Ch0);
+                *_Pstate = static_cast<unsigned short>(0xdc00 | (_Ch & 0x03ff));
+                continue;
+            }
+
+            if (_Nskip != 0) {
+                if (_Mid1 == _Last1) { // not enough bytes, noncanonical value
+                    _Mid1 = _First1;
+                    break;
+                }
+
+                if ((_By = static_cast<unsigned char>(*_Mid1++)) < 0x80u || 0xc0u <= _By) {
+                    return _Mybase::error; // not continuation byte
+                }
+
+                _Ch |= _By & 0x3f; // complete noncanonical value
+            }
+
+            if (*_Pstate == 0u) { // first time, maybe look for and consume header
+                *_Pstate = 1;
+
+                if constexpr ((_Mymode & consume_header) != 0) {
+                    if (_Ch == 0xfeffu) { // drop header and retry
+                        result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+
+                        if (_Ans == _Mybase::partial) { // roll back header determination
+                            *_Pstate = 0;
+                            _Mid1    = _First1;
+                        }
+
+                        return _Ans;
+                    }
+                }
+            }
+
+            *_Mid2++ = static_cast<_Elem>(_Ch);
+        }
+
+        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
+    }
+
+    result __CLR_OR_THIS_CALL do_out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
+        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const override {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
+        _Mid1                   = _First1;
+        _Mid2                   = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert and put a wide char
+            unsigned long _Ch;
+            unsigned short _Ch1 = static_cast<unsigned short>(*_Mid1);
+            bool _Save          = false;
+
+            if (1u < *_Pstate) { // get saved MS 11 bits from *_Pstate
+                if (_Ch1 < 0xdc00u || 0xe000u <= _Ch1) {
+                    return _Mybase::error; // bad second word
+                }
+
+                _Ch = static_cast<unsigned long>((*_Pstate << 10) | (_Ch1 - 0xdc00));
+            } else if (0xd800u <= _Ch1 && _Ch1 < 0xdc00u) { // get new first word
+                _Ch   = static_cast<unsigned long>((_Ch1 - 0xd800 + 0x0040) << 10);
+                _Save = true; // put only first byte, rest with second word
+            } else {
+                _Ch = _Ch1; // not first word, just put it
+            }
+
+            _Byte _By;
+            int _Nextra;
+
+            if (_Ch < 0x0080u) {
+                _By     = static_cast<_Byte>(_Ch);
+                _Nextra = 0;
+            } else if (_Ch < 0x0800u) {
+                _By     = static_cast<_Byte>(0xc0 | _Ch >> 6);
+                _Nextra = 1;
+            } else if (_Ch < 0x10000u) {
+                _By     = static_cast<_Byte>(0xe0 | _Ch >> 12);
+                _Nextra = 2;
+            } else {
+                _By     = static_cast<_Byte>(0xf0 | _Ch >> 18);
+                _Nextra = 3;
+            }
+
+            int _Nput = _Nextra < 3 ? _Nextra + 1 : _Save ? 1 : 3;
+
+            if (_Last2 - _Mid2 < _Nput) {
+                break; // not enough room, even without header
+            }
+
+            if constexpr ((_Mymode & generate_header) != 0) { // header to put
+                if (*_Pstate == 0u) {
+                    if (_Last2 - _Mid2 < 3 + _Nput) {
+                        break; // not enough room for header + output
+                    }
+
+                    // prepend header
+                    *_Mid2++ = '\xef';
+                    *_Mid2++ = '\xbb';
+                    *_Mid2++ = '\xbf';
+                }
+            }
+
+            ++_Mid1;
+            if (_Save || _Nextra < 3) { // put first byte of sequence, if not already put
+                *_Mid2++ = _By;
+                --_Nput;
+            }
+
+            for (; 0 < _Nput; --_Nput) {
+                *_Mid2++ = static_cast<_Byte>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
+            }
+
+            *_Pstate = static_cast<unsigned short>(_Save ? _Ch >> 10 : 1);
+        }
+
+        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
+    }
+
+    result __CLR_OR_THIS_CALL do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const override {
+        // generate bytes to return to default shift state
+        _Mid2 = _First2;
+        return _Mybase::noconv;
+    }
+
+    friend int _Codecvt_do_length<>(const codecvt_utf8_utf16&, _Statype&, const _Byte*, const _Byte*, size_t);
+
+    int __CLR_OR_THIS_CALL do_length(
+        _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const noexcept override {
+        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        if constexpr ((_Mymode & consume_header) != 0) {
+            return 9; // header + max input
+        } else if constexpr ((_Mymode & generate_header) != 0) {
+            return 7; // header + max output
+        } else {
+            return 6; // 6-byte max input sequence, no 3-byte header
+        }
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return 0; // 0 => varying length
+    }
+};
+_STL_RESTORE_DEPRECATED_WARNING
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CODECVT_
diff --git a/msvc-stl/stl/inc/compare b/msvc-stl/stl/inc/compare
new file mode 100644
index 0000000..17e5a62
--- /dev/null
+++ b/msvc-stl/stl/inc/compare
@@ -0,0 +1,866 @@
+// compare standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _COMPARE_
+#define _COMPARE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <compare> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+#include <concepts>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+void _Literal_zero_is_expected();
+
+struct _Literal_zero {
+    template <class _Ty>
+        requires is_same_v<_Ty, int>
+    consteval _Literal_zero(_Ty _Zero) noexcept {
+        // Can't use _STL_VERIFY because this is a core header
+        if (_Zero != 0) {
+            _Literal_zero_is_expected();
+        }
+    }
+};
+
+using _Compare_t = signed char;
+
+// These "pretty" enumerator names are safe since they reuse names of user-facing entities.
+enum class _Compare_eq : _Compare_t { equal = 0, equivalent = equal };
+enum class _Compare_ord : _Compare_t { less = -1, greater = 1 };
+enum class _Compare_ncmp : _Compare_t { unordered = -128 };
+
+_EXPORT_STD struct partial_ordering {
+    template <int> // Prevent unwanted construction without interfering with overload resolution or the MSVC ABI.
+    constexpr partial_ordering() = delete; // constexpr is necessary, see N5032 [basic.types.general]/10.5.3.4.
+
+    static const partial_ordering less;
+    static const partial_ordering equivalent;
+    static const partial_ordering greater;
+    static const partial_ordering unordered;
+
+    _NODISCARD friend constexpr bool operator==(const partial_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value == 0;
+    }
+
+    _NODISCARD friend constexpr bool operator==(partial_ordering, partial_ordering) noexcept = default;
+
+    _NODISCARD friend constexpr bool operator<(const partial_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value == static_cast<_Compare_t>(_Compare_ord::less);
+    }
+
+    _NODISCARD friend constexpr bool operator>(const partial_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value > 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<=(const partial_ordering _Val, _Literal_zero) noexcept {
+        // The stored value is either less (0xff), equivalent (0x00), greater (0x01), or unordered (0x80).
+        // Subtracting from 0 produces either 0x01, 0x00, 0xff, or 0x80. The result is greater than or equal to 0
+        // if and only if the initial value was less or equivalent, for which we want to return true.
+        return static_cast<signed char>(0 - static_cast<unsigned int>(_Val._Value)) >= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>=(const partial_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value >= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<(_Literal_zero, const partial_ordering _Val) noexcept {
+        return _Val > 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>(_Literal_zero, const partial_ordering _Val) noexcept {
+        return _Val < 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<=(_Literal_zero, const partial_ordering _Val) noexcept {
+        return _Val >= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>=(_Literal_zero, const partial_ordering _Val) noexcept {
+        return _Val <= 0;
+    }
+
+    _NODISCARD friend constexpr partial_ordering operator<=>(const partial_ordering _Val, _Literal_zero) noexcept {
+        return _Val;
+    }
+
+    _NODISCARD friend constexpr partial_ordering operator<=>(_Literal_zero, const partial_ordering _Val) noexcept {
+        // The stored value is either less (0xff), equivalent (0x00), greater (0x01), or unordered (0x80).
+        // Subtracting from 0 produces either 0x01, 0x00, 0xff, or 0x80. Note that the effect is to
+        // exchange less for greater (and vice versa), while leaving equivalent and unordered unchanged.
+        return _STD _Bit_cast<partial_ordering>(static_cast<_Compare_t>(0 - static_cast<unsigned int>(_Val._Value)));
+    }
+
+    _Compare_t _Value;
+};
+
+inline constexpr partial_ordering partial_ordering::less{_STD _Bit_cast<partial_ordering>(_Compare_ord::less)};
+inline constexpr partial_ordering partial_ordering::equivalent{
+    _STD _Bit_cast<partial_ordering>(_Compare_eq::equivalent)};
+inline constexpr partial_ordering partial_ordering::greater{_STD _Bit_cast<partial_ordering>(_Compare_ord::greater)};
+inline constexpr partial_ordering partial_ordering::unordered{
+    _STD _Bit_cast<partial_ordering>(_Compare_ncmp::unordered)};
+
+_EXPORT_STD struct weak_ordering {
+    template <int> // Prevent unwanted construction without interfering with overload resolution or the MSVC ABI.
+    constexpr weak_ordering() = delete; // constexpr is necessary, see N5032 [basic.types.general]/10.5.3.4.
+
+    static const weak_ordering less;
+    static const weak_ordering equivalent;
+    static const weak_ordering greater;
+
+    constexpr operator partial_ordering() const noexcept {
+        return _STD _Bit_cast<partial_ordering>(_Value);
+    }
+
+    _NODISCARD friend constexpr bool operator==(const weak_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value == 0;
+    }
+
+    _NODISCARD friend constexpr bool operator==(weak_ordering, weak_ordering) noexcept = default;
+
+    _NODISCARD friend constexpr bool operator<(const weak_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value < 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>(const weak_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value > 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<=(const weak_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value <= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>=(const weak_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value >= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<(_Literal_zero, const weak_ordering _Val) noexcept {
+        return _Val > 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>(_Literal_zero, const weak_ordering _Val) noexcept {
+        return _Val < 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<=(_Literal_zero, const weak_ordering _Val) noexcept {
+        return _Val >= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>=(_Literal_zero, const weak_ordering _Val) noexcept {
+        return _Val <= 0;
+    }
+
+    _NODISCARD friend constexpr weak_ordering operator<=>(const weak_ordering _Val, _Literal_zero) noexcept {
+        return _Val;
+    }
+
+    _NODISCARD friend constexpr weak_ordering operator<=>(_Literal_zero, const weak_ordering _Val) noexcept {
+        return _STD _Bit_cast<weak_ordering>(static_cast<_Compare_t>(-_Val._Value));
+    }
+
+    _Compare_t _Value;
+};
+
+inline constexpr weak_ordering weak_ordering::less{_STD _Bit_cast<weak_ordering>(_Compare_ord::less)};
+inline constexpr weak_ordering weak_ordering::equivalent{_STD _Bit_cast<weak_ordering>(_Compare_eq::equivalent)};
+inline constexpr weak_ordering weak_ordering::greater{_STD _Bit_cast<weak_ordering>(_Compare_ord::greater)};
+
+_EXPORT_STD struct strong_ordering {
+    template <int> // Prevent unwanted construction without interfering with overload resolution or the MSVC ABI.
+    constexpr strong_ordering() = delete; // constexpr is necessary, see N5032 [basic.types.general]/10.5.3.4.
+
+    static const strong_ordering less;
+    static const strong_ordering equal;
+    static const strong_ordering equivalent;
+    static const strong_ordering greater;
+
+    constexpr operator partial_ordering() const noexcept {
+        return _STD _Bit_cast<partial_ordering>(_Value);
+    }
+
+    constexpr operator weak_ordering() const noexcept {
+        return _STD _Bit_cast<weak_ordering>(_Value);
+    }
+
+    _NODISCARD friend constexpr bool operator==(const strong_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value == 0;
+    }
+
+    _NODISCARD friend constexpr bool operator==(strong_ordering, strong_ordering) noexcept = default;
+
+    _NODISCARD friend constexpr bool operator<(const strong_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value < 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>(const strong_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value > 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<=(const strong_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value <= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>=(const strong_ordering _Val, _Literal_zero) noexcept {
+        return _Val._Value >= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<(_Literal_zero, const strong_ordering _Val) noexcept {
+        return _Val > 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>(_Literal_zero, const strong_ordering _Val) noexcept {
+        return _Val < 0;
+    }
+
+    _NODISCARD friend constexpr bool operator<=(_Literal_zero, const strong_ordering _Val) noexcept {
+        return _Val >= 0;
+    }
+
+    _NODISCARD friend constexpr bool operator>=(_Literal_zero, const strong_ordering _Val) noexcept {
+        return _Val <= 0;
+    }
+
+    _NODISCARD friend constexpr strong_ordering operator<=>(const strong_ordering _Val, _Literal_zero) noexcept {
+        return _Val;
+    }
+
+    _NODISCARD friend constexpr strong_ordering operator<=>(_Literal_zero, const strong_ordering _Val) noexcept {
+        return _STD _Bit_cast<strong_ordering>(static_cast<_Compare_t>(-_Val._Value));
+    }
+
+    _Compare_t _Value;
+};
+
+inline constexpr strong_ordering strong_ordering::less{_STD _Bit_cast<strong_ordering>(_Compare_ord::less)};
+inline constexpr strong_ordering strong_ordering::equal{_STD _Bit_cast<strong_ordering>(_Compare_eq::equal)};
+inline constexpr strong_ordering strong_ordering::equivalent{_STD _Bit_cast<strong_ordering>(_Compare_eq::equivalent)};
+inline constexpr strong_ordering strong_ordering::greater{_STD _Bit_cast<strong_ordering>(_Compare_ord::greater)};
+
+_EXPORT_STD _NODISCARD constexpr bool is_eq(const partial_ordering _Comp) noexcept {
+    return _Comp == 0;
+}
+
+_EXPORT_STD _NODISCARD constexpr bool is_neq(const partial_ordering _Comp) noexcept {
+    return _Comp != 0;
+}
+
+_EXPORT_STD _NODISCARD constexpr bool is_lt(const partial_ordering _Comp) noexcept {
+    return _Comp < 0;
+}
+
+_EXPORT_STD _NODISCARD constexpr bool is_lteq(const partial_ordering _Comp) noexcept {
+    return _Comp <= 0;
+}
+
+_EXPORT_STD _NODISCARD constexpr bool is_gt(const partial_ordering _Comp) noexcept {
+    return _Comp > 0;
+}
+
+_EXPORT_STD _NODISCARD constexpr bool is_gteq(const partial_ordering _Comp) noexcept {
+    return _Comp >= 0;
+}
+
+enum _Comparison_category : unsigned char {
+    _Comparison_category_none    = 1,
+    _Comparison_category_partial = 2,
+    _Comparison_category_weak    = 4,
+    _Comparison_category_strong  = 0,
+};
+
+template <class... _Types>
+constexpr unsigned char _Classify_category =
+    _Comparison_category{(_Classify_category<_Types> | ... | _Comparison_category_strong)};
+template <class _Ty>
+constexpr unsigned char _Classify_category<_Ty> = _Comparison_category_none;
+template <>
+inline constexpr unsigned char _Classify_category<partial_ordering> = _Comparison_category_partial;
+template <>
+inline constexpr unsigned char _Classify_category<weak_ordering> = _Comparison_category_weak;
+template <>
+inline constexpr unsigned char _Classify_category<strong_ordering> = _Comparison_category_strong;
+
+_EXPORT_STD template <class... _Types>
+using common_comparison_category_t =
+    conditional_t<((_Classify_category<_Types...> & _Comparison_category_none) != 0), void,
+        conditional_t<((_Classify_category<_Types...> & _Comparison_category_partial) != 0), partial_ordering,
+            conditional_t<((_Classify_category<_Types...> & _Comparison_category_weak) != 0), weak_ordering,
+                strong_ordering>>>;
+
+_EXPORT_STD template <class... _Types>
+struct common_comparison_category {
+    using type = common_comparison_category_t<_Types...>;
+};
+
+template <class _Ty, class _Cat>
+concept _Compares_as = same_as<common_comparison_category_t<_Ty, _Cat>, _Cat>;
+
+_EXPORT_STD template <class _Ty, class _Cat = partial_ordering>
+concept three_way_comparable = _Half_equality_comparable<_Ty, _Ty> && _Half_ordered<_Ty, _Ty>
+                            && requires(const remove_reference_t<_Ty>& __a, const remove_reference_t<_Ty>& __b) {
+                                   { __a <=> __b } -> _Compares_as<_Cat>;
+                               };
+
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Cat = partial_ordering>
+concept three_way_comparable_with =
+    three_way_comparable<_Ty1, _Cat> && three_way_comparable<_Ty2, _Cat> && _Comparison_common_type_with<_Ty1, _Ty2>
+    && three_way_comparable<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>, _Cat>
+    && _Weakly_equality_comparable_with<_Ty1, _Ty2> && _Partially_ordered_with<_Ty1, _Ty2>
+    && requires(const remove_reference_t<_Ty1>& __t, const remove_reference_t<_Ty2>& __u) {
+           { __t <=> __u } -> _Compares_as<_Cat>;
+           { __u <=> __t } -> _Compares_as<_Cat>;
+       };
+
+_EXPORT_STD template <class _Ty1, class _Ty2 = _Ty1>
+using compare_three_way_result_t =
+    decltype(_STD declval<const remove_reference_t<_Ty1>&>() <=> _STD declval<const remove_reference_t<_Ty2>&>());
+
+_EXPORT_STD template <class _Ty1, class _Ty2 = _Ty1>
+struct _NO_SPECIALIZATIONS_CITING("N5014 [cmp.result]/1") compare_three_way_result {};
+
+template <class _Ty1, class _Ty2>
+    requires requires { typename compare_three_way_result_t<_Ty1, _Ty2>; }
+struct compare_three_way_result<_Ty1, _Ty2> {
+    using type = compare_three_way_result_t<_Ty1, _Ty2>;
+};
+
+_EXPORT_STD struct compare_three_way {
+    template <class _Ty1, class _Ty2>
+        requires three_way_comparable_with<_Ty1, _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(_STD forward<_Ty1>(_Left) <=> _STD forward<_Ty2>(_Right))) /* strengthened */ {
+        return _STD forward<_Ty1>(_Left) <=> _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+struct _Synth_three_way {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD static constexpr auto operator()(const _Ty1& _Left, const _Ty2& _Right)
+        requires requires {
+            { _Left < _Right } -> _Boolean_testable;
+            { _Right < _Left } -> _Boolean_testable;
+        }
+    {
+        if constexpr (three_way_comparable_with<_Ty1, _Ty2>) {
+            return _Left <=> _Right;
+        } else {
+            if (_Left < _Right) {
+                return weak_ordering::less;
+            } else if (_Right < _Left) {
+                return weak_ordering::greater;
+            } else {
+                return weak_ordering::equivalent;
+            }
+        }
+    }
+};
+
+template <class _Ty1, class _Ty2 = _Ty1>
+using _Synth_three_way_result = decltype(_Synth_three_way{}(_STD declval<_Ty1&>(), _STD declval<_Ty2&>()));
+
+// Note: The following CPOs are passing arguments as lvalues; see GH-1374.
+
+namespace _Strong_order {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+    void strong_order() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+    void strong_order();
+#endif // ^^^ workaround ^^^
+
+    template <class _Ty1, class _Ty2>
+    concept _Has_ADL = requires(_Ty1& _Left, _Ty2& _Right) {
+        static_cast<strong_ordering>(strong_order(_Left, _Right)); // intentional ADL
+    };
+
+    template <class _Ty1, class _Ty2>
+    concept _Can_compare_three_way =
+        requires(_Ty1& _Left, _Ty2& _Right) { static_cast<strong_ordering>(compare_three_way{}(_Left, _Right)); };
+
+    class _Cpo {
+    private:
+        enum class _St { _None, _Adl, _Floating, _Three };
+
+        template <class _Ty1, class _Ty2>
+        _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
+                return {_St::_None};
+            } else if constexpr (_Has_ADL<_Ty1, _Ty2>) {
+                return {_St::_Adl, noexcept(static_cast<strong_ordering>(
+                                       strong_order(_STD declval<_Ty1&>(), _STD declval<_Ty2&>())))}; // intentional ADL
+            } else if constexpr (floating_point<decay_t<_Ty1>>) {
+                return {_St::_Floating, true};
+            } else if constexpr (_Can_compare_three_way<_Ty1, _Ty2>) {
+                return {_St::_Three, noexcept(static_cast<strong_ordering>(
+                                         compare_three_way{}(_STD declval<_Ty1&>(), _STD declval<_Ty2&>())))};
+            } else {
+                return {_St::_None};
+            }
+        }
+
+        template <class _Ty1, class _Ty2>
+        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();
+
+    public:
+        template <class _Ty1, class _Ty2>
+            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
+        _NODISCARD static constexpr strong_ordering operator()(_Ty1&& _Left, _Ty2&& _Right)
+            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
+            if constexpr (_Strat == _St::_Adl) {
+                return static_cast<strong_ordering>(strong_order(_Left, _Right)); // intentional ADL
+            } else if constexpr (_Strat == _St::_Floating) {
+                using _Floating_type = decay_t<_Ty1>;
+                using _Traits        = _Floating_type_traits<_Floating_type>;
+                using _Uint_type     = _Traits::_Uint_type;
+                using _Sint_type     = make_signed_t<_Uint_type>;
+
+                const auto _Left_uint  = _Bit_cast<_Uint_type>(_Left);
+                const auto _Right_uint = _Bit_cast<_Uint_type>(_Right);
+
+                // 1. Ultra-fast path: equal representations are equal.
+                if (_Left_uint == _Right_uint) {
+                    return strong_ordering::equal;
+                }
+
+                // 2. Examine the sign bits.
+                const _Uint_type _Left_shifted_sign  = _Left_uint & _Traits::_Shifted_sign_mask;
+                const _Uint_type _Right_shifted_sign = _Right_uint & _Traits::_Shifted_sign_mask;
+
+                // 3. Interpret floating-point bit patterns as sign magnitude representations of integers,
+                //    and then transform them into ones' complement representation.
+                // (Ones' complement representations of positive zero and negative zero are different.)
+                const _Uint_type _Left_sign  = _Left_shifted_sign >> _Traits::_Sign_shift;
+                const _Uint_type _Right_sign = _Right_shifted_sign >> _Traits::_Sign_shift;
+
+                const _Uint_type _Left_xor  = _Left_shifted_sign - _Left_sign;
+                const _Uint_type _Right_xor = _Right_shifted_sign - _Right_sign;
+
+                const _Uint_type _Left_ones_complement_uint  = _Left_uint ^ _Left_xor;
+                const _Uint_type _Right_ones_complement_uint = _Right_uint ^ _Right_xor;
+
+                const auto _Left_ones_complement  = static_cast<_Sint_type>(_Left_ones_complement_uint);
+                const auto _Right_ones_complement = static_cast<_Sint_type>(_Right_ones_complement_uint);
+
+                // 4. Perform the final comparison.
+                return _Left_ones_complement <=> _Right_ones_complement;
+            } else if constexpr (_Strat == _St::_Three) {
+                return static_cast<strong_ordering>(compare_three_way{}(_Left, _Right));
+            } else {
+                static_assert(false); // unexpected strategy
+            }
+        }
+    };
+} // namespace _Strong_order
+
+inline namespace _Cpos {
+    _EXPORT_STD inline constexpr _Strong_order::_Cpo strong_order;
+}
+
+namespace _Weak_order {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+    void weak_order() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+    void weak_order();
+#endif // ^^^ workaround ^^^
+
+    template <class _Ty1, class _Ty2>
+    concept _Has_ADL = requires(_Ty1& _Left, _Ty2& _Right) {
+        static_cast<weak_ordering>(weak_order(_Left, _Right)); // intentional ADL
+    };
+
+    template <class _Ty1, class _Ty2>
+    concept _Can_compare_three_way =
+        requires(_Ty1& _Left, _Ty2& _Right) { static_cast<weak_ordering>(compare_three_way{}(_Left, _Right)); };
+
+    // Throughput optimization: attempting to use _STD strong_order will always select ADL strong_order here.
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+    void strong_order() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+    void strong_order();
+#endif // ^^^ workaround ^^^
+
+    class _Cpo {
+    private:
+        enum class _St { _None, _Adl, _Floating, _Three, _Strong };
+
+        template <class _Ty1, class _Ty2>
+        _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
+                return {_St::_None};
+            } else if constexpr (_Has_ADL<_Ty1, _Ty2>) {
+                return {_St::_Adl, noexcept(static_cast<weak_ordering>(
+                                       weak_order(_STD declval<_Ty1&>(), _STD declval<_Ty2&>())))}; // intentional ADL
+            } else if constexpr (floating_point<decay_t<_Ty1>>) {
+                return {_St::_Floating, true};
+            } else if constexpr (_Can_compare_three_way<_Ty1, _Ty2>) {
+                return {_St::_Three, noexcept(static_cast<weak_ordering>(
+                                         compare_three_way{}(_STD declval<_Ty1&>(), _STD declval<_Ty2&>())))};
+            } else if constexpr (_Strong_order::_Has_ADL<_Ty1, _Ty2>) {
+                // throughput optimization (see above):
+                return {_St::_Strong, noexcept(static_cast<weak_ordering>(static_cast<strong_ordering>(strong_order(
+                                          _STD declval<_Ty1&>(), _STD declval<_Ty2&>()))))}; // intentional ADL
+            } else {
+                return {_St::_None};
+            }
+        }
+
+        template <class _Ty1, class _Ty2>
+        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();
+
+    public:
+        template <class _Ty1, class _Ty2>
+            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
+        _NODISCARD static constexpr weak_ordering operator()(_Ty1&& _Left, _Ty2&& _Right)
+            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
+            if constexpr (_Strat == _St::_Adl) {
+                return static_cast<weak_ordering>(weak_order(_Left, _Right)); // intentional ADL
+            } else if constexpr (_Strat == _St::_Floating) {
+                using _Floating_type = decay_t<_Ty1>;
+                using _Traits        = _Floating_type_traits<_Floating_type>;
+                using _Uint_type     = _Traits::_Uint_type;
+                using _Sint_type     = make_signed_t<_Uint_type>;
+
+                auto _Left_uint  = _Bit_cast<_Uint_type>(_Left);
+                auto _Right_uint = _Bit_cast<_Uint_type>(_Right);
+
+                // 1. Ultra-fast path: equal representations are equivalent.
+                if (_Left_uint == _Right_uint) {
+                    return weak_ordering::equivalent;
+                }
+
+                // 2. Examine the sign bits.
+                const _Uint_type _Left_shifted_sign  = _Left_uint & _Traits::_Shifted_sign_mask;
+                const _Uint_type _Right_shifted_sign = _Right_uint & _Traits::_Shifted_sign_mask;
+
+                // 3. Fold all NaN values together.
+                // (The fact that _Infinity_plus_one represents a signaling NaN is irrelevant here.)
+                constexpr _Uint_type _Infinity_plus_one = _Traits::_Shifted_exponent_mask + 1;
+
+                const _Uint_type _Left_magnitude  = _Left_uint & ~_Traits::_Shifted_sign_mask;
+                const _Uint_type _Right_magnitude = _Right_uint & ~_Traits::_Shifted_sign_mask;
+
+                if (_Left_magnitude > _Infinity_plus_one) {
+                    _Left_uint = _Left_shifted_sign | _Infinity_plus_one;
+                }
+
+                if (_Right_magnitude > _Infinity_plus_one) {
+                    _Right_uint = _Right_shifted_sign | _Infinity_plus_one;
+                }
+
+                // 4. Interpret floating-point bit patterns as sign magnitude representations of integers,
+                //    and then transform them into two's complement representation.
+                // (Two's complement representations of positive zero and negative zero are the same.)
+                const _Uint_type _Left_sign  = _Left_shifted_sign >> _Traits::_Sign_shift;
+                const _Uint_type _Right_sign = _Right_shifted_sign >> _Traits::_Sign_shift;
+
+                const _Uint_type _Left_xor  = _Left_shifted_sign - _Left_sign;
+                const _Uint_type _Right_xor = _Right_shifted_sign - _Right_sign;
+
+                const _Uint_type _Left_twos_complement_uint  = (_Left_uint ^ _Left_xor) + _Left_sign;
+                const _Uint_type _Right_twos_complement_uint = (_Right_uint ^ _Right_xor) + _Right_sign;
+
+                const auto _Left_twos_complement  = static_cast<_Sint_type>(_Left_twos_complement_uint);
+                const auto _Right_twos_complement = static_cast<_Sint_type>(_Right_twos_complement_uint);
+
+                // 5. Perform the final comparison.
+                return static_cast<weak_ordering>(_Left_twos_complement <=> _Right_twos_complement);
+            } else if constexpr (_Strat == _St::_Three) {
+                return static_cast<weak_ordering>(compare_three_way{}(_Left, _Right));
+            } else if constexpr (_Strat == _St::_Strong) {
+                // throughput optimization (see above):
+                return static_cast<weak_ordering>(
+                    static_cast<strong_ordering>(strong_order(_Left, _Right))); // intentional ADL
+            } else {
+                static_assert(false); // unexpected strategy
+            }
+        }
+    };
+} // namespace _Weak_order
+
+inline namespace _Cpos {
+    _EXPORT_STD inline constexpr _Weak_order::_Cpo weak_order;
+}
+
+namespace _Partial_order {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+    void partial_order() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+    void partial_order();
+#endif // ^^^ workaround ^^^
+
+    template <class _Ty1, class _Ty2>
+    concept _Has_ADL = requires(_Ty1& _Left, _Ty2& _Right) {
+        static_cast<partial_ordering>(partial_order(_Left, _Right)); // intentional ADL
+    };
+
+    template <class _Ty1, class _Ty2>
+    concept _Can_compare_three_way =
+        requires(_Ty1& _Left, _Ty2& _Right) { static_cast<partial_ordering>(compare_three_way{}(_Left, _Right)); };
+
+    // Throughput optimization: attempting to use _STD weak_order
+    // will attempt to select ADL weak_order, followed by ADL strong_order, here.
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+    void weak_order()   = delete; // Block unqualified name lookup
+    void strong_order() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+    void weak_order();
+    void strong_order();
+#endif // ^^^ workaround ^^^
+
+    class _Cpo {
+    private:
+        enum class _St { _None, _Adl, _Three, _Weak, _Strong };
+
+        template <class _Ty1, class _Ty2>
+        _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
+                return {_St::_None};
+            } else if constexpr (_Has_ADL<_Ty1, _Ty2>) {
+                return {_St::_Adl, noexcept(static_cast<partial_ordering>(partial_order(
+                                       _STD declval<_Ty1&>(), _STD declval<_Ty2&>())))}; // intentional ADL
+            } else if constexpr (_Can_compare_three_way<_Ty1, _Ty2>) {
+                return {_St::_Three, noexcept(static_cast<partial_ordering>(
+                                         compare_three_way{}(_STD declval<_Ty1&>(), _STD declval<_Ty2&>())))};
+            } else if constexpr (_Weak_order::_Has_ADL<_Ty1, _Ty2>) {
+                // throughput optimization (see above):
+                return {_St::_Weak, noexcept(static_cast<partial_ordering>(static_cast<weak_ordering>(
+                                        weak_order(_STD declval<_Ty1&>(), _STD declval<_Ty2&>()))))}; // intentional ADL
+            } else if constexpr (_Strong_order::_Has_ADL<_Ty1, _Ty2>) {
+                // throughput optimization (see above):
+                return {_St::_Strong, noexcept(static_cast<partial_ordering>(static_cast<strong_ordering>(strong_order(
+                                          _STD declval<_Ty1&>(), _STD declval<_Ty2&>()))))}; // intentional ADL
+            } else {
+                return {_St::_None};
+            }
+        }
+
+        template <class _Ty1, class _Ty2>
+        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();
+
+    public:
+        template <class _Ty1, class _Ty2>
+            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
+        _NODISCARD static constexpr partial_ordering operator()(_Ty1&& _Left, _Ty2&& _Right)
+            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
+            if constexpr (_Strat == _St::_Adl) {
+                return static_cast<partial_ordering>(/* ADL */ partial_order(_Left, _Right));
+            } else if constexpr (_Strat == _St::_Three) {
+                return static_cast<partial_ordering>(compare_three_way{}(_Left, _Right));
+            } else if constexpr (_Strat == _St::_Weak) {
+                // throughput optimization (see above):
+                return static_cast<partial_ordering>(
+                    static_cast<weak_ordering>(weak_order(_Left, _Right))); // intentional ADL
+            } else if constexpr (_Strat == _St::_Strong) {
+                // throughput optimization (see above):
+                return static_cast<partial_ordering>(
+                    static_cast<strong_ordering>(strong_order(_Left, _Right))); // intentional ADL
+            } else {
+                static_assert(false); // unexpected strategy
+            }
+        }
+    };
+} // namespace _Partial_order
+
+inline namespace _Cpos {
+    _EXPORT_STD inline constexpr _Partial_order::_Cpo partial_order;
+}
+
+template <class _Ty1, class _Ty2>
+concept _Can_fallback_eq_lt = requires(_Ty1& _Left, _Ty2& _Right) {
+    { _Left == _Right } -> _Boolean_testable;
+    { _Left < _Right } -> _Boolean_testable;
+};
+
+template <class _Ty1, class _Ty2>
+concept _Can_strong_order = requires(_Ty1& _Left, _Ty2& _Right) { _STD strong_order(_Left, _Right); };
+
+namespace _Compare_strong_order_fallback {
+    class _Cpo {
+    private:
+        enum class _St { _None, _Strong, _Fallback };
+
+        template <class _Ty1, class _Ty2>
+        _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
+                return {_St::_None};
+            } else if constexpr (_Can_strong_order<_Ty1, _Ty2>) {
+                return {_St::_Strong, noexcept(_STD strong_order(_STD declval<_Ty1&>(), _STD declval<_Ty2&>()))};
+            } else if constexpr (_Can_fallback_eq_lt<_Ty1, _Ty2>) {
+                return {_St::_Fallback,
+                    noexcept(_STD declval<_Ty1&>() == _STD declval<_Ty2&>()  ? strong_ordering::equal
+                             : _STD declval<_Ty1&>() < _STD declval<_Ty2&>() ? strong_ordering::less
+                                                                             : strong_ordering::greater)};
+            } else {
+                return {_St::_None};
+            }
+        }
+
+        template <class _Ty1, class _Ty2>
+        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();
+
+    public:
+        template <class _Ty1, class _Ty2>
+            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
+        _NODISCARD static constexpr strong_ordering operator()(_Ty1&& _Left, _Ty2&& _Right)
+            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
+            if constexpr (_Strat == _St::_Strong) {
+                return _STD strong_order(_Left, _Right);
+            } else if constexpr (_Strat == _St::_Fallback) {
+                return _Left == _Right ? strong_ordering::equal
+                     : _Left < _Right  ? strong_ordering::less
+                                       : strong_ordering::greater;
+            } else {
+                static_assert(false); // unexpected strategy
+            }
+        }
+    };
+} // namespace _Compare_strong_order_fallback
+
+inline namespace _Cpos {
+    _EXPORT_STD inline constexpr _Compare_strong_order_fallback::_Cpo compare_strong_order_fallback;
+}
+
+template <class _Ty1, class _Ty2>
+concept _Can_weak_order = requires(_Ty1& _Left, _Ty2& _Right) { _STD weak_order(_Left, _Right); };
+
+namespace _Compare_weak_order_fallback {
+    class _Cpo {
+    private:
+        enum class _St { _None, _Weak, _Fallback };
+
+        template <class _Ty1, class _Ty2>
+        _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
+                return {_St::_None};
+            } else if constexpr (_Can_weak_order<_Ty1, _Ty2>) {
+                return {_St::_Weak, noexcept(_STD weak_order(_STD declval<_Ty1&>(), _STD declval<_Ty2&>()))};
+            } else if constexpr (_Can_fallback_eq_lt<_Ty1, _Ty2>) {
+                return {
+                    _St::_Fallback, noexcept(_STD declval<_Ty1&>() == _STD declval<_Ty2&>()  ? weak_ordering::equivalent
+                                             : _STD declval<_Ty1&>() < _STD declval<_Ty2&>() ? weak_ordering::less
+                                                                                             : weak_ordering::greater)};
+            } else {
+                return {_St::_None};
+            }
+        }
+
+        template <class _Ty1, class _Ty2>
+        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();
+
+    public:
+        template <class _Ty1, class _Ty2>
+            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
+        _NODISCARD static constexpr weak_ordering operator()(_Ty1&& _Left, _Ty2&& _Right)
+            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
+            if constexpr (_Strat == _St::_Weak) {
+                return _STD weak_order(_Left, _Right);
+            } else if constexpr (_Strat == _St::_Fallback) {
+                return _Left == _Right ? weak_ordering::equivalent
+                     : _Left < _Right  ? weak_ordering::less
+                                       : weak_ordering::greater;
+            } else {
+                static_assert(false); // unexpected strategy
+            }
+        }
+    };
+} // namespace _Compare_weak_order_fallback
+
+inline namespace _Cpos {
+    _EXPORT_STD inline constexpr _Compare_weak_order_fallback::_Cpo compare_weak_order_fallback;
+}
+
+template <class _Ty1, class _Ty2>
+concept _Can_partial_order = requires(_Ty1& _Left, _Ty2& _Right) { _STD partial_order(_Left, _Right); };
+
+namespace _Compare_partial_order_fallback {
+    template <class _Ty1, class _Ty2>
+    concept _Can_fallback_eq_lt_twice = requires(_Ty1& _Left, _Ty2& _Right) {
+        { _Left == _Right } -> _Boolean_testable;
+        { _Left < _Right } -> _Boolean_testable;
+        { _Right < _Left } -> _Boolean_testable;
+    };
+
+    class _Cpo {
+    private:
+        enum class _St { _None, _Partial, _Fallback };
+
+        template <class _Ty1, class _Ty2>
+        _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
+                return {_St::_None};
+            } else if constexpr (_Can_partial_order<_Ty1, _Ty2>) {
+                return {_St::_Partial, noexcept(_STD partial_order(_STD declval<_Ty1&>(), _STD declval<_Ty2&>()))};
+            } else if constexpr (_Can_fallback_eq_lt_twice<_Ty1, _Ty2>) {
+                return {_St::_Fallback,
+                    noexcept(_STD declval<_Ty1&>() == _STD declval<_Ty2&>()  ? partial_ordering::equivalent
+                             : _STD declval<_Ty1&>() < _STD declval<_Ty2&>() ? partial_ordering::less
+                             : _STD declval<_Ty2&>() < _STD declval<_Ty1&>() ? partial_ordering::greater
+                                                                             : partial_ordering::unordered)};
+            } else {
+                return {_St::_None};
+            }
+        }
+
+        template <class _Ty1, class _Ty2>
+        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();
+
+    public:
+        template <class _Ty1, class _Ty2>
+            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
+        _NODISCARD static constexpr partial_ordering operator()(_Ty1&& _Left, _Ty2&& _Right)
+            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
+            if constexpr (_Strat == _St::_Partial) {
+                return _STD partial_order(_Left, _Right);
+            } else if constexpr (_Strat == _St::_Fallback) {
+                return _Left == _Right ? partial_ordering::equivalent
+                     : _Left < _Right  ? partial_ordering::less
+                     : _Right < _Left  ? partial_ordering::greater
+                                       : partial_ordering::unordered;
+            } else {
+                static_assert(false); // unexpected strategy
+            }
+        }
+    };
+} // namespace _Compare_partial_order_fallback
+
+inline namespace _Cpos {
+    _EXPORT_STD inline constexpr _Compare_partial_order_fallback::_Cpo compare_partial_order_fallback;
+}
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _HAS_CXX20
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _COMPARE_
diff --git a/msvc-stl/stl/inc/complex b/msvc-stl/stl/inc/complex
new file mode 100644
index 0000000..3a1958f
--- /dev/null
+++ b/msvc-stl/stl/inc/complex
@@ -0,0 +1,2332 @@
+// complex standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _COMPLEX_
+#define _COMPLEX_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <sstream>
+#include <type_traits>
+#include <xutility>
+#include <ymath.h>
+
+#ifdef _M_CEE_PURE
+// no intrinsics for /clr:pure
+#elif defined(_M_ARM64) || defined(_M_ARM64EC)
+// https://learn.microsoft.com/cpp/build/arm64-windows-abi-conventions#base-requirements
+// Both floating-point and NEON support are presumed to be present in hardware.
+#define _FMP_USING_STD_FMA
+#elif defined(_M_IX86) || defined(_M_X64)
+#define _FMP_USING_X86_X64_INTRINSICS
+#include <__msvc_bit_utils.hpp>
+#include <intrin.h>
+#endif // ^^^ defined(_M_IX86) || defined(_M_X64) ^^^
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#ifndef _C_COMPLEX_T
+#define _C_COMPLEX_T // Also defined by UCRT <complex.h>
+
+extern "C" {
+struct _C_double_complex {
+    double _Val[2];
+};
+
+struct _C_float_complex {
+    float _Val[2];
+};
+
+struct _C_ldouble_complex {
+    long double _Val[2];
+};
+} // extern "C"
+#endif // _C_COMPLEX_T
+
+// complex _Val offsets
+#define _RE 0
+#define _IM 1
+
+_STD_BEGIN
+// TRANSITION, workaround x86 ABI
+// On x86 ABI, floating-point by-value arguments and return values are passed in 80-bit x87 registers.
+// When the value is a 32-bit or 64-bit signaling NaN, the conversion to/from 80-bit raises FE_INVALID
+// and turns it into a quiet NaN. This behavior is undesirable if we want to test for signaling NaNs.
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr bool _Is_signaling_nan(const _Ty& _Xx) noexcept { // returns true if input is a signaling NaN
+    using _Traits        = _Floating_type_traits<_Ty>;
+    const auto _Abs_bits = _Float_abs_bits(_Xx);
+    return _Abs_bits > _Traits::_Shifted_exponent_mask && ((_Abs_bits & _Traits::_Special_nan_mantissa_mask) == 0);
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr bool _Is_inf(const _Ty _Xx) noexcept { // constexpr isinf()
+    using _Traits = _Floating_type_traits<_Ty>;
+    return _Float_abs_bits(_Xx) == _Traits::_Shifted_exponent_mask;
+}
+
+// implements multi-precision floating-point arithmetic for numerical algorithms
+#pragma float_control(precise, on, push)
+namespace _Float_multi_prec {
+    // multi-precision floating-point types
+    template <class _Ty, int _Prec>
+    struct _Fmp_t;
+
+    template <class _Ty>
+    struct _Fmp_t<_Ty, 2> {
+        static_assert(is_floating_point_v<_Ty>, "_Ty must be floating-point");
+        _Ty _Val0; // most significant numeric_limits<_Ty>::precision bits
+        _Ty _Val1; // least significant numeric_limits<_Ty>::precision bits
+    };
+
+    // addition
+
+    // 1x precision + 1x precision -> 2x precision
+    // the result is exact when:
+    // 1) no internal overflow occurs
+    // 2) either underflow is gradual, or no internal underflow occurs
+    // 3) intermediate precision is either the same as _Ty, or greater than twice the precision of _Ty
+    // 4) parameters and local variables do not retain extra intermediate precision
+    // 5) rounding mode is rounding to nearest
+    // violation of condition 3 or 5 could lead to relative error on the order of epsilon^2
+    // violation of other conditions could lead to worse results
+    template <class _Ty>
+    _NODISCARD constexpr _Fmp_t<_Ty, 2> _Add_x2(const _Ty _Xval, const _Ty _Yval) noexcept {
+        const _Ty _Sum0 = _Xval + _Yval;
+        const _Ty _Ymod = _Sum0 - _Xval;
+        const _Ty _Xmod = _Sum0 - _Ymod;
+        const _Ty _Yerr = _Yval - _Ymod;
+        const _Ty _Xerr = _Xval - _Xmod;
+        return {_Sum0, _Xerr + _Yerr};
+    }
+
+    // 1x precision + 1x precision -> 2x precision
+    // requires: exponent(_Xval) + countr_zero(significand(_Xval)) >= exponent(_Yval) || _Xval == 0
+    // the result is exact when:
+    // 0) the requirement above is satisfied
+    // 1) the result doesn't overflow
+    // 2) either underflow is gradual, or no internal underflow occurs
+    // 3) intermediate precision is either the same as _Ty, or greater than twice the precision of _Ty
+    // 4) parameters and local variables do not retain extra intermediate precision
+    // 5) rounding mode is rounding to nearest
+    // violation of condition 3 or 5 could lead to relative error on the order of epsilon^2
+    // violation of other conditions could lead to worse results
+    template <class _Ty>
+    _NODISCARD constexpr _Fmp_t<_Ty, 2> _Add_small_x2(const _Ty _Xval, const _Ty _Yval) noexcept {
+        const _Ty _Sum0 = _Xval + _Yval;
+        const _Ty _Ymod = _Sum0 - _Xval;
+        const _Ty _Yerr = _Yval - _Ymod;
+        return {_Sum0, _Yerr};
+    }
+
+    // 1x precision + 2x precision -> 2x precision
+    // requires: exponent(_Xval) + countr_zero(significand(_Xval)) >= exponent(_Yval._Val0) || _Xval == 0
+    template <class _Ty>
+    _NODISCARD constexpr _Fmp_t<_Ty, 2> _Add_small_x2(const _Ty _Xval, const _Fmp_t<_Ty, 2>& _Yval) noexcept {
+        const _Fmp_t<_Ty, 2> _Sum0 = _Add_small_x2(_Xval, _Yval._Val0);
+        return _Add_small_x2(_Sum0._Val0, _Sum0._Val1 + _Yval._Val1);
+    }
+
+    // 2x precision + 2x precision -> 1x precision
+    template <class _Ty>
+    _NODISCARD constexpr _Ty _Add_x1(const _Fmp_t<_Ty, 2>& _Xval, const _Fmp_t<_Ty, 2>& _Yval) noexcept {
+        const _Fmp_t<_Ty, 2> _Sum00 = _Add_x2(_Xval._Val0, _Yval._Val0);
+        return _Sum00._Val0 + (_Sum00._Val1 + (_Xval._Val1 + _Yval._Val1));
+    }
+
+    // multiplication
+
+    // round to 26 significant bits, ties toward zero
+    _NODISCARD constexpr double _High_half(const double _Val) noexcept {
+        const auto _Bits           = _Bit_cast<unsigned long long>(_Val);
+        const auto _High_half_bits = (_Bits + 0x3ff'ffffULL) & 0xffff'ffff'f800'0000ULL;
+        return _Bit_cast<double>(_High_half_bits);
+    }
+
+    // _Xval * _Xval - _Prod0
+    // the result is exact when:
+    // 1) _Prod0 is _Xval^2 faithfully rounded
+    // 2) no internal overflow or underflow occurs
+    // violation of condition 1 could lead to relative error on the order of epsilon
+    _NODISCARD constexpr double _Sqr_error_fallback(const double _Xval, const double _Prod0) noexcept {
+        const double _Xhigh = _High_half(_Xval);
+        const double _Xlow  = _Xval - _Xhigh;
+        return ((_Xhigh * _Xhigh - _Prod0) + 2.0 * _Xhigh * _Xlow) + _Xlow * _Xlow;
+    }
+
+#ifdef _FMP_USING_X86_X64_INTRINSICS
+#ifdef __clang__
+    [[__gnu__::__target__("fma")]]
+#endif // defined(__clang__)
+    _NODISCARD inline double _Sqr_error_x86_x64_fma(const double _Xval, const double _Prod0) noexcept {
+        const __m128d _Mx      = _mm_set_sd(_Xval);
+        const __m128d _Mprod0  = _mm_set_sd(_Prod0);
+        const __m128d _Mresult = _mm_fmsub_sd(_Mx, _Mx, _Mprod0);
+        double _Result;
+        _mm_store_sd(&_Result, _Mresult);
+        return _Result;
+    }
+#endif // defined(_FMP_USING_X86_X64_INTRINSICS)
+
+#ifdef _FMP_USING_STD_FMA
+    _NODISCARD inline double _Sqr_error_std_fma(const double _Xval, const double _Prod0) noexcept {
+        return _STD fma(_Xval, _Xval, -_Prod0);
+    }
+#endif // defined(_FMP_USING_STD_FMA)
+
+    // square(1x precision) -> 2x precision
+    // the result is exact when no internal overflow or underflow occurs
+    _NODISCARD inline _Fmp_t<double, 2> _Sqr_x2(const double _Xval) noexcept {
+        const double _Prod0 = _Xval * _Xval;
+
+#if defined(_FMP_USING_X86_X64_INTRINSICS)
+#ifndef __AVX2__
+        const bool _Definitely_have_fma = __isa_available >= _Stl_isa_available_avx2;
+        if (!_Definitely_have_fma) {
+            return {_Prod0, _Sqr_error_fallback(_Xval, _Prod0)};
+        }
+#endif // ^^^ !defined(__AVX2__) ^^^
+        return {_Prod0, _Sqr_error_x86_x64_fma(_Xval, _Prod0)};
+#elif defined(_FMP_USING_STD_FMA)
+        return {_Prod0, _Sqr_error_std_fma(_Xval, _Prod0)};
+#else // ^^^ defined(_FMP_USING_STD_FMA) / not using intrinsics vvv
+        return {_Prod0, _Sqr_error_fallback(_Xval, _Prod0)};
+#endif // ^^^ not using intrinsics ^^^
+    }
+} // namespace _Float_multi_prec
+#pragma float_control(pop)
+
+#undef _FMP_USING_X86_X64_INTRINSICS
+#undef _FMP_USING_STD_FMA
+
+#define _FMP _STD _Float_multi_prec::
+
+// implements numerical algorithms for <complex>
+namespace _Math_algorithms {
+    // TRANSITION: sqrt() isn't constexpr
+    // _Hypot_leg_huge = _Ty{0.5} * _STD sqrt((_STD numeric_limits<_Ty>::max)());
+    // _Hypot_leg_tiny = _STD sqrt(_Ty{2.0} * (_STD numeric_limits<_Ty>::min)() / _STD numeric_limits<_Ty>::epsilon());
+    template <class _Ty>
+    struct _Hypot_leg_huge_helper {
+        static constexpr _Ty value{6.703903964971298e+153};
+    };
+    template <>
+    struct _Hypot_leg_huge_helper<float> {
+        static constexpr float value{9.2233715e+18f};
+    };
+    template <class _Ty>
+    constexpr _Ty _Hypot_leg_huge = _Hypot_leg_huge_helper<_Ty>::value;
+
+    template <class _Ty>
+    struct _Hypot_leg_tiny_helper {
+        static constexpr _Ty value{1.4156865331029228e-146};
+    };
+    template <>
+    struct _Hypot_leg_tiny_helper<float> {
+        static constexpr float value{4.440892e-16f};
+    };
+    template <class _Ty>
+    constexpr _Ty _Hypot_leg_tiny = _Hypot_leg_tiny_helper<_Ty>::value;
+
+    template <class _Ty>
+    _NODISCARD _Ty _Norm_minus_one(const _Ty _Xval, const _Ty _Yval) noexcept {
+        // requires |_Xval| >= |_Yval| and 0.5 <= |_Xval| < 2^12
+        // returns _Xval * _Xval + _Yval * _Yval - 1
+        const _FMP _Fmp_t<_Ty, 2> _Xsqr    = _FMP _Sqr_x2(_Xval);
+        const _FMP _Fmp_t<_Ty, 2> _Ysqr    = _FMP _Sqr_x2(_Yval);
+        const _FMP _Fmp_t<_Ty, 2> _Xsqr_m1 = _FMP _Add_small_x2(_Ty{-1.0}, _Xsqr);
+        return _Add_x1(_Xsqr_m1, _Ysqr);
+    }
+
+    _NODISCARD inline float _Norm_minus_one(const float _Xval, const float _Yval) noexcept {
+        const auto _Dx = static_cast<double>(_Xval);
+        const auto _Dy = static_cast<double>(_Yval);
+        return static_cast<float>((_Dx * _Dx - 1.0) + _Dy * _Dy);
+    }
+
+    // TRANSITION: CRT log1p can be inaccurate for tiny inputs under directed rounding modes
+    template <class _Ty>
+    _NODISCARD _Ty _Logp1(const _Ty _Xval) noexcept { // returns log(1 + _Xval)
+        static_assert(is_floating_point_v<_Ty>, "_Ty must be floating-point");
+
+        if (_Is_nan(_Xval)) { // NaN
+            return _Xval + _Xval; // raise FE_INVALID if _Xval is a signaling NaN
+        }
+
+        if (_Xval <= _Ty{-0.5} || _Ty{2.0} <= _Xval) { // naive formula is moderately accurate
+            if (_Xval == (numeric_limits<_Ty>::max)()) { // avoid overflow
+                return _STD log(_Xval);
+            }
+
+            return _STD log(_Ty{1.0} + _Xval);
+        }
+
+        const _Ty _Xabs = _Float_abs(_Xval);
+        if (_Xabs < numeric_limits<_Ty>::epsilon()) { // zero or tiny
+            if (_Xval == _Ty{0.0}) {
+                return _Xval;
+            }
+
+            // honor rounding mode, raise FE_INEXACT
+            return _Xval - _Ty{0.5} * _Xval * _Xval;
+        }
+
+        // compute log(1 + _Xval) with fixup for small _Xval
+        const _FMP _Fmp_t<_Ty, 2> _Xp1 = _FMP _Add_small_x2(_Ty{1.0}, _Xval);
+        return _STD log(_Xp1._Val0) + _Xp1._Val1 / _Xp1._Val0;
+    }
+
+    template <class _Ty>
+    _NODISCARD _Ty _Log_hypot(const _Ty _Xval, const _Ty _Yval) noexcept { // returns log(hypot(_Xval, _Yval))
+        static_assert(is_floating_point_v<_Ty>, "_Ty must be floating-point");
+
+        if (!_Is_finite(_Xval) || !_Is_finite(_Yval)) { // Inf or NaN
+            // raise FE_INVALID and return NaN if at least one of them is a signaling NaN
+            if (_Is_signaling_nan(_Xval) || _Is_signaling_nan(_Yval)) {
+                return _Xval + _Yval;
+            }
+
+            // return +Inf if at least one of them is an infinity, even when the other is a quiet NaN
+            if (_Is_inf(_Xval)) {
+                return _Float_abs(_Xval);
+            }
+
+            if (_Is_inf(_Yval)) {
+                return _Float_abs(_Yval);
+            }
+
+            // at least one of them is a quiet NaN, and the other is not an infinity
+            return _Xval + _Yval;
+        }
+
+        _Ty _Av = _Float_abs(_Xval);
+        _Ty _Bv = _Float_abs(_Yval);
+
+        if (_Av < _Bv) { // ensure that _Bv <= _Av
+            _STD swap(_Av, _Bv);
+        }
+
+        if (_Bv == 0) {
+            return _STD log(_Av);
+        }
+
+        if (_Hypot_leg_tiny<_Ty> < _Av && _Av < _Hypot_leg_huge<_Ty>) { // no overflow or harmful underflow
+            constexpr _Ty _Norm_small{0.5};
+            constexpr _Ty _Norm_big{3.0};
+
+            const _Ty _Bv_sqr = _Bv * _Bv;
+
+            if (_Av == _Ty{1.0}) { // correctly return +0 when _Av == 1 and _Bv * _Bv underflows
+                                   // _Norm_minus_one(_Av, _Bv) could return -0 under FE_DOWNWARD rounding mode
+                return _Logp1(_Bv_sqr) * _Ty{0.5};
+            }
+
+            const _Ty _Norm = _Av * _Av + _Bv_sqr;
+
+            if (_Norm_small < _Norm && _Norm < _Norm_big) { // avoid catastrophic cancellation
+                return _Logp1(_Norm_minus_one(_Av, _Bv)) * _Ty{0.5};
+            } else {
+                return _STD log(_Norm) * _Ty{0.5};
+            }
+        } else { // use 1 1/2 precision to preserve bits
+            constexpr _Ty _Cm = _Ty{22713.0L / 32768.0L};
+            constexpr _Ty _Cl = _Ty{1.4286068203094172321214581765680755e-6L};
+
+            const int _Exponent      = _STD ilogb(_Av);
+            const _Ty _Av_scaled     = _STD scalbn(_Av, -_Exponent);
+            const _Ty _Bv_scaled     = _STD scalbn(_Bv, -_Exponent);
+            const _Ty _Bv_scaled_sqr = _Bv_scaled * _Bv_scaled;
+            const _Ty _Norm_scaled   = _Av_scaled * _Av_scaled + _Bv_scaled_sqr;
+            const _Ty _Real_shifted  = _STD log(_Norm_scaled) * _Ty{0.5};
+            const auto _Fexponent    = static_cast<_Ty>(_Exponent);
+            return (_Real_shifted + _Fexponent * _Cl) + _Fexponent * _Cm;
+        }
+    }
+} // namespace _Math_algorithms
+
+#undef _FMP
+
+using _Dcomplex_value = _CSTD _C_double_complex;
+using _Fcomplex_value = _CSTD _C_float_complex;
+using _Lcomplex_value = _CSTD _C_ldouble_complex;
+
+_EXPORT_STD template <class _Ty>
+class complex;
+template <>
+class complex<float>;
+template <>
+class complex<double>;
+template <>
+class complex<long double>;
+
+template <class _Ty>
+class _Ctraits {
+public:
+    static constexpr _Ty _Flt_eps() { // get epsilon
+        return numeric_limits<_Ty>::epsilon();
+    }
+
+    static constexpr _Ty _Flt_max() {
+        return (numeric_limits<_Ty>::max)();
+    }
+
+    static constexpr _Ty _Flt_norm_min() {
+        return (numeric_limits<_Ty>::min)() > 0 ? (numeric_limits<_Ty>::min)() : 0;
+    }
+
+    static _Ty _Abs(_Ty _Left) {
+        return static_cast<_Ty>(_Signbit(_Left) ? -_Left : _Left);
+    }
+
+    static _Ty _Cosh(_Ty _Left, _Ty _Right) { // return cosh(_Left) * _Right
+        return static_cast<_Ty>(_CSTD _Cosh(static_cast<double>(_Left), static_cast<double>(_Right)));
+    }
+
+    static _Ty _Copysign(_Ty _Magnitude, _Ty _Sign) {
+        return static_cast<_Ty>(_Signbit(_Sign) ? -_Abs(_Magnitude) : _Abs(_Magnitude));
+    }
+
+    static short _Exp(_Ty* _Pleft, _Ty _Right, short _Exponent) { // compute exp(*_Pleft) * _Right * 2 ^ _Exponent
+        double _Tmp = static_cast<double>(*_Pleft);
+        short _Ans  = _CSTD _Exp(&_Tmp, static_cast<double>(_Right), _Exponent);
+        *_Pleft     = static_cast<_Ty>(_Tmp);
+        return _Ans;
+    }
+
+    static constexpr _Ty _Infv() { // return infinity
+        return numeric_limits<_Ty>::infinity();
+    }
+
+    static bool _Isinf(_Ty _Left) { // test for infinity
+        const auto _Tmp  = static_cast<double>(_Left);
+        const auto _Uint = _Bit_cast<uint64_t>(_Tmp);
+        return (_Uint & 0x7fffffffffffffffU) == 0x7ff0000000000000U;
+    }
+
+    static _CONSTEXPR20 bool _Isnan(_Ty _Left) {
+        const auto _Tmp  = static_cast<double>(_Left);
+        const auto _Uint = _Bit_cast<uint64_t>(_Tmp);
+        return (_Uint & 0x7fffffffffffffffU) > 0x7ff0000000000000U;
+    }
+
+    static constexpr _Ty _Nanv() { // return NaN
+        return numeric_limits<_Ty>::quiet_NaN();
+    }
+
+    static bool _Signbit(_Ty _Left) {
+        return (_STD signbit) (static_cast<double>(_Left));
+    }
+
+    static _Ty _Sinh(_Ty _Left, _Ty _Right) { // return sinh(_Left) * _Right
+        return static_cast<_Ty>(_CSTD _Sinh(static_cast<double>(_Left), static_cast<double>(_Right)));
+    }
+
+    static _Ty asinh(_Ty _Left) {
+        if (_Left == 0 || _Isnan(_Left) || _Isinf(_Left)) {
+            return _Left;
+        }
+
+        constexpr _Ty _Ln2 = 0.69314718055994530941723212145817658L;
+
+        const _Ty _Old_left = _Left;
+        _Ty _Ans;
+
+        _Left = _Abs(_Left);
+
+        if (_Left < 2 / _Flt_eps()) {
+            _Ans = log1p(_Left + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
+        } else {
+            _Ans = log(_Left) + _Ln2;
+        }
+
+        return _Copysign(_Ans, _Old_left);
+    }
+
+    static _Ty atan2(_Ty _Yval, _Ty _Xval) { // return atan(_Yval / _Xval)
+        return static_cast<_Ty>(_CSTD atan2(static_cast<double>(_Yval), static_cast<double>(_Xval)));
+    }
+
+    static _Ty cos(_Ty _Left) {
+        return static_cast<_Ty>(_CSTD cos(static_cast<double>(_Left)));
+    }
+
+    static _Ty exp(_Ty _Left) {
+        return static_cast<_Ty>(_CSTD exp(static_cast<double>(_Left)));
+    }
+
+    static _Ty ldexp(_Ty _Left, int _Exponent) { // return _Left * 2 ^ _Exponent
+        return static_cast<_Ty>(_CSTD ldexp(static_cast<double>(_Left), _Exponent));
+    }
+
+    static _Ty log(_Ty _Left) {
+        return static_cast<_Ty>(_CSTD log(static_cast<double>(_Left)));
+    }
+
+    static _Ty log1p(_Ty _Left) { // return log(1 + _Left)
+        if (_Left < -1) {
+            return _Nanv();
+        } else if (_Left == 0) {
+            return _Left;
+        } else { // compute log(1 + _Left) with fixup for small _Left
+            _Ty _Leftp1 = 1 + _Left;
+            return log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1;
+        }
+    }
+
+    static _Ty pow(_Ty _Left, _Ty _Right) {
+        return static_cast<_Ty>(_CSTD pow(static_cast<double>(_Left), static_cast<double>(_Right)));
+    }
+
+    static _Ty sin(_Ty _Left) {
+        return static_cast<_Ty>(_CSTD sin(static_cast<double>(_Left)));
+    }
+
+    static _Ty sqrt(_Ty _Left) {
+        return static_cast<_Ty>(_CSTD sqrt(static_cast<double>(_Left)));
+    }
+
+    static _Ty tan(_Ty _Left) {
+        return static_cast<_Ty>(_CSTD tan(static_cast<double>(_Left)));
+    }
+
+    static _Ty hypot(_Ty _Left, _Ty _Right) {
+        return static_cast<_Ty>(_CSTD hypot(static_cast<double>(_Left), static_cast<double>(_Right)));
+    }
+};
+
+template <>
+class _Ctraits<long double> {
+public:
+    using _Ty = long double;
+
+    static constexpr _Ty _Flt_eps() noexcept { // get epsilon
+        return numeric_limits<long double>::epsilon();
+    }
+
+    static constexpr _Ty _Flt_max() noexcept {
+        return (numeric_limits<long double>::max)();
+    }
+
+    static constexpr _Ty _Flt_norm_min() noexcept {
+        return (numeric_limits<long double>::min)();
+    }
+
+    static _Ty _Abs(_Ty _Left) noexcept {
+        // testing _Left < 0 would be incorrect when _Left is -0.0
+        return _CSTD fabsl(_Left);
+    }
+
+    static _Ty _Cosh(_Ty _Left, _Ty _Right) noexcept { // return cosh(_Left) * _Right
+        return _CSTD _LCosh(_Left, _Right);
+    }
+
+    static _Ty _Copysign(_Ty _Magnitude, _Ty _Sign) noexcept {
+        // testing _Sign < 0 would be incorrect when _Sign is -0.0
+        return _CSTD copysignl(_Magnitude, _Sign);
+    }
+
+    static short _Exp(_Ty* _Pleft, _Ty _Right, short _Exponent) noexcept {
+        // compute exp(*_Pleft) * _Right * 2 ^ _Exponent
+        return _CSTD _LExp(_Pleft, _Right, _Exponent);
+    }
+
+    static constexpr _Ty _Infv() noexcept { // return infinity
+        return numeric_limits<long double>::infinity();
+    }
+
+    static bool _Isinf(_Ty _Left) noexcept { // test for infinity
+#if defined(__LDBL_DIG__) && __LDBL_DIG__ == 18
+        return _CSTD _LDtest(&_Left) == FP_INFINITE;
+#else // ^^^ 80-bit long double (not supported by MSVC in general, see GH-1316) / 64-bit long double vvv
+        const auto _Uint = _Bit_cast<uint64_t>(_Left);
+        return (_Uint & 0x7fffffffffffffffU) == 0x7ff0000000000000U;
+#endif // ^^^ 64-bit long double ^^^
+    }
+
+    static _CONSTEXPR20 bool _Isnan(_Ty _Left) noexcept {
+#if defined(__LDBL_DIG__) && __LDBL_DIG__ == 18
+        return _CSTD _LDtest(&_Left) == FP_NAN;
+#else // ^^^ 80-bit long double (not supported by MSVC in general, see GH-1316) / 64-bit long double vvv
+        const auto _Uint = _Bit_cast<uint64_t>(_Left);
+        return (_Uint & 0x7fffffffffffffffU) > 0x7ff0000000000000U;
+#endif // ^^^ 64-bit long double ^^^
+    }
+
+    static constexpr _Ty _Nanv() noexcept { // return NaN
+        return numeric_limits<long double>::quiet_NaN();
+    }
+
+    static bool _Signbit(_Ty _Left) noexcept {
+        // testing _Left < 0 would be incorrect when _Left is -0.0
+        return (_STD signbit) (_Left);
+    }
+
+    static _Ty _Sinh(_Ty _Left, _Ty _Right) noexcept { // return sinh(_Left) * _Right
+        return _CSTD _LSinh(_Left, _Right);
+    }
+
+    static _Ty asinh(_Ty _Left) noexcept {
+        if (_Left == 0 || _Isnan(_Left) || _Isinf(_Left)) {
+            return _Left;
+        }
+
+        constexpr _Ty _Ln2 = 0.69314718055994530941723212145817658L;
+
+        const _Ty _Old_left = _Left;
+        _Ty _Ans;
+
+        _Left = _Abs(_Left);
+
+        if (_Left < 2 / _Flt_eps()) {
+            _Ans = log1p(_Left + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
+        } else {
+            _Ans = log(_Left) + _Ln2;
+        }
+
+        return _Copysign(_Ans, _Old_left);
+    }
+
+    static _Ty atan2(_Ty _Yval, _Ty _Xval) noexcept { // return atan(_Yval / _Xval)
+        return _CSTD atan2l(_Yval, _Xval);
+    }
+
+    static _Ty cos(_Ty _Left) noexcept {
+        return _CSTD cosl(_Left);
+    }
+
+    static _Ty exp(_Ty _Left) noexcept {
+        return _CSTD expl(_Left);
+    }
+
+    static _Ty ldexp(_Ty _Left, int _Exponent) noexcept { // return _Left * 2 ^ _Exponent
+        return _CSTD ldexpl(_Left, _Exponent);
+    }
+
+    static _Ty log(_Ty _Left) noexcept {
+        return _CSTD logl(_Left);
+    }
+
+    static _Ty log1p(_Ty _Left) noexcept { // return log(1 + _Left)
+        if (_Left < -1) {
+            return _Nanv();
+        } else if (_Left == 0) {
+            return _Left;
+        } else { // compute log(1 + _Left) with fixup for small _Left
+            _Ty _Leftp1 = 1 + _Left;
+            return log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1;
+        }
+    }
+
+    static _Ty pow(_Ty _Left, _Ty _Right) noexcept {
+        return _CSTD powl(_Left, _Right);
+    }
+
+    static _Ty sin(_Ty _Left) noexcept {
+        return _CSTD sinl(_Left);
+    }
+
+    static _Ty sqrt(_Ty _Left) noexcept {
+        return _CSTD sqrtl(_Left);
+    }
+
+    static _Ty tan(_Ty _Left) noexcept {
+        return _CSTD tanl(_Left);
+    }
+
+    static _Ty hypot(_Ty _Left, _Ty _Right) noexcept {
+        return _CSTD hypotl(_Left, _Right);
+    }
+};
+
+template <>
+class _Ctraits<double> {
+public:
+    using _Ty = double;
+
+    static constexpr _Ty _Flt_eps() noexcept { // get epsilon
+        return numeric_limits<double>::epsilon();
+    }
+
+    static constexpr _Ty _Flt_max() noexcept {
+        return (numeric_limits<double>::max)();
+    }
+
+    static constexpr _Ty _Flt_norm_min() noexcept {
+        return (numeric_limits<double>::min)();
+    }
+
+    static _Ty _Abs(_Ty _Left) noexcept {
+        // testing _Left < 0 would be incorrect when _Left is -0.0
+        return _CSTD fabs(_Left);
+    }
+
+    static _Ty _Cosh(_Ty _Left, _Ty _Right) noexcept { // return cosh(_Left) * _Right
+        return _CSTD _Cosh(_Left, _Right);
+    }
+
+    static _Ty _Copysign(_Ty _Magnitude, _Ty _Sign) noexcept {
+        // testing _Sign < 0 would be incorrect when _Sign is -0.0
+        return _CSTD copysign(_Magnitude, _Sign);
+    }
+
+    static short _Exp(_Ty* _Pleft, _Ty _Right, short _Exponent) noexcept {
+        // compute exp(*_Pleft) * _Right * 2 ^ _Exponent
+        return _CSTD _Exp(_Pleft, _Right, _Exponent);
+    }
+
+    static constexpr _Ty _Infv() noexcept { // return infinity
+        return numeric_limits<double>::infinity();
+    }
+
+    static bool _Isinf(_Ty _Left) noexcept { // test for infinity
+        const auto _Uint = _Bit_cast<uint64_t>(_Left);
+        return (_Uint & 0x7fffffffffffffffU) == 0x7ff0000000000000U;
+    }
+
+    static _CONSTEXPR20 bool _Isnan(_Ty _Left) noexcept {
+        const auto _Uint = _Bit_cast<uint64_t>(_Left);
+        return (_Uint & 0x7fffffffffffffffU) > 0x7ff0000000000000U;
+    }
+
+    static constexpr _Ty _Nanv() noexcept { // return NaN
+        return numeric_limits<double>::quiet_NaN();
+    }
+
+    static bool _Signbit(_Ty _Left) noexcept {
+        // testing _Left < 0 would be incorrect when _Left is -0.0
+        return (_STD signbit) (_Left);
+    }
+
+    static _Ty _Sinh(_Ty _Left, _Ty _Right) noexcept { // return sinh(_Left) * _Right
+        return _CSTD _Sinh(_Left, _Right);
+    }
+
+    static _Ty asinh(_Ty _Left) noexcept {
+        if (_Isnan(_Left) || _Isinf(_Left) || _Left == 0) {
+            return _Left;
+        } else { // _Left finite nonzero
+            const _Ty _Old_left = _Left;
+            _Ty _Ans;
+
+            _Left = _Abs(_Left);
+
+            if (_Left < 2 / _Flt_eps()) {
+                _Ans = log1p(_Left + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
+            } else {
+                _Ans = log(_Left) // _Left big, compute log(_Left+_Left)
+                     + static_cast<_Ty>(0.69314718055994530941723212145817658L);
+            }
+
+            return _Copysign(_Ans, _Old_left);
+        }
+    }
+
+    static _Ty atan2(_Ty _Yval, _Ty _Xval) noexcept { // return atan(_Yval / _Xval)
+        return _CSTD atan2(_Yval, _Xval);
+    }
+
+    static _Ty cos(_Ty _Left) noexcept {
+        return _CSTD cos(_Left);
+    }
+
+    static _Ty exp(_Ty _Left) noexcept {
+        return _CSTD exp(_Left);
+    }
+
+    static _Ty ldexp(_Ty _Left, int _Exponent) noexcept { // return _Left * 2 ^ _Exponent
+        return _CSTD ldexp(_Left, _Exponent);
+    }
+
+    static _Ty log(_Ty _Left) noexcept {
+        return _CSTD log(_Left);
+    }
+
+    static _Ty log1p(_Ty _Left) noexcept { // return log(1 + _Left)
+        if (_Isnan(_Left) || _Left == 0 || (_Isinf(_Left) && 0 < _Left)) {
+            return _Left;
+        } else if (_Left < -1) {
+            return _Nanv();
+        } else if (_Left == -1) {
+            return -_Infv();
+        } else if (_Left == 0) {
+            return _Left;
+        } else { // compute log(1 + _Left) with fixup for small _Left
+            _Ty _Leftp1 = 1 + _Left;
+            return log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1;
+        }
+    }
+
+    static _Ty pow(_Ty _Left, _Ty _Right) noexcept {
+        return _CSTD pow(_Left, _Right);
+    }
+
+    static _Ty sin(_Ty _Left) noexcept {
+        return _CSTD sin(_Left);
+    }
+
+    static _Ty sqrt(_Ty _Left) noexcept {
+        return _CSTD sqrt(_Left);
+    }
+
+    static _Ty tan(_Ty _Left) noexcept {
+        return _CSTD tan(_Left);
+    }
+
+    static _Ty hypot(_Ty _Left, _Ty _Right) noexcept {
+        return _CSTD hypot(_Left, _Right);
+    }
+};
+
+template <>
+class _Ctraits<float> {
+public:
+    using _Ty = float;
+
+    static constexpr _Ty _Flt_eps() noexcept { // get epsilon
+        return numeric_limits<float>::epsilon();
+    }
+
+    static constexpr _Ty _Flt_max() noexcept {
+        return (numeric_limits<float>::max)();
+    }
+
+    static constexpr _Ty _Flt_norm_min() noexcept {
+        return (numeric_limits<float>::min)();
+    }
+
+    static _Ty _Abs(_Ty _Left) noexcept {
+        // testing _Left < 0 would be incorrect when _Left is -0.0
+        return _CSTD fabsf(_Left);
+    }
+
+    static _Ty _Cosh(_Ty _Left, _Ty _Right) noexcept { // return cosh(_Left) * _Right
+        return _CSTD _FCosh(_Left, _Right);
+    }
+
+    static _Ty _Copysign(_Ty _Magnitude, _Ty _Sign) noexcept {
+        // testing _Sign < 0 would be incorrect when _Sign is -0.0
+        return _CSTD copysignf(_Magnitude, _Sign);
+    }
+
+    static short _Exp(_Ty* _Pleft, _Ty _Right, short _Exponent) noexcept {
+        // compute exp(*_Pleft) * _Right * 2 ^ _Exponent
+        return _CSTD _FExp(_Pleft, _Right, _Exponent);
+    }
+
+    static constexpr _Ty _Infv() noexcept { // return infinity
+        return numeric_limits<float>::infinity();
+    }
+
+    static bool _Isinf(_Ty _Left) noexcept { // test for infinity
+        const auto _Uint = _Bit_cast<uint32_t>(_Left);
+        return (_Uint & 0x7fffffffU) == 0x7f800000U;
+    }
+
+    static _CONSTEXPR20 bool _Isnan(_Ty _Left) noexcept {
+        const auto _Uint = _Bit_cast<uint32_t>(_Left);
+        return (_Uint & 0x7fffffffU) > 0x7f800000U;
+    }
+
+    static constexpr _Ty _Nanv() noexcept { // return NaN
+        return numeric_limits<float>::quiet_NaN();
+    }
+
+    static bool _Signbit(_Ty _Left) noexcept {
+        // testing _Left < 0 would be incorrect when _Left is -0.0
+        return (_STD signbit) (_Left);
+    }
+
+    static _Ty _Sinh(_Ty _Left, _Ty _Right) noexcept { // return sinh(_Left) * _Right
+        return _CSTD _FSinh(_Left, _Right);
+    }
+
+    static _Ty asinh(_Ty _Left) noexcept {
+        if (_Left == 0 || _Isnan(_Left) || _Isinf(_Left)) {
+            return _Left;
+        }
+
+        constexpr _Ty _Ln2 = 0.69314718055994530941723212145817658F;
+
+        const _Ty _Old_left = _Left;
+        _Ty _Ans;
+
+        _Left = _Abs(_Left);
+
+        if (_Left < 2 / _Flt_eps()) {
+            _Ans = log1p(_Left + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
+        } else {
+            _Ans = log(_Left) + _Ln2;
+        }
+
+        return _Copysign(_Ans, _Old_left);
+    }
+
+    static _Ty atan2(_Ty _Yval, _Ty _Xval) noexcept { // return atan(_Yval / _Xval)
+        return _CSTD atan2f(_Yval, _Xval);
+    }
+
+    static _Ty cos(_Ty _Left) noexcept {
+        return _CSTD cosf(_Left);
+    }
+
+    static _Ty exp(_Ty _Left) noexcept {
+        return _CSTD expf(_Left);
+    }
+
+    static _Ty ldexp(_Ty _Left, int _Exponent) noexcept { // return _Left * 2 ^ _Exponent
+        return _CSTD ldexpf(_Left, _Exponent);
+    }
+
+    static _Ty log(_Ty _Left) noexcept {
+        return _CSTD logf(_Left);
+    }
+
+    static _Ty log1p(_Ty _Left) noexcept { // return log(1 + _Left)
+        if (_Left < -1) {
+            return _Nanv();
+        } else if (_Left == 0) {
+            return _Left;
+        } else { // compute log(1 + _Left) with fixup for small _Left
+            _Ty _Leftp1 = 1 + _Left;
+            return log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1;
+        }
+    }
+
+    static _Ty pow(_Ty _Left, _Ty _Right) noexcept {
+        return _CSTD powf(_Left, _Right);
+    }
+
+    static _Ty sin(_Ty _Left) noexcept {
+        return _CSTD sinf(_Left);
+    }
+
+    static _Ty sqrt(_Ty _Left) noexcept {
+        return _CSTD sqrtf(_Left);
+    }
+
+    static _Ty tan(_Ty _Left) noexcept {
+        return _CSTD tanf(_Left);
+    }
+
+    static _Ty hypot(_Ty _Left, _Ty _Right) noexcept {
+        return _CSTD hypotf(_Left, _Right);
+    }
+};
+
+template <class _Ty>
+constexpr bool _Is_unqual_fp = _Is_any_of_v<_Ty, float, double, long double>;
+
+template <class _Ty>
+struct _Complex_value {
+    enum { _Re = 0, _Im = 1 };
+    _Ty _Val[2];
+};
+
+template <class _Ty, class _Valbase>
+class _Complex_base : public _Valbase {
+private:
+    static constexpr bool _Is_for_standard_complex = _Is_any_of_v<_Complex_base, _Complex_base<float, _Fcomplex_value>,
+        _Complex_base<double, _Dcomplex_value>, _Complex_base<long double, _Lcomplex_value>>;
+
+public:
+    using _Myctraits = _Ctraits<_Ty>;
+    using value_type = _Ty;
+
+    constexpr _Complex_base(const _Ty& _Realval, const _Ty& _Imagval) noexcept(_Is_for_standard_complex)
+        : _Valbase{{_Realval, _Imagval}} {}
+
+    _CONSTEXPR20 void real(const _Ty& _Right) noexcept(_Is_for_standard_complex) /* strengthened */ {
+        // set real component
+        this->_Val[_RE] = _Right;
+    }
+
+    _CONSTEXPR20 void imag(const _Ty& _Right) noexcept(_Is_for_standard_complex) /* strengthened */ {
+        // set imaginary component
+        this->_Val[_IM] = _Right;
+    }
+
+    _NODISCARD constexpr _Ty real() const noexcept(_Is_for_standard_complex) /* strengthened */ {
+        // return real component
+        return this->_Val[_RE];
+    }
+
+    _NODISCARD constexpr _Ty imag() const noexcept(_Is_for_standard_complex) /* strengthened */ {
+        // return imaginary component
+        return this->_Val[_IM];
+    }
+
+protected:
+    template <class _Other>
+    _CONSTEXPR20 void _Add(const complex<_Other>& _Right) noexcept(_Is_for_standard_complex && _Is_unqual_fp<_Other>) {
+        this->_Val[_RE] = this->_Val[_RE] + static_cast<_Ty>(_Right.real());
+        this->_Val[_IM] = this->_Val[_IM] + static_cast<_Ty>(_Right.imag());
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 void _Sub(const complex<_Other>& _Right) noexcept(_Is_for_standard_complex && _Is_unqual_fp<_Other>) {
+        this->_Val[_RE] = this->_Val[_RE] - static_cast<_Ty>(_Right.real());
+        this->_Val[_IM] = this->_Val[_IM] - static_cast<_Ty>(_Right.imag());
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 void _Mul(const complex<_Other>& _Right) noexcept(_Is_for_standard_complex && _Is_unqual_fp<_Other>) {
+        _Ty _Rightreal = static_cast<_Ty>(_Right.real());
+        _Ty _Rightimag = static_cast<_Ty>(_Right.imag());
+
+        _Ty _Tmp        = this->_Val[_RE] * _Rightreal - this->_Val[_IM] * _Rightimag;
+        this->_Val[_IM] = this->_Val[_RE] * _Rightimag + this->_Val[_IM] * _Rightreal;
+        this->_Val[_RE] = _Tmp;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 void _Div(const complex<_Other>& _Right) noexcept(_Is_for_standard_complex && _Is_unqual_fp<_Other>) {
+        using _Myctraits = _Ctraits<_Ty>;
+
+        _Ty _Rightreal = static_cast<_Ty>(_Right.real());
+        _Ty _Rightimag = static_cast<_Ty>(_Right.imag());
+
+        if (_Myctraits::_Isnan(_Rightreal) || _Myctraits::_Isnan(_Rightimag)) { // set NaN result
+            this->_Val[_RE] = _Myctraits::_Nanv();
+            this->_Val[_IM] = this->_Val[_RE];
+        } else if ((_Rightimag < 0 ? -_Rightimag : +_Rightimag)
+                   < (_Rightreal < 0 ? -_Rightreal : +_Rightreal)) { // |_Right.imag()| < |_Right.real()|
+            _Ty _Wr = _Rightimag / _Rightreal;
+            _Ty _Wd = _Rightreal + _Wr * _Rightimag;
+
+            if (_Myctraits::_Isnan(_Wd) || _Wd == 0) { // set NaN result
+                this->_Val[_RE] = _Myctraits::_Nanv();
+                this->_Val[_IM] = this->_Val[_RE];
+            } else { // compute representable result
+                _Ty _Tmp        = (this->_Val[_RE] + this->_Val[_IM] * _Wr) / _Wd;
+                this->_Val[_IM] = (this->_Val[_IM] - this->_Val[_RE] * _Wr) / _Wd;
+                this->_Val[_RE] = _Tmp;
+            }
+        } else if (_Rightimag == 0) { // _Right.real() == 0 && _Right.imag() == 0
+            this->_Val[_RE] /= _Rightreal;
+            this->_Val[_IM] /= _Rightreal;
+        } else { // 0 < |_Right.real()| <= |_Right.imag()|
+            _Ty _Wr = _Rightreal / _Rightimag;
+            _Ty _Wd = _Rightimag + _Wr * _Rightreal;
+
+            if (_Myctraits::_Isnan(_Wd) || _Wd == 0) { // set NaN result
+                this->_Val[_RE] = _Myctraits::_Nanv();
+                this->_Val[_IM] = this->_Val[_RE];
+            } else { // compute representable result
+                _Ty _Tmp        = (this->_Val[_RE] * _Wr + this->_Val[_IM]) / _Wd;
+                this->_Val[_IM] = (this->_Val[_IM] * _Wr - this->_Val[_RE]) / _Wd;
+                this->_Val[_RE] = _Tmp;
+            }
+        }
+    }
+};
+
+template <>
+class complex<float> : public _Complex_base<float, _Fcomplex_value> {
+public:
+    using _Ty = float;
+
+    constexpr explicit complex(const complex<double>&) noexcept; // strengthened, defined below
+    constexpr explicit complex(const complex<long double>&) noexcept; // strengthened, defined below
+
+    constexpr complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0) noexcept // strengthened
+        : _Complex_base<float, _Fcomplex_value>(_Realval, _Imagval) {}
+
+    _CONSTEXPR20 complex& operator=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Right;
+        _Val[_IM] = 0;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator+=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] + _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator-=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] - _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator*=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] * _Right;
+        _Val[_IM] = _Val[_IM] * _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator/=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] / _Right;
+        _Val[_IM] = _Val[_IM] / _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator+=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Add(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator-=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Sub(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator*=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Mul(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator/=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Div(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        _Val[_RE] = static_cast<_Ty>(_Right._Val[_RE]);
+        _Val[_IM] = static_cast<_Ty>(_Right._Val[_IM]);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator+=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Add(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator-=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Sub(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator*=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Mul(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator/=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Div(_Right);
+        return *this;
+    }
+};
+
+template <>
+class complex<double> : public _Complex_base<double, _Dcomplex_value> {
+public:
+    using _Ty = double;
+
+    constexpr complex(const complex<float>&) noexcept; // strengthened, defined below
+    constexpr explicit complex(const complex<long double>&) noexcept; // strengthened, defined below
+
+    constexpr complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0) noexcept // strengthened
+        : _Complex_base<double, _Dcomplex_value>(_Realval, _Imagval) {}
+
+    _CONSTEXPR20 complex& operator=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Right;
+        _Val[_IM] = 0;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator+=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] + _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator-=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] - _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator*=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] * _Right;
+        _Val[_IM] = _Val[_IM] * _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator/=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] / _Right;
+        _Val[_IM] = _Val[_IM] / _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator+=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Add(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator-=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Sub(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator*=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Mul(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator/=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Div(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        _Val[_RE] = static_cast<_Ty>(_Right._Val[_RE]);
+        _Val[_IM] = static_cast<_Ty>(_Right._Val[_IM]);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator+=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Add(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator-=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Sub(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator*=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Mul(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator/=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Div(_Right);
+        return *this;
+    }
+};
+
+template <>
+class complex<long double> : public _Complex_base<long double, _Lcomplex_value> {
+public:
+    using _Ty = long double;
+
+    constexpr complex(const complex<float>&) noexcept; // strengthened, defined below
+    constexpr complex(const complex<double>&) noexcept; // strengthened, defined below
+
+    constexpr complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0) noexcept // strengthened
+        : _Complex_base<long double, _Lcomplex_value>(_Realval, _Imagval) {}
+
+    _CONSTEXPR20 complex& operator=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Right;
+        _Val[_IM] = 0;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator+=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] + _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator-=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] - _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator*=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] * _Right;
+        _Val[_IM] = _Val[_IM] * _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator/=(const _Ty& _Right) noexcept /* strengthened */ {
+        _Val[_RE] = _Val[_RE] / _Right;
+        _Val[_IM] = _Val[_IM] / _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator+=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Add(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator-=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Sub(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator*=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Mul(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator/=(const complex& _Right) noexcept /* strengthened */ {
+        this->_Div(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        _Val[_RE] = static_cast<_Ty>(_Right._Val[_RE]);
+        _Val[_IM] = static_cast<_Ty>(_Right._Val[_IM]);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator+=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Add(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator-=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Sub(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator*=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Mul(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator/=(const complex<_Other>& _Right) noexcept(_Is_unqual_fp<_Other>) /* strengthened */ {
+        this->_Div(_Right);
+        return *this;
+    }
+};
+
+constexpr complex<float>::complex(const complex<double>& _Right) noexcept // strengthened
+    : _Complex_base<float, _Fcomplex_value>(static_cast<_Ty>(_Right.real()), static_cast<_Ty>(_Right.imag())) {}
+
+constexpr complex<float>::complex(const complex<long double>& _Right) noexcept // strengthened
+    : _Complex_base<float, _Fcomplex_value>(static_cast<_Ty>(_Right.real()), static_cast<_Ty>(_Right.imag())) {}
+
+constexpr complex<double>::complex(const complex<float>& _Right) noexcept // strengthened
+    : _Complex_base<double, _Dcomplex_value>(_Right.real(), _Right.imag()) {}
+
+constexpr complex<double>::complex(const complex<long double>& _Right) noexcept // strengthened
+    : _Complex_base<double, _Dcomplex_value>(static_cast<_Ty>(_Right.real()), static_cast<_Ty>(_Right.imag())) {}
+
+constexpr complex<long double>::complex(const complex<float>& _Right) noexcept // strengthened
+    : _Complex_base<long double, _Lcomplex_value>(_Right.real(), _Right.imag()) {}
+
+constexpr complex<long double>::complex(const complex<double>& _Right) noexcept // strengthened
+    : _Complex_base<long double, _Lcomplex_value>(_Right.real(), _Right.imag()) {}
+
+_EXPORT_STD template <class _Ty>
+class complex : public _Complex_base<_Ty, _Complex_value<_Ty>> {
+public:
+    using _Mybase = _Complex_base<_Ty, _Complex_value<_Ty>>;
+
+    _DEPRECATE_NONFLOATING_COMPLEX
+    constexpr complex(const _Ty& _Realval = _Ty(), const _Ty& _Imagval = _Ty()) : _Mybase(_Realval, _Imagval) {}
+
+    _CONSTEXPR20 complex& operator=(const _Ty& _Right) {
+        this->_Val[_RE] = _Right;
+        this->_Val[_IM] = _Ty();
+        return *this;
+    }
+
+    template <class _Other>
+    _DEPRECATE_NONFLOATING_COMPLEX constexpr complex(const complex<_Other>& _Right)
+        : _Mybase(static_cast<_Ty>(_Right.real()), static_cast<_Ty>(_Right.imag())) {}
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator=(const complex<_Other>& _Right) {
+        this->_Val[_RE] = static_cast<_Ty>(_Right.real());
+        this->_Val[_IM] = static_cast<_Ty>(_Right.imag());
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator+=(const _Ty& _Right) {
+        this->_Val[_RE] = this->_Val[_RE] + _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator-=(const _Ty& _Right) {
+        this->_Val[_RE] = this->_Val[_RE] - _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator*=(const _Ty& _Right) {
+        this->_Val[_RE] = this->_Val[_RE] * _Right;
+        this->_Val[_IM] = this->_Val[_IM] * _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator/=(const _Ty& _Right) {
+        this->_Val[_RE] = this->_Val[_RE] / _Right;
+        this->_Val[_IM] = this->_Val[_IM] / _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator+=(const complex& _Right) {
+        this->_Add(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator-=(const complex& _Right) {
+        this->_Sub(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator*=(const complex& _Right) {
+        this->_Mul(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 complex& operator/=(const complex& _Right) {
+        this->_Div(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator+=(const complex<_Other>& _Right) {
+        this->_Add(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator-=(const complex<_Other>& _Right) {
+        this->_Sub(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator*=(const complex<_Other>& _Right) {
+        this->_Mul(_Right);
+        return *this;
+    }
+
+    template <class _Other>
+    _CONSTEXPR20 complex& operator/=(const complex<_Other>& _Right) {
+        this->_Div(_Right);
+        return *this;
+    }
+};
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator+(const complex<_Ty>& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp += _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator+(const complex<_Ty>& _Left, const _Ty& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp += _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator+(const _Ty& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Right);
+    _Tmp += _Left;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator-(const complex<_Ty>& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp -= _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator-(const complex<_Ty>& _Left, const _Ty& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp -= _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator-(const _Ty& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp -= _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator*(const complex<_Ty>& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp *= _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator*(const complex<_Ty>& _Left, const _Ty& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp *= _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator*(const _Ty& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Right);
+    _Tmp *= _Left;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator/(const complex<_Ty>& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp /= _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator/(const complex<_Ty>& _Left, const _Ty& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp /= _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator/(const _Ty& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Tmp(_Left);
+    _Tmp /= _Right;
+    return _Tmp;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator+(const complex<_Ty>& _Left)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return _Left;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> operator-(const complex<_Ty>& _Left)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return complex<_Ty>(-_Left.real(), -_Left.imag());
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr bool operator==(const complex<_Ty>& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return _Left.real() == _Right.real() && _Left.imag() == _Right.imag();
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr bool operator==(const complex<_Ty>& _Left, const _Ty& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return _Left.real() == _Right && _Left.imag() == 0;
+}
+
+#if !_HAS_CXX20
+template <class _Ty>
+_NODISCARD constexpr bool operator==(const _Ty& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return _Left == _Right.real() && 0 == _Right.imag();
+}
+
+template <class _Ty>
+_NODISCARD constexpr bool operator!=(const complex<_Ty>& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return !(_Left == _Right);
+}
+
+template <class _Ty>
+_NODISCARD constexpr bool operator!=(const complex<_Ty>& _Left, const _Ty& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return !(_Left == _Right);
+}
+
+template <class _Ty>
+_NODISCARD constexpr bool operator!=(const _Ty& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty imag(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return _Left.imag();
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty real(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return _Left.real();
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> sqrt(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */;
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Ty abs(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return _Ctraits<_Ty>::hypot(_Left.real(), _Left.imag());
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> acos(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    const _Ty _Arcbig     = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
+    constexpr _Ty _Pi_val = static_cast<_Ty>(3.1415926535897932384626433832795029L);
+
+    const _Ty _Re = real(_Left);
+    const _Ty _Im = imag(_Left);
+    _Ty _Ux;
+    _Ty _Vx;
+
+    if (_Ctraits<_Ty>::_Isnan(_Re) || _Ctraits<_Ty>::_Isnan(_Im)) { // at least one NaN
+        _Ux = _Ctraits<_Ty>::_Nanv();
+        _Vx = _Ux;
+    } else if (_Ctraits<_Ty>::_Isinf(_Re)) { // (+/-Inf, not NaN)
+        if (_Ctraits<_Ty>::_Isinf(_Im)) {
+            if (_Re < 0) {
+                _Ux = static_cast<_Ty>(0.75) * _Pi_val; // (-Inf, +/-Inf)
+            } else {
+                _Ux = static_cast<_Ty>(0.25) * _Pi_val; // (+Inf, +/-Inf)
+            }
+        } else if (_Re < 0) {
+            _Ux = _Pi_val; // (-Inf, finite)
+        } else {
+            _Ux = 0; // (+Inf, finite)
+        }
+        _Vx = -_Ctraits<_Ty>::_Copysign(_Ctraits<_Ty>::_Infv(), _Im);
+    } else if (_Ctraits<_Ty>::_Isinf(_Im)) { // (finite, finite)
+        _Ux = static_cast<_Ty>(0.50) * _Pi_val; // (finite, +/-Inf)
+        _Vx = -_Im;
+    } else { // (finite, finite)
+        const complex<_Ty> _Wx = sqrt(complex<_Ty>(1 + _Re, -_Im));
+        const complex<_Ty> _Zx = sqrt(complex<_Ty>(1 - _Re, -_Im));
+        const _Ty _Wr          = real(_Wx);
+        const _Ty _Wi          = imag(_Wx);
+        const _Ty _Zr          = real(_Zx);
+        const _Ty _Zi          = imag(_Zx);
+        _Ty _Alfa;
+        _Ty _Beta;
+
+        _Ux = 2 * _Ctraits<_Ty>::atan2(_Zr, _Wr);
+
+        if (_Arcbig < _Wr) { // real parts large
+            _Alfa = _Wr;
+            _Beta = _Zi + _Wi * (_Zr / _Alfa);
+        } else if (_Arcbig < _Wi) { // imag parts large
+            _Alfa = _Wi;
+            _Beta = _Wr * (_Zi / _Alfa) + _Zr;
+        } else if (_Wi < -_Arcbig) { // imag part of w large negative
+            _Alfa = -_Wi;
+            _Beta = _Wr * (_Zi / _Alfa) - _Zr;
+        } else { // shouldn't overflow
+            _Alfa = 0;
+            _Beta = _Wr * _Zi + _Wi * _Zr; // Im(w * z)
+        }
+
+        _Vx = _Ctraits<_Ty>::asinh(_Beta);
+        if (_Alfa != 0) {
+            if (0 <= _Vx) {
+                _Vx += _Ctraits<_Ty>::log(_Alfa);
+            } else {
+                _Vx -= _Ctraits<_Ty>::log(_Alfa); // asinh(a*b) = asinh(a)+log(b)
+            }
+        }
+    }
+    return complex<_Ty>(_Ux, _Vx);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> acosh(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    const _Ty _Arcbig     = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
+    constexpr _Ty _Pi_val = static_cast<_Ty>(3.1415926535897932384626433832795029L);
+
+    const _Ty _Re = real(_Left);
+    _Ty _Im       = imag(_Left);
+    _Ty _Ux;
+    _Ty _Vx;
+
+    if (_Ctraits<_Ty>::_Isnan(_Re) || _Ctraits<_Ty>::_Isnan(_Im)) { // at least one NaN
+        _Ux = _Ctraits<_Ty>::_Nanv();
+        _Vx = _Ux;
+    } else if (_Ctraits<_Ty>::_Isinf(_Re)) { // (+/-Inf, not NaN)
+        _Ux = _Ctraits<_Ty>::_Infv();
+
+        if (_Ctraits<_Ty>::_Isinf(_Im)) {
+            if (_Re < 0) {
+                _Vx = static_cast<_Ty>(0.75) * _Pi_val; // (-Inf, +/-Inf)
+            } else {
+                _Vx = static_cast<_Ty>(0.25) * _Pi_val; // (+Inf, +/-Inf)
+            }
+        } else if (_Re < 0) {
+            _Vx = _Pi_val; // (-Inf, finite)
+        } else {
+            _Vx = 0; // (+Inf, finite)
+        }
+
+        _Vx = _Ctraits<_Ty>::_Copysign(_Vx, _Im);
+    } else if (_Ctraits<_Ty>::_Isinf(_Im)) { // (finite, +/-Inf)
+        _Ux = _Ctraits<_Ty>::_Infv();
+        _Vx = _Ctraits<_Ty>::_Copysign(static_cast<_Ty>(0.50) * _Pi_val, _Im);
+    } else { // (finite, finite)
+        const complex<_Ty> _Wx = sqrt(complex<_Ty>(_Re - 1, -_Im));
+        const complex<_Ty> _Zx = sqrt(complex<_Ty>(_Re + 1, _Im));
+        const _Ty _Wr          = real(_Wx);
+        const _Ty _Wi          = imag(_Wx);
+        const _Ty _Zr          = real(_Zx);
+        const _Ty _Zi          = imag(_Zx);
+        _Ty _Alfa;
+        _Ty _Beta;
+
+        if (_Arcbig < _Wr) { // real parts large
+            _Alfa = _Wr;
+            _Beta = _Zr - _Wi * (_Zi / _Alfa);
+        } else if (_Arcbig < _Wi) { // imag parts large
+            _Alfa = _Wi;
+            _Beta = _Wr * (_Zr / _Alfa) - _Zi;
+        } else if (_Wi < -_Arcbig) { // imag part of w large negative
+            _Alfa = -_Wi;
+            _Beta = _Wr * (_Zr / _Alfa) + _Zi;
+        } else { // shouldn't overflow
+            _Alfa = 0;
+            _Beta = _Wr * _Zr - _Wi * _Zi; // Re(w * z)
+        }
+
+        _Ux = _Ctraits<_Ty>::asinh(_Beta);
+        if (_Alfa != 0) {
+            if (0 <= _Ux) {
+                _Ux += _Ctraits<_Ty>::log(_Alfa);
+            } else {
+                _Ux -= _Ctraits<_Ty>::log(_Alfa); // asinh(a*b) = asinh(a)+log(b)
+            }
+        }
+
+        _Vx = 2 * _Ctraits<_Ty>::atan2(imag(sqrt(complex<_Ty>(_Re - 1, _Im))), _Zr);
+    }
+    return complex<_Ty>(_Ux, _Vx);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> asinh(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    const _Ty _Arcbig     = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
+    constexpr _Ty _Pi_val = static_cast<_Ty>(3.1415926535897932384626433832795029L);
+
+    const _Ty _Re = real(_Left);
+    _Ty _Im       = imag(_Left);
+    _Ty _Ux;
+    _Ty _Vx;
+
+    if (_Ctraits<_Ty>::_Isnan(_Re) || _Ctraits<_Ty>::_Isnan(_Im)) { // at least one NaN/Inf
+        _Ux = _Ctraits<_Ty>::_Nanv();
+        _Vx = _Ux;
+    } else if (_Ctraits<_Ty>::_Isinf(_Re)) { // (+/-Inf, not NaN)
+        _Ux = _Ctraits<_Ty>::_Infv();
+
+        if (_Ctraits<_Ty>::_Isinf(_Im)) { // (+/-Inf, +/-Inf)
+            _Ux = _Re;
+            _Vx = _Ctraits<_Ty>::_Copysign(static_cast<_Ty>(0.25) * _Pi_val, _Im);
+        } else { // (+/-Inf, finite)
+            _Ux = _Re;
+            _Vx = _Ctraits<_Ty>::_Copysign(_Ty{0}, _Im);
+        }
+    } else if (_Ctraits<_Ty>::_Isinf(_Im)) { // (finite, +/-Inf)
+        _Ux = _Ctraits<_Ty>::_Copysign(_Ctraits<_Ty>::_Infv(), _Re);
+        _Vx = _Ctraits<_Ty>::_Copysign(static_cast<_Ty>(0.50) * _Pi_val, _Im);
+    } else { // (finite, finite)
+        const complex<_Ty> _Wx = sqrt(complex<_Ty>(1 - _Im, _Re));
+        const complex<_Ty> _Zx = sqrt(complex<_Ty>(1 + _Im, -_Re));
+        const _Ty _Wr          = real(_Wx);
+        const _Ty _Wi          = imag(_Wx);
+        const _Ty _Zr          = real(_Zx);
+        const _Ty _Zi          = imag(_Zx);
+        _Ty _Alfa;
+        _Ty _Beta;
+
+        if (_Arcbig < _Wr) { // real parts large
+            _Alfa = _Wr;
+            _Beta = _Wi * (_Zr / _Alfa) - _Zi;
+        } else if (_Arcbig < _Wi) { // imag parts large
+            _Alfa = _Wi;
+            _Beta = _Zr - _Wr * (_Zi / _Alfa);
+        } else if (_Wi < -_Arcbig) { // imag part of w large negative
+            _Alfa = -_Wi;
+            _Beta = -_Zr - _Wr * (_Zi / _Alfa);
+        } else { // shouldn't overflow
+            _Alfa = 0;
+            _Beta = _Wi * _Zr - _Wr * _Zi; // Im(w * conj(z))
+        }
+
+        _Ux = _Ctraits<_Ty>::asinh(_Beta);
+        if (_Alfa != 0) {
+            if (0 <= _Ux) {
+                _Ux += _Ctraits<_Ty>::log(_Alfa);
+            } else {
+                _Ux -= _Ctraits<_Ty>::log(_Alfa); // asinh(a*b) = asinh(a)+log(b)
+            }
+        }
+
+        _Vx = _Ctraits<_Ty>::atan2(_Im, real(_Wx * _Zx));
+    }
+
+    return complex<_Ty>(_Ux, _Vx);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> asin(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Asinh = _STD asinh(complex<_Ty>(-imag(_Left), real(_Left)));
+
+    return complex<_Ty>(imag(_Asinh), -real(_Asinh));
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> atanh(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    const _Ty _Arcbig    = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
+    constexpr _Ty _Piby2 = static_cast<_Ty>(1.5707963267948966192313216916397514L);
+
+    _Ty _Re = real(_Left);
+    _Ty _Im = imag(_Left);
+    _Ty _Ux;
+    _Ty _Vx;
+
+    if (_Ctraits<_Ty>::_Isnan(_Re) || _Ctraits<_Ty>::_Isnan(_Im)) { // at least one NaN
+        _Ux = _Ctraits<_Ty>::_Nanv();
+        _Vx = _Ux;
+    } else if (_Ctraits<_Ty>::_Isinf(_Re)) { // (+/-Inf, not NaN)
+        _Ux = _Ctraits<_Ty>::_Copysign(_Ty{0}, _Re);
+        _Vx = _Ctraits<_Ty>::_Copysign(_Piby2, _Im);
+    } else { // (finite, not _NaN)
+        const _Ty _Magim  = _Ctraits<_Ty>::_Abs(_Im);
+        const _Ty _Old_re = _Re;
+
+        _Re = _Ctraits<_Ty>::_Abs(_Re);
+
+        if (_Arcbig < _Re) { // |re| is large
+            _Ty _Fx = _Im / _Re;
+
+            _Ux = 1 / _Re / (1 + _Fx * _Fx);
+            _Vx = _Ctraits<_Ty>::_Copysign(_Piby2, _Im);
+        } else if (_Arcbig < _Magim) { // |im| is large
+            _Ty _Fx = _Re / _Im;
+
+            _Ux = _Fx / _Im / (1 + _Fx * _Fx);
+            _Vx = _Ctraits<_Ty>::_Copysign(_Piby2, _Im);
+        } else if (_Re != 1) { // |re| is small
+            _Ty _Refrom1 = 1 - _Re;
+            _Ty _Imeps2  = _Magim * _Magim;
+
+            _Ux = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::log1p(4 * _Re / (_Refrom1 * _Refrom1 + _Imeps2));
+            _Vx = static_cast<_Ty>(0.50) * _Ctraits<_Ty>::atan2(2 * _Im, _Refrom1 * (1 + _Re) - _Imeps2);
+        } else if (_Im == 0) { // {+/-1, 0)
+            _Ux = _Ctraits<_Ty>::_Infv();
+            _Vx = _Im;
+        } else { // {+/-1, nonzero)
+            _Ux = _Ctraits<_Ty>::log(
+                _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::sqrt(4 + _Im * _Im)) / _Ctraits<_Ty>::sqrt(_Magim));
+            _Vx = _Ctraits<_Ty>::_Copysign(static_cast<_Ty>(0.50) * (_Piby2 + _Ctraits<_Ty>::atan2(_Magim, 2)), _Im);
+        }
+
+        _Ux = _Ctraits<_Ty>::_Copysign(_Ux, _Old_re);
+    }
+    return complex<_Ty>(_Ux, _Vx);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> atan(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Atanh = _STD atanh(complex<_Ty>(-imag(_Left), real(_Left)));
+
+    return complex<_Ty>(imag(_Atanh), -real(_Atanh));
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> cosh(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return complex<_Ty>(_Ctraits<_Ty>::_Cosh(real(_Left), _Ctraits<_Ty>::cos(imag(_Left))),
+        _Ctraits<_Ty>::_Sinh(real(_Left), _Ctraits<_Ty>::sin(imag(_Left))));
+}
+
+template <class _Ty>
+_NODISCARD complex<_Ty> _Polar_positive_nan_inf_zero_rho(const _Ty& _Rho, const _Ty& _Theta)
+    noexcept(_Is_unqual_fp<_Ty>) { // _Rho is +NaN/+Inf/+0
+    if (_Ctraits<_Ty>::_Isnan(_Theta) || _Ctraits<_Ty>::_Isinf(_Theta)) { // _Theta is NaN/Inf
+        if (_Ctraits<_Ty>::_Isinf(_Rho)) {
+            return complex<_Ty>(_Rho, _Ctraits<_Ty>::sin(_Theta)); // (Inf, NaN/Inf)
+        } else {
+            return complex<_Ty>(_Rho, _Ctraits<_Ty>::_Copysign(_Rho, _Theta)); // (NaN/0, NaN/Inf)
+        }
+    } else if (_Theta == _Ty{0}) { // _Theta is zero
+        return complex<_Ty>(_Rho, _Theta); // (NaN/Inf/0, 0)
+    } else { // _Theta is finite non-zero
+        // (NaN/Inf/0, finite non-zero)
+        return complex<_Ty>(_Rho * _Ctraits<_Ty>::cos(_Theta), _Rho * _Ctraits<_Ty>::sin(_Theta));
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> exp(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    const _Ty _Log_rho = _STD real(_Left);
+    const _Ty _Theta   = _STD imag(_Left);
+
+    if (!_Ctraits<_Ty>::_Isnan(_Log_rho) && !_Ctraits<_Ty>::_Isinf(_Log_rho)) { // real component is finite
+        _Ty _Real = _Log_rho;
+        _Ty _Imag = _Log_rho;
+        _Ctraits<_Ty>::_Exp(&_Real, _Ctraits<_Ty>::cos(_Theta), 0);
+        _Ctraits<_Ty>::_Exp(&_Imag, _Ctraits<_Ty>::sin(_Theta), 0);
+        return complex<_Ty>(_Real, _Imag);
+    }
+
+    // real component is NaN/Inf
+    // return polar(exp(re), im)
+    if (_Ctraits<_Ty>::_Isinf(_Log_rho)) {
+        if (_Log_rho < _Ty{0}) {
+            return _Polar_positive_nan_inf_zero_rho(_Ty{0}, _Theta); // exp(-Inf) = +0
+        } else {
+            return _Polar_positive_nan_inf_zero_rho(_Log_rho, _Theta); // exp(+Inf) = +Inf
+        }
+    } else {
+        return _Polar_positive_nan_inf_zero_rho(_Ctraits<_Ty>::_Abs(_Log_rho), _Theta); // exp(NaN) = +NaN
+    }
+}
+
+template <class _Ty>
+_Ty _Fabs(const complex<_Ty>& _Left, int* _Pexp) noexcept(_Is_unqual_fp<_Ty>) {
+    // Used by sqrt(), return magnitude and scale factor.
+    // Returns a non-zero even integer in *_Pexp when _Left is finite and non-zero.
+    // Returns 0 in *_Pexp when _Left is zero, infinity, or NaN.
+    *_Pexp  = 0;
+    _Ty _Av = _Ctraits<_Ty>::_Abs(_STD real(_Left));
+    _Ty _Bv = _Ctraits<_Ty>::_Abs(_STD imag(_Left));
+
+    if (_Ctraits<_Ty>::_Isinf(_Av) || _Ctraits<_Ty>::_Isinf(_Bv)) {
+        return _Ctraits<_Ty>::_Infv(); // at least one component is INF
+    } else if (_Ctraits<_Ty>::_Isnan(_Av)) {
+        return _Av; // real component is NaN
+    } else if (_Ctraits<_Ty>::_Isnan(_Bv)) {
+        return _Bv; // imaginary component is NaN
+    } else { // neither component is NaN or INF
+        if (_Av < _Bv) { // ensure that |_Bv| <= |_Av|
+            _STD swap(_Av, _Bv);
+        }
+
+        if (_Av == 0) {
+            return _Av; // |0| == 0
+        }
+
+        if (1 <= _Av) {
+            *_Pexp = 4;
+            _Av    = _Av * static_cast<_Ty>(0.0625);
+            _Bv    = _Bv * static_cast<_Ty>(0.0625);
+        } else {
+            constexpr _Ty _Flt_eps = _Ctraits<_Ty>::_Flt_eps();
+            // TRANSITION, workaround for non-floating-point _Ty
+            constexpr _Ty _Leg_tiny = _Flt_eps == 0 ? _Ty{0} : 2 * _Ctraits<_Ty>::_Flt_norm_min() / _Flt_eps;
+
+            if (_Av < _Leg_tiny) {
+                constexpr int _Exponent = -2 * numeric_limits<_Ty>::digits;
+
+                *_Pexp = _Exponent;
+                _Av    = _Ctraits<_Ty>::ldexp(_Av, -_Exponent);
+                _Bv    = _Ctraits<_Ty>::ldexp(_Bv, -_Exponent);
+            } else {
+                *_Pexp = -2;
+                _Av    = _Av * 4;
+                _Bv    = _Bv * 4;
+            }
+        }
+
+        const _Ty _Tmp = _Av - _Bv;
+        if (_Tmp == _Av) {
+            return _Av; // _Bv unimportant
+        } else if (_Bv < _Tmp) { // use simple approximation
+            const _Ty _Qv = _Av / _Bv;
+            return _Av + _Bv / (_Qv + _Ctraits<_Ty>::sqrt(_Qv * _Qv + 1));
+        } else { // use 1 1/2 precision to preserve bits
+            constexpr _Ty _Root2            = static_cast<_Ty>(1.4142135623730950488016887242096981L);
+            constexpr _Ty _Oneplusroot2high = static_cast<_Ty>(10125945.0 / 4194304.0); // exact if prec >= 24 bits
+            constexpr _Ty _Oneplusroot2low  = static_cast<_Ty>(1.4341252375973918872420969807856967e-7L);
+
+            const _Ty _Qv = _Tmp / _Bv;
+            const _Ty _Rv = (_Qv + 2) * _Qv;
+            const _Ty _Sv = _Rv / (_Root2 + _Ctraits<_Ty>::sqrt(_Rv + 2)) + _Oneplusroot2low + _Qv + _Oneplusroot2high;
+            return _Av + _Bv / _Sv;
+        }
+    }
+}
+
+template <class _Ty>
+_NODISCARD _Ty _Log_abs(const complex<_Ty>& _Left) noexcept { // for double, long double, and non-floating-point types
+    return static_cast<_Ty>(
+        _Math_algorithms::_Log_hypot(static_cast<double>(_STD real(_Left)), static_cast<double>(_STD imag(_Left))));
+}
+
+_NODISCARD inline float _Log_abs(const complex<float>& _Left) noexcept {
+    return _Math_algorithms::_Log_hypot(_STD real(_Left), _STD imag(_Left));
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> log(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    const _Ty _Log_abs_v = _Log_abs(_Left); // get logarithm of magnitude
+    const _Ty _Theta     = _Ctraits<_Ty>::atan2(_STD imag(_Left), _STD real(_Left)); // get phase
+    return complex<_Ty>(_Log_abs_v, _Theta);
+}
+
+template <class _Ty>
+complex<_Ty> _Pow(const _Ty& _Left, const _Ty& _Right) noexcept(_Is_unqual_fp<_Ty>) {
+    if (0 <= _Left) {
+        return complex<_Ty>(_Ctraits<_Ty>::pow(_Left, _Right), _Ctraits<_Ty>::_Copysign(_Ty{0}, _Right));
+    } else {
+        return exp(_Right * log(complex<_Ty>(_Left)));
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> pow(const complex<_Ty>& _Left, const _Ty& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    if (imag(_Left) == 0) {
+        if (_Ctraits<_Ty>::_Signbit(imag(_Left))) {
+            return conj(_Pow(real(_Left), _Right));
+        } else {
+            return _Pow(real(_Left), _Right);
+        }
+    } else {
+        return exp(_Right * log(_Left));
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> pow(const _Ty& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    if (imag(_Right) == 0) {
+        return _Pow(_Left, real(_Right));
+    } else if (0 < _Left) {
+        return exp(_Right * _Ctraits<_Ty>::log(_Left));
+    } else {
+        return exp(_Right * log(complex<_Ty>(_Left)));
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> pow(const complex<_Ty>& _Left, const complex<_Ty>& _Right)
+    noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    if (imag(_Right) == 0) {
+        return pow(_Left, real(_Right));
+    } else if (imag(_Left) == 0 && 0 < real(_Left)) {
+        return exp(_Right * _Ctraits<_Ty>::log(real(_Left)));
+    } else {
+        return exp(_Right * log(_Left));
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> sinh(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return complex<_Ty>(_Ctraits<_Ty>::_Sinh(real(_Left), _Ctraits<_Ty>::cos(imag(_Left))),
+        _Ctraits<_Ty>::_Cosh(real(_Left), _Ctraits<_Ty>::sin(imag(_Left))));
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> sqrt(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    int _Leftexp;
+    _Ty _Rho = _Fabs(_Left, &_Leftexp); // get magnitude and scale factor
+
+    if (_Leftexp == 0) {
+        // argument is zero, INF, or NaN
+        if (_Rho == 0) {
+            return complex<_Ty>(_Ty{0}, imag(_Left));
+        } else if (_Ctraits<_Ty>::_Isinf(_Rho)) {
+            const _Ty _Re = real(_Left);
+            const _Ty _Im = imag(_Left);
+
+            if (_Ctraits<_Ty>::_Isinf(_Im)) {
+                return complex<_Ty>(_Ctraits<_Ty>::_Infv(), _Im); // (any, +/-Inf)
+            } else if (_Ctraits<_Ty>::_Isnan(_Im)) {
+                if (_Re < 0) {
+                    return complex<_Ty>(_Ctraits<_Ty>::_Abs(_Im), _Ctraits<_Ty>::_Copysign(_Re, _Im)); // (-Inf, NaN)
+                } else {
+                    return _Left; // (+Inf, NaN)
+                }
+            } else {
+                if (_Re < 0) {
+                    return complex<_Ty>(_Ty{0}, _Ctraits<_Ty>::_Copysign(_Re, _Im)); // (-Inf, finite)
+                } else {
+                    return complex<_Ty>(_Re, _Ctraits<_Ty>::_Copysign(_Ty{0}, _Im)); // (+Inf, finite)
+                }
+            }
+        } else {
+            return complex<_Ty>(_Rho, _Rho);
+        }
+    } else { // compute in safest quadrant
+        _Ty _Realmag = _Ctraits<_Ty>::ldexp(_Ctraits<_Ty>::_Abs(real(_Left)), -_Leftexp);
+        _Rho         = _Ctraits<_Ty>::ldexp(_Ctraits<_Ty>::sqrt(2 * (_Realmag + _Rho)), _Leftexp / 2 - 1);
+
+        if (0 <= real(_Left)) {
+            return complex<_Ty>(_Rho, imag(_Left) / (2 * _Rho));
+        } else {
+            return complex<_Ty>(
+                _Ctraits<_Ty>::_Abs(imag(_Left) / (2 * _Rho)), _Ctraits<_Ty>::_Copysign(_Rho, imag(_Left)));
+        }
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> tanh(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    _Ty _Tv = _Ctraits<_Ty>::tan(imag(_Left));
+    _Ty _Sv = _Ctraits<_Ty>::_Sinh(real(_Left), _Ty{1});
+    _Ty _Bv = _Sv * (_Ty{1} + _Tv * _Tv);
+    _Ty _Dv = _Ty{1} + _Bv * _Sv;
+
+    if (_Ctraits<_Ty>::_Isinf(_Dv)) {
+        _Ty _Real;
+
+        if (_Sv < _Ty{0}) {
+            _Real = -_Ty{1};
+        } else {
+            _Real = _Ty{1};
+        }
+
+        return complex<_Ty>(_Real, _Tv * _Ty{0});
+    }
+
+    return complex<_Ty>((_Ctraits<_Ty>::sqrt(_Ty{1} + _Sv * _Sv)) * _Bv / _Dv, _Tv / _Dv);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Ty arg(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    // return phase angle of complex as real
+    return _Ctraits<_Ty>::atan2(imag(_Left), real(_Left));
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 complex<_Ty> conj(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    // return complex conjugate
+    return complex<_Ty>(real(_Left), -imag(_Left));
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> proj(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    // return complex projection
+    if (_Ctraits<_Ty>::_Isinf(real(_Left)) || _Ctraits<_Ty>::_Isinf(imag(_Left))) {
+        const _Ty _Imag = _Ctraits<_Ty>::_Copysign(_Ty{0}, imag(_Left));
+        return complex<_Ty>(_Ctraits<_Ty>::_Infv(), _Imag);
+    }
+
+    return _Left;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> cos(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return complex<_Ty>(_Ctraits<_Ty>::_Cosh(imag(_Left), _Ctraits<_Ty>::cos(real(_Left))),
+        -_Ctraits<_Ty>::_Sinh(imag(_Left), _Ctraits<_Ty>::sin(real(_Left))));
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> log10(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return log(_Left) * static_cast<_Ty>(0.43429448190325182765112891891660508L);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 _Ty norm(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    // return squared magnitude
+    return real(_Left) * real(_Left) + imag(_Left) * imag(_Left);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> polar(const _Ty& _Rho, const _Ty& _Theta) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    // return _Rho * exp(i * _Theta) as complex
+    if (!_Ctraits<_Ty>::_Isnan(_Rho) && !_Ctraits<_Ty>::_Isinf(_Rho) && _Rho != _Ty{0}) { // _Rho is finite non-zero
+        return complex<_Ty>(_Rho * _Ctraits<_Ty>::cos(_Theta), _Rho * _Ctraits<_Ty>::sin(_Theta));
+    }
+
+    // _Rho is NaN/Inf/0
+    if (_Ctraits<_Ty>::_Signbit(_Rho)) {
+        return -_Polar_positive_nan_inf_zero_rho(-_Rho, _Theta);
+    } else {
+        return _Polar_positive_nan_inf_zero_rho(_Rho, _Theta);
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> polar(const _Ty& _Rho) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    // return _Rho * exp(i * 0) as complex
+    return complex<_Ty>(_Rho, _Ty{0});
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> sin(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    return complex<_Ty>(_Ctraits<_Ty>::_Cosh(imag(_Left), _Ctraits<_Ty>::sin(real(_Left))),
+        _Ctraits<_Ty>::_Sinh(imag(_Left), _Ctraits<_Ty>::cos(real(_Left))));
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD complex<_Ty> tan(const complex<_Ty>& _Left) noexcept(_Is_unqual_fp<_Ty>) /* strengthened */ {
+    complex<_Ty> _Zv(tanh(complex<_Ty>(-imag(_Left), real(_Left))));
+    return complex<_Ty>(imag(_Zv), -real(_Zv));
+}
+
+template <class _Ty>
+using _Upgrade_to_double = conditional_t<is_integral_v<_Ty>, double, _Ty>;
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_NODISCARD _Upgrade_to_double<_Ty> arg(_Ty _Left) noexcept /* strengthened */ {
+    using _Upgraded = _Upgrade_to_double<_Ty>;
+    const auto _Val = static_cast<_Upgraded>(_Left);
+
+    return _Ctraits<_Upgraded>::atan2(0, _Val);
+}
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_NODISCARD _CONSTEXPR20 _Upgrade_to_double<_Ty> imag(_Ty) noexcept /* strengthened */ {
+    return 0;
+}
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_NODISCARD _CONSTEXPR20 _Upgrade_to_double<_Ty> real(_Ty _Left) noexcept /* strengthened */ {
+    using _Upgraded = _Upgrade_to_double<_Ty>;
+    const auto _Val = static_cast<_Upgraded>(_Left);
+
+    return _Val;
+}
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_NODISCARD _CONSTEXPR20 _Upgrade_to_double<_Ty> norm(_Ty _Left) noexcept /* strengthened */ {
+    using _Upgraded = _Upgrade_to_double<_Ty>;
+    const auto _Val = static_cast<_Upgraded>(_Left);
+
+    return _Val * _Val;
+}
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_NODISCARD _CONSTEXPR20 complex<_Upgrade_to_double<_Ty>> conj(_Ty _Left) noexcept /* strengthened */ {
+    using _Upgraded = _Upgrade_to_double<_Ty>;
+    const auto _Val = static_cast<_Upgraded>(_Left);
+
+    return complex<_Upgraded>(_Val, -_Upgraded{0});
+}
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
+_NODISCARD complex<_Upgrade_to_double<_Ty>> proj(_Ty _Left) noexcept /* strengthened */ {
+    using _Upgraded = _Upgrade_to_double<_Ty>;
+    const auto _Val = static_cast<_Upgraded>(_Left);
+
+    if (_Ctraits<_Upgraded>::_Isinf(_Val)) {
+        // C11 7.3.9.5/2: "z projects to z except that all complex infinities [...]
+        // project to positive infinity on the real axis."
+        return complex<_Upgraded>(_Ctraits<_Upgraded>::_Infv(), 0);
+    }
+
+    return complex<_Upgraded>(_Val, 0);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const complex<_Ty1>& _Left, const complex<_Ty2>& _Right)
+    noexcept(_Is_unqual_fp<_Ty1> && _Is_unqual_fp<_Ty2>) /* strengthened */ {
+    using _Type = complex<_Common_float_type_t<_Ty1, _Ty2>>;
+    return _STD pow(_Type(_Left), _Type(_Right));
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty2>, int> = 0>
+_NODISCARD complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const complex<_Ty1>& _Left, const _Ty2& _Right)
+    noexcept(_Is_unqual_fp<_Ty1>) /* strengthened */ {
+    using _Promoted = _Common_float_type_t<_Ty1, _Ty2>;
+    using _Type     = complex<_Promoted>;
+    return _STD pow(_Type(_Left), _Type(static_cast<_Promoted>(_Right)));
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1>, int> = 0>
+_NODISCARD complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const _Ty1& _Left, const complex<_Ty2>& _Right)
+    noexcept(_Is_unqual_fp<_Ty2>) /* strengthened */ {
+    using _Promoted = _Common_float_type_t<_Ty1, _Ty2>;
+    using _Type     = complex<_Promoted>;
+    return _STD pow(_Type(static_cast<_Promoted>(_Left)), _Type(_Right));
+}
+
+_EXPORT_STD template <class _Ty, class _Elem, class _Tr>
+basic_istream<_Elem, _Tr>& operator>>(basic_istream<_Elem, _Tr>& _Istr, complex<_Ty>& _Right) {
+    const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Istr.getloc());
+    _Elem _Ch                      = 0;
+    long double _Real              = 0;
+    long double _Imag              = 0;
+
+    if (_Istr >> _Ch && _Ch != _Ctype_fac.widen('(')) { // no leading '(', treat as real only
+        _Istr.putback(_Ch);
+        _Istr >> _Real;
+        _Imag = 0;
+    } else if (_Istr >> _Real >> _Ch && _Ch != _Ctype_fac.widen(',')) {
+        if (_Ch == _Ctype_fac.widen(')')) {
+            _Imag = 0; // (real)
+        } else { // no trailing ')' after real, treat as bad field
+            _Istr.putback(_Ch);
+            _Istr.setstate(ios_base::failbit);
+        }
+    } else if (_Istr >> _Imag >> _Ch && _Ch != _Ctype_fac.widen(')')) { // no imag or trailing ')', treat as bad field
+        _Istr.putback(_Ch);
+        _Istr.setstate(ios_base::failbit);
+    }
+
+    if (!_Istr.fail()) { // store valid result
+        _Ty _Tyreal(static_cast<_Ty>(_Real)), _Tyimag(static_cast<_Ty>(_Imag));
+        _Right = complex<_Ty>(_Tyreal, _Tyimag);
+    }
+    return _Istr;
+}
+
+_EXPORT_STD template <class _Ty, class _Elem, class _Tr>
+basic_ostream<_Elem, _Tr>& operator<<(basic_ostream<_Elem, _Tr>& _Ostr, const complex<_Ty>& _Right) {
+    const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Ostr.getloc());
+    basic_ostringstream<_Elem, _Tr, allocator<_Elem>> _Sstr;
+
+    _Sstr.flags(_Ostr.flags());
+    _Sstr.imbue(_Ostr.getloc());
+    _Sstr.precision(_Ostr.precision());
+    _Sstr << _Ctype_fac.widen('(') << real(_Right) << _Ctype_fac.widen(',') << imag(_Right) << _Ctype_fac.widen(')');
+
+    return _Ostr << _Sstr.str();
+}
+
+inline namespace literals {
+    inline namespace complex_literals {
+        _EXPORT_STD _NODISCARD constexpr complex<long double> operator""il(long double _Val) noexcept
+        /* strengthened */ {
+            return complex<long double>(0.0L, static_cast<long double>(_Val));
+        }
+
+        _EXPORT_STD _NODISCARD constexpr complex<long double> operator""il(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return complex<long double>(0.0L, static_cast<long double>(_Val));
+        }
+
+        _EXPORT_STD _NODISCARD constexpr complex<double> operator""i(long double _Val) noexcept /* strengthened */ {
+            return complex<double>(0.0, static_cast<double>(_Val));
+        }
+
+        _EXPORT_STD _NODISCARD constexpr complex<double> operator""i(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return complex<double>(0.0, static_cast<double>(_Val));
+        }
+
+        _EXPORT_STD _NODISCARD constexpr complex<float> operator""if(long double _Val) noexcept /* strengthened */ {
+            return complex<float>(0.0f, static_cast<float>(_Val));
+        }
+
+        _EXPORT_STD _NODISCARD constexpr complex<float> operator""if(unsigned long long _Val) noexcept
+        /* strengthened */ {
+            return complex<float>(0.0f, static_cast<float>(_Val));
+        }
+    } // namespace complex_literals
+} // namespace literals
+
+_STD_END
+
+#undef _RE
+#undef _IM
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _COMPLEX_
diff --git a/msvc-stl/stl/inc/concepts b/msvc-stl/stl/inc/concepts
new file mode 100644
index 0000000..1486abc
--- /dev/null
+++ b/msvc-stl/stl/inc/concepts
@@ -0,0 +1,277 @@
+// concepts standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CONCEPTS_
+#define _CONCEPTS_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <concepts> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+#include <type_traits>
+#include <vcruntime_new.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Ty1, class _Ty2>
+concept _Same_impl = // Must be a distinct concept to provide symmetric subsumption for same_as
+#ifdef __clang__
+    __is_same(_Ty1, _Ty2);
+#else // ^^^ use intrinsic / no intrinsic vvv
+    is_same_v<_Ty1, _Ty2>;
+#endif // ^^^ no intrinsic ^^^
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+concept same_as = _Same_impl<_Ty1, _Ty2> && _Same_impl<_Ty2, _Ty1>;
+
+_EXPORT_STD template <class _Derived, class _Base>
+concept derived_from =
+    __is_base_of(_Base, _Derived) && __is_convertible_to(const volatile _Derived*, const volatile _Base*);
+
+template <class _From, class _To>
+concept _Implicitly_convertible_to = is_convertible_v<_From, _To>;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+concept common_reference_with =
+    requires {
+        typename common_reference_t<_Ty1, _Ty2>;
+        typename common_reference_t<_Ty2, _Ty1>;
+    } && same_as<common_reference_t<_Ty1, _Ty2>, common_reference_t<_Ty2, _Ty1>>
+    && convertible_to<_Ty1, common_reference_t<_Ty1, _Ty2>> && convertible_to<_Ty2, common_reference_t<_Ty1, _Ty2>>;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+concept common_with =
+    requires {
+        typename common_type_t<_Ty1, _Ty2>;
+        typename common_type_t<_Ty2, _Ty1>;
+    } //
+    && same_as<common_type_t<_Ty1, _Ty2>, common_type_t<_Ty2, _Ty1>> //
+    && requires {
+        static_cast<common_type_t<_Ty1, _Ty2>>(_STD declval<_Ty1>());
+        static_cast<common_type_t<_Ty1, _Ty2>>(_STD declval<_Ty2>());
+    } //
+    && common_reference_with<add_lvalue_reference_t<const _Ty1>, add_lvalue_reference_t<const _Ty2>> //
+    && common_reference_with<add_lvalue_reference_t<common_type_t<_Ty1, _Ty2>>,
+        common_reference_t<add_lvalue_reference_t<const _Ty1>, add_lvalue_reference_t<const _Ty2>>>;
+
+_EXPORT_STD template <class _Ty>
+concept integral = is_integral_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+concept signed_integral = integral<_Ty> && static_cast<_Ty>(-1) < static_cast<_Ty>(0);
+
+_EXPORT_STD template <class _Ty>
+concept unsigned_integral = integral<_Ty> && !signed_integral<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+concept floating_point = is_floating_point_v<_Ty>;
+
+_EXPORT_STD template <class _LTy, class _RTy>
+concept assignable_from = is_lvalue_reference_v<_LTy>
+                       && common_reference_with<const remove_reference_t<_LTy>&, const remove_reference_t<_RTy>&>
+                       && requires(_LTy _Left, _RTy&& _Right) {
+                              { _Left = static_cast<_RTy&&>(_Right) } -> same_as<_LTy>;
+                          };
+
+// swappable and swappable_with are defined below, since they depend on move_constructible.
+
+_EXPORT_STD template <class _Ty>
+concept destructible = __is_nothrow_destructible(_Ty);
+
+_EXPORT_STD template <class _Ty, class... _ArgTys>
+concept constructible_from = destructible<_Ty> && __is_constructible(_Ty, _ArgTys...);
+
+_EXPORT_STD template <class _Ty>
+concept default_initializable = constructible_from<_Ty> && requires {
+    _Ty{};
+    ::new (static_cast<void*>(nullptr)) _Ty; // is-default-initializable<_Ty>
+};
+
+_EXPORT_STD template <class _Ty>
+concept move_constructible = constructible_from<_Ty, _Ty> && convertible_to<_Ty, _Ty>;
+
+template <class _Ty>
+concept _Has_class_or_enum_type =
+    __is_class(remove_reference_t<_Ty>) || __is_enum(remove_reference_t<_Ty>) || __is_union(remove_reference_t<_Ty>);
+
+namespace ranges {
+    namespace _Swap {
+        template <class _Ty>
+        void swap(_Ty&, _Ty&) = delete;
+
+        template <class _Ty1, class _Ty2>
+        concept _Use_ADL_swap =
+            (_Has_class_or_enum_type<_Ty1> || _Has_class_or_enum_type<_Ty2>) && requires(_Ty1&& __t, _Ty2&& __u) {
+                swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u)); // intentional ADL
+            };
+
+        struct _Cpo {
+            template <class _Ty1, class _Ty2>
+                requires _Use_ADL_swap<_Ty1, _Ty2>
+            static constexpr void operator()(_Ty1&& __t, _Ty2&& __u)
+                noexcept(noexcept(swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u)))) { // intentional ADL
+                swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u)); // intentional ADL
+            }
+
+            template <class _Ty>
+                requires (!_Use_ADL_swap<_Ty&, _Ty&> && move_constructible<_Ty> && assignable_from<_Ty&, _Ty>)
+            static constexpr void operator()(_Ty& __x, _Ty& __y)
+                noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>) {
+                _Ty __tmp(static_cast<_Ty&&>(__x));
+                __x = static_cast<_Ty&&>(__y);
+                __y = static_cast<_Ty&&>(__tmp);
+            }
+
+            template <class _Ty1, class _Ty2, size_t _Size>
+            static constexpr void operator()(_Ty1 (&__t)[_Size], _Ty2 (&__u)[_Size])
+                noexcept(noexcept(operator()(__t[0], __u[0])))
+                requires requires(_Cpo __fn) { __fn(__t[0], __u[0]); }
+            {
+                if constexpr (is_same_v<_Ty1, _Ty2> && _Is_trivially_swappable_v<_Ty1>) {
+                    if (!_STD is_constant_evaluated()) {
+                        _STD _Swap_trivial_arrays(__t, __u);
+                        return;
+                    }
+                }
+
+                for (size_t __i = 0; __i < _Size; ++__i) {
+                    operator()(__t[__i], __u[__i]);
+                }
+            }
+        };
+    } // namespace _Swap
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Swap::_Cpo swap;
+    }
+} // namespace ranges
+
+_EXPORT_STD template <class _Ty>
+concept swappable = requires(_Ty& __x, _Ty& __y) { _RANGES swap(__x, __y); };
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+concept swappable_with = common_reference_with<_Ty1, _Ty2> && requires(_Ty1&& __t, _Ty2&& __u) {
+    _RANGES swap(static_cast<_Ty1&&>(__t), static_cast<_Ty1&&>(__t));
+    _RANGES swap(static_cast<_Ty2&&>(__u), static_cast<_Ty2&&>(__u));
+    _RANGES swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u));
+    _RANGES swap(static_cast<_Ty2&&>(__u), static_cast<_Ty1&&>(__t));
+};
+
+_EXPORT_STD template <class _Ty>
+concept copy_constructible = move_constructible<_Ty> && constructible_from<_Ty, _Ty&> && convertible_to<_Ty&, _Ty>
+                          && constructible_from<_Ty, const _Ty&> && convertible_to<const _Ty&, _Ty>
+                          && constructible_from<_Ty, const _Ty> && convertible_to<const _Ty, _Ty>;
+
+template <class _Ty>
+concept _Boolean_testable_impl = convertible_to<_Ty, bool>;
+
+template <class _Ty>
+concept _Boolean_testable = _Boolean_testable_impl<_Ty> && requires(_Ty&& __t) {
+    { !static_cast<_Ty&&>(__t) } -> _Boolean_testable_impl;
+};
+
+template <class _Ty1, class _Ty2>
+concept _Half_equality_comparable = requires(const remove_reference_t<_Ty1>& __x, const remove_reference_t<_Ty2>& __y) {
+    { __x == __y } -> _Boolean_testable;
+    { __x != __y } -> _Boolean_testable;
+};
+
+template <class _Ty1, class _Ty2>
+concept _Weakly_equality_comparable_with =
+    _Half_equality_comparable<_Ty1, _Ty2> && _Half_equality_comparable<_Ty2, _Ty1>;
+
+_EXPORT_STD template <class _Ty>
+concept equality_comparable = _Half_equality_comparable<_Ty, _Ty>;
+
+template <class _Ty1, class _Ty2, class _Ref = common_reference_t<const _Ty1&, const _Ty2&>>
+concept _Comparison_common_type_with_impl = same_as<_Ref, common_reference_t<const _Ty2&, const _Ty1&>> && requires {
+    requires convertible_to<const _Ty1&, const _Ref&> || convertible_to<_Ty1, const _Ref&>;
+    requires convertible_to<const _Ty2&, const _Ref&> || convertible_to<_Ty2, const _Ref&>;
+};
+
+template <class _Ty1, class _Ty2>
+concept _Comparison_common_type_with = _Comparison_common_type_with_impl<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>>;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+concept equality_comparable_with =
+    equality_comparable<_Ty1> && equality_comparable<_Ty2> && _Comparison_common_type_with<_Ty1, _Ty2>
+    && equality_comparable<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>>
+    && _Weakly_equality_comparable_with<_Ty1, _Ty2>;
+
+template <class _Ty1, class _Ty2>
+concept _Half_ordered = requires(const remove_reference_t<_Ty1>& __t, const remove_reference_t<_Ty2>& __u) {
+    { __t < __u } -> _Boolean_testable;
+    { __t > __u } -> _Boolean_testable;
+    { __t <= __u } -> _Boolean_testable;
+    { __t >= __u } -> _Boolean_testable;
+};
+
+template <class _Ty1, class _Ty2>
+concept _Partially_ordered_with = _Half_ordered<_Ty1, _Ty2> && _Half_ordered<_Ty2, _Ty1>;
+
+_EXPORT_STD template <class _Ty>
+concept totally_ordered = equality_comparable<_Ty> && _Half_ordered<_Ty, _Ty>;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+concept totally_ordered_with =
+    totally_ordered<_Ty1> && totally_ordered<_Ty2> && equality_comparable_with<_Ty1, _Ty2>
+    && totally_ordered<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>>
+    && _Partially_ordered_with<_Ty1, _Ty2>;
+
+_EXPORT_STD template <class _Ty>
+concept movable = is_object_v<_Ty> && move_constructible<_Ty> && assignable_from<_Ty&, _Ty> && swappable<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+concept copyable = copy_constructible<_Ty> && movable<_Ty> && assignable_from<_Ty&, _Ty&>
+                && assignable_from<_Ty&, const _Ty&> && assignable_from<_Ty&, const _Ty>;
+
+_EXPORT_STD template <class _Ty>
+concept semiregular = copyable<_Ty> && default_initializable<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+concept regular = semiregular<_Ty> && equality_comparable<_Ty>;
+
+_EXPORT_STD template <class _FTy, class... _ArgTys>
+concept invocable = requires(
+    _FTy&& _Fn, _ArgTys&&... _Args) { _STD invoke(static_cast<_FTy&&>(_Fn), static_cast<_ArgTys&&>(_Args)...); };
+
+_EXPORT_STD template <class _FTy, class... _ArgTys>
+concept regular_invocable = invocable<_FTy, _ArgTys...>;
+
+_EXPORT_STD template <class _FTy, class... _ArgTys>
+concept predicate = regular_invocable<_FTy, _ArgTys...> && _Boolean_testable<invoke_result_t<_FTy, _ArgTys...>>;
+
+_EXPORT_STD template <class _FTy, class _Ty1, class _Ty2>
+concept relation = predicate<_FTy, _Ty1, _Ty1> && predicate<_FTy, _Ty2, _Ty2> && predicate<_FTy, _Ty1, _Ty2>
+                && predicate<_FTy, _Ty2, _Ty1>;
+
+_EXPORT_STD template <class _FTy, class _Ty1, class _Ty2>
+concept equivalence_relation = relation<_FTy, _Ty1, _Ty2>;
+
+_EXPORT_STD template <class _FTy, class _Ty1, class _Ty2>
+concept strict_weak_order = relation<_FTy, _Ty1, _Ty2>;
+
+template <class _Ty>
+struct _Choice_t {
+    _Ty _Strategy  = _Ty{};
+    bool _No_throw = false;
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _HAS_CXX20
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CONCEPTS_
diff --git a/msvc-stl/stl/inc/condition_variable b/msvc-stl/stl/inc/condition_variable
new file mode 100644
index 0000000..5fbad37
--- /dev/null
+++ b/msvc-stl/stl/inc/condition_variable
@@ -0,0 +1,254 @@
+// condition_variable standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CONDITION_VARIABLE_
+#define _CONDITION_VARIABLE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <condition_variable> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#include <__msvc_chrono.hpp>
+#include <memory>
+#include <mutex>
+#include <xthreads.h>
+
+#if _HAS_CXX20
+#include <stop_token>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Lock>
+struct _NODISCARD _Unlock_guard {
+    explicit _Unlock_guard(_Lock& _Mtx_) : _Mtx(_Mtx_) {
+        _Mtx.unlock();
+    }
+
+    ~_Unlock_guard() noexcept /* terminates */ {
+        // relock mutex or terminate()
+        // condition_variable_any wait functions are required to terminate if
+        // the mutex cannot be relocked;
+        // we slam into noexcept here for easier user debugging.
+        _Mtx.lock();
+    }
+
+    _Unlock_guard(const _Unlock_guard&)            = delete;
+    _Unlock_guard& operator=(const _Unlock_guard&) = delete;
+
+private:
+    _Lock& _Mtx;
+};
+
+_EXPORT_STD class condition_variable_any { // class for waiting for conditions with any kind of mutex
+public:
+    condition_variable_any() : _Myptr{_STD make_shared<mutex>()} {
+#ifdef _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR
+        _Cnd_init_in_situ(_Mycnd());
+#endif // ^^^ defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) ^^^
+    }
+
+    ~condition_variable_any() noexcept = default;
+
+    condition_variable_any(const condition_variable_any&)            = delete;
+    condition_variable_any& operator=(const condition_variable_any&) = delete;
+
+    void notify_one() noexcept { // wake up one waiter
+        lock_guard<mutex> _Guard{*_Myptr};
+        _Cnd_signal(_Mycnd());
+    }
+
+    void notify_all() noexcept { // wake up all waiters
+        lock_guard<mutex> _Guard{*_Myptr};
+        _Cnd_broadcast(_Mycnd());
+    }
+
+    template <class _Lock>
+    void wait(_Lock& _Lck) noexcept /* terminates */ { // wait for signal
+        const shared_ptr<mutex> _Ptr = _Myptr; // for immunity to *this destruction
+        unique_lock<mutex> _Guard{*_Ptr};
+        _Unlock_guard<_Lock> _Unlock_outer{_Lck};
+        _Cnd_wait(_Mycnd(), _Ptr->_Mymtx());
+        _Guard.unlock();
+    } // relock _Lck
+
+    template <class _Lock, class _Predicate>
+    void wait(_Lock& _Lck, _Predicate _Pred) noexcept(noexcept(static_cast<bool>(_Pred()))) /* strengthened */ {
+        // wait for signal and check predicate
+        while (!static_cast<bool>(_Pred())) {
+            wait(_Lck);
+        }
+    }
+
+    template <class _Lock, class _Clock, class _Duration>
+    cv_status wait_until(_Lock& _Lck, const chrono::time_point<_Clock, _Duration> _Abs_time) {
+        // wait until time point
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        const auto _Now                  = _Clock::now();
+        using _Common_duration           = decltype(_Abs_time - _Now);
+        const _Common_duration _Rel_time = (_Abs_time <= _Now) ? _Common_duration::zero() : _Abs_time - _Now;
+        return wait_for(_Lck, _Rel_time);
+    }
+
+    template <class _Lock, class _Clock, class _Duration, class _Predicate>
+    bool wait_until(_Lock& _Lck, const chrono::time_point<_Clock, _Duration> _Abs_time, _Predicate _Pred) {
+        // wait for signal with timeout and check predicate
+#if _HAS_CXX20
+        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
+#endif // _HAS_CXX20
+        while (!_Pred()) {
+            if (wait_until(_Lck, _Abs_time) == cv_status::timeout) {
+                return _Pred();
+            }
+        }
+
+        return true;
+    }
+
+    template <class _Lock, class _Rep, class _Period>
+    cv_status wait_for(_Lock& _Lck, const chrono::duration<_Rep, _Period> _Rel_time) { // wait for duration
+        if (_Rel_time <= chrono::duration<_Rep, _Period>::zero()) {
+            _Unlock_guard<_Lock> _Unlock_outer{_Lck};
+            (void) _Unlock_outer;
+            return cv_status::timeout;
+        }
+
+        const auto _Rel_time_ms = _Clamped_rel_time_ms_count(_Rel_time);
+
+        // wait for signal with timeout
+        const shared_ptr<mutex> _Ptr = _Myptr; // for immunity to *this destruction
+        const auto _Start            = _CHRONO steady_clock::now();
+        const auto _Target           = _Start + _Rel_time;
+
+        unique_lock<mutex> _Guard{*_Ptr};
+        _Unlock_guard<_Lock> _Unlock_outer{_Lck};
+        const _Thrd_result _Res = _Cnd_timedwait_for_unchecked(_Mycnd(), _Ptr->_Mymtx(), _Rel_time_ms._Count);
+        _Guard.unlock();
+
+        if (_Res == _Thrd_result::_Success) {
+            return cv_status::no_timeout; // Real or WinAPI-internal spurious wake
+        } else if (_Rel_time_ms._Clamped) {
+            return cv_status::no_timeout; // Spuriously wake due to clamped timeout
+        } else if (_CHRONO steady_clock::now() < _Target) {
+            return cv_status::no_timeout; // Spuriously wake due to premature timeout
+        } else {
+            return cv_status::timeout;
+        }
+    }
+
+    template <class _Lock, class _Rep, class _Period, class _Predicate>
+    bool wait_for(_Lock& _Lck, const chrono::duration<_Rep, _Period> _Rel_time, _Predicate _Pred) {
+        // wait for signal with timeout and check predicate
+        return wait_until(_Lck, _To_absolute_time(_Rel_time), _STD move(_Pred));
+    }
+
+#if _HAS_CXX20
+private:
+    struct _Cv_any_notify_all {
+        condition_variable_any* _This;
+
+        explicit _Cv_any_notify_all(condition_variable_any* _This_) noexcept : _This{_This_} {}
+
+        _Cv_any_notify_all(const _Cv_any_notify_all&)            = delete;
+        _Cv_any_notify_all& operator=(const _Cv_any_notify_all&) = delete;
+
+        void operator()() const noexcept {
+            _This->notify_all();
+        }
+    };
+
+public:
+    template <class _Lock, class _Predicate>
+    bool wait(_Lock& _Lck, stop_token _Stoken, _Predicate _Pred)
+        noexcept(noexcept(static_cast<bool>(_Pred()))) /* strengthened */ {
+        // TRANSITION, ABI: Due to the unsynchronized delivery of notify_all by _Stoken,
+        // this implementation cannot tolerate *this destruction while an interruptible wait
+        // is outstanding. A future ABI should store both the internal CV and internal mutex
+        // in the reference counted block to allow this.
+        stop_callback<_Cv_any_notify_all> _Cb{_Stoken, this};
+        for (;;) {
+            if (_Pred()) {
+                return true;
+            }
+
+            unique_lock<mutex> _Guard{*_Myptr};
+            if (_Stoken.stop_requested()) {
+                _Guard.unlock();
+                return _Pred();
+            }
+
+            _Unlock_guard<_Lock> _Unlock_outer{_Lck};
+            _Cnd_wait(_Mycnd(), _Myptr->_Mymtx());
+            _Guard.unlock();
+        } // relock
+    }
+
+    template <class _Lock, class _Clock, class _Duration, class _Predicate>
+    bool wait_until(
+        _Lock& _Lck, stop_token _Stoken, const chrono::time_point<_Clock, _Duration> _Abs_time, _Predicate _Pred) {
+        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
+        stop_callback<_Cv_any_notify_all> _Cb{_Stoken, this};
+        for (;;) {
+            if (_Pred()) {
+                return true;
+            }
+
+            unique_lock<mutex> _Guard{*_Myptr};
+            if (_Stoken.stop_requested()) {
+                break;
+            }
+
+            _Unlock_guard<_Lock> _Unlock_outer{_Lck};
+            unique_lock<mutex> _Guard_unlocks_before_locking_outer{_STD move(_Guard)};
+
+            const auto _Now = _Clock::now();
+            if (_Now >= _Abs_time) {
+                break;
+            }
+
+            const unsigned long _Rel_ms_count = _Clamped_rel_time_ms_count(_Abs_time - _Now)._Count;
+            (void) _Cnd_timedwait_for_unchecked(_Mycnd(), _Myptr->_Mymtx(), _Rel_ms_count);
+            _Guard_unlocks_before_locking_outer.unlock();
+        } // relock
+
+        return _Pred();
+    }
+
+    template <class _Lock, class _Rep, class _Period, class _Predicate>
+    bool wait_for(_Lock& _Lck, stop_token _Stoken, const chrono::duration<_Rep, _Period> _Rel_time, _Predicate _Pred) {
+        return wait_until(_Lck, _STD move(_Stoken), _To_absolute_time(_Rel_time), _STD move(_Pred));
+    }
+#endif // _HAS_CXX20
+
+private:
+    shared_ptr<mutex> _Myptr;
+
+    _Cnd_internal_imp_t _Cnd_storage{};
+
+    _NODISCARD _Cnd_t _Mycnd() noexcept {
+        return &_Cnd_storage;
+    }
+};
+
+_EXPORT_STD inline void notify_all_at_thread_exit(condition_variable& _Cnd, unique_lock<mutex> _Lck) noexcept
+/* strengthened */ {
+    // register _Cnd for release at thread exit
+    _Cnd._Register(_Lck, nullptr);
+}
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CONDITION_VARIABLE_
diff --git a/msvc-stl/stl/inc/coroutine b/msvc-stl/stl/inc/coroutine
new file mode 100644
index 0000000..701dcc6
--- /dev/null
+++ b/msvc-stl/stl/inc/coroutine
@@ -0,0 +1,272 @@
+// coroutine standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _COROUTINE_
+#define _COROUTINE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _RESUMABLE_FUNCTIONS_SUPPORTED
+_EMIT_STL_WARNING(STL4039, "The <coroutine> header is incompatible with the deprecated /await compiler option.");
+#elif !defined(__cpp_lib_coroutine)
+_EMIT_STL_WARNING(STL4038, "The contents of <coroutine> are available only with C++20 or later "
+                           "(or /await:strict in C++14/17).");
+#else // ^^^ <coroutine> is not available / <coroutine> is available vvv
+#ifndef _ALLOW_COROUTINE_ABI_MISMATCH
+#pragma detect_mismatch("_COROUTINE_ABI", "2")
+#endif // !defined(_ALLOW_COROUTINE_ABI_MISMATCH)
+
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+
+template <class _Ret, class = void>
+struct _Coroutine_traits {};
+
+template <class _Ret>
+struct _Coroutine_traits<_Ret, void_t<typename _Ret::promise_type>> {
+    using promise_type = typename _Ret::promise_type;
+};
+
+_EXPORT_STD template <class _Ret, class...>
+struct coroutine_traits : _Coroutine_traits<_Ret> {};
+
+_EXPORT_STD template <class = void>
+struct _NO_SPECIALIZATIONS_CITING("N5014 [coroutine.handle.general]/2") coroutine_handle;
+
+template <>
+struct coroutine_handle<void> {
+    constexpr coroutine_handle() noexcept = default;
+    constexpr coroutine_handle(nullptr_t) noexcept {}
+
+    coroutine_handle& operator=(nullptr_t) noexcept {
+        _Ptr = nullptr;
+        return *this;
+    }
+
+    _NODISCARD constexpr void* address() const noexcept {
+        return _Ptr;
+    }
+
+    _NODISCARD static constexpr coroutine_handle from_address(void* const _Addr) noexcept { // strengthened
+        coroutine_handle _Result;
+        _Result._Ptr = _Addr;
+        return _Result;
+    }
+
+    constexpr explicit operator bool() const noexcept {
+        return _Ptr != nullptr;
+    }
+
+    _NODISCARD bool done() const noexcept { // strengthened
+        return __builtin_coro_done(_Ptr);
+    }
+
+    void operator()() const {
+        __builtin_coro_resume(_Ptr);
+    }
+
+    void resume() const {
+        __builtin_coro_resume(_Ptr);
+    }
+
+    void destroy() const noexcept { // strengthened
+        __builtin_coro_destroy(_Ptr);
+    }
+
+private:
+    void* _Ptr = nullptr;
+};
+
+_EXPORT_STD template <class _CoroPromise>
+struct _NO_SPECIALIZATIONS_CITING("N5014 [coroutine.handle.general]/2") coroutine_handle {
+    constexpr coroutine_handle() noexcept = default;
+    constexpr coroutine_handle(nullptr_t) noexcept {}
+
+    _NODISCARD static coroutine_handle from_promise(_CoroPromise& _Prom) noexcept { // strengthened
+        const auto _Prom_ptr  = const_cast<void*>(static_cast<const volatile void*>(_STD addressof(_Prom)));
+        const auto _Frame_ptr = __builtin_coro_promise(_Prom_ptr, 0, true);
+        coroutine_handle _Result;
+        _Result._Ptr = _Frame_ptr;
+        return _Result;
+    }
+
+    coroutine_handle& operator=(nullptr_t) noexcept {
+        _Ptr = nullptr;
+        return *this;
+    }
+
+    _NODISCARD constexpr void* address() const noexcept {
+        return _Ptr;
+    }
+
+    _NODISCARD static constexpr coroutine_handle from_address(void* const _Addr) noexcept { // strengthened
+        coroutine_handle _Result;
+        _Result._Ptr = _Addr;
+        return _Result;
+    }
+
+    constexpr operator coroutine_handle<>() const noexcept {
+        return coroutine_handle<>::from_address(_Ptr);
+    }
+
+    constexpr explicit operator bool() const noexcept {
+        return _Ptr != nullptr;
+    }
+
+    _NODISCARD bool done() const noexcept { // strengthened
+        return __builtin_coro_done(_Ptr);
+    }
+
+    void operator()() const {
+        __builtin_coro_resume(_Ptr);
+    }
+
+    void resume() const {
+        __builtin_coro_resume(_Ptr);
+    }
+
+    void destroy() const noexcept { // strengthened
+        __builtin_coro_destroy(_Ptr);
+    }
+
+    _NODISCARD _CoroPromise& promise() const noexcept { // strengthened
+        return *reinterpret_cast<_CoroPromise*>(__builtin_coro_promise(_Ptr, 0, false));
+    }
+
+private:
+    void* _Ptr = nullptr;
+};
+
+_EXPORT_STD _NODISCARD constexpr bool operator==(
+    const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
+    return _Left.address() == _Right.address();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(
+    const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
+    return compare_three_way{}(_Left.address(), _Right.address());
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+_NODISCARD constexpr bool operator!=(const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD constexpr bool operator<(const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
+    return less<void*>{}(_Left.address(), _Right.address());
+}
+
+_NODISCARD constexpr bool operator>(const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
+    return _Right < _Left;
+}
+
+_NODISCARD constexpr bool operator<=(const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
+    return !(_Left > _Right);
+}
+
+_NODISCARD constexpr bool operator>=(const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _CoroPromise>
+struct hash<coroutine_handle<_CoroPromise>> {
+    _NODISCARD static size_t operator()(const coroutine_handle<_CoroPromise>& _Coro) noexcept {
+        return _Hash_representation(_Coro.address());
+    }
+};
+
+_EXPORT_STD struct noop_coroutine_promise {};
+
+template <>
+struct coroutine_handle<noop_coroutine_promise> {
+    friend coroutine_handle noop_coroutine() noexcept;
+
+    constexpr operator coroutine_handle<>() const noexcept {
+        return coroutine_handle<>::from_address(_Ptr);
+    }
+
+    constexpr explicit operator bool() const noexcept {
+        return true;
+    }
+    _NODISCARD constexpr bool done() const noexcept {
+        return false;
+    }
+
+    constexpr void operator()() const noexcept {}
+    constexpr void resume() const noexcept {}
+    constexpr void destroy() const noexcept {}
+
+    _NODISCARD noop_coroutine_promise& promise() const noexcept {
+        // Returns a reference to the associated promise
+        return *static_cast<noop_coroutine_promise*>(__builtin_coro_promise(_Ptr, 0, false));
+    }
+
+    _NODISCARD constexpr void* address() const noexcept {
+        return _Ptr;
+    }
+
+private:
+    coroutine_handle() noexcept = default;
+
+    void* _Ptr = __builtin_coro_noop();
+};
+
+_EXPORT_STD using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
+
+_EXPORT_STD _NODISCARD inline noop_coroutine_handle noop_coroutine() noexcept {
+    // Returns a handle to a coroutine that has no observable effects when resumed or destroyed.
+    return noop_coroutine_handle{};
+}
+
+_EXPORT_STD struct suspend_never {
+    _NODISCARD constexpr bool await_ready() const noexcept {
+        return true;
+    }
+
+    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
+    constexpr void await_resume() const noexcept {}
+};
+
+_EXPORT_STD struct suspend_always {
+    _NODISCARD constexpr bool await_ready() const noexcept {
+        return false;
+    }
+
+    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
+    constexpr void await_resume() const noexcept {}
+};
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // ^^^ <coroutine> is available ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _COROUTINE_
diff --git a/msvc-stl/stl/inc/csetjmp b/msvc-stl/stl/inc/csetjmp
new file mode 100644
index 0000000..ab7beb8
--- /dev/null
+++ b/msvc-stl/stl/inc/csetjmp
@@ -0,0 +1,32 @@
+// csetjmp standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSETJMP_
+#define _CSETJMP_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <setjmp.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using ::jmp_buf;
+_EXPORT_STD using ::longjmp;
+using ::setjmp;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSETJMP_
diff --git a/msvc-stl/stl/inc/csignal b/msvc-stl/stl/inc/csignal
new file mode 100644
index 0000000..db46c9c
--- /dev/null
+++ b/msvc-stl/stl/inc/csignal
@@ -0,0 +1,34 @@
+// csignal standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSIGNAL_
+#define _CSIGNAL_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <signal.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD sig_atomic_t;
+_EXPORT_STD using _CSTD raise;
+#ifndef _M_CEE_PURE
+_EXPORT_STD using _CSTD signal;
+#endif // !defined(_M_CEE_PURE)
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSIGNAL_
diff --git a/msvc-stl/stl/inc/cstdalign b/msvc-stl/stl/inc/cstdalign
new file mode 100644
index 0000000..ede4f44
--- /dev/null
+++ b/msvc-stl/stl/inc/cstdalign
@@ -0,0 +1,30 @@
+// cstdalign standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSTDALIGN_
+#define _CSTDALIGN_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#define __alignas_is_defined 1
+#define __alignof_is_defined 1
+
+using _Header_cstdalign _CXX17_DEPRECATE_C_HEADER = int;
+using _Hdr_cstdalign                              = _Header_cstdalign;
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSTDALIGN_
diff --git a/msvc-stl/stl/inc/cstdarg b/msvc-stl/stl/inc/cstdarg
new file mode 100644
index 0000000..88e1d73
--- /dev/null
+++ b/msvc-stl/stl/inc/cstdarg
@@ -0,0 +1,30 @@
+// cstdarg standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSTDARG_
+#define _CSTDARG_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <stdarg.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using ::va_list;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSTDARG_
diff --git a/msvc-stl/stl/inc/cstdbool b/msvc-stl/stl/inc/cstdbool
new file mode 100644
index 0000000..347a43b
--- /dev/null
+++ b/msvc-stl/stl/inc/cstdbool
@@ -0,0 +1,29 @@
+// cstdbool standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSTDBOOL_
+#define _CSTDBOOL_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <stdbool.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+using _Header_cstdbool _CXX17_DEPRECATE_C_HEADER = int;
+using _Hdr_cstdbool                              = _Header_cstdbool;
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSTDBOOL_
diff --git a/msvc-stl/stl/inc/cstddef b/msvc-stl/stl/inc/cstddef
new file mode 100644
index 0000000..fb5fc32
--- /dev/null
+++ b/msvc-stl/stl/inc/cstddef
@@ -0,0 +1,115 @@
+// cstddef standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSTDDEF_
+#define _CSTDDEF_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <stddef.h>
+#include <xtr1common>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("intrinsic")
+#undef msvc
+#undef intrinsic
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD ptrdiff_t;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using max_align_t = double; // most aligned type
+_EXPORT_STD using nullptr_t   = decltype(nullptr);
+
+#ifdef __cpp_lib_byte
+_EXPORT_STD enum class byte : unsigned char {};
+
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+_NODISCARD constexpr byte operator<<(const byte _Arg, const _IntType _Shift) noexcept {
+    // every static_cast is intentional
+    return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(_Arg) << _Shift));
+}
+
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+_NODISCARD constexpr byte operator>>(const byte _Arg, const _IntType _Shift) noexcept {
+    // every static_cast is intentional
+    return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(_Arg) >> _Shift));
+}
+
+_EXPORT_STD _NODISCARD constexpr byte operator|(const byte _Left, const byte _Right) noexcept {
+    // every static_cast is intentional
+    return static_cast<byte>(
+        static_cast<unsigned char>(static_cast<unsigned int>(_Left) | static_cast<unsigned int>(_Right)));
+}
+
+_EXPORT_STD _NODISCARD constexpr byte operator&(const byte _Left, const byte _Right) noexcept {
+    // every static_cast is intentional
+    return static_cast<byte>(
+        static_cast<unsigned char>(static_cast<unsigned int>(_Left) & static_cast<unsigned int>(_Right)));
+}
+
+_EXPORT_STD _NODISCARD constexpr byte operator^(const byte _Left, const byte _Right) noexcept {
+    // every static_cast is intentional
+    return static_cast<byte>(
+        static_cast<unsigned char>(static_cast<unsigned int>(_Left) ^ static_cast<unsigned int>(_Right)));
+}
+
+_EXPORT_STD _NODISCARD constexpr byte operator~(const byte _Arg) noexcept {
+    // every static_cast is intentional
+    return static_cast<byte>(static_cast<unsigned char>(~static_cast<unsigned int>(_Arg)));
+}
+
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+constexpr byte& operator<<=(byte& _Arg, const _IntType _Shift) noexcept {
+    return _Arg = _Arg << _Shift;
+}
+
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+constexpr byte& operator>>=(byte& _Arg, const _IntType _Shift) noexcept {
+    return _Arg = _Arg >> _Shift;
+}
+
+_EXPORT_STD constexpr byte& operator|=(byte& _Left, const byte _Right) noexcept {
+    return _Left = _Left | _Right;
+}
+
+_EXPORT_STD constexpr byte& operator&=(byte& _Left, const byte _Right) noexcept {
+    return _Left = _Left & _Right;
+}
+
+_EXPORT_STD constexpr byte& operator^=(byte& _Left, const byte _Right) noexcept {
+    return _Left = _Left ^ _Right;
+}
+
+_EXPORT_STD template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
+_NODISCARD _MSVC_INTRINSIC constexpr _IntType to_integer(const byte _Arg) noexcept {
+    return static_cast<_IntType>(_Arg);
+}
+#endif // defined(__cpp_lib_byte)
+
+_STD_END
+
+_EXTERN_CXX_WORKAROUND
+using _STD max_align_t; // intentional, for historical reasons
+_END_EXTERN_CXX_WORKAROUND
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("intrinsic")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSTDDEF_
diff --git a/msvc-stl/stl/inc/cstdint b/msvc-stl/stl/inc/cstdint
new file mode 100644
index 0000000..0ec169a
--- /dev/null
+++ b/msvc-stl/stl/inc/cstdint
@@ -0,0 +1,60 @@
+// cstdint standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSTDINT_
+#define _CSTDINT_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <stdint.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD int8_t;
+_EXPORT_STD using _CSTD int16_t;
+_EXPORT_STD using _CSTD int32_t;
+_EXPORT_STD using _CSTD int64_t;
+_EXPORT_STD using _CSTD uint8_t;
+_EXPORT_STD using _CSTD uint16_t;
+_EXPORT_STD using _CSTD uint32_t;
+_EXPORT_STD using _CSTD uint64_t;
+
+_EXPORT_STD using _CSTD int_least8_t;
+_EXPORT_STD using _CSTD int_least16_t;
+_EXPORT_STD using _CSTD int_least32_t;
+_EXPORT_STD using _CSTD int_least64_t;
+_EXPORT_STD using _CSTD uint_least8_t;
+_EXPORT_STD using _CSTD uint_least16_t;
+_EXPORT_STD using _CSTD uint_least32_t;
+_EXPORT_STD using _CSTD uint_least64_t;
+
+_EXPORT_STD using _CSTD int_fast8_t;
+_EXPORT_STD using _CSTD int_fast16_t;
+_EXPORT_STD using _CSTD int_fast32_t;
+_EXPORT_STD using _CSTD int_fast64_t;
+_EXPORT_STD using _CSTD uint_fast8_t;
+_EXPORT_STD using _CSTD uint_fast16_t;
+_EXPORT_STD using _CSTD uint_fast32_t;
+_EXPORT_STD using _CSTD uint_fast64_t;
+
+_EXPORT_STD using _CSTD intmax_t;
+_EXPORT_STD using _CSTD intptr_t;
+_EXPORT_STD using _CSTD uintmax_t;
+_EXPORT_STD using _CSTD uintptr_t;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSTDINT_
diff --git a/msvc-stl/stl/inc/cstdio b/msvc-stl/stl/inc/cstdio
new file mode 100644
index 0000000..674c36c
--- /dev/null
+++ b/msvc-stl/stl/inc/cstdio
@@ -0,0 +1,94 @@
+// cstdio standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSTDIO_
+#define _CSTDIO_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <stdio.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// undef common macro overrides
+#undef clearerr
+#undef feof
+#undef ferror
+#undef getc
+#undef getchar
+#undef putc
+#undef putchar
+
+_STD_BEGIN
+#pragma warning(push)
+#pragma warning(disable : 4995) // name was marked as #pragma deprecated
+
+using _CSTD _Mbstatet;
+
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD fpos_t;
+_EXPORT_STD using _CSTD FILE;
+_EXPORT_STD using _CSTD clearerr;
+_EXPORT_STD using _CSTD fclose;
+_EXPORT_STD using _CSTD feof;
+_EXPORT_STD using _CSTD ferror;
+_EXPORT_STD using _CSTD fflush;
+_EXPORT_STD using _CSTD fgetc;
+_EXPORT_STD using _CSTD fgetpos;
+_EXPORT_STD using _CSTD fgets;
+_EXPORT_STD using _CSTD fopen;
+_EXPORT_STD using _CSTD fprintf;
+_EXPORT_STD using _CSTD fputc;
+_EXPORT_STD using _CSTD fputs;
+_EXPORT_STD using _CSTD fread;
+_EXPORT_STD using _CSTD freopen;
+_EXPORT_STD using _CSTD fscanf;
+_EXPORT_STD using _CSTD fseek;
+_EXPORT_STD using _CSTD fsetpos;
+_EXPORT_STD using _CSTD ftell;
+_EXPORT_STD using _CSTD fwrite;
+_EXPORT_STD using _CSTD getc;
+_EXPORT_STD using _CSTD getchar;
+_EXPORT_STD using _CSTD perror;
+_EXPORT_STD using _CSTD putc;
+_EXPORT_STD using _CSTD putchar;
+_EXPORT_STD using _CSTD printf;
+_EXPORT_STD using _CSTD puts;
+_EXPORT_STD using _CSTD remove;
+_EXPORT_STD using _CSTD rename;
+_EXPORT_STD using _CSTD rewind;
+_EXPORT_STD using _CSTD scanf;
+_EXPORT_STD using _CSTD setbuf;
+_EXPORT_STD using _CSTD setvbuf;
+_EXPORT_STD using _CSTD sprintf;
+_EXPORT_STD using _CSTD sscanf;
+_EXPORT_STD using _CSTD tmpfile;
+_EXPORT_STD using _CSTD tmpnam;
+_EXPORT_STD using _CSTD ungetc;
+_EXPORT_STD using _CSTD vfprintf;
+_EXPORT_STD using _CSTD vprintf;
+_EXPORT_STD using _CSTD vsprintf;
+
+_EXPORT_STD using _CSTD snprintf;
+_EXPORT_STD using _CSTD vsnprintf;
+_EXPORT_STD using _CSTD vfscanf;
+_EXPORT_STD using _CSTD vscanf;
+_EXPORT_STD using _CSTD vsscanf;
+
+#pragma warning(pop)
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSTDIO_
diff --git a/msvc-stl/stl/inc/cstdlib b/msvc-stl/stl/inc/cstdlib
new file mode 100644
index 0000000..1bf0509
--- /dev/null
+++ b/msvc-stl/stl/inc/cstdlib
@@ -0,0 +1,91 @@
+// cstdlib standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSTDLIB_
+#define _CSTDLIB_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <math.h>
+#include <stdlib.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_EXTERN_CXX_WORKAROUND
+// <stdlib.h> has abs(long) and abs(long long)
+_NODISCARD _Check_return_ inline double abs(_In_ double _Xx) noexcept /* strengthened */ {
+    return _CSTD fabs(_Xx);
+}
+
+_NODISCARD _Check_return_ inline float abs(_In_ float _Xx) noexcept /* strengthened */ {
+    return _CSTD fabsf(_Xx);
+}
+
+_NODISCARD _Check_return_ inline long double abs(_In_ long double _Xx) noexcept /* strengthened */ {
+    return _CSTD fabsl(_Xx);
+}
+_END_EXTERN_CXX_WORKAROUND
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD div_t;
+_EXPORT_STD using _CSTD ldiv_t;
+_EXPORT_STD using _CSTD abort;
+_EXPORT_STD using _CSTD abs;
+_EXPORT_STD using _CSTD atexit;
+_EXPORT_STD using _CSTD atof;
+_EXPORT_STD using _CSTD atoi;
+_EXPORT_STD using _CSTD atol;
+_EXPORT_STD using _CSTD bsearch;
+_EXPORT_STD using _CSTD calloc;
+_EXPORT_STD using _CSTD div;
+_EXPORT_STD using _CSTD exit;
+_EXPORT_STD using _CSTD free;
+_EXPORT_STD using _CSTD labs;
+_EXPORT_STD using _CSTD ldiv;
+_EXPORT_STD using _CSTD malloc;
+_EXPORT_STD using _CSTD mblen;
+_EXPORT_STD using _CSTD mbstowcs;
+_EXPORT_STD using _CSTD mbtowc;
+_EXPORT_STD using _CSTD qsort;
+_EXPORT_STD using _CSTD rand;
+_EXPORT_STD using _CSTD realloc;
+_EXPORT_STD using _CSTD srand;
+_EXPORT_STD using _CSTD strtod;
+_EXPORT_STD using _CSTD strtol;
+_EXPORT_STD using _CSTD strtoul;
+_EXPORT_STD using _CSTD wcstombs;
+_EXPORT_STD using _CSTD wctomb;
+
+_EXPORT_STD using _CSTD lldiv_t;
+
+_EXPORT_STD using _CSTD getenv;
+_EXPORT_STD using _CSTD system;
+
+_EXPORT_STD using _CSTD atoll;
+_EXPORT_STD using _CSTD llabs;
+_EXPORT_STD using _CSTD lldiv;
+_EXPORT_STD using _CSTD strtof;
+_EXPORT_STD using _CSTD strtold;
+_EXPORT_STD using _CSTD strtoll;
+_EXPORT_STD using _CSTD strtoull;
+
+_EXPORT_STD using _CSTD _Exit;
+_EXPORT_STD using _CSTD at_quick_exit;
+_EXPORT_STD using _CSTD quick_exit;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSTDLIB_
diff --git a/msvc-stl/stl/inc/cstring b/msvc-stl/stl/inc/cstring
new file mode 100644
index 0000000..2445e9f
--- /dev/null
+++ b/msvc-stl/stl/inc/cstring
@@ -0,0 +1,57 @@
+// cstring standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CSTRING_
+#define _CSTRING_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <string.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#pragma warning(push)
+#pragma warning(disable : 4995) // name was marked as #pragma deprecated
+
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD memchr;
+_EXPORT_STD using _CSTD memcmp;
+_EXPORT_STD using _CSTD memcpy;
+_EXPORT_STD using _CSTD memmove;
+_EXPORT_STD using _CSTD memset;
+_EXPORT_STD using _CSTD strcat;
+_EXPORT_STD using _CSTD strchr;
+_EXPORT_STD using _CSTD strcmp;
+_EXPORT_STD using _CSTD strcoll;
+_EXPORT_STD using _CSTD strcpy;
+_EXPORT_STD using _CSTD strcspn;
+_EXPORT_STD using _CSTD strerror;
+_EXPORT_STD using _CSTD strlen;
+_EXPORT_STD using _CSTD strncat;
+_EXPORT_STD using _CSTD strncmp;
+_EXPORT_STD using _CSTD strncpy;
+_EXPORT_STD using _CSTD strpbrk;
+_EXPORT_STD using _CSTD strrchr;
+_EXPORT_STD using _CSTD strspn;
+_EXPORT_STD using _CSTD strstr;
+_EXPORT_STD using _CSTD strtok;
+_EXPORT_STD using _CSTD strxfrm;
+
+#pragma warning(pop)
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CSTRING_
diff --git a/msvc-stl/stl/inc/ctgmath b/msvc-stl/stl/inc/ctgmath
new file mode 100644
index 0000000..2877ec1
--- /dev/null
+++ b/msvc-stl/stl/inc/ctgmath
@@ -0,0 +1,30 @@
+// ctgmath standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CTGMATH_
+#define _CTGMATH_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cmath>
+#include <complex>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+using _Header_ctgmath _CXX17_DEPRECATE_C_HEADER = int;
+using _Hdr_ctgmath                              = _Header_ctgmath;
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CTGMATH_
diff --git a/msvc-stl/stl/inc/ctime b/msvc-stl/stl/inc/ctime
new file mode 100644
index 0000000..f046800
--- /dev/null
+++ b/msvc-stl/stl/inc/ctime
@@ -0,0 +1,100 @@
+// ctime standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CTIME_
+#define _CTIME_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <time.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD clock_t;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD time_t;
+_EXPORT_STD using _CSTD tm;
+_EXPORT_STD using _CSTD asctime;
+_EXPORT_STD using _CSTD clock;
+_EXPORT_STD using _CSTD strftime;
+#if _HAS_CXX17
+_EXPORT_STD using _CSTD timespec;
+#endif // _HAS_CXX17
+
+// `_STATIC_INLINE_UCRT_FUNCTIONS` is exposed by the UCRT starting with Windows SDK 10.0.26100.6901.
+// When set to `1`, several UCRT functions are declared as `static inline` (for historical compatibility),
+// preventing them from being directly exported by modules. In that case (and when an older UCRT doesn't define
+// the macro), we use templates to shadow their names, allowing us to export the templates as an approximation.
+#if defined(_BUILD_STD_MODULE) && (!defined(_STATIC_INLINE_UCRT_FUNCTIONS) || _STATIC_INLINE_UCRT_FUNCTIONS == 1)
+_STL_DISABLE_DEPRECATED_WARNING
+
+_EXPORT_STD template <int = 0>
+_Check_return_ _CRT_INSECURE_DEPRECATE(ctime_s)
+char* __CRTDECL ctime(_In_ const time_t* const _Time) noexcept /* strengthened */ {
+    return _CSTD _ctime64(_Time);
+}
+
+_EXPORT_STD template <int = 0>
+_Check_return_ double __CRTDECL difftime(_In_ const time_t _Time1, _In_ const time_t _Time2) noexcept
+/* strengthened */ {
+    return _CSTD _difftime64(_Time1, _Time2);
+}
+
+_EXPORT_STD template <int = 0>
+_Check_return_ _CRT_INSECURE_DEPRECATE(gmtime_s)
+tm* __CRTDECL gmtime(_In_ const time_t* const _Time) noexcept /* strengthened */ {
+    return _CSTD _gmtime64(_Time);
+}
+
+_EXPORT_STD template <int = 0>
+_CRT_INSECURE_DEPRECATE(localtime_s)
+tm* __CRTDECL localtime(_In_ const time_t* const _Time) noexcept /* strengthened */ {
+    return _CSTD _localtime64(_Time);
+}
+
+_EXPORT_STD template <int = 0>
+_Check_return_opt_ time_t __CRTDECL mktime(_Inout_ tm* const _Tm) noexcept /* strengthened */ {
+    return _CSTD _mktime64(_Tm);
+}
+
+_EXPORT_STD template <int = 0>
+time_t __CRTDECL time(_Out_opt_ time_t* const _Time) noexcept /* strengthened */ {
+    return _CSTD _time64(_Time);
+}
+
+_EXPORT_STD template <int = 0>
+_Check_return_ int __CRTDECL timespec_get(_Out_ timespec* const _Ts, _In_ const int _Base) noexcept /* strengthened */ {
+    return _CSTD _timespec64_get(reinterpret_cast<_timespec64*>(_Ts), _Base);
+}
+
+_STL_RESTORE_DEPRECATED_WARNING
+#else // ^^^ workaround / no workaround vvv
+
+_EXPORT_STD using _CSTD ctime;
+_EXPORT_STD using _CSTD difftime;
+_EXPORT_STD using _CSTD gmtime;
+_EXPORT_STD using _CSTD localtime;
+_EXPORT_STD using _CSTD mktime;
+_EXPORT_STD using _CSTD time;
+#if _HAS_CXX17
+_EXPORT_STD using _CSTD timespec_get;
+#endif // _HAS_CXX17
+
+#endif // ^^^ no workaround ^^^
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CTIME_
diff --git a/msvc-stl/stl/inc/cuchar b/msvc-stl/stl/inc/cuchar
new file mode 100644
index 0000000..c782097
--- /dev/null
+++ b/msvc-stl/stl/inc/cuchar
@@ -0,0 +1,35 @@
+// cuchar standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CUCHAR_
+#define _CUCHAR_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <uchar.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD mbstate_t;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD mbrtoc16;
+_EXPORT_STD using _CSTD c16rtomb;
+_EXPORT_STD using _CSTD mbrtoc32;
+_EXPORT_STD using _CSTD c32rtomb;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CUCHAR_
diff --git a/msvc-stl/stl/inc/cwchar b/msvc-stl/stl/inc/cwchar
new file mode 100644
index 0000000..5b2574d
--- /dev/null
+++ b/msvc-stl/stl/inc/cwchar
@@ -0,0 +1,106 @@
+// cwchar standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CWCHAR_
+#define _CWCHAR_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdio> // TRANSITION, VSO-661721
+#include <wchar.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_EXTERN_CXX_WORKAROUND
+using _Mbstatet = mbstate_t;
+_END_EXTERN_CXX_WORKAROUND
+
+_STD_BEGIN
+#pragma warning(push)
+#pragma warning(disable : 4995) // name was marked as #pragma deprecated
+
+using _CSTD _Mbstatet;
+
+_EXPORT_STD using _CSTD mbstate_t;
+_EXPORT_STD using _CSTD size_t;
+_EXPORT_STD using _CSTD tm;
+_EXPORT_STD using _CSTD wint_t;
+
+_EXPORT_STD using _CSTD btowc;
+_EXPORT_STD using _CSTD fgetwc;
+_EXPORT_STD using _CSTD fgetws;
+_EXPORT_STD using _CSTD fputwc;
+_EXPORT_STD using _CSTD fputws;
+_EXPORT_STD using _CSTD fwide;
+_EXPORT_STD using _CSTD fwprintf;
+_EXPORT_STD using _CSTD fwscanf;
+_EXPORT_STD using _CSTD getwc;
+_EXPORT_STD using _CSTD getwchar;
+_EXPORT_STD using _CSTD mbrlen;
+_EXPORT_STD using _CSTD mbrtowc;
+_EXPORT_STD using _CSTD mbsrtowcs;
+_EXPORT_STD using _CSTD mbsinit;
+_EXPORT_STD using _CSTD putwc;
+_EXPORT_STD using _CSTD putwchar;
+_EXPORT_STD using _CSTD swprintf;
+_EXPORT_STD using _CSTD swscanf;
+_EXPORT_STD using _CSTD ungetwc;
+_EXPORT_STD using _CSTD vfwprintf;
+_EXPORT_STD using _CSTD vswprintf;
+_EXPORT_STD using _CSTD vwprintf;
+_EXPORT_STD using _CSTD wcrtomb;
+_EXPORT_STD using _CSTD wprintf;
+_EXPORT_STD using _CSTD wscanf;
+_EXPORT_STD using _CSTD wcsrtombs;
+_EXPORT_STD using _CSTD wcstol;
+_EXPORT_STD using _CSTD wcscat;
+_EXPORT_STD using _CSTD wcschr;
+_EXPORT_STD using _CSTD wcscmp;
+_EXPORT_STD using _CSTD wcscoll;
+_EXPORT_STD using _CSTD wcscpy;
+_EXPORT_STD using _CSTD wcscspn;
+_EXPORT_STD using _CSTD wcslen;
+_EXPORT_STD using _CSTD wcsncat;
+_EXPORT_STD using _CSTD wcsncmp;
+_EXPORT_STD using _CSTD wcsncpy;
+_EXPORT_STD using _CSTD wcspbrk;
+_EXPORT_STD using _CSTD wcsrchr;
+_EXPORT_STD using _CSTD wcsspn;
+_EXPORT_STD using _CSTD wcstod;
+_EXPORT_STD using _CSTD wcstoul;
+_EXPORT_STD using _CSTD wcsstr;
+_EXPORT_STD using _CSTD wcstok;
+_EXPORT_STD using _CSTD wcsxfrm;
+_EXPORT_STD using _CSTD wctob;
+_EXPORT_STD using _CSTD wmemchr;
+_EXPORT_STD using _CSTD wmemcmp;
+_EXPORT_STD using _CSTD wmemcpy;
+_EXPORT_STD using _CSTD wmemmove;
+_EXPORT_STD using _CSTD wmemset;
+_EXPORT_STD using _CSTD wcsftime;
+
+_EXPORT_STD using _CSTD vfwscanf;
+_EXPORT_STD using _CSTD vswscanf;
+_EXPORT_STD using _CSTD vwscanf;
+_EXPORT_STD using _CSTD wcstof;
+_EXPORT_STD using _CSTD wcstold;
+_EXPORT_STD using _CSTD wcstoll;
+_EXPORT_STD using _CSTD wcstoull;
+
+#pragma warning(pop)
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CWCHAR_
diff --git a/msvc-stl/stl/inc/cwctype b/msvc-stl/stl/inc/cwctype
new file mode 100644
index 0000000..f677596
--- /dev/null
+++ b/msvc-stl/stl/inc/cwctype
@@ -0,0 +1,72 @@
+// cwctype standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _CWCTYPE_
+#define _CWCTYPE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <wctype.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, /clr:pure (see corecrt_wctype.h): remove any (improper) macro overrides
+#undef iswalnum
+#undef iswalpha
+#undef iswblank
+#undef iswcntrl
+#undef iswctype
+#undef iswdigit
+#undef iswgraph
+#undef iswlower
+#undef iswprint
+#undef iswpunct
+#undef iswspace
+#undef iswupper
+#undef iswxdigit
+#undef towctrans
+#undef towlower
+#undef towupper
+#undef wctrans
+#undef wctype
+
+_STD_BEGIN
+_EXPORT_STD using _CSTD wint_t;
+_EXPORT_STD using _CSTD wctrans_t;
+_EXPORT_STD using _CSTD wctype_t;
+
+_EXPORT_STD using _CSTD iswalnum;
+_EXPORT_STD using _CSTD iswalpha;
+_EXPORT_STD using _CSTD iswcntrl;
+_EXPORT_STD using _CSTD iswctype;
+_EXPORT_STD using _CSTD iswdigit;
+_EXPORT_STD using _CSTD iswgraph;
+_EXPORT_STD using _CSTD iswlower;
+_EXPORT_STD using _CSTD iswprint;
+_EXPORT_STD using _CSTD iswpunct;
+_EXPORT_STD using _CSTD iswspace;
+_EXPORT_STD using _CSTD iswupper;
+_EXPORT_STD using _CSTD iswxdigit;
+_EXPORT_STD using _CSTD towctrans;
+_EXPORT_STD using _CSTD towlower;
+_EXPORT_STD using _CSTD towupper;
+_EXPORT_STD using _CSTD wctrans;
+_EXPORT_STD using _CSTD wctype;
+
+_EXPORT_STD using _CSTD iswblank;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _CWCTYPE_
diff --git a/msvc-stl/stl/inc/deque b/msvc-stl/stl/inc/deque
new file mode 100644
index 0000000..a9cd242
--- /dev/null
+++ b/msvc-stl/stl/inc/deque
@@ -0,0 +1,1866 @@
+// deque standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _DEQUE_
+#define _DEQUE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xmemory>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Mydeque>
+class _Deque_unchecked_const_iterator {
+private:
+    using _Size_type = typename _Mydeque::size_type;
+
+    static constexpr int _Block_size = _Mydeque::_Block_size;
+
+public:
+    using iterator_category = random_access_iterator_tag;
+
+    using value_type      = typename _Mydeque::value_type;
+    using difference_type = typename _Mydeque::difference_type;
+    using pointer         = typename _Mydeque::const_pointer;
+    using reference       = const value_type&;
+
+    _Deque_unchecked_const_iterator() noexcept : _Mycont(), _Myoff(0) {}
+
+    _Deque_unchecked_const_iterator(_Size_type _Off, const _Container_base12* _Pdeque) noexcept
+        : _Mycont(static_cast<const _Mydeque*>(_Pdeque)), _Myoff(_Off) {}
+
+    _NODISCARD reference operator*() const noexcept {
+        return _Mycont->_Subscript(_Myoff);
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Deque_unchecked_const_iterator& operator++() noexcept {
+        ++_Myoff;
+        return *this;
+    }
+
+    _Deque_unchecked_const_iterator operator++(int) noexcept {
+        _Deque_unchecked_const_iterator _Tmp = *this;
+        ++_Myoff;
+        return _Tmp;
+    }
+
+    _Deque_unchecked_const_iterator& operator--() noexcept {
+        --_Myoff;
+        return *this;
+    }
+
+    _Deque_unchecked_const_iterator operator--(int) noexcept {
+        _Deque_unchecked_const_iterator _Tmp = *this;
+        --_Myoff;
+        return _Tmp;
+    }
+
+    _Deque_unchecked_const_iterator& operator+=(const difference_type _Off) noexcept {
+        _Myoff = static_cast<_Size_type>(_Myoff + _Off);
+        return *this;
+    }
+
+    _NODISCARD _Deque_unchecked_const_iterator operator+(const difference_type _Off) const noexcept {
+        _Deque_unchecked_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _Deque_unchecked_const_iterator operator+(
+        const difference_type _Off, _Deque_unchecked_const_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _Deque_unchecked_const_iterator& operator-=(const difference_type _Off) noexcept {
+        _Myoff = static_cast<_Size_type>(_Myoff - _Off);
+        return *this;
+    }
+
+    _NODISCARD _Deque_unchecked_const_iterator operator-(const difference_type _Off) const noexcept {
+        _Deque_unchecked_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD difference_type operator-(const _Deque_unchecked_const_iterator& _Right) const noexcept {
+        return static_cast<difference_type>(_Myoff - _Right._Myoff);
+    }
+
+    _NODISCARD reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD bool operator==(const _Deque_unchecked_const_iterator& _Right) const noexcept {
+        return _Myoff == _Right._Myoff;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD strong_ordering operator<=>(const _Deque_unchecked_const_iterator& _Right) const noexcept {
+        return _Myoff <=> _Right._Myoff;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const _Deque_unchecked_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const _Deque_unchecked_const_iterator& _Right) const noexcept {
+        return _Myoff < _Right._Myoff;
+    }
+
+    _NODISCARD bool operator>(const _Deque_unchecked_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const _Deque_unchecked_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD bool operator>=(const _Deque_unchecked_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    const _Container_base12* _Getcont() const noexcept { // get container pointer
+        return _Mycont;
+    }
+
+    const _Mydeque* _Mycont;
+    _Size_type _Myoff; // offset of element in deque
+};
+
+template <class _Mydeque>
+class _Deque_unchecked_iterator : public _Deque_unchecked_const_iterator<_Mydeque> {
+private:
+    using _Size_type = typename _Mydeque::size_type;
+    using _Mybase    = _Deque_unchecked_const_iterator<_Mydeque>;
+
+public:
+    using iterator_category = random_access_iterator_tag;
+
+    using value_type      = typename _Mydeque::value_type;
+    using difference_type = typename _Mydeque::difference_type;
+    using pointer         = typename _Mydeque::pointer;
+    using reference       = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Deque_unchecked_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Deque_unchecked_iterator operator++(int) noexcept {
+        _Deque_unchecked_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _Deque_unchecked_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _Deque_unchecked_iterator operator--(int) noexcept {
+        _Deque_unchecked_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _Deque_unchecked_iterator& operator+=(const difference_type _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _Deque_unchecked_iterator operator+(const difference_type _Off) const noexcept {
+        _Deque_unchecked_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _Deque_unchecked_iterator operator+(
+        const difference_type _Off, _Deque_unchecked_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _Deque_unchecked_iterator& operator-=(const difference_type _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _Deque_unchecked_iterator operator-(const difference_type _Off) const noexcept {
+        _Deque_unchecked_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD difference_type operator-(const _Mybase& _Right) const noexcept {
+        return _Mybase::operator-(_Right);
+    }
+
+    _NODISCARD reference operator[](const difference_type _Off) const noexcept {
+        return const_cast<reference>(_Mybase::operator[](_Off));
+    }
+};
+
+template <class _Mydeque>
+class _Deque_const_iterator : public _Iterator_base12 {
+private:
+    using _Size_type = typename _Mydeque::size_type;
+
+    static constexpr int _Block_size = _Mydeque::_Block_size;
+
+public:
+    using iterator_category = random_access_iterator_tag;
+
+    using value_type      = typename _Mydeque::value_type;
+    using difference_type = typename _Mydeque::difference_type;
+    using pointer         = typename _Mydeque::const_pointer;
+    using reference       = const value_type&;
+
+    using _Mydeque_t = _Mydeque; // helper for expression evaluator
+    enum { _EEN_DS = _Block_size }; // helper for expression evaluator
+    _Deque_const_iterator() noexcept : _Myoff(0) {
+        _Setcont(nullptr);
+    }
+
+    _Deque_const_iterator(_Size_type _Off, const _Container_base12* _Pdeque) noexcept : _Myoff(_Off) {
+        _Setcont(static_cast<const _Mydeque*>(_Pdeque));
+    }
+
+    _NODISCARD reference operator*() const noexcept {
+        const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mycont, "cannot dereference value-initialized deque iterator");
+        _STL_VERIFY(_Mycont->_Myoff <= this->_Myoff && this->_Myoff < _Mycont->_Myoff + _Mycont->_Mysize,
+            "cannot deference out of range deque iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Mycont->_Subscript(_Myoff);
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Deque_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot increment value-initialized deque iterator");
+        _STL_VERIFY(this->_Myoff < _Mycont->_Myoff + _Mycont->_Mysize, "cannot increment deque iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        ++_Myoff;
+        return *this;
+    }
+
+    _Deque_const_iterator operator++(int) noexcept {
+        _Deque_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _Deque_const_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot decrement value-initialized deque iterator");
+        _STL_VERIFY(_Mycont->_Myoff < this->_Myoff, "cannot decrement deque iterator before begin");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        --_Myoff;
+        return *this;
+    }
+
+    _Deque_const_iterator operator--(int) noexcept {
+        _Deque_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _Deque_const_iterator& operator+=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if (_Off != 0) {
+            const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
+            _STL_VERIFY(_Mycont, "cannot seek value-initialized deque iterator");
+            _STL_VERIFY(
+                _Mycont->_Myoff <= this->_Myoff + _Off && this->_Myoff + _Off <= _Mycont->_Myoff + _Mycont->_Mysize,
+                "cannot seek deque iterator out of range");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        _Myoff = static_cast<_Size_type>(_Myoff + _Off);
+        return *this;
+    }
+
+    _NODISCARD _Deque_const_iterator operator+(const difference_type _Off) const noexcept {
+        _Deque_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _Deque_const_iterator operator+(
+        const difference_type _Off, _Deque_const_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _Deque_const_iterator& operator-=(const difference_type _Off) noexcept {
+        return *this += -_Off;
+    }
+
+    _NODISCARD _Deque_const_iterator operator-(const difference_type _Off) const noexcept {
+        _Deque_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD difference_type operator-(const _Deque_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return static_cast<difference_type>(this->_Myoff - _Right._Myoff);
+    }
+
+    _NODISCARD reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD bool operator==(const _Deque_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return this->_Myoff == _Right._Myoff;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD strong_ordering operator<=>(const _Deque_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return this->_Myoff <=> _Right._Myoff;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const _Deque_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const _Deque_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return this->_Myoff < _Right._Myoff;
+    }
+
+    _NODISCARD bool operator>(const _Deque_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const _Deque_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD bool operator>=(const _Deque_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    void _Compat(const _Deque_const_iterator& _Right) const noexcept { // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Right;
+#else
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "deque iterators incompatible");
+#endif
+    }
+
+    void _Setcont(const _Mydeque* _Pdeque) noexcept { // set container pointer
+        this->_Adopt(_Pdeque);
+    }
+
+    using _Prevent_inheriting_unwrap = _Deque_const_iterator;
+
+    _NODISCARD _Deque_unchecked_const_iterator<_Mydeque> _Unwrapped() const noexcept {
+        return {this->_Myoff, this->_Getcont()};
+    }
+
+    void _Verify_offset(const difference_type _Off) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Off;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        if (_Off != 0) {
+            const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());
+            _STL_VERIFY(_Mycont, "cannot use value-initialized deque iterator");
+            _STL_VERIFY(
+                _Mycont->_Myoff <= this->_Myoff + _Off && this->_Myoff + _Off <= _Mycont->_Myoff + _Mycont->_Mysize,
+                "cannot seek deque iterator out of range");
+        }
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+    friend void _Verify_range(const _Deque_const_iterator& _First, const _Deque_const_iterator& _Last) noexcept {
+        // note _Compat check inside operator<=
+        _STL_VERIFY(_First <= _Last, "deque iterators transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+    void _Seek_to(const _Deque_unchecked_const_iterator<_Mydeque>& _UIt) noexcept {
+        _Myoff = _UIt._Myoff;
+    }
+
+    _Size_type _Myoff; // offset of element in deque
+};
+
+template <class _Mydeque>
+class _Deque_iterator : public _Deque_const_iterator<_Mydeque> {
+private:
+    using _Size_type = typename _Mydeque::size_type;
+    using _Mybase    = _Deque_const_iterator<_Mydeque>;
+
+public:
+    using iterator_category = random_access_iterator_tag;
+
+    using value_type      = typename _Mydeque::value_type;
+    using difference_type = typename _Mydeque::difference_type;
+    using pointer         = typename _Mydeque::pointer;
+    using reference       = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Deque_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Deque_iterator operator++(int) noexcept {
+        _Deque_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _Deque_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _Deque_iterator operator--(int) noexcept {
+        _Deque_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _Deque_iterator& operator+=(const difference_type _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _Deque_iterator operator+(const difference_type _Off) const noexcept {
+        _Deque_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _Deque_iterator operator+(const difference_type _Off, _Deque_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _Deque_iterator& operator-=(const difference_type _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    using _Mybase::operator-;
+
+    _NODISCARD _Deque_iterator operator-(const difference_type _Off) const noexcept {
+        _Deque_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD reference operator[](const difference_type _Off) const noexcept {
+        return const_cast<reference>(_Mybase::operator[](_Off));
+    }
+
+    using _Prevent_inheriting_unwrap = _Deque_iterator;
+
+    _NODISCARD _Deque_unchecked_iterator<_Mydeque> _Unwrapped() const noexcept {
+        return {this->_Myoff, this->_Getcont()};
+    }
+};
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
+    class _Mapptr_type>
+struct _Deque_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+    using _Mapptr         = _Mapptr_type;
+};
+
+template <class _Ty>
+struct _Deque_simple_types : _Simple_types<_Ty> {
+    using _Mapptr = _Ty**;
+};
+
+template <class _Val_types>
+class _Deque_val : public _Container_base12 {
+public:
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using _Mapptr         = typename _Val_types::_Mapptr;
+
+private:
+    using _Map_difference_type = typename iterator_traits<_Mapptr>::difference_type;
+
+    static constexpr size_t _Bytes = sizeof(value_type);
+
+public:
+    static constexpr int _Block_size = _Bytes <= 1 ? 16
+                                     : _Bytes <= 2 ? 8
+                                     : _Bytes <= 4 ? 4
+                                     : _Bytes <= 8 ? 2
+                                                   : 1; // elements per block (a power of 2)
+
+    _Deque_val() noexcept : _Map(), _Mapsize(0), _Myoff(0), _Mysize(0) {}
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    ~_Deque_val() noexcept {
+        if constexpr (is_pointer_v<_Mapptr>) {
+            const auto _Tombstone{reinterpret_cast<_Mapptr>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+            _Map     = _Tombstone;
+            _Mapsize = 0;
+            _Myoff   = 0;
+            _Mysize  = 0;
+        }
+    }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+
+    _Map_difference_type _Getblock(size_type _Off) const noexcept {
+        // NB: _Mapsize and _Block_size are guaranteed to be powers of 2
+        return static_cast<_Map_difference_type>((_Off / _Block_size) & (_Mapsize - 1));
+    }
+
+    reference _Subscript(size_type _Off) noexcept {
+        const auto _Block     = _Getblock(_Off);
+        const auto _Block_off = static_cast<difference_type>(_Off % _Block_size);
+        return _Map[_Block][_Block_off];
+    }
+
+    const_reference _Subscript(size_type _Off) const noexcept {
+        const auto _Block     = _Getblock(_Off);
+        const auto _Block_off = static_cast<difference_type>(_Off % _Block_size);
+        return _Map[_Block][_Block_off];
+    }
+
+    value_type* _Address_subscript(size_type _Off) noexcept {
+        const auto _Block     = _Getblock(_Off);
+        const auto _Block_off = static_cast<difference_type>(_Off % _Block_size);
+        return _STD _Unfancy(_Map[_Block] + _Block_off);
+    }
+
+    _Mapptr _Map; // pointer to array of pointers to blocks
+    size_type _Mapsize; // size of map array, zero or 2^N
+    size_type _Myoff; // offset of initial element
+    size_type _Mysize; // current length of sequence
+};
+
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
+class deque {
+private:
+    friend _Tidy_guard<deque>;
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Ty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("deque<T, Allocator>", "T"));
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
+                                    "because of [container.requirements].");
+
+    using _Alty         = _Rebind_alloc_t<_Alloc, _Ty>;
+    using _Alty_traits  = allocator_traits<_Alty>;
+    using _Alpty        = _Rebind_alloc_t<_Alloc, typename _Alty_traits::pointer>;
+    using _Alpty_traits = allocator_traits<_Alpty>;
+    using _Mapptr       = typename _Alpty_traits::pointer;
+    using _Alproxy_ty   = _Rebind_alloc_t<_Alty, _Container_proxy>;
+
+    using _Map_difference_type = typename iterator_traits<_Mapptr>::difference_type;
+
+    using _Scary_val = _Deque_val<conditional_t<_Is_simple_alloc_v<_Alty>, _Deque_simple_types<_Ty>,
+        _Deque_iter_types<_Ty, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
+            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Mapptr>>>;
+
+    static constexpr int _Minimum_map_size = 8;
+    static constexpr int _Block_size       = _Scary_val::_Block_size;
+
+public:
+    using allocator_type  = _Alloc;
+    using value_type      = _Ty;
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = _Ty&;
+    using const_reference = const _Ty&;
+
+    using iterator                  = _Deque_iterator<_Scary_val>;
+    using const_iterator            = _Deque_const_iterator<_Scary_val>;
+    using _Unchecked_iterator       = _Deque_unchecked_iterator<_Scary_val>;
+    using _Unchecked_const_iterator = _Deque_unchecked_const_iterator<_Scary_val>;
+
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+    enum { _EEN_DS = _Block_size }; // helper for expression evaluator
+
+    deque() : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Get_data()._Alloc_proxy(static_cast<_Alproxy_ty>(_Getal()));
+    }
+
+    explicit deque(const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Get_data()._Alloc_proxy(static_cast<_Alproxy_ty>(_Getal()));
+    }
+
+    explicit deque(_CRT_GUARDOVERFLOW size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Alproxy_ty _Alproxy(_Getal());
+        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
+        _Tidy_guard<deque> _Guard{this};
+        resize(_Count);
+        _Guard._Target = nullptr;
+        _Proxy._Release();
+    }
+
+    deque(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct_n(_Count, _Val);
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    deque(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_n(_Count, _Val);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    deque(_Iter _First, _Iter _Last) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct(_First, _Last);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    deque(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    deque(from_range_t, _Rng&& _Range) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    deque(from_range_t, _Rng&& _Range, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    deque(const deque& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
+        _Construct(_Right._Unchecked_begin(), _Right._Unchecked_end());
+    }
+
+    deque(const deque& _Right, const _Identity_t<_Alloc>& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct(_Right._Unchecked_begin(), _Right._Unchecked_end());
+    }
+
+    deque(deque&& _Right) : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
+        _Get_data()._Alloc_proxy(static_cast<_Alproxy_ty>(_Getal()));
+        _Take_contents(_Right);
+    }
+
+    deque(deque&& _Right, const _Identity_t<_Alloc>& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (!_Alty_traits::is_always_equal::value) {
+            if (_Getal() != _Right._Getal()) {
+                _Construct(_STD make_move_iterator(_Right._Unchecked_begin()),
+                    _STD make_move_iterator(_Right._Unchecked_end()));
+                return;
+            }
+        }
+
+        _Get_data()._Alloc_proxy(static_cast<_Alproxy_ty>(_Getal()));
+        _Take_contents(_Right);
+    }
+
+    deque(initializer_list<_Ty> _Ilist, const _Alloc& _Al = allocator_type())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct(_Ilist.begin(), _Ilist.end());
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    void _Construct(_Iter _First, const _Sent _Last) { // initialize from input range [_First, _Last)
+        _Alproxy_ty _Alproxy(_Getal());
+        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
+
+        _Tidy_guard<deque> _Guard{this};
+        for (; _First != _Last; ++_First) {
+            _Emplace_back_internal(*_First);
+        }
+
+        _Guard._Target = nullptr;
+        _Proxy._Release();
+    }
+
+    void _Construct_n(size_type _Count, const _Ty& _Val) { // construct from _Count * _Val
+        _Alproxy_ty _Alproxy(_Getal());
+        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
+
+        _Tidy_guard<deque> _Guard{this};
+        for (; _Count > 0; --_Count) {
+            _Emplace_back_internal(_Val);
+        }
+
+        _Guard._Target = nullptr;
+        _Proxy._Release();
+    }
+
+    void _Take_contents(deque& _Right) noexcept {
+        // move from _Right, stealing its contents
+        // pre: _Getal() == _Right._Getal()
+        auto& _My_data    = _Get_data();
+        auto& _Right_data = _Right._Get_data();
+        _My_data._Swap_proxy_and_iterators(_Right_data);
+        _My_data._Map     = _Right_data._Map;
+        _My_data._Mapsize = _Right_data._Mapsize;
+        _My_data._Myoff   = _Right_data._Myoff;
+        _My_data._Mysize  = _Right_data._Mysize;
+
+        _Right_data._Map     = nullptr;
+        _Right_data._Mapsize = 0;
+        _Right_data._Myoff   = 0;
+        _Right_data._Mysize  = 0;
+    }
+
+public:
+    ~deque() noexcept {
+        _Tidy();
+        _Alproxy_ty _Proxy_allocator(_Getal());
+        _Delete_plain_internal(_Proxy_allocator, _STD exchange(_Get_data()._Myproxy, nullptr));
+    }
+
+    deque& operator=(const deque& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al       = _Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alty>) {
+            if (_Al != _Right_al) {
+                _Tidy();
+                _Get_data()._Reload_proxy(static_cast<_Alproxy_ty>(_Al), static_cast<_Alproxy_ty>(_Right_al));
+            }
+        }
+
+        _Pocca(_Al, _Right_al);
+        assign(_Right._Unchecked_begin(), _Right._Unchecked_end());
+
+        return *this;
+    }
+
+    deque& operator=(deque&& _Right) noexcept(_Alty_traits::is_always_equal::value) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alty>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                _Alproxy_ty _Alproxy(_Al);
+                _Alproxy_ty _Right_alproxy(_Right_al);
+                _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                _Tidy();
+                _Pocma(_Al, _Right_al);
+                _Proxy._Bind(_Alproxy, _STD addressof(_Get_data()));
+                _Take_contents(_Right);
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                assign(_STD make_move_iterator(_Right._Unchecked_begin()),
+                    _STD make_move_iterator(_Right._Unchecked_end()));
+                return *this;
+            }
+        }
+
+        _Tidy();
+        _Pocma(_Al, _Right_al);
+        _Take_contents(_Right);
+
+        return *this;
+    }
+
+    deque& operator=(initializer_list<_Ty> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    void assign(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Assign_range(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void assign_range(_Rng&& _Range) {
+        static_assert(assignable_from<_Ty&, _RANGES range_reference_t<_Rng>>,
+            "Elements must be assignable from the range's reference type (N4993 [sequence.reqmts]/60).");
+        _Assign_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    void assign(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) { // assign _Count * _Val
+        _Orphan_all();
+        auto _Myfirst       = _Unchecked_begin();
+        const auto _Oldsize = _Mysize();
+        auto _Assign_count  = (_STD min) (_Count, _Oldsize);
+        for (; _Assign_count > 0; --_Assign_count) {
+            *_Myfirst = _Val;
+            ++_Myfirst;
+        }
+
+        const auto _Shrink_by = _Oldsize - _Assign_count;
+        auto _Extend_by       = _Count - _Assign_count;
+        _Erase_last_n(_Shrink_by);
+        for (; _Extend_by > 0; --_Extend_by) {
+            _Emplace_back_internal(_Val);
+        }
+    }
+
+    void assign(initializer_list<_Ty> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    void _Assign_range(_Iter _First, const _Sent _Last) {
+        _Orphan_all();
+        auto _Myfirst      = _Unchecked_begin();
+        const auto _Mylast = _Unchecked_end();
+        // Reuse existing elements
+        for (; _Myfirst != _Mylast; ++_Myfirst, (void) ++_First) {
+            if (_First == _Last) {
+                _Erase_last_n(static_cast<size_type>(_Mylast - _Myfirst));
+                return;
+            }
+
+            *_Myfirst = *_First;
+        }
+
+        // Allocate new elements for remaining tail of values
+        for (; _First != _Last; ++_First) {
+            _Emplace_back_internal(*_First);
+        }
+    }
+
+public:
+    _NODISCARD iterator begin() noexcept {
+        return iterator(_Myoff(), _STD addressof(_Get_data()));
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        return const_iterator(_Myoff(), _STD addressof(_Get_data()));
+    }
+
+    _NODISCARD iterator end() noexcept {
+        return iterator(_Myoff() + _Mysize(), _STD addressof(_Get_data()));
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        return const_iterator(_Myoff() + _Mysize(), _STD addressof(_Get_data()));
+    }
+
+    _Unchecked_iterator _Unchecked_begin() noexcept {
+        return _Unchecked_iterator(_Myoff(), _STD addressof(_Get_data()));
+    }
+
+    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
+        return _Unchecked_const_iterator(_Myoff(), _STD addressof(_Get_data()));
+    }
+
+    _Unchecked_iterator _Unchecked_end() noexcept {
+        return _Unchecked_iterator(_Myoff() + _Mysize(), _STD addressof(_Get_data()));
+    }
+
+    _Unchecked_const_iterator _Unchecked_end() const noexcept {
+        return _Unchecked_const_iterator(_Myoff() + _Mysize(), _STD addressof(_Get_data()));
+    }
+
+    iterator _Make_iter(const_iterator _Where) const noexcept {
+        return iterator(_Where._Myoff, _STD addressof(_Get_data()));
+    }
+
+    _NODISCARD reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Mysize() == 0;
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _Mysize();
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        constexpr auto _Diff_max = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        return (_STD min) (_Diff_max, _Alty_traits::max_size(_Getal()));
+    }
+
+    void resize(_CRT_GUARDOVERFLOW size_type _Newsize) {
+        _Orphan_all();
+        while (_Mysize() < _Newsize) {
+            _Emplace_back_internal();
+        }
+
+        while (_Mysize() > _Newsize) {
+            pop_back();
+        }
+    }
+
+    void resize(_CRT_GUARDOVERFLOW size_type _Newsize, const _Ty& _Val) {
+        _Orphan_all();
+        while (_Mysize() < _Newsize) {
+            _Emplace_back_internal(_Val);
+        }
+
+        while (_Mysize() > _Newsize) {
+            pop_back();
+        }
+    }
+
+    void shrink_to_fit() {
+        if (empty()) {
+            if (_Map() != nullptr) {
+                _Reset_map();
+            }
+            return;
+        }
+
+        const auto _Mask = static_cast<size_type>(_Mapsize() - 1);
+
+        const auto _Unmasked_first_used_block_idx = static_cast<size_type>(_Myoff() / _Block_size);
+        const auto _First_used_block_idx          = static_cast<size_type>(_Unmasked_first_used_block_idx & _Mask);
+
+        // (_Myoff() + _Mysize() - 1) is for the last element, i.e. the back() of the deque.
+        // Divide by _Block_size to get the unmasked index of the last used block.
+        // Add 1 to get the unmasked index of the first unused block.
+        const auto _Unmasked_first_unused_block_idx =
+            static_cast<size_type>(((_Myoff() + _Mysize() - 1) / _Block_size) + 1);
+
+        const auto _First_unused_block_idx = static_cast<size_type>(_Unmasked_first_unused_block_idx & _Mask);
+
+        // deallocate unused blocks, traversing over the circular buffer until the first used block index
+        for (auto _Block_idx = _First_unused_block_idx; _Block_idx != _First_used_block_idx;
+            _Block_idx       = static_cast<size_type>((_Block_idx + 1) & _Mask)) {
+            auto& _Block_ptr = _Map()[static_cast<_Map_difference_type>(_Block_idx)];
+            if (_Block_ptr != nullptr) {
+                _Getal().deallocate(_Block_ptr, _Block_size);
+                _Block_ptr = nullptr;
+            }
+        }
+
+        const auto _Used_block_count =
+            static_cast<size_type>(_Unmasked_first_unused_block_idx - _Unmasked_first_used_block_idx);
+
+        size_type _New_block_count = _Minimum_map_size; // should be power of 2
+
+        while (_New_block_count < _Used_block_count) {
+            _New_block_count *= 2;
+        }
+
+        if (_New_block_count >= _Mapsize()) {
+            return;
+        }
+
+        // worth shrinking the internal map, do it
+
+        _Alpty _Almap(_Getal());
+        const auto _New_map = _Almap.allocate(_New_block_count);
+
+        _Orphan_all(); // the map can be shrunk, invalidate all iterators
+
+        // transfer the ownership of blocks to pointers in the new map
+        for (size_type _Block = 0; _Block != _Used_block_count; ++_Block) {
+            const auto _New_block_idx = static_cast<_Map_difference_type>(_Block);
+            const auto _Old_block_idx = static_cast<_Map_difference_type>((_First_used_block_idx + _Block) & _Mask);
+            _STD _Construct_in_place(_New_map[_New_block_idx], _Map()[_Old_block_idx]);
+        }
+
+        // null out the rest of the new map
+        _STD _Uninitialized_value_construct_n_unchecked1(
+            _New_map + static_cast<_Map_difference_type>(_Used_block_count), _New_block_count - _Used_block_count);
+
+        for (auto _Block = _Map_distance(); _Block > 0;) {
+            --_Block;
+            _STD _Destroy_in_place(_Map()[_Block]); // destroy pointer to block
+        }
+        _Almap.deallocate(_Map(), _Mapsize()); // free storage for map
+
+        _Map()     = _New_map;
+        _Mapsize() = _New_block_count;
+        _Myoff() %= _Block_size; // the first element is within block index 0 of the new map
+    }
+
+    _NODISCARD const_reference operator[](size_type _Pos) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_DEQUE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Pos < _Mysize(), "deque subscript out of range");
+#endif
+
+        return _Subscript(_Pos);
+    }
+
+    _NODISCARD reference operator[](size_type _Pos) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_DEQUE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Pos < _Mysize(), "deque subscript out of range");
+#endif
+
+        return _Subscript(_Pos);
+    }
+
+    _NODISCARD const_reference at(size_type _Pos) const {
+        if (_Mysize() <= _Pos) {
+            _Xran();
+        }
+
+        return _Subscript(_Pos);
+    }
+
+    _NODISCARD reference at(size_type _Pos) {
+        if (_Mysize() <= _Pos) {
+            _Xran();
+        }
+
+        return _Subscript(_Pos);
+    }
+
+    _NODISCARD reference front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_DEQUE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!empty(), "front() called on empty deque");
+#endif
+
+        return _Subscript(0);
+    }
+
+    _NODISCARD const_reference front() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_DEQUE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!empty(), "front() called on empty deque");
+#endif
+
+        return _Subscript(0);
+    }
+
+    _NODISCARD reference back() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_DEQUE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!empty(), "back() called on empty deque");
+#endif
+
+        return _Subscript(_Mysize() - 1);
+    }
+
+    _NODISCARD const_reference back() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_DEQUE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!empty(), "back() called on empty deque");
+#endif
+
+        return _Subscript(_Mysize() - 1);
+    }
+
+private:
+    template <class... _Tys>
+    void _Emplace_back_internal(_Tys&&... _Vals) {
+        if ((_Myoff() + _Mysize()) % _Block_size == 0 && _Mapsize() <= (_Mysize() + _Block_size) / _Block_size) {
+            _Growmap(1);
+        }
+        _Myoff() &= _Mapsize() * _Block_size - 1;
+        const auto _Newoff = static_cast<size_type>(_Myoff() + _Mysize());
+        const auto _Block  = _Getblock(_Newoff);
+        if (_Map()[_Block] == nullptr) {
+            _Map()[_Block] = _Getal().allocate(_Block_size);
+        }
+
+        _Alty_traits::construct(_Getal(), _Get_data()._Address_subscript(_Newoff), _STD forward<_Tys>(_Vals)...);
+
+        ++_Mysize();
+    }
+
+    template <class... _Tys>
+    void _Emplace_front_internal(_Tys&&... _Vals) {
+        if (_Myoff() % _Block_size == 0 && _Mapsize() <= (_Mysize() + _Block_size) / _Block_size) {
+            _Growmap(1);
+        }
+        _Myoff() &= _Mapsize() * _Block_size - 1;
+        const auto _Newoff = static_cast<size_type>((_Myoff() != 0 ? _Myoff() : _Mapsize() * _Block_size) - 1);
+        const auto _Block  = _Getblock(_Newoff);
+        if (_Map()[_Block] == nullptr) {
+            _Map()[_Block] = _Getal().allocate(_Block_size);
+        }
+
+        _Alty_traits::construct(_Getal(), _Get_data()._Address_subscript(_Newoff), _STD forward<_Tys>(_Vals)...);
+
+        _Myoff() = _Newoff;
+        ++_Mysize();
+    }
+
+public:
+    template <class... _Valty>
+    _CONTAINER_EMPLACE_RETURN emplace_front(_Valty&&... _Val) {
+        _Orphan_all();
+        _Emplace_front_internal(_STD forward<_Valty>(_Val)...);
+#if _HAS_CXX17
+        return front();
+#endif // _HAS_CXX17
+    }
+
+    template <class... _Valty>
+    _CONTAINER_EMPLACE_RETURN emplace_back(_Valty&&... _Val) {
+        _Orphan_all();
+        _Emplace_back_internal(_STD forward<_Valty>(_Val)...);
+
+#if _HAS_CXX17
+        return back();
+#endif // _HAS_CXX17
+    }
+
+    template <class... _Valty>
+    iterator emplace(const_iterator _Where, _Valty&&... _Val) {
+        const auto _Off = static_cast<size_type>(_Where - begin());
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Off <= _Mysize(), "deque emplace iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Orphan_all();
+        if (_Off == 0) { // at the beginning
+            _Emplace_front_internal(_STD forward<_Valty>(_Val)...);
+        } else if (_Off == _Mysize()) { // at the end
+            _Emplace_back_internal(_STD forward<_Valty>(_Val)...);
+        } else {
+            _Alloc_temporary2<_Alty> _Obj(_Getal(), _STD forward<_Valty>(_Val)...); // handle aliasing
+
+            if (_Off <= _Mysize() / 2) { // closer to front
+                _Emplace_front_internal(_STD move(*_Unchecked_begin()));
+
+                auto _Moving_dst       = _STD _Next_iter(_Unchecked_begin());
+                auto _Moving_src_begin = _STD _Next_iter(_Moving_dst);
+                auto _Moving_src_end   = _Moving_dst + static_cast<difference_type>(_Off);
+
+                auto _Moving_dst_end = _STD _Move_unchecked(_Moving_src_begin, _Moving_src_end, _Moving_dst);
+                *_Moving_dst_end     = _STD move(_Obj._Get_value());
+            } else { // closer to back
+                _Emplace_back_internal(_STD move(*_STD _Prev_iter(_Unchecked_end())));
+
+                auto _Moving_dst_end   = _STD _Prev_iter(_Unchecked_end());
+                auto _Moving_src_end   = _STD _Prev_iter(_Moving_dst_end);
+                auto _Moving_src_begin = _Unchecked_begin() + static_cast<difference_type>(_Off);
+
+                _STD _Move_backward_unchecked(_Moving_src_begin, _Moving_src_end, _Moving_dst_end);
+                *_Moving_src_begin = _STD move(_Obj._Get_value());
+            }
+        }
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    void push_front(const _Ty& _Val) {
+        _Orphan_all();
+        _Emplace_front_internal(_Val);
+    }
+
+    void push_front(_Ty&& _Val) {
+        _Orphan_all();
+        _Emplace_front_internal(_STD move(_Val));
+    }
+
+    void push_back(const _Ty& _Val) {
+        _Orphan_all();
+        _Emplace_back_internal(_Val);
+    }
+
+    void push_back(_Ty&& _Val) {
+        _Orphan_all();
+        _Emplace_back_internal(_STD move(_Val));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void prepend_range(_Rng&& _Range) {
+        _Orphan_all();
+
+        const auto _Oldsize = _Mysize();
+        _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
+        if constexpr (_RANGES bidirectional_range<_Rng>) {
+            const auto _UFirst = _RANGES _Ubegin(_Range);
+            auto _ULast        = _RANGES _Get_final_iterator_unwrapped(_Range);
+            while (_UFirst != _ULast) {
+                _Emplace_front_internal(*--_ULast); // prepend in order
+            }
+        } else {
+            auto _UFirst      = _RANGES _Ubegin(_Range);
+            const auto _ULast = _RANGES _Uend(_Range);
+            for (; _UFirst != _ULast; ++_UFirst) {
+                _Emplace_front_internal(*_UFirst); // prepend flipped
+            }
+
+            const auto _Num = static_cast<difference_type>(_Mysize() - _Oldsize);
+            _STD reverse(_Unchecked_begin(), _Unchecked_begin() + _Num);
+        }
+        _Guard._Container = nullptr;
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    void append_range(_Rng&& _Range) {
+        _Orphan_all();
+
+        const auto _Oldsize = _Mysize();
+        auto _UFirst        = _RANGES _Ubegin(_Range);
+        const auto _ULast   = _RANGES _Uend(_Range);
+
+        _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
+        for (; _UFirst != _ULast; ++_UFirst) {
+            _Emplace_back_internal(*_UFirst);
+        }
+        _Guard._Container = nullptr;
+    }
+#endif // _HAS_CXX23
+
+    iterator insert(const_iterator _Where, const _Ty& _Val) {
+        return emplace(_Where, _Val);
+    }
+
+    iterator insert(const_iterator _Where, _Ty&& _Val) {
+        return emplace(_Where, _STD move(_Val));
+    }
+
+    iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) {
+        // insert _Count * _Val at _Where
+        size_type _Off = static_cast<size_type>(_Where - begin());
+        _Insert_n(_Where, _Count, _Val);
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
+        // insert [_First, _Last) at _Where
+        _STD _Adl_verify_range(_First, _Last);
+        const size_type _Off = static_cast<size_type>(_Where - begin());
+        return _Insert_range<static_cast<_Is_bidi>(_Is_cpp17_bidi_iter_v<_Iter>)>(
+            _Off, _STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+        const size_type _Off = static_cast<size_type>(_Where - begin());
+
+        if constexpr (_RANGES bidirectional_range<_Rng>) {
+            return _Insert_range<_Is_bidi::_Yes>(
+                _Off, _RANGES _Ubegin(_Range), _RANGES _Get_final_iterator_unwrapped(_Range));
+        } else {
+            return _Insert_range<_Is_bidi::_Nope>(_Off, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) {
+        return insert(_Where, _Ilist.begin(), _Ilist.end());
+    }
+
+private:
+    enum class _Pop_direction : bool {
+        _Front,
+        _Back,
+    };
+
+    template <_Pop_direction _Direction>
+    struct _NODISCARD _Restore_old_size_guard {
+        deque* _Container;
+        const size_type _Oldsize;
+
+        ~_Restore_old_size_guard() { // restore old size, at least
+            if (_Container) {
+                while (_Oldsize < _Container->_Mysize()) {
+                    if constexpr (_Direction == _Pop_direction::_Front) {
+                        _Container->pop_front();
+                    } else {
+                        _Container->pop_back();
+                    }
+                }
+            }
+        }
+    };
+
+    enum class _Is_bidi : bool { _Nope, _Yes };
+
+    template <_Is_bidi _Bidi, class _Iter, class _Sent>
+    iterator _Insert_range(const size_type _Off, _Iter _First, _Sent _Last) {
+        // insert [_First, _Last) at begin() + _Off
+        // Pre: _Bidi == _Is_bidi::_Yes implies that _Iter and _Sent are the same type, and that
+        //      _Iter is either a bidirectional_iterator or a Cpp17BidirectionalIterator.
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Mysize() >= _Off, "deque insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_First == _Last) {
+            return begin() + static_cast<difference_type>(_Off);
+        }
+
+        const size_type _Oldsize = _Mysize();
+
+        _Orphan_all();
+        if (_Off <= _Oldsize / 2) { // closer to front, push to front then rotate
+            _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
+            if constexpr (_Bidi == _Is_bidi::_Yes) {
+                while (_First != _Last) {
+                    _Emplace_front_internal(*--_Last); // prepend in order
+                }
+            } else {
+                for (; _First != _Last; ++_First) {
+                    _Emplace_front_internal(*_First); // prepend flipped
+                }
+            }
+
+            _Guard._Container = nullptr;
+
+            const auto _Num     = static_cast<difference_type>(_Mysize() - _Oldsize);
+            const auto _Myfirst = _Unchecked_begin();
+            const auto _Mymid   = _Myfirst + _Num;
+            if constexpr (_Bidi == _Is_bidi::_Nope) {
+                _STD reverse(_Myfirst, _Mymid); // flip new stuff in place
+            }
+            _STD rotate(_Myfirst, _Mymid, _Mymid + static_cast<difference_type>(_Off));
+            return begin() + static_cast<difference_type>(_Off);
+        }
+
+        _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
+        for (; _First != _Last; ++_First) {
+            _Emplace_back_internal(*_First);
+        }
+
+        _Guard._Container = nullptr;
+
+        const auto _Myfirst = _Unchecked_begin();
+        _STD rotate(_Myfirst + static_cast<difference_type>(_Off), _Myfirst + static_cast<difference_type>(_Oldsize),
+            _Unchecked_end());
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    void _Insert_n(const_iterator _Where, size_type _Count, const _Ty& _Val) { // insert _Count * _Val at _Where
+        _Unchecked_iterator _Mid;
+        size_type _Num;
+        size_type _Off     = static_cast<size_type>(_Where - begin());
+        size_type _Oldsize = _Mysize();
+        size_type _Rem     = _Oldsize - _Off;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Off <= _Oldsize, "deque insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Off < _Rem) { // closer to front
+            _Restore_old_size_guard<_Pop_direction::_Front> _Guard{this, _Oldsize};
+            if (_Off < _Count) { // insert longer than prefix
+                for (_Num = _Count - _Off; _Num > 0; --_Num) {
+                    push_front(_Val); // push excess values
+                }
+                for (_Num = _Off; _Num > 0; --_Num) {
+                    push_front(_Subscript(_Count - 1)); // push prefix
+                }
+
+                _Mid = _Unchecked_begin() + static_cast<difference_type>(_Count);
+                _STD fill_n(_Mid, _Off, _Val); // fill in rest of values
+            } else { // insert not longer than prefix
+                for (_Num = _Count; _Num > 0; --_Num) {
+                    push_front(_Subscript(_Count - 1)); // push part of prefix
+                }
+
+                _Mid = _Unchecked_begin() + static_cast<difference_type>(_Count);
+                _Alloc_temporary2<_Alty> _Tmp(_Getal(), _Val); // in case _Val is in sequence
+                _STD move(_Mid + static_cast<difference_type>(_Count), _Mid + static_cast<difference_type>(_Off),
+                    _Mid); // copy rest of prefix
+                _STD fill(_Unchecked_begin() + static_cast<difference_type>(_Off),
+                    _Mid + static_cast<difference_type>(_Off), _Tmp._Get_value()); // fill in values
+            }
+            _Guard._Container = nullptr;
+        } else { // closer to back
+            _Restore_old_size_guard<_Pop_direction::_Back> _Guard{this, _Oldsize};
+            if (_Rem < _Count) { // insert longer than suffix
+                _Orphan_all();
+                for (_Num = _Count - _Rem; _Num > 0; --_Num) {
+                    _Emplace_back_internal(_Val); // push excess values
+                }
+                for (_Num = 0; _Num < _Rem; ++_Num) {
+                    _Emplace_back_internal(_Subscript(_Off + _Num)); // push suffix
+                }
+
+                _Mid = _Unchecked_begin() + static_cast<difference_type>(_Off);
+                _STD fill_n(_Mid, _Rem, _Val); // fill in rest of values
+            } else { // insert not longer than prefix
+                for (_Num = 0; _Num < _Count; ++_Num) {
+                    _Emplace_back_internal(_Subscript(_Off + _Rem - _Count + _Num)); // push part of prefix
+                }
+
+                _Mid = _Unchecked_begin() + static_cast<difference_type>(_Off);
+                _Alloc_temporary2<_Alty> _Tmp(_Getal(), _Val); // in case _Val is in sequence
+                _STD move_backward(_Mid, _Mid + static_cast<difference_type>(_Rem - _Count),
+                    _Mid + static_cast<difference_type>(_Rem)); // copy rest of prefix
+                _STD fill_n(_Mid, _Count, _Tmp._Get_value()); // fill in values
+            }
+            _Guard._Container = nullptr;
+        }
+    }
+
+public:
+    void pop_front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_DEQUE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!empty(), "pop_front() called on empty deque");
+#endif
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Orphan_off(_Myoff());
+#endif
+        _Alty_traits::destroy(_Getal(), _Get_data()._Address_subscript(_Myoff()));
+        if (--_Mysize() == 0) {
+            _Myoff() = 0;
+        } else {
+            ++_Myoff();
+        }
+    }
+
+    void pop_back() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_DEQUE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!empty(), "pop_back() called on empty deque");
+#endif
+
+        size_type _Newoff = _Myoff() + _Mysize() - 1;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Orphan_off(_Newoff);
+#endif
+        _Alty_traits::destroy(_Getal(), _Get_data()._Address_subscript(_Newoff));
+        if (--_Mysize() == 0) {
+            _Myoff() = 0;
+        }
+    }
+
+    iterator erase(const_iterator _Where) noexcept(is_nothrow_move_assignable_v<value_type>) /* strengthened */ {
+        return erase(_Where, _Next_iter(_Where));
+    }
+
+    iterator erase(const_iterator _First_arg, const_iterator _Last_arg)
+        noexcept(is_nothrow_move_assignable_v<value_type>) /* strengthened */ {
+        iterator _First = _Make_iter(_First_arg);
+        iterator _Last  = _Make_iter(_Last_arg);
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_First <= _Last && begin() <= _First && _Last <= end(), "deque erase iterator outside range");
+        _STD _Adl_verify_range(_First, _Last);
+#endif
+
+        auto _Off   = static_cast<size_type>(_First - begin());
+        auto _Count = static_cast<size_type>(_Last - _First);
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const bool _Moved = _Off > 0 && _Off + _Count < _Mysize();
+#endif
+
+        if (_Count == 0) {
+            return _First;
+        }
+
+        auto _Unchecked_first = _First._Unwrapped();
+        auto _Unchecked_last  = _Last._Unwrapped();
+
+        if (_Off < static_cast<size_type>(_Unchecked_end() - _Unchecked_last)) { // closer to front
+            _STD move_backward(_Unchecked_begin(), _Unchecked_first, _Unchecked_last); // copy over hole
+            for (; _Count > 0; --_Count) {
+                pop_front(); // pop copied elements
+            }
+        } else { // closer to back
+            _STD move(_Unchecked_last, _Unchecked_end(), _Unchecked_first); // copy over hole
+            for (; _Count > 0; --_Count) {
+                pop_back(); // pop copied elements
+            }
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        if (_Moved) {
+            _Orphan_all();
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+private:
+    void _Erase_last_n(size_type _Count) noexcept {
+        for (; _Count > 0; --_Count) {
+            pop_back();
+        }
+    }
+
+public:
+    void clear() noexcept { // erase all
+        _Tidy();
+    }
+
+    void swap(deque& _Right) noexcept /* strengthened */ {
+        using _STD swap;
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+            auto& _My_data    = _Get_data();
+            auto& _Right_data = _Right._Get_data();
+            _My_data._Swap_proxy_and_iterators(_Right_data);
+            swap(_My_data._Map, _Right_data._Map); // intentional ADL
+            _STD swap(_My_data._Mapsize, _Right_data._Mapsize);
+            _STD swap(_My_data._Myoff, _Right_data._Myoff);
+            _STD swap(_My_data._Mysize, _Right_data._Mysize);
+        }
+    }
+
+private:
+    [[noreturn]] static void _Xlen() {
+        _Xlength_error("deque<T> too long");
+    }
+
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid deque<T> subscript");
+    }
+
+    void _Growmap(size_type _Count) { // grow map by at least _Count pointers, _Mapsize() a power of 2
+        static_assert(_Minimum_map_size > 1, "The _Xlen() test should always be performed.");
+
+        _Alpty _Almap(_Getal());
+        size_type _Newsize = _Mapsize() > 0 ? _Mapsize() : 1;
+        while (_Newsize - _Mapsize() < _Count || _Newsize < _Minimum_map_size) {
+            // scale _Newsize to 2^N >= _Mapsize() + _Count
+            if (max_size() / _Block_size - _Newsize < _Newsize) {
+                _Xlen(); // result too long
+            }
+
+            _Newsize *= 2;
+        }
+
+        size_type _Allocsize = _Newsize;
+
+        const auto _Myboff  = static_cast<size_type>(_Myoff() / _Block_size);
+        const auto _Map_off = static_cast<_Map_difference_type>(_Myboff);
+        _Mapptr _Newmap     = _Allocate_at_least_helper(_Almap, _Allocsize);
+        _Mapptr _Myptr      = _Newmap + _Map_off;
+        _STL_ASSERT(_Allocsize >= _Newsize, "_Allocsize >= _Newsize");
+        while (_Newsize <= _Allocsize / 2) {
+            _Newsize *= 2;
+        }
+
+        _Count = _Newsize - _Mapsize();
+
+        const auto _Map_count = static_cast<_Map_difference_type>(_Count);
+
+        _Myptr = _STD uninitialized_copy(_Map() + _Map_off, _Map() + _Map_distance(), _Myptr); // copy initial to end
+        if (_Myboff <= _Count) { // increment greater than offset of initial block
+            _Myptr = _STD uninitialized_copy(_Map(), _Map() + _Map_off, _Myptr); // copy rest of old
+            _Uninitialized_value_construct_n_unchecked1(_Myptr, _Count - _Myboff); // clear suffix of new
+            _Uninitialized_value_construct_n_unchecked1(_Newmap, _Myboff); // clear prefix of new
+        } else { // increment not greater than offset of initial block
+            _STD uninitialized_copy(_Map(), _Map() + _Map_count, _Myptr); // copy more old
+            _Myptr = _STD uninitialized_copy(_Map() + _Map_count, _Map() + _Map_off, _Newmap); // copy rest of old
+            _Uninitialized_value_construct_n_unchecked1(_Myptr, _Count); // clear rest to initial block
+        }
+
+        if (_Map() != nullptr) {
+            _Destroy_range(_Map(), _Map() + _Map_distance());
+            _Almap.deallocate(_Map(), _Mapsize()); // free storage for old
+        }
+
+        _Map() = _Newmap; // point at new
+        _Mapsize() += _Count;
+    }
+
+    void _Reset_map() noexcept {
+        // pre: each block pointer is either null or pointing to a block without constructed elements
+
+        for (auto _Block = _Map_distance(); _Block > 0;) { // free storage for a block and destroy pointer
+            --_Block;
+            auto& _Block_ptr = _Map()[_Block];
+            if (_Block_ptr) { // free block
+                _Getal().deallocate(_Block_ptr, _Block_size);
+            }
+            _STD _Destroy_in_place(_Block_ptr); // destroy pointer to block
+        }
+
+        _Alpty _Almap(_Getal());
+        _Almap.deallocate(_Map(), _Mapsize()); // free storage for map
+
+        _Map()     = nullptr;
+        _Mapsize() = 0;
+    }
+
+    void _Tidy() noexcept { // free all storage
+        _Orphan_all();
+
+        while (!empty()) {
+            pop_back();
+        }
+
+        if (_Map() != nullptr) {
+            _Reset_map();
+        }
+
+        _STL_INTERNAL_CHECK(_Mapsize() == 0); // null map should always be paired with zero mapsize
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    void _Orphan_off(size_type _Offlo) const noexcept { // orphan iterators with specified offset(s)
+        size_type _Offhigh = _Myoff() + _Mysize() <= _Offlo + 1 ? static_cast<size_type>(-1) : _Offlo;
+        if (_Offlo == _Myoff()) {
+            _Offlo = 0;
+        }
+
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &_Get_data()._Myproxy->_Myfirstiter;
+        while (*_Pnext) {
+            const auto _Pnextoff = static_cast<const_iterator&>(**_Pnext)._Myoff;
+            if (_Pnextoff < _Offlo || _Offhigh < _Pnextoff) {
+                _Pnext = &(*_Pnext)->_Mynextiter;
+            } else { // orphan the iterator
+                (*_Pnext)->_Myproxy = nullptr;
+                *_Pnext             = (*_Pnext)->_Mynextiter;
+            }
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    _Map_difference_type _Getblock(size_type _Off) const noexcept {
+        return _Get_data()._Getblock(_Off);
+    }
+
+    void _Orphan_all() noexcept {
+        _Get_data()._Orphan_all();
+    }
+
+    _Alty& _Getal() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    const _Alty& _Getal() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _Scary_val& _Get_data() noexcept {
+        return _Mypair._Myval2;
+    }
+
+    const _Scary_val& _Get_data() const noexcept {
+        return _Mypair._Myval2;
+    }
+
+    _Mapptr& _Map() noexcept {
+        return _Get_data()._Map;
+    }
+
+    const _Mapptr& _Map() const noexcept {
+        return _Get_data()._Map;
+    }
+
+    size_type& _Mapsize() noexcept {
+        return _Get_data()._Mapsize;
+    }
+
+    const size_type& _Mapsize() const noexcept {
+        return _Get_data()._Mapsize;
+    }
+
+    size_type& _Myoff() noexcept {
+        return _Get_data()._Myoff;
+    }
+
+    const size_type& _Myoff() const noexcept {
+        return _Get_data()._Myoff;
+    }
+
+    size_type& _Mysize() noexcept {
+        return _Get_data()._Mysize;
+    }
+
+    const size_type& _Mysize() const noexcept {
+        return _Get_data()._Mysize;
+    }
+
+    _Map_difference_type _Map_distance() const noexcept {
+        return static_cast<_Map_difference_type>(_Get_data()._Mapsize);
+    }
+
+    reference _Subscript(size_type _Pos) noexcept {
+        return _Get_data()._Subscript(_Myoff() + _Pos);
+    }
+
+    const_reference _Subscript(size_type _Pos) const noexcept {
+        return _Get_data()._Subscript(_Myoff() + _Pos);
+    }
+
+    _Compressed_pair<_Alty, _Scary_val> _Mypair;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+deque(_Iter, _Iter, _Alloc = _Alloc()) -> deque<_Iter_value_t<_Iter>, _Alloc>;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+deque(from_range_t, _Rng&&, _Alloc = _Alloc()) -> deque<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+void swap(deque<_Ty, _Alloc>& _Left, deque<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD bool operator==(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
+    return _Left.size() == _Right.size()
+        && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD _Synth_three_way_result<_Ty> operator<=>(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
+    return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
+        _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator!=(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator<(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
+    return _STD lexicographical_compare(
+        _Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin(), _Right._Unchecked_end());
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator<=(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator>(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator>=(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
+deque<_Ty, _Alloc>::size_type erase(deque<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
+    return _STD _Erase_remove(_Cont, _Val);
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
+deque<_Ty, _Alloc>::size_type erase_if(deque<_Ty, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Ty>
+    using deque = _STD deque<_Ty, polymorphic_allocator<_Ty>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <class _Ty, class _Alloc>
+constexpr bool _Has_guaranteed_push_back<deque<_Ty, _Alloc>> = true;
+
+template <class _Ty, class _Alloc>
+constexpr bool _Has_guaranteed_append_range<deque<_Ty, _Alloc>> = true;
+#endif // _HAS_CXX23
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _DEQUE_
diff --git a/msvc-stl/stl/inc/exception b/msvc-stl/stl/inc/exception
new file mode 100644
index 0000000..7804935
--- /dev/null
+++ b/msvc-stl/stl/inc/exception
@@ -0,0 +1,442 @@
+// exception standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _EXCEPTION_
+#define _EXCEPTION_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdlib>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+#if _HAS_DEPRECATED_UNCAUGHT_EXCEPTION
+_EXPORT_STD extern "C++" _CXX17_DEPRECATE_UNCAUGHT_EXCEPTION _NODISCARD _CRTIMP2_PURE bool
+    __CLRCALL_PURE_OR_CDECL uncaught_exception() noexcept;
+#endif // _HAS_DEPRECATED_UNCAUGHT_EXCEPTION
+_EXPORT_STD extern "C++" _NODISCARD _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL uncaught_exceptions() noexcept;
+
+_STD_END
+
+#if _HAS_EXCEPTIONS
+
+#include <malloc.h> // TRANSITION, VSO-2048380: This is unnecessary, but many projects assume it as of 2024-04-29
+#include <vcruntime_exception.h>
+
+_STD_BEGIN
+
+_EXPORT_STD using ::terminate;
+
+#ifndef _M_CEE_PURE
+_EXPORT_STD using ::set_terminate;
+_EXPORT_STD using ::terminate_handler;
+
+_EXPORT_STD _NODISCARD inline terminate_handler __CRTDECL get_terminate() noexcept {
+    // get current terminate handler
+    return _get_terminate();
+}
+#endif // !defined(_M_CEE_PURE)
+
+#if _HAS_UNEXPECTED
+using ::unexpected;
+
+#ifndef _M_CEE_PURE
+using ::set_unexpected;
+using ::unexpected_handler;
+
+_NODISCARD inline unexpected_handler __CRTDECL get_unexpected() noexcept {
+    // get current unexpected handler
+    return _get_unexpected();
+}
+#endif // !defined(_M_CEE_PURE)
+#endif // _HAS_UNEXPECTED
+
+_STD_END
+
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+
+#pragma push_macro("stdext")
+#undef stdext
+
+#define _STDEXT_BEGIN      \
+    _EXTERN_CXX_WORKAROUND \
+    namespace stdext {
+
+#define _STDEXT_END \
+    }               \
+    _END_EXTERN_CXX_WORKAROUND
+
+#define _STDEXT ::stdext::
+
+_STDEXT_BEGIN
+class _NODISCARD exception;
+_STDEXT_END
+
+_STD_BEGIN
+
+_EXPORT_STD using _STDEXT exception;
+
+using _Prhand = void(__cdecl*)(const exception&);
+
+extern _CRTIMP2_PURE_IMPORT _Prhand _Raise_handler; // pointer to raise handler
+
+_STD_END
+
+_STDEXT_BEGIN
+class _NODISCARD exception { // base of all library exceptions
+public:
+    static _STD _Prhand _Set_raise_handler(_STD _Prhand _Pnew) { // register a handler for _Raise calls
+        const _STD _Prhand _Pold = _STD _Raise_handler;
+        _STD _Raise_handler      = _Pnew;
+        return _Pold;
+    }
+
+    // this constructor is necessary to compile
+    // successfully header new for _HAS_EXCEPTIONS==0 scenario
+    explicit __CLR_OR_THIS_CALL exception(const char* _Message = "unknown", int = 1) noexcept : _Ptr(_Message) {}
+
+    __CLR_OR_THIS_CALL exception(const exception& _Right) noexcept : _Ptr(_Right._Ptr) {}
+
+    exception& __CLR_OR_THIS_CALL operator=(const exception& _Right) noexcept {
+        _Ptr = _Right._Ptr;
+        return *this;
+    }
+
+    virtual __CLR_OR_THIS_CALL ~exception() noexcept {}
+
+    _NODISCARD virtual const char* __CLR_OR_THIS_CALL what() const noexcept { // return pointer to message string
+        return _Ptr ? _Ptr : "unknown exception";
+    }
+
+    [[noreturn]] void __CLR_OR_THIS_CALL _Raise() const { // raise the exception
+        if (_STD _Raise_handler) {
+            (*_STD _Raise_handler)(*this); // call raise handler if present
+        }
+
+        _Doraise(); // call the protected virtual
+        _RAISE(*this); // raise this exception
+    }
+
+protected:
+    virtual void __CLR_OR_THIS_CALL _Doraise() const {} // perform class-specific exception handling
+
+    const char* _Ptr; // the message pointer
+};
+
+class _NODISCARD bad_exception : public exception { // base of all bad exceptions
+public:
+    __CLR_OR_THIS_CALL bad_exception(const char* _Message = "bad exception") noexcept : exception(_Message) {}
+
+    __CLR_OR_THIS_CALL ~bad_exception() noexcept override {}
+
+protected:
+    void __CLR_OR_THIS_CALL _Doraise() const override { // raise this exception
+        _RAISE(*this);
+    }
+};
+
+class _NODISCARD bad_array_new_length;
+
+class _NODISCARD bad_alloc : public exception { // base of all bad allocation exceptions
+public:
+    __CLR_OR_THIS_CALL bad_alloc() noexcept
+        : exception("bad allocation", 1) {} // construct from message string with no memory allocation
+
+    __CLR_OR_THIS_CALL ~bad_alloc() noexcept override {}
+
+private:
+    friend bad_array_new_length;
+
+    __CLR_OR_THIS_CALL bad_alloc(const char* _Message) noexcept
+        : exception(_Message, 1) {} // construct from message string with no memory allocation
+
+protected:
+    void __CLR_OR_THIS_CALL _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+};
+
+class _NODISCARD bad_array_new_length : public bad_alloc {
+public:
+    bad_array_new_length() noexcept : bad_alloc("bad array new length") {}
+};
+
+_STDEXT_END
+
+_STD_BEGIN
+_EXPORT_STD using terminate_handler = void(__cdecl*)();
+
+_EXPORT_STD inline terminate_handler __CRTDECL set_terminate(terminate_handler) noexcept {
+    // register a terminate handler
+    return nullptr;
+}
+
+_EXPORT_STD [[noreturn]] inline void __CRTDECL terminate() noexcept {
+    // handle exception termination
+    _CSTD abort();
+}
+
+_EXPORT_STD _NODISCARD inline terminate_handler __CRTDECL get_terminate() noexcept {
+    // get current terminate handler
+    return nullptr;
+}
+
+#if _HAS_UNEXPECTED
+using unexpected_handler = void(__cdecl*)();
+
+inline unexpected_handler __CRTDECL set_unexpected(unexpected_handler) noexcept {
+    // register an unexpected handler
+    return nullptr;
+}
+
+inline void __CRTDECL unexpected() {} // handle unexpected exception
+
+_NODISCARD inline unexpected_handler __CRTDECL get_unexpected() noexcept {
+    // get current unexpected handler
+    return nullptr;
+}
+#endif // _HAS_UNEXPECTED
+
+_EXPORT_STD using _STDEXT bad_alloc;
+_EXPORT_STD using _STDEXT bad_array_new_length;
+_EXPORT_STD using _STDEXT bad_exception;
+
+_STD_END
+
+#undef _STDEXT_BEGIN
+#undef _STDEXT_END
+#undef _STDEXT
+
+#pragma pop_macro("stdext")
+
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void*, _In_ const void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrAssign(_Inout_ void*, _In_ const void*) noexcept;
+extern "C++" _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrCompare(
+    _In_ const void*, _In_ const void*) noexcept;
+extern "C++" _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrToBool(_In_ const void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(_Inout_ void*, _Inout_ void*) noexcept;
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCurrentException(void*) noexcept;
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrRethrow(_In_ const void*);
+extern "C++" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopyException(
+    _Inout_ void*, _In_ const void*, _In_ const void*) noexcept;
+
+_STD_BEGIN
+
+_EXPORT_STD class exception_ptr {
+public:
+    exception_ptr() noexcept {
+        __ExceptionPtrCreate(this);
+    }
+
+    exception_ptr(nullptr_t) noexcept {
+        __ExceptionPtrCreate(this);
+    }
+
+    ~exception_ptr() noexcept {
+        __ExceptionPtrDestroy(this);
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        const auto _Tombstone{reinterpret_cast<void*>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+        _Data1 = _Tombstone;
+        _Data2 = _Tombstone;
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    }
+
+    exception_ptr(const exception_ptr& _Rhs) noexcept {
+        __ExceptionPtrCopy(this, &_Rhs);
+    }
+
+    exception_ptr& operator=(const exception_ptr& _Rhs) noexcept {
+        __ExceptionPtrAssign(this, &_Rhs);
+        return *this;
+    }
+
+    exception_ptr& operator=(nullptr_t) noexcept {
+        exception_ptr _Ptr;
+        __ExceptionPtrAssign(this, &_Ptr);
+        return *this;
+    }
+
+    explicit operator bool() const noexcept {
+        return __ExceptionPtrToBool(this);
+    }
+
+    static exception_ptr _Copy_exception(_In_ void* _Except, _In_ const void* _Ptr) {
+        exception_ptr _Retval;
+        if (!_Ptr) {
+            // unsupported exceptions
+            return _Retval;
+        }
+        __ExceptionPtrCopyException(&_Retval, _Except, _Ptr);
+        return _Retval;
+    }
+
+    friend void swap(exception_ptr& _Lhs, exception_ptr& _Rhs) noexcept {
+        __ExceptionPtrSwap(&_Lhs, &_Rhs);
+    }
+
+    _NODISCARD friend bool operator==(const exception_ptr& _Lhs, const exception_ptr& _Rhs) noexcept {
+        return __ExceptionPtrCompare(&_Lhs, &_Rhs);
+    }
+
+    _NODISCARD friend bool operator==(const exception_ptr& _Lhs, nullptr_t) noexcept {
+        return !_Lhs;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator==(nullptr_t, const exception_ptr& _Rhs) noexcept {
+        return !_Rhs;
+    }
+
+    _NODISCARD friend bool operator!=(const exception_ptr& _Lhs, const exception_ptr& _Rhs) noexcept {
+        return !(_Lhs == _Rhs);
+    }
+
+    _NODISCARD friend bool operator!=(const exception_ptr& _Lhs, nullptr_t) noexcept {
+        return !(_Lhs == nullptr);
+    }
+
+    _NODISCARD friend bool operator!=(nullptr_t, const exception_ptr& _Rhs) noexcept {
+        return !(nullptr == _Rhs);
+    }
+#endif // !_HAS_CXX20
+
+private:
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+#endif // defined(__clang__)
+    void* _Data1{};
+    void* _Data2{};
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+};
+
+_EXPORT_STD _NODISCARD inline exception_ptr current_exception() noexcept {
+    exception_ptr _Retval;
+    __ExceptionPtrCurrentException(&_Retval);
+    return _Retval;
+}
+
+_EXPORT_STD [[noreturn]] inline void rethrow_exception(_In_ exception_ptr _Ptr) {
+    __ExceptionPtrRethrow(&_Ptr);
+}
+
+template <class _Ex>
+void* __GetExceptionInfo(_Ex);
+
+_EXPORT_STD template <class _Ex>
+_NODISCARD_SMART_PTR_ALLOC exception_ptr make_exception_ptr(_Ex _Except) noexcept {
+    return exception_ptr::_Copy_exception(_STD addressof(_Except), __GetExceptionInfo(_Except));
+}
+
+_EXPORT_STD class nested_exception { // wrap an exception_ptr
+public:
+    nested_exception() noexcept : _Exc(_STD current_exception()) {}
+
+    nested_exception(const nested_exception&) noexcept            = default;
+    nested_exception& operator=(const nested_exception&) noexcept = default;
+    virtual ~nested_exception() noexcept {}
+
+    [[noreturn]] void rethrow_nested() const { // throw wrapped exception_ptr
+        if (_Exc) {
+            _STD rethrow_exception(_Exc);
+        } else {
+            _STD terminate(); // per N4950 [except.nested]/4
+        }
+    }
+
+    _NODISCARD exception_ptr nested_ptr() const noexcept { // return wrapped exception_ptr
+        return _Exc;
+    }
+
+private:
+    exception_ptr _Exc;
+};
+
+template <class _Uty>
+struct _With_nested_v2 : _Uty, nested_exception { // glue user exception to nested_exception
+    template <class _Ty>
+    explicit _With_nested_v2(_Ty&& _Arg)
+        : _Uty(_STD forward<_Ty>(_Arg)), nested_exception() {} // store user exception and current_exception()
+};
+
+_EXPORT_STD template <class _Ty>
+[[noreturn]] void throw_with_nested(_Ty&& _Arg) {
+    // throw user exception, glued to nested_exception if possible
+    using _Uty = decay_t<_Ty>;
+
+    if constexpr (is_class_v<_Uty> && !is_base_of_v<nested_exception, _Uty> && !is_final_v<_Uty>) {
+        // throw user exception glued to nested_exception
+        _THROW(_With_nested_v2<_Uty>(_STD forward<_Ty>(_Arg)));
+    } else {
+        // throw user exception by itself
+        _THROW(_STD forward<_Ty>(_Arg));
+    }
+}
+
+#ifdef _CPPRTTI
+_EXPORT_STD template <class _Ty>
+void rethrow_if_nested(const _Ty& _Arg) {
+    // detect nested_exception inheritance
+    constexpr bool _Can_use_dynamic_cast =
+        is_polymorphic_v<_Ty> && (!is_base_of_v<nested_exception, _Ty> || is_convertible_v<_Ty*, nested_exception*>);
+
+    if constexpr (_Can_use_dynamic_cast) {
+        const auto _Nested = dynamic_cast<const nested_exception*>(_STD addressof(_Arg));
+
+        if (_Nested) {
+            _Nested->rethrow_nested();
+        }
+    }
+}
+#else // ^^^ defined(_CPPRTTI) / !defined(_CPPRTTI) vvv
+_EXPORT_STD template <class _Ty>
+void rethrow_if_nested(const _Ty&) = delete; // requires /GR option
+#endif // ^^^ !defined(_CPPRTTI) ^^^
+
+_EXPORT_STD class _NODISCARD bad_variant_access : public exception {
+    // exception for visit of a valueless variant or get<I> on a variant with index() != I
+public:
+    bad_variant_access() noexcept = default;
+
+    _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
+        return "bad variant access";
+    }
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+};
+
+[[noreturn]] inline void _Throw_bad_variant_access() {
+    _THROW(bad_variant_access{});
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _EXCEPTION_
diff --git a/msvc-stl/stl/inc/execution b/msvc-stl/stl/inc/execution
new file mode 100644
index 0000000..b45860b
--- /dev/null
+++ b/msvc-stl/stl/inc/execution
@@ -0,0 +1,5381 @@
+// execution standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _EXECUTION_
+#define _EXECUTION_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <execution> are available only with C++17 or later.");
+#else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#include <algorithm>
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <numeric>
+#include <queue>
+#include <vector>
+#include <xbit_ops.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+#ifdef _M_CEE
+using __std_TP_WORK              = void;
+using __std_TP_CALLBACK_INSTANCE = void;
+using __std_TP_CALLBACK_ENVIRON  = void;
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+struct __std_TP_WORK; // not defined
+struct __std_TP_CALLBACK_INSTANCE; // not defined
+struct __std_TP_CALLBACK_ENVIRON; // not defined
+#endif // ^^^ !defined(_M_CEE) ^^^
+
+using __std_PTP_WORK              = __std_TP_WORK*;
+using __std_PTP_CALLBACK_INSTANCE = __std_TP_CALLBACK_INSTANCE*;
+using __std_PTP_CALLBACK_ENVIRON  = __std_TP_CALLBACK_ENVIRON*;
+
+_NODISCARD unsigned int __stdcall __std_parallel_algorithms_hw_threads() noexcept;
+
+using __std_PTP_WORK_CALLBACK = void(__stdcall*)(
+    _Inout_ __std_PTP_CALLBACK_INSTANCE, _Inout_opt_ void*, _Inout_ __std_PTP_WORK);
+
+_NODISCARD __std_PTP_WORK __stdcall __std_create_threadpool_work(
+    _In_ __std_PTP_WORK_CALLBACK, _Inout_opt_ void*, _In_opt_ __std_PTP_CALLBACK_ENVIRON) noexcept;
+
+void __stdcall __std_submit_threadpool_work(_Inout_ __std_PTP_WORK) noexcept;
+
+void __stdcall __std_bulk_submit_threadpool_work(_Inout_ __std_PTP_WORK, _In_ size_t) noexcept;
+
+void __stdcall __std_close_threadpool_work(_Inout_ __std_PTP_WORK) noexcept;
+
+void __stdcall __std_wait_for_threadpool_work_callbacks(_Inout_ __std_PTP_WORK, _In_ int) noexcept;
+
+void __stdcall __std_execution_wait_on_uchar(
+    _In_ const volatile unsigned char* _Address, _In_ unsigned char _Compare) noexcept;
+
+void __stdcall __std_execution_wake_by_address_all(_In_ const volatile void* _Address) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+inline constexpr size_t _Oversubscription_multiplier = 32;
+inline constexpr size_t _Oversubmission_multiplier   = 4;
+inline constexpr size_t _Still_active                = static_cast<size_t>(-1);
+
+namespace execution {
+    _EXPORT_STD class sequenced_policy {
+        // indicates support for only sequential execution, and requests termination on exceptions
+    public:
+        explicit sequenced_policy() = default; // per LWG-4273
+
+        using _Standard_execution_policy   = int;
+        static constexpr bool _Parallelize = false;
+        static constexpr bool _Ivdep       = false;
+    };
+
+    _EXPORT_STD inline constexpr sequenced_policy seq{};
+
+    _EXPORT_STD class parallel_policy {
+        // indicates support by element access functions for parallel execution with parallel forward progress
+        // guarantees, and requests termination on exceptions
+    public:
+        explicit parallel_policy() = default; // per LWG-4273
+
+        using _Standard_execution_policy   = int;
+        static constexpr bool _Parallelize = true;
+        static constexpr bool _Ivdep       = true;
+    };
+
+    _EXPORT_STD inline constexpr parallel_policy par{};
+
+    _EXPORT_STD class parallel_unsequenced_policy {
+        // indicates support by element access functions for parallel execution with weakly parallel forward progress
+        // guarantees, and requests termination on exceptions
+        //
+        // (at this time, equivalent to parallel_policy)
+    public:
+        explicit parallel_unsequenced_policy() = default; // per LWG-4273
+
+        using _Standard_execution_policy   = int;
+        static constexpr bool _Parallelize = true;
+        static constexpr bool _Ivdep       = true;
+    };
+
+    _EXPORT_STD inline constexpr parallel_unsequenced_policy par_unseq{};
+
+#if _HAS_CXX20
+    _EXPORT_STD class unsequenced_policy {
+        // indicates support by element access functions for weakly parallel forward progress guarantees, and for
+        // executing interleaved on the same thread, and requests termination on exceptions
+        //
+        // (at this time, equivalent to sequenced_policy except for for_each(_n), destroy(_n),
+        // uninitialized_default_construct(_n), and uninitialized_value_construct(_n))
+    public:
+        explicit unsequenced_policy() = default; // per LWG-4273
+
+        using _Standard_execution_policy   = int;
+        static constexpr bool _Parallelize = false;
+        static constexpr bool _Ivdep       = true;
+    };
+
+    _EXPORT_STD inline constexpr unsequenced_policy unseq{};
+#endif // _HAS_CXX20
+
+} // namespace execution
+
+// All of the above are execution policies:
+template <>
+struct is_execution_policy<execution::sequenced_policy> : true_type {};
+
+template <>
+struct is_execution_policy<execution::parallel_policy> : true_type {};
+
+template <>
+struct is_execution_policy<execution::parallel_unsequenced_policy> : true_type {};
+
+#if _HAS_CXX20
+template <>
+struct is_execution_policy<execution::unsequenced_policy> : true_type {};
+#endif // _HAS_CXX20
+
+template <class _Ty, class _UnaryOp, class _FwdIt>
+void _Construct_in_place_by_transform_deref(_Ty& _Val, _UnaryOp _Transform_op, const _FwdIt& _Iter) {
+    ::new (static_cast<void*>(_STD addressof(_Val))) _Ty(_Transform_op(*_Iter));
+}
+
+template <class _Ty, class _BinaryOp, class _ArgTy>
+void _Implicitly_construct_in_place_by_binary_op(_Ty& _Val, _BinaryOp _Reduce_op, _ArgTy& _Left, _ArgTy& _Right) {
+    ::new (static_cast<void*>(_STD addressof(_Val))) _Ty([&]() -> _Ty { return _Reduce_op(_Left, _Right); }());
+}
+
+template <class _Ty, class _BinaryOp, class _LeftTy, class _FwdIt>
+void _Implicitly_construct_in_place_by_binary_op_deref_rhs(
+    _Ty& _Val, _BinaryOp _Reduce_op, _LeftTy&& _Left, const _FwdIt& _Iter) {
+    ::new (static_cast<void*>(_STD addressof(_Val)))
+        _Ty([&]() -> _Ty { return _Reduce_op(_STD forward<_LeftTy>(_Left), *_Iter); }());
+}
+
+template <class _Ty, class _BinaryOp, class _UnaryOp, class _LeftTy, class _FwdIt>
+void _Implicitly_construct_in_place_by_binary_op_transform_deref_rhs(
+    _Ty& _Val, _BinaryOp _Reduce_op, _UnaryOp _Transform_op, _LeftTy&& _Left, const _FwdIt& _Iter) {
+    ::new (static_cast<void*>(_STD addressof(_Val)))
+        _Ty([&]() -> _Ty { return _Reduce_op(_STD forward<_LeftTy>(_Left), _Transform_op(*_Iter)); }());
+}
+
+struct _NODISCARD _Parallelism_resources_exhausted : exception {
+    _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
+        // return pointer to message string
+        return "Insufficient resources were available to use additional parallelism.";
+    }
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+[[noreturn]] inline void _Throw_parallelism_resources_exhausted() {
+    _THROW(_Parallelism_resources_exhausted{});
+}
+
+enum class _Cancellation_status : bool { _Running, _Canceled };
+
+struct _Cancellation_token {
+    atomic<_Cancellation_status> _Is_canceled_impl{_Cancellation_status::_Running};
+
+    bool _Is_canceled() const {
+        return _Is_canceled_impl.load() == _Cancellation_status::_Canceled;
+    }
+
+    bool _Is_canceled_relaxed() const {
+        return _Is_canceled_impl.load(memory_order_relaxed) == _Cancellation_status::_Canceled;
+    }
+
+    void _Cancel() {
+        _Is_canceled_impl.store(_Cancellation_status::_Canceled);
+    }
+
+    _Cancellation_status _Status() const {
+        return _Is_canceled_impl.load();
+    }
+};
+
+class _Work_ptr {
+public:
+    template <class _Work, enable_if_t<!is_same_v<remove_cv_t<_Work>, _Work_ptr>, int> = 0>
+    explicit _Work_ptr(_Work& _Operation)
+        : _Ptp_work(::__std_create_threadpool_work(&_Work::_Threadpool_callback, _STD addressof(_Operation), nullptr)) {
+        // register work with the thread pool
+        // usually, after _Work_ptr is constructed, a parallel algorithm runs to completion or terminates
+        static_assert(noexcept(_Work::_Threadpool_callback(_STD declval<__std_PTP_CALLBACK_INSTANCE>(),
+                          _STD declval<void*>(), _STD declval<__std_PTP_WORK>())),
+            "Threadpool callbacks must be noexcept to enforce termination");
+        if (!_Ptp_work) {
+            // usually, the last place a bailout to serial execution can occur
+            _Throw_parallelism_resources_exhausted();
+        }
+    }
+
+    _Work_ptr(const _Work_ptr&)            = delete;
+    _Work_ptr& operator=(const _Work_ptr&) = delete;
+
+    ~_Work_ptr() noexcept {
+        __std_wait_for_threadpool_work_callbacks(_Ptp_work, true);
+        __std_close_threadpool_work(_Ptp_work);
+    }
+
+    void _Submit() const noexcept {
+        __std_submit_threadpool_work(_Ptp_work);
+    }
+
+    void _Submit(const size_t _Submissions) const noexcept {
+        __std_bulk_submit_threadpool_work(_Ptp_work, _Submissions);
+    }
+
+    void _Submit_for_chunks(const size_t _Hw_threads, const size_t _Chunks) const noexcept {
+        _Submit((_STD min) (_Hw_threads * _Oversubmission_multiplier, _Chunks));
+    }
+
+private:
+    __std_PTP_WORK _Ptp_work;
+};
+
+template <class _Work>
+void _Run_available_chunked_work(_Work& _Operation) {
+    while (_Operation._Process_chunk() == _Cancellation_status::_Running) { // process while there are chunks remaining
+    }
+}
+
+template <class _Work>
+void _Run_chunked_parallel_work(const size_t _Hw_threads, _Work& _Operation) {
+    // process chunks of _Operation on the thread pool
+    const _Work_ptr _Work_op{_Operation};
+    // setup complete, hereafter nothrow or terminate
+    _Work_op._Submit_for_chunks(_Hw_threads, _Operation._Team._Chunks);
+    _STD _Run_available_chunked_work(_Operation);
+}
+
+// The parallel algorithms library below assumes that distance(first, last) fits into a size_t;
+// forward iterators must refer to objects in memory and therefore must meet this requirement.
+//
+// Unlike the serial algorithms library, which can stay in the difference_type domain, here we need
+// to talk with vector (which speaks size_t), and with Windows, which wants to speak unsigned int.
+//
+// This assumption should be localized to the chunk calculation functions; the rest of
+// the library assumes that chunk numbers can be static_cast into the difference_type domain.
+
+template <class _Diff>
+constexpr size_t _Get_chunked_work_chunk_count(const size_t _Hw_threads, const _Diff _Count) {
+    // get the number of chunks to break work into to parallelize
+    const auto _Size_count = static_cast<size_t>(_Count); // no overflow due to forward iterators
+    // we assume _Hw_threads * _Oversubscription_multiplier does not overflow
+    return (_STD min) (_Hw_threads * _Oversubscription_multiplier, _Size_count);
+}
+
+template <class _Diff>
+constexpr size_t _Get_least2_chunked_work_chunk_count(const size_t _Hw_threads, const _Diff _Count) {
+    // get the number of chunks to break work into to parallelize, assuming chunks must be of size 2
+    const auto _Size_count = static_cast<size_t>(_Count); // no overflow due to forward iterators
+    // we assume _Hw_threads * _Oversubscription_multiplier does not overflow
+    return _Get_chunked_work_chunk_count(_Hw_threads, _Size_count / 2);
+}
+
+struct _Parallelism_allocate_traits {
+    __declspec(allocator) static void* _Allocate(const size_t _Bytes) {
+        void* _Result = ::operator new(_Bytes, nothrow);
+        if (!_Result) {
+            _Throw_parallelism_resources_exhausted();
+        }
+
+        return _Result;
+    }
+
+#ifdef __cpp_aligned_new
+    __declspec(allocator) static void* _Allocate_aligned(const size_t _Bytes, const size_t _Align) {
+        void* _Result = ::operator new(_Bytes, align_val_t{_Align}, nothrow);
+        if (!_Result) {
+            _Throw_parallelism_resources_exhausted();
+        }
+
+        return _Result;
+    }
+#endif // defined(__cpp_aligned_new)
+};
+
+template <class _Ty = void>
+struct _Parallelism_allocator {
+    using value_type = _Ty;
+
+    _Parallelism_allocator() = default;
+
+    template <class _Other>
+    constexpr _Parallelism_allocator(const _Parallelism_allocator<_Other>&) noexcept {}
+
+    _Ty* allocate(const size_t _Count) {
+        return static_cast<_Ty*>(
+            _Allocate<_New_alignof<_Ty>, _Parallelism_allocate_traits>(_Get_size_of_n<sizeof(_Ty)>(_Count)));
+    }
+
+    void deallocate(_Ty* const _Ptr, const size_t _Count) {
+        // no overflow check on the following multiply; we assume _Allocate did that check
+        _STD _Deallocate<_New_alignof<_Ty>>(_Ptr, sizeof(_Ty) * _Count);
+    }
+
+    template <class _Other>
+    bool operator==(const _Parallelism_allocator<_Other>&) const noexcept {
+        return true;
+    }
+
+#if !_HAS_CXX20
+    template <class _Other>
+    bool operator!=(const _Parallelism_allocator<_Other>&) const noexcept {
+        return false;
+    }
+#endif // !_HAS_CXX20
+};
+
+template <class _Ty>
+using _Parallel_vector = vector<_Ty, _Parallelism_allocator<_Ty>>;
+
+template <class _Ty>
+struct _Generalized_sum_drop { // drop off point for GENERALIZED_SUM intermediate results
+    _Ty* _Data;
+    size_t _Slots;
+    atomic<size_t> _Frontier;
+
+    explicit _Generalized_sum_drop(const size_t _Slots)
+        : _Data(static_cast<_Ty*>(
+              _Allocate<_New_alignof<_Ty>, _Parallelism_allocate_traits>(_Get_size_of_n<sizeof(_Ty)>(_Slots)))),
+          _Slots(_Slots), _Frontier(0) {}
+
+    ~_Generalized_sum_drop() noexcept {
+        // pre: the caller has synchronized with all threads that modify _Data.
+        _STD _Destroy_range(begin(), end());
+        // no overflow check on the following multiply; we assume _Allocate did that check
+        _STD _Deallocate<_New_alignof<_Ty>>(_Data, sizeof(_Ty) * _Slots);
+    }
+
+    template <class... _Args>
+    void _Add_result(_Args&&... _Vals) noexcept /* terminates */ {
+        // constructs a _Ty in place with _Vals parameters perfectly forwarded
+        // pre: the number of results added is less than the size the drop was constructed with
+        const size_t _Target = _Frontier++;
+        _STD _Construct_in_place(_Data[_Target], _STD forward<_Args>(_Vals)...);
+    }
+
+    _Ty* begin() {
+        return _Data;
+    }
+
+    _Ty* end() {
+        return _Data + _Frontier.load(memory_order_relaxed);
+    }
+};
+
+template <class _Ty>
+struct _Atomic_is_usually_lock_free : bool_constant<atomic<_Ty>::is_always_lock_free> {
+    // deferred evaluation of atomic::is_always_lock_free
+};
+
+template <class _FwdIt>
+constexpr bool _Use_atomic_iterator = conjunction_v<bool_constant<_Is_ranges_random_iter_v<_FwdIt>>,
+    is_trivially_copyable<_FwdIt>, _Atomic_is_usually_lock_free<_FwdIt>>;
+
+template <class _Ty>
+struct _Parallel_choose_min_result { // parallel results collector which uses atomic<_Ty> to choose the minimum value
+    _Ty _Last;
+    atomic<_Ty> _Result;
+
+    explicit _Parallel_choose_min_result(_Ty _Last_) : _Last{_Last_}, _Result{_Last} {}
+
+    _Ty _Get_result() const { // load the imbued value
+        return _Result.load(memory_order_relaxed);
+    }
+
+    bool _Complete() const { // tests whether a result has been found
+        return _Result.load(memory_order_relaxed) != _Last;
+    }
+
+    void _Imbue(size_t, const _Ty _Local_result) { // atomically sets the result to min(result, _Local_result)
+        _Ty _Expected{_Last};
+        while (!_Result.compare_exchange_weak(_Expected, _Local_result) && _Expected > _Local_result) { // keep trying
+        }
+    }
+};
+
+template <class _Ty>
+struct _Parallel_choose_max_result { // parallel results collector which uses atomic<_Ty> to choose the maximum value
+    _Ty _Last;
+    atomic<_Ty> _Result;
+
+    explicit _Parallel_choose_max_result(_Ty _Last_) : _Last{_Last_}, _Result{_Last} {}
+
+    _Ty _Get_result() const { // load the imbued value
+        return _Result.load(memory_order_relaxed);
+    }
+
+    bool _Complete() const { // tests whether a result has been found
+        return _Result.load(memory_order_relaxed) != _Last;
+    }
+
+    void _Imbue(size_t, const _Ty _Local_result) { // atomically sets the result to max(result, _Local_result)
+        _Ty _Expected{_Last};
+        if (_Result.compare_exchange_strong(_Expected, _Local_result)) {
+            return;
+        }
+
+        while (_Expected < _Local_result && !_Result.compare_exchange_weak(_Expected, _Local_result)) { // keep trying
+        }
+    }
+};
+
+template <class _Ty>
+struct _Parallel_choose_min_chunk {
+    // parallel results collector which uses atomic<chunk number> to choose the lowest chunk's result
+    _Ty _Result;
+    atomic<size_t> _Selected_chunk;
+    mutex _Mtx;
+
+    explicit _Parallel_choose_min_chunk(_Ty _Last) : _Result(_Last), _Selected_chunk{_Still_active}, _Mtx{} {}
+
+    _Ty _Get_result() const { // load the imbued value
+        return _Result;
+    }
+
+    bool _Complete() const { // tests whether a result has been found
+        return _Selected_chunk.load(memory_order_relaxed) != _Still_active;
+    }
+
+    void _Imbue(const size_t _Chunk, const _Ty _Local_result) {
+        // atomically sets the result to the lowest chunk's value
+        size_t _Expected = _Still_active;
+        while (!_Selected_chunk.compare_exchange_weak(_Expected, _Chunk)) {
+            // note: _Still_active is the maximum possible value, so it gets ignored implicitly
+            if (_Chunk > _Expected) {
+                return;
+            }
+        }
+
+        lock_guard _Lck(_Mtx);
+        if (_Selected_chunk.load(memory_order_relaxed) == _Chunk) {
+            _Result = _Local_result;
+        }
+    }
+};
+
+template <class _Ty>
+struct _Parallel_choose_max_chunk {
+    // parallel results collector which uses atomic<chunk number> to choose the highest chunk's result
+    _Ty _Result;
+    atomic<size_t> _Selected_chunk;
+    mutex _Mtx;
+
+    explicit _Parallel_choose_max_chunk(_Ty _Last) : _Result(_Last), _Selected_chunk{_Still_active}, _Mtx{} {}
+
+    _Ty _Get_result() const { // load the imbued value
+        return _Result;
+    }
+
+    bool _Complete() const { // tests whether a result has been found
+        return _Selected_chunk.load(memory_order_relaxed) != _Still_active;
+    }
+
+    void _Imbue(const size_t _Chunk, const _Ty _Local_result) {
+        // atomically sets the result to the highest chunk's value
+        size_t _Expected = _Still_active;
+        while (!_Selected_chunk.compare_exchange_weak(_Expected, _Chunk)) {
+            // wrap _Still_active down to 0 so that only 1 branch is necessary:
+            if (_Chunk + 1 < _Expected + 1) {
+                return;
+            }
+        }
+
+        lock_guard _Lck(_Mtx);
+        if (_Selected_chunk.load(memory_order_relaxed) == _Chunk) {
+            _Result = _Local_result;
+        }
+    }
+};
+
+template <class _Ty>
+struct alignas(_Ty) alignas(size_t) alignas(_Atomic_counter_t) _Circular_buffer { // work stealing deque extent type
+    static_assert(is_trivially_copyable_v<_Ty> && is_trivially_default_constructible_v<_Ty>,
+        "Work stealing deques work only with trivial operations");
+
+    size_t _Log_size;
+    _Atomic_counter_t _Ref_count;
+
+    void _Release() {
+        static_assert(is_trivially_destructible_v<_Circular_buffer>, "global delete requires trivial destruction");
+        if (_MT_DECR(_Ref_count) == 0) {
+            ::operator delete(this);
+        }
+    }
+
+    static _Circular_buffer* _Allocate_circular_buffer(const size_t _New_log_size) {
+        // allocate a circular buffer with space for 2^_New_log_size elements
+        if (_New_log_size >= 32) {
+            _Throw_parallelism_resources_exhausted();
+        }
+
+        const size_t _Count         = static_cast<size_t>(1) << _New_log_size;
+        constexpr size_t _Max_bytes = static_cast<size_t>(-1) - sizeof(_Circular_buffer);
+        if (_Max_bytes / sizeof(_Ty) < _Count) {
+            _Throw_parallelism_resources_exhausted();
+        }
+
+        const size_t _Result_bytes = _Count * sizeof(_Ty) + sizeof(_Circular_buffer);
+        static_assert(alignof(_Ty) <= alignof(max_align_t), "incapable of supporting the requested alignment");
+        const auto _Result  = static_cast<_Circular_buffer*>(::operator new(_Result_bytes));
+        _Result->_Log_size  = _New_log_size;
+        _Result->_Ref_count = 1;
+        return _Result;
+    }
+
+    static _Circular_buffer* _New_circular_buffer() { // allocate a circular buffer with a default number of elements
+        return _Allocate_circular_buffer(6); // start with 64 elements
+    }
+
+    _Ty* _Get_base() { // get the base address where the _Ty instances are stored
+        return reinterpret_cast<_Ty*>(this + 1);
+    }
+
+    const _Ty* _Get_base() const { // get the base address where the _Ty instances are stored
+        return reinterpret_cast<const _Ty*>(this + 1);
+    }
+
+    _Ty& _Subscript(const size_t _Idx) { // get a reference to the _Idxth element
+        const auto _Mask = (static_cast<size_t>(1) << _Log_size) - static_cast<size_t>(1);
+        return _Get_base()[_Idx & _Mask];
+    }
+
+    const _Ty& _Subscript(const size_t _Idx) const { // get a reference to the _Idxth element
+        const auto _Mask = (static_cast<size_t>(1) << _Log_size) - static_cast<size_t>(1);
+        return _Get_base()[_Idx & _Mask];
+    }
+
+    _Circular_buffer* _Grow(const size_t _Bottom, const size_t _Top) const {
+        // create a bigger _Circular_buffer suitable for use by a _Work_stealing_deque<_Ty> with bounds _Bottom and _Top
+        const size_t _New_log_size = _Log_size + 1;
+        _Circular_buffer* _Result  = _Allocate_circular_buffer(_New_log_size);
+        for (size_t _Idx = _Top; _Idx < _Bottom; ++_Idx) {
+            _Result->_Subscript(_Idx) = _Subscript(_Idx);
+        }
+
+        return _Result;
+    }
+};
+
+template <class _Ty>
+class alignas(hardware_destructive_interference_size) _Work_stealing_deque {
+    // thread-local work-stealing deque, which allows efficient access from a single owner thread at the "bottom"
+    // of the queue, and any thread access to the "top" of the queue. Originally described in the paper
+    // "Dynamic Circular Work-Stealing Deque" by David Chase and Yossi Lev
+public:
+    _Work_stealing_deque()                                       = default;
+    _Work_stealing_deque(const _Work_stealing_deque&)            = delete;
+    _Work_stealing_deque& operator=(const _Work_stealing_deque&) = delete;
+
+    ~_Work_stealing_deque() noexcept {
+        _Segment->_Release();
+    }
+
+    void _Push_bottom(_Ty& _Val) {
+        // attempts to push _Val onto the bottom of this queue
+        // may be accessed by owning thread only
+        const auto _Local_b = _Bottom.load();
+        if (_Local_b == SIZE_MAX) {
+            // we assume that any input range won't be divided into more than SIZE_MAX subproblems;
+            // treat overflow of that kind as OOM
+            _Throw_parallelism_resources_exhausted();
+        }
+
+        const auto _Local_t = _Top.load();
+        const auto _Size    = _Local_b - _Local_t;
+        if (_Size >= (static_cast<size_t>(1) << _Segment->_Log_size)) {
+            auto _New_segment = _Segment->_Grow(_Local_b, _Local_t);
+            _Circular_buffer<_Ty>* _Detached_segment;
+            {
+                lock_guard _Lck(_Segment_lock);
+                _Detached_segment = _STD exchange(_Segment, _New_segment);
+            } // unlock
+
+            _Detached_segment->_Release();
+        }
+
+        _Segment->_Subscript(_Local_b) = _Val;
+        _Bottom.store(_Local_b + 1U);
+    }
+
+    bool _Steal(_Ty& _Val) noexcept {
+        // attempt to pop an item from the top of this deque
+        // may be accessed by any thread
+        // returns false if the deque was empty and _Val is indeterminate; otherwise, returns true and sets _Val to the
+        // element retrieved from the top of the deque.
+        auto _Local_t = _Top.load();
+        size_t _Desired_t;
+        do {
+            if (_Bottom.load() <= _Local_t) { // deque was empty
+                return false;
+            }
+
+            _Circular_buffer<_Ty>* _Stealing_segment;
+            {
+                lock_guard _Lck(_Segment_lock);
+                _Stealing_segment = _Segment;
+                _MT_INCR(_Stealing_segment->_Ref_count);
+            }
+
+            _Val = _Stealing_segment->_Subscript(_Local_t); // speculative read/write data race
+            _Stealing_segment->_Release();
+            // The above is technically prohibited by the C++ memory model, but happens
+            // to be well defined on all hardware this implementation targets.
+            // Hardware with trap representations or similar must not use this implementation.
+            _Desired_t = _Local_t + 1U;
+        } while (!_Top.compare_exchange_strong(_Local_t, _Desired_t)); // if a data race occurred, try again
+
+        return true;
+    }
+
+    bool _Try_pop_bottom(_Ty& _Val) noexcept {
+        // attempt to pop an item from the bottom of this deque into _Val
+        // may be accessed by owning thread only
+        auto _Local_b = _Bottom.load();
+        if (_Local_b == 0) { // queue never contained any elements (should never happen)
+            return false;
+        }
+
+        --_Local_b;
+        _Bottom.store(_Local_b);
+        auto _Local_t = _Top.load();
+        if (_Local_b < _Local_t) { // all elements were stolen before we got here
+            _Bottom.store(_Local_t);
+            return false;
+        }
+
+        // memory model says following load is OK, since _Push_bottom can't run concurrently
+        _Val = _Segment->_Subscript(_Local_b);
+
+        if (_Local_b > _Local_t) {
+            // other threads only look at top, so we get the bottom without synchronization
+            return true;
+        }
+
+        // We're trying to read the last element that another thread may be trying to steal;
+        // see who gets to keep the element through _Top (effectively, steal from ourselves)
+        const auto _Desired_top = _Local_t + 1U;
+        if (_Top.compare_exchange_strong(_Local_t, _Desired_top)) {
+            _Bottom.store(_Desired_top);
+            return true;
+        } else {
+            _Bottom.store(_Local_t);
+            return false;
+        }
+    }
+
+private:
+    atomic<size_t> _Bottom{0}; // modified by only owning thread
+    atomic<size_t> _Top{0}; // modified by all threads
+    // clang-format off: clang-format 20 doesn't understand _Guarded_by_ and will damage the following code
+    _Guarded_by_(_Segment_lock) _Circular_buffer<_Ty>* _Segment { _Circular_buffer<_Ty>::_New_circular_buffer() };
+    // clang-format on
+    mutex _Segment_lock{};
+};
+
+enum class _Steal_result { _Success, _Abort, _Done };
+
+template <class _Ty>
+struct _Work_stealing_team;
+
+template <class _Ty>
+struct _Work_stealing_membership { // thread-local "ticket" that team members use to talk with a _Work_stealing_team
+    using _Diff = typename _Ty::difference_type;
+
+    size_t _Id;
+    _Work_stealing_team<_Ty>* _Team;
+    _Diff _Work_complete;
+
+    void _Push_bottom(_Ty& _Val) {
+        _Team->_Queues[_Id]._Push_bottom(_Val);
+    }
+
+    bool _Try_pop_bottom(_Ty& _Val) noexcept {
+        return _Team->_Queues[_Id]._Try_pop_bottom(_Val);
+    }
+
+    _Steal_result _Steal(_Ty& _Val) noexcept {
+        _Diff _Remaining;
+        const auto _Completed_this_time = _STD exchange(_Work_complete, {});
+        if (_Completed_this_time == 0) {
+            _Remaining = _Team->_Remaining_work.load();
+        } else {
+            _Remaining = _Team->_Remaining_work -= _Completed_this_time;
+        }
+
+        if (_Remaining == 0) {
+            return _Steal_result::_Done;
+        }
+
+        const size_t _High = _Team->_Queues_used.load() + 1;
+        size_t _Idx        = _Id;
+        for (;;) {
+            if (_Idx == 0) {
+                _Idx = _High;
+            }
+
+            --_Idx;
+            if (_Idx == _Id) {
+                return _Steal_result::_Abort;
+            }
+
+            if (_Team->_Queues[_Idx]._Steal(_Val)) {
+                return _Steal_result::_Success;
+            }
+        }
+    }
+
+    void _Leave() noexcept {
+        _Team->_Leave_team(_Id);
+    }
+};
+
+template <class _Ty>
+struct _Work_stealing_team { // inter-thread communication for threads working on a single task
+    using _Diff = typename _Ty::difference_type;
+
+    static _Parallel_vector<size_t> _Get_queues(const size_t _Queue_count) {
+        _Parallel_vector<size_t> _Result(_Queue_count);
+        _STD iota(_Result.begin(), _Result.end(), size_t{});
+        return _Result;
+    }
+
+    _Work_stealing_team(size_t _Threads, _Diff _Total_work)
+        : _Queues(_Threads), _Queues_used(0), _Remaining_work(_Total_work), _Available_mutex(),
+          _Available_queues(greater{}, _Get_queues(_Threads)) {} // register work with the thread pool
+
+    _Work_stealing_membership<_Ty> _Join_team() noexcept {
+        size_t _Id;
+        {
+            lock_guard _Lck(_Available_mutex);
+            _Id = _Available_queues.top();
+            _Available_queues.pop();
+        } // unlock
+
+        // set _Queues_used to the high water mark of queues used
+        size_t _High_water = _Queues_used.load();
+        while (_High_water < _Id && !_Queues_used.compare_exchange_weak(_High_water, _Id)) { // keep trying
+        }
+
+        return _Work_stealing_membership<_Ty>{_Id, this, 0};
+    }
+
+    void _Leave_team(size_t _Id) noexcept {
+        lock_guard _Lck(_Available_mutex);
+        _Available_queues.push(_Id);
+    }
+
+    _Parallel_vector<_Work_stealing_deque<_Ty>> _Queues;
+    atomic<size_t> _Queues_used;
+    atomic<_Diff> _Remaining_work;
+
+    mutex _Available_mutex;
+    priority_queue<size_t, _Parallel_vector<size_t>, greater<>> _Available_queues;
+};
+
+template <class _Diff>
+struct _Static_partition_key { // "pointer" identifying a static partition
+    size_t _Chunk_number; // In range [0, numeric_limits<_Diff>::max()]
+    _Diff _Start_at;
+    _Diff _Size;
+
+    explicit operator bool() const { // test if this is a valid key
+        return _Chunk_number != static_cast<size_t>(-1);
+    }
+};
+
+template <class _Diff>
+struct _Static_partition_team { // common data for all static partitioned ops
+    atomic<size_t> _Consumed_chunks;
+    size_t _Chunks;
+    _Diff _Count;
+    _Diff _Chunk_size;
+    _Diff _Unchunked_items;
+
+    _Static_partition_team(const _Diff _Count_, const size_t _Chunks_)
+        : _Consumed_chunks{0}, _Chunks{_Chunks_}, _Count{_Count_},
+          _Chunk_size{static_cast<_Diff>(_Count_ / static_cast<_Diff>(_Chunks_))},
+          _Unchunked_items{static_cast<_Diff>(_Count_ % static_cast<_Diff>(_Chunks_))} {
+        // Calculate common data for statically partitioning iterator ranges.
+        // pre: _Count_ >= _Chunks_ && _Chunks_ >= 1
+    }
+
+    _Static_partition_key<_Diff> _Get_chunk_key(const size_t _This_chunk) const {
+        const auto _This_chunk_diff = static_cast<_Diff>(_This_chunk);
+        auto _This_chunk_size       = _Chunk_size;
+        auto _This_chunk_start_at   = static_cast<_Diff>(_This_chunk_diff * _This_chunk_size);
+        if (_This_chunk_diff < _Unchunked_items) {
+            // chunks at index lower than _Unchunked_items get an extra item,
+            // and need to shift forward by all their predecessors' extra items
+            _This_chunk_start_at += _This_chunk_diff;
+            ++_This_chunk_size;
+        } else { // chunks without an extra item need to account for all the extra items
+            _This_chunk_start_at += _Unchunked_items;
+        }
+
+        return {_This_chunk, _This_chunk_start_at, _This_chunk_size};
+    }
+
+    _Diff _Get_chunk_offset(const size_t _This_chunk) const {
+        const auto _This_chunk_diff = static_cast<_Diff>(_This_chunk);
+        return _This_chunk_diff * _Chunk_size + (_STD min) (_This_chunk_diff, _Unchunked_items);
+    }
+
+    _Static_partition_key<_Diff> _Get_next_key() {
+        // retrieves the next static partition key to process, if it exists;
+        // otherwise, retrieves an invalid partition key
+        const auto _This_chunk = _Consumed_chunks++;
+        if (_This_chunk < _Chunks) {
+            return _Get_chunk_key(_This_chunk);
+        }
+
+        return {static_cast<size_t>(-1), 0, 0};
+    }
+};
+
+template <class _FwdIt>
+struct _Iterator_range { // record of a partition of work
+    _FwdIt _First;
+    _FwdIt _Last;
+};
+
+template <class _FwdIt, class _Diff = _Iter_diff_t<_FwdIt>, bool = _Is_ranges_random_iter_v<_FwdIt>>
+struct _Static_partition_range;
+
+template <class _RanIt, class _Diff>
+struct _Static_partition_range<_RanIt, _Diff, true> {
+    using _Target_diff = _Iter_diff_t<_RanIt>;
+    using _URanIt      = _Unwrapped_t<const _RanIt&>;
+    using _Chunk_type  = _Iterator_range<_URanIt>;
+
+    _URanIt _Start_at;
+
+    _RanIt _Populate(const _Static_partition_team<_Diff>& _Team, _RanIt _First) {
+        // statically partition a random-access iterator range and return next(_First, _Team._Count)
+        // pre: _Populate hasn't yet been called on this instance
+        auto _Result = _First + static_cast<_Target_diff>(_Team._Count); // does verification
+        _Start_at    = _STD _Get_unwrapped(_First);
+        return _Result;
+    }
+
+    bool _Populate(const _Static_partition_team<_Diff>& _Team, _RanIt _First, _RanIt _Last) {
+        // statically partition a random-access iterator range and check if the range ends at _Last
+        // pre: _Populate hasn't yet been called on this instance
+        _STD _Adl_verify_range(_First, _Last);
+        _Start_at = _STD _Get_unwrapped(_First);
+        return _Team._Count == _Last - _First;
+    }
+
+    _URanIt _Get_first(size_t /* _Chunk_number */, const _Diff _Offset) {
+        // get the first iterator for _Chunk _Chunk_number (which is at offset _Offset)
+        return _Start_at + static_cast<_Target_diff>(_Offset);
+    }
+
+    _Chunk_type _Get_chunk(const _Static_partition_key<_Diff> _Key) const {
+        // get a static partition chunk from a random-access range
+        // pre: _Key was generated by the _Static_partition_team instance passed to a previous call to _Populate
+        const auto _First = _Start_at + static_cast<_Target_diff>(_Key._Start_at);
+        return {_First, _First + static_cast<_Target_diff>(_Key._Size)};
+    }
+};
+
+template <class _FwdIt, class _Diff>
+struct _Static_partition_range<_FwdIt, _Diff, false> {
+    using _Target_diff = _Iter_diff_t<_FwdIt>;
+    using _UFwdIt      = _Unwrapped_t<const _FwdIt&>;
+    using _Chunk_type  = _Iterator_range<_UFwdIt>;
+
+    _Parallel_vector<_UFwdIt> _Division_points;
+
+    _FwdIt _Populate(const _Static_partition_team<_Diff>& _Team, _FwdIt _First) {
+        // statically partition a forward iterator range and return next(_First, _Team._Count)
+        // pre: _Populate hasn't yet been called on this instance
+        const auto _Chunks = _Team._Chunks;
+        _Division_points.resize(_Chunks + 1);
+        // The following potentially narrowing cast is OK because caller has ensured
+        // next(_First, _Team._Count) is valid (and _Count <= _Chunk_size)
+        const auto _Chunk_size      = static_cast<_Target_diff>(_Team._Chunk_size);
+        const auto _Unchunked_items = _Team._Unchunked_items;
+        auto _Result                = _Division_points.begin();
+        *_Result                    = _STD _Get_unwrapped(_First);
+        for (_Diff _Idx{}; _Idx < _Unchunked_items; ++_Idx) { // record bounds of chunks with an extra item
+            _STD advance(_First, static_cast<_Target_diff>(_Chunk_size + 1));
+            *++_Result = _STD _Get_unwrapped(_First);
+        }
+
+        const auto _Diff_chunks = static_cast<_Diff>(_Chunks);
+        for (_Diff _Idx = _Unchunked_items; _Idx < _Diff_chunks; ++_Idx) { // record bounds of chunks with no extra item
+            _STD advance(_First, _Chunk_size);
+            *++_Result = _STD _Get_unwrapped(_First);
+        }
+
+        return _First;
+    }
+
+    bool _Populate(const _Static_partition_team<_Diff>& _Team, _FwdIt _First, _FwdIt _Last) {
+        // statically partition a forward iterator range and check if the range ends at _Last
+        // pre: _Populate hasn't yet been called on this instance
+        const auto _Chunks = _Team._Chunks;
+        _Division_points.resize(_Chunks + 1);
+        const auto _Chunk_size      = _Team._Chunk_size;
+        const auto _Unchunked_items = _Team._Unchunked_items;
+        auto _Result                = _Division_points.begin();
+        *_Result                    = _STD _Get_unwrapped(_First);
+        for (_Diff _Idx{}; _Idx < _Unchunked_items; ++_Idx) { // record bounds of chunks with an extra item
+            for (_Diff _This_chunk_size = _Chunk_size + 1; 0 < _This_chunk_size--;) {
+                if (_First == _Last) {
+                    return false;
+                }
+
+                ++_First;
+            }
+
+            *++_Result = _STD _Get_unwrapped(_First);
+        }
+
+        const auto _Diff_chunks = static_cast<_Diff>(_Chunks);
+        for (_Diff _Idx = _Unchunked_items; _Idx < _Diff_chunks; ++_Idx) { // record bounds of chunks with no extra item
+            for (_Diff _This_chunk_size = _Chunk_size; 0 < _This_chunk_size--;) {
+                if (_First == _Last) {
+                    return false;
+                }
+
+                ++_First;
+            }
+
+            *++_Result = _STD _Get_unwrapped(_First);
+        }
+
+        return _First == _Last;
+    }
+
+    _UFwdIt _Get_first(const size_t _Chunk_number, _Diff /* _Offset */) {
+        // get the first iterator for _Chunk _Chunk_number (which is at offset _Offset)
+        return _Division_points[_Chunk_number];
+    }
+
+    _Chunk_type _Get_chunk(const _Static_partition_key<_Diff> _Key) const {
+        // get a static partition chunk from a forward range
+        // pre: _Key was generated by the _Static_partition_team instance passed to a previous call to _Populate
+        return {_Division_points[_Key._Chunk_number], _Division_points[_Key._Chunk_number + 1]};
+    }
+};
+
+template <class _BidIt, class _Diff = _Iter_diff_t<_BidIt>, bool = _Is_ranges_random_iter_v<_BidIt>>
+struct _Static_partition_range_backward;
+
+template <class _RanIt, class _Diff>
+struct _Static_partition_range_backward<_RanIt, _Diff, true> {
+    using _Target_diff = _Iter_diff_t<_RanIt>;
+    using _Chunk_type  = _Iterator_range<_Unwrapped_t<const _RanIt&>>;
+
+    _Unwrapped_t<const _RanIt&> _Start_at;
+
+    void _Populate(const _Static_partition_team<_Diff>& _Team, _RanIt _Last) {
+        // statically partition a random-access iterator range ending at _Last
+        // pre: _Populate hasn't yet been called on this instance
+        _Start_at = _STD _Get_unwrapped_n(_Last, -static_cast<_Target_diff>(_Team._Count));
+    }
+
+    _Chunk_type _Get_chunk(const _Static_partition_key<_Diff> _Key) const {
+        // get a static partition chunk from a random-access range
+        // pre: _Key was generated by the _Static_partition_team instance passed to a previous call to _Populate
+        const auto _Last = _Start_at - static_cast<_Target_diff>(_Key._Start_at);
+        return {_Last - static_cast<_Target_diff>(_Key._Size), _Last};
+    }
+};
+
+template <class _BidIt, class _Diff>
+struct _Static_partition_range_backward<_BidIt, _Diff, false> {
+    using _Target_diff = _Iter_diff_t<_BidIt>;
+    using _Chunk_type  = _Iterator_range<_Unwrapped_t<const _BidIt&>>;
+
+    _Parallel_vector<_Unwrapped_t<const _BidIt&>> _Division_points;
+
+    void _Populate(const _Static_partition_team<_Diff>& _Team, _BidIt _Last) {
+        // statically partition a bidirectional iterator range ending at _Last
+        // pre: _Populate hasn't yet been called on this instance
+        const auto _Chunks = _Team._Chunks;
+        _Division_points.resize(_Chunks + 1);
+        const auto _Neg_chunk_size  = static_cast<_Target_diff>(-_Team._Chunk_size);
+        const auto _Unchunked_items = _Team._Unchunked_items;
+        auto _Result = _Division_points.begin(); // does range checking by incrementing in the checked domain
+        *_Result     = _STD _Get_unwrapped(_Last);
+        for (_Diff _Idx{}; _Idx < _Unchunked_items; ++_Idx) {
+            _STD advance(_Last, static_cast<_Target_diff>(_Neg_chunk_size - 1));
+            *++_Result = _STD _Get_unwrapped(_Last);
+        }
+
+        const auto _Diff_chunks = static_cast<_Diff>(_Chunks);
+        for (_Diff _Idx = _Unchunked_items; _Idx < _Diff_chunks; ++_Idx) {
+            _STD advance(_Last, _Neg_chunk_size);
+            *++_Result = _STD _Get_unwrapped(_Last);
+        }
+    }
+
+    _Chunk_type _Get_chunk(const _Static_partition_key<_Diff> _Key) const {
+        // get a static partition chunk from a bidirectional range
+        // pre: _Key was generated by the _Static_partition_team instance passed to a previous call to _Populate
+        return {_Division_points[_Key._Chunk_number + 1], _Division_points[_Key._Chunk_number]};
+    }
+};
+
+template <class _InIt1, class _InIt2>
+_Common_diff_t<_InIt1, _InIt2> _Distance_any(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
+    // get the distance from 2 ranges which should have identical lengths
+    if constexpr (_Is_ranges_random_iter_v<_InIt1>) {
+        return _Last1 - _First1;
+    } else if constexpr (_Is_ranges_random_iter_v<_InIt2>) {
+        return _Last2 - _First2;
+    } else {
+        return _STD distance(_First1, _Last1);
+    }
+}
+
+template <class _InIt1, class _InIt2>
+_Common_diff_t<_InIt1, _InIt2> _Distance_min(_InIt1 _First1, const _InIt1 _Last1, _InIt2 _First2, const _InIt2 _Last2) {
+    // get min(distance(_First1, _Last1), distance(_First2, _Last2))
+    using _CT = _Common_diff_t<_InIt1, _InIt2>;
+    _CT _Result{};
+    if constexpr (_Is_ranges_random_iter_v<_InIt1> && _Is_ranges_random_iter_v<_InIt2>) {
+        const _CT _Count1 = _Last1 - _First1;
+        const _CT _Count2 = _Last2 - _First2;
+        _Result           = (_STD min) (_Count1, _Count2);
+    } else if constexpr (_Is_ranges_random_iter_v<_InIt1>) {
+        for (auto _Count1 = _Last1 - _First1; 0 < _Count1 && _First2 != _Last2; --_Count1) {
+            ++_First2;
+            ++_Result;
+        }
+    } else if constexpr (_Is_ranges_random_iter_v<_InIt2>) {
+        for (auto _Count2 = _Last2 - _First2; 0 < _Count2 && _First1 != _Last1; --_Count2) {
+            ++_First1;
+            ++_Result;
+        }
+    } else {
+        while (_First1 != _Last1 && _First2 != _Last2) {
+            ++_First1;
+            ++_First2;
+            ++_Result;
+        }
+    }
+
+    return _Result;
+}
+
+template <bool _Invert, class _FwdIt, class _Pr>
+struct _Static_partitioned_all_of_family2 { // all_of/any_of/none_of task scheduled on the system thread pool
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _Pr _Pred;
+    _Cancellation_token _Cancel_token;
+
+    _Static_partitioned_all_of_family2(
+        _FwdIt _First, const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Pred(_Pred_), _Cancel_token{} {
+        _Basis._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        if (_Cancel_token._Is_canceled()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Range = _Basis._Get_chunk(_Key);
+        for (auto _First = _Range._First; _First != _Range._Last; ++_First) {
+            if (_Pred(*_First) ? _Invert : !_Invert) {
+                _Cancel_token._Cancel();
+                return _Cancellation_status::_Canceled;
+            }
+        }
+
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_all_of_family2*>(_Context));
+    }
+};
+
+template <bool _Invert, class _FwdIt, class _Pr>
+bool _All_of_family_parallel(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
+    // test if all elements in [_First, _Last) satisfy _Pred (or !_Pred if _Invert is true) in parallel
+    const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+    if (_Hw_threads > 1) { // parallelize on multiprocessor machines...
+        const auto _Count = _STD distance(_First, _Last);
+        if (_Count >= 2) { // ... with at least 2 elements
+            _TRY_BEGIN
+            _Static_partitioned_all_of_family2<_Invert, _FwdIt, _Pr> _Operation{_First, _Hw_threads, _Count, _Pred};
+            _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+            return !_Operation._Cancel_token._Is_canceled_relaxed();
+            _CATCH(const _Parallelism_resources_exhausted&)
+            // fall through to serial case below
+            _CATCH_END
+        }
+    }
+
+    for (; _First != _Last; ++_First) {
+        if (_Pred(*_First) ? _Invert : !_Invert) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD bool all_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // test if all elements in [_First, _Last) satisfy _Pred with the indicated execution policy
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        return _STD _All_of_family_parallel<false>(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    } else {
+        return _STD all_of(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD bool any_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // test if any element in [_First, _Last) satisfies _Pred with the indicated execution policy
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        return !_STD _All_of_family_parallel<true>(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    } else {
+        return _STD any_of(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD bool none_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // test if no element in [_First, _Last) satisfies _Pred with the indicated execution policy
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        return _STD _All_of_family_parallel<true>(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    } else {
+        return _STD none_of(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    }
+}
+
+template <class _FwdIt, class _Fn>
+void _For_each_ivdep(_FwdIt _First, const _FwdIt _Last, _Fn _Func) {
+    // perform function for each element [_First, _Last) assuming independent loop bodies
+#pragma loop(ivdep)
+    for (; _First != _Last; ++_First) {
+        _Func(*_First);
+    }
+}
+
+template <class _FwdIt, class _Diff, class _Fn>
+struct _Static_partitioned_for_each2 { // for_each task scheduled on the system thread pool
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt, _Diff> _Basis;
+    _Fn _Func;
+
+    _Static_partitioned_for_each2(const size_t _Hw_threads, const _Diff _Count, _Fn _Fx)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Func(_Fx) {}
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (_Key) {
+            const auto _Chunk = _Basis._Get_chunk(_Key);
+            _STD _For_each_ivdep(_Chunk._First, _Chunk._Last, _Func);
+            return _Cancellation_status::_Running;
+        }
+
+        return _Cancellation_status::_Canceled;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_for_each2*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+void for_each(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept /* terminates */ {
+    // perform function for each element [_First, _Last) with the indicated execution policy
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines...
+            auto _Count = _STD distance(_UFirst, _ULast);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                auto _Passed_fn = _STD _Pass_fn(_Func);
+                _Static_partitioned_for_each2<decltype(_UFirst), decltype(_Count), decltype(_Passed_fn)> _Operation{
+                    _Hw_threads, _Count, _Passed_fn};
+                _Operation._Basis._Populate(_Operation._Team, _UFirst);
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+
+        _STD _For_each_ivdep(_UFirst, _ULast, _STD _Pass_fn(_Func));
+    } else if constexpr (remove_reference_t<_ExPo>::_Ivdep) {
+        _STD _For_each_ivdep(_UFirst, _ULast, _STD _Pass_fn(_Func));
+    } else {
+        for (; _UFirst != _ULast; ++_UFirst) {
+            _Func(*_UFirst);
+        }
+    }
+}
+
+template <class _FwdIt, class _Diff, class _Fn>
+_FwdIt _For_each_n_ivdep(_FwdIt _First, _Diff _Count, _Fn _Func) {
+    // perform function for each element [_First, _First + _Count) assuming independent loop bodies
+#pragma loop(ivdep)
+    for (; 0 < _Count; --_Count, (void) ++_First) {
+        _Func(*_First);
+    }
+
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt for_each_n(_ExPo&&, _FwdIt _First, const _Diff _Count_raw, _Fn _Func) noexcept /* terminates */ {
+    // perform function for each element [_First, _First + _Count)
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (0 < _Count) {
+        auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+        if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+            const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+            if (_Hw_threads > 1 && _Count >= 2) { // parallelize on multiprocessor machines with at least 2 elements
+                _TRY_BEGIN
+                auto _Passed_fn = _STD _Pass_fn(_Func);
+                _Static_partitioned_for_each2<decltype(_UFirst), decltype(_Count), decltype(_Passed_fn)> _Operation{
+                    _Hw_threads, _Count, _Passed_fn};
+                _STD _Seek_wrapped(_First, _Operation._Basis._Populate(_Operation._Team, _UFirst));
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _First;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(_First, _STD _For_each_n_ivdep(_UFirst, _Count, _STD _Pass_fn(_Func)));
+        } else if constexpr (remove_reference_t<_ExPo>::_Ivdep) {
+            _STD _Seek_wrapped(_First, _STD _For_each_n_ivdep(_UFirst, _Count, _STD _Pass_fn(_Func)));
+        } else {
+            for (; 0 < _Count; --_Count, (void) ++_UFirst) {
+                _Func(*_UFirst);
+            }
+
+            _STD _Seek_wrapped(_First, _UFirst);
+        }
+    }
+
+    return _First;
+}
+
+template <class _FwdIt>
+using _Parallel_find_results = conditional_t<_Use_atomic_iterator<_FwdIt>, _Parallel_choose_min_result<_FwdIt>,
+    _Parallel_choose_min_chunk<_FwdIt>>;
+
+template <class _FwdIt, class _Find_fx>
+struct _Static_partitioned_find3 {
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _Parallel_find_results<_FwdIt> _Results;
+    _Find_fx _Fx;
+
+    _Static_partitioned_find3(
+        const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, const _FwdIt _Last, const _Find_fx _Fx_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Results(_Last), _Fx(_Fx_) {}
+
+    _Cancellation_status _Process_chunk() {
+        if (_Results._Complete()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Range     = _Basis._Get_chunk(_Key);
+        const auto _This_find = _Fx(_Range._First, _Range._Last);
+        if (_This_find == _Range._Last) {
+            return _Cancellation_status::_Running;
+        }
+
+        _Results._Imbue(_Key._Chunk_number, _This_find);
+        return _Cancellation_status::_Canceled;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_find3*>(_Context));
+    }
+};
+
+template <class _ExPo, class _FwdIt, class _Find_fx>
+_FwdIt _Find_parallel_unchecked(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, const _Find_fx _Fx) {
+    // find first matching _Val, potentially in parallel
+    if (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count = _STD distance(_First, _Last);
+            if (_Count >= 2) {
+                _TRY_BEGIN
+                _Static_partitioned_find3 _Operation{_Hw_threads, _Count, _Last, _Fx};
+                _Operation._Basis._Populate(_Operation._Team, _First);
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Operation._Results._Get_result();
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to _Fx below
+                _CATCH_END
+            }
+        }
+    }
+
+    return _Fx(_First, _Last);
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdIt find(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept /* terminates */ {
+    // find first matching _Val
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Seek_wrapped(_First, _STD _Find_parallel_unchecked(_STD forward<_ExPo>(_Exec), _STD _Get_unwrapped(_First),
+                                   _STD _Get_unwrapped(_Last), [&](const _UFwdIt _LFirst, const _UFwdIt _LLast) {
+                                       return _STD _Find_unchecked(_LFirst, _LLast, _Val);
+                                   }));
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find first satisfying _Pred
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
+    _STD _Adl_verify_range(_First, _Last);
+    auto _Pass_pred = _STD _Pass_fn(_Pred);
+    _STD _Seek_wrapped(_First, _STD _Find_parallel_unchecked(_STD forward<_ExPo>(_Exec), _STD _Get_unwrapped(_First),
+                                   _STD _Get_unwrapped(_Last), [=](const _UFwdIt _LFirst, const _UFwdIt _LLast) {
+                                       return _STD find_if(_LFirst, _LLast, _Pass_pred);
+                                   }));
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdIt find_if_not(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find first satisfying !_Pred
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
+    _STD _Adl_verify_range(_First, _Last);
+    auto _Pass_pred = _STD _Pass_fn(_Pred);
+    _STD _Seek_wrapped(_First, _STD _Find_parallel_unchecked(_STD forward<_ExPo>(_Exec), _STD _Get_unwrapped(_First),
+                                   _STD _Get_unwrapped(_Last), [=](const _UFwdIt _LFirst, const _UFwdIt _LLast) {
+                                       return _STD find_if_not(_LFirst, _LLast, _Pass_pred);
+                                   }));
+    return _First;
+}
+
+template <class _FwdIt1, class _FwdIt2>
+_Iter_diff_t<_FwdIt1> _Get_find_end_forward_partition_size(
+    _FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2, const _FwdIt2 _Last2) {
+    // get the count of the range of possible matches in a find_end operation for forward iterators
+    if (_First2 == _Last2) {
+        return 0;
+    }
+
+    for (;;) {
+        if (_First1 == _Last1) { // haystack is shorter than needle
+            return 0;
+        }
+
+        ++_First2;
+        if (_First2 == _Last2) { // seek complete
+            return _STD distance(_First1, _Last1);
+        }
+
+        ++_First1;
+    }
+}
+
+template <class _FwdIt1, class _FwdIt2, class _Pr>
+struct _Static_partitioned_find_end_forward2 {
+    _Static_partition_team<_Iter_diff_t<_FwdIt1>> _Team;
+    _Static_partition_range<_FwdIt1> _Basis;
+    _Iterator_range<_FwdIt2> _Range2;
+    _Pr _Pred;
+    conditional_t<_Use_atomic_iterator<_FwdIt1>, _Parallel_choose_max_result<_FwdIt1>,
+        _Parallel_choose_max_chunk<_FwdIt1>>
+        _Results;
+
+    _Static_partitioned_find_end_forward2(const size_t _Hw_threads, const _Iter_diff_t<_FwdIt1> _Count,
+        const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, const _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Range2{_First2, _Last2},
+          _Pred{_Pred_}, _Results(_Last1) {}
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        const auto _Range        = _Basis._Get_chunk(_Key);
+        _FwdIt1 _Result          = _Range._Last;
+        for (auto _First1 = _Range._First; _First1 != _Range._Last; ++_First1) {
+            if (_Equal_rev_pred_unchecked(_First1, _Range2._First, _Range2._Last, _Pred)) {
+                _Result = _First1;
+            }
+        }
+
+        if (_Result != _Range._Last) {
+            _Results._Imbue(_Chunk_number, _Result);
+        }
+
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        (void) static_cast<_Static_partitioned_find_end_forward2*>(_Context)->_Process_chunk();
+    }
+};
+
+template <class _BidIt1, class _FwdIt2>
+_BidIt1 _Get_find_end_backward_partition_start(
+    const _BidIt1 _First1, _BidIt1 _Last1, _FwdIt2 _First2, const _FwdIt2 _Last2) {
+    // gets the end of the range of possible matches for a find_end operation
+    if constexpr (_Is_ranges_random_iter_v<_BidIt1> && _Is_ranges_random_iter_v<_FwdIt2>) {
+        using _CT         = _Common_diff_t<_BidIt1, _FwdIt2>;
+        const _CT _Count1 = _Last1 - _First1;
+        const _CT _Count2 = _Last2 - _First2;
+        _Iter_diff_t<_BidIt1> _Count{};
+        if (0 < _Count2 && _Count2 <= _Count1) {
+            _Count = static_cast<_Iter_diff_t<_BidIt1>>(_Count1 - _Count2 + 1);
+        }
+        return _First1 + _Count;
+    } else {
+        if (_First2 == _Last2) { // always 0 matches, give up
+            return _First1;
+        }
+
+        for (;;) {
+            if (_First1 == _Last1) { // haystack is shorter than needle, give up
+                return _First1;
+            }
+
+            ++_First2;
+            if (_First2 == _Last2) { // seek complete
+                return _Last1;
+            }
+
+            --_Last1;
+        }
+    }
+}
+
+template <class _BidIt1, class _FwdIt2, class _Pr>
+struct _Static_partitioned_find_end_backward3 {
+    _Static_partition_team<_Iter_diff_t<_BidIt1>> _Team;
+    _Static_partition_range_backward<_BidIt1> _Basis;
+    conditional_t<_Use_atomic_iterator<_BidIt1>, _Parallel_choose_max_result<_BidIt1>,
+        _Parallel_choose_min_chunk<_BidIt1>>
+        _Results;
+    _Iterator_range<_FwdIt2> _Range2;
+    _Pr _Pred;
+
+    _Static_partitioned_find_end_backward3(const size_t _Hw_threads, const _Iter_diff_t<_BidIt1> _Count,
+        const _BidIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, const _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Results(_Last1),
+          _Range2{_First2, _Last2}, _Pred{_Pred_} {}
+
+    _Cancellation_status _Process_chunk() {
+        if (_Results._Complete()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        const auto _Range        = _Basis._Get_chunk(_Key);
+        auto _Last1              = _Range._Last;
+        do {
+            --_Last1;
+            if (_STD _Equal_rev_pred_unchecked(_Last1, _Range2._First, _Range2._Last, _Pred)) {
+                _Results._Imbue(_Chunk_number, _Last1);
+                return _Cancellation_status::_Canceled;
+            }
+        } while (_Last1 != _Range._First);
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_find_end_backward3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdIt1 find_end(_ExPo&&, _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2,
+    _Pr _Pred) noexcept /* terminates */ {
+    // find last [_First2, _Last2) satisfying _Pred
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    const auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+    const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            if constexpr (_Is_ranges_bidi_iter_v<_FwdIt1>) {
+                const auto _Partition_start =
+                    _STD _Get_find_end_backward_partition_start(_UFirst1, _ULast1, _UFirst2, _ULast2);
+                if (_UFirst1 == _Partition_start) {
+                    _STD _Seek_wrapped(_First1, _ULast1);
+                    return _First1;
+                }
+
+                const auto _Count = _STD distance(_UFirst1, _Partition_start);
+                if (_Count >= 2) {
+                    _TRY_BEGIN
+                    _Static_partitioned_find_end_backward3 _Operation{
+                        _Hw_threads, _Count, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred)};
+                    _Operation._Basis._Populate(_Operation._Team, _Partition_start);
+                    _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                    _STD _Seek_wrapped(_First1, _Operation._Results._Get_result());
+                    return _First1;
+                    _CATCH(const _Parallelism_resources_exhausted&)
+                    // fall through to serial case below
+                    _CATCH_END
+                }
+            } else {
+                const auto _Count = _STD _Get_find_end_forward_partition_size(_UFirst1, _ULast1, _UFirst2, _ULast2);
+                if (_Count >= 2) {
+                    _TRY_BEGIN
+                    _Static_partitioned_find_end_forward2 _Operation{
+                        _Hw_threads, _Count, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred)};
+                    _Operation._Basis._Populate(_Operation._Team, _UFirst1);
+                    _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                    _STD _Seek_wrapped(_First1, _Operation._Results._Get_result());
+                    return _First1;
+                    _CATCH(const _Parallelism_resources_exhausted&)
+                    // fall through to serial case below
+                    _CATCH_END
+                }
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First1, _STD find_end(_UFirst1, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred)));
+    return _First1;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2, _Pr _Pred) noexcept /* terminates */ {
+    // look for one of [_First2, _Last2) that matches element
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    using _UFwdIt1 = _Unwrapped_t<const _FwdIt1&>;
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+    const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    if (_UFirst2 == _ULast2) {
+        return _Last1;
+    }
+
+    auto _Pass_pred = _STD _Pass_fn(_Pred);
+    _STD _Seek_wrapped(_Last1, _STD _Find_parallel_unchecked(_STD forward<_ExPo>(_Exec), _STD _Get_unwrapped(_First1),
+                                   _STD _Get_unwrapped(_Last1), [=](const _UFwdIt1 _LFirst1, const _UFwdIt1 _LLast1) {
+                                       return _STD find_first_of(_LFirst1, _LLast1, _UFirst2, _ULast2, _Pass_pred);
+                                   }));
+    return _Last1;
+}
+
+template <class _FwdIt, class _Pr>
+struct _Static_partitioned_adjacent_find3 {
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _Parallel_find_results<_FwdIt> _Results;
+    _Pr _Pred;
+
+    _Static_partitioned_adjacent_find3(
+        const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, const _FwdIt _Last, const _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Results{_Last}, _Pred{_Pred_} {}
+
+    _Cancellation_status _Process_chunk() {
+        if (_Results._Complete()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        const auto _Range        = _Basis._Get_chunk(_Key);
+        // tests [_First, _Last) for _Pred(*_Result, *next(_Result));
+        // note: intentionally dereferences _Last
+        auto _First = _Range._First;
+        for (auto _Next = _First; _First != _Range._Last; _First = _Next) {
+            ++_Next;
+            if (_Pred(*_First, *_Next)) { // found match
+                _Results._Imbue(_Chunk_number, _First);
+                return _Cancellation_status::_Canceled;
+            }
+        }
+
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_adjacent_find3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdIt adjacent_find(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find first satisfying _Pred with successor
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count = static_cast<_Iter_diff_t<_FwdIt>>(_STD distance(_UFirst, _ULast) - 1);
+            if (_Count >= 2) {
+                _TRY_BEGIN
+                _Static_partitioned_adjacent_find3 _Operation{_Hw_threads, _Count, _ULast, _STD _Pass_fn(_Pred)};
+                _Operation._Basis._Populate(_Operation._Team, _UFirst);
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                _STD _Seek_wrapped(_Last, _Operation._Results._Get_result());
+                return _Last;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to adjacent_find below
+                _CATCH_END
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_Last, _STD adjacent_find(_UFirst, _ULast, _STD _Pass_fn(_Pred)));
+    return _Last;
+}
+
+template <class _FwdIt, class _Pr>
+struct _Static_partitioned_count_if2 {
+    using _Diff = _Iter_diff_t<_FwdIt>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _Pr _Pred;
+    atomic<_Diff> _Results;
+
+    _Static_partitioned_count_if2(const _Diff _Count, const size_t _Chunks, const _FwdIt _First, const _Pr _Pred_)
+        : _Team{_Count, _Chunks}, _Basis{}, _Pred{_Pred_}, _Results{} {
+        _Basis._Populate(_Team, _First);
+    }
+
+    _Diff _Process_chunks() {
+        _Diff _Result{};
+        while (const auto _Key = _Team._Get_next_key()) {
+            const auto _Range = _Basis._Get_chunk(_Key);
+            _Result += _STD count_if(_Range._First, _Range._Last, _Pred);
+        }
+
+        return _Result;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        const auto _This = static_cast<_Static_partitioned_count_if2*>(_Context);
+        _This->_Results.fetch_add(_This->_Process_chunks(), memory_order_relaxed);
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _Iter_diff_t<_FwdIt> count_if(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept
+/* terminates */ {
+    // count elements satisfying _Pred
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            if (_Count >= 2) {
+                const auto _Chunks = _Get_chunked_work_chunk_count(_Hw_threads, _Count);
+                _TRY_BEGIN
+                _Static_partitioned_count_if2 _Operation{_Count, _Chunks, _UFirst, _STD _Pass_fn(_Pred)};
+                _Iter_diff_t<_FwdIt> _Foreground_count;
+                {
+                    const _Work_ptr _Work{_Operation};
+                    // setup complete, hereafter nothrow or terminate
+                    _Work._Submit_for_chunks(_Hw_threads, _Chunks);
+                    _Foreground_count = _Operation._Process_chunks();
+                } // join with _Work_ptr threads
+
+                return _Operation._Results.load(memory_order_relaxed) + _Foreground_count;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to count_if below
+                _CATCH_END
+            }
+        }
+    }
+
+    return _STD count_if(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _Iter_diff_t<_FwdIt> count(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept
+/* terminates */ {
+    // count elements that match _Val
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    return _STD count_if(_STD forward<_ExPo>(_Exec), _STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last),
+        [&_Val](auto&& _Iter_val) { return _STD forward<decltype(_Iter_val)>(_Iter_val) == _Val; });
+}
+
+template <class _FwdIt1, class _FwdIt2,
+    bool = _Use_atomic_iterator<_Unwrapped_t<const _FwdIt1&>> && _Is_ranges_random_iter_v<_FwdIt2>,
+    bool = _Use_atomic_iterator<_Unwrapped_t<const _FwdIt2&>> && _Is_ranges_random_iter_v<_FwdIt1>>
+struct _Static_partitioned_mismatch_results;
+
+template <class _FwdIt1, class _FwdIt2, bool _Unused>
+struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, true, _Unused> {
+    // atomically manipulate atomic<_FwdIt1> and calculate the second iterator by adding distance to it
+    _Parallel_choose_min_result<_FwdIt1> _Storage;
+
+    _Static_partitioned_mismatch_results(const _FwdIt1 _Last1, const _Unwrapped_t<const _FwdIt2&>&)
+        : _Storage(_Last1) {}
+
+    void _Imbue(const size_t _Chunk_number, const _FwdIt1 _First1, const _Unwrapped_t<const _FwdIt2&>&) {
+        _Storage._Imbue(_Chunk_number, _First1);
+    }
+
+    pair<_FwdIt1, _FwdIt2> _Get_result(const _FwdIt1 _First1, const _FwdIt2 _First2) const {
+        const _FwdIt1 _Result1 = _Storage._Get_result();
+        return {_Result1, _First2 + static_cast<_Iter_diff_t<_FwdIt2>>(_Result1 - _First1)};
+    }
+};
+
+template <class _FwdIt1, class _FwdIt2>
+struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, false, true> {
+    // atomically manipulate atomic<_FwdIt2> and calculate the first iterator by adding distance to it
+    _Parallel_choose_min_result<_FwdIt2> _Storage;
+
+    _Static_partitioned_mismatch_results(const _Unwrapped_t<const _FwdIt1&>&, const _FwdIt2 _Last2)
+        : _Storage(_Last2) {}
+
+    void _Imbue(const size_t _Chunk_number, const _Unwrapped_t<const _FwdIt1&>&, const _FwdIt2 _First2) {
+        _Storage._Imbue(_Chunk_number, _First2);
+    }
+
+    pair<_FwdIt1, _FwdIt2> _Get_result(const _FwdIt1 _First1, const _FwdIt2 _First2) const {
+        const _FwdIt2 _Result2 = _Storage._Get_result();
+        return {_First1 + static_cast<_Iter_diff_t<_FwdIt1>>(_Result2 - _First2), _Result2};
+    }
+};
+
+template <class _FwdIt1, class _FwdIt2>
+struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, false, false> {
+    // get both iterators by manipulating them under lock
+    using _UFwdIt1 = _Unwrapped_t<const _FwdIt1&>;
+    using _UFwdIt2 = _Unwrapped_t<const _FwdIt2&>;
+    _Parallel_choose_min_chunk<pair<_UFwdIt1, _UFwdIt2>> _Storage;
+
+    _Static_partitioned_mismatch_results(const _UFwdIt1 _Last1, const _UFwdIt2 _Last2) : _Storage({_Last1, _Last2}) {}
+
+    void _Imbue(const size_t _Chunk_number, const _UFwdIt1 _First1, const _UFwdIt2 _First2) {
+        _Storage._Imbue(_Chunk_number, {_First1, _First2});
+    }
+
+    pair<_FwdIt1, _FwdIt2> _Get_result(_FwdIt1 _First1, _FwdIt2 _First2) const {
+        const auto _Result = _Storage._Get_result();
+        _STD _Seek_wrapped(_First2, _Result.second);
+        _STD _Seek_wrapped(_First1, _Result.first);
+        return {_First1, _First2};
+    }
+};
+
+template <class _FwdIt1, class _FwdIt2, class _Pr>
+struct _Static_partitioned_mismatch3 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
+    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
+    _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2> _Results;
+    _Pr _Pred;
+
+    _Static_partitioned_mismatch3(
+        const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First1, const _FwdIt2 _First2, const _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
+          _Results(_STD _Get_unwrapped(_Basis1._Populate(_Team, _First1)),
+              _STD _Get_unwrapped(_Basis2._Populate(_Team, _First2))),
+          _Pred(_Pred_) {}
+
+    _Cancellation_status _Process_chunk() {
+        if (_Results._Storage._Complete()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        const auto _Range1       = _Basis1._Get_chunk(_Key);
+        auto _First1             = _Range1._First;
+        auto _First2             = _Basis2._Get_chunk(_Key)._First;
+        for (;;) {
+            if (_First1 == _Range1._Last) {
+                return _Cancellation_status::_Running;
+            }
+
+            if (!_Pred(*_First1, *_First2)) {
+                _Results._Imbue(_Chunk_number, _First1, _First2);
+                return _Cancellation_status::_Canceled;
+            }
+
+            ++_First1;
+            ++_First2;
+        }
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_mismatch3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
+    _ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) noexcept /* terminates */ {
+    // return [_First1, _Last1)/[_First2, ...) mismatch
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First1, _Last1);
+    const auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count   = _STD distance(_UFirst1, _ULast1);
+            const auto _UFirst2 = _STD _Get_unwrapped_n(_First2, _Count);
+            if (_Count >= 2) {
+                _TRY_BEGIN
+                _Static_partitioned_mismatch3 _Operation{_Hw_threads, _Count, _UFirst1, _UFirst2, _STD _Pass_fn(_Pred)};
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                const auto _Result = _Operation._Results._Get_result(_UFirst1, _UFirst2);
+                _STD _Seek_wrapped(_First2, _Result.second);
+                _STD _Seek_wrapped(_First1, _Result.first);
+                return {_First1, _First2};
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            const auto _Result = _STD mismatch(_UFirst1, _ULast1, _UFirst2, _STD _Pass_fn(_Pred));
+            _STD _Seek_wrapped(_First2, _Result.second);
+            _STD _Seek_wrapped(_First1, _Result.first);
+            return {_First1, _First2};
+        }
+    }
+
+    const auto _Result = _STD mismatch(_UFirst1, _ULast1,
+        _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_FwdIt1>(_UFirst1, _ULast1)), _STD _Pass_fn(_Pred));
+    _STD _Seek_wrapped(_First2, _Result.second);
+    _STD _Seek_wrapped(_First1, _Result.first);
+    return {_First1, _First2};
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD pair<_FwdIt1, _FwdIt2> mismatch(
+    _ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept /* terminates */ {
+    // return [_First1, _Last1)/[_First2, _Last2) mismatch
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    const auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+    const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count =
+                static_cast<_Iter_diff_t<_FwdIt1>>(_STD _Distance_min(_UFirst1, _ULast1, _UFirst2, _ULast2));
+            if (_Count >= 2) {
+                _TRY_BEGIN
+                _Static_partitioned_mismatch3 _Operation{_Hw_threads, _Count, _UFirst1, _UFirst2, _STD _Pass_fn(_Pred)};
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                const auto _Result = _Operation._Results._Get_result(_UFirst1, _UFirst2);
+                _STD _Seek_wrapped(_First2, _Result.second);
+                _STD _Seek_wrapped(_First1, _Result.first);
+                return {_First1, _First2};
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial below
+                _CATCH_END
+            }
+        }
+    }
+
+    const auto _Result = _STD mismatch(_UFirst1, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred));
+    _STD _Seek_wrapped(_First2, _Result.second);
+    _STD _Seek_wrapped(_First1, _Result.first);
+    return {_First1, _First2};
+}
+
+template <class _FwdIt1, class _FwdIt2, class _Pr>
+struct _Static_partitioned_equal2 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
+    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
+    _Pr _Pred;
+    _Cancellation_token _Cancel_token;
+
+    _Static_partitioned_equal2(const size_t _Hw_threads, const _Diff _Count, _Pr _Pred_, const _FwdIt1&, const _FwdIt2&)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{}, _Pred(_Pred_),
+          _Cancel_token{} {}
+
+    _Cancellation_status _Process_chunk() {
+        if (_Cancel_token._Is_canceled()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Range1       = _Basis1._Get_chunk(_Key);
+        const auto _Range2_first = _Basis2._Get_chunk(_Key)._First;
+        if (_STD equal(_Range1._First, _Range1._Last, _Range2_first, _Pred)) {
+            return _Cancellation_status::_Running;
+        }
+
+        _Cancel_token._Cancel();
+        return _Cancellation_status::_Canceled;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_equal2*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD bool equal(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, _Pr _Pred) noexcept
+/* terminates */ {
+    // compare [_First1, _Last1) to [_First2, ...)
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First1, _Last1);
+    const auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count   = _STD distance(_UFirst1, _ULast1);
+            const auto _UFirst2 = _STD _Get_unwrapped_n(_First2, _Count);
+            if (_Count >= 2) {
+                _TRY_BEGIN
+                _Static_partitioned_equal2 _Operation{_Hw_threads, _Count, _STD _Pass_fn(_Pred), _UFirst1, _UFirst2};
+                _Operation._Basis1._Populate(_Operation._Team, _UFirst1);
+                _Operation._Basis2._Populate(_Operation._Team, _UFirst2);
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return !_Operation._Cancel_token._Is_canceled_relaxed();
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            return _STD equal(_UFirst1, _ULast1, _UFirst2, _STD _Pass_fn(_Pred));
+        }
+    }
+
+    return _STD equal(_UFirst1, _ULast1, _First2, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD bool equal(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2,
+    _Pr _Pred) noexcept /* terminates */ {
+    // compare [_First1, _Last1) to [_First2, _Last2)
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    const auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+    const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count = _STD _Distance_any(_UFirst1, _ULast1, _UFirst2, _ULast2);
+            if (_Count >= 2) {
+                _TRY_BEGIN
+                _Static_partitioned_equal2 _Operation{_Hw_threads, _Count, _STD _Pass_fn(_Pred), _UFirst1, _UFirst2};
+                if (!_Operation._Basis1._Populate(_Operation._Team, _UFirst1, _ULast1)) {
+                    // left sequence didn't have length _Count
+                    return false;
+                }
+
+                if (!_Operation._Basis2._Populate(_Operation._Team, _UFirst2, _ULast2)) {
+                    // right sequence didn't have length _Count
+                    return false;
+                }
+
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return !_Operation._Cancel_token._Is_canceled_relaxed();
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to equal below
+                _CATCH_END
+            }
+        }
+    }
+
+    return _STD equal(_UFirst1, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred));
+}
+
+template <class _FwdItHaystack, class _FwdItPat, class _Pr>
+struct _Static_partitioned_search3 {
+    _Static_partition_team<_Iter_diff_t<_FwdItHaystack>> _Team;
+    _Static_partition_range<_FwdItHaystack> _Basis;
+    _Parallel_find_results<_FwdItHaystack> _Results;
+    _FwdItPat _First2;
+    _FwdItPat _Last2;
+    _Pr _Pred;
+
+    _Static_partitioned_search3(const size_t _Hw_threads, const _Iter_diff_t<_FwdItHaystack> _Count,
+        const _FwdItHaystack _First1, const _FwdItHaystack _Last1, const _FwdItPat _First2_, const _FwdItPat _Last2_,
+        _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Results(_Last1),
+          _First2(_First2_), _Last2(_Last2_), _Pred(_Pred_) {
+        _Basis._Populate(_Team, _First1);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        if (_Results._Complete()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Range = _Basis._Get_chunk(_Key);
+        for (auto _Candidate = _Range._First; _Candidate != _Range._Last; ++_Candidate) {
+            if (_STD _Equal_rev_pred_unchecked(_Candidate, _First2, _Last2, _Pred)) {
+                _Results._Imbue(_Key._Chunk_number, _Candidate);
+                return _Cancellation_status::_Canceled;
+            }
+        }
+
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_search3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdItHaystack, class _FwdItPat, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdItHaystack search(_ExPo&&, const _FwdItHaystack _First1, _FwdItHaystack _Last1, const _FwdItPat _First2,
+    const _FwdItPat _Last2, _Pr _Pred) noexcept /* terminates */ {
+    // find first [_First2, _Last2) match
+    _REQUIRE_PARALLEL_ITERATOR(_FwdItHaystack);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdItPat);
+    _STD _Adl_verify_range(_First2, _Last2);
+    const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+    const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    if (_UFirst2 == _ULast2) {
+        return _First1;
+    }
+
+    _STD _Adl_verify_range(_First1, _Last1);
+    const auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            _Iter_diff_t<_FwdItHaystack> _Count;
+            if constexpr (_Is_ranges_random_iter_v<_FwdItHaystack> && _Is_ranges_random_iter_v<_FwdItPat>) {
+                const auto _HaystackDist = _ULast1 - _UFirst1;
+                const auto _NeedleDist   = _ULast2 - _UFirst2;
+                if (_NeedleDist > _HaystackDist) { // needle is longer than haystack, no match possible
+                    return _Last1;
+                }
+
+                // +1 can't overflow because _NeedleDist > 0 because _First2 != _Last2
+                _Count = static_cast<_Iter_diff_t<_FwdItHaystack>>(_HaystackDist - _NeedleDist + 1);
+            } else {
+                auto _UFirst1c = _UFirst1;
+                auto _UFirst2c = _UFirst2;
+                for (;;) {
+                    if (_UFirst1c == _ULast1) {
+                        // either haystack was shorter than needle so no match is possible, or haystack was empty so
+                        // returning _Last1 is the same as returning _First1
+                        return _Last1;
+                    }
+
+                    ++_UFirst2c;
+                    if (_UFirst2c == _ULast2) {
+                        _Count = _STD distance(_UFirst1c, _ULast1);
+                        break;
+                    }
+
+                    ++_UFirst1c;
+                }
+            }
+
+            if (_Count == 1) {
+                // 1 match possible == ranges are of equal length -- do better than serial search because we've done the
+                // work to calculate distance() of the inputs
+                if (_STD _Equal_rev_pred_unchecked(_UFirst1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred))) {
+                    return _First1;
+                }
+
+                return _Last1;
+            }
+
+            _TRY_BEGIN
+            _Static_partitioned_search3 _Operation{
+                _Hw_threads, _Count, _UFirst1, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred)};
+            _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+            _STD _Seek_wrapped(_Last1, _Operation._Results._Get_result());
+            return _Last1;
+            _CATCH(const _Parallelism_resources_exhausted&)
+            // fall through to search, below
+            _CATCH_END
+        }
+    }
+
+    _STD _Seek_wrapped(_Last1, _STD search(_UFirst1, _ULast1, _UFirst2, _ULast2, _STD _Pass_fn(_Pred)));
+    return _Last1;
+}
+
+template <class _FwdIt, class _Ty, class _Pr>
+struct _Static_partitioned_search_n3 {
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _Parallel_find_results<_FwdIt> _Results;
+    _Iter_diff_t<_FwdIt> _Target_count;
+    const _Ty& _Val;
+    _Pr _Pred;
+
+    _Static_partitioned_search_n3(const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Candidates, const _FwdIt _First,
+        const _FwdIt _Last, const _Iter_diff_t<_FwdIt> _Target_count_, const _Ty& _Val_, _Pr _Pred_)
+        : _Team{_Candidates, _Get_chunked_work_chunk_count(_Hw_threads, _Candidates)}, _Basis{}, _Results(_Last),
+          _Target_count(_Target_count_), _Val(_Val_), _Pred(_Pred_) {
+        _Basis._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        if (_Results._Complete()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Range = _Basis._Get_chunk(_Key);
+
+        // any match in this chunk will have at least 1 element in _Range, so the furthest off the
+        // end of the candidate range we will need to search is _Target_count - 1
+        const _Iter_diff_t<_FwdIt> _Overshoot = _Target_count - 1;
+        const auto _Serial_last               = _STD next(_Range._Last, _Overshoot);
+
+        // we delegate to the serial algorithm targeting [_First, _Last + _Overshoot)
+        // which we know is safe because we only partitioned _First + _Candidates start positions
+        // if we have a match, it will be within [_First, _Last); otherwise the serial algorithm
+        // will tell us _Last + _Overshoot
+        const auto _Candidate = _STD search_n(_Range._First, _Serial_last, _Target_count, _Val, _Pred);
+        if (_Candidate == _Serial_last) {
+            return _Cancellation_status::_Running;
+        }
+
+        _Results._Imbue(_Key._Chunk_number, _Candidate);
+        return _Cancellation_status::_Canceled;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_search_n3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdIt search_n(_ExPo&&, const _FwdIt _First, _FwdIt _Last, const _Diff _Count_raw, const _Ty& _Val,
+    _Pr _Pred) noexcept /* terminates */ {
+    // find first _Count * _Val satisfying _Pred
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    const _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        _Last = _First;
+        return _Last;
+    }
+
+    if (static_cast<uintmax_t>(_Count) > static_cast<uintmax_t>(_STD _Max_limit<_Iter_diff_t<_FwdIt>>())) {
+        // if the number of _Vals searched for is larger than the longest possible sequence, we can't find it
+        return _Last;
+    }
+
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Haystack_count = _STD distance(_UFirst, _ULast);
+            if (_Count > _Haystack_count) {
+                return _Last;
+            }
+
+            // +1 can't overflow because _Count > 0
+            const auto _Candidates = static_cast<_Iter_diff_t<_FwdIt>>(_Haystack_count - _Count + 1);
+            _TRY_BEGIN
+            _Static_partitioned_search_n3 _Operation{_Hw_threads, _Candidates, _UFirst, _ULast,
+                static_cast<_Iter_diff_t<_FwdIt>>(_Count), _Val, _STD _Pass_fn(_Pred)};
+            _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+            _STD _Seek_wrapped(_Last, _Operation._Results._Get_result());
+            return _Last;
+            _CATCH(const _Parallelism_resources_exhausted&)
+            // fall through to search_n, below
+            _CATCH_END
+        }
+    }
+
+    _STD _Seek_wrapped(_Last, _STD search_n(_UFirst, _ULast, _Count, _Val, _STD _Pass_fn(_Pred)));
+    return _Last;
+}
+
+template <class _FwdIt1, class _FwdIt2, class _Fn>
+struct _Static_partitioned_unary_transform2 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Source_basis;
+    _Static_partition_range<_FwdIt2, _Diff> _Dest_basis;
+    _Fn _Func;
+
+    _Static_partitioned_unary_transform2(
+        const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First, _Fn _Fx, const _FwdIt2&)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Source_basis{}, _Dest_basis{},
+          _Func(_Fx) {
+        _Source_basis._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (_Key) {
+            const auto _Source = _Source_basis._Get_chunk(_Key);
+            _STD transform(_Source._First, _Source._Last, _Dest_basis._Get_chunk(_Key)._First, _Func);
+            return _Cancellation_status::_Running;
+        }
+
+        return _Cancellation_status::_Canceled;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_unary_transform2*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Fn,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt2 transform(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Fn _Func) noexcept
+/* terminates */ {
+    // transform [_First, _Last) with _Func
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines...
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            const auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                _Static_partitioned_unary_transform2 _Operation{
+                    _Hw_threads, _Count, _UFirst, _STD _Pass_fn(_Func), _UDest};
+                _STD _Seek_wrapped(_Dest, _Operation._Dest_basis._Populate(_Operation._Team, _UDest));
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(_Dest, _STD transform(_UFirst, _ULast, _UDest, _STD _Pass_fn(_Func)));
+            return _Dest;
+        } else {
+            _STD _Seek_wrapped(_Dest,
+                _STD transform(_UFirst, _ULast,
+                    _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)), _STD _Pass_fn(_Func)));
+            return _Dest;
+        }
+    } else {
+        _STD _Seek_wrapped(_Dest,
+            _STD transform(_UFirst, _ULast, _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
+                _STD _Pass_fn(_Func)));
+        return _Dest;
+    }
+}
+
+template <class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn>
+struct _Static_partitioned_binary_transform2 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2, _FwdIt3>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Source1_basis;
+    _Static_partition_range<_FwdIt2, _Diff> _Source2_basis;
+    _Static_partition_range<_FwdIt3, _Diff> _Dest_basis;
+    _Fn _Func;
+
+    _Static_partitioned_binary_transform2(
+        const size_t _Hw_threads, const _Diff _Count, _FwdIt1 _First1, _FwdIt2 _First2, _Fn _Fx, const _FwdIt3&)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Source1_basis{}, _Source2_basis{},
+          _Dest_basis{}, _Func(_Fx) {
+        _Source1_basis._Populate(_Team, _First1);
+        _Source2_basis._Populate(_Team, _First2);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (_Key) {
+            const auto _Source1 = _Source1_basis._Get_chunk(_Key);
+            _STD transform(_Source1._First, _Source1._Last, _Source2_basis._Get_chunk(_Key)._First,
+                _Dest_basis._Get_chunk(_Key)._First, _Func);
+            return _Cancellation_status::_Running;
+        }
+
+        return _Cancellation_status::_Canceled;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_binary_transform2*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt3 transform(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, _FwdIt3 _Dest,
+    _Fn _Func) noexcept /* terminates */ {
+    // transform [_First1, _Last1) and [_First2, ...) with _Func
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    _STD _Adl_verify_range(_First1, _Last1);
+    const auto _UFirst1 = _STD _Get_unwrapped(_First1);
+    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines...
+            const auto _Count   = _STD distance(_UFirst1, _ULast1);
+            const auto _UFirst2 = _STD _Get_unwrapped_n(_First2, _Count);
+            const auto _UDest   = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                _Static_partitioned_binary_transform2 _Operation{
+                    _Hw_threads, _Count, _UFirst1, _UFirst2, _STD _Pass_fn(_Func), _UDest};
+                _STD _Seek_wrapped(_Dest, _Operation._Dest_basis._Populate(_Operation._Team, _UDest));
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(_Dest, _STD transform(_UFirst1, _ULast1, _UFirst2, _UDest, _STD _Pass_fn(_Func)));
+            return _Dest;
+        } else {
+            const auto _Count = _STD _Idl_distance<_FwdIt1>(_UFirst1, _ULast1);
+            _STD _Seek_wrapped(_Dest, _STD transform(_UFirst1, _ULast1, _STD _Get_unwrapped_n(_First2, _Count),
+                                          _STD _Get_unwrapped_n(_Dest, _Count), _STD _Pass_fn(_Func)));
+            return _Dest;
+        }
+    } else {
+        const auto _Count = _STD _Idl_distance<_FwdIt1>(_UFirst1, _ULast1);
+        _STD _Seek_wrapped(_Dest, _STD transform(_UFirst1, _ULast1, _STD _Get_unwrapped_n(_First2, _Count),
+                                      _STD _Get_unwrapped_n(_Dest, _Count), _STD _Pass_fn(_Func)));
+        return _Dest;
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+void replace(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval) noexcept
+/* terminates */ {
+    // replace each matching _Oldval with _Newval
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    _STD for_each(_STD forward<_ExPo>(_Exec), _First, _Last, [&](auto&& _Value) {
+        if (_STD forward<decltype(_Value)>(_Value) == _Oldval) {
+            _STD forward<decltype(_Value)>(_Value) = _Newval;
+        }
+    });
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+void replace_if(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred, const _Ty& _Val) noexcept
+/* terminates */ {
+    // replace each satisfying _Pred with _Val
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    auto _Lambda_pred = _STD _Pass_fn(_Pred); // TRANSITION, DevCom-10456445
+    _STD for_each(_STD forward<_ExPo>(_Exec), _First, _Last, [&_Val, _Lambda_pred](auto&& _Value) mutable {
+        if (_Lambda_pred(_STD forward<decltype(_Value)>(_Value))) {
+            _STD forward<decltype(_Value)>(_Value) = _Val;
+        }
+    });
+}
+
+template <class _FwdIt, class _Pr>
+_FwdIt _Remove_move_if_unchecked(_FwdIt _First, const _FwdIt _Last, _FwdIt _Dest, _Pr _Pred) {
+    // move omitting each element satisfying _Pred
+    for (; _First != _Last; ++_First) {
+        if (!_Pred(*_First)) {
+            *_Dest = _STD move(*_First);
+            ++_Dest;
+        }
+    }
+
+    return _Dest;
+}
+
+template <class _FwdIt, class _Pr>
+struct _Static_partitioned_remove_if2 {
+    enum class _Chunk_state : unsigned char {
+        _Serial, // while a chunk is in the serial state, it is touched only by an owner thread
+        _Merging, // while a chunk is in the merging state, threads all try to CAS the chunk _Merging -> _Moving
+                  // the thread that succeeds takes responsibility for moving the keepers from that chunk to the
+                  // results
+        _Moving, // while a chunk is in the moving state, the keepers are being moved to _Results
+                 // only one chunk at a time is ever _Moving; this also serves to synchronize access to _Results
+        _Done // when a chunk becomes _Done, it is complete / will never need to touch _Results again
+
+        // as an optimization, if a thread sees that it has no predecessor (or its predecessor is _Done), it
+        // may transition from _Serial directly to _Done, doing the moving step implicitly.
+    };
+
+    struct alignas(hardware_destructive_interference_size) alignas(_FwdIt) _Chunk_local_data {
+        atomic<_Chunk_state> _State;
+        _FwdIt _New_end;
+    };
+
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _Pr _Pred;
+    _Parallel_vector<_Chunk_local_data> _Chunk_locals;
+    _FwdIt _Results;
+
+    _Static_partitioned_remove_if2(
+        const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, const _FwdIt _First, const _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Pred{_Pred_},
+          _Chunk_locals(_Team._Chunks), _Results{_First} {
+        _Basis._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        // remove phase:
+        auto _Merge_index = _Key._Chunk_number; // merge step will start from this index
+        {
+            auto& _Chunk_data = _Chunk_locals[_Merge_index];
+            const auto _Range = _Basis._Get_chunk(_Key);
+            if (_Merge_index == 0 || _Chunk_locals[_Merge_index - 1]._State.load() == _Chunk_state::_Done) {
+                // no predecessor, so run serial algorithm directly into results
+                if (_Merge_index == 0 || _Results == _Range._First) {
+                    _Results = _STD remove_if(_Range._First, _Range._Last, _Pred);
+                } else {
+                    _Results = _STD _Remove_move_if_unchecked(_Range._First, _Range._Last, _Results, _Pred);
+                }
+
+                _Chunk_data._State.store(_Chunk_state::_Done);
+                ++_Merge_index; // this chunk is already merged
+            } else { // predecessor, run serial algorithm in place and attempt to merge later
+                _Chunk_data._New_end = _STD remove_if(_Range._First, _Range._Last, _Pred);
+                _Chunk_data._State.store(_Chunk_state::_Merging);
+                if (_Chunk_locals[_Merge_index - 1]._State.load() != _Chunk_state::_Done) {
+                    // if the predecessor isn't done, whichever thread merges our predecessor will merge us too
+                    return _Cancellation_status::_Running;
+                }
+            }
+        }
+
+        // merge phase: at this point, we have observed that our predecessor chunk has been merged to the output,
+        // attempt to become the new merging thread if the previous merger gave up
+        // note: it is an invariant when we get here that _Chunk_locals[_Merge_index - 1]._State == _Chunk_state::_Done
+        for (; _Merge_index != _Team._Chunks; ++_Merge_index) {
+            auto& _Merge_chunk_data = _Chunk_locals[_Merge_index];
+            auto _Expected          = _Chunk_state::_Merging;
+            if (!_Merge_chunk_data._State.compare_exchange_strong(_Expected, _Chunk_state::_Moving)) {
+                // either the _Merge_index chunk isn't ready to merge yet, or another thread will do it
+                return _Cancellation_status::_Running;
+            }
+
+            const auto _Merge_first   = _Basis._Get_first(_Merge_index, _Team._Get_chunk_offset(_Merge_index));
+            const auto _Merge_new_end = _STD exchange(_Merge_chunk_data._New_end, {});
+            if (_Results == _Merge_first) { // entire range up to now had no removals, don't bother moving
+                _Results = _Merge_new_end;
+            } else {
+                _Results = _STD _Move_unchecked(_Merge_first, _Merge_new_end, _Results);
+            }
+
+            _Merge_chunk_data._State.store(_Chunk_state::_Done);
+        }
+
+        return _Cancellation_status::_Canceled;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_remove_if2*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD_REMOVE_ALG _FwdIt remove_if(_ExPo&&, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept
+/* terminates */ {
+    // remove each satisfying _Pred
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            if (_Count >= 2) {
+                _TRY_BEGIN
+                _Static_partitioned_remove_if2 _Operation{_Hw_threads, _Count, _UFirst, _STD _Pass_fn(_Pred)};
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                _STD _Seek_wrapped(_First, _Operation._Results);
+                return _First;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _STD remove_if(_UFirst, _ULast, _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD_REMOVE_ALG _FwdIt remove(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept
+/* terminates */ {
+    // remove each matching _Val
+    return _STD remove_if(_STD forward<_ExPo>(_Exec), _First, _Last,
+        [&_Val](auto&& _Lhs) { return _STD forward<decltype(_Lhs)>(_Lhs) == _Val; });
+}
+
+template <class _Diff>
+struct _Sort_work_item_impl { // data describing an individual sort work item
+    using difference_type = _Diff;
+
+    _Diff _Offset;
+    _Diff _Size;
+    _Diff _Ideal;
+};
+
+template <class _RanIt>
+using _Sort_work_item = _Sort_work_item_impl<_Iter_diff_t<_RanIt>>;
+
+template <class _RanIt, class _Pr>
+bool _Process_sort_work_item(const _RanIt _Basis, _Pr _Pred, _Sort_work_item<_RanIt>& _Wi,
+    _Sort_work_item<_RanIt>& _Right_fork_wi, _Iter_diff_t<_RanIt>& _Work_complete) noexcept /* terminates */ {
+    // processes the sort work item, _Wi, relative to _Basis
+    // if the sort is divided into quicksort sub-problems:
+    //   the return value is true
+    //   _Wi contains the left sub-problem; the caller should continue with this
+    //   _Right_fork_wi contains the right sub-problem; the caller should allow this to be stolen
+    // otherwise:
+    //   the return value is false
+    //   _Wi's range is completely sorted
+    //   _Right_fork_wi is unmodified
+    const auto _Size  = _Wi._Size;
+    const auto _First = _Basis + _Wi._Offset;
+    const auto _Last  = _First + _Size;
+    const auto _Ideal = _Wi._Ideal;
+    if (_Size <= _Isort_max<_RanIt>) {
+        _STD _Insertion_sort_unchecked(_First, _Last, _Pred);
+        _Work_complete += _Size;
+        return false;
+    }
+
+    if (0 < _Ideal) { // divide and conquer by partitioning (quicksort)
+        const auto _Mid = _STD _Partition_by_median_guess_unchecked(_First, _Last, _Pred);
+        const auto _New_ideal =
+            static_cast<_Iter_diff_t<_RanIt>>(_Ideal / 2 + _Ideal / 4); // allow 1.5 log2(N) divisions
+        _Wi._Size      = _Mid.first - _First;
+        _Wi._Ideal     = _New_ideal;
+        _Right_fork_wi = {_Mid.second - _Basis, _Last - _Mid.second, _New_ideal};
+        _Work_complete += _Mid.second - _Mid.first;
+        return true;
+    }
+
+    // too many divisions; heap sort
+    _STD _Make_heap_unchecked(_First, _Last, _Pred);
+    _STD _Sort_heap_unchecked(_First, _Last, _Pred);
+    _Work_complete += _Size;
+    return false;
+}
+
+template <class _RanIt, class _Pr>
+void _Process_sort_queue(const _RanIt _Basis, _Pr _Pred, _Work_stealing_membership<_Sort_work_item<_RanIt>>& _My_ticket,
+    _Sort_work_item<_RanIt>& _Wi) noexcept /* terminates */ {
+    _Sort_work_item<_RanIt> _Right_fork_wi;
+    do { // process work items in the local queue
+        while (_STD _Process_sort_work_item(_Basis, _Pred, _Wi, _Right_fork_wi, _My_ticket._Work_complete)) {
+            _TRY_BEGIN
+            _My_ticket._Push_bottom(_Right_fork_wi);
+            _CATCH(const _Parallelism_resources_exhausted&)
+            // local queue is full and memory can't be acquired, process _Right_fork_wi serially
+            const auto _First = _Basis + _Right_fork_wi._Offset;
+            _STD _Sort_unchecked(_First, _First + _Right_fork_wi._Size, _Right_fork_wi._Ideal, _Pred);
+            _My_ticket._Work_complete += _Right_fork_wi._Size;
+            _CATCH_END
+        }
+    } while (_My_ticket._Try_pop_bottom(_Wi));
+}
+
+template <class _RanIt, class _Pr>
+struct _Sort_operation { // context for background threads
+    _RanIt _Basis;
+    _Pr _Pred;
+    _Work_stealing_team<_Sort_work_item<_RanIt>> _Team;
+
+    _Sort_operation(_RanIt _First, _Pr _Pred_arg, size_t _Threads, _Iter_diff_t<_RanIt> _Count)
+        : _Basis(_First), _Pred(_Pred_arg), _Team(_Threads, _Count) {}
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, const __std_PTP_WORK _Work) noexcept /* terminates */ {
+        const auto _This  = static_cast<_Sort_operation*>(_Context);
+        const auto _Basis = _This->_Basis;
+        const auto _Pred  = _This->_Pred;
+        auto& _Team       = _This->_Team;
+        auto _My_ticket   = _Team._Join_team();
+        _Sort_work_item<_RanIt> _Wi;
+        for (;;) {
+            switch (_My_ticket._Steal(_Wi)) {
+            case _Steal_result::_Success:
+                _STD _Process_sort_queue(_Basis, _Pred, _My_ticket, _Wi);
+                break;
+            case _Steal_result::_Abort:
+                _My_ticket._Leave();
+                __std_submit_threadpool_work(_Work);
+                return;
+            case _Steal_result::_Done:
+                return;
+            }
+        }
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+void sort(_ExPo&&, const _RanIt _First, const _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // order [_First, _Last)
+    _REQUIRE_CPP17_MUTABLE_RANDOM_ACCESS_ITERATOR(_RanIt);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst                = _STD _Get_unwrapped(_First);
+    const auto _ULast                 = _STD _Get_unwrapped(_Last);
+    const _Iter_diff_t<_RanIt> _Ideal = _ULast - _UFirst;
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        size_t _Threads;
+        if (_Ideal > _ISORT_MAX && (_Threads = __std_parallel_algorithms_hw_threads()) > 1) {
+            // parallelize when input is large enough and we aren't on a uniprocessor machine
+            _TRY_BEGIN
+            _Sort_operation _Operation(_UFirst, _STD _Pass_fn(_Pred), _Threads, _Ideal); // throws
+            const _Work_ptr _Work{_Operation}; // throws
+            auto& _Team     = _Operation._Team;
+            auto _My_ticket = _Team._Join_team();
+            _Work._Submit(_Threads - 1);
+            _Sort_work_item<_RanIt> _Wi{0, _Ideal, _Ideal};
+            _Steal_result _Sr;
+            do {
+                _STD _Process_sort_queue(_UFirst, _STD _Pass_fn(_Pred), _My_ticket, _Wi);
+
+                do {
+                    _Sr = _My_ticket._Steal(_Wi);
+                } while (_Sr == _Steal_result::_Abort);
+            } while (_Sr != _Steal_result::_Done);
+            return;
+            _CATCH(const _Parallelism_resources_exhausted&)
+            // fall through to _Sort_unchecked, below
+            _CATCH_END
+        }
+    }
+
+    _STD _Sort_unchecked(_UFirst, _ULast, _Ideal, _STD _Pass_fn(_Pred));
+}
+
+template <class _Ty>
+struct _Static_partitioned_temporary_buffer3 {
+    _Optimistic_temporary_buffer2<_Ty>& _Temp_buf;
+    ptrdiff_t _Chunk_size;
+    ptrdiff_t _Unchunked_items;
+
+    template <class _Diff>
+    explicit _Static_partitioned_temporary_buffer3(
+        _Optimistic_temporary_buffer2<_Ty>& _Temp_buf_raw, _Static_partition_team<_Diff>& _Team)
+        : _Temp_buf(_Temp_buf_raw), _Chunk_size(static_cast<ptrdiff_t>(_Temp_buf._Capacity / _Team._Chunks)),
+          _Unchunked_items(static_cast<ptrdiff_t>(_Temp_buf._Capacity % _Team._Chunks)) {}
+
+    pair<_Ty*, ptrdiff_t> _Get_temp_buffer_for_chunk(const size_t _Chunk_number) {
+        // get a view of the region of the temporary buffer allocated to chunk _Chunk_number
+        return _Get_temp_buffer_for_chunk_range(_Chunk_number, _Chunk_number + 1);
+    }
+
+    pair<_Ty*, ptrdiff_t> _Get_temp_buffer_for_chunk_range(const size_t _Base, const size_t _End) {
+        // get a view of the region of the temporary buffer allocated to the region of chunks [_Base, _End)
+        const auto _Offset = _Get_offset(_Base);
+        return {_Temp_buf._Data + _Offset, _Offset - _Get_offset(_End)};
+    }
+
+    _Ty* _Get_first(const size_t _Chunk_number) {
+        // get a pointer to the first element of the temporary buffer allocated to chunk _Chunk_number
+        return _Temp_buf._Data + _Get_offset(_Chunk_number);
+    }
+
+    ptrdiff_t _Get_offset(const size_t _Chunk_number) {
+        // get the offset of the first element of the temporary buffer allocated to chunk _Chunk_number
+        auto _Diff_chunk = static_cast<ptrdiff_t>(_Chunk_number);
+        return _Diff_chunk * _Chunk_size + (_STD min) (_Diff_chunk, _Unchunked_items);
+    }
+
+    void _Destroy_all() { // destroy each element of the temporary buffer
+        _STD _Destroy_range(_Temp_buf._Data, _Temp_buf._Data + _Temp_buf._Capacity);
+    }
+};
+
+inline size_t _Get_stable_sort_tree_height(const size_t _Count, const size_t _Hw_threads) {
+    // Get height of merge tree for parallel stable_sort, a bottom-up merge sort.
+    // * each merge takes two chunks from a buffer and copies to the other buffer in sorted order
+    // * we want the overall result to end up in the input buffer and not into _Temp_buf; each merge
+    //   "level" switches between the input buffer and the temporary buffer; as a result we want
+    //   the number of merge "levels" to be even (and thus chunks must be 2 raised to an even power)
+    // * the smallest chunk must be at least of size _ISORT_MAX
+    // * we want a number of chunks as close to _Ideal_chunks as we can to minimize scheduling
+    //   overhead, but can use more chunks than that
+    const auto _Count_max_chunks       = _Count / _ISORT_MAX;
+    const size_t _Log_count_max_chunks = _Floor_of_log_2(_Count_max_chunks);
+
+    // if _Log_count_max_chunks is odd, that would break our 2 to even power invariant, so
+    // go to the next smaller power of 2
+    const auto _Count_max_tree_height = _Log_count_max_chunks & ~static_cast<size_t>(1);
+
+    const auto _Ideal_chunks       = _Hw_threads * _Oversubscription_multiplier;
+    const size_t _Log_ideal_chunks = _Floor_of_log_2(_Ideal_chunks);
+#ifdef _WIN64
+    constexpr size_t _Max_tree_height = 62; // to avoid ptrdiff_t overflow
+#else // ^^^ 64-bit / 32-bit vvv
+    constexpr size_t _Max_tree_height = 30;
+#endif // ^^^ 32-bit ^^^
+    const size_t _Clamped_ideal_chunks = (_STD min) (_Max_tree_height, _Log_ideal_chunks);
+
+    // similarly, if _Clamped_ideal_chunks is odd, that would break our 2 to even power invariant,
+    // so go to the next higher power of 2
+    const auto _Ideal_tree_height = _Clamped_ideal_chunks + (_Clamped_ideal_chunks & 0x1U);
+
+    return (_STD min) (_Count_max_tree_height, _Ideal_tree_height);
+}
+
+struct _Bottom_up_merge_tree {
+    // merge tree / cells:
+    // each level of the tree has the next 1 bit turned on:
+    // 0 == done
+    //         1               1
+    //         2       3       1x
+    //         4   5   6   7   1xx
+    // chunks: 0 1 2 3 4 5 6 7
+    // the starting cell for a given chunk is (_Chunk_number >> 1) + (1 << (height - 1))
+    // (divide the chunk number by 2, and add the starting index of the bottom row of the tree)
+    // a cell's parent is just left shifting the current cell by 1
+    size_t _Height;
+    // each cell's data is stored at _Buckets[_Cell - 1], since the 0th cell is unused / indicates termination
+    _Parallel_vector<atomic<bool>> _Buckets;
+
+    explicit _Bottom_up_merge_tree(const size_t _Height_)
+        : _Height(_Height_), _Buckets((static_cast<size_t>(1) << _Height_) - 1) {}
+};
+
+struct _Bottom_up_tree_visitor {
+    size_t _Cell;
+    size_t _Base;
+    size_t _Shift;
+
+    _Bottom_up_tree_visitor(const size_t _Tree_height, const size_t _Initial_chunk)
+        : _Cell((_Initial_chunk >> 1) + (static_cast<size_t>(1) << (_Tree_height - 1))),
+          _Base(_Initial_chunk & ~static_cast<size_t>(1)), _Shift(1) {}
+
+    bool _Try_give_up_merge_to_peer(_Bottom_up_merge_tree& _Merge_tree) const {
+        // Attempt to mark that this child is done, to let our peer do the merge.
+        // Returns whether we successfully gave responsibility for doing the current merge to our peer.
+        return !_Merge_tree._Buckets[_Cell - 1].exchange(true);
+    }
+
+    bool _Go_to_parent() {
+        // Attempt to go to the parent in the merge tree; returns whether the move to the parent was successful.
+        _Shift <<= 1;
+        _Base -= _Shift * (_Cell & static_cast<size_t>(1));
+        _Cell >>= 1;
+        return _Cell != 0;
+    }
+};
+
+template <class _BidIt, class _Pr>
+struct _Static_partitioned_stable_sort4 {
+    using _Diff = _Iter_diff_t<_BidIt>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_BidIt> _Basis;
+    _Bottom_up_merge_tree _Merge_tree;
+    _Static_partitioned_temporary_buffer3<_Iter_value_t<_BidIt>> _Temp_buf;
+    _Pr _Pred;
+
+    _Static_partitioned_stable_sort4(_Optimistic_temporary_buffer2<_Iter_value_t<_BidIt>>& _Temp_buf_raw,
+        const _Diff _Count, const size_t _Merge_tree_height_, const _BidIt _First, _Pr _Pred_)
+        : _Team(_Count, static_cast<size_t>(1) << _Merge_tree_height_), _Basis{}, _Merge_tree(_Merge_tree_height_),
+          _Temp_buf(_Temp_buf_raw, _Team), _Pred{_Pred_} {
+        _Basis._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        {
+            const auto _Serial_chunk = _Basis._Get_chunk(_Key);
+            const auto _Temp_chunk   = _Temp_buf._Get_temp_buffer_for_chunk(_Key._Chunk_number);
+            _STD _Stable_sort_unchecked(
+                _Serial_chunk._First, _Serial_chunk._Last, _Key._Size, _Temp_chunk.first, _Temp_chunk.second, _Pred);
+        }
+
+        _Bottom_up_tree_visitor _Visitor{_Merge_tree._Height, _Key._Chunk_number};
+        if (_Visitor._Try_give_up_merge_to_peer(_Merge_tree)) { // peer will do the work to merge
+            return _Cancellation_status::_Running;
+        }
+
+        if (_Temp_buf._Temp_buf._Capacity >= _Team._Count) { // enough space, combine using merge
+            { // first merge is special; constructs the elements in the temporary buffer space
+                const size_t _Base = _Visitor._Base;
+                _STD _Uninitialized_merge_move(_Basis._Get_first(_Base, _Team._Get_chunk_offset(_Base)),
+                    _Basis._Get_first(_Base + 1, _Team._Get_chunk_offset(_Base + 1)),
+                    _Basis._Get_first(_Base + 2, _Team._Get_chunk_offset(_Base + 2)), _Temp_buf._Get_first(_Base),
+                    _Pred);
+            }
+
+            for (;;) { // walk remaining merge tree
+                (void) _Visitor._Go_to_parent(); // can't be complete because the data is in the temporary buffer
+                if (_Visitor._Try_give_up_merge_to_peer(_Merge_tree)) { // the other child will do the merge
+                    return _Cancellation_status::_Running;
+                }
+
+                { // merge two sub-ranges from temporary buffer to input
+                    const size_t _Base = _Visitor._Base;
+                    const size_t _Mid  = _Base + _Visitor._Shift;
+                    const size_t _End  = _Mid + _Visitor._Shift;
+                    _STD _Merge_move_unchecked(_Temp_buf._Get_first(_Base), _Temp_buf._Get_first(_Mid),
+                        _Temp_buf._Get_first(_End), _Basis._Get_first(_Base, _Team._Get_chunk_offset(_Base)), _Pred);
+                }
+
+                if (!_Visitor._Go_to_parent()) {
+                    // temporary bits have been copied back to the input, no parent, so we're done
+                    _Temp_buf._Destroy_all();
+                    return _Cancellation_status::_Canceled;
+                }
+
+                if (_Visitor._Try_give_up_merge_to_peer(_Merge_tree)) { // the other child will do the merge
+                    return _Cancellation_status::_Running;
+                }
+
+                { // merge two sub-ranges from input to temporary buffer
+                    const size_t _Base = _Visitor._Base;
+                    const size_t _Mid  = _Base + _Visitor._Shift;
+                    const size_t _End  = _Mid + _Visitor._Shift;
+                    _STD _Merge_move_unchecked(_Basis._Get_first(_Base, _Team._Get_chunk_offset(_Base)),
+                        _Basis._Get_first(_Mid, _Team._Get_chunk_offset(_Mid)),
+                        _Basis._Get_first(_End, _Team._Get_chunk_offset(_End)), _Temp_buf._Get_first(_Base), _Pred);
+                }
+            }
+        } else { // not enough space, combine using inplace_merge
+            for (;;) {
+                const size_t _Base      = _Visitor._Base;
+                const size_t _Mid       = _Base + _Visitor._Shift;
+                const size_t _End       = _Mid + _Visitor._Shift;
+                const auto _Base_offset = _Team._Get_chunk_offset(_Base);
+                const auto _Mid_offset  = _Team._Get_chunk_offset(_Mid);
+                const auto _End_offset  = _Team._Get_chunk_offset(_End);
+                const auto _Temp_range  = _Temp_buf._Get_temp_buffer_for_chunk_range(_Base, _End);
+                _STD _Buffered_inplace_merge_unchecked(_Basis._Get_first(_Base, _Base_offset),
+                    _Basis._Get_first(_Mid, _Mid_offset), _Basis._Get_first(_End, _End_offset),
+                    _Mid_offset - _Base_offset, _End_offset - _Mid_offset, _Temp_range.first, _Temp_range.second,
+                    _Pred);
+
+                if (!_Visitor._Go_to_parent()) { // no parent, so we're done
+                    return _Cancellation_status::_Canceled;
+                }
+
+                if (_Visitor._Try_give_up_merge_to_peer(_Merge_tree)) { // the other child will do the merge
+                    return _Cancellation_status::_Running;
+                }
+            }
+        }
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_stable_sort4*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+void stable_sort(_ExPo&&, const _BidIt _First, const _BidIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // sort preserving order of equivalents
+    _REQUIRE_CPP17_MUTABLE_BIDIRECTIONAL_ITERATOR(_BidIt);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _Count  = _STD distance(_UFirst, _ULast);
+    if (_Count <= _ISORT_MAX) {
+        _STD _Insertion_sort_unchecked(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+        return;
+    }
+
+    size_t _Hw_threads;
+    bool _Attempt_parallelism;
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        _Hw_threads          = __std_parallel_algorithms_hw_threads();
+        _Attempt_parallelism = _Hw_threads > 1;
+    } else {
+        _Attempt_parallelism = false;
+    }
+
+    _Optimistic_temporary_buffer2<_Iter_value_t<_BidIt>> _Temp_buf{_Attempt_parallelism ? _Count : _Count - _Count / 2};
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        if (_Attempt_parallelism) {
+            // forward+ iterator overflow assumption for size_t cast
+            const auto _Tree_height = _Get_stable_sort_tree_height(static_cast<size_t>(_Count), _Hw_threads);
+            if (_Tree_height != 0) {
+                _TRY_BEGIN
+                _Static_partitioned_stable_sort4 _Operation{
+                    _Temp_buf, _Count, _Tree_height, _UFirst, _STD _Pass_fn(_Pred)};
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    _STD _Stable_sort_unchecked(_UFirst, _ULast, _Count, _Temp_buf._Data, _Temp_buf._Capacity, _STD _Pass_fn(_Pred));
+}
+
+template <class _FwdIt, class _Pr>
+struct _Static_partitioned_is_sorted_until2 {
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    // note offset partitioning:
+    _Static_partition_range<_FwdIt> _Basis; // contains partition of [_First, _Last - 1)
+    _Pr _Pred;
+    _Parallel_find_results<_FwdIt> _Results;
+
+    _Static_partitioned_is_sorted_until2(
+        _FwdIt _First, _FwdIt _Last, const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Pred(_Pred_), _Results(_Last) {
+        _Basis._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        if (_Results._Complete()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        auto _Range = _Basis._Get_chunk(_Key);
+        auto _Next  = _Range._First;
+        do {
+            ++_Next;
+            if (_DEBUG_LT_PRED(_Pred, *_Next, *_Range._First)) {
+                _Results._Imbue(_Key._Chunk_number, _Next);
+                return _Cancellation_status::_Canceled;
+            }
+
+            _Range._First = _Next;
+        } while (_Range._First != _Range._Last);
+
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_is_sorted_until2*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _FwdIt is_sorted_until(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find extent of range that is ordered by predicate
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            auto _Count = _STD distance(_UFirst, _ULast);
+            if (_Count >= 3) { // ... with at least 3 elements
+                _TRY_BEGIN
+                --_Count; // note unusual offset partitioning
+                _Static_partitioned_is_sorted_until2 _Operation{
+                    _UFirst, _ULast, _Hw_threads, _Count, _STD _Pass_fn(_Pred)};
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                _STD _Seek_wrapped(_First, _Operation._Results._Get_result());
+                return _First;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _STD is_sorted_until(_UFirst, _ULast, _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+inline constexpr unsigned char _Contains_counterexample = 0;
+inline constexpr unsigned char _Contains_true           = 1;
+inline constexpr unsigned char _Contains_false          = 2;
+
+template <class _FwdIt, class _Pr>
+unsigned char _Chunk_is_partitioned_status(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+    // Returns the is_partitioned status for this range.
+    // pre: Range is non-empty
+    unsigned char _Result = 0;
+    if (_Pred(*_First)) { // starts with T
+        _Result = _Contains_true;
+        for (;;) { // skip T partition
+            ++_First;
+            if (_First == _Last) { // all T
+                return _Contains_true;
+            }
+
+            if (!_Pred(*_First)) { // range contains a switching point from T to F
+                break;
+            }
+        }
+    }
+
+    _Result |= _Contains_false;
+    while (++_First != _Last) { // verify F partition
+        if (_Pred(*_First)) { // found an out of place element
+            return _Contains_counterexample;
+        }
+    }
+
+    return _Result;
+}
+
+template <class _FwdIt, class _Pr>
+struct _Static_partitioned_is_partitioned {
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    atomic<size_t> _Rightmost_true; // chunk number of the rightmost chunk found so far containing a T element
+    atomic<size_t> _Leftmost_false; // chunk number of the leftmost chunk found so far containing an F element
+    _Pr _Pred;
+
+    _Static_partitioned_is_partitioned(
+        const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, const _FwdIt _First, _Pr _Pred_)
+        : _Team(_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)), _Basis{}, _Rightmost_true(0),
+          _Leftmost_false(SIZE_MAX - 1), _Pred(_Pred_) {
+        _Basis._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        // Note that the cancellation status here is not used in the final returned answer of is_partitioned. Returning
+        // _Cancellation_status::_Canceled is simply used as an "early fail" mechanism to avoid doing unnecessary work.
+        // A final comparison of _Rightmost_true and _Leftmost_false is used to determine the final return value from
+        // a call to is_partitioned.
+        if (_Rightmost_true.load(memory_order_relaxed) > _Leftmost_false.load(memory_order_relaxed)) {
+            // we've found a T to the right of an F, so we know the range cannot be partitioned and we can stop
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        // looking at chunks from either end, moving in towards the middle
+        auto _Target_chunk_number = _Key._Chunk_number >> 1;
+        if (!(_Key._Chunk_number & static_cast<size_t>(1))) {
+            _Target_chunk_number = _Team._Chunks - _Target_chunk_number - 1;
+        }
+
+        const auto _Target_chunk_key  = _Team._Get_chunk_key(_Target_chunk_number);
+        const auto _Chunk             = _Basis._Get_chunk(_Target_chunk_key);
+        const auto _This_chunk_status = _STD _Chunk_is_partitioned_status(_Chunk._First, _Chunk._Last, _Pred);
+
+        if (_This_chunk_status == _Contains_counterexample) {
+            // indicating that this chunk contains a counterexample, so the range is not partitioned
+            _Rightmost_true.store(SIZE_MAX);
+            return _Cancellation_status::_Canceled;
+        }
+
+        // after determining the is_partitioned status for this chunk,
+        // we need to update the chunk numbers for leftmost F and rightmost T
+        auto _Old_true = _Rightmost_true.load();
+        if (_This_chunk_status & _Contains_true) {
+            while (_Target_chunk_number > _Old_true) {
+                if (_Rightmost_true.compare_exchange_weak(_Old_true, _Target_chunk_number)) {
+                    _Old_true = _Target_chunk_number;
+                    break;
+                }
+            }
+        }
+
+        // try to bail before doing more work if possible
+        auto _Old_false = _Leftmost_false.load();
+        if (_Old_true > _Old_false) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        if (_This_chunk_status & _Contains_false) {
+            while (_Target_chunk_number < _Old_false) {
+                if (_Leftmost_false.compare_exchange_weak(_Old_false, _Target_chunk_number)) {
+                    _Old_false = _Target_chunk_number;
+                    break;
+                }
+            }
+        }
+
+        // Other loads/stores may have been reordered around the loads of _Old_false and _Old_true, but this check may
+        // allow us to avoid more atomic loads.
+        // If such loads/stores have been reordered around the loads of _Old_false and _Old_true, then the next call to
+        // _Process_chunk will exit given the check on the _Rightmost_true and _Leftmost_false values at the top of the
+        // method.
+        if (_Old_true > _Old_false) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_is_partitioned*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD bool is_partitioned(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // test if [_First, _Last) is partitioned by _Pred
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                _Static_partitioned_is_partitioned _Operation{_Hw_threads, _Count, _UFirst, _STD _Pass_fn(_Pred)};
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Operation._Rightmost_true.load(memory_order_relaxed)
+                    <= _Operation._Leftmost_false.load(memory_order_relaxed);
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    return _STD is_partitioned(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+}
+
+template <class _RanIt, class _Pr>
+struct _Static_partitioned_is_heap_until2 {
+    using _Diff = _Iter_diff_t<_RanIt>;
+    _Static_partition_team<_Diff> _Team;
+    _RanIt _Range_first;
+    _Pr _Pred;
+    _Parallel_find_results<_RanIt> _Results;
+
+    _Static_partitioned_is_heap_until2(
+        _RanIt _First, _RanIt _Last, const size_t _Hw_threads, const _Diff _Count, _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Range_first(_First), _Pred(_Pred_),
+          _Results(_Last) {}
+
+    _Cancellation_status _Process_chunk() {
+        if (_Results._Complete()) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+        // Once _Key is obtained, the amount of work should not be discarded (see GH-818).
+
+        const auto _Chunk_range_size = _Key._Size;
+        const auto _Chunk_offset     = _Key._Start_at;
+        const auto _Last             = _Chunk_offset + _Chunk_range_size;
+
+        const auto _Initial = (_STD max) (_Chunk_offset, _Diff{1});
+        for (_Diff _Off = _Initial; _Off < _Last; ++_Off) {
+            if (_DEBUG_LT_PRED(_Pred, *(_Range_first + ((_Off - 1) >> 1)), *(_Range_first + _Off))) {
+                _Results._Imbue(_Key._Chunk_number, _Range_first + _Off);
+                return _Cancellation_status::_Canceled;
+            }
+        }
+
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_is_heap_until2*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _RanIt is_heap_until(_ExPo&&, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find extent of range that is a heap
+    _REQUIRE_PARALLEL_ITERATOR(_RanIt);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const auto _Count = _ULast - _UFirst;
+            if (_Count >= 3) { // ... with at least 3 elements
+                _TRY_BEGIN
+                _Static_partitioned_is_heap_until2 _Operation{
+                    _UFirst, _ULast, _Hw_threads, _Count, _STD _Pass_fn(_Pred)};
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                _STD _Seek_wrapped(_First, _Operation._Results._Get_result());
+                return _First;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _STD is_heap_until(_UFirst, _ULast, _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+template <class _FwdIt, class _Pr>
+pair<_FwdIt, _Iter_diff_t<_FwdIt>> _Partition_with_count_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
+    // move elements satisfying _Pred to front and track how many elements satisfy _Pred
+    if constexpr (_Is_cpp17_random_iter_v<_FwdIt>) {
+        auto _Mid = _STD partition(_First, _Last, _Pred);
+        return {_Mid, _Mid - _First};
+    } else if constexpr (_Is_cpp17_bidi_iter_v<_FwdIt>) {
+        _Iter_diff_t<_FwdIt> _Trues{};
+        for (;;) { // find any out-of-order pair
+            for (;;) { // skip in-place elements at beginning
+                if (_First == _Last) {
+                    return {_First, _Trues};
+                }
+
+                if (!_Pred(*_First)) {
+                    break;
+                }
+
+                ++_First;
+                ++_Trues;
+            }
+
+            do { // skip in-place elements at end
+                --_Last;
+                if (_First == _Last) {
+                    return {_First, _Trues};
+                }
+            } while (!_Pred(*_Last));
+
+            swap(*_First, *_Last); // out of place, swap and loop; intentional ADL
+            ++_First;
+            ++_Trues;
+        }
+    } else {
+        _Iter_diff_t<_FwdIt> _Trues{};
+        for (;;) { // skip in-place elements at beginning
+            if (_First == _Last) {
+                return {_First, _Trues};
+            }
+
+            if (!_Pred(*_First)) {
+                break;
+            }
+
+            ++_First;
+            ++_Trues;
+        }
+
+        for (_FwdIt _Next = _First; ++_Next != _Last;) {
+            if (_Pred(*_Next)) {
+                swap(*_First, *_Next); // out of place, swap and loop; intentional ADL
+                ++_First;
+                ++_Trues;
+            }
+        }
+
+        return {_First, _Trues};
+    }
+}
+
+template <class _FwdIt, class _Pr>
+pair<_FwdIt, _Iter_diff_t<_FwdIt>> _Partition_swap_backward(
+    _FwdIt _First, _FwdIt _Last, _FwdIt _Beginning_of_falses, _Pr _Pred) {
+    // Swap elements in [_First, _Last) satisfying _Pred with elements from _Beginning_of_falses.
+    // Pre: _Beginning_of_falses < _First
+    _Iter_diff_t<_FwdIt> _Trues{};
+    if constexpr (_Is_cpp17_bidi_iter_v<_FwdIt>) {
+        while (_First != _Last) {
+            --_Last;
+            if (_Pred(*_Last)) {
+                swap(*_Beginning_of_falses, *_Last); // intentional ADL
+                ++_Beginning_of_falses;
+                ++_Trues;
+                if (_Beginning_of_falses == _First) {
+                    auto _Remain = _STD _Partition_with_count_unchecked(_First, _Last, _Pred);
+                    return {_Remain.first, static_cast<_Iter_diff_t<_FwdIt>>(_Remain.second + _Trues)};
+                }
+            }
+        }
+    } else {
+        for (; _First != _Last; ++_First) {
+            if (_Pred(*_First)) {
+                swap(*_First, *_Beginning_of_falses); // intentional ADL
+                ++_Beginning_of_falses;
+                ++_Trues;
+            }
+        }
+    }
+
+    return {_Beginning_of_falses, _Trues};
+}
+
+template <class _FwdIt>
+_FwdIt _Partition_merge(const _FwdIt _False_first, const _FwdIt _True_first, const _FwdIt _True_last,
+    const _Iter_diff_t<_FwdIt> _Count1, const _Iter_diff_t<_FwdIt> _Count2) {
+    // Merge partition ranges where [_False_first, _True_first) are falses, [_True_first, _True_last) are trues
+    // pre: _Count1 == distance(_False_first, _True_first) && _Count2 == distance(_True_first, _True_last)
+    if (_Count1 < _Count2) { // move the false range to the end of the true range
+        const _Iter_diff_t<_FwdIt> _Offset = _Count2 - _Count1;
+        auto _Result                       = _True_first;
+        if constexpr (_Is_cpp17_random_iter_v<_FwdIt>) {
+            _Result += _Offset;
+        } else if constexpr (_Is_cpp17_bidi_iter_v<_FwdIt>) {
+            if (_Count1 < _Offset) {
+                _Result = _True_last;
+                _STD advance(_Result, -_Count1);
+            } else {
+                _STD advance(_Result, _Offset);
+            }
+        } else {
+            _STD advance(_Result, _Offset);
+        }
+
+        _Swap_ranges_unchecked(_False_first, _True_first, _Result);
+        return _Result;
+    }
+
+    // move the true range to the beginning of the false range
+    return _Swap_ranges_unchecked(_True_first, _True_last, _False_first);
+}
+
+template <class _FwdIt, class _Pr>
+struct _Static_partitioned_partition2 {
+    using _Diff = _Iter_diff_t<_FwdIt>;
+
+    enum class _Chunk_state : unsigned char {
+        _Serial, // while a chunk is in the serial state, it is touched only by an owner thread
+        _Merging, // while a chunk is in the merging state, threads all try to CAS the chunk _Merging -> _Swapping
+                  // the thread that succeeds takes responsibility for swapping the trues from that chunk to the
+                  // results
+        _Swapping, // while a chunk is in the swapping state, the trues are being merged with _Results
+                   // only one chunk at a time is ever _Swapping; this also serves to synchronize access to
+                   // _Results and _Results_falses
+        _Done // when a chunk becomes _Done, it is complete / will never need to touch _Results again
+    };
+
+    struct alignas(hardware_destructive_interference_size) alignas(_FwdIt) _Chunk_local_data {
+        atomic<_Chunk_state> _State;
+        _FwdIt _Beginning_of_falses;
+        _Diff _Chunk_trues;
+    };
+
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _Pr _Pred;
+    _Parallel_vector<_Chunk_local_data> _Chunk_locals;
+    _FwdIt _Results;
+    _Diff _Results_falses;
+
+    _Static_partitioned_partition2(const size_t _Hw_threads, const _Diff _Count, const _FwdIt _First, const _Pr _Pred_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Pred{_Pred_},
+          _Chunk_locals(_Team._Chunks), _Results{_First}, _Results_falses{} {
+        _Basis._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        // serial-on-each-chunk phase:
+        auto _Merge_index = _Key._Chunk_number; // merge step will start from this index
+        {
+            auto& _Chunk_data = _Chunk_locals[_Merge_index];
+            const auto _Range = _Basis._Get_chunk(_Key);
+            if (_Merge_index == 0 || _Chunk_locals[_Merge_index - 1]._State.load() == _Chunk_state::_Done) {
+                // no predecessor, so run serial algorithm directly into results
+                const auto _Chunk_results =
+                    _Merge_index == 0 || _Results == _Range._First
+                        ? _STD _Partition_with_count_unchecked(_Range._First, _Range._Last, _Pred)
+                        : _STD _Partition_swap_backward(_Range._First, _Range._Last, _Results, _Pred);
+                _Results                 = _Chunk_results.first;
+                _Chunk_data._Chunk_trues = _Chunk_results.second;
+                _Results_falses += _Key._Size - _Chunk_results.second;
+                _Chunk_data._State.store(_Chunk_state::_Done);
+                ++_Merge_index; // this chunk is already merged
+            } else {
+                // predecessor, run serial algorithm in place and attempt to merge later
+                auto _Chunk_results = _STD _Partition_with_count_unchecked(_Range._First, _Range._Last, _Pred);
+                _Chunk_data._Beginning_of_falses = _Chunk_results.first;
+                _Chunk_data._Chunk_trues         = _Chunk_results.second;
+                _Chunk_data._State.store(_Chunk_state::_Merging);
+                if (_Chunk_locals[_Merge_index - 1]._State.load() != _Chunk_state::_Done) {
+                    // if the predecessor isn't done, whichever thread merges our predecessor will merge us too
+                    return _Cancellation_status::_Running;
+                }
+            }
+        }
+
+        // merge phase: at this point, we have observed that our predecessor chunk has been merged to the output,
+        // attempt to become the new merging thread if the previous merger gave up
+        // note: it is an invariant when we get here that _Chunk_locals[_Merge_index - 1]._State == _Chunk_state::_Done
+        for (; _Merge_index != _Team._Chunks; ++_Merge_index) {
+            auto& _Merge_chunk_data = _Chunk_locals[_Merge_index];
+            auto _Expected          = _Chunk_state::_Merging;
+            if (!_Merge_chunk_data._State.compare_exchange_strong(_Expected, _Chunk_state::_Swapping)) {
+                // either the _Merge_index chunk isn't ready to merge yet, or another thread will do it
+                return _Cancellation_status::_Running;
+            }
+
+            const auto _Merge_key   = _Team._Get_chunk_key(_Merge_index);
+            const auto _Chunk_trues = _Merge_chunk_data._Chunk_trues;
+
+            _Results = _Partition_merge(_Results, _Basis._Get_first(_Merge_index, _Merge_key._Start_at),
+                _STD exchange(_Merge_chunk_data._Beginning_of_falses, {}), _Results_falses, _Chunk_trues);
+            _Results_falses += _Merge_key._Size - _Chunk_trues;
+            _Merge_chunk_data._State.store(_Chunk_state::_Done);
+        }
+
+        return _Cancellation_status::_Canceled;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_partition2*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt partition(_ExPo&&, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // move elements satisfying _Pred to beginning of sequence
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) {
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            if (_Count >= 2) {
+                _TRY_BEGIN
+                _Static_partitioned_partition2 _Operation{_Hw_threads, _Count, _UFirst, _STD _Pass_fn(_Pred)};
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                _STD _Seek_wrapped(_First, _Operation._Results);
+                return _First;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _STD partition(_UFirst, _ULast, _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+inline constexpr unsigned char _Local_available = 1;
+inline constexpr unsigned char _Sum_available   = 2;
+
+// For scan algorithms: if the intermediate and output types are the same, we can directly store the binary operation
+// result in the output. If not, then we need a place to store intermediate results.
+template <class _Ty, class _Iter>
+constexpr bool _Scan_reuse_output = is_same_v<_Ty, typename iterator_traits<_Iter>::value_type>;
+
+template <class _Ty, class _Iter, bool = _Scan_reuse_output<_Ty, _Iter>>
+class _Scan_intermediate_storage {
+private:
+    _Parallel_vector<_Ty> _Data;
+
+public:
+    template <class _Diff>
+    explicit _Scan_intermediate_storage(const _Static_partition_team<_Diff>&) noexcept {}
+
+    _NODISCARD _Parallel_vector<_Ty>& operator[](size_t) noexcept {
+        return _Data;
+    }
+};
+
+template <class _Ty, class _Iter>
+class _Scan_intermediate_storage<_Ty, _Iter, false> {
+private:
+    _Parallel_vector<_Parallel_vector<_Ty>> _Data;
+
+public:
+    template <class _Diff>
+    explicit _Scan_intermediate_storage(const _Static_partition_team<_Diff>& _Team) : _Data(_Team._Chunks) {
+        const auto _Chunk_size = static_cast<size_t>(_Team._Chunk_size);
+        for (auto& _Vec : _Data) {
+            _Vec.reserve(_Chunk_size);
+        }
+    }
+
+    _NODISCARD _Parallel_vector<_Ty>& operator[](const size_t _Idx) noexcept {
+        _STL_INTERNAL_CHECK(_Idx < _Data.size());
+        return _Data[_Idx];
+    }
+};
+
+template <class _Ty>
+struct _Scan_decoupled_lookback {
+    // inter-chunk communication block in "Single-pass Parallel Prefix Scan with Decoupled Look-back" by Merrill and
+    // Garland
+    using value_type = _Ty;
+    atomic<unsigned char> _State;
+    _Storage_for<_Ty> _Local; // owned by thread iff _State < _Local_available; otherwise const and shared
+    _Storage_for<_Ty> _Sum; // owned by thread iff _State < _Sum_available
+
+    unsigned char _Get_available_state() const {
+        for (;;) {
+            const unsigned char _Local_state = _State.load();
+            if (_Local_state != 0) {
+                return _Local_state;
+            }
+
+            __std_execution_wait_on_uchar(reinterpret_cast<const unsigned char*>(&_State), _Local_state);
+        }
+    }
+
+    void _Store_available_state(const unsigned char _New_state) {
+        _State.store(_New_state);
+        __std_execution_wake_by_address_all(&_State);
+    }
+
+    template <class _FwdIt, class _BinOp>
+    void _Apply_exclusive_predecessor(
+        _Ty& _Preceding, _FwdIt _First, _Ty* _First2, const _FwdIt _Last, _BinOp _Reduce_op) {
+        // apply _Preceding to [_First, _Last) and _Sum._Ref(), using _Reduce_op
+        _STD _Implicitly_construct_in_place_by_binary_op(_Sum._Ref(), _Reduce_op, _Preceding, _Local._Ref());
+        _State.store(_Local_available | _Sum_available);
+        *_First = _Preceding;
+
+#pragma loop(ivdep)
+        while (++_First != _Last) {
+            if constexpr (_Scan_reuse_output<_Ty, _FwdIt>) {
+                *_First = _Reduce_op(_Preceding, _STD move(*_First));
+            } else {
+                ++_First2;
+                *_First = _Reduce_op(_Preceding, _STD move(*_First2));
+            }
+        }
+    }
+
+    template <class _FwdIt, class _BinOp>
+    void _Apply_inclusive_predecessor(
+        _Ty& _Preceding, _FwdIt _First, _Ty* _First2, const _FwdIt _Last, _BinOp _Reduce_op) {
+        // apply _Preceding to [_First, _Last) and _Sum._Ref(), using _Reduce_op
+        _STD _Implicitly_construct_in_place_by_binary_op(_Sum._Ref(), _Reduce_op, _Preceding, _Local._Ref());
+        _State.store(_Local_available | _Sum_available);
+
+#pragma loop(ivdep)
+        for (; _First != _Last; ++_First) {
+            if constexpr (_Scan_reuse_output<_Ty, _FwdIt>) {
+                *_First = _Reduce_op(_Preceding, _STD move(*_First));
+            } else {
+                *_First = _Reduce_op(_Preceding, _STD move(*_First2));
+                ++_First2;
+            }
+        }
+    }
+
+    ~_Scan_decoupled_lookback() {
+        const auto _State_bits = _State.load(memory_order_relaxed);
+        if (_State_bits & _Sum_available) {
+            _STD _Destroy_in_place(_Sum._Ref());
+        }
+
+        if (_State_bits & _Local_available) {
+            _STD _Destroy_in_place(_Local._Ref());
+        }
+    }
+};
+
+template <class _BidIt, class _BinOp>
+typename _Iter_value_t<_BidIt>::value_type _Get_lookback_sum(const _BidIt _Current, _BinOp _Reduce_op) {
+    // Calculate the sum of the _Scan_decoupled_lookback referenced by _Current.
+    // pre: _Current->_State & _Local_available
+    // pre: Some iterator i exists before _Current such that i->_Get_available_state & _Sum_available
+    static_assert(_Is_specialization_v<_Iter_value_t<_BidIt>, _Scan_decoupled_lookback>, "Bad _Get_lookback_sum");
+    auto _Prev = _Current;
+    --_Prev;
+    auto _Prev_state = _Prev->_Get_available_state();
+    typename _Iter_value_t<_BidIt>::value_type _Result =
+        _Reduce_op(_Prev_state & _Sum_available ? _Prev->_Sum._Ref() : _Prev->_Local._Ref(), _Current->_Local._Ref());
+    while (!(_Prev_state & _Sum_available)) {
+        --_Prev;
+        _Prev_state = _Prev->_Get_available_state();
+        _Result =
+            _Reduce_op(_Prev_state & _Sum_available ? _Prev->_Sum._Ref() : _Prev->_Local._Ref(), _STD move(_Result));
+    }
+
+    return _Result;
+}
+
+template <class _Ty>
+struct _Casty_plus {
+    // Adds the two arguments together and casts the result back to _Ty.
+    // pre: the result from adding the two arguments together can fit in _Ty
+    _NODISCARD static constexpr _Ty operator()(_Ty _Val1, _Ty _Val2) noexcept
+    /* terminates */ {
+        return static_cast<_Ty>(_Val1 + _Val2);
+    }
+};
+
+template <class _Diff>
+void _Surrender_elements_to_next_chunk(const size_t _Chunk_number,
+    const typename _Parallel_vector<_Scan_decoupled_lookback<_Diff>>::iterator _Chunk_lookback_data) {
+    // Deals with the case in which all of the elements in the chunk corresponding to _Chunk_lookback_data will be
+    // handled by the following chunk, so this chunk needs to publish its results accordingly.
+    if (_Chunk_number == 0) {
+        // This is the first chunk, so we can immediately publish results. No need to set
+        // _Chunk_lookback_data->_Local._Ref() to be 0, since chunk 0 has no predecessors and its local and total sums
+        // are the same. Chunk_lookback_data->_Sum is already 0, so we can just publish results immediately.
+        _Chunk_lookback_data->_Store_available_state(_Sum_available);
+        return;
+    }
+
+    // We need to pass the previous chunk's sum to the right.
+    // _Chunk_lookback_data->_Local is already 0, so we can just publish results immediately.
+    _Chunk_lookback_data->_Store_available_state(_Local_available);
+
+    const auto _Prev_chunk_lookback_data = _Prev_iter(_Chunk_lookback_data);
+    _Diff _Prev_chunk_sum;
+    if (_Prev_chunk_lookback_data->_Get_available_state() & _Sum_available) {
+        _Prev_chunk_sum = _Prev_chunk_lookback_data->_Sum._Ref();
+    } else {
+        // Note that we can use _Casty_plus because _Diff is defined as _Common_diff<..., _RanIt3> and the maximum value
+        // that will be placed in _Lookback by adding two of the previous sums together is the total number of elements
+        // in the result. Assuming that _Dest has enough space for the result, the value produced by adding two previous
+        // sums should fit inside _Diff.
+        _Prev_chunk_sum = _STD _Get_lookback_sum(_Prev_chunk_lookback_data, _Casty_plus<_Diff>{});
+    }
+
+    _Chunk_lookback_data->_Sum._Ref() = _Prev_chunk_sum;
+    _Chunk_lookback_data->_Store_available_state(_Sum_available);
+}
+
+template <class _RanIt1, class _RanIt2, class _RanIt3>
+void _Place_elements_from_indices(
+    const _RanIt1 _First, _RanIt2 _Dest, _RanIt3 _Indices_first, const ptrdiff_t _Num_results) {
+    // Places _Num_results elements at indices in _Indices_first from the range indicated by _First into _Dest.
+    const auto _Last_index = _Indices_first + _Num_results;
+    for (; _Indices_first != _Last_index; ++_Indices_first) {
+        const auto _Curr_index = *_Indices_first;
+        *_Dest                 = *(_First + static_cast<_Iter_diff_t<_RanIt1>>(_Curr_index));
+        ++_Dest;
+    }
+}
+
+template <class _RanIt1, class _RanIt2, class _RanIt3, class _Pr, class _SetOper>
+struct _Static_partitioned_set_subtraction {
+    using _Diff = _Common_diff_t<_RanIt1, _RanIt2, _RanIt3>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_RanIt1, _Diff> _Basis;
+    _Parallel_vector<_Diff> _Index_indicator; // buffer used to store information about indices in Range 1
+    _Iterator_range<_RanIt2> _Range2;
+    _RanIt3 _Dest;
+    _Parallel_vector<_Scan_decoupled_lookback<_Diff>> _Lookback; // the "Single-pass Parallel Prefix Scan with
+                                                                 // Decoupled Look-back" is used here to track
+                                                                 // information about how many elements were placed
+                                                                 // in _Dest by preceding chunks
+    _Pr _Pred;
+    _SetOper _Set_oper_per_chunk;
+
+    _Static_partitioned_set_subtraction(const size_t _Hw_threads, const _Diff _Count, _RanIt1 _First1, _RanIt2 _First2,
+        const _RanIt2 _Last2, _RanIt3 _Dest_, _Pr _Pred_, _SetOper _Set_oper)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{},
+          _Index_indicator(static_cast<size_t>(_Count)), _Range2{_First2, _Last2}, _Dest(_Dest_),
+          _Lookback(_Team._Chunks), _Pred(_Pred_), _Set_oper_per_chunk(_Set_oper) {
+        _Basis._Populate(_Team, _First1);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Chunk_number        = _Key._Chunk_number;
+        const auto _Chunk_lookback_data = _Lookback.begin() + static_cast<ptrdiff_t>(_Chunk_number);
+
+        // iterators for the actual beginning of this chunk's range in _Range1 (after adjustments below)
+        auto [_Range1_chunk_first, _Range1_chunk_last] = _Basis._Get_chunk(_Key);
+        const bool _Last_chunk                         = _Chunk_number == _Team._Chunks - 1;
+
+        // Get appropriate range for _Range1.
+        // We don't want any spans of equal elements to reach across chunk boundaries.
+        if (!_Last_chunk) {
+            // Slide _Range1_chunk_last to the left so that there are no copies of *_Range1_chunk_last in _Range1_chunk.
+            // Note that we know that this chunk is not the last, so we can look at the element at _Range1_chunk_last.
+            _Range1_chunk_last = _STD lower_bound(_Range1_chunk_first, _Range1_chunk_last, *_Range1_chunk_last, _Pred);
+
+            if (_Range1_chunk_last <= _Range1_chunk_first) {
+                // All of the elements in _Range1's chunk are equal to the element at _Range1_chunk_last, so they will
+                // be handled by the next chunk.
+                _Surrender_elements_to_next_chunk<_Diff>(_Chunk_number, _Chunk_lookback_data);
+                return _Cancellation_status::_Running;
+            }
+        }
+
+        // Slide _Range1_chunk_first to the left so that all copies of *_Range1_chunk_first are in this chunk
+        // of Range 1.
+        _Range1_chunk_first = _STD lower_bound(_Basis._Start_at, _Range1_chunk_first, *_Range1_chunk_first, _Pred);
+
+        // Get chunk in _Range2 that corresponds to our current chunk from _Range1
+        auto _Range2_chunk_first = _STD lower_bound(_Range2._First, _Range2._Last, *_Range1_chunk_first, _Pred);
+        auto _Range2_chunk_last =
+            _STD upper_bound(_Range2_chunk_first, _Range2._Last, *_STD _Prev_iter(_Range1_chunk_last), _Pred);
+
+        // Publish results to rest of chunks.
+        if (_Chunk_number == 0) {
+            // Chunk 0 is special as it has no predecessor;
+            // its local and total sums are the same and we can immediately put its results in _Dest.
+            const auto _Num_results = _Set_oper_per_chunk._Update_dest(
+                _Range1_chunk_first, _Range1_chunk_last, _Range2_chunk_first, _Range2_chunk_last, _Dest, _Pred);
+
+            _Chunk_lookback_data->_Sum._Ref() = _Num_results;
+            _Chunk_lookback_data->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        const auto _Prev_chunk_lookback_data = _Prev_iter(_Chunk_lookback_data);
+        if (_Prev_chunk_lookback_data->_State.load() & _Sum_available) {
+            // If the predecessor sum is already complete, we can incorporate its value directly for 1 pass.
+            const auto _Prev_chunk_sum = _Prev_chunk_lookback_data->_Sum._Ref();
+            auto _Chunk_specific_dest  = _Dest + static_cast<_Iter_diff_t<_RanIt3>>(_Prev_chunk_sum);
+            const auto _Num_results    = _Set_oper_per_chunk._Update_dest(_Range1_chunk_first, _Range1_chunk_last,
+                _Range2_chunk_first, _Range2_chunk_last, _Chunk_specific_dest, _Pred);
+
+            _Chunk_lookback_data->_Sum._Ref() = static_cast<_Diff>(_Num_results + _Prev_chunk_sum);
+            _Chunk_lookback_data->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        // Get range we can use for this chunk of range 1 in the buffer.
+        auto _Index_chunk_first =
+            _Index_indicator.begin() + static_cast<ptrdiff_t>(_Range1_chunk_first - _Basis._Start_at);
+
+        // Determine the indices of elements that should be in the result from this chunk.
+        const auto _Num_results             = _Set_oper_per_chunk._Mark_indices(_Range1_chunk_first, _Range1_chunk_last,
+            _Range2_chunk_first, _Range2_chunk_last, _Index_chunk_first, _Pred);
+        _Chunk_lookback_data->_Local._Ref() = _Num_results;
+        _Chunk_lookback_data->_Store_available_state(_Local_available);
+
+        // Apply the predecessor overall sum to current overall sum and elements.
+        _Diff _Prev_chunk_sum;
+        if (_Prev_chunk_lookback_data->_Get_available_state() & _Sum_available) {
+            // Predecessor overall sum is done, use directly.
+            _Prev_chunk_sum = _Prev_chunk_lookback_data->_Sum._Ref();
+        } else {
+            _Prev_chunk_sum = _STD _Get_lookback_sum(_Prev_chunk_lookback_data, _Casty_plus<_Diff>{});
+        }
+
+        _Chunk_lookback_data->_Sum._Ref() = static_cast<_Diff>(_Num_results + _Prev_chunk_sum);
+        _Chunk_lookback_data->_Store_available_state(_Sum_available);
+
+        // Place elements from _Range1 in _Dest according to the offsets previously calculated.
+        auto _Chunk_specific_dest = _Dest + static_cast<_Iter_diff_t<_RanIt3>>(_Prev_chunk_sum);
+        _STD _Place_elements_from_indices(
+            _Range1_chunk_first, _Chunk_specific_dest, _Index_chunk_first, static_cast<ptrdiff_t>(_Num_results));
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_set_subtraction*>(_Context));
+    }
+};
+
+struct _Set_intersection_per_chunk {
+    template <class _RanIt1, class _RanIt2, class _RanIt3, class _Pr>
+    _Common_diff_t<_RanIt1, _RanIt2, _RanIt3> _Update_dest(
+        _RanIt1 _First1, const _RanIt1 _Last1, _RanIt2 _First2, const _RanIt2 _Last2, _RanIt3 _Dest, _Pr _Pred) {
+        // Copy elements from [_First, _Last1) that are also present in [_First2, _Last2) according to _Pred, to
+        // _Dest. Returns the number of elements stored.
+        return _STD set_intersection(_First1, _Last1, _First2, _Last2, _Dest, _Pred) - _Dest;
+    }
+
+    template <class _RanIt1, class _RanIt2, class _BidIt, class _Pr>
+    _Iter_value_t<_BidIt> _Mark_indices(_RanIt1 _First1, const _RanIt1 _Last1, _RanIt2 _First2, const _RanIt2 _Last2,
+        _BidIt _Index_chunk_first, _Pr _Pred) {
+        // Stores offsets of elements in [_First1, _Last1) that are also present in [_First2, _Last2) according to
+        // _Pred, to _Index_chunk_first. Returns the number of offsets stored.
+        static_assert(is_integral_v<_Iter_value_t<_BidIt>>);
+        static_assert(
+            is_same_v<_Iter_value_t<_BidIt>, common_type_t<_Iter_value_t<_BidIt>, _Common_diff_t<_RanIt1, _RanIt2>>>);
+        _DEBUG_ORDER_SET_UNWRAPPED(_RanIt2, _First1, _Last1, _Pred);
+        _DEBUG_ORDER_SET_UNWRAPPED(_RanIt1, _First2, _Last2, _Pred);
+        const auto _Index_chunk_first_save       = _Index_chunk_first;
+        _Iter_diff_t<_RanIt1> _Curr_range1_index = 0;
+        _Iter_diff_t<_RanIt2> _Curr_range2_index = 0;
+        const auto _Range1_dist                  = _Last1 - _First1;
+        const auto _Range2_dist                  = _Last2 - _First2;
+        while (_Curr_range1_index < _Range1_dist && _Curr_range1_index < _Range2_dist) {
+            if (_DEBUG_LT_PRED(_Pred, *(_First1 + _Curr_range1_index), *(_First2 + _Curr_range2_index))) {
+                ++_Curr_range1_index;
+            } else {
+                if (!_Pred(*(_First2 + _Curr_range2_index), *(_First1 + _Curr_range1_index))) {
+                    *_Index_chunk_first = static_cast<_Iter_value_t<_BidIt>>(_Curr_range1_index);
+                    ++_Index_chunk_first;
+                    ++_Curr_range1_index;
+                }
+
+                ++_Curr_range2_index;
+            }
+        }
+
+        return static_cast<_Iter_value_t<_BidIt>>(_Index_chunk_first - _Index_chunk_first_save);
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt3 set_intersection(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
+    _Pr _Pred) noexcept /* terminates */ {
+    // AND sets [_First1, _Last1) and [_First2, _Last2)
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    auto _UDest        = _STD _Get_unwrapped_unverified(_Dest);
+    using _Diff        = _Common_diff_t<_FwdIt1, _FwdIt2, _FwdIt3>;
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize && _Is_ranges_random_iter_v<_FwdIt1>
+                  && _Is_ranges_random_iter_v<_FwdIt2> && _Is_cpp17_random_iter_v<_FwdIt3>) {
+        // only parallelize if desired, and all of the iterators given are random access
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const _Diff _Count1 = _ULast1 - _UFirst1;
+            const _Diff _Count2 = _ULast2 - _UFirst2;
+            if (_Count1 >= 2 && _Count2 >= 2) { // ... with each range containing at least 2 elements
+                _TRY_BEGIN
+                _Static_partitioned_set_subtraction _Operation(_Hw_threads, _Count1, _UFirst1, _UFirst2, _ULast2,
+                    _UDest, _STD _Pass_fn(_Pred), _Set_intersection_per_chunk());
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                _UDest += static_cast<_Iter_diff_t<_FwdIt3>>(_Operation._Lookback.back()._Sum._Ref());
+                _STD _Seek_wrapped(_Dest, _UDest);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(
+        _Dest, _STD set_intersection(_UFirst1, _ULast1, _UFirst2, _ULast2, _UDest, _STD _Pass_fn(_Pred)));
+    return _Dest;
+}
+
+struct _Set_difference_per_chunk {
+    template <class _RanIt1, class _RanIt2, class _RanIt3, class _Pr>
+    _Common_diff_t<_RanIt1, _RanIt2, _RanIt3> _Update_dest(
+        _RanIt1 _First1, const _RanIt1 _Last1, _RanIt2 _First2, _RanIt2 _Last2, _RanIt3 _Dest, _Pr _Pred) {
+        // Copy elements from [_First1, _Last1), except those in [_First2, _Last2) according to _Pred, to _Dest.
+        // Returns the number of elements stored.
+        return _STD set_difference(_First1, _Last1, _First2, _Last2, _Dest, _Pred) - _Dest;
+    }
+
+    template <class _RanIt1, class _RanIt2, class _BidIt, class _Pr>
+    _Iter_value_t<_BidIt> _Mark_indices(_RanIt1 _First1, const _RanIt1 _Last1, _RanIt2 _First2, const _RanIt2 _Last2,
+        _BidIt _Index_chunk_first, _Pr _Pred) {
+        // Stores offsets of elements in [_First1, _Last1), except those in [_First2, _Last2) according to _Pred, to
+        // _Index_chunk_first. Returns the number of offsets stored.
+        static_assert(is_integral_v<_Iter_value_t<_BidIt>>);
+        static_assert(
+            is_same_v<_Iter_value_t<_BidIt>, common_type_t<_Iter_value_t<_BidIt>, _Common_diff_t<_RanIt1, _RanIt2>>>);
+        _DEBUG_ORDER_SET_UNWRAPPED(_RanIt2, _First1, _Last1, _Pred);
+        _DEBUG_ORDER_SET_UNWRAPPED(_RanIt1, _First2, _Last2, _Pred);
+        const auto _Index_chunk_first_save       = _Index_chunk_first;
+        _Iter_diff_t<_RanIt1> _Curr_range1_index = 0;
+        _Iter_diff_t<_RanIt2> _Curr_range2_index = 0;
+        const auto _Range1_dist                  = _Last1 - _First1;
+        const auto _Range2_dist                  = _Last2 - _First2;
+        while (_Curr_range1_index < _Range1_dist && _Curr_range2_index < _Range2_dist) {
+            if (_DEBUG_LT_PRED(_Pred, *(_First1 + _Curr_range1_index), *(_First2 + _Curr_range2_index))) {
+                *_Index_chunk_first = static_cast<_Iter_value_t<_BidIt>>(_Curr_range1_index);
+                ++_Index_chunk_first;
+                ++_Curr_range1_index;
+            } else {
+                if (!_Pred(*(_First2 + _Curr_range2_index), *(_First1 + _Curr_range1_index))) {
+                    ++_Curr_range1_index;
+                }
+
+                ++_Curr_range2_index;
+            }
+        }
+
+        // If we haven't traversed all of range 1 yet, we want to include the rest of it in the results.
+        for (; _Curr_range1_index < _Range1_dist; ++_Curr_range1_index) {
+            *_Index_chunk_first = static_cast<_Iter_value_t<_BidIt>>(_Curr_range1_index);
+            ++_Index_chunk_first;
+        }
+
+        return static_cast<_Iter_value_t<_BidIt>>(_Index_chunk_first - _Index_chunk_first_save);
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt3 set_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
+    _Pr _Pred) noexcept /* terminates */ {
+    // take set [_First2, _Last2) from [_First1, _Last1)
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt3);
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    auto _UDest        = _STD _Get_unwrapped_unverified(_Dest);
+    using _Diff        = _Common_diff_t<_FwdIt1, _FwdIt2, _FwdIt3>;
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize && _Is_ranges_random_iter_v<_FwdIt1>
+                  && _Is_ranges_random_iter_v<_FwdIt2> && _Is_cpp17_random_iter_v<_FwdIt3>) {
+        // only parallelize if desired, and all of the iterators given are random access
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const _Diff _Count = _ULast1 - _UFirst1;
+            if (_Count >= 2) { // ... with at least 2 elements in [_First1, _Last1)
+                _TRY_BEGIN
+                _Static_partitioned_set_subtraction _Operation(_Hw_threads, _Count, _UFirst1, _UFirst2, _ULast2, _UDest,
+                    _STD _Pass_fn(_Pred), _Set_difference_per_chunk());
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                _UDest += static_cast<_Iter_diff_t<_FwdIt3>>(_Operation._Lookback.back()._Sum._Ref());
+                _STD _Seek_wrapped(_Dest, _UDest);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _STD set_difference(_UFirst1, _ULast1, _UFirst2, _ULast2, _UDest, _STD _Pass_fn(_Pred)));
+    return _Dest;
+}
+
+template <class _InIt, class _Ty, class _BinOp>
+_Ty _Reduce_move_unchecked(_InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op) {
+    // return reduction, choose optimization
+#if _STD_VECTORIZE_WITH_FLOAT_CONTROL
+    if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_Unwrapped_t<const _InIt&>, _Ty, _BinOp>) {
+        return _STD _Reduce_plus_arithmetic_ranges(_First, _Last, _Val);
+    } else
+#endif // ^^^ _STD_VECTORIZE_WITH_FLOAT_CONTROL ^^^
+    {
+        for (; _First != _Last; ++_First) {
+            _Val = _Reduce_op(_STD move(_Val), _STD move(*_First)); // Requirement missing from N4950
+        }
+
+        return _Val;
+    }
+}
+
+template <class _Ty, class _FwdIt, class _BinOp>
+_Ty _Reduce_at_least_two(const _FwdIt _First, const _FwdIt _Last, _BinOp _Reduce_op) {
+    // return reduction with no initial value
+    // pre: distance(_First, _Last) >= 2
+#if _STD_VECTORIZE_WITH_FLOAT_CONTROL
+    if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_FwdIt, _Ty, _BinOp>) {
+        return _STD _Reduce_plus_arithmetic_ranges(_First, _Last, _Ty{0});
+    } else
+#endif // ^^^ _STD_VECTORIZE_WITH_FLOAT_CONTROL ^^^
+    {
+        auto _Next = _First;
+        _Ty _Val   = _Reduce_op(*_First, *++_Next);
+        while (++_Next != _Last) {
+            _Val = _Reduce_op(_STD move(_Val), *_Next); // Requirement missing from N4950
+        }
+
+        return _Val;
+    }
+}
+
+template <class _FwdIt, class _Ty, class _BinOp>
+struct _Static_partitioned_reduce2 {
+    // reduction task scheduled on the system thread pool
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _BinOp _Reduce_op;
+    _Generalized_sum_drop<_Ty> _Results;
+
+    _Static_partitioned_reduce2(
+        const _Iter_diff_t<_FwdIt> _Count, const size_t _Chunks, const _FwdIt _First, _BinOp _Reduce_op_)
+        : _Team{_Count, _Chunks}, _Basis{}, _Reduce_op(_Reduce_op_), _Results{_Team._Chunks} {
+        _Basis._Populate(_Team, _First);
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        const auto _This = static_cast<_Static_partitioned_reduce2*>(_Context);
+        auto _Key        = _This->_Team._Get_next_key();
+        if (_Key) {
+            auto _Chunk        = _This->_Basis._Get_chunk(_Key);
+            auto _Local_result = _STD _Reduce_at_least_two<_Ty>(_Chunk._First, _Chunk._Last, _This->_Reduce_op);
+            while ((_Key = _This->_Team._Get_next_key())) {
+                _Chunk        = _This->_Basis._Get_chunk(_Key);
+                _Local_result = _STD reduce(_Chunk._First, _Chunk._Last, _STD move(_Local_result), _This->_Reduce_op);
+            }
+
+            _This->_Results._Add_result(_STD move(_Local_result));
+        }
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _Ty reduce(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op) noexcept
+/* terminates */ {
+    // return commutative and associative reduction of _Val and [_First, _Last), using _Reduce_op
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines...
+            const auto _Count  = _STD distance(_UFirst, _ULast);
+            const auto _Chunks = _Get_least2_chunked_work_chunk_count(_Hw_threads, _Count);
+            if (_Chunks > 1) {
+                _TRY_BEGIN
+                auto _Passed_fn = _STD _Pass_fn(_Reduce_op);
+                _Static_partitioned_reduce2<decltype(_UFirst), _Ty, decltype(_Passed_fn)> _Operation{
+                    _Count, _Chunks, _UFirst, _Passed_fn};
+                {
+                    // we don't use _Run_chunked_parallel_work here because the initial value on background threads
+                    // is synthesized from the input, but on this thread the initial value is _Val
+                    const _Work_ptr _Work{_Operation};
+                    // setup complete, hereafter nothrow or terminate
+                    _Work._Submit_for_chunks(_Hw_threads, _Chunks);
+                    while (const auto _Stolen_key = _Operation._Team._Get_next_key()) {
+                        auto _Chunk = _Operation._Basis._Get_chunk(_Stolen_key);
+                        _Val = _STD reduce(_Chunk._First, _Chunk._Last, _STD move(_Val), _STD _Pass_fn(_Reduce_op));
+                    }
+                } // join with _Work_ptr threads
+
+                auto& _Results = _Operation._Results;
+                return _STD _Reduce_move_unchecked(
+                    _Results.begin(), _Results.end(), _STD move(_Val), _STD _Pass_fn(_Reduce_op));
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    return _STD reduce(_UFirst, _ULast, _STD move(_Val), _STD _Pass_fn(_Reduce_op));
+}
+
+template <class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2>
+struct _Static_partitioned_transform_reduce_binary2 { // transform-reduction task scheduled on the system thread pool
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
+    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
+    _BinOp1 _Reduce_op;
+    _BinOp2 _Transform_op;
+    _Generalized_sum_drop<_Ty> _Results;
+
+    _Static_partitioned_transform_reduce_binary2(const _Diff _Count, const size_t _Chunks, const _FwdIt1 _First1,
+        const _FwdIt2 _First2, _BinOp1 _Reduce_op_, _BinOp2 _Transform_op_)
+        : _Team{_Count, _Chunks}, _Basis1{}, _Basis2{}, _Reduce_op(_Reduce_op_), _Transform_op(_Transform_op_),
+          _Results{_Chunks} {
+        _Basis1._Populate(_Team, _First1);
+        _Basis2._Populate(_Team, _First2);
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        const auto _This = static_cast<_Static_partitioned_transform_reduce_binary2*>(_Context);
+        auto _Key        = _This->_Team._Get_next_key();
+        if (_Key) {
+            auto _Reduce_op    = _This->_Reduce_op;
+            auto _Transform_op = _This->_Transform_op;
+            auto _Chunk1       = _This->_Basis1._Get_chunk(_Key);
+            auto _First2 =
+                _This->_Basis2._Get_first(_Key._Chunk_number, _This->_Team._Get_chunk_offset(_Key._Chunk_number));
+            auto _Next1 = _Chunk1._First;
+            auto _Next2 = _First2;
+            // Requirement missing from N4950:
+            _Ty _Val = _Reduce_op(_Transform_op(*_Chunk1._First, *_First2), _Transform_op(*++_Next1, *++_Next2));
+            while (++_Next1 != _Chunk1._Last) {
+                // Requirement missing from N4950:
+                _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_Next1, *++_Next2));
+            }
+
+            while ((_Key = _This->_Team._Get_next_key())) {
+                _Chunk1 = _This->_Basis1._Get_chunk(_Key);
+                _First2 =
+                    _This->_Basis2._Get_first(_Key._Chunk_number, _This->_Team._Get_chunk_offset(_Key._Chunk_number));
+                _Next1 = _Chunk1._First;
+                _Next2 = _First2;
+                for (; _Next1 != _Chunk1._Last; ++_Next1, (void) ++_Next2) {
+                    // Requirement missing from N4950:
+                    _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_Next1, *_Next2));
+                }
+            }
+
+            _This->_Results._Add_result(_STD move(_Val));
+        }
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _Ty transform_reduce(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op,
+    _BinOp2 _Transform_op) noexcept /* terminates */ {
+    // return commutative and associative transform-reduction of sequences, using _Reduce_op and _Transform_op
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First1, _Last1);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines...
+            const auto _Count  = _STD distance(_UFirst1, _ULast1);
+            auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _Count);
+            const auto _Chunks = _Get_least2_chunked_work_chunk_count(_Hw_threads, _Count);
+            if (_Chunks > 1) {
+                _TRY_BEGIN
+                auto _Passed_reduce    = _STD _Pass_fn(_Reduce_op);
+                auto _Passed_transform = _STD _Pass_fn(_Transform_op);
+                _Static_partitioned_transform_reduce_binary2<decltype(_UFirst1), decltype(_UFirst2), _Ty,
+                    decltype(_Passed_reduce), decltype(_Passed_transform)>
+                    _Operation{_Count, _Chunks, _UFirst1, _UFirst2, _Passed_reduce, _Passed_transform};
+                { // ditto no _Run_chunked_parallel_work for the same reason as reduce
+                    const _Work_ptr _Work{_Operation};
+                    // setup complete, hereafter nothrow or terminate
+                    _Work._Submit_for_chunks(_Hw_threads, _Chunks);
+                    while (const auto _Stolen_key = _Operation._Team._Get_next_key()) {
+                        const auto _Chunk_number = _Stolen_key._Chunk_number;
+                        const auto _Chunk1       = _Operation._Basis1._Get_chunk(_Stolen_key);
+
+                        _Val = _STD transform_reduce(_Chunk1._First, _Chunk1._Last,
+                            _Operation._Basis2._Get_first(
+                                _Chunk_number, _Operation._Team._Get_chunk_offset(_Chunk_number)),
+                            _STD move(_Val), _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op));
+                    }
+                } // join with _Work_ptr threads
+
+                auto& _Results = _Operation._Results; // note: already transformed
+                return _STD _Reduce_move_unchecked(
+                    _Results.begin(), _Results.end(), _STD move(_Val), _STD _Pass_fn(_Reduce_op));
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            return _STD transform_reduce(
+                _UFirst1, _ULast1, _UFirst2, _STD move(_Val), _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op));
+        }
+    }
+
+    return _STD transform_reduce(_UFirst1, _ULast1,
+        _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_FwdIt1>(_UFirst1, _ULast1)), _STD move(_Val),
+        _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op));
+}
+
+template <class _FwdIt, class _Ty, class _BinOp, class _UnaryOp>
+struct _Static_partitioned_transform_reduce2 { // transformed reduction task scheduled on the system thread pool
+    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
+    _Static_partition_range<_FwdIt> _Basis;
+    _BinOp _Reduce_op;
+    _UnaryOp _Transform_op;
+    _Generalized_sum_drop<_Ty> _Results;
+
+    _Static_partitioned_transform_reduce2(const _Iter_diff_t<_FwdIt> _Count, const size_t _Chunks, _FwdIt _First,
+        _BinOp _Reduce_op_, _UnaryOp _Transform_op_)
+        : _Team{_Count, _Chunks}, _Basis{}, _Reduce_op(_Reduce_op_), _Transform_op(_Transform_op_), _Results{_Chunks} {
+        _Basis._Populate(_Team, _First);
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        const auto _This = static_cast<_Static_partitioned_transform_reduce2*>(_Context);
+        auto _Key        = _This->_Team._Get_next_key();
+        if (_Key) {
+            auto& _Reduce_op    = _This->_Reduce_op;
+            auto& _Transform_op = _This->_Transform_op;
+            auto _Chunk         = _This->_Basis._Get_chunk(_Key);
+            auto _Next          = _Chunk._First;
+
+            _Ty _Val = _Reduce_op(_Transform_op(*_Chunk._First), _Transform_op(*++_Next));
+            while (++_Next != _Chunk._Last) {
+                _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_Next));
+            }
+
+            while ((_Key = _This->_Team._Get_next_key())) {
+                _Chunk = _This->_Basis._Get_chunk(_Key);
+                _Next  = _Chunk._First;
+                for (; _Next != _Chunk._Last; ++_Next) {
+                    _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_Next));
+                }
+            }
+
+            _This->_Results._Add_result(_STD move(_Val));
+        }
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NODISCARD _Ty transform_reduce(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op) noexcept /* terminates */ {
+    // return commutative and associative reduction of transformed sequence, using _Reduce_op and _Transform_op
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines...
+            const auto _Count  = _STD distance(_UFirst, _ULast);
+            const auto _Chunks = _Get_least2_chunked_work_chunk_count(_Hw_threads, _Count);
+            if (_Chunks > 1) {
+                _TRY_BEGIN
+                auto _Passed_reduce    = _STD _Pass_fn(_Reduce_op);
+                auto _Passed_transform = _STD _Pass_fn(_Transform_op);
+                _Static_partitioned_transform_reduce2<decltype(_UFirst), _Ty, decltype(_Passed_reduce),
+                    decltype(_Passed_transform)>
+                    _Operation{_Count, _Chunks, _UFirst, _Passed_reduce, _Passed_transform};
+                { // ditto no _Run_chunked_parallel_work for the same reason as reduce
+                    const _Work_ptr _Work{_Operation};
+                    // setup complete, hereafter nothrow or terminate
+                    _Work._Submit_for_chunks(_Hw_threads, _Chunks);
+                    while (auto _Stolen_key = _Operation._Team._Get_next_key()) {
+                        // keep processing remaining chunks to comply with N4950 [intro.progress]/14
+                        auto _Chunk = _Operation._Basis._Get_chunk(_Stolen_key);
+                        _Val        = _STD transform_reduce(_Chunk._First, _Chunk._Last, _STD move(_Val),
+                            _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op));
+                    }
+                } // join with _Work_ptr threads
+
+                auto& _Results = _Operation._Results; // note: already transformed
+                return _STD _Reduce_move_unchecked(
+                    _Results.begin(), _Results.end(), _STD move(_Val), _STD _Pass_fn(_Reduce_op));
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+    }
+
+    return _STD transform_reduce(
+        _UFirst, _ULast, _STD move(_Val), _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op));
+}
+
+struct _No_init_tag {
+    explicit _No_init_tag() = default;
+}; // tag to indicate that no initial value is to be used
+
+template <class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty>
+_FwdIt2 _Exclusive_scan_per_chunk(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty& _Val,
+    _Parallel_vector<_Ty>& _Intermediate_result) {
+    // local-sum for parallel exclusive_scan; writes local sums into [_Dest + 1, _Dest + (_Last - _First)) and stores
+    // successor sum in _Val
+    // pre: _Val is *uninitialized* && _First != _Last
+    _STD _Construct_in_place(_Val, *_First);
+    for (;;) {
+        ++_First;
+        ++_Dest;
+        if (_First == _Last) {
+            return _Dest;
+        }
+
+        _Ty _Tmp = _Reduce_op(_Val, *_First); // temp to enable _First == _Dest
+        if constexpr (_Scan_reuse_output<_Ty, _FwdIt2>) {
+            *_Dest = _Val;
+        } else {
+            _STL_INTERNAL_CHECK(_Intermediate_result.size() < _Intermediate_result.capacity());
+            *_Dest = _Intermediate_result.emplace_back(_STD move(_Val));
+        }
+        _Val = _STD move(_Tmp);
+    }
+}
+
+template <class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty>
+void _Exclusive_scan_per_chunk_complete(
+    _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty& _Val, _Ty& _Init) {
+    // Sum for parallel exclusive_scan with predecessor available, into [_Dest, _Dest + (_Last - _First)) and stores
+    // successor sum in _Val.
+    // Pre: _Val is *uninitialized* && _First != _Last && predecessor sum is in _Init
+    _STD _Implicitly_construct_in_place_by_binary_op_deref_rhs(_Val, _Reduce_op, _Init, _First);
+    *_Dest = _Init;
+    while (++_First != _Last) {
+        ++_Dest;
+        _Ty _Tmp = _Reduce_op(_Val, *_First); // temp to enable _First == _Dest
+        *_Dest   = _STD move(_Val);
+        _Val     = _STD move(_Tmp);
+    }
+}
+
+template <class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp>
+struct _Static_partitioned_exclusive_scan3 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
+    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
+    _Parallel_vector<_Scan_decoupled_lookback<_Ty>> _Lookback;
+    _Scan_intermediate_storage<_Ty, _FwdIt2> _Intermediate_result;
+    _Ty& _Initial;
+    _BinOp _Reduce_op;
+
+    _Static_partitioned_exclusive_scan3(const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First,
+        _Ty& _Initial_, _BinOp _Reduce_op_, const _FwdIt2&)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
+          _Lookback(_Team._Chunks), _Intermediate_result{_Team}, _Initial(_Initial_), _Reduce_op(_Reduce_op_) {
+        _Basis1._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        const auto _In_rng       = _Basis1._Get_chunk(_Key);
+        const auto _Dest         = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
+        // Run local exclusive_scan on this chunk
+        const auto _Chunk = _Lookback.data() + static_cast<ptrdiff_t>(_Chunk_number);
+        if (_Chunk_number == 0) { // chunk 0 is special as it has no predecessor; its local and total sums are the same
+            _STD _Exclusive_scan_per_chunk_complete(
+                _In_rng._First, _In_rng._Last, _Dest, _Reduce_op, _Chunk->_Sum._Ref(), _Initial);
+            _Chunk->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        const auto _Prev_chunk = _STD _Prev_iter(_Chunk);
+        if (_Prev_chunk->_State.load() & _Sum_available) {
+            // if predecessor sum already complete, we can incorporate its value directly for 1 pass
+            _STD _Exclusive_scan_per_chunk_complete(
+                _In_rng._First, _In_rng._Last, _Dest, _Reduce_op, _Chunk->_Sum._Ref(), _Prev_chunk->_Sum._Ref());
+            _Chunk->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        // Calculate local sum and publish to other threads
+        const auto _Last = _STD _Exclusive_scan_per_chunk(_In_rng._First, _In_rng._Last, _Dest, _Reduce_op,
+            _Chunk->_Local._Ref(), _Intermediate_result[_Chunk_number]);
+        _Chunk->_Store_available_state(_Local_available);
+
+        // Apply the predecessor overall sum to current overall sum and elements
+        if (_Prev_chunk->_Get_available_state() & _Sum_available) { // predecessor overall sum done, use directly
+            _Chunk->_Apply_exclusive_predecessor(
+                _Prev_chunk->_Sum._Ref(), _Dest, _Intermediate_result[_Chunk_number].data(), _Last, _Reduce_op);
+        } else {
+            auto _Tmp = _STD _Get_lookback_sum(_Prev_chunk, _Reduce_op);
+            _Chunk->_Apply_exclusive_predecessor(
+                _Tmp, _Dest, _Intermediate_result[_Chunk_number].data(), _Last, _Reduce_op);
+        }
+
+        if constexpr (!_Scan_reuse_output<_Ty, _FwdIt2>) {
+            _Intermediate_result[_Chunk_number].clear();
+        }
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_exclusive_scan3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt2 exclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
+    _BinOp _Reduce_op) noexcept /* terminates */ {
+    // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of predecessors and _Val
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            const auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                _Static_partitioned_exclusive_scan3 _Operation{
+                    _Hw_threads, _Count, _UFirst, _Val, _STD _Pass_fn(_Reduce_op), _UDest};
+                _STD _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
+                // Note that _Val is used as temporary storage by whichever thread runs the first chunk.
+                // If any thread starts any chunk, initialization is complete, so we can't enter the
+                // catch or serial fallback below, so that's OK.
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(
+                _Dest, _STD exclusive_scan(_UFirst, _ULast, _UDest, _STD move(_Val), _STD _Pass_fn(_Reduce_op)));
+            return _Dest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest,
+        _STD exclusive_scan(_UFirst, _ULast, _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
+            _STD move(_Val), _STD _Pass_fn(_Reduce_op)));
+    return _Dest;
+}
+
+template <class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty, class _Ty_fwd, class... _VectorTy>
+_FwdIt2 _Inclusive_scan_per_chunk(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty& _Val,
+    _Ty_fwd&& _Predecessor, [[maybe_unused]] _VectorTy&... _Intermediate_result) {
+    // local-sum for parallel inclusive_scan; writes local inclusive prefix sums into _Dest and stores overall sum in
+    // _Val.
+    // pre: _Val is *uninitialized* && _First != _Last
+    if constexpr (is_same_v<_No_init_tag, remove_const_t<remove_reference_t<_Ty_fwd>>>) {
+        _STD _Construct_in_place_by_deref(_Val, _First);
+    } else {
+        _STD _Implicitly_construct_in_place_by_binary_op_deref_rhs(
+            _Val, _Reduce_op, _STD forward<_Ty_fwd>(_Predecessor), _First);
+    }
+
+    for (;;) {
+        *_Dest = _Val;
+        ++_Dest;
+        ++_First;
+        if (_First == _Last) {
+            return _Dest;
+        }
+
+        if constexpr (sizeof...(_VectorTy) == 0 || _Scan_reuse_output<_Ty, _FwdIt2>) {
+            _Val = _Reduce_op(_STD move(_Val), *_First);
+        } else {
+            _STL_INTERNAL_CHECK(((_Intermediate_result.size() < _Intermediate_result.capacity()) && ...));
+            _Val = _Reduce_op(_Intermediate_result.emplace_back(_STD move(_Val))..., *_First);
+        }
+    }
+}
+
+template <class _Ty, class _Init_ty, class _FwdIt1, class _FwdIt2, class _BinOp>
+struct _Static_partitioned_inclusive_scan3 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
+    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
+    _Parallel_vector<_Scan_decoupled_lookback<_Ty>> _Lookback;
+    _Scan_intermediate_storage<_Ty, _FwdIt2> _Intermediate_result;
+    _BinOp _Reduce_op;
+    _Init_ty& _Initial;
+
+    _Static_partitioned_inclusive_scan3(
+        const size_t _Hw_threads, const _Diff _Count, _BinOp _Reduce_op_, _Init_ty& _Initial_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
+          _Lookback(_Team._Chunks), _Intermediate_result{_Team}, _Reduce_op(_Reduce_op_), _Initial(_Initial_) {}
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        const auto _In_rng       = _Basis1._Get_chunk(_Key);
+        const auto _Dest         = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
+        // Run local inclusive_scan on this chunk
+        const auto _Chunk = _Lookback.data() + static_cast<ptrdiff_t>(_Chunk_number);
+        if (_Chunk_number == 0) { // chunk 0 is special as it has no predecessor; its local and total sums are the same
+            _STD _Inclusive_scan_per_chunk(
+                _In_rng._First, _In_rng._Last, _Dest, _Reduce_op, _Chunk->_Sum._Ref(), _STD move(_Initial));
+            _Chunk->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        const auto _Prev_chunk = _STD _Prev_iter(_Chunk);
+        if (_Prev_chunk->_State.load() & _Sum_available) {
+            // if predecessor sum already complete, we can incorporate its value directly for 1 pass
+            _STD _Inclusive_scan_per_chunk(
+                _In_rng._First, _In_rng._Last, _Dest, _Reduce_op, _Chunk->_Sum._Ref(), _Prev_chunk->_Sum._Ref());
+            _Chunk->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        // Calculate local sum and publish to other threads
+        const auto _Last = _STD _Inclusive_scan_per_chunk(_In_rng._First, _In_rng._Last, _Dest, _Reduce_op,
+            _Chunk->_Local._Ref(), _No_init_tag{}, _Intermediate_result[_Chunk_number]);
+        _Chunk->_Store_available_state(_Local_available);
+
+        // Apply the predecessor overall sum to current overall sum and elements
+        if (_Prev_chunk->_Get_available_state() & _Sum_available) { // predecessor overall sum done, use directly
+            _Chunk->_Apply_inclusive_predecessor(
+                _Prev_chunk->_Sum._Ref(), _Dest, _Intermediate_result[_Chunk_number].data(), _Last, _Reduce_op);
+        } else {
+            auto _Tmp = _STD _Get_lookback_sum(_Prev_chunk, _Reduce_op);
+            _Chunk->_Apply_inclusive_predecessor(
+                _Tmp, _Dest, _Intermediate_result[_Chunk_number].data(), _Last, _Reduce_op);
+        }
+
+        if constexpr (!_Scan_reuse_output<_Ty, _FwdIt2>) {
+            _Intermediate_result[_Chunk_number].clear();
+        }
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_inclusive_scan3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt2 inclusive_scan(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty _Val) noexcept
+/* terminates */ {
+    // compute partial noncommutative and associative reductions including _Val into _Dest, using _Reduce_op
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const auto _Count = _STD distance(_First, _Last);
+            auto _UDest       = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                auto _Passed_op = _STD _Pass_fn(_Reduce_op);
+                _Static_partitioned_inclusive_scan3<_Ty, _Ty, _Unwrapped_t<const _FwdIt1&>, decltype(_UDest),
+                    decltype(_Passed_op)>
+                    _Operation{_Hw_threads, _Count, _Passed_op, _Val};
+                _Operation._Basis1._Populate(_Operation._Team, _UFirst);
+                _STD _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
+                // Note that _Val is moved from by whichever thread runs the first chunk.
+                // If any thread starts any chunk, initialization is complete, so we can't enter the
+                // catch or serial fallback below.
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(
+                _Dest, _STD inclusive_scan(_UFirst, _ULast, _UDest, _STD _Pass_fn(_Reduce_op), _STD move(_Val)));
+            return _Dest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest,
+        _STD inclusive_scan(_UFirst, _ULast, _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
+            _STD _Pass_fn(_Reduce_op), _STD move(_Val)));
+    return _Dest;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt2 inclusive_scan(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op) noexcept
+/* terminates */ {
+    // compute partial noncommutative and associative reductions into _Dest, using _Reduce_op
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            auto _UDest       = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                _No_init_tag _Tag;
+                auto _Passed_op = _STD _Pass_fn(_Reduce_op);
+                _Static_partitioned_inclusive_scan3<_Iter_value_t<_FwdIt1>, _No_init_tag, _Unwrapped_t<const _FwdIt1&>,
+                    decltype(_UDest), decltype(_Passed_op)>
+                    _Operation{_Hw_threads, _Count, _Passed_op, _Tag};
+                _Operation._Basis1._Populate(_Operation._Team, _UFirst);
+                _STD _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(_Dest, _STD inclusive_scan(_UFirst, _ULast, _UDest, _STD _Pass_fn(_Reduce_op)));
+            return _Dest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest,
+        _STD inclusive_scan(_UFirst, _ULast, _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
+            _STD _Pass_fn(_Reduce_op)));
+    return _Dest;
+}
+
+template <class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp, class _Ty>
+_FwdIt2 _Transform_exclusive_scan_per_chunk(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op, _Ty& _Val, _Parallel_vector<_Ty>& _Intermediate_result) {
+    // Local-sum for parallel transform_exclusive_scan; writes local sums into [_Dest + 1, _Dest + (_Last - _First)) and
+    // stores successor sum in _Val.
+    // pre: _Val is *uninitialized* && _First != _Last
+    _STD _Construct_in_place_by_transform_deref(_Val, _Transform_op, _First);
+    for (;;) {
+        ++_First;
+        ++_Dest;
+        if (_First == _Last) {
+            return _Dest;
+        }
+
+        _Ty _Tmp = _Reduce_op(_Val, _Transform_op(*_First)); // temp to enable _First == _Dest
+        if constexpr (_Scan_reuse_output<_Ty, _FwdIt2>) {
+            *_Dest = _Val;
+        } else {
+            _STL_INTERNAL_CHECK(_Intermediate_result.size() < _Intermediate_result.capacity());
+            *_Dest = _Intermediate_result.emplace_back(_STD move(_Val));
+        }
+        _Val = _STD move(_Tmp);
+    }
+}
+
+template <class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp, class _Ty>
+void _Transform_exclusive_scan_per_chunk_complete(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op, _Ty& _Val, _Ty& _Init) {
+    // Sum for parallel transform_exclusive_scan with predecessor available, into [_Dest, _Dest + (_Last - _First)) and
+    // stores successor sum in _Val.
+    // pre: _Val is *uninitialized* && _First != _Last && predecessor sum is in _Init
+    _STD _Implicitly_construct_in_place_by_binary_op_transform_deref_rhs(
+        _Val, _Reduce_op, _Transform_op, _Init, _First);
+    *_Dest = _Init;
+    while (++_First != _Last) {
+        ++_Dest;
+        _Ty _Tmp = _Reduce_op(_Val, _Transform_op(*_First)); // temp to enable _First == _Dest
+        *_Dest   = _STD move(_Val);
+        _Val     = _STD move(_Tmp);
+    }
+}
+
+template <class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp>
+struct _Static_partitioned_transform_exclusive_scan3 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
+    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
+    _Parallel_vector<_Scan_decoupled_lookback<_Ty>> _Lookback;
+    _Scan_intermediate_storage<_Ty, _FwdIt2> _Intermediate_result;
+    _Ty& _Initial;
+    _BinOp _Reduce_op;
+    _UnaryOp _Transform_op;
+
+    _Static_partitioned_transform_exclusive_scan3(const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First,
+        _Ty& _Initial_, _BinOp _Reduce_op_, _UnaryOp _Transform_op_, const _FwdIt2&)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
+          _Lookback(_Team._Chunks), _Intermediate_result{_Team}, _Initial(_Initial_), _Reduce_op(_Reduce_op_),
+          _Transform_op(_Transform_op_) {
+        _Basis1._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        const auto _In_rng       = _Basis1._Get_chunk(_Key);
+        const auto _Dest         = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
+        // Run local transform_exclusive_scan on this chunk
+        const auto _Chunk = _Lookback.data() + static_cast<ptrdiff_t>(_Chunk_number);
+        if (_Chunk_number == 0) { // chunk 0 is special as it has no predecessor; its local and total sums are the same
+            _STD _Transform_exclusive_scan_per_chunk_complete(
+                _In_rng._First, _In_rng._Last, _Dest, _Reduce_op, _Transform_op, _Chunk->_Sum._Ref(), _Initial);
+            _Chunk->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        const auto _Prev_chunk = _STD _Prev_iter(_Chunk);
+        if (_Prev_chunk->_State.load() & _Sum_available) {
+            // if predecessor sum already complete, we can incorporate its value directly for 1 pass
+            _STD _Transform_exclusive_scan_per_chunk_complete(_In_rng._First, _In_rng._Last, _Dest, _Reduce_op,
+                _Transform_op, _Chunk->_Sum._Ref(), _Prev_chunk->_Sum._Ref());
+            _Chunk->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        // Calculate local sum and publish to other threads
+        const auto _Last = _STD _Transform_exclusive_scan_per_chunk(_In_rng._First, _In_rng._Last, _Dest, _Reduce_op,
+            _Transform_op, _Chunk->_Local._Ref(), _Intermediate_result[_Chunk_number]);
+        _Chunk->_Store_available_state(_Local_available);
+
+        // Apply the predecessor overall sum to current overall sum and elements
+        if (_Prev_chunk->_Get_available_state() & _Sum_available) { // predecessor overall sum done, use directly
+            _Chunk->_Apply_exclusive_predecessor(
+                _Prev_chunk->_Sum._Ref(), _Dest, _Intermediate_result[_Chunk_number].data(), _Last, _Reduce_op);
+        } else {
+            auto _Tmp = _STD _Get_lookback_sum(_Prev_chunk, _Reduce_op);
+            _Chunk->_Apply_exclusive_predecessor(
+                _Tmp, _Dest, _Intermediate_result[_Chunk_number].data(), _Last, _Reduce_op);
+        }
+
+        if constexpr (!_Scan_reuse_output<_Ty, _FwdIt2>) {
+            _Intermediate_result[_Chunk_number].clear();
+        }
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_transform_exclusive_scan3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt2 transform_exclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
+    _BinOp _Reduce_op, _UnaryOp _Transform_op) noexcept /* terminates */ {
+    // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of transformed predecessors
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            const auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                _Static_partitioned_transform_exclusive_scan3 _Operation{_Hw_threads, _Count, _UFirst, _Val,
+                    _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op), _UDest};
+                _STD _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
+                // Note that _Val is used as temporary storage by whichever thread runs the first chunk.
+                // If any thread starts any chunk, initialization is complete, so we can't enter the
+                // catch or serial fallback below, so that's OK.
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(_Dest, _STD transform_exclusive_scan(_UFirst, _ULast, _UDest, _STD move(_Val),
+                                          _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op)));
+            return _Dest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _STD transform_exclusive_scan(_UFirst, _ULast,
+                                  _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
+                                  _STD move(_Val), _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op)));
+    return _Dest;
+}
+
+template <class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp, class _Ty, class _Ty_fwd, class... _VectorTy>
+_FwdIt2 _Transform_inclusive_scan_per_chunk(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op, _Ty& _Val, _Ty_fwd&& _Predecessor, [[maybe_unused]] _VectorTy&... _Intermediate_result) {
+    // local-sum for parallel transform_inclusive_scan; writes local inclusive prefix sums into _Dest and stores overall
+    // sum in _Val
+    // pre: _Val is *uninitialized* && _First != _Last
+    if constexpr (is_same_v<_No_init_tag, remove_const_t<remove_reference_t<_Ty_fwd>>>) {
+        _STD _Construct_in_place_by_transform_deref(_Val, _Transform_op, _First);
+    } else {
+        _STD _Implicitly_construct_in_place_by_binary_op_transform_deref_rhs(
+            _Val, _Reduce_op, _Transform_op, _STD forward<_Ty_fwd>(_Predecessor), _First);
+    }
+
+    for (;;) {
+        *_Dest = _Val;
+        ++_Dest;
+        ++_First;
+        if (_First == _Last) {
+            return _Dest;
+        }
+
+        if constexpr (sizeof...(_VectorTy) == 0 || _Scan_reuse_output<_Ty, _FwdIt2>) {
+            _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_First));
+        } else {
+            _STL_INTERNAL_CHECK(((_Intermediate_result.size() < _Intermediate_result.capacity()) && ...));
+            _Val = _Reduce_op(_Intermediate_result.emplace_back(_STD move(_Val))..., _Transform_op(*_First));
+        }
+    }
+}
+
+template <class _Ty, class _Init_ty, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp>
+struct _Static_partitioned_transform_inclusive_scan3 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
+    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
+    _Parallel_vector<_Scan_decoupled_lookback<_Ty>> _Lookback;
+    _Scan_intermediate_storage<_Ty, _FwdIt2> _Intermediate_result;
+    _BinOp _Reduce_op;
+    _UnaryOp _Transform_op;
+    _Init_ty& _Initial;
+
+    _Static_partitioned_transform_inclusive_scan3(
+        const size_t _Hw_threads, const _Diff _Count, _BinOp _Reduce_op_, _UnaryOp _Transform_op_, _Init_ty& _Initial_)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
+          _Lookback(_Team._Chunks), _Intermediate_result{_Team}, _Reduce_op(_Reduce_op_), _Transform_op(_Transform_op_),
+          _Initial(_Initial_) {}
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        const auto _In_rng       = _Basis1._Get_chunk(_Key);
+        const auto _Dest         = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
+        // Run local transform_inclusive_scan on this chunk
+        const auto _Chunk = _Lookback.data() + static_cast<ptrdiff_t>(_Chunk_number);
+        if (_Chunk_number == 0) { // chunk 0 is special as it has no predecessor; its local and total sums are the same
+            _STD _Transform_inclusive_scan_per_chunk(_In_rng._First, _In_rng._Last, _Dest, _Reduce_op, _Transform_op,
+                _Chunk->_Sum._Ref(), _STD move(_Initial));
+            _Chunk->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        const auto _Prev_chunk = _STD _Prev_iter(_Chunk);
+        if (_Prev_chunk->_State.load() & _Sum_available) {
+            // if predecessor sum already complete, we can incorporate its value directly for 1 pass
+            _STD _Transform_inclusive_scan_per_chunk(_In_rng._First, _In_rng._Last, _Dest, _Reduce_op, _Transform_op,
+                _Chunk->_Sum._Ref(), _Prev_chunk->_Sum._Ref());
+            _Chunk->_Store_available_state(_Sum_available);
+            return _Cancellation_status::_Running;
+        }
+
+        // Calculate local sum and publish to other threads
+        const auto _Last = _STD _Transform_inclusive_scan_per_chunk(_In_rng._First, _In_rng._Last, _Dest, _Reduce_op,
+            _Transform_op, _Chunk->_Local._Ref(), _No_init_tag{}, _Intermediate_result[_Chunk_number]);
+        _Chunk->_Store_available_state(_Local_available);
+
+        // Apply the predecessor overall sum to current overall sum and elements
+        if (_Prev_chunk->_Get_available_state() & _Sum_available) { // predecessor overall sum done, use directly
+            _Chunk->_Apply_inclusive_predecessor(
+                _Prev_chunk->_Sum._Ref(), _Dest, _Intermediate_result[_Chunk_number].data(), _Last, _Reduce_op);
+        } else {
+            auto _Tmp = _STD _Get_lookback_sum(_Prev_chunk, _Reduce_op);
+            _Chunk->_Apply_inclusive_predecessor(
+                _Tmp, _Dest, _Intermediate_result[_Chunk_number].data(), _Last, _Reduce_op);
+        }
+
+        if constexpr (!_Scan_reuse_output<_Ty, _FwdIt2>) {
+            _Intermediate_result[_Chunk_number].clear();
+        }
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_transform_inclusive_scan3*>(_Context));
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op, _Ty _Val) noexcept /* terminates */ {
+    // compute partial noncommutative and associative transformed reductions including _Val into _Dest
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            auto _UDest       = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                auto _Passed_reduce    = _STD _Pass_fn(_Reduce_op);
+                auto _Passed_transform = _STD _Pass_fn(_Transform_op);
+                _Static_partitioned_transform_inclusive_scan3<_Ty, _Ty, _Unwrapped_t<const _FwdIt1&>, decltype(_UDest),
+                    decltype(_Passed_reduce), decltype(_Passed_transform)>
+                    _Operation{_Hw_threads, _Count, _Passed_reduce, _Passed_transform, _Val};
+                _Operation._Basis1._Populate(_Operation._Team, _UFirst);
+                _STD _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
+                // Note that _Val is moved from by whichever thread runs the first chunk.
+                // If any thread starts any chunk, initialization is complete, so we can't enter the
+                // catch or serial fallback below.
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(_Dest, _STD transform_inclusive_scan(_UFirst, _ULast, _UDest, _STD _Pass_fn(_Reduce_op),
+                                          _STD _Pass_fn(_Transform_op), _STD move(_Val)));
+            return _Dest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _STD transform_inclusive_scan(_UFirst, _ULast,
+                                  _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
+                                  _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op), _STD move(_Val)));
+    return _Dest;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op) noexcept /* terminates */ {
+    // compute partial noncommutative and associative transformed reductions into _Dest
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            const auto _Count = _STD distance(_UFirst, _ULast);
+            auto _UDest       = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                _No_init_tag _Tag;
+                auto _Passed_reduce    = _STD _Pass_fn(_Reduce_op);
+                auto _Passed_transform = _STD _Pass_fn(_Transform_op);
+                using _Intermediate_t  = decay_t<decltype(_Transform_op(*_UFirst))>;
+                _Static_partitioned_transform_inclusive_scan3<_Intermediate_t, _No_init_tag,
+                    _Unwrapped_t<const _FwdIt1&>, decltype(_UDest), decltype(_Passed_reduce),
+                    decltype(_Passed_transform)>
+                    _Operation{_Hw_threads, _Count, _Passed_reduce, _Passed_transform, _Tag};
+                _Operation._Basis1._Populate(_Operation._Team, _UFirst);
+                _STD _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(_Dest, _STD transform_inclusive_scan(_UFirst, _ULast, _UDest, _STD _Pass_fn(_Reduce_op),
+                                          _STD _Pass_fn(_Transform_op)));
+            return _Dest;
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _STD transform_inclusive_scan(_UFirst, _ULast,
+                                  _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
+                                  _STD _Pass_fn(_Reduce_op), _STD _Pass_fn(_Transform_op)));
+    return _Dest;
+}
+
+template <class _FwdIt1, class _FwdIt2, class _BinOp>
+struct _Static_partitioned_adjacent_difference2 {
+    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
+    _Static_partition_team<_Diff> _Team;
+    // note offset partitioning:
+    _Static_partition_range<_FwdIt1, _Diff> _Basis1; // contains partition of [_First, _Last - 1)
+    _Static_partition_range<_FwdIt2, _Diff> _Basis2; // contains partition of [_Dest + 1, _Dest + (_Last - _First))
+    _BinOp _Diff_op;
+
+    _Static_partitioned_adjacent_difference2(
+        const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First, _BinOp _Diff_op_, const _FwdIt2&)
+        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{}, _Diff_op(_Diff_op_) {
+        _Basis1._Populate(_Team, _First);
+    }
+
+    _Cancellation_status _Process_chunk() {
+        const auto _Key = _Team._Get_next_key();
+        if (!_Key) {
+            return _Cancellation_status::_Canceled;
+        }
+
+        const auto _Chunk_number = _Key._Chunk_number;
+        auto _In_rng             = _Basis1._Get_chunk(_Key);
+        auto _Dest               = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
+        auto _Next               = _In_rng._First;
+        do {
+            ++_Next; // note: steps 1 element into the following chunk
+            *_Dest = _Diff_op(*_Next, *_In_rng._First);
+            ++_Dest;
+            _In_rng._First = _Next;
+        } while (_In_rng._First != _In_rng._Last);
+
+        return _Cancellation_status::_Running;
+    }
+
+    static void __stdcall _Threadpool_callback(
+        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept /* terminates */ {
+        _STD _Run_available_chunked_work(*static_cast<_Static_partitioned_adjacent_difference2*>(_Context));
+    }
+};
+
+template <class _FwdIt1, class _FwdIt2, class _BinOp>
+_FwdIt2 _Adjacent_difference_seq(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Diff_op) {
+    // compute adjacent differences into _Dest, serially
+    if (_First != _Last) {
+        *_Dest = *_First;
+        ++_Dest;
+        for (auto _Next = _First; ++_Next != _Last; _First = _Next) {
+            *_Dest = _Diff_op(*_Next, *_First);
+            ++_Dest;
+        }
+    }
+
+    return _Dest;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_FwdIt2 adjacent_difference(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Diff_op) noexcept
+/* terminates */ {
+    // compute adjacent differences into _Dest
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines
+            auto _Count       = _STD distance(_UFirst, _ULast);
+            const auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                --_Count; // note unusual offset partitioning
+                _Static_partitioned_adjacent_difference2 _Operation{
+                    _Hw_threads, _Count, _UFirst, _STD _Pass_fn(_Diff_op), _UDest};
+                auto _Result = _Operation._Basis2._Populate(_Operation._Team, _STD _Next_iter(_UDest));
+                const _Work_ptr _Work_op{_Operation};
+                // setup complete, hereafter nothrow or terminate
+                _Work_op._Submit_for_chunks(_Hw_threads, _Operation._Team._Chunks);
+                // must be done after setup is complete to avoid duplicate assign in serial fallback:
+                *_UDest = *_UFirst;
+                _STD _Run_available_chunked_work(_Operation);
+                _STD _Seek_wrapped(_Dest, _Result);
+                return _Dest;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+
+            _STD _Seek_wrapped(_Dest, _STD _Adjacent_difference_seq(_UFirst, _ULast, _UDest, _STD _Pass_fn(_Diff_op)));
+            return _Dest;
+        }
+    }
+
+    // Don't call serial adjacent_difference because it's described as creating a temporary we can avoid
+    _STD _Seek_wrapped(_Dest,
+        _STD _Adjacent_difference_seq(_UFirst, _ULast,
+            _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_FwdIt1>(_UFirst, _ULast)), _STD _Pass_fn(_Diff_op)));
+    return _Dest;
+}
+
+template <class _Ty>
+struct _Inplace_destroy_fn {
+    static void operator()(_Ty& _Obj) noexcept {
+        _STD _Destroy_in_place(_Obj);
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+void destroy(_ExPo&& _Exec, const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) noexcept /* terminates */ {
+    // destroy all elements in [_First, _Last)
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    using _Ty = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
+    if constexpr (!is_trivially_destructible_v<_Ty>) {
+        _STD for_each(_STD forward<_ExPo>(_Exec), _First, _Last, _Inplace_destroy_fn<_Ty>{});
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NoThrowFwdIt destroy_n(_ExPo&& _Exec, _NoThrowFwdIt _First, const _Diff _Count_raw) noexcept /* terminates */ {
+    // destroy all elements in [_First, _First + _Count)
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return _First;
+    }
+
+    using _Ty = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
+    if constexpr (is_trivially_destructible_v<_Ty>) {
+        _STD advance(_First, _Count);
+        return _First;
+    } else {
+        return _STD for_each_n(_STD forward<_ExPo>(_Exec), _First, _Count, _Inplace_destroy_fn<_Ty>{});
+    }
+}
+
+template <class _Ty>
+struct _Inplace_default_construct_fn {
+    static void operator()(_Ty& _Obj) noexcept(is_nothrow_default_constructible_v<_Ty>) {
+        _STD _Default_construct_in_place(_Obj);
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+void uninitialized_default_construct(_ExPo&& _Exec, const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) noexcept
+/* terminates */ {
+    // default-initialize all elements in [_First, _Last)
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    using _Ty = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
+    if constexpr (!is_trivially_default_constructible_v<_Ty>) {
+        _STD for_each(_STD forward<_ExPo>(_Exec), _First, _Last, _Inplace_default_construct_fn<_Ty>{});
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NoThrowFwdIt uninitialized_default_construct_n(_ExPo&& _Exec, _NoThrowFwdIt _First, const _Diff _Count_raw) noexcept
+/* terminates */ {
+    // default-initialize all elements in [_First, _First + _Count)
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return _First;
+    }
+
+    using _Ty = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
+    if constexpr (is_trivially_default_constructible_v<_Ty>) {
+        _STD advance(_First, _Count);
+        return _First;
+    } else {
+        return _STD for_each_n(_STD forward<_ExPo>(_Exec), _First, _Count, _Inplace_default_construct_fn<_Ty>{});
+    }
+}
+
+template <class _Ty>
+struct _Inplace_value_construct_fn {
+    static void operator()(_Ty& _Obj) noexcept(is_nothrow_default_constructible_v<_Ty>) {
+        _STD _Construct_in_place(_Obj);
+    }
+};
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+void uninitialized_value_construct(_ExPo&&, _NoThrowFwdIt _First, _NoThrowFwdIt _Last) noexcept /* terminates */ {
+    // value-initialize all elements in [_First, _Last)
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+    if constexpr (_Use_memset_value_construct_v<decltype(_UFirst)>) {
+        _STD _Zero_range(_UFirst, _ULast);
+    } else if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = _CSTD __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1) { // parallelize on multiprocessor machines...
+            auto _Count = _STD distance(_UFirst, _ULast);
+            if (_Count >= 2) { // ... with at least 2 elements
+                _TRY_BEGIN
+                using _Ty      = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
+                using _Ctor_fn = _Inplace_value_construct_fn<_Ty>;
+                _Static_partitioned_for_each2<decltype(_UFirst), decltype(_Count), _Ctor_fn> _Operation{
+                    _Hw_threads, _Count, _Ctor_fn{}};
+                _Operation._Basis._Populate(_Operation._Team, _UFirst);
+                _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+                return;
+                _CATCH(const _Parallelism_resources_exhausted&)
+                // fall through to serial case below
+                _CATCH_END
+            }
+        }
+
+#pragma loop(ivdep)
+        for (; _UFirst != _ULast; ++_UFirst) {
+            _STD _Construct_in_place(*_UFirst);
+        }
+    } else if constexpr (remove_reference_t<_ExPo>::_Ivdep) {
+#pragma loop(ivdep)
+        for (; _UFirst != _ULast; ++_UFirst) {
+            _STD _Construct_in_place(*_UFirst);
+        }
+    } else {
+        for (; _UFirst != _ULast; ++_UFirst) {
+            _STD _Construct_in_place(*_UFirst);
+        }
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> /* = 0 */>
+_NoThrowFwdIt uninitialized_value_construct_n(_ExPo&&, _NoThrowFwdIt _First, const _Diff _Count_raw) noexcept
+/* terminates */ {
+    // value-initialize all elements in [_First, _First + _Count)
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+
+    if (_Count <= 0) {
+        return _First;
+    }
+
+    auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+    if constexpr (_Use_memset_value_construct_v<decltype(_UFirst)>) {
+        _STD _Zero_range(_UFirst, _UFirst + _Count);
+        _STD _Seek_wrapped(_First, _UFirst + _Count);
+    } else if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
+        const size_t _Hw_threads = _CSTD __std_parallel_algorithms_hw_threads();
+        if (_Hw_threads > 1 && _Count >= 2) { // parallelize on multiprocessor machines with at least 2 elements
+            _TRY_BEGIN
+            using _Ty      = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
+            using _Ctor_fn = _Inplace_value_construct_fn<_Ty>;
+            _Static_partitioned_for_each2<decltype(_UFirst), decltype(_Count), _Ctor_fn> _Operation{
+                _Hw_threads, _Count, _Ctor_fn{}};
+            _STD _Seek_wrapped(_First, _Operation._Basis._Populate(_Operation._Team, _UFirst));
+            _STD _Run_chunked_parallel_work(_Hw_threads, _Operation);
+            return _First;
+            _CATCH(const _Parallelism_resources_exhausted&)
+            // fall through to serial case below
+            _CATCH_END
+        }
+
+#pragma loop(ivdep)
+        for (; _Count > 0; --_Count, (void) ++_UFirst) {
+            _STD _Construct_in_place(*_UFirst);
+        }
+        _STD _Seek_wrapped(_First, _UFirst);
+    } else if constexpr (remove_reference_t<_ExPo>::_Ivdep) {
+#pragma loop(ivdep)
+        for (; _Count > 0; --_Count, (void) ++_UFirst) {
+            _STD _Construct_in_place(*_UFirst);
+        }
+        _STD _Seek_wrapped(_First, _UFirst);
+    } else {
+        for (; _Count > 0; --_Count, (void) ++_UFirst) {
+            _STD _Construct_in_place(*_UFirst);
+        }
+        _STD _Seek_wrapped(_First, _UFirst);
+    }
+
+    return _First;
+}
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX17 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _EXECUTION_
diff --git a/msvc-stl/stl/inc/expected b/msvc-stl/stl/inc/expected
new file mode 100644
index 0000000..7087c35
--- /dev/null
+++ b/msvc-stl/stl/inc/expected
@@ -0,0 +1,1942 @@
+// expected standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _EXPECTED_
+#define _EXPECTED_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <expected> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+#include <exception>
+#include <initializer_list>
+#include <type_traits>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_EXPORT_STD template <class _Err>
+class _NODISCARD unexpected;
+
+template <class _Err>
+struct _Check_unexpected_argument : true_type {
+    static_assert(is_object_v<_Err>, "E must be an object type. (N4950 [expected.un.general]/2)");
+    static_assert(!is_array_v<_Err>, "E must not be an array type. (N4950 [expected.un.general]/2)");
+    static_assert(!is_const_v<_Err>, "E must not be const. (N4950 [expected.un.general]/2)");
+    static_assert(!is_volatile_v<_Err>, "E must not be volatile. (N4950 [expected.un.general]/2)");
+    static_assert(!_Is_specialization_v<_Err, unexpected>,
+        "E must not be a specialization of unexpected. (N4950 [expected.un.general]/2)");
+};
+
+// [expected.un.general]
+_EXPORT_STD template <class _Err>
+class _NODISCARD unexpected {
+    static_assert(_Check_unexpected_argument<_Err>::value);
+
+    template <class _Ty, class _Err2>
+    friend class expected;
+
+public:
+    // [expected.un.cons]
+    template <class _UError = _Err>
+        requires (!is_same_v<remove_cvref_t<_UError>, unexpected> && !is_same_v<remove_cvref_t<_UError>, in_place_t>
+                  && is_constructible_v<_Err, _UError>)
+    constexpr explicit unexpected(_UError&& _Unex) noexcept(is_nothrow_constructible_v<_Err, _UError>) // strengthened
+        : _Unexpected(_STD forward<_UError>(_Unex)) {}
+
+    template <class... _Args>
+        requires is_constructible_v<_Err, _Args...>
+    constexpr explicit unexpected(in_place_t, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened
+        : _Unexpected(_STD forward<_Args>(_Vals)...) {}
+
+    template <class _Uty, class... _Args>
+        requires is_constructible_v<_Err, initializer_list<_Uty>&, _Args...>
+    constexpr explicit unexpected(in_place_t, initializer_list<_Uty> _Ilist, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Uty>&, _Args...>) // strengthened
+        : _Unexpected(_Ilist, _STD forward<_Args>(_Vals)...) {}
+
+    // [expected.un.obs]
+    _NODISCARD constexpr const _Err& error() const& noexcept {
+        return _Unexpected;
+    }
+    _NODISCARD constexpr _Err& error() & noexcept {
+        return _Unexpected;
+    }
+    _NODISCARD constexpr const _Err&& error() const&& noexcept {
+        return _STD move(_Unexpected);
+    }
+    _NODISCARD constexpr _Err&& error() && noexcept {
+        return _STD move(_Unexpected);
+    }
+
+    // [expected.un.swap]
+    constexpr void swap(unexpected& _Other) noexcept(is_nothrow_swappable_v<_Err>) {
+        static_assert(is_swappable_v<_Err>, "E must be swappable");
+        using _STD swap;
+        swap(_Unexpected, _Other._Unexpected); // intentional ADL
+    }
+
+    friend constexpr void swap(unexpected& _Left, unexpected& _Right) noexcept(is_nothrow_swappable_v<_Err>)
+        requires is_swappable<_Err>::value // TRANSITION, /permissive needs ::value
+    {
+        _Left.swap(_Right);
+    }
+
+    // [expected.un.eq]
+    template <class _UErr>
+    _NODISCARD friend constexpr bool operator==(const unexpected& _Left, const unexpected<_UErr>& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Unexpected == _Right.error()))) /* strengthened */ {
+        return _Left._Unexpected == _Right.error();
+    }
+
+private:
+    _Err _Unexpected;
+};
+
+template <class _Err>
+unexpected(_Err) -> unexpected<_Err>;
+
+_EXPORT_STD template <class _Err>
+class _NODISCARD bad_expected_access;
+
+template <>
+class _NODISCARD bad_expected_access<void> : public exception {
+public:
+    _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
+        return "Bad expected access";
+    }
+
+protected:
+    bad_expected_access()                                      = default;
+    bad_expected_access(const bad_expected_access&)            = default;
+    bad_expected_access(bad_expected_access&&)                 = default;
+    bad_expected_access& operator=(const bad_expected_access&) = default;
+    bad_expected_access& operator=(bad_expected_access&&)      = default;
+
+#if !_HAS_EXCEPTIONS
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD template <class _Err>
+class _NODISCARD bad_expected_access : public bad_expected_access<void> {
+public:
+    explicit bad_expected_access(_Err _Unex) noexcept(is_nothrow_move_constructible_v<_Err>) // strengthened
+        : _Unexpected(_STD move(_Unex)) {}
+
+    _NODISCARD const _Err& error() const& noexcept {
+        return _Unexpected;
+    }
+    _NODISCARD _Err& error() & noexcept {
+        return _Unexpected;
+    }
+    _NODISCARD const _Err&& error() const&& noexcept {
+        return _STD move(_Unexpected);
+    }
+    _NODISCARD _Err&& error() && noexcept {
+        return _STD move(_Unexpected);
+    }
+
+private:
+    _Err _Unexpected;
+};
+
+_EXPORT_STD struct unexpect_t {
+    explicit unexpect_t() = default;
+};
+
+_EXPORT_STD inline constexpr unexpect_t unexpect{};
+
+struct _Construct_expected_from_invoke_result_tag {
+    explicit _Construct_expected_from_invoke_result_tag() = default;
+};
+
+template <class _Fn, class... _Tys>
+concept _Is_invoke_constructible = requires(_Fn&& _Func, _Tys&&... _Vals) {
+    static_cast<remove_cvref_t<invoke_result_t<_Fn, _Tys...>>>(
+        _STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Tys>(_Vals)...));
+};
+
+template <class _Ty>
+struct _Check_expected_argument : true_type {
+    static_assert(!is_reference_v<_Ty>, "T must not be a reference type. (N4950 [expected.object.general]/2)");
+    static_assert(!is_function_v<_Ty>, "T must not be a function type. (N4950 [expected.object.general]/2)");
+    static_assert(!is_array_v<_Ty>, "T must not be an array type. (N4950 [expected.object.general]/2)");
+    static_assert(!is_same_v<remove_cv_t<_Ty>, in_place_t>,
+        "T must not be (possibly cv-qualified) in_place_t. (N4950 [expected.object.general]/2)");
+    static_assert(!is_same_v<remove_cv_t<_Ty>, unexpect_t>,
+        "T must not be (possibly cv-qualified) unexpect_t. (N4950 [expected.object.general]/2)");
+    static_assert(!_Is_specialization_v<remove_cv_t<_Ty>, unexpected>,
+        "T must not be a (possibly cv-qualified) specialization of unexpected. (N4950 [expected.object.general]/2)");
+};
+
+template <class _Ty, class _Err>
+concept _Expected_binary_copy_assignable =
+    is_copy_assignable_v<_Ty> && is_copy_constructible_v<_Ty> //
+    && is_copy_assignable_v<_Err> && is_copy_constructible_v<_Err>
+    && (is_nothrow_move_constructible_v<_Ty> || is_nothrow_move_constructible_v<_Err>);
+
+template <class _Ty, class _Err>
+concept _Expected_binary_move_assignable =
+    is_move_assignable_v<_Ty> && is_move_constructible_v<_Ty> //
+    && is_move_assignable_v<_Err> && is_move_constructible_v<_Err>
+    && (is_nothrow_move_constructible_v<_Ty> || is_nothrow_move_constructible_v<_Err>);
+
+template <class _Type> // used with both _Ty and _Err
+concept _Trivially_copy_constructible_assignable_destructible =
+    is_trivially_copy_constructible_v<_Type> && is_trivially_copy_assignable_v<_Type>
+    && is_trivially_destructible_v<_Type>;
+
+template <class _Type> // used with both _Ty and _Err
+concept _Trivially_move_constructible_assignable_destructible =
+    is_trivially_move_constructible_v<_Type> && is_trivially_move_assignable_v<_Type>
+    && is_trivially_destructible_v<_Type>;
+
+_EXPORT_STD template <class _Ty, class _Err>
+class _NODISCARD expected {
+private:
+    static_assert(_Check_expected_argument<_Ty>::value);
+    static_assert(_Check_unexpected_argument<_Err>::value);
+
+    template <class _UTy, class _UErr>
+    friend class expected;
+
+    template <class _Uty, class _UErr>
+    static constexpr bool _Allow_unwrapping = disjunction_v<is_same<remove_cv_t<_Ty>, bool>,
+                                                  negation<disjunction<is_constructible<_Ty, expected<_Uty, _UErr>&>, //
+                                                      is_constructible<_Ty, expected<_Uty, _UErr>>, //
+                                                      is_constructible<_Ty, const expected<_Uty, _UErr>&>, //
+                                                      is_constructible<_Ty, const expected<_Uty, _UErr>>, //
+                                                      is_convertible<expected<_Uty, _UErr>&, _Ty>, //
+                                                      is_convertible<expected<_Uty, _UErr>&&, _Ty>, //
+                                                      is_convertible<const expected<_Uty, _UErr>&, _Ty>, //
+                                                      is_convertible<const expected<_Uty, _UErr>&&, _Ty>>>>
+                                           && !is_constructible_v<unexpected<_Err>, expected<_Uty, _UErr>&>
+                                           && !is_constructible_v<unexpected<_Err>, expected<_Uty, _UErr>>
+                                           && !is_constructible_v<unexpected<_Err>, const expected<_Uty, _UErr>&>
+                                           && !is_constructible_v<unexpected<_Err>, const expected<_Uty, _UErr>>;
+
+public:
+    using value_type      = _Ty;
+    using error_type      = _Err;
+    using unexpected_type = unexpected<_Err>;
+
+    template <class _Uty>
+    using rebind = expected<_Uty, error_type>;
+
+    // [expected.object.cons]
+    constexpr expected() noexcept(is_nothrow_default_constructible_v<_Ty>) // strengthened
+        requires is_default_constructible_v<_Ty>
+        : _Value(), _Has_value(true) {}
+
+    constexpr expected(const expected& _Other)
+        noexcept(is_nothrow_copy_constructible_v<_Ty> && is_nothrow_copy_constructible_v<_Err>) // strengthened
+        requires (!(is_trivially_copy_constructible_v<_Ty> && is_trivially_copy_constructible_v<_Err>)
+                  && is_copy_constructible_v<_Ty> && is_copy_constructible_v<_Err>)
+        : _Has_value(_Other._Has_value) {
+        if (_Has_value) {
+            _STD construct_at(_STD addressof(_Value), _Other._Value);
+        } else {
+            _STD construct_at(_STD addressof(_Unexpected), _Other._Unexpected);
+        }
+    }
+
+    expected(const expected&)
+        requires is_trivially_copy_constructible_v<_Ty> && is_trivially_copy_constructible_v<_Err>
+    = default;
+
+    expected(const expected&) = delete;
+
+    constexpr expected(expected&& _Other)
+        noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_constructible_v<_Err>)
+        requires (!(is_trivially_move_constructible_v<_Ty> && is_trivially_move_constructible_v<_Err>)
+                  && is_move_constructible_v<_Ty> && is_move_constructible_v<_Err>)
+        : _Has_value(_Other._Has_value) {
+        if (_Has_value) {
+            _STD construct_at(_STD addressof(_Value), _STD move(_Other._Value));
+        } else {
+            _STD construct_at(_STD addressof(_Unexpected), _STD move(_Other._Unexpected));
+        }
+    }
+
+    expected(expected&&)
+        requires is_trivially_move_constructible_v<_Ty> && is_trivially_move_constructible_v<_Err>
+    = default;
+
+    template <class _Uty, class _UErr>
+        requires _Different_from<expected<_Uty, _UErr>, expected> && is_constructible_v<_Ty, const _Uty&>
+              && is_constructible_v<_Err, const _UErr&> && _Allow_unwrapping<_Uty, _UErr>
+    constexpr explicit(!is_convertible_v<const _Uty&, _Ty> || !is_convertible_v<const _UErr&, _Err>)
+        expected(const expected<_Uty, _UErr>& _Other)
+            noexcept(is_nothrow_constructible_v<_Ty, const _Uty&>
+                     && is_nothrow_constructible_v<_Err, const _UErr&>) // strengthened
+        : _Has_value(_Other._Has_value) {
+        if (_Has_value) {
+            _STD construct_at(_STD addressof(_Value), _Other._Value);
+        } else {
+            _STD construct_at(_STD addressof(_Unexpected), _Other._Unexpected);
+        }
+    }
+
+    template <class _Uty, class _UErr>
+        requires _Different_from<expected<_Uty, _UErr>, expected> && is_constructible_v<_Ty, _Uty>
+              && is_constructible_v<_Err, _UErr> && _Allow_unwrapping<_Uty, _UErr>
+    constexpr explicit(!is_convertible_v<_Uty, _Ty> || !is_convertible_v<_UErr, _Err>)
+        expected(expected<_Uty, _UErr>&& _Other)
+            noexcept(is_nothrow_constructible_v<_Ty, _Uty> && is_nothrow_constructible_v<_Err, _UErr>) // strengthened
+        : _Has_value(_Other._Has_value) {
+        if (_Has_value) {
+            _STD construct_at(_STD addressof(_Value), _STD move(_Other._Value));
+        } else {
+            _STD construct_at(_STD addressof(_Unexpected), _STD move(_Other._Unexpected));
+        }
+    }
+
+    template <class _Uty = remove_cv_t<_Ty>>
+        requires (!is_same_v<remove_cvref_t<_Uty>, in_place_t> && !is_same_v<remove_cvref_t<_Uty>, expected>
+                     && !is_same_v<remove_cvref_t<_Uty>, unexpect_t>
+                     && !_Is_specialization_v<remove_cvref_t<_Uty>, unexpected>
+                     && (!is_same_v<remove_cv_t<_Ty>, bool> || !_Is_specialization_v<remove_cvref_t<_Uty>, expected>)
+                     && is_constructible_v<_Ty, _Uty>)
+    constexpr explicit(!is_convertible_v<_Uty, _Ty>) expected(_Uty&& _Other)
+        noexcept(is_nothrow_constructible_v<_Ty, _Uty>) // strengthened
+        : _Value(_STD forward<_Uty>(_Other)), _Has_value(true) {}
+
+    template <class _UErr>
+        requires is_constructible_v<_Err, const _UErr&>
+    constexpr explicit(!is_convertible_v<const _UErr&, _Err>) expected(const unexpected<_UErr>& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, const _UErr&>) // strengthened
+        : _Unexpected(_Other._Unexpected), _Has_value(false) {}
+
+    template <class _UErr>
+        requires is_constructible_v<_Err, _UErr>
+    constexpr explicit(!is_convertible_v<_UErr, _Err>) expected(unexpected<_UErr>&& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, _UErr>) // strengthened
+        : _Unexpected(_STD move(_Other._Unexpected)), _Has_value(false) {}
+
+    template <class... _Args>
+        requires is_constructible_v<_Ty, _Args...>
+    constexpr explicit expected(in_place_t, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_Ty, _Args...>) // strengthened
+        : _Value(_STD forward<_Args>(_Vals)...), _Has_value(true) {}
+
+    template <class _Uty, class... _Args>
+        requires is_constructible_v<_Ty, initializer_list<_Uty>&, _Args...>
+    constexpr explicit expected(in_place_t, initializer_list<_Uty> _Ilist, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_Ty, initializer_list<_Uty>&, _Args...>) // strengthened
+        : _Value(_Ilist, _STD forward<_Args>(_Vals)...), _Has_value(true) {}
+
+    template <class... _Args>
+        requires is_constructible_v<_Err, _Args...>
+    constexpr explicit expected(unexpect_t, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened
+        : _Unexpected(_STD forward<_Args>(_Vals)...), _Has_value(false) {}
+
+    template <class _Uty, class... _Args>
+        requires is_constructible_v<_Err, initializer_list<_Uty>&, _Args...>
+    constexpr explicit expected(unexpect_t, initializer_list<_Uty> _Ilist, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Uty>&, _Args...>) // strengthened
+        : _Unexpected(_Ilist, _STD forward<_Args>(_Vals)...), _Has_value(false) {}
+
+    // [expected.object.dtor]
+    constexpr ~expected()
+#ifndef __clang__ // TRANSITION, LLVM-59854
+        noexcept
+#endif // ^^^ no workaround ^^^
+    {
+        if (_Has_value) {
+            if constexpr (!is_trivially_destructible_v<_Ty>) {
+                _Value.~_Ty();
+            }
+        } else {
+            if constexpr (!is_trivially_destructible_v<_Err>) {
+                _Unexpected.~_Err();
+            }
+        }
+    }
+
+    ~expected()
+        requires is_trivially_destructible_v<_Ty> && is_trivially_destructible_v<_Err>
+    = default;
+
+    // [expected.object.assign]
+    template <class _Uty>
+        requires is_nothrow_move_constructible_v<_Uty>
+    struct _NODISCARD _GuardTy {
+        constexpr _GuardTy(_Uty* _Target_, _Uty* _Tmp_) noexcept : _Target(_Target_), _Tmp(_Tmp_) {}
+        constexpr ~_GuardTy() noexcept {
+            if (_Target) {
+                _STD construct_at(_Target, _STD move(*_Tmp));
+            }
+        }
+        _Uty* _Target;
+        _Uty* _Tmp;
+    };
+
+    template <class _First, class _Second, class... _Args>
+    static constexpr void _Reinit_expected(_First& _New_val, _Second& _Old_val, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_First, _Args...>) /* strengthened */ {
+        if constexpr (is_nothrow_constructible_v<_First, _Args...>) {
+            if constexpr (!is_trivially_destructible_v<_Second>) {
+                _Old_val.~_Second();
+            }
+            _STD construct_at(_STD addressof(_New_val), _STD forward<_Args>(_Vals)...);
+        } else if constexpr (is_nothrow_move_constructible_v<_First>) {
+            _First _Tmp(_STD forward<_Args>(_Vals)...);
+            if constexpr (!is_trivially_destructible_v<_Second>) {
+                _Old_val.~_Second();
+            }
+            _STD construct_at(_STD addressof(_New_val), _STD move(_Tmp));
+        } else {
+            _Second _Tmp(_STD move(_Old_val));
+            if constexpr (!is_trivially_destructible_v<_Second>) {
+                _Old_val.~_Second();
+            }
+
+            _GuardTy<_Second> _Guard{_STD addressof(_Old_val), _STD addressof(_Tmp)};
+            _STD construct_at(_STD addressof(_New_val), _STD forward<_Args>(_Vals)...);
+            _Guard._Target = nullptr;
+        }
+    }
+
+    constexpr expected& operator=(const expected& _Other)
+        noexcept(is_nothrow_copy_constructible_v<_Ty> && is_nothrow_copy_constructible_v<_Err>
+                 && is_nothrow_copy_assignable_v<_Ty> && is_nothrow_copy_assignable_v<_Err>) // strengthened
+        requires _Expected_binary_copy_assignable<_Ty, _Err>
+    {
+        if (_Has_value && _Other._Has_value) {
+            _Value = _Other._Value;
+        } else if (_Has_value) {
+            _Reinit_expected(_Unexpected, _Value, _Other._Unexpected);
+        } else if (_Other._Has_value) {
+            _Reinit_expected(_Value, _Unexpected, _Other._Value);
+        } else {
+            _Unexpected = _Other._Unexpected;
+        }
+
+        _Has_value = _Other._Has_value;
+        return *this;
+    }
+
+    expected& operator=(const expected&)
+        requires _Expected_binary_copy_assignable<_Ty, _Err>
+                  && _Trivially_copy_constructible_assignable_destructible<_Ty>
+                  && _Trivially_copy_constructible_assignable_destructible<_Err>
+    = default;
+
+    expected& operator=(const expected&) = delete;
+
+    constexpr expected& operator=(expected&& _Other)
+        noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_constructible_v<_Err>
+                 && is_nothrow_move_assignable_v<_Ty> && is_nothrow_move_assignable_v<_Err>)
+        requires _Expected_binary_move_assignable<_Ty, _Err>
+    {
+        if (_Has_value && _Other._Has_value) {
+            _Value = _STD move(_Other._Value);
+        } else if (_Has_value) {
+            _Reinit_expected(_Unexpected, _Value, _STD move(_Other._Unexpected));
+        } else if (_Other._Has_value) {
+            _Reinit_expected(_Value, _Unexpected, _STD move(_Other._Value));
+        } else {
+            _Unexpected = _STD move(_Other._Unexpected);
+        }
+
+        _Has_value = _Other._Has_value;
+        return *this;
+    }
+
+    expected& operator=(expected&&)
+        requires _Expected_binary_move_assignable<_Ty, _Err>
+                  && _Trivially_move_constructible_assignable_destructible<_Ty>
+                  && _Trivially_move_constructible_assignable_destructible<_Err>
+    = default;
+
+    template <class _Uty = remove_cv_t<_Ty>>
+        requires (!is_same_v<remove_cvref_t<_Uty>, expected> && !_Is_specialization_v<remove_cvref_t<_Uty>, unexpected>
+                  && is_constructible_v<_Ty, _Uty> && is_assignable_v<_Ty&, _Uty>
+                  && (is_nothrow_constructible_v<_Ty, _Uty> || is_nothrow_move_constructible_v<_Ty>
+                      || is_nothrow_move_constructible_v<_Err>) )
+    constexpr expected& operator=(_Uty&& _Other)
+        noexcept(is_nothrow_constructible_v<_Ty, _Uty> && is_nothrow_assignable_v<_Ty&, _Uty>) /* strengthened */ {
+        if (_Has_value) {
+            _Value = _STD forward<_Uty>(_Other);
+        } else {
+            _Reinit_expected(_Value, _Unexpected, _STD forward<_Uty>(_Other));
+            _Has_value = true;
+        }
+
+        return *this;
+    }
+
+    template <class _UErr>
+        requires (is_constructible_v<_Err, const _UErr&> && is_assignable_v<_Err&, const _UErr&>
+                  && (is_nothrow_constructible_v<_Err, const _UErr&> || is_nothrow_move_constructible_v<_Ty>
+                      || is_nothrow_move_constructible_v<_Err>) )
+    constexpr expected& operator=(const unexpected<_UErr>& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, const _UErr&>
+                 && is_nothrow_assignable_v<_Err&, const _UErr&>) /* strengthened */ {
+        if (_Has_value) {
+            _Reinit_expected(_Unexpected, _Value, _Other._Unexpected);
+            _Has_value = false;
+        } else {
+            _Unexpected = _Other._Unexpected;
+        }
+
+        return *this;
+    }
+
+    template <class _UErr>
+        requires (is_constructible_v<_Err, _UErr> && is_assignable_v<_Err&, _UErr>
+                  && (is_nothrow_constructible_v<_Err, _UErr> || is_nothrow_move_constructible_v<_Ty>
+                      || is_nothrow_move_constructible_v<_Err>) )
+    constexpr expected& operator=(unexpected<_UErr>&& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, _UErr> && is_nothrow_assignable_v<_Err&, _UErr>) /* strengthened */ {
+        if (_Has_value) {
+            _Reinit_expected(_Unexpected, _Value, _STD move(_Other._Unexpected));
+            _Has_value = false;
+        } else {
+            _Unexpected = _STD move(_Other._Unexpected);
+        }
+
+        return *this;
+    }
+
+    template <class... _Args>
+        requires is_nothrow_constructible_v<_Ty, _Args...>
+    constexpr _Ty& emplace(_Args&&... _Vals) noexcept {
+        if (_Has_value) {
+            if constexpr (!is_trivially_destructible_v<_Ty>) {
+                _Value.~_Ty();
+            }
+        } else {
+            if constexpr (!is_trivially_destructible_v<_Err>) {
+                _Unexpected.~_Err();
+            }
+            _Has_value = true;
+        }
+
+        return *_STD construct_at(_STD addressof(_Value), _STD forward<_Args>(_Vals)...);
+    }
+
+    template <class _Uty, class... _Args>
+        requires is_nothrow_constructible_v<_Ty, initializer_list<_Uty>&, _Args...>
+    constexpr _Ty& emplace(initializer_list<_Uty> _Ilist, _Args&&... _Vals) noexcept {
+        if (_Has_value) {
+            if constexpr (!is_trivially_destructible_v<_Ty>) {
+                _Value.~_Ty();
+            }
+        } else {
+            if constexpr (!is_trivially_destructible_v<_Err>) {
+                _Unexpected.~_Err();
+            }
+            _Has_value = true;
+        }
+
+        return *_STD construct_at(_STD addressof(_Value), _Ilist, _STD forward<_Args>(_Vals)...);
+    }
+
+    // [expected.object.swap]
+    constexpr void swap(expected& _Other)
+        noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_swappable_v<_Ty>
+                 && is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
+        requires is_swappable_v<_Ty> && is_swappable_v<_Err> //
+              && is_move_constructible_v<_Ty> && is_move_constructible_v<_Err>
+              && (is_nothrow_move_constructible_v<_Ty> || is_nothrow_move_constructible_v<_Err>)
+    {
+        using _STD swap;
+        if (_Has_value && _Other._Has_value) {
+            swap(_Value, _Other._Value); // intentional ADL
+        } else if (_Has_value) {
+            if constexpr (is_nothrow_move_constructible_v<_Err>) {
+                _Err _Tmp(_STD move(_Other._Unexpected));
+                if constexpr (!is_trivially_destructible_v<_Err>) {
+                    _Other._Unexpected.~_Err();
+                }
+
+                if constexpr (is_nothrow_move_constructible_v<_Ty>) {
+                    _STD construct_at(_STD addressof(_Other._Value), _STD move(_Value));
+                } else {
+                    _GuardTy<_Err> _Guard{_STD addressof(_Other._Unexpected), _STD addressof(_Tmp)};
+                    _STD construct_at(_STD addressof(_Other._Value), _STD move(_Value));
+                    _Guard._Target = nullptr;
+                }
+
+                if constexpr (!is_trivially_destructible_v<_Ty>) {
+                    _Value.~_Ty();
+                }
+                _STD construct_at(_STD addressof(_Unexpected), _STD move(_Tmp));
+            } else {
+                remove_cv_t<_Ty> _Tmp(_STD move(_Value));
+                if constexpr (!is_trivially_destructible_v<_Ty>) {
+                    _Value.~_Ty();
+                }
+
+                _GuardTy<_Ty> _Guard{_STD addressof(_Value), _STD addressof(_Tmp)};
+                _STD construct_at(_STD addressof(_Unexpected), _STD move(_Other._Unexpected));
+                _Guard._Target = nullptr;
+
+                if constexpr (!is_trivially_destructible_v<_Err>) {
+                    _Other._Unexpected.~_Err();
+                }
+                _STD construct_at(_STD addressof(_Other._Value), _STD move(_Tmp));
+            }
+
+            _Has_value        = false;
+            _Other._Has_value = true;
+        } else if (_Other._Has_value) {
+            _Other.swap(*this);
+        } else {
+            swap(_Unexpected, _Other._Unexpected); // intentional ADL
+        }
+    }
+
+    friend constexpr void swap(expected& _Lhs, expected& _Rhs)
+        noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_swappable_v<_Ty>
+                 && is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
+        requires is_swappable<_Ty>::value && is_swappable<_Err>::value // TRANSITION, /permissive needs ::value
+              && is_move_constructible_v<_Ty> && is_move_constructible_v<_Err>
+              && (is_nothrow_move_constructible_v<_Ty> || is_nothrow_move_constructible_v<_Err>)
+    {
+        _Lhs.swap(_Rhs);
+    }
+
+    // [expected.object.obs]
+    _NODISCARD constexpr const _Ty* operator->() const noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Has_value, "operator->() called on a std::expected that contains an error, not a value");
+#endif
+
+        return _STD addressof(_Value);
+    }
+    _NODISCARD constexpr _Ty* operator->() noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Has_value, "operator->() called on a std::expected that contains an error, not a value");
+#endif
+
+        return _STD addressof(_Value);
+    }
+
+    _NODISCARD constexpr const _Ty& operator*() const& noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Has_value, "operator*() called on a std::expected that contains an error, not a value");
+#endif
+
+        return _Value;
+    }
+    _NODISCARD constexpr _Ty& operator*() & noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Has_value, "operator*() called on a std::expected that contains an error, not a value");
+#endif
+
+        return _Value;
+    }
+    _NODISCARD constexpr const _Ty&& operator*() const&& noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Has_value, "operator*() called on a std::expected that contains an error, not a value");
+#endif
+
+        return _STD move(_Value);
+    }
+    _NODISCARD constexpr _Ty&& operator*() && noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Has_value, "operator*() called on a std::expected that contains an error, not a value");
+#endif
+
+        return _STD move(_Value);
+    }
+
+    _NODISCARD constexpr explicit operator bool() const noexcept {
+        return _Has_value;
+    }
+    _NODISCARD constexpr bool has_value() const noexcept {
+        return _Has_value;
+    }
+
+    _NODISCARD constexpr const _Ty& value() const& {
+        if (_Has_value) {
+            return _Value;
+        }
+
+        _Throw_bad_expected_access_lv();
+    }
+    _NODISCARD constexpr _Ty& value() & {
+        if (_Has_value) {
+            return _Value;
+        }
+
+        _Throw_bad_expected_access_lv();
+    }
+    _NODISCARD constexpr const _Ty&& value() const&& {
+        // TRANSITION, DevCom-1638273 and LLVM-53224
+        static_assert(
+            is_copy_constructible_v<_Err>, "is_copy_constructible_v<E> must be true. N4950 [expected.object.obs]/11");
+        static_assert(is_constructible_v<_Err, const _Err&&>,
+            "is_constructible_v<E, const E&&> must be true. N4950 [expected.object.obs]/11");
+
+        if (_Has_value) {
+            return _STD move(_Value);
+        }
+
+        _Throw_bad_expected_access_rv();
+    }
+    _NODISCARD constexpr _Ty&& value() && {
+        // TRANSITION, DevCom-1638273 and LLVM-53224
+        static_assert(
+            is_copy_constructible_v<_Err>, "is_copy_constructible_v<E> must be true. N4950 [expected.object.obs]/11");
+        static_assert(
+            is_move_constructible_v<_Err>, "is_constructible_v<E, E&&> must be true. N4950 [expected.object.obs]/11");
+
+        if (_Has_value) {
+            return _STD move(_Value);
+        }
+
+        _Throw_bad_expected_access_rv();
+    }
+
+    _NODISCARD constexpr const _Err& error() const& noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!_Has_value, "error() called on a std::expected that contains a value, not an error");
+#endif
+
+        return _Unexpected;
+    }
+    _NODISCARD constexpr _Err& error() & noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!_Has_value, "error() called on a std::expected that contains a value, not an error");
+#endif
+
+        return _Unexpected;
+    }
+    _NODISCARD constexpr const _Err&& error() const&& noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!_Has_value, "error() called on a std::expected that contains a value, not an error");
+#endif
+
+        return _STD move(_Unexpected);
+    }
+    _NODISCARD constexpr _Err&& error() && noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!_Has_value, "error() called on a std::expected that contains a value, not an error");
+#endif
+
+        return _STD move(_Unexpected);
+    }
+
+    template <class _Uty = remove_cv_t<_Ty>>
+    _NODISCARD constexpr remove_cv_t<_Ty> value_or(_Uty&& _Other) const& noexcept(
+        is_nothrow_convertible_v<const _Ty&, remove_cv_t<_Ty>>
+        && is_nothrow_convertible_v<_Uty, remove_cv_t<_Ty>>) /* strengthened */ {
+        static_assert(is_convertible_v<const _Ty&, remove_cv_t<_Ty>>,
+            "is_convertible_v<const T&, remove_cv_t<T>> must be true. "
+            "(N5001 [expected.object.obs]/18 as modified by LWG-3424)");
+        static_assert(is_convertible_v<_Uty, remove_cv_t<_Ty>>,
+            "is_convertible_v<U, remove_cv_t<T>> must be true. "
+            "(N5001 [expected.object.obs]/18 as modified by LWG-3424)");
+
+        if (_Has_value) {
+            return _Value;
+        } else {
+            return static_cast<remove_cv_t<_Ty>>(_STD forward<_Uty>(_Other));
+        }
+    }
+    template <class _Uty = remove_cv_t<_Ty>>
+    _NODISCARD constexpr remove_cv_t<_Ty> value_or(_Uty&& _Other) && noexcept(
+        is_nothrow_convertible_v<_Ty, remove_cv_t<_Ty>>
+        && is_nothrow_convertible_v<_Uty, remove_cv_t<_Ty>>) /* strengthened */ {
+        static_assert(is_convertible_v<_Ty, remove_cv_t<_Ty>>,
+            "is_convertible_v<T, remove_cv_t<T>> must be true. "
+            "(N5001 [expected.object.obs]/20 as modified by LWG-3424)");
+        static_assert(is_convertible_v<_Uty, remove_cv_t<_Ty>>,
+            "is_convertible_v<U, remove_cv_t<T>> must be true. "
+            "(N5001 [expected.object.obs]/20 as modified by LWG-3424)");
+
+        if (_Has_value) {
+            return _STD move(_Value);
+        } else {
+            return static_cast<remove_cv_t<_Ty>>(_STD forward<_Uty>(_Other));
+        }
+    }
+
+    template <class _Uty = _Err>
+    _NODISCARD constexpr _Err error_or(_Uty&& _Other) const& noexcept(
+        is_nothrow_copy_constructible_v<_Err> && is_nothrow_convertible_v<_Uty, _Err>) /* strengthened */ {
+        static_assert(
+            is_copy_constructible_v<_Err>, "is_copy_constructible_v<E> must be true. (N4950 [expected.object.obs]/22)");
+        static_assert(
+            is_convertible_v<_Uty, _Err>, "is_convertible_v<G, E> must be true. (N4950 [expected.object.obs]/22)");
+
+        if (_Has_value) {
+            return _STD forward<_Uty>(_Other);
+        } else {
+            return _Unexpected;
+        }
+    }
+
+    template <class _Uty = _Err>
+    _NODISCARD constexpr _Err error_or(_Uty&& _Other) && noexcept(
+        is_nothrow_move_constructible_v<_Err> && is_nothrow_convertible_v<_Uty, _Err>) /* strengthened */ {
+        static_assert(
+            is_move_constructible_v<_Err>, "is_move_constructible_v<E> must be true. (N4950 [expected.object.obs]/24)");
+        static_assert(
+            is_convertible_v<_Uty, _Err>, "is_convertible_v<G, E> must be true. (N4950 [expected.object.obs]/24)");
+
+        if (_Has_value) {
+            return _STD forward<_Uty>(_Other);
+        } else {
+            return _STD move(_Unexpected);
+        }
+    }
+
+    // [expected.object.monadic]
+    template <class _Fn>
+        requires is_constructible_v<_Err, _Err&>
+    constexpr auto and_then(_Fn&& _Func) & {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, _Ty&>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<T, E>::and_then(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.object.monadic]/3)");
+        static_assert(is_same_v<typename _Uty::error_type, _Err>,
+            "expected<T, E>::and_then(F) requires the error type of the return type of F to be E. "
+            "(N4950 [expected.object.monadic]/3)");
+
+        if (_Has_value) {
+            return _STD invoke(_STD forward<_Fn>(_Func), _Value);
+        } else {
+            return _Uty{unexpect, _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_copy_constructible_v<_Err>
+    constexpr auto and_then(_Fn&& _Func) const& {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, const _Ty&>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<T, E>::and_then(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.object.monadic]/3)");
+        static_assert(is_same_v<typename _Uty::error_type, _Err>,
+            "expected<T, E>::and_then(F) requires the error type of the return type of F to be E. "
+            "(N4950 [expected.object.monadic]/3)");
+
+        if (_Has_value) {
+            return _STD invoke(_STD forward<_Fn>(_Func), _Value);
+        } else {
+            return _Uty{unexpect, _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_move_constructible_v<_Err>
+    constexpr auto and_then(_Fn&& _Func) && {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, _Ty>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<T, E>::and_then(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.object.monadic]/7)");
+        static_assert(is_same_v<typename _Uty::error_type, _Err>,
+            "expected<T, E>::and_then(F) requires the error type of the return type of F to be E. "
+            "(N4950 [expected.object.monadic]/7)");
+
+        if (_Has_value) {
+            return _STD invoke(_STD forward<_Fn>(_Func), _STD move(_Value));
+        } else {
+            return _Uty{unexpect, _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Err, const _Err>
+    constexpr auto and_then(_Fn&& _Func) const&& {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, const _Ty>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<T, E>::and_then(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.object.monadic]/7)");
+        static_assert(is_same_v<typename _Uty::error_type, _Err>,
+            "expected<T, E>::and_then(F) requires the error type of the return type of F to be E. "
+            "(N4950 [expected.object.monadic]/7)");
+
+        if (_Has_value) {
+            return _STD invoke(_STD forward<_Fn>(_Func), _STD move(_Value));
+        } else {
+            return _Uty{unexpect, _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Ty, _Ty&>
+    constexpr auto or_else(_Fn&& _Func) & {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, _Err&>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<T, E>::or_else(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.object.monadic]/11)");
+        static_assert(is_same_v<typename _Uty::value_type, _Ty>,
+            "expected<T, E>::or_else(F) requires the value type of the return type of F to be T. "
+            "(N4950 [expected.object.monadic]/11)");
+
+        if (_Has_value) {
+            return _Uty{in_place, _Value};
+        } else {
+            return _STD invoke(_STD forward<_Fn>(_Func), _Unexpected);
+        }
+    }
+
+    template <class _Fn>
+        requires is_copy_constructible_v<_Ty>
+    constexpr auto or_else(_Fn&& _Func) const& {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, const _Err&>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<T, E>::or_else(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.object.monadic]/11)");
+        static_assert(is_same_v<typename _Uty::value_type, _Ty>,
+            "expected<T, E>::or_else(F) requires the value type of the return type of F to be T. "
+            "(N4950 [expected.object.monadic]/11)");
+
+        if (_Has_value) {
+            return _Uty{in_place, _Value};
+        } else {
+            return _STD invoke(_STD forward<_Fn>(_Func), _Unexpected);
+        }
+    }
+
+    template <class _Fn>
+        requires is_move_constructible_v<_Ty>
+    constexpr auto or_else(_Fn&& _Func) && {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, _Err>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<T, E>::or_else(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.object.monadic]/15)");
+        static_assert(is_same_v<typename _Uty::value_type, _Ty>,
+            "expected<T, E>::or_else(F) requires the value type of the return type of F to be T. "
+            "(N4950 [expected.object.monadic]/15)");
+
+        if (_Has_value) {
+            return _Uty{in_place, _STD move(_Value)};
+        } else {
+            return _STD invoke(_STD forward<_Fn>(_Func), _STD move(_Unexpected));
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Ty, const _Ty>
+    constexpr auto or_else(_Fn&& _Func) const&& {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, const _Err>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<T, E>::or_else(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.object.monadic]/15)");
+        static_assert(is_same_v<typename _Uty::value_type, _Ty>,
+            "expected<T, E>::or_else(F) requires the value type of the return type of F to be T. "
+            "(N4950 [expected.object.monadic]/15)");
+
+        if (_Has_value) {
+            return _Uty{in_place, _STD move(_Value)};
+        } else {
+            return _STD invoke(_STD forward<_Fn>(_Func), _STD move(_Unexpected));
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Err, _Err&>
+    constexpr auto transform(_Fn&& _Func) & {
+        static_assert(invocable<_Fn, _Ty&>, "expected<T, E>::transform(F) requires that F is invocable with T. "
+                                            "(N4950 [expected.object.monadic]/19)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Ty&>>;
+
+        if constexpr (!is_void_v<_Uty>) {
+            static_assert(_Is_invoke_constructible<_Fn, _Ty&>,
+                "expected<T, E>::transform(F) requires that the return type of F is constructible with the result of "
+                "invoking f. (N4950 [expected.object.monadic]/19)");
+        }
+        static_assert(_Check_expected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            if constexpr (is_void_v<_Uty>) {
+                _STD invoke(_STD forward<_Fn>(_Func), _Value);
+                return expected<_Uty, _Err>{};
+            } else {
+                return expected<_Uty, _Err>{
+                    _Construct_expected_from_invoke_result_tag{}, _STD forward<_Fn>(_Func), _Value};
+            }
+        } else {
+            return expected<_Uty, _Err>{unexpect, _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_copy_constructible_v<_Err>
+    constexpr auto transform(_Fn&& _Func) const& {
+        static_assert(invocable<_Fn, const _Ty&>, "expected<T, E>::transform(F) requires that F is invocable with T. "
+                                                  "(N4950 [expected.object.monadic]/19)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Ty&>>;
+
+        if constexpr (!is_void_v<_Uty>) {
+            static_assert(_Is_invoke_constructible<_Fn, const _Ty&>,
+                "expected<T, E>::transform(F) requires that the return type of F is constructible with the result of "
+                "invoking f. (N4950 [expected.object.monadic]/19)");
+        }
+        static_assert(_Check_expected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            if constexpr (is_void_v<_Uty>) {
+                _STD invoke(_STD forward<_Fn>(_Func), _Value);
+                return expected<_Uty, _Err>{};
+            } else {
+                return expected<_Uty, _Err>{
+                    _Construct_expected_from_invoke_result_tag{}, _STD forward<_Fn>(_Func), _Value};
+            }
+        } else {
+            return expected<_Uty, _Err>{unexpect, _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_move_constructible_v<_Err>
+    constexpr auto transform(_Fn&& _Func) && {
+        static_assert(invocable<_Fn, _Ty>, "expected<T, E>::transform(F) requires that F is invocable with T. "
+                                           "(N4950 [expected.object.monadic]/23)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Ty>>;
+
+        if constexpr (!is_void_v<_Uty>) {
+            static_assert(_Is_invoke_constructible<_Fn, _Ty>,
+                "expected<T, E>::transform(F) requires that the return type of F is constructible with the result of "
+                "invoking f. (N4950 [expected.object.monadic]/23)");
+        }
+        static_assert(_Check_expected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            if constexpr (is_void_v<_Uty>) {
+                _STD invoke(_STD forward<_Fn>(_Func), _STD move(_Value));
+                return expected<_Uty, _Err>{};
+            } else {
+                return expected<_Uty, _Err>{
+                    _Construct_expected_from_invoke_result_tag{}, _STD forward<_Fn>(_Func), _STD move(_Value)};
+            }
+        } else {
+            return expected<_Uty, _Err>{unexpect, _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Err, const _Err>
+    constexpr auto transform(_Fn&& _Func) const&& {
+        static_assert(invocable<_Fn, const _Ty>, "expected<T, E>::transform(F) requires that F is invocable with T. "
+                                                 "(N4950 [expected.object.monadic]/23)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Ty>>;
+
+        if constexpr (!is_void_v<_Uty>) {
+            static_assert(_Is_invoke_constructible<_Fn, const _Ty>,
+                "expected<T, E>::transform(F) requires that the return type of F is constructible with the result of "
+                "invoking f. (N4950 [expected.object.monadic]/23)");
+        }
+        static_assert(_Check_expected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            if constexpr (is_void_v<_Uty>) {
+                _STD invoke(_STD forward<_Fn>(_Func), _STD move(_Value));
+                return expected<_Uty, _Err>{};
+            } else {
+                return expected<_Uty, _Err>{
+                    _Construct_expected_from_invoke_result_tag{}, _STD forward<_Fn>(_Func), _STD move(_Value)};
+            }
+        } else {
+            return expected<_Uty, _Err>{unexpect, _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Ty, _Ty&>
+    constexpr auto transform_error(_Fn&& _Func) & {
+        static_assert(invocable<_Fn, _Err&>, "expected<T, E>::transform_error(F) requires that F is invocable with E. "
+                                             "(N4950 [expected.object.monadic]/27)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Err&>>;
+        static_assert(_Is_invoke_constructible<_Fn, _Err&>,
+            "expected<T, E>::transform_error(F) requires that the return type of F is constructible with the result of "
+            "invoking f. (N4950 [expected.object.monadic]/27)");
+
+        static_assert(_Check_unexpected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            return expected<_Ty, _Uty>{in_place, _Value};
+        } else {
+            return expected<_Ty, _Uty>{
+                _Construct_expected_from_invoke_result_tag{}, unexpect, _STD forward<_Fn>(_Func), _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_copy_constructible_v<_Ty>
+    constexpr auto transform_error(_Fn&& _Func) const& {
+        static_assert(invocable<_Fn, const _Err&>,
+            "expected<T, E>::transform_error(F) requires that F is invocable with E. "
+            "(N4950 [expected.object.monadic]/27)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Err&>>;
+        static_assert(_Is_invoke_constructible<_Fn, const _Err&>,
+            "expected<T, E>::transform_error(F) requires that the return type of F is constructible with the result of "
+            "invoking f. (N4950 [expected.object.monadic]/27)");
+
+        static_assert(_Check_unexpected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            return expected<_Ty, _Uty>{in_place, _Value};
+        } else {
+            return expected<_Ty, _Uty>{
+                _Construct_expected_from_invoke_result_tag{}, unexpect, _STD forward<_Fn>(_Func), _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_move_constructible_v<_Ty>
+    constexpr auto transform_error(_Fn&& _Func) && {
+        static_assert(invocable<_Fn, _Err>, "expected<T, E>::transform_error(F) requires that F is invocable with E. "
+                                            "(N4950 [expected.object.monadic]/31)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Err>>;
+        static_assert(_Is_invoke_constructible<_Fn, _Err>,
+            "expected<T, E>::transform_error(F) requires that the return type of F is constructible with the result of "
+            "invoking f. (N4950 [expected.object.monadic]/31)");
+
+        static_assert(_Check_unexpected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            return expected<_Ty, _Uty>{in_place, _STD move(_Value)};
+        } else {
+            return expected<_Ty, _Uty>{_Construct_expected_from_invoke_result_tag{}, unexpect, _STD forward<_Fn>(_Func),
+                _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Ty, const _Ty>
+    constexpr auto transform_error(_Fn&& _Func) const&& {
+        static_assert(invocable<_Fn, const _Err>,
+            "expected<T, E>::transform_error(F) requires that F is invocable with E. "
+            "(N4950 [expected.object.monadic]/31)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Err>>;
+        static_assert(_Is_invoke_constructible<_Fn, const _Err>,
+            "expected<T, E>::transform_error(F) requires that the return type of F is constructible with the result of "
+            "invoking f. (N4950 [expected.object.monadic]/31)");
+
+        static_assert(_Check_unexpected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            return expected<_Ty, _Uty>{in_place, _STD move(_Value)};
+        } else {
+            return expected<_Ty, _Uty>{_Construct_expected_from_invoke_result_tag{}, unexpect, _STD forward<_Fn>(_Func),
+                _STD move(_Unexpected)};
+        }
+    }
+
+    // [expected.object.eq]
+    template <class _Uty, class _UErr>
+        requires (!is_void_v<_Uty>)
+    _NODISCARD friend constexpr bool operator==(const expected& _Left, const expected<_Uty, _UErr>& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Value == *_Right))
+                 && noexcept(_STD _Fake_copy_init<bool>(_Left._Unexpected == _Right.error()))) /* strengthened */ {
+        if (_Left._Has_value != _Right.has_value()) {
+            return false;
+        } else if (_Left._Has_value) {
+            return _Left._Value == *_Right;
+        } else {
+            return _Left._Unexpected == _Right.error();
+        }
+    }
+
+    template <class _Uty>
+    _NODISCARD friend constexpr bool operator==(const expected& _Left, const _Uty& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Value == _Right))) /* strengthened */ {
+        if (_Left._Has_value) {
+            return _Left._Value == _Right;
+        } else {
+            return false;
+        }
+    }
+
+    template <class _UErr>
+    _NODISCARD friend constexpr bool operator==(const expected& _Left, const unexpected<_UErr>& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Unexpected == _Right.error()))) /* strengthened */ {
+        if (_Left._Has_value) {
+            return false;
+        } else {
+            return _Left._Unexpected == _Right.error();
+        }
+    }
+
+private:
+    // These overloads force copy elision from the invoke call into _Value
+    template <class _Fn, class _Ux>
+    constexpr expected(_Construct_expected_from_invoke_result_tag, _Fn&& _Func, _Ux&& _Arg)
+        noexcept(noexcept(static_cast<_Ty>(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg)))))
+        : _Value(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg))), _Has_value{true} {}
+
+    // For when transform is called on an expected<void, E> and requires calling _Func with no arg
+    template <class _Fn>
+    constexpr expected(_Construct_expected_from_invoke_result_tag, _Fn&& _Func)
+        noexcept(noexcept(static_cast<_Ty>(_STD forward<_Fn>(_Func)()))) // f() is equivalent to invoke(f)
+        : _Value(_STD forward<_Fn>(_Func)()), _Has_value{true} {} // f() is equivalent to invoke(f)
+
+    template <class _Fn, class _Ux>
+    constexpr expected(_Construct_expected_from_invoke_result_tag, unexpect_t, _Fn&& _Func, _Ux&& _Arg)
+        noexcept(noexcept(static_cast<_Err>(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg)))))
+        : _Unexpected(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg))), _Has_value{false} {}
+
+    [[noreturn]] void _Throw_bad_expected_access_lv() const {
+        _THROW(bad_expected_access{_Unexpected});
+    }
+    [[noreturn]] void _Throw_bad_expected_access_rv() const {
+        _THROW(bad_expected_access{_STD move(_Unexpected)});
+    }
+    [[noreturn]] void _Throw_bad_expected_access_rv() {
+        _THROW(bad_expected_access{_STD move(_Unexpected)});
+    }
+
+    union {
+        remove_cv_t<_Ty> _Value;
+        _Err _Unexpected;
+    };
+    bool _Has_value;
+};
+
+template <class _Err>
+concept _Expected_unary_copy_assignable = is_copy_assignable_v<_Err> && is_copy_constructible_v<_Err>;
+
+template <class _Err>
+concept _Expected_unary_move_assignable = is_move_assignable_v<_Err> && is_move_constructible_v<_Err>;
+
+template <class _Ty, class _Err>
+    requires is_void_v<_Ty>
+class _NODISCARD expected<_Ty, _Err> {
+private:
+    static_assert(_Check_unexpected_argument<_Err>::value);
+
+    template <class _UTy, class _UErr>
+    friend class expected;
+
+    template <class _Uty, class _UErr>
+    static constexpr bool _Allow_unwrapping = !is_constructible_v<unexpected<_Err>, expected<_Uty, _UErr>&>
+                                           && !is_constructible_v<unexpected<_Err>, expected<_Uty, _UErr>>
+                                           && !is_constructible_v<unexpected<_Err>, const expected<_Uty, _UErr>&>
+                                           && !is_constructible_v<unexpected<_Err>, const expected<_Uty, _UErr>>;
+
+public:
+    using value_type      = _Ty;
+    using error_type      = _Err;
+    using unexpected_type = unexpected<_Err>;
+
+    template <class _Uty>
+    using rebind = expected<_Uty, error_type>;
+
+    // [expected.void.cons]
+    constexpr expected() noexcept : _Has_value(true) {}
+
+    constexpr expected(const expected& _Other) noexcept(is_nothrow_copy_constructible_v<_Err>) // strengthened
+        requires (!is_trivially_copy_constructible_v<_Err> && is_copy_constructible_v<_Err>)
+        : _Has_value(_Other._Has_value) {
+        if (!_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _Other._Unexpected);
+        }
+    }
+
+    expected(const expected&)
+        requires is_trivially_copy_constructible_v<_Err>
+    = default;
+
+    expected(const expected&) = delete;
+
+    constexpr expected(expected&& _Other) noexcept(is_nothrow_move_constructible_v<_Err>)
+        requires (!is_trivially_move_constructible_v<_Err> && is_move_constructible_v<_Err>)
+        : _Has_value(_Other._Has_value) {
+        if (!_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _STD move(_Other._Unexpected));
+        }
+    }
+
+    expected(expected&&)
+        requires is_trivially_move_constructible_v<_Err>
+    = default;
+
+    template <class _Uty, class _UErr>
+        requires _Different_from<expected<_Uty, _UErr>, expected> && is_void_v<_Uty>
+              && is_constructible_v<_Err, const _UErr&> && _Allow_unwrapping<_Uty, _UErr>
+    constexpr explicit(!is_convertible_v<const _UErr&, _Err>) expected(const expected<_Uty, _UErr>& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, const _UErr&>) // strengthened
+        : _Has_value(_Other._Has_value) {
+        if (!_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _Other._Unexpected);
+        }
+    }
+
+    template <class _Uty, class _UErr>
+        requires _Different_from<expected<_Uty, _UErr>, expected> && is_void_v<_Uty> && is_constructible_v<_Err, _UErr>
+              && _Allow_unwrapping<_Uty, _UErr>
+    constexpr explicit(!is_convertible_v<_UErr, _Err>) expected(expected<_Uty, _UErr>&& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, _UErr>) // strengthened
+        : _Has_value(_Other._Has_value) {
+        if (!_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _STD move(_Other._Unexpected));
+        }
+    }
+
+    template <class _UErr>
+        requires is_constructible_v<_Err, const _UErr&>
+    constexpr explicit(!is_convertible_v<const _UErr&, _Err>) expected(const unexpected<_UErr>& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, const _UErr&>) // strengthened
+        : _Unexpected(_Other._Unexpected), _Has_value(false) {}
+
+    template <class _UErr>
+        requires is_constructible_v<_Err, _UErr>
+    constexpr explicit(!is_convertible_v<_UErr, _Err>) expected(unexpected<_UErr>&& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, _UErr>) // strengthened
+        : _Unexpected(_STD move(_Other._Unexpected)), _Has_value(false) {}
+
+    constexpr explicit expected(in_place_t) noexcept : _Has_value(true) {}
+
+    template <class... _Args>
+        requires is_constructible_v<_Err, _Args...>
+    constexpr explicit expected(unexpect_t, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened
+        : _Unexpected(_STD forward<_Args>(_Vals)...), _Has_value(false) {}
+
+    template <class _Uty, class... _Args>
+        requires is_constructible_v<_Err, initializer_list<_Uty>&, _Args...>
+    constexpr explicit expected(unexpect_t, initializer_list<_Uty> _Ilist, _Args&&... _Vals)
+        noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Uty>&, _Args...>) // strengthened
+        : _Unexpected(_Ilist, _STD forward<_Args>(_Vals)...), _Has_value(false) {}
+
+    // [expected.void.dtor]
+    constexpr ~expected()
+#ifndef __clang__ // TRANSITION, LLVM-59854
+        noexcept
+#endif // ^^^ no workaround ^^^
+    {
+        if (!_Has_value) {
+            _Unexpected.~_Err();
+        }
+    }
+
+    ~expected()
+        requires is_trivially_destructible_v<_Err>
+    = default;
+
+    // [expected.void.assign]
+    constexpr expected& operator=(const expected& _Other)
+        noexcept(is_nothrow_copy_constructible_v<_Err> && is_nothrow_copy_assignable_v<_Err>) // strengthened
+        requires _Expected_unary_copy_assignable<_Err>
+    {
+        if (_Has_value && _Other._Has_value) {
+            // nothing to do
+        } else if (_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _Other._Unexpected);
+            _Has_value = false;
+        } else if (_Other._Has_value) {
+            if constexpr (!is_trivially_destructible_v<_Err>) {
+                _Unexpected.~_Err();
+            }
+            _Has_value = true;
+        } else {
+            _Unexpected = _Other._Unexpected;
+        }
+
+        return *this;
+    }
+
+    expected& operator=(const expected&)
+        requires _Expected_unary_copy_assignable<_Err> && _Trivially_copy_constructible_assignable_destructible<_Err>
+    = default;
+
+    expected& operator=(const expected&) = delete;
+
+    constexpr expected& operator=(expected&& _Other)
+        noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_move_assignable_v<_Err>)
+        requires _Expected_unary_move_assignable<_Err>
+    {
+        if (_Has_value && _Other._Has_value) {
+            // nothing to do
+        } else if (_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _STD move(_Other._Unexpected));
+            _Has_value = false;
+        } else if (_Other._Has_value) {
+            if constexpr (!is_trivially_destructible_v<_Err>) {
+                _Unexpected.~_Err();
+            }
+            _Has_value = true;
+        } else {
+            _Unexpected = _STD move(_Other._Unexpected);
+        }
+
+        return *this;
+    }
+
+    expected& operator=(expected&&)
+        requires _Expected_unary_move_assignable<_Err> && _Trivially_move_constructible_assignable_destructible<_Err>
+    = default;
+
+    template <class _UErr>
+        requires is_constructible_v<_Err, const _UErr&> && is_assignable_v<_Err&, const _UErr&>
+    constexpr expected& operator=(const unexpected<_UErr>& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, const _UErr&>
+                 && is_nothrow_assignable_v<_Err&, const _UErr&>) /* strengthened */ {
+        if (_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _Other._Unexpected);
+            _Has_value = false;
+        } else {
+            _Unexpected = _Other._Unexpected;
+        }
+
+        return *this;
+    }
+
+    template <class _UErr>
+        requires is_constructible_v<_Err, _UErr> && is_assignable_v<_Err&, _UErr>
+    constexpr expected& operator=(unexpected<_UErr>&& _Other)
+        noexcept(is_nothrow_constructible_v<_Err, _UErr> && is_nothrow_assignable_v<_Err&, _UErr>) /* strengthened */ {
+        if (_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _STD move(_Other._Unexpected));
+            _Has_value = false;
+        } else {
+            _Unexpected = _STD move(_Other._Unexpected);
+        }
+
+        return *this;
+    }
+
+    constexpr void emplace() noexcept {
+        if (!_Has_value) {
+            if constexpr (!is_trivially_destructible_v<_Err>) {
+                _Unexpected.~_Err();
+            }
+            _Has_value = true;
+        }
+    }
+
+    // [expected.void.swap]
+    constexpr void swap(expected& _Other)
+        noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
+        requires is_swappable_v<_Err> && is_move_constructible_v<_Err>
+    {
+        using _STD swap;
+        if (_Has_value && _Other._Has_value) {
+            // nothing
+        } else if (_Has_value) {
+            _STD construct_at(_STD addressof(_Unexpected), _STD move(_Other._Unexpected));
+            if constexpr (!is_trivially_destructible_v<_Err>) {
+                _Other._Unexpected.~_Err();
+            }
+            _Has_value        = false;
+            _Other._Has_value = true;
+        } else if (_Other._Has_value) {
+            _STD construct_at(_STD addressof(_Other._Unexpected), _STD move(_Unexpected));
+            if constexpr (!is_trivially_destructible_v<_Err>) {
+                _Unexpected.~_Err();
+            }
+            _Has_value        = true;
+            _Other._Has_value = false;
+        } else {
+            swap(_Unexpected, _Other._Unexpected); // intentional ADL
+        }
+    }
+
+    friend constexpr void swap(expected& _Left, expected& _Right)
+        noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, /permissive
+        requires is_swappable_v<_Err>
+#else // ^^^ no workaround / workaround vvv
+        requires is_swappable<_Err>::value
+#endif // ^^^ workaround ^^^
+              && is_move_constructible_v<_Err>
+    {
+        _Left.swap(_Right);
+    }
+
+    // [expected.void.obs]
+    _NODISCARD constexpr explicit operator bool() const noexcept {
+        return _Has_value;
+    }
+    _NODISCARD constexpr bool has_value() const noexcept {
+        return _Has_value;
+    }
+
+    constexpr void operator*() const noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Has_value, "operator*() called on a std::expected that contains an error, not a value");
+#endif
+    }
+
+    constexpr void value() const& {
+        if (!_Has_value) {
+            _Throw_bad_expected_access_lv();
+        }
+    }
+    constexpr void value() && {
+        // TRANSITION, DevCom-1638273 and LLVM-53224
+        static_assert(is_copy_constructible_v<_Err>, "is_copy_constructible_v<E> must be true");
+        static_assert(is_move_constructible_v<_Err>, "is_move_constructible_v<E> must be true");
+
+        if (!_Has_value) {
+            _Throw_bad_expected_access_rv();
+        }
+    }
+
+    _NODISCARD constexpr const _Err& error() const& noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!_Has_value, "error() called on a std::expected that contains a value, not an error");
+#endif
+
+        return _Unexpected;
+    }
+    _NODISCARD constexpr _Err& error() & noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!_Has_value, "error() called on a std::expected that contains a value, not an error");
+#endif
+
+        return _Unexpected;
+    }
+    _NODISCARD constexpr const _Err&& error() const&& noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!_Has_value, "error() called on a std::expected that contains a value, not an error");
+#endif
+
+        return _STD move(_Unexpected);
+    }
+    _NODISCARD constexpr _Err&& error() && noexcept {
+#if _MSVC_STL_HARDENING_EXPECTED || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(!_Has_value, "error() called on a std::expected that contains a value, not an error");
+#endif
+
+        return _STD move(_Unexpected);
+    }
+
+    template <class _Uty = _Err>
+    _NODISCARD constexpr _Err error_or(_Uty&& _Other) const& noexcept(
+        is_nothrow_copy_constructible_v<_Err> && is_nothrow_convertible_v<_Uty, _Err>) /* strengthened */ {
+        static_assert(
+            is_copy_constructible_v<_Err>, "is_copy_constructible_v<E> must be true. (N4950 [expected.void.obs]/9)");
+        static_assert(
+            is_convertible_v<_Uty, _Err>, "is_convertible_v<G, E> must be true. (N4950 [expected.void.obs]/9)");
+
+        if (_Has_value) {
+            return _STD forward<_Uty>(_Other);
+        } else {
+            return _Unexpected;
+        }
+    }
+
+    template <class _Uty = _Err>
+    _NODISCARD constexpr _Err error_or(_Uty&& _Other) && noexcept(
+        is_nothrow_move_constructible_v<_Err> && is_nothrow_convertible_v<_Uty, _Err>) /* strengthened */ {
+        static_assert(
+            is_move_constructible_v<_Err>, "is_move_constructible_v<E> must be true. (N4950 [expected.void.obs]/11)");
+        static_assert(
+            is_convertible_v<_Uty, _Err>, "is_convertible_v<G, E> must be true. (N4950 [expected.void.obs]/11)");
+
+        if (_Has_value) {
+            return _STD forward<_Uty>(_Other);
+        } else {
+            return _STD move(_Unexpected);
+        }
+    }
+
+    // [expected.void.monadic]
+    template <class _Fn>
+        requires is_constructible_v<_Err, _Err&>
+    constexpr auto and_then(_Fn&& _Func) & {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<void, E>::and_then(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.void.monadic]/3)");
+        static_assert(is_same_v<typename _Uty::error_type, _Err>,
+            "expected<void, E>::and_then(F) requires the error type of the return type of F to be E. "
+            "(N4950 [expected.void.monadic]/3)");
+
+        if (_Has_value) {
+            return _STD forward<_Fn>(_Func)(); // f() is equivalent to invoke(f)
+        } else {
+            return _Uty{unexpect, _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_copy_constructible_v<_Err>
+    constexpr auto and_then(_Fn&& _Func) const& {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<void, E>::and_then(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.void.monadic]/3)");
+        static_assert(is_same_v<typename _Uty::error_type, _Err>,
+            "expected<void, E>::and_then(F) requires the error type of the return type of F to be E. "
+            "(N4950 [expected.void.monadic]/3)");
+
+        if (_Has_value) {
+            return _STD forward<_Fn>(_Func)(); // f() is equivalent to invoke(f)
+        } else {
+            return _Uty{unexpect, _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_move_constructible_v<_Err>
+    constexpr auto and_then(_Fn&& _Func) && {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<void, E>::and_then(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.void.monadic]/7)");
+        static_assert(is_same_v<typename _Uty::error_type, _Err>,
+            "expected<void, E>::and_then(F) requires the error type of the return type of F to be E. "
+            "(N4950 [expected.void.monadic]/7)");
+
+        if (_Has_value) {
+            return _STD forward<_Fn>(_Func)(); // f() is equivalent to invoke(f)
+        } else {
+            return _Uty{unexpect, _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Err, const _Err>
+    constexpr auto and_then(_Fn&& _Func) const&& {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<void, E>::and_then(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.void.monadic]/7)");
+        static_assert(is_same_v<typename _Uty::error_type, _Err>,
+            "expected<void, E>::and_then(F) requires the error type of the return type of F to be E. "
+            "(N4950 [expected.void.monadic]/7)");
+
+        if (_Has_value) {
+            return _STD forward<_Fn>(_Func)(); // f() is equivalent to invoke(f)
+        } else {
+            return _Uty{unexpect, _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto or_else(_Fn&& _Func) & {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, _Err&>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<void, E>::or_else(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.void.monadic]/10)");
+        static_assert(is_same_v<typename _Uty::value_type, _Ty>,
+            "expected<void, E>::or_else(F) requires the value type of the return type of F to be T. "
+            "(N4950 [expected.void.monadic]/10)");
+
+        if (_Has_value) {
+            return _Uty{};
+        } else {
+            return _STD invoke(_STD forward<_Fn>(_Func), _Unexpected);
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto or_else(_Fn&& _Func) const& {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, const _Err&>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<void, E>::or_else(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.void.monadic]/10)");
+        static_assert(is_same_v<typename _Uty::value_type, _Ty>,
+            "expected<void, E>::or_else(F) requires the value type of the return type of F to be T. "
+            "(N4950 [expected.void.monadic]/10)");
+
+        if (_Has_value) {
+            return _Uty{};
+        } else {
+            return _STD invoke(_STD forward<_Fn>(_Func), _Unexpected);
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto or_else(_Fn&& _Func) && {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, _Err>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<void, E>::or_else(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.void.monadic]/13)");
+        static_assert(is_same_v<typename _Uty::value_type, _Ty>,
+            "expected<void, E>::or_else(F) requires the value type of the return type of F to be T. "
+            "(N4950 [expected.void.monadic]/13)");
+
+        if (_Has_value) {
+            return _Uty{};
+        } else {
+            return _STD invoke(_STD forward<_Fn>(_Func), _STD move(_Unexpected));
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto or_else(_Fn&& _Func) const&& {
+        using _Uty = remove_cvref_t<invoke_result_t<_Fn, const _Err>>;
+
+        static_assert(_Is_specialization_v<_Uty, expected>,
+            "expected<void, E>::or_else(F) requires the return type of F to be a specialization of expected. "
+            "(N4950 [expected.void.monadic]/13)");
+        static_assert(is_same_v<typename _Uty::value_type, _Ty>,
+            "expected<void, E>::or_else(F) requires the value type of the return type of F to be T. "
+            "(N4950 [expected.void.monadic]/13)");
+
+        if (_Has_value) {
+            return _Uty{};
+        } else {
+            return _STD invoke(_STD forward<_Fn>(_Func), _STD move(_Unexpected));
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Err, _Err&>
+    constexpr auto transform(_Fn&& _Func) & {
+        static_assert(invocable<_Fn>, "expected<void, E>::transform(F) requires that F is invocable with no arguments. "
+                                      "(N4950 [expected.void.monadic]/17)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn>>;
+
+        if constexpr (!is_void_v<_Uty>) {
+            static_assert(_Is_invoke_constructible<_Fn>, "expected<void, E>::transform(F) requires that the return "
+                                                         "type of F is constructible with the result of "
+                                                         "invoking f. (N4950 [expected.void.monadic]/17)");
+        }
+        static_assert(_Check_expected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            if constexpr (is_void_v<_Uty>) {
+                _STD forward<_Fn>(_Func)(); // f() is equivalent to invoke(f)
+                return expected<_Uty, _Err>{};
+            } else {
+                return expected<_Uty, _Err>{_Construct_expected_from_invoke_result_tag{}, _STD forward<_Fn>(_Func)};
+            }
+        } else {
+            return expected<_Uty, _Err>{unexpect, _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_copy_constructible_v<_Err>
+    constexpr auto transform(_Fn&& _Func) const& {
+        static_assert(invocable<_Fn>, "expected<void, E>::transform(F) requires that F is invocable with no arguments. "
+                                      "(N4950 [expected.void.monadic]/17)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn>>;
+
+        if constexpr (!is_void_v<_Uty>) {
+            static_assert(_Is_invoke_constructible<_Fn>, "expected<void, E>::transform(F) requires that the return "
+                                                         "type of F is constructible with the result of "
+                                                         "invoking f. (N4950 [expected.void.monadic]/17)");
+        }
+        static_assert(_Check_expected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            if constexpr (is_void_v<_Uty>) {
+                _STD forward<_Fn>(_Func)(); // f() is equivalent to invoke(f)
+                return expected<_Uty, _Err>{};
+            } else {
+                return expected<_Uty, _Err>{_Construct_expected_from_invoke_result_tag{}, _STD forward<_Fn>(_Func)};
+            }
+        } else {
+            return expected<_Uty, _Err>{unexpect, _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+        requires is_move_constructible_v<_Err>
+    constexpr auto transform(_Fn&& _Func) && {
+        static_assert(invocable<_Fn>, "expected<void, E>::transform(F) requires that F is invocable with no arguments. "
+                                      "(N4950 [expected.void.monadic]/21)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn>>;
+
+        if constexpr (!is_void_v<_Uty>) {
+            static_assert(_Is_invoke_constructible<_Fn>, "expected<void, E>::transform(F) requires that the return "
+                                                         "type of F is constructible with the result of "
+                                                         "invoking f. (N4950 [expected.void.monadic]/21)");
+        }
+        static_assert(_Check_expected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            if constexpr (is_void_v<_Uty>) {
+                _STD forward<_Fn>(_Func)(); // f() is equivalent to invoke(f)
+                return expected<_Uty, _Err>{};
+            } else {
+                return expected<_Uty, _Err>{_Construct_expected_from_invoke_result_tag{}, _STD forward<_Fn>(_Func)};
+            }
+        } else {
+            return expected<_Uty, _Err>{unexpect, _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<_Err, const _Err>
+    constexpr auto transform(_Fn&& _Func) const&& {
+        static_assert(invocable<_Fn>, "expected<void, E>::transform(F) requires that F is invocable with no arguments. "
+                                      "(N4950 [expected.void.monadic]/21)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn>>;
+
+        if constexpr (!is_void_v<_Uty>) {
+            static_assert(_Is_invoke_constructible<_Fn>, "expected<void, E>::transform(F) requires that the return "
+                                                         "type of F is constructible with the result of "
+                                                         "invoking f. (N4950 [expected.void.monadic]/21)");
+        }
+        static_assert(_Check_expected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            if constexpr (is_void_v<_Uty>) {
+                _STD forward<_Fn>(_Func)(); // f() is equivalent to invoke(f)
+                return expected<_Uty, _Err>{};
+            } else {
+                return expected<_Uty, _Err>{_Construct_expected_from_invoke_result_tag{}, _STD forward<_Fn>(_Func)};
+            }
+        } else {
+            return expected<_Uty, _Err>{unexpect, _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto transform_error(_Fn&& _Func) & {
+        static_assert(invocable<_Fn, _Err&>,
+            "expected<void, E>::transform_error(F) requires that F is invocable with E. "
+            "(N4950 [expected.void.monadic]/24)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Err&>>;
+        static_assert(_Is_invoke_constructible<_Fn, _Err&>, "expected<void, E>::transform_error(F) requires that the "
+                                                            "return type of F is constructible with the result of "
+                                                            "invoking f. (N4950 [expected.void.monadic]/24)");
+
+        static_assert(_Check_unexpected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            return expected<_Ty, _Uty>{};
+        } else {
+            return expected<_Ty, _Uty>{
+                _Construct_expected_from_invoke_result_tag{}, unexpect, _STD forward<_Fn>(_Func), _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto transform_error(_Fn&& _Func) const& {
+        static_assert(invocable<_Fn, const _Err&>,
+            "expected<void, E>::transform_error(F) requires that F is invocable with E. "
+            "(N4950 [expected.void.monadic]/24)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Err&>>;
+        static_assert(_Is_invoke_constructible<_Fn, const _Err&>,
+            "expected<void, E>::transform_error(F) requires that the "
+            "return type of F is constructible with the result of "
+            "invoking f. (N4950 [expected.void.monadic]/24)");
+
+        static_assert(_Check_unexpected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            return expected<_Ty, _Uty>{};
+        } else {
+            return expected<_Ty, _Uty>{
+                _Construct_expected_from_invoke_result_tag{}, unexpect, _STD forward<_Fn>(_Func), _Unexpected};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto transform_error(_Fn&& _Func) && {
+        static_assert(invocable<_Fn, _Err>,
+            "expected<void, E>::transform_error(F) requires that F is invocable with E. "
+            "(N4950 [expected.void.monadic]/27)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Err>>;
+        static_assert(_Is_invoke_constructible<_Fn, _Err>, "expected<void, E>::transform_error(F) requires that the "
+                                                           "return type of F is constructible with the result of "
+                                                           "invoking f. (N4950 [expected.void.monadic]/27)");
+
+        static_assert(_Check_unexpected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            return expected<_Ty, _Uty>{};
+        } else {
+            return expected<_Ty, _Uty>{_Construct_expected_from_invoke_result_tag{}, unexpect, _STD forward<_Fn>(_Func),
+                _STD move(_Unexpected)};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto transform_error(_Fn&& _Func) const&& {
+        static_assert(invocable<_Fn, const _Err>,
+            "expected<void, E>::transform_error(F) requires that F is invocable with E. "
+            "(N4950 [expected.void.monadic]/27)");
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Err>>;
+        static_assert(_Is_invoke_constructible<_Fn, const _Err>,
+            "expected<void, E>::transform_error(F) requires that the "
+            "return type of F is constructible with the result of "
+            "invoking f. (N4950 [expected.void.monadic]/27)");
+
+        static_assert(_Check_unexpected_argument<_Uty>::value);
+
+        if (_Has_value) {
+            return expected<_Ty, _Uty>{};
+        } else {
+            return expected<_Ty, _Uty>{_Construct_expected_from_invoke_result_tag{}, unexpect, _STD forward<_Fn>(_Func),
+                _STD move(_Unexpected)};
+        }
+    }
+
+    // [expected.void.eq]
+    template <class _Uty, class _UErr>
+        requires is_void_v<_Uty>
+    _NODISCARD friend constexpr bool operator==(const expected& _Left, const expected<_Uty, _UErr>& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Unexpected == _Right.error()))) /* strengthened */ {
+        if (_Left._Has_value != _Right.has_value()) {
+            return false;
+        } else {
+            if (_Left._Has_value) {
+                return true;
+            } else {
+                return _Left._Unexpected == _Right.error();
+            }
+        }
+    }
+
+    template <class _UErr>
+    _NODISCARD friend constexpr bool operator==(const expected& _Left, const unexpected<_UErr>& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Unexpected == _Right.error()))) /* strengthened */ {
+        if (_Left._Has_value) {
+            return false;
+        } else {
+            return _Left._Unexpected == _Right.error();
+        }
+    }
+
+private:
+    template <class _Fn, class _Ux>
+    constexpr expected(_Construct_expected_from_invoke_result_tag, unexpect_t, _Fn&& _Func, _Ux&& _Arg)
+        noexcept(noexcept(_Err(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg)))))
+        : _Unexpected(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg))), _Has_value{false} {}
+
+    [[noreturn]] void _Throw_bad_expected_access_lv() const {
+        _THROW(bad_expected_access{_Unexpected});
+    }
+    [[noreturn]] void _Throw_bad_expected_access_rv() {
+        _THROW(bad_expected_access{_STD move(_Unexpected)});
+    }
+
+    union {
+        _Err _Unexpected;
+    };
+    bool _Has_value;
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX23 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _EXPECTED_
diff --git a/msvc-stl/stl/inc/experimental/coroutine b/msvc-stl/stl/inc/experimental/coroutine
new file mode 100644
index 0000000..1ae46b7
--- /dev/null
+++ b/msvc-stl/stl/inc/experimental/coroutine
@@ -0,0 +1,296 @@
+// coroutine experimental header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Library support of coroutines TS, https://wg21.link/p0057
+
+#ifndef _EXPERIMENTAL_COROUTINE_
+#define _EXPERIMENTAL_COROUTINE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdint>
+#include <memory>
+#include <new>
+#include <type_traits>
+
+#if _HAS_EXCEPTIONS
+#include <exception>
+#endif
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#ifdef __clang__
+_EMIT_STL_ERROR(STL1009, "The <experimental/coroutine>, <experimental/generator>, and <experimental/resumable> "
+                         "headers do not support Clang, but the C++20 <coroutine> and C++23 <generator> headers do.");
+#elif defined(__cpp_impl_coroutine)
+_EMIT_STL_ERROR(STL1010, "You're compiling with support for standard C++20 coroutines "
+                         "(also available with /await:strict in C++14/17), so you should include <coroutine> "
+                         "instead of <experimental/coroutine> and <experimental/resumable>.");
+#elif !defined(_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS)
+_EMIT_STL_ERROR(STL1011, "The /await compiler option, <experimental/coroutine>, <experimental/generator>, and "
+                         "<experimental/resumable> are deprecated by Microsoft and will be REMOVED SOON. "
+                         "They are superseded by the C++20 <coroutine> and C++23 <generator> headers. You can define "
+                         "_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS to suppress this error for now.");
+#endif // _SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS
+
+// intrinsics used in implementation of coroutine_handle
+extern "C" size_t _coro_resume(void*) noexcept;
+extern "C" void _coro_destroy(void*) noexcept;
+extern "C" size_t _coro_done(void*) noexcept;
+#pragma intrinsic(_coro_resume)
+#pragma intrinsic(_coro_destroy)
+#pragma intrinsic(_coro_done)
+
+#ifndef _ALLOW_COROUTINE_ABI_MISMATCH
+#pragma detect_mismatch("_COROUTINE_ABI", "1")
+#endif // _ALLOW_COROUTINE_ABI_MISMATCH
+
+_STD_BEGIN
+
+namespace experimental {
+
+    template <class _Ret, class = void>
+    struct _Coroutine_traits_sfinae {};
+
+    template <class _Ret>
+    struct _Coroutine_traits_sfinae<_Ret, void_t<typename _Ret::promise_type>> {
+        using promise_type = typename _Ret::promise_type;
+    };
+
+    template <class _Ret, class... _Ts>
+    struct coroutine_traits : _Coroutine_traits_sfinae<_Ret> {};
+
+    template <class _PromiseT = void>
+    struct coroutine_handle;
+
+    template <>
+    struct coroutine_handle<void> { // no promise access
+        coroutine_handle() noexcept {}
+
+        coroutine_handle(nullptr_t) noexcept {}
+
+        coroutine_handle& operator=(nullptr_t) noexcept {
+            _Ptr = nullptr;
+            return *this;
+        }
+
+        static coroutine_handle from_address(void* _Addr) noexcept {
+            coroutine_handle _Result;
+            _Result._Ptr = static_cast<_Resumable_frame_prefix*>(_Addr);
+            return _Result;
+        }
+
+        void* address() const noexcept {
+            return _Ptr;
+        }
+
+        [[deprecated("coroutine_handle::to_address() is deprecated. "
+                     "Use coroutine_handle::address() instead.")]] void*
+            to_address() const noexcept {
+            return _Ptr;
+        }
+
+        void operator()() const {
+            resume();
+        }
+
+        explicit operator bool() const noexcept {
+            return _Ptr != nullptr;
+        }
+
+        void resume() const {
+            _coro_resume(_Ptr);
+        }
+
+        void destroy() {
+            _coro_destroy(_Ptr);
+        }
+
+        bool done() const {
+            // REVISIT: should return _coro_done() == 0; when intrinsic is
+            // hooked up
+            return _Ptr->_Index == 0;
+        }
+
+        struct _Resumable_frame_prefix {
+            using _Resume_fn = void(__cdecl*)(void*);
+
+            _Resume_fn _Fn;
+            uint16_t _Index;
+            uint16_t _Flags;
+        };
+
+    protected:
+        _Resumable_frame_prefix* _Ptr = nullptr;
+    };
+
+    template <class _PromiseT>
+    struct coroutine_handle : coroutine_handle<> { // general form
+        using coroutine_handle<>::coroutine_handle;
+
+        [[deprecated("coroutine_handle::from_promise(T*) with pointer parameter is deprecated. "
+                     "Use coroutine_handle::from_promise(T&) instead.")]] static coroutine_handle
+            from_promise(_PromiseT* _Prom) noexcept {
+            return from_promise(*_Prom);
+        }
+
+        static coroutine_handle from_promise(_PromiseT& _Prom) noexcept {
+            auto _FramePtr = reinterpret_cast<char*>(_STD addressof(_Prom)) + _ALIGNED_SIZE;
+            coroutine_handle<_PromiseT> _Result;
+            _Result._Ptr = reinterpret_cast<_Resumable_frame_prefix*>(_FramePtr);
+            return _Result;
+        }
+
+        static coroutine_handle from_address(void* _Addr) noexcept {
+            coroutine_handle _Result;
+            _Result._Ptr = static_cast<_Resumable_frame_prefix*>(_Addr);
+            return _Result;
+        }
+
+        coroutine_handle& operator=(nullptr_t) noexcept {
+            _Ptr = nullptr;
+            return *this;
+        }
+
+        static const size_t _ALIGN_REQ = sizeof(void*) * 2;
+
+        static const size_t _ALIGNED_SIZE =
+            is_empty_v<_PromiseT> ? 0 : ((sizeof(_PromiseT) + _ALIGN_REQ - 1) & ~(_ALIGN_REQ - 1));
+
+        _PromiseT& promise() const noexcept {
+            return *const_cast<_PromiseT*>(
+                reinterpret_cast<const _PromiseT*>(reinterpret_cast<const char*>(_Ptr) - _ALIGNED_SIZE));
+        }
+    };
+
+    _NODISCARD inline bool operator==(coroutine_handle<> _Left, coroutine_handle<> _Right) noexcept {
+        return _Left.address() == _Right.address();
+    }
+
+    _NODISCARD inline bool operator<(coroutine_handle<> _Left, coroutine_handle<> _Right) noexcept {
+        return less<void*>()(_Left.address(), _Right.address());
+    }
+
+    _NODISCARD inline bool operator!=(coroutine_handle<> _Left, coroutine_handle<> _Right) noexcept {
+        return !(_Left == _Right);
+    }
+
+    _NODISCARD inline bool operator>(coroutine_handle<> _Left, coroutine_handle<> _Right) noexcept {
+        return _Right < _Left;
+    }
+
+    _NODISCARD inline bool operator<=(coroutine_handle<> _Left, coroutine_handle<> _Right) noexcept {
+        return !(_Left > _Right);
+    }
+
+    _NODISCARD inline bool operator>=(coroutine_handle<> _Left, coroutine_handle<> _Right) noexcept {
+        return !(_Left < _Right);
+    }
+
+    struct suspend_if {
+        bool _Ready;
+
+        explicit suspend_if(bool _Condition) noexcept : _Ready(!_Condition) {}
+
+        bool await_ready() noexcept {
+            return _Ready;
+        }
+
+        void await_suspend(coroutine_handle<>) noexcept {}
+
+        void await_resume() noexcept {}
+    };
+
+    struct suspend_always {
+        bool await_ready() noexcept {
+            return false;
+        }
+
+        void await_suspend(coroutine_handle<>) noexcept {}
+
+        void await_resume() noexcept {}
+    };
+
+    struct suspend_never {
+        bool await_ready() noexcept {
+            return true;
+        }
+
+        void await_suspend(coroutine_handle<>) noexcept {}
+
+        void await_resume() noexcept {}
+    };
+
+    // _Resumable_helper_traits class isolates front-end from public surface
+    // naming changes
+
+    template <class _Ret, class... _Ts>
+    struct _Resumable_helper_traits {
+        using _Traits      = coroutine_traits<_Ret, _Ts...>;
+        using _PromiseT    = typename _Traits::promise_type;
+        using _Handle_type = coroutine_handle<_PromiseT>;
+
+        static _PromiseT* _Promise_from_frame(void* _Addr) noexcept {
+            return reinterpret_cast<_PromiseT*>(reinterpret_cast<char*>(_Addr) - _Handle_type::_ALIGNED_SIZE);
+        }
+
+        static _Handle_type _Handle_from_frame(void* _Addr) noexcept {
+            return _Handle_type::from_promise(*_Promise_from_frame(_Addr));
+        }
+
+        static void _Set_exception(void* _Addr) {
+            _Promise_from_frame(_Addr)->set_exception(_STD current_exception());
+        }
+
+        static void _ConstructPromise(void* _Addr, void* _Resume_addr, int _HeapElision) {
+            *reinterpret_cast<void**>(_Addr) = _Resume_addr;
+            *reinterpret_cast<uint32_t*>(reinterpret_cast<uintptr_t>(_Addr) + sizeof(void*)) =
+                2u + (_HeapElision ? 0u : 0x10000u);
+            auto _Prom = _Promise_from_frame(_Addr);
+            ::new (static_cast<void*>(_Prom)) _PromiseT();
+        }
+
+        static void _DestructPromise(void* _Addr) {
+            _Promise_from_frame(_Addr)->~_PromiseT();
+        }
+    };
+} // namespace experimental
+
+_STD_END
+
+// resumable functions support intrinsics
+
+extern "C" size_t _coro_frame_size() noexcept;
+extern "C" void* _coro_frame_ptr() noexcept;
+extern "C" void _coro_init_block() noexcept;
+extern "C" void* _coro_resume_addr() noexcept;
+extern "C" void _coro_init_frame(void*) noexcept;
+extern "C" void _coro_save(size_t) noexcept;
+extern "C" void _coro_suspend(size_t) noexcept;
+extern "C" void _coro_cancel() noexcept;
+extern "C" void _coro_resume_block() noexcept;
+
+#pragma intrinsic(_coro_frame_size)
+#pragma intrinsic(_coro_frame_ptr)
+#pragma intrinsic(_coro_init_block)
+#pragma intrinsic(_coro_resume_addr)
+#pragma intrinsic(_coro_init_frame)
+#pragma intrinsic(_coro_save)
+#pragma intrinsic(_coro_suspend)
+#pragma intrinsic(_coro_cancel)
+#pragma intrinsic(_coro_resume_block)
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _EXPERIMENTAL_COROUTINE_
diff --git a/msvc-stl/stl/inc/experimental/generator b/msvc-stl/stl/inc/experimental/generator
new file mode 100644
index 0000000..aa03c72
--- /dev/null
+++ b/msvc-stl/stl/inc/experimental/generator
@@ -0,0 +1,212 @@
+// generator experimental header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _EXPERIMENTAL_GENERATOR_
+#define _EXPERIMENTAL_GENERATOR_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _CPPUNWIND
+#include <exception>
+#endif
+
+#include <memory>
+
+#ifdef __clang__
+_EMIT_STL_ERROR(STL1009, "The <experimental/coroutine>, <experimental/generator>, and <experimental/resumable> "
+                         "headers do not support Clang, but the C++20 <coroutine> and C++23 <generator> headers do.");
+#elif !defined(_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS)
+_EMIT_STL_ERROR(STL1011, "The /await compiler option, <experimental/coroutine>, <experimental/generator>, and "
+                         "<experimental/resumable> are deprecated by Microsoft and will be REMOVED SOON. "
+                         "They are superseded by the C++20 <coroutine> and C++23 <generator> headers. You can define "
+                         "_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS to suppress this error for now.");
+#elif defined(__cpp_impl_coroutine)
+#include <coroutine>
+#elif defined(__cpp_coroutines)
+#include <experimental/resumable>
+#else // ^^^ legacy coroutines / no coroutine support vvv
+_EMIT_STL_ERROR(STL1012, "You've included the <experimental/generator> header without compiler support for "
+                         "legacy coroutines (available with the deprecated /await compiler option) or "
+                         "standard C++20 coroutines (also available with /await:strict in C++14/17). "
+                         "You should include C++23 <generator> instead of <experimental/generator>.");
+#endif // ^^^ no coroutine support ^^^
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+namespace experimental {
+    // NOTE WELL: _CPPUNWIND currently affects the ABI of generator.
+    template <class _Ty, class _Alloc = allocator<char>>
+    struct generator {
+        struct promise_type {
+            const _Ty* _Value;
+#ifdef _CPPUNWIND
+            exception_ptr _Exception;
+#endif // defined(_CPPUNWIND)
+
+            generator get_return_object() noexcept {
+                return generator{*this};
+            }
+
+            suspend_always initial_suspend() noexcept {
+                return {};
+            }
+
+            suspend_always final_suspend() noexcept {
+                return {};
+            }
+
+#ifndef _KERNEL_MODE
+#ifdef _CPPUNWIND
+            void unhandled_exception() noexcept {
+                _Exception = _STD current_exception();
+            }
+#else // ^^^ defined(_CPPUNWIND) / !defined(_CPPUNWIND) vvv
+            void unhandled_exception() noexcept {}
+#endif // ^^^ !defined(_CPPUNWIND) ^^^
+#endif // !defined(_KERNEL_MODE)
+
+#ifdef _CPPUNWIND
+            void _Rethrow_if_exception() {
+                if (_Exception) {
+                    _STD rethrow_exception(_Exception);
+                }
+            }
+#endif // defined(_CPPUNWIND)
+
+            suspend_always yield_value(const _Ty& _Val) noexcept {
+                _Value = _STD addressof(_Val);
+                return {};
+            }
+
+            void return_void() noexcept {}
+
+            template <class _Uty>
+            _Uty&& await_transform(_Uty&& _Whatever) {
+                static_assert(false, "co_await is not supported in coroutines of type std::experimental::generator");
+                return _STD forward<_Uty>(_Whatever);
+            }
+
+            using _Alloc_char = _Rebind_alloc_t<_Alloc, char>;
+            static_assert(is_same_v<char*, typename allocator_traits<_Alloc_char>::pointer>,
+                "generator does not support allocators with fancy pointer types");
+            static_assert(
+                allocator_traits<_Alloc_char>::is_always_equal::value && is_default_constructible_v<_Alloc_char>,
+                "generator supports only stateless allocators");
+
+            static void* operator new(size_t _Size) {
+                _Alloc_char _Al{};
+                return allocator_traits<_Alloc_char>::allocate(_Al, _Size);
+            }
+
+            static void operator delete(void* _Ptr, size_t _Size) noexcept {
+                _Alloc_char _Al{};
+                return allocator_traits<_Alloc_char>::deallocate(_Al, static_cast<char*>(_Ptr), _Size);
+            }
+        };
+
+        struct iterator {
+            using iterator_category = input_iterator_tag;
+            using difference_type   = ptrdiff_t;
+            using value_type        = _Ty;
+            using reference         = const _Ty&;
+            using pointer           = const _Ty*;
+
+            coroutine_handle<promise_type> _Coro = nullptr;
+
+            iterator() = default;
+            explicit iterator(coroutine_handle<promise_type> _Coro_) noexcept : _Coro(_Coro_) {}
+
+            iterator& operator++() {
+                _Coro.resume();
+                if (_Coro.done()) {
+#ifdef _CPPUNWIND
+                    _STD exchange(_Coro, nullptr).promise()._Rethrow_if_exception();
+#else // ^^^ defined(_CPPUNWIND) / !defined(_CPPUNWIND) vvv
+                    _Coro = nullptr;
+#endif // ^^^ !defined(_CPPUNWIND) ^^^
+                }
+
+                return *this;
+            }
+
+            void operator++(int) {
+                // This operator meets the requirements of the C++20 input_iterator concept,
+                // but not the Cpp17InputIterator requirements.
+                ++*this;
+            }
+
+            _NODISCARD bool operator==(const iterator& _Right) const noexcept {
+                return _Coro == _Right._Coro;
+            }
+
+            _NODISCARD bool operator!=(const iterator& _Right) const noexcept {
+                return !(*this == _Right);
+            }
+
+            _NODISCARD reference operator*() const noexcept {
+                return *_Coro.promise()._Value;
+            }
+
+            _NODISCARD pointer operator->() const noexcept {
+                return _Coro.promise()._Value;
+            }
+        };
+
+        _NODISCARD iterator begin() {
+            if (_Coro) {
+                _Coro.resume();
+                if (_Coro.done()) {
+#ifdef _CPPUNWIND
+                    _Coro.promise()._Rethrow_if_exception();
+#endif // ^^^ defined(_CPPUNWIND) ^^^
+                    return {};
+                }
+            }
+
+            return iterator{_Coro};
+        }
+
+        _NODISCARD iterator end() noexcept {
+            return {};
+        }
+
+        explicit generator(promise_type& _Prom) noexcept : _Coro(coroutine_handle<promise_type>::from_promise(_Prom)) {}
+
+        generator() = default;
+
+        generator(generator&& _Right) noexcept : _Coro(_STD exchange(_Right._Coro, nullptr)) {}
+
+        generator& operator=(generator&& _Right) noexcept {
+            _Coro = _STD exchange(_Right._Coro, nullptr);
+            return *this;
+        }
+
+        ~generator() {
+            if (_Coro) {
+                _Coro.destroy();
+            }
+        }
+
+    private:
+        coroutine_handle<promise_type> _Coro = nullptr;
+    };
+} // namespace experimental
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _EXPERIMENTAL_GENERATOR_
diff --git a/msvc-stl/stl/inc/experimental/resumable b/msvc-stl/stl/inc/experimental/resumable
new file mode 100644
index 0000000..9195e6c
--- /dev/null
+++ b/msvc-stl/stl/inc/experimental/resumable
@@ -0,0 +1,85 @@
+// resumable experimental header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Library support of coroutines TS, https://wg21.link/p0057
+
+#ifndef _EXPERIMENTAL_RESUMABLE_
+#define _EXPERIMENTAL_RESUMABLE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstdint>
+#include <experimental/coroutine>
+#include <memory>
+#include <new>
+#include <type_traits>
+
+#if _HAS_EXCEPTIONS
+#include <exception>
+#endif
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+namespace experimental {
+
+#ifndef __EDG__
+    struct noop_coroutine_promise {};
+
+    template <>
+    struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<> {
+        friend coroutine_handle noop_coroutine() noexcept;
+        constexpr explicit operator bool() const noexcept {
+            return true;
+        }
+        _NODISCARD constexpr bool done() const noexcept {
+            return false;
+        }
+        constexpr void operator()() const noexcept {}
+        constexpr void resume() const noexcept {}
+        constexpr void destroy() const noexcept {}
+
+        using _Promise = noop_coroutine_promise;
+
+        static const size_t _ALIGN_REQ = sizeof(void*) * 2;
+
+        static const size_t _ALIGNED_SIZE =
+            is_empty_v<_Promise> ? 0 : ((sizeof(_Promise) + _ALIGN_REQ - 1) & ~(_ALIGN_REQ - 1));
+
+        _NODISCARD _Promise& promise() const noexcept {
+            // Returns a reference to the associated promise.
+            return *const_cast<_Promise*>(
+                reinterpret_cast<const _Promise*>(reinterpret_cast<const char*>(_Ptr) - _ALIGNED_SIZE));
+        }
+
+    private:
+        coroutine_handle() noexcept {
+            _Ptr = reinterpret_cast<_Resumable_frame_prefix*>(__builtin_coro_noop());
+        }
+    };
+
+    using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
+
+    _NODISCARD inline noop_coroutine_handle noop_coroutine() noexcept {
+        // Returns a handle to a coroutine that has no observable effects when resumed or destroyed.
+        return noop_coroutine_handle{};
+    }
+#endif // ^^^ !defined(__EDG__) ^^^
+} // namespace experimental
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _EXPERIMENTAL_RESUMABLE_
diff --git a/msvc-stl/stl/inc/filesystem b/msvc-stl/stl/inc/filesystem
new file mode 100644
index 0000000..6987488
--- /dev/null
+++ b/msvc-stl/stl/inc/filesystem
@@ -0,0 +1,4456 @@
+// filesystem standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _FILESYSTEM_
+#define _FILESYSTEM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <filesystem> are available only with C++17 or later.");
+#else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#include <algorithm>
+#include <chrono>
+#include <cwchar>
+#include <iomanip>
+#include <locale>
+#include <memory>
+#include <system_error>
+#include <utility>
+#include <vector>
+#include <xfilesystem_abi.h>
+#include <xstring>
+
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+namespace filesystem {
+    _NODISCARD inline wstring _Convert_narrow_to_wide(const __std_code_page _Code_page, const string_view _Input) {
+        wstring _Output;
+
+        if (!_Input.empty()) {
+            if (!_STD _In_range<int>(_Input.size())) {
+                _Throw_system_error(errc::invalid_argument);
+            }
+
+            const int _Len = _Check_convert_result(__std_fs_convert_narrow_to_wide(
+                _Code_page, _Input.data(), static_cast<int>(_Input.size()), nullptr, 0));
+
+            _Output.resize(static_cast<size_t>(_Len));
+
+            (void) _Check_convert_result(__std_fs_convert_narrow_to_wide(
+                _Code_page, _Input.data(), static_cast<int>(_Input.size()), _Output.data(), _Len));
+        }
+
+        return _Output;
+    }
+
+    // More lenient version of _Convert_wide_to_narrow: Instead of failing on non-representable characters,
+    // replace them with a replacement character.
+    template <class _Traits, class _Alloc>
+    _NODISCARD basic_string<typename _Traits::char_type, _Traits, _Alloc> _Convert_wide_to_narrow_replace_chars(
+        const __std_code_page _Code_page, const wstring_view _Input, const _Alloc& _Al) {
+        basic_string<typename _Traits::char_type, _Traits, _Alloc> _Output(_Al);
+
+        if (!_Input.empty()) {
+            if (!_STD _In_range<int>(_Input.size())) {
+                _Throw_system_error(errc::invalid_argument);
+            }
+
+            const int _Len = _Check_convert_result(__std_fs_convert_wide_to_narrow_replace_chars(
+                _Code_page, _Input.data(), static_cast<int>(_Input.size()), nullptr, 0));
+
+            _Output.resize(static_cast<size_t>(_Len));
+
+            const auto _Data_as_char = reinterpret_cast<char*>(_Output.data());
+
+            (void) _Check_convert_result(__std_fs_convert_wide_to_narrow_replace_chars(
+                _Code_page, _Input.data(), static_cast<int>(_Input.size()), _Data_as_char, _Len));
+        }
+
+        return _Output;
+    }
+
+    _NODISCARD inline wstring _Convert_utf32_to_wide(const u32string_view _Input) {
+        wstring _Output;
+
+        _Output.reserve(_Input.size()); // ideal when surrogate pairs are uncommon
+
+        for (const auto& _Code_point : _Input) {
+            if (_Code_point <= 0xD7FFU) {
+                _Output.push_back(static_cast<wchar_t>(_Code_point));
+            } else if (_Code_point <= 0xDFFFU) {
+                _Throw_system_error(errc::invalid_argument);
+            } else if (_Code_point <= 0xFFFFU) {
+                _Output.push_back(static_cast<wchar_t>(_Code_point));
+            } else if (_Code_point <= 0x10FFFFU) {
+                _Output.push_back(static_cast<wchar_t>(0xD7C0U + (_Code_point >> 10)));
+                _Output.push_back(static_cast<wchar_t>(0xDC00U + (_Code_point & 0x3FFU)));
+            } else {
+                _Throw_system_error(errc::invalid_argument);
+            }
+        }
+
+        return _Output;
+    }
+
+    template <class _Traits, class _Alloc>
+    _NODISCARD basic_string<char32_t, _Traits, _Alloc> _Convert_wide_to_utf32(
+        const wstring_view _Input, const _Alloc& _Al) {
+        basic_string<char32_t, _Traits, _Alloc> _Output(_Al);
+
+        _Output.reserve(_Input.size()); // ideal when surrogate pairs are uncommon
+
+        const wchar_t* _First      = _Input.data();
+        const wchar_t* const _Last = _First + _Input.size();
+
+        for (; _First != _Last; ++_First) {
+            if (*_First <= 0xD7FFU) {
+                _Output.push_back(*_First);
+            } else if (*_First <= 0xDBFFU) { // found leading surrogate
+                const char32_t _Leading = *_First; // widen for later math
+
+                ++_First;
+
+                if (_First == _Last) { // missing trailing surrogate
+                    _Throw_system_error(errc::invalid_argument);
+                }
+
+                const char32_t _Trailing = *_First; // widen for later math
+
+                if (0xDC00U <= _Trailing && _Trailing <= 0xDFFFU) { // valid trailing surrogate
+                    _Output.push_back(0xFCA02400U + (_Leading << 10) + _Trailing);
+                } else { // invalid trailing surrogate
+                    _Throw_system_error(errc::invalid_argument);
+                }
+            } else if (*_First <= 0xDFFFU) { // found trailing surrogate by itself, invalid
+                _Throw_system_error(errc::invalid_argument);
+            } else {
+                _Output.push_back(*_First);
+            }
+        }
+
+        return _Output;
+    }
+
+    template <class _Traits, class _Alloc, class _EcharT = typename _Traits::char_type>
+    _NODISCARD basic_string<_EcharT, _Traits, _Alloc> _Convert_wide_to(const wstring_view _Input, const _Alloc& _Al) {
+        if constexpr (is_same_v<_EcharT, char>) {
+            return _Convert_wide_to_narrow<_Traits>(__std_fs_code_page(), _Input, _Al);
+        }
+#ifdef __cpp_char8_t
+        else if constexpr (is_same_v<_EcharT, char8_t>) {
+            return _Convert_wide_to_narrow<_Traits>(__std_code_page::_Utf8, _Input, _Al);
+        }
+#endif // defined(__cpp_char8_t)
+        else if constexpr (is_same_v<_EcharT, char32_t>) {
+            return _Convert_wide_to_utf32<_Traits>(_Input, _Al);
+        } else { // wchar_t, char16_t
+            return basic_string<_EcharT, _Traits, _Alloc>(_Input.data(), _Input.data() + _Input.size(), _Al);
+        }
+    }
+
+    template <class _Ty, class = void>
+    constexpr bool _Is_Source_impl = false;
+
+    template <class _Ty>
+    constexpr bool _Is_Source_impl<_Ty, void_t<typename iterator_traits<_Ty>::value_type>> =
+        _Is_EcharT<typename iterator_traits<_Ty>::value_type>;
+
+    template <class _Ty>
+    constexpr bool _Is_Source = _Is_Source_impl<decay_t<_Ty>>;
+
+    _EXPORT_STD class path;
+
+    template <>
+    inline constexpr bool _Is_Source<path> = false; // to avoid constraint recursion via the converting constructor and
+                                                    // iterator_traits when determining if path is copyable.
+
+    template <class _Elem, class _Traits, class _Alloc>
+    constexpr bool _Is_Source<basic_string<_Elem, _Traits, _Alloc>> = _Is_EcharT<_Elem>;
+
+    template <class _Elem, class _Traits>
+    constexpr bool _Is_Source<basic_string_view<_Elem, _Traits>> = _Is_EcharT<_Elem>;
+
+    struct _Normal_conversion {};
+
+    struct _Utf8_conversion {};
+
+    // A "stringoid" is basic_string_view<_EcharT> or basic_string<_EcharT>.
+
+    template <class _Conversion>
+    _NODISCARD wstring _Convert_stringoid_to_wide(const string_view _Input, _Conversion) {
+        _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_Conversion, _Normal_conversion, _Utf8_conversion>);
+
+        if constexpr (is_same_v<_Conversion, _Normal_conversion>) {
+            return _Convert_narrow_to_wide(__std_fs_code_page(), _Input);
+        } else {
+            return _Convert_narrow_to_wide(__std_code_page::_Utf8, _Input);
+        }
+    }
+
+    template <class _Conversion>
+    _NODISCARD wstring _Convert_stringoid_to_wide(const wstring_view _Input, _Conversion) {
+        static_assert(
+            is_same_v<_Conversion, _Normal_conversion>, "invalid value_type, see N4950 [depr.fs.path.factory]/1");
+        return wstring{_Input};
+    }
+
+#ifdef __cpp_char8_t
+    template <class _Conversion>
+    _NODISCARD wstring _Convert_stringoid_to_wide(const basic_string_view<char8_t> _Input, _Conversion) {
+        _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_Conversion, _Normal_conversion, _Utf8_conversion>);
+
+        const string_view _Input_as_char{reinterpret_cast<const char*>(_Input.data()), _Input.size()};
+        return _Convert_narrow_to_wide(__std_code_page::_Utf8, _Input_as_char);
+    }
+#endif // defined(__cpp_char8_t)
+
+    template <class _Conversion>
+    _NODISCARD wstring _Convert_stringoid_to_wide(const u16string_view _Input, _Conversion) {
+        static_assert(
+            is_same_v<_Conversion, _Normal_conversion>, "invalid value_type, see N4950 [depr.fs.path.factory]/1");
+        return wstring{_Input.data(), _Input.data() + _Input.size()};
+    }
+
+    template <class _Conversion>
+    _NODISCARD wstring _Convert_stringoid_to_wide(const u32string_view _Input, _Conversion) {
+        static_assert(
+            is_same_v<_Conversion, _Normal_conversion>, "invalid value_type, see N4950 [depr.fs.path.factory]/1");
+        return _Convert_utf32_to_wide(_Input);
+    }
+
+    template <class _EcharT, class _Traits>
+    _NODISCARD auto _Stringoid_from_Source(const basic_string_view<_EcharT, _Traits>& _Source) {
+        return basic_string_view<_EcharT>(_Source.data(), _Source.size()); // erase mismatching _Traits
+    }
+
+    template <class _EcharT, class _Traits, class _Alloc>
+    _NODISCARD auto _Stringoid_from_Source(const basic_string<_EcharT, _Traits, _Alloc>& _Source) {
+        return basic_string_view<_EcharT>(_Source.data(), _Source.size()); // erase mismatching _Traits
+    }
+
+    template <class _Src>
+    _NODISCARD auto _Stringoid_from_Source(const _Src& _Source) {
+        using _EcharT = _Iter_value_t<decay_t<_Src>>;
+        if constexpr (is_pointer_v<_Unwrapped_unverified_t<const _Src&>>) {
+            return basic_string_view<_EcharT>(_Get_unwrapped_unverified(_Source));
+        } else if constexpr (is_pointer_v<_Unwrapped_t<const _Src&>>) {
+            const auto _Data = _Get_unwrapped(_Source);
+            auto _Next       = _Source;
+            while (*_Next != _EcharT{}) {
+                ++_Next;
+            }
+
+            return basic_string_view<_EcharT>(_Data, static_cast<size_t>(_Get_unwrapped(_Next) - _Data));
+        } else {
+            basic_string<_EcharT> _Str;
+            for (auto _Next = _Source; *_Next != _EcharT{}; ++_Next) {
+                _Str.push_back(*_Next);
+            }
+
+            return _Str;
+        }
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    template <class _EcharT, size_t _SourceSize>
+    _NODISCARD basic_string_view<_EcharT> _Stringoid_from_Source(const _EcharT (&_Src)[_SourceSize]) {
+        for (size_t _Idx = 0;; ++_Idx) {
+            _STL_VERIFY(_Idx < _SourceSize, "path input not null terminated");
+            if (_Src[_Idx] == _EcharT{}) {
+                return basic_string_view<_EcharT>(_Src, _Idx);
+            }
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    template <class _Src, class _Conversion = _Normal_conversion>
+    _NODISCARD wstring _Convert_Source_to_wide(const _Src& _Source, _Conversion _Tag = {}) {
+        return _Convert_stringoid_to_wide(_Stringoid_from_Source(_Source), _Tag);
+    }
+
+    template <class _InIt>
+    _NODISCARD auto _Stringoid_from_range(_InIt _First, _InIt _Last) {
+        _Adl_verify_range(_First, _Last);
+        const auto _UFirst = _Get_unwrapped(_First);
+        const auto _ULast  = _Get_unwrapped(_Last);
+
+        if constexpr (is_pointer_v<decltype(_UFirst)>) {
+            return basic_string_view<_Iter_value_t<_InIt>>(_UFirst, static_cast<size_t>(_ULast - _UFirst));
+        } else {
+            return basic_string<_Iter_value_t<_InIt>>(_UFirst, _ULast);
+        }
+    }
+
+    template <class _InIt, class _Conversion = _Normal_conversion>
+    _NODISCARD wstring _Convert_range_to_wide(_InIt _First, _InIt _Last, _Conversion _Tag = {}) {
+        return _Convert_stringoid_to_wide(_Stringoid_from_range(_First, _Last), _Tag);
+    }
+
+    _NODISCARD inline wstring _Convert_stringoid_with_locale_to_wide(const string_view _Input, const locale& _Loc) {
+        const auto& _Facet = _STD use_facet<codecvt<wchar_t, char, mbstate_t>>(_Loc);
+
+        wstring _Output(_Input.size(), L'\0'); // almost always sufficient
+
+        for (;;) {
+            mbstate_t _State{};
+            const char* const _From_begin = _Input.data();
+            const char* const _From_end   = _From_begin + _Input.size();
+            const char* _From_next        = nullptr;
+            wchar_t* const _To_begin      = _Output.data();
+            wchar_t* const _To_end        = _To_begin + _Output.size();
+            wchar_t* _To_next             = nullptr;
+
+            const auto _Result = _Facet.in(_State, _From_begin, _From_end, _From_next, _To_begin, _To_end, _To_next);
+
+            if (_From_next < _From_begin || _From_next > _From_end || _To_next < _To_begin || _To_next > _To_end) {
+                _Throw_system_error(errc::invalid_argument);
+            }
+
+            switch (_Result) {
+            case codecvt_base::ok:
+                _Output.resize(static_cast<size_t>(_To_next - _To_begin));
+                return _Output;
+
+            case codecvt_base::partial:
+                // N4950 [locale.codecvt.virtuals]/5:
+                // "A return value of partial, if (from_next == from_end), indicates that either the
+                // destination sequence has not absorbed all the available destination elements,
+                // or that additional source elements are needed before another destination element can be produced."
+                if ((_From_next == _From_end && _To_next != _To_end) || _Output.size() > _Output.max_size() / 2) {
+                    _Throw_system_error(errc::invalid_argument);
+                }
+
+                _Output.resize(_Output.size() * 2);
+                break; // out of switch, keep looping
+
+            case codecvt_base::error:
+            case codecvt_base::noconv:
+            default:
+                _Throw_system_error(errc::invalid_argument);
+            }
+        }
+    }
+
+    struct _Is_slash_oper { // predicate testing if input is a preferred-separator or fallback-separator
+        _NODISCARD static constexpr bool operator()(const wchar_t _Ch) {
+            return _Ch == L'\\' || _Ch == L'/';
+        }
+    };
+
+    inline constexpr _Is_slash_oper _Is_slash{};
+
+    _NODISCARD inline bool _Is_drive_prefix(const wchar_t* const _First) {
+        // test if _First points to a prefix of the form X:
+        // pre: _First points to at least 2 wchar_t instances
+        // pre: Little endian
+        unsigned int _Value;
+        _CSTD memcpy(&_Value, _First, sizeof(_Value)); // load from possibly unaligned address
+        _Value &= 0xFFFF'FFDFu; // transform lowercase drive letters into uppercase ones
+        _Value -= (static_cast<unsigned int>(L':') << (sizeof(wchar_t) * CHAR_BIT)) | L'A';
+        return _Value < 26;
+    }
+
+    _NODISCARD inline bool _Has_drive_letter_prefix(const wchar_t* const _First, const wchar_t* const _Last) {
+        // test if [_First, _Last) has a prefix of the form X:
+        return _Last - _First >= 2 && _Is_drive_prefix(_First);
+    }
+
+    _NODISCARD inline const wchar_t* _Find_root_name_end(const wchar_t* const _First, const wchar_t* const _Last) {
+        // attempt to parse [_First, _Last) as a path and return the end of root-name if it exists; otherwise, _First
+
+        // This is the place in the generic grammar where library implementations have the most freedom.
+        // Below are example Windows paths, and what we've decided to do with them:
+        // * X:DriveRelative, X:\DosAbsolute
+        //   We parse X: as root-name, if and only if \ is present we consider that root-directory
+        // * \RootRelative
+        //   We parse no root-name, and \ as root-directory
+        // * \\server\share
+        //   We parse \\server as root-name, \ as root-directory, and share as the first element in relative-path.
+        //   Technically, Windows considers all of \\server\share the logical "root", but for purposes
+        //   of decomposition we want those split, so that path{R"(\\server\share)"}.replace_filename("other_share")
+        //   is \\server\other_share
+        // * \\?\device
+        // * \??\device
+        // * \\.\device
+        //   CreateFile appears to treat these as the same thing; we will set the first three characters as root-name
+        //   and the first \ as root-directory. Support for these prefixes varies by particular Windows version, but
+        //   for the purposes of path decomposition we don't need to worry about that.
+        // * \\?\UNC\server\share
+        //   MSDN explicitly documents the \\?\UNC syntax as a special case. What actually happens is that the device
+        //   Mup, or "Multiple UNC provider", owns the path \\?\UNC in the NT namespace, and is responsible for the
+        //   network file access. When the user says \\server\share, CreateFile translates that into
+        //   \\?\UNC\server\share to get the remote server access behavior. Because NT treats this like any other
+        //   device, we have chosen to treat this as the \\?\ case above.
+        if (_Last - _First < 2) {
+            return _First;
+        }
+
+        if (_Has_drive_letter_prefix(_First, _Last)) { // check for X: first because it's the most common root-name
+            return _First + 2;
+        }
+
+        if (!_Is_slash(_First[0])) { // all the other root-names start with a slash; check that first because
+                                     // we expect paths without a leading slash to be very common
+            return _First;
+        }
+
+        // $ means anything other than a slash, including potentially the end of the input
+        if (_Last - _First >= 4 && _Is_slash(_First[3]) && (_Last - _First == 4 || !_Is_slash(_First[4])) // \xx\$
+            && ((_Is_slash(_First[1]) && (_First[2] == L'?' || _First[2] == L'.')) // \\?\$ or \\.\$
+                || (_First[1] == L'?' && _First[2] == L'?'))) { // \??\$
+            return _First + 3;
+        }
+
+        if (_Last - _First >= 3 && _Is_slash(_First[1]) && !_Is_slash(_First[2])) { // \\server
+            return _STD find_if(_First + 3, _Last, _Is_slash);
+        }
+
+        // no match
+        return _First;
+    }
+
+    _NODISCARD inline wstring_view _Parse_root_name(const wstring_view _Str) {
+        // attempt to parse _Str as a path and return the root-name if it exists; otherwise, an empty view
+        const auto _First = _Str.data();
+        const auto _Last  = _First + _Str.size();
+        return wstring_view(_First, static_cast<size_t>(_Find_root_name_end(_First, _Last) - _First));
+    }
+
+    _NODISCARD inline const wchar_t* _Find_relative_path(const wchar_t* const _First, const wchar_t* const _Last) {
+        // attempt to parse [_First, _Last) as a path and return the start of relative-path
+        return _STD find_if_not(_Find_root_name_end(_First, _Last), _Last, _Is_slash);
+    }
+
+    _NODISCARD inline wstring_view _Parse_root_directory(const wstring_view _Str) {
+        // attempt to parse _Str as a path and return the root-directory if it exists; otherwise, an empty view
+        const auto _First         = _Str.data();
+        const auto _Last          = _First + _Str.size();
+        const auto _Root_name_end = _Find_root_name_end(_First, _Last);
+        const auto _Relative_path = _STD find_if_not(_Root_name_end, _Last, _Is_slash);
+        return wstring_view(_Root_name_end, static_cast<size_t>(_Relative_path - _Root_name_end));
+    }
+
+    _NODISCARD inline wstring_view _Parse_root_path(const wstring_view _Str) {
+        // attempt to parse _Str as a path and return the root-path if it exists; otherwise, an empty view
+        const auto _First = _Str.data();
+        const auto _Last  = _First + _Str.size();
+        return wstring_view(_First, static_cast<size_t>(_Find_relative_path(_First, _Last) - _First));
+    }
+
+    _NODISCARD inline wstring_view _Parse_relative_path(const wstring_view _Str) {
+        // attempt to parse _Str as a path and return the relative-path if it exists; otherwise, an empty view
+        const auto _First         = _Str.data();
+        const auto _Last          = _First + _Str.size();
+        const auto _Relative_path = _Find_relative_path(_First, _Last);
+        return wstring_view(_Relative_path, static_cast<size_t>(_Last - _Relative_path));
+    }
+
+    _NODISCARD inline wstring_view _Parse_parent_path(const wstring_view _Str) {
+        // attempt to parse _Str as a path and return the parent_path if it exists; otherwise, an empty view
+        const auto _First         = _Str.data();
+        auto _Last                = _First + _Str.size();
+        const auto _Relative_path = _Find_relative_path(_First, _Last);
+        // case 1: relative-path ends in a directory-separator, remove the separator to remove "magic empty path"
+        //  for example: R"(/cat/dog/\//\)"
+        // case 2: relative-path doesn't end in a directory-separator, remove the filename and last directory-separator
+        //  to prevent creation of a "magic empty path"
+        //  for example: "/cat/dog"
+        while (_Relative_path != _Last && !_Is_slash(_Last[-1])) {
+            // handle case 2 by removing trailing filename, puts us into case 1
+            --_Last;
+        }
+
+        while (_Relative_path != _Last && _Is_slash(_Last[-1])) { // handle case 1 by removing trailing slashes
+            --_Last;
+        }
+
+        return wstring_view(_First, static_cast<size_t>(_Last - _First));
+    }
+
+    _NODISCARD inline const wchar_t* _Find_filename(const wchar_t* const _First, const wchar_t* _Last) {
+        // attempt to parse [_First, _Last) as a path and return the start of filename if it exists; otherwise, _Last
+        const auto _Relative_path = _Find_relative_path(_First, _Last);
+        while (_Relative_path != _Last && !_Is_slash(_Last[-1])) {
+            --_Last;
+        }
+
+        return _Last;
+    }
+
+    _NODISCARD inline wstring_view _Parse_filename(const wstring_view _Str) {
+        // attempt to parse _Str as a path and return the filename if it exists; otherwise, an empty view
+        const auto _First    = _Str.data();
+        const auto _Last     = _First + _Str.size();
+        const auto _Filename = _Find_filename(_First, _Last);
+        return wstring_view(_Filename, static_cast<size_t>(_Last - _Filename));
+    }
+
+    _NODISCARD constexpr const wchar_t* _Find_extension(const wchar_t* const _Filename, const wchar_t* const _Ads) {
+        // find dividing point between stem and extension in a generic format filename consisting of [_Filename, _Ads)
+        auto _Extension = _Ads;
+        if (_Filename == _Extension) { // empty path
+            return _Ads;
+        }
+
+        --_Extension;
+        if (_Filename == _Extension) {
+            // path is length 1 and either dot, or has no dots; either way, extension() is empty
+            return _Ads;
+        }
+
+        if (*_Extension == L'.') { // we might have found the end of stem
+            if (_Filename == _Extension - 1 && _Extension[-1] == L'.') { // dotdot special case
+                return _Ads;
+            } else { // x.
+                return _Extension;
+            }
+        }
+
+        while (_Filename != --_Extension) {
+            if (*_Extension == L'.') { // found a dot which is not in first position, so it starts extension()
+                return _Extension;
+            }
+        }
+
+        // if we got here, either there are no dots, in which case extension is empty, or the first element
+        // is a dot, in which case we have the leading single dot special case, which also makes extension empty
+        return _Ads;
+    }
+
+    _NODISCARD inline wstring_view _Parse_stem(const wstring_view _Str) {
+        // attempt to parse _Str as a path and return the stem if it exists; otherwise, an empty view
+        const auto _First    = _Str.data();
+        const auto _Last     = _First + _Str.size();
+        const auto _Filename = _Find_filename(_First, _Last);
+        const auto _Ads =
+            _STD find(_Filename, _Last, L':'); // strip alternate data streams in intra-filename decomposition
+        const auto _Extension = _Find_extension(_Filename, _Ads);
+        return wstring_view(_Filename, static_cast<size_t>(_Extension - _Filename));
+    }
+
+    _NODISCARD inline wstring_view _Parse_extension(const wstring_view _Str) {
+        // attempt to parse _Str as a path and return the extension if it exists; otherwise, an empty view
+        const auto _First    = _Str.data();
+        const auto _Last     = _First + _Str.size();
+        const auto _Filename = _Find_filename(_First, _Last);
+        const auto _Ads =
+            _STD find(_Filename, _Last, L':'); // strip alternate data streams in intra-filename decomposition
+        const auto _Extension = _Find_extension(_Filename, _Ads);
+        return wstring_view(_Extension, static_cast<size_t>(_Ads - _Extension));
+    }
+
+    _NODISCARD inline int _Range_compare(const wchar_t* const _Lfirst, const wchar_t* const _Llast,
+        const wchar_t* const _Rfirst, const wchar_t* const _Rlast) {
+        // 3 way compare [_Lfirst, _Llast) with [_Rfirst, _Rlast)
+        return _Traits_compare<char_traits<wchar_t>>(
+            _Lfirst, static_cast<size_t>(_Llast - _Lfirst), _Rfirst, static_cast<size_t>(_Rlast - _Rfirst));
+    }
+
+    _NODISCARD inline bool _Is_drive_prefix_with_slash_slash_question(const wstring_view _Text) {
+        // test if _Text starts with a \\?\X: prefix
+        return _Text.size() >= 6 && _Text._Starts_with(LR"(\\?\)"sv) && _Is_drive_prefix(_Text.data() + 4);
+    }
+
+    _NODISCARD inline bool _Is_dot_or_dotdot(const __std_fs_find_data& _Data) {
+        // tests if _File_name of __std_fs_find_data is . or ..
+        if (_Data._File_name[0] != L'.') {
+            return false;
+        }
+
+        const auto _Second_char = _Data._File_name[1];
+        if (_Second_char == 0) {
+            return true;
+        }
+
+        if (_Second_char != L'.') {
+            return false;
+        }
+
+        return _Data._File_name[2] == 0;
+    }
+
+    struct _Find_file_handle {
+        __std_fs_dir_handle _Handle = __std_fs_dir_handle::_Invalid;
+
+        _Find_file_handle() noexcept = default;
+        _Find_file_handle(_Find_file_handle&& _Rhs) noexcept
+            : _Handle(_STD exchange(_Rhs._Handle, __std_fs_dir_handle::_Invalid)) {}
+
+        _Find_file_handle& operator=(_Find_file_handle&& _Rhs) noexcept {
+            auto _Tmp = _STD exchange(_Rhs._Handle, __std_fs_dir_handle::_Invalid);
+            _Tmp      = _STD exchange(_Handle, _Tmp);
+            __std_fs_directory_iterator_close(_Tmp);
+            return *this;
+        }
+
+        _NODISCARD __std_win_error _Open(const wchar_t* _Path_spec, __std_fs_find_data* _Results) noexcept {
+            return __std_fs_directory_iterator_open(_Path_spec, &_Handle, _Results);
+        }
+
+        ~_Find_file_handle() noexcept {
+            __std_fs_directory_iterator_close(_Handle);
+        }
+
+        explicit operator bool() const noexcept {
+            return _Handle != __std_fs_dir_handle::_Invalid;
+        }
+    };
+
+    template <class _Base_iter>
+    class _Path_iterator;
+
+    _EXPORT_STD class path {
+        template <class _Base_iter>
+        friend class _Path_iterator;
+        friend inline path absolute(const path& _Input, error_code& _Ec);
+        friend inline __std_win_error _Canonical(path& _Result, const wstring& _Text);
+        friend inline path _Temp_directory_path_impl(error_code& _Ec);
+        friend inline path current_path(error_code& _Ec);
+        friend inline void current_path(const path& _To);
+        friend inline void current_path(const path& _To, error_code& _Ec) noexcept;
+        friend inline __std_win_error _Read_symlink(const path& _Symlink_path, path& _Result);
+
+    public:
+        using value_type  = wchar_t;
+        using string_type = _STD wstring;
+
+        static constexpr wchar_t preferred_separator = L'\\';
+
+        enum format { auto_format, native_format, generic_format };
+
+        path()                           = default;
+        path(const path&)                = default;
+        path(path&&)                     = default;
+        ~path()                          = default;
+        path& operator=(const path&)     = default;
+        path& operator=(path&&) noexcept = default;
+
+        path(string_type&& _Source) : _Text(_STD move(_Source)) {}
+
+        path(string_type&& _Source, format) : _Text(_STD move(_Source)) {
+            // format has no meaning for this implementation, as the generic grammar is acceptable as a native path
+        }
+
+        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+        path(const _Src& _Source, format = auto_format) : _Text(_Convert_Source_to_wide(_Source)) {
+            // format has no meaning for this implementation, as the generic grammar is acceptable as a native path
+        }
+
+        template <class _InIt>
+        path(_InIt _First, _InIt _Last, format = auto_format) : _Text(_Convert_range_to_wide(_First, _Last)) {
+            // format has no meaning for this implementation, as the generic grammar is acceptable as a native path
+            static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4950 [fs.req]/3");
+        }
+
+        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+        path(const _Src& _Source, const locale& _Loc, format = auto_format)
+            : _Text(_Convert_stringoid_with_locale_to_wide(_Stringoid_from_Source(_Source), _Loc)) {
+            // format has no meaning for this implementation, as the generic grammar is acceptable as a native path
+            using _Stringoid = decltype(_Stringoid_from_Source(_Source));
+            static_assert(is_same_v<typename _Stringoid::value_type, char>,
+                "invalid value_type, see N4950 [fs.path.construct]/5");
+        }
+
+        template <class _InIt>
+        path(_InIt _First, _InIt _Last, const locale& _Loc, format = auto_format)
+            : _Text(_Convert_stringoid_with_locale_to_wide(_Stringoid_from_range(_First, _Last), _Loc)) {
+            // format has no meaning for this implementation, as the generic grammar is acceptable as a native path
+            static_assert(is_same_v<_Iter_value_t<_InIt>, char>, "invalid value_type, see N4950 [fs.path.construct]/5");
+        }
+
+        path& operator=(string_type&& _Source) noexcept /* strengthened */ {
+            // set native() to _Source
+            _Text = _STD move(_Source);
+            return *this;
+        }
+
+        path& assign(string_type&& _Source) noexcept /* strengthened */ {
+            // set native() to _Source
+            _Text = _STD move(_Source);
+            return *this;
+        }
+
+        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+        path& operator=(const _Src& _Source) { // set native() to _Source
+            _Text = _Convert_Source_to_wide(_Source);
+            return *this;
+        }
+
+        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+        path& assign(const _Src& _Source) { // set native() to _Source
+            _Text = _Convert_Source_to_wide(_Source);
+            return *this;
+        }
+
+        template <class _InIt>
+        path& assign(_InIt _First, _InIt _Last) { // set native() to [_First, _Last)
+            static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4950 [fs.req]/3");
+            _Text = _Convert_range_to_wide(_First, _Last);
+            return *this;
+        }
+
+        path& operator/=(const path& _Other) {
+            // set *this to the path lexically resolved by _Other relative to *this
+            // examples:
+            // path{"cat"} / "c:/dog"; // yields "c:/dog"
+            // path{"cat"} / "c:"; // yields "c:"
+            // path{"c:"} / ""; // yields "c:"
+            // path{"c:cat"} / "/dog"; // yields "c:/dog"
+            // path{"c:cat"} / "c:dog"; // yields "c:cat/dog"
+            // path{"c:cat"} / "d:dog"; // yields "d:dog"
+            // several places herein quote the standard, but the standard's variable p is replaced with _Other
+
+            if (_Other.is_absolute()) { // if _Other.is_absolute(), then op=(_Other)
+                return operator=(_Other);
+            }
+
+            const auto _My_first            = _Text.data();
+            const auto _My_last             = _My_first + _Text.size();
+            const auto _Other_first         = _Other._Text.data();
+            const auto _Other_last          = _Other_first + _Other._Text.size();
+            const auto _My_root_name_end    = _Find_root_name_end(_My_first, _My_last);
+            const auto _Other_root_name_end = _Find_root_name_end(_Other_first, _Other_last);
+            if (_Other_first != _Other_root_name_end
+                && _Range_compare(_My_first, _My_root_name_end, _Other_first, _Other_root_name_end) != 0) {
+                // if _Other.has_root_name() && _Other.root_name() != root_name(), then op=(_Other)
+                return operator=(_Other);
+            }
+
+            if (_Other_root_name_end != _Other_last && _Is_slash(*_Other_root_name_end)) {
+                // If _Other.has_root_directory() removes any root directory and relative-path from *this
+                _Text.erase(static_cast<size_t>(_My_root_name_end - _My_first));
+            } else {
+                // Otherwise, if (!has_root_directory && is_absolute) || has_filename appends path::preferred_separator
+                if (_My_root_name_end == _My_last) {
+                    // Here, !has_root_directory && !has_filename
+                    // Going through our root_name kinds:
+                    // X: can't be absolute here, since those paths are absolute only when has_root_directory
+                    // \\?\ can't exist without has_root_directory
+                    // \\server can be absolute here
+                    if (_My_root_name_end - _My_first >= 3) {
+                        _Text.push_back(preferred_separator);
+                    }
+                } else {
+                    // Here, has_root_directory || has_filename
+                    // If there is a trailing slash, the trailing slash might be part of root_directory.
+                    // If it is, has_root_directory && !has_filename, so the test fails.
+                    // If there is a trailing slash not part of root_directory, then !has_filename, so only
+                    // (!has_root_directory && is_absolute) remains
+                    // Going through our root_name kinds:
+                    // X:cat\ needs a root_directory to be absolute
+                    // \\server\cat must have a root_directory to exist with a relative_path
+                    // \\?\ must have a root_directory to exist
+                    // As a result, the test fails if there is a trailing slash.
+                    // If there is no trailing slash, then has_filename, so the test passes.
+                    // Therefore, the test passes if and only if there is no trailing slash.
+                    if (!_Is_slash(_My_last[-1])) {
+                        _Text.push_back(preferred_separator);
+                    }
+                }
+            }
+
+            // Then appends the native format pathname of _Other, omitting any root-name from its generic format
+            // pathname, to the native format pathname.
+            _Text.append(_Other_root_name_end, static_cast<size_t>(_Other_last - _Other_root_name_end));
+            return *this;
+        }
+
+        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+        path& operator/=(const _Src& _Source) {
+            return operator/=(path{_Source});
+        }
+
+        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+        path& append(const _Src& _Source) {
+            return operator/=(path{_Source});
+        }
+
+        template <class _InIt>
+        path& append(_InIt _First, _InIt _Last) {
+            static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4950 [fs.req]/3");
+            return operator/=(path{_First, _Last});
+        }
+
+        path& operator+=(const path& _Added) { // concat _Added to native()
+            return operator+=(_Added._Text);
+        }
+
+        path& operator+=(const string_type& _Added) { // concat _Added to native()
+            _Text._Orphan_all();
+            _Text += _Added;
+            return *this;
+        }
+
+        path& operator+=(const wstring_view _Added) { // concat _Added to native()
+            _Text._Orphan_all();
+            _Text += _Added;
+            return *this;
+        }
+
+        path& operator+=(const value_type* const _Added) { // concat _Added to native()
+            _Text._Orphan_all();
+            _Text += _Added;
+            return *this;
+        }
+
+        path& operator+=(const value_type _Added) { // concat _Added to native()
+            _Text._Orphan_all();
+            _Text += _Added;
+            return *this;
+        }
+
+        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+        path& operator+=(const _Src& _Added) { // concat _Added to native()
+            return operator+=(path{_Added}._Text);
+        }
+
+        template <class _EcharT, enable_if_t<_Is_EcharT<_EcharT>, int> = 0>
+        path& operator+=(const _EcharT _Added) { // concat _Added to native()
+            return operator+=(path{&_Added, &_Added + 1}._Text);
+        }
+
+        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+        path& concat(const _Src& _Added) { // concat _Added to native()
+            return operator+=(path{_Added}._Text);
+        }
+
+        template <class _InIt>
+        path& concat(_InIt _First, _InIt _Last) { // concat [_First, _Last) to native()
+            static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4950 [fs.req]/3");
+            return operator+=(path{_First, _Last}._Text);
+        }
+
+        void clear() noexcept { // set *this to the empty path
+            _Text._Orphan_all();
+            _Text.clear();
+        }
+
+        path& make_preferred() noexcept /* strengthened */ {
+            // transform each fallback-separator into preferred-separator
+            _Text._Orphan_all();
+            _STD replace(_Text.begin(), _Text.end(), L'/', L'\\');
+            return *this;
+        }
+
+        path& remove_filename() noexcept /* strengthened */ {
+            // remove any filename from *this
+            const auto _First    = _Text.data();
+            const auto _Last     = _First + _Text.size();
+            const auto _Filename = _Find_filename(_First, _Last);
+            _Text._Orphan_all();
+            _Text.erase(static_cast<size_t>(_Filename - _First));
+            return *this;
+        }
+
+        void _Remove_filename_and_separator() noexcept { // remove filename and preceding non-root directory-separator
+            const auto _First         = _Text.data();
+            const auto _Last          = _First + _Text.size();
+            const auto _Root_name_end = _Find_root_name_end(_First, _Last);
+            const auto _Root_dir_end =
+                (_Root_name_end != _Last && _Is_slash(*_Root_name_end)) ? _Root_name_end + 1 : _Root_name_end;
+
+            using _Reverse_iter = reverse_iterator<const wchar_t*>;
+
+            const _Reverse_iter _Rbegin{_Last};
+            const _Reverse_iter _Rend{_Root_dir_end};
+
+            const auto _Rslash_first = _STD find_if(_Rbegin, _Rend, _Is_slash);
+            const auto _Rslash_last  = _STD find_if_not(_Rslash_first, _Rend, _Is_slash);
+
+            const _Reverse_iter _Rlast{_First};
+
+            _Text._Orphan_all();
+            _Text.erase(static_cast<size_t>(_Rlast - _Rslash_last));
+        }
+
+        path& replace_filename(const path& _Replacement) { // remove any filename from *this and append _Replacement
+            remove_filename();
+            return operator/=(_Replacement);
+        }
+
+        path& replace_extension(/* const path& _Replacement = {} */) noexcept /* strengthened */ {
+            // remove any extension() (and alternate data stream references) from *this's filename()
+            const wchar_t* _First = _Text.data();
+            const auto _Last      = _First + _Text.size();
+            const auto _Filename  = _Find_filename(_First, _Last);
+            const auto _Ads       = _STD find(_Filename, _Last, L':');
+            const auto _Extension = _Find_extension(_Filename, _Ads);
+            _Text._Orphan_all();
+            _Text.erase(static_cast<size_t>(_Extension - _First));
+            return *this;
+        }
+
+        path& replace_extension(const path& _Replacement) {
+            // remove any extension() (and alternate data stream references) from *this's filename(), and concatenate
+            // _Replacement
+            replace_extension();
+            if (!_Replacement.empty() && _Replacement._Text[0] != L'.') {
+                _Text.push_back(L'.');
+            }
+
+            return operator+=(_Replacement._Text);
+        }
+
+        void swap(path& _Rhs) noexcept {
+            _Text.swap(_Rhs._Text);
+        }
+
+        _NODISCARD const string_type& native() const noexcept {
+            // return a reference to the internally stored wstring in the native format
+            return _Text;
+        }
+
+        _NODISCARD const value_type* c_str() const noexcept {
+            // return a NTCTS to the internally stored path in the native format
+            return _Text.c_str();
+        }
+
+        operator string_type() const { // implicitly convert *this into a string containing the native format
+            return _Text;
+        }
+
+        template <class _EcharT, class _Traits = char_traits<_EcharT>, class _Alloc = allocator<_EcharT>,
+            enable_if_t<_Is_EcharT<_EcharT>, int> = 0>
+        _NODISCARD basic_string<_EcharT, _Traits, _Alloc> string(const _Alloc& _Al = _Alloc()) const {
+            // convert the native path from this instance into a basic_string
+            return _Convert_wide_to<_Traits>(_Text, _Al);
+        }
+
+        _NODISCARD _STD string string() const { // convert the native path from this instance into a string
+            return string<char>();
+        }
+
+        _NODISCARD _STD wstring wstring() const { // copy the native path from this instance into a wstring
+            return _Text;
+        }
+
+        _NODISCARD auto u8string() const { // convert the native path from this instance into a UTF-8 string
+#ifdef __cpp_lib_char8_t
+            using _U8Ty = char8_t;
+#else // ^^^ defined(__cpp_lib_char8_t) / !defined(__cpp_lib_char8_t) vvv
+            using _U8Ty = char;
+#endif // ^^^ !defined(__cpp_lib_char8_t) ^^^
+            return _Convert_wide_to_narrow<char_traits<_U8Ty>>(__std_code_page::_Utf8, _Text, allocator<_U8Ty>{});
+        }
+
+        _NODISCARD _STD u16string u16string() const { // convert the native path from this instance into a u16string
+            return string<char16_t>();
+        }
+
+        _NODISCARD _STD u32string u32string() const { // convert the native path from this instance into a u32string
+            return string<char32_t>();
+        }
+
+        template <class _EcharT, class _Traits = char_traits<_EcharT>, class _Alloc = allocator<_EcharT>,
+            enable_if_t<_Is_EcharT<_EcharT>, int> = 0>
+        _NODISCARD basic_string<_EcharT, _Traits, _Alloc> generic_string(const _Alloc& _Al = _Alloc()) const {
+            // convert the native path from this instance into a generic basic_string
+            using _Alwide = _Rebind_alloc_t<_Alloc, wchar_t>;
+            _Alwide _Al_wchar(_Al);
+            basic_string<wchar_t, char_traits<wchar_t>, _Alwide> _Generic_str(_Al_wchar);
+            _Generic_str.resize(_Text.size());
+            _STD replace_copy(_Text.begin(), _Text.end(), _Generic_str.begin(), L'\\', L'/');
+            return _Convert_wide_to<_Traits>(_Generic_str, _Al);
+        }
+
+        _NODISCARD _STD string generic_string() const {
+            // convert the native path from this instance into a generic string
+            return generic_string<char>();
+        }
+
+        _NODISCARD _STD wstring generic_wstring() const {
+            // convert the current native path into a copy of it in the generic format
+            // note: intra-filename() observers stem() and extension() strip alternate data
+            // streams, but filenames with alternate data streams inside can serve as
+            // perfectly valid values of filename in the generic format, so in the interest of
+            // destroying less information we have preserved them here.
+            _STD wstring _Result;
+            _Result.resize(_Text.size());
+            _STD replace_copy(_Text.begin(), _Text.end(), _Result.begin(), L'\\', L'/');
+            return _Result;
+        }
+
+        _NODISCARD auto generic_u8string() const {
+            // convert the native path from this instance into a generic UTF-8 string
+            auto _Result = u8string();
+            using _U8Ty  = decltype(_Result)::value_type;
+            _STD replace(_Result.begin(), _Result.end(), _U8Ty{u8'\\'}, _U8Ty{u8'/'});
+            return _Result;
+        }
+
+        _NODISCARD _STD u16string generic_u16string() const {
+            // convert the native path from this instance into a generic u16string
+            _STD u16string _Result = u16string();
+            _STD replace(_Result.begin(), _Result.end(), u'\\', u'/');
+            return _Result;
+        }
+
+        _NODISCARD _STD u32string generic_u32string() const {
+            // convert the native path from this instance into a generic u32string
+            _STD u32string _Result = u32string();
+            _STD replace(_Result.begin(), _Result.end(), U'\\', U'/');
+            return _Result;
+        }
+
+        _NODISCARD int compare(const path& _Other) const noexcept { // compare *this with _Other
+            return compare(static_cast<wstring_view>(_Other._Text));
+        }
+
+        _NODISCARD int compare(const string_type& _Other) const noexcept /* strengthened */ {
+            // compare *this with _Other
+            return compare(static_cast<wstring_view>(_Other));
+        }
+
+        _NODISCARD int compare(const basic_string_view<value_type> _Other) const noexcept /* strengthened */ {
+            // compare *this with _Other
+            // several places herein quote the standard, but the standard's variable p is replaced with _Other
+            const auto _My_first            = _Text.data();
+            const auto _My_last             = _My_first + _Text.size();
+            const auto _My_root_name_end    = _Find_root_name_end(_My_first, _My_last);
+            const auto _Other_first         = _Other.data();
+            const auto _Other_last          = _Other_first + _Other.size();
+            const auto _Other_root_name_end = _Find_root_name_end(_Other_first, _Other_last);
+
+            // Let rootNameComparison be the result of this->root_name().native().compare(_Other.root_name().native())
+            const int _Root_cmp = _Range_compare(_My_first, _My_root_name_end, _Other_first, _Other_root_name_end);
+            if (_Root_cmp != 0) { // If rootNameComparison is not 0, rootNameComparison
+                return _Root_cmp;
+            }
+
+            auto _My_relative               = _STD find_if_not(_My_root_name_end, _My_last, _Is_slash);
+            auto _Other_relative            = _STD find_if_not(_Other_root_name_end, _Other_last, _Is_slash);
+            const bool _My_has_root_name    = _My_root_name_end != _My_relative;
+            const bool _Other_has_root_name = _Other_root_name_end != _Other_relative;
+            // If !this->has_root_directory() and _Other.has_root_directory(), a value less than 0
+            // If this->has_root_directory() and !_Other.has_root_directory(), a value greater than 0
+            const int _Root_name_cmp = _My_has_root_name - _Other_has_root_name;
+            if (_Root_name_cmp != 0) {
+                return _Root_name_cmp;
+            }
+
+            // Otherwise, lexicographic by element
+            for (;;) {
+                const bool _My_empty    = _My_relative == _My_last;
+                const bool _Other_empty = _Other_relative == _Other_last;
+                const int _Empty_cmp    = _Other_empty - _My_empty;
+                if (_My_empty || _Empty_cmp != 0) {
+                    return _Empty_cmp;
+                }
+
+                const bool _My_slash    = _Is_slash(*_My_relative);
+                const bool _Other_slash = _Is_slash(*_Other_relative);
+                const int _Slash_cmp    = _Other_slash - _My_slash;
+                if (_Slash_cmp != 0) {
+                    return _Slash_cmp;
+                }
+
+                if (_My_slash) { // comparing directory-separator
+                    _My_relative    = _STD find_if_not(_My_relative + 1, _My_last, _Is_slash);
+                    _Other_relative = _STD find_if_not(_Other_relative + 1, _Other_last, _Is_slash);
+                    continue;
+                }
+
+                const int _Cmp = *_My_relative - *_Other_relative;
+                if (_Cmp != 0) {
+                    return _Cmp;
+                }
+
+                ++_My_relative;
+                ++_Other_relative;
+            }
+        }
+
+        _NODISCARD int compare(const value_type* const _Other) const noexcept /* strengthened */ {
+            // compare *this with _Other
+            return compare(static_cast<wstring_view>(_Other));
+        }
+
+        _NODISCARD path root_name() const {
+            // parse the root-name from *this and return a copy if present; otherwise, return the empty path
+            return _Parse_root_name(_Text);
+        }
+
+        _NODISCARD path root_directory() const {
+            // parse the root-directory from *this and return a copy if present; otherwise, return the empty path
+            return _Parse_root_directory(_Text);
+        }
+
+        _NODISCARD path root_path() const {
+            // parse the root-path from *this and return a copy if present; otherwise, return the empty path
+            return _Parse_root_path(_Text);
+        }
+
+        _NODISCARD path relative_path() const {
+            // parse the relative-path from *this and return a copy if present; otherwise, return the empty path
+            return _Parse_relative_path(_Text);
+        }
+
+        _NODISCARD path parent_path() const {
+            // parse the parent-path from *this and return a copy if present; otherwise, return the empty path
+            return _Parse_parent_path(_Text);
+        }
+
+        _NODISCARD path filename() const {
+            // parse the filename from *this and return a copy if present; otherwise, return the empty path
+            return _Parse_filename(_Text);
+        }
+
+        _NODISCARD path stem() const {
+            // parse the stem from *this and return a copy if present; otherwise, return the empty path
+            return _Parse_stem(_Text);
+        }
+
+        _NODISCARD path extension() const {
+            // parse the extension from *this and return a copy if present; otherwise, return the empty path
+            return _Parse_extension(_Text);
+        }
+
+        _NODISCARD bool empty() const noexcept {
+            return _Text.empty();
+        }
+
+        _NODISCARD bool has_root_name() const noexcept /* strengthened */ {
+            // parse the root-name from *this and return whether it exists
+            return !_Parse_root_name(_Text).empty();
+        }
+
+        _NODISCARD bool has_root_directory() const noexcept /* strengthened */ {
+            // parse the root-directory from *this and return whether it exists
+            return !_Parse_root_directory(_Text).empty();
+        }
+
+        _NODISCARD bool has_root_path() const noexcept /* strengthened */ {
+            // parse the root-path from *this and return whether it exists
+            return !_Parse_root_path(_Text).empty();
+        }
+
+        _NODISCARD bool has_relative_path() const noexcept /* strengthened */ {
+            // parse the relative-path from *this and return whether it exists
+            return !_Parse_relative_path(_Text).empty();
+        }
+
+        _NODISCARD bool has_parent_path() const noexcept /* strengthened */ {
+            // parse the parent-path from *this and return whether it exists
+            return !_Parse_parent_path(_Text).empty();
+        }
+
+        _NODISCARD bool has_filename() const noexcept /* strengthened */ {
+            // parse the filename from *this and return whether it exists
+            return !_Parse_filename(_Text).empty();
+        }
+
+        _NODISCARD bool has_stem() const noexcept /* strengthened */ {
+            // parse the stem from *this and return whether it exists
+            return !_Parse_stem(_Text).empty();
+        }
+
+        _NODISCARD bool has_extension() const noexcept /* strengthened */ {
+            // parse the extension from *this and return whether it exists
+            return !_Parse_extension(_Text).empty();
+        }
+
+        _NODISCARD bool is_absolute() const noexcept /* strengthened */ {
+            // paths with a root-name that is a drive letter and no root-directory are drive relative, such as x:example
+            // paths with no root-name or root-directory are relative, such as example
+            // paths with no root-name but a root-directory are root relative, such as \example
+            // all other paths are absolute
+            const auto _First = _Text.data();
+            const auto _Last  = _First + _Text.size();
+            if (_Has_drive_letter_prefix(_First, _Last)) { // test for X:\ but not X:cat
+                return _Last - _First >= 3 && _Is_slash(_First[2]);
+            }
+
+            // if root-name is otherwise nonempty, then it must be one of the always-absolute prefixes like
+            // \\?\ or \\server, so the path is absolute. Otherwise it is relative.
+            return _First != _Find_root_name_end(_First, _Last);
+        }
+
+        _NODISCARD bool is_relative() const noexcept /* strengthened */ {
+            // test if *this is a relative path
+            return !is_absolute();
+        }
+
+        _NODISCARD path lexically_normal() const {
+            constexpr wstring_view _Dot     = L"."sv;
+            constexpr wstring_view _Dot_dot = L".."sv;
+
+            // N4950 [fs.path.generic]/6:
+            // "Normalization of a generic format pathname means:"
+
+            // "1. If the path is empty, stop."
+            if (empty()) {
+                return {};
+            }
+
+            // "2. Replace each slash character in the root-name with a preferred-separator."
+            const auto _First         = _Text.data();
+            const auto _Last          = _First + _Text.size();
+            const auto _Root_name_end = _Find_root_name_end(_First, _Last);
+            string_type _Normalized(_First, _Root_name_end);
+            _STD replace(_Normalized.begin(), _Normalized.end(), L'/', L'\\');
+
+            // "3. Replace each directory-separator with a preferred-separator.
+            // [ Note 4: The generic pathname grammar defines directory-separator
+            // as one or more slashes and preferred-separators. -end note ]"
+            vector<wstring_view> _Vec; // Empty wstring_view means directory-separator
+                                       // that will be normalized to a preferred-separator.
+                                       // Non-empty wstring_view means filename.
+            _Vec.reserve(19); // avoid frequent re-allocations
+            bool _Has_root_directory = false; // true: there is a slash right after root-name.
+            auto _Ptr                = _Root_name_end;
+            if (_Ptr != _Last && _Is_slash(*_Ptr)) {
+                _Has_root_directory = true;
+                _Normalized += preferred_separator;
+                ++_Ptr;
+                while (_Ptr != _Last && _Is_slash(*_Ptr)) {
+                    ++_Ptr;
+                }
+            }
+            // _Vec will start with a filename (if not empty).
+            while (_Ptr != _Last) {
+                if (_Is_slash(*_Ptr)) {
+                    if (_Vec.empty() || !_Vec.back().empty()) {
+                        // collapse one or more slashes and preferred-separators to one empty wstring_view
+                        _Vec.emplace_back();
+                    }
+                    ++_Ptr;
+                } else {
+                    const auto _Filename_end = _STD find_if(_Ptr + 1, _Last, _Is_slash);
+                    _Vec.emplace_back(_Ptr, static_cast<size_t>(_Filename_end - _Ptr));
+                    _Ptr = _Filename_end;
+                }
+            }
+
+            // "4. Remove each dot filename and any immediately following directory-separator."
+            // "5. As long as any appear, remove a non-dot-dot filename immediately followed by a
+            // directory-separator and a dot-dot filename, along with any immediately following directory-separator."
+            // "6. If there is a root-directory, remove all dot-dot filenames
+            // and any directory-separators immediately following them.
+            // [ Note 5: These dot-dot filenames attempt to refer to nonexistent parent directories. -end note ]"
+            auto _New_end = _Vec.begin();
+            for (auto _Pos = _Vec.begin(); _Pos != _Vec.end();) {
+                const auto _Elem = *_Pos++; // _Pos points at a filename here; it points at end or a separator after ++.
+                if (_Elem == _Dot) {
+                    // ignore dot (and following separator).
+                    if (_Pos == _Vec.end()) {
+                        break;
+                    }
+                } else if (_Elem != _Dot_dot) {
+                    // append normal filename and separator.
+                    *_New_end++ = _Elem; // _New_end points at end or a separator after ++.
+                    if (_Pos == _Vec.end()) {
+                        break;
+                    }
+                    ++_New_end; // _New_end(<=_Pos) doesn't point at end; accept separator.
+                } else { // _Dot_dot
+                    if (_New_end != _Vec.begin() && _New_end[-2] != _Dot_dot) {
+                        // _New_end == _Vec.begin() + 2n here.
+                        // remove preceding non-dot-dot filename and separator.
+                        _New_end -= 2;
+                        if (_Pos == _Vec.end()) {
+                            break;
+                        }
+                    } else if (!_Has_root_directory) {
+                        // due to 6, append dot-dot and separator only if !_Has_root_directory.
+                        *_New_end++ = _Dot_dot;
+                        if (_Pos == _Vec.end()) {
+                            break;
+                        }
+                        ++_New_end;
+                    } else {
+                        // ignore dot-dot and separator.
+                        if (_Pos == _Vec.end()) {
+                            break;
+                        }
+                    }
+                }
+                ++_Pos; // _Pos points at a separator here; it points at end or a filename after ++.
+            }
+            _Vec.erase(_New_end, _Vec.end());
+
+            // "7. If the last filename is dot-dot, remove any trailing directory-separator."
+            if (_Vec.size() >= 2 && _Vec.back().empty() && _Vec.end()[-2] == _Dot_dot) {
+                _Vec.pop_back();
+            }
+
+            // Build up _Normalized by flattening _Vec.
+            for (const auto& _Elem : _Vec) {
+                if (_Elem.empty()) {
+                    _Normalized += preferred_separator;
+                } else {
+                    _Normalized += _Elem;
+                }
+            }
+
+            // "8. If the path is empty, add a dot."
+            if (_Normalized.empty()) {
+                _Normalized = _Dot;
+            }
+
+            // "The result of normalization is a path in normal form, which is said to be normalized."
+            return path(_STD move(_Normalized));
+        }
+
+        _NODISCARD inline path lexically_relative(const path& _Base) const;
+
+        _NODISCARD path lexically_proximate(const path& _Base) const {
+            path _Result = lexically_relative(_Base);
+
+            if (_Result.empty()) {
+                _Result = *this;
+            }
+
+            return _Result;
+        }
+
+        using iterator       = _Path_iterator<string_type::const_iterator>;
+        using const_iterator = iterator;
+
+        _NODISCARD inline iterator begin() const;
+        _NODISCARD inline iterator end() const noexcept; // strengthened
+
+        template <class _Elem, class _Traits>
+        friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const path& _Path) {
+            // insert a path into a stream
+            return _Ostr << _STD quoted(_Path.string<_Elem, _Traits>());
+        }
+
+        template <class _Elem, class _Traits>
+        friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, path& _Path) {
+            // extract a path from a stream
+            basic_string<_Elem, _Traits> _Tmp;
+            _Istr >> _STD quoted(_Tmp);
+            _Path = _STD move(_Tmp); // obvious optimization not depicted in N4950 [fs.path.io]/3
+            return _Istr;
+        }
+
+        _NODISCARD friend bool operator==(const path& _Left, const path& _Right) noexcept {
+            return _Left.compare(_Right._Text) == 0;
+        }
+
+#if _HAS_CXX20
+        _NODISCARD friend strong_ordering operator<=>(const path& _Left, const path& _Right) noexcept {
+            return _Left.compare(_Right._Text) <=> 0;
+        }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        _NODISCARD friend bool operator!=(const path& _Left, const path& _Right) noexcept {
+            return _Left.compare(_Right) != 0;
+        }
+
+        _NODISCARD friend bool operator<(const path& _Left, const path& _Right) noexcept {
+            return _Left.compare(_Right) < 0;
+        }
+
+        _NODISCARD friend bool operator>(const path& _Left, const path& _Right) noexcept {
+            return _Left.compare(_Right) > 0;
+        }
+
+        _NODISCARD friend bool operator<=(const path& _Left, const path& _Right) noexcept {
+            return _Left.compare(_Right) <= 0;
+        }
+
+        _NODISCARD friend bool operator>=(const path& _Left, const path& _Right) noexcept {
+            return _Left.compare(_Right) >= 0;
+        }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+        _NODISCARD friend path operator/(const path& _Left, const path& _Right) { // append a pair of paths together
+            const auto _Right_size  = _Right._Text.size();
+            const auto _Right_first = _Right._Text.data();
+            const auto _Right_last  = _Right_first + _Right_size;
+
+            // Handle the most common case: !has_root_name(_Right) && !has_root_directory(_Right)
+            if (_Right_size != 0 && !_Has_drive_letter_prefix(_Right_first, _Right_last) && !_Is_slash(*_Right_first)) {
+                const auto _Left_size  = _Left._Text.size();
+                const auto _Left_first = _Left._Text.data();
+                const auto _Left_last  = _Left_first + _Left_size;
+
+                // Appending a slash to "X:" would make it an absolute path
+                const bool _Left_is_just_drive = _Left_size == 2 && _Is_drive_prefix(_Left_first);
+                const bool _Is_slash_needed    = _Left_size != 0 && !_Left_is_just_drive && !_Is_slash(_Left_last[-1]);
+
+                const auto _Total_size = _Left_size + static_cast<size_t>(_Is_slash_needed) + _Right_size;
+
+                path _Tmp;
+                _Tmp._Text._Resize_and_overwrite(_Total_size, [=](wchar_t* _Ptr, const size_t _Size) {
+                    _CSTD memcpy(_Ptr, _Left_first, _Left_size * sizeof(wchar_t));
+                    _Ptr += _Left_size;
+                    if (_Is_slash_needed) {
+                        *_Ptr++ = preferred_separator;
+                    }
+                    _CSTD memcpy(_Ptr, _Right_first, _Right_size * sizeof(wchar_t));
+                    return _Size;
+                });
+                return _Tmp;
+            }
+
+            path _Tmp = _Left;
+            _Tmp /= _Right;
+            return _Tmp;
+        }
+
+    private:
+        string_type _Text;
+    };
+
+    _EXPORT_STD template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
+    _CXX20_DEPRECATE_U8PATH _NODISCARD path u8path(const _Src& _Source) { // construct a path from UTF-8 _Source
+        return path{_Convert_Source_to_wide(_Source, _Utf8_conversion{})};
+    }
+
+    _EXPORT_STD template <class _InIt>
+    _CXX20_DEPRECATE_U8PATH _NODISCARD path u8path(_InIt _First, _InIt _Last) {
+        // construct a path from UTF-8 [_First, _Last)
+        static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4950 [fs.req]/3");
+        return path{_Convert_range_to_wide(_First, _Last, _Utf8_conversion{})};
+    }
+
+    template <class _Base_iter>
+    class _Path_iterator { // almost bidirectional iterator for path
+    public:
+        // Note that the path::iterator can be decremented and can be dereferenced multiple times,
+        // but doesn't actually meet the forward iterator requirements. See N4950 [fs.path.itr]/2:
+        //  ... for dereferenceable iterators a and b of type path::iterator with a == b, there is no requirement
+        //  that *a and *b are bound to the same object
+        // This means that you can't give path::iterator to std::reverse_iterator, as operator* there ends
+        // up returning a reference to a destroyed temporary. Other algorithms requiring bidirectional
+        // iterators may be similarly affected, so we've marked input for now.
+        // Also note, in the vector<path>(p.begin(), p.end()) case, the user actually probably wants
+        // input behavior, as distance()-ing a path is fairly expensive.
+        using iterator_category = input_iterator_tag;
+        using value_type        = path;
+        using difference_type   = ptrdiff_t;
+        using pointer           = const path*;
+        using reference         = const path&;
+
+        _Path_iterator() = default;
+
+        _Path_iterator(const _Base_iter& _Position_, const path* _Mypath_) noexcept
+            : _Position(_Position_), _Element(), _Mypath(_Mypath_) {}
+
+        _Path_iterator(const _Base_iter& _Position_, const path& _Element_, const path* _Mypath_)
+            : _Position(_Position_), _Element(_Element_), _Mypath(_Mypath_) {}
+        _Path_iterator(const _Base_iter& _Position_, path&& _Element_, const path* _Mypath_)
+            : _Position(_Position_), _Element(_STD move(_Element_)), _Mypath(_Mypath_) {}
+
+        _Path_iterator(const _Path_iterator&)            = default;
+        _Path_iterator(_Path_iterator&&)                 = default;
+        _Path_iterator& operator=(const _Path_iterator&) = default;
+        _Path_iterator& operator=(_Path_iterator&&)      = default;
+
+        _NODISCARD reference operator*() const noexcept {
+            return _Element;
+        }
+
+        _NODISCARD pointer operator->() const noexcept {
+            return _STD addressof(_Element);
+        }
+
+        _Path_iterator& operator++() {
+            const auto& _Text = _Mypath->native();
+            const auto _Size  = _Element.native().size();
+            _Adl_verify_range(_Text.begin(), _Position); // engaged when *this is checked
+            const auto _Begin = _Text.data();
+            const auto _End   = _Begin + _Text.size();
+            _Adl_verify_range(_Begin, _Position); // engaged when *this is unchecked
+            if (_Begin == _Get_unwrapped(_Position)) { // test if the next element will be root-directory
+                _Position += static_cast<ptrdiff_t>(_Size);
+                const auto _First              = _Text.data();
+                const auto _Last               = _First + _Text.size();
+                const auto _Root_name_end      = _Find_root_name_end(_First, _Last);
+                const auto _Root_directory_end = _STD find_if_not(_Root_name_end, _Last, _Is_slash);
+                if (_First != _Root_name_end && _Root_name_end != _Root_directory_end) {
+                    // current element is root-name, root-directory exists, so next is root-directory
+                    _Element._Text.assign(_Root_name_end, _Root_directory_end);
+                    return *this;
+                }
+
+                // If we get here, either there is no root-name, and by !_Is_slash(*_Position), no root-directory,
+                // or, current element is root-name, and root-directory doesn't exist.
+                // Either way, the next element is the first of relative-path
+            } else if (_Is_slash(*_Position)) { // current element is root-directory, or the "magic empty path"
+                if (_Size == 0) { // current element was "magic empty path", become end()
+                    ++_Position;
+                    return *this;
+                }
+
+                // current element was root-directory, advance to relative-path
+                _Position += static_cast<ptrdiff_t>(_Size);
+            } else { // current element is one of relative-path
+                _Position += static_cast<ptrdiff_t>(_Size);
+            }
+
+            if (_Get_unwrapped(_Position) == _End) {
+                _Element.clear();
+                return *this;
+            }
+
+            // at this point, the next element is a standard filename from relative_path(), and _Position
+            // points at the preferred-separator or fallback-separator after the previous element
+            while (_Is_slash(*_Position)) { // advance to the start of the following path element
+                if (_Get_unwrapped(++_Position) == _End) { // "magic" empty element selected
+                    --_Position;
+                    _Element.clear();
+                    return *this;
+                }
+            }
+
+            _Element._Text.assign(_Get_unwrapped(_Position), _STD find_if(_Get_unwrapped(_Position), _End, _Is_slash));
+            return *this;
+        }
+
+        _Path_iterator operator++(int) {
+            _Path_iterator _Tmp = *this;
+            ++*this;
+            return _Tmp;
+        }
+
+        _Path_iterator& operator--() {
+            const auto& _Text = _Mypath->native();
+            _Adl_verify_range(_Text.begin(), _Position); // engaged when *this is checked
+            const auto _First = _Text.data();
+            _Adl_verify_range(_First, _Position); // engaged when *this is unchecked
+            const auto _Last                   = _First + _Text.size();
+            const auto _Root_name_end_ptr      = _Find_root_name_end(_First, _Last);
+            const auto _Root_directory_end_ptr = _STD find_if_not(_Root_name_end_ptr, _Last, _Is_slash);
+
+            if (_Root_name_end_ptr != _Root_directory_end_ptr && _Get_unwrapped(_Position) == _Root_directory_end_ptr) {
+                // current element is the first of relative-path, and the prev element is root-directory
+                _Seek_wrapped(_Position, _Root_name_end_ptr);
+                _Element._Text.assign(
+                    _Root_name_end_ptr, static_cast<size_t>(_Root_directory_end_ptr - _Root_name_end_ptr));
+                return *this;
+            }
+
+            if (_First != _Root_name_end_ptr && _Get_unwrapped(_Position) == _Root_name_end_ptr) {
+                // current element is root-directory or, if that doesn't exist, first
+                // element of relative-path prev element therefore is root-name
+                _Seek_wrapped(_Position, _First);
+                _Element._Text.assign(_First, static_cast<size_t>(_Root_name_end_ptr - _First));
+                return *this;
+            }
+
+            // from here, the result will be somewhere in relative-path
+            if (_Get_unwrapped(_Position) == _Last && _Is_slash(_Position[-1])) { // target is "magic empty path"
+                --_Position;
+                _Element.clear();
+                return *this;
+            }
+
+            while (_Root_directory_end_ptr != _Get_unwrapped(_Position) && _Is_slash(_Position[-1])) {
+                --_Position;
+            }
+
+            const auto _New_end = _Position;
+            while (_Root_directory_end_ptr != _Get_unwrapped(_Position) && !_Is_slash(_Position[-1])) {
+                --_Position;
+            }
+
+            _Element._Text.assign(_Position, _New_end);
+            return *this;
+        }
+
+        _Path_iterator operator--(int) {
+            _Path_iterator _Tmp = *this;
+            --*this;
+            return _Tmp;
+        }
+
+        _NODISCARD friend bool operator==(const _Path_iterator& _Lhs, const _Path_iterator& _Rhs) {
+            return _Lhs._Position == _Rhs._Position;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const _Path_iterator& _Lhs, const _Path_iterator& _Rhs) {
+            return _Lhs._Position != _Rhs._Position;
+        }
+#endif // !_HAS_CXX20
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+        friend void _Verify_range(const _Path_iterator& _Lhs, const _Path_iterator& _Rhs) {
+            _Verify_range(_Lhs._Position, _Rhs._Position);
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        using _Prevent_inheriting_unwrap = _Path_iterator;
+
+        template <class _Iter2 = _Base_iter, enable_if_t<_Unwrappable_v<const _Iter2&>, int> = 0>
+        _NODISCARD _Path_iterator<_Unwrapped_t<const _Iter2&>> _Unwrapped() const& {
+            return {_Position._Unwrapped(), _Element, _Mypath};
+        }
+        template <class _Iter2 = _Base_iter, enable_if_t<_Unwrappable_v<_Iter2>, int> = 0>
+        _NODISCARD _Path_iterator<_Unwrapped_t<_Iter2>> _Unwrapped() && noexcept {
+            _STL_INTERNAL_STATIC_ASSERT(_Has_nothrow_unwrapped<_Iter2>);
+            return {_Position._Unwrapped(), _STD move(_Element), _Mypath};
+        }
+
+        static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_Base_iter>;
+
+        template <class _Other>
+        friend class _Path_iterator;
+
+        template <class _Other, enable_if_t<_Wrapped_seekable_v<_Base_iter, const _Other&>, int> = 0>
+        constexpr void _Seek_to(const _Path_iterator<_Other>& _It) {
+            _Position._Seek_to(_It._Position);
+            _Element = _It._Element;
+            // _Mypath intentionally unchanged
+        }
+
+    private:
+        // if the current element is the "magic empty path",
+        //   points to preferred-separator or fallback-separator immediately before
+        // otherwise, points to the first element of _Element
+        _Base_iter _Position{};
+        path _Element{};
+        const path* _Mypath{};
+    };
+
+    _EXPORT_STD inline void swap(path& _Left, path& _Right) noexcept {
+        _Left.swap(_Right);
+    }
+
+    _EXPORT_STD _NODISCARD inline size_t hash_value(const path& _Path) noexcept {
+        // calculate a hash value for _Path
+        // See path::compare; we effectively decompose the path with special handling for root_name, root_directory.
+        // Examples:
+        // c:\cat\dog =>  {"c:", true , "cat", "dog"}
+        // c:cat\dog =>   {"c:", false, "cat", "dog"}
+        // \cat\dog =>    {""  , true , "cat", "dog"}
+        // cat\dog =>     {""  , false, "cat", "dog"}
+        // c:\cat\dog\ => {"c:", true , "cat", "dog", ""}
+        size_t _Val       = _FNV_offset_basis;
+        const auto& _Text = _Path.native();
+        const auto _First = _Text.data();
+        const auto _Last  = _First + _Text.size();
+
+        // First, like compare, examine the raw root_name directly
+        auto _Next = _Find_root_name_end(_First, _Last);
+        _Val       = _Fnv1a_append_range(_Val, _First, _Next);
+
+        // The remaining path elements, including root_directory, are effectively hashed by normalizing each
+        // directory-separator into a single preferred-separator when that goes into the hash function.
+        // path::compare has special handling for root_directory to ensure c:\cat sorts before c:cat, but hash only
+        // cares about equality, so no special case is necessary.
+        bool _Slash_inserted = false;
+        for (; _Next != _Last; ++_Next) {
+            if (_Is_slash(*_Next)) {
+                if (!_Slash_inserted) {
+                    _Val            = _Fnv1a_append_value(_Val, path::preferred_separator);
+                    _Slash_inserted = true;
+                }
+            } else {
+                _Val            = _Fnv1a_append_value(_Val, *_Next);
+                _Slash_inserted = false;
+            }
+        }
+
+        return _Val;
+    }
+
+    _NODISCARD inline bool _Starts_with_root_name(const wchar_t* const _First, const wchar_t* const _Last) {
+        return _Find_root_name_end(_First, _Last) != _First;
+    }
+
+    _NODISCARD inline bool _Relative_path_contains_root_name(const path& _Path) {
+        const auto& _Native = _Path.native();
+        auto _First         = _Native.data();
+        const auto _Last    = _First + _Native.size();
+        _First              = _Find_relative_path(_First, _Last);
+        while (_First != _Last) {
+            const auto _Next = _STD find_if(_First, _Last, _Is_slash);
+            if (_Starts_with_root_name(_First, _Next)) {
+                return true;
+            }
+            _First = _STD find_if_not(_Next, _Last, _Is_slash);
+        }
+        return false;
+    }
+
+    _NODISCARD inline path path::lexically_relative(const path& _Base_raw) const {
+        constexpr wstring_view _Dot     = L"."sv;
+        constexpr wstring_view _Dot_dot = L".."sv;
+
+        // LWG-3699: `lexically_relative` on UNC drive paths (`\\?\C:\...`) results in a default-constructed value
+        // This avoids doing any unnecessary copies;
+        // the return value of `relative_path()` is lifetime-extended if necessary.
+        const bool _Both_unc_paths = _Is_drive_prefix_with_slash_slash_question(_Text)
+                                  && _Is_drive_prefix_with_slash_slash_question(_Base_raw._Text);
+        const path& _This          = _Both_unc_paths ? relative_path() : *this;
+        const path& _Base          = _Both_unc_paths ? _Base_raw.relative_path() : _Base_raw;
+
+        path _Result;
+
+        if (_This.root_name() != _Base.root_name() || _This.is_absolute() != _Base.is_absolute()
+            || (!_This.has_root_directory() && _Base.has_root_directory())
+            || (_Relative_path_contains_root_name(_This) || _Relative_path_contains_root_name(_Base))) {
+            return _Result;
+        }
+
+        const iterator _This_end   = _This.end();
+        const iterator _Base_begin = _Base.begin();
+        const iterator _Base_end   = _Base.end();
+
+        auto _Mismatched  = _STD mismatch(_This.begin(), _This_end, _Base_begin, _Base_end);
+        iterator& _A_iter = _Mismatched.first;
+        iterator& _B_iter = _Mismatched.second;
+
+        if (_A_iter == _This_end && _B_iter == _Base_end) {
+            _Result = _Dot;
+            return _Result;
+        }
+
+        { // Skip root-name and root-directory elements, N4950 [fs.path.itr]/4.1, 4.2
+            ptrdiff_t _B_dist = _STD distance(_Base_begin, _B_iter);
+
+            const ptrdiff_t _Base_root_dist =
+                static_cast<ptrdiff_t>(_Base.has_root_name()) + static_cast<ptrdiff_t>(_Base.has_root_directory());
+
+            while (_B_dist < _Base_root_dist) {
+                ++_B_iter;
+                ++_B_dist;
+            }
+        }
+
+        ptrdiff_t _Num = 0;
+
+        for (; _B_iter != _Base_end; ++_B_iter) {
+            const path& _Elem = *_B_iter;
+
+            if (_Elem.empty()) { // skip empty element, N4950 [fs.path.itr]/4.4
+            } else if (_Elem == _Dot) { // skip filename elements that are dot, N4950 [fs.path.gen]/3.6
+            } else if (_Elem == _Dot_dot) {
+                --_Num;
+            } else {
+                ++_Num;
+            }
+        }
+
+        if (_Num < 0) {
+            return _Result;
+        }
+
+        if (_Num == 0 && (_A_iter == _This_end || _A_iter->empty())) {
+            _Result = _Dot;
+            return _Result;
+        }
+
+        for (; _Num > 0; --_Num) {
+            _Result /= _Dot_dot;
+        }
+
+        for (; _A_iter != _This_end; ++_A_iter) {
+            _Result /= *_A_iter;
+        }
+
+        return _Result;
+    }
+
+    _NODISCARD inline path::iterator path::begin() const {
+        const auto _First         = _Text.data();
+        const auto _Last          = _First + _Text.size();
+        const auto _Root_name_end = _Find_root_name_end(_First, _Last);
+        const wchar_t* _First_end;
+        if (_First == _Root_name_end) { // first element isn't root-name
+            auto _Root_directory_end = _STD find_if_not(_Root_name_end, _Last, _Is_slash);
+            if (_First == _Root_directory_end) { // first element is first relative-path entry
+                _First_end = _STD find_if(_Root_directory_end, _Last, _Is_slash);
+            } else { // first element is root-directory
+                _First_end = _Root_directory_end;
+            }
+        } else { // first element is root-name
+            _First_end = _Root_name_end;
+        }
+
+        return iterator(_Text.cbegin(), wstring_view(_First, static_cast<size_t>(_First_end - _First)), this);
+    }
+
+    _NODISCARD inline path::iterator path::end() const noexcept /* strengthened */ {
+        return iterator(_Text.cend(), this);
+    }
+
+    _EXPORT_STD class _NODISCARD filesystem_error : public system_error { // base of all filesystem-error exceptions
+    public:
+        filesystem_error(const string& _Message, const error_code _Errcode)
+            : system_error(_Errcode, _Message), _What(runtime_error::what()) {}
+
+        filesystem_error(const string& _Message, const path& _Path1_arg, const error_code _Errcode)
+            : system_error(_Errcode, _Message), _Path1(_Path1_arg), _Path2(),
+              _What(_Pretty_message(runtime_error::what(), _Path1_arg)) {}
+
+        filesystem_error(
+            const string& _Message, const path& _Path1_arg, const path& _Path2_arg, const error_code _Errcode)
+            : system_error(_Errcode, _Message), _Path1(_Path1_arg), _Path2(_Path2_arg),
+              _What(_Pretty_message(runtime_error::what(), _Path1_arg, _Path2_arg)) {}
+
+        _NODISCARD const path& path1() const noexcept {
+            return _Path1;
+        }
+
+        _NODISCARD const path& path2() const noexcept {
+            return _Path2;
+        }
+
+        _NODISCARD const char* what() const noexcept override {
+            return _What.c_str();
+        }
+
+    private:
+        static string _Pretty_message(const string_view _Op, const path& _Path1, const path& _Path2 = {}) {
+            string _Result;
+            // Convert the paths to narrow encoding in a way that gracefully handles non-encodable characters
+            const auto _Code_page   = __std_fs_code_page();
+            const string _Path1_str = _Convert_wide_to_narrow_replace_chars<char_traits<char>>(
+                _Code_page, _Path1.native(), allocator<char>{});
+            const string _Path2_str = _Convert_wide_to_narrow_replace_chars<char_traits<char>>(
+                _Code_page, _Path2.native(), allocator<char>{});
+            _Result.reserve(_Op.size() + (_Path2_str.empty() ? 4 : 8) + _Path1_str.size() + _Path2_str.size());
+            _Result += _Op;
+            _Result += R"(: ")"sv; // 3 chars
+            _Result += _Path1_str;
+            if (!_Path2_str.empty()) {
+                _Result += R"(", ")"sv; // 4 chars
+                _Result += _Path2_str;
+            }
+            _Result += '"'; // 1 char
+            return _Result;
+        }
+
+        path _Path1;
+        path _Path2;
+        string _What;
+
+#if !_HAS_EXCEPTIONS
+    protected:
+        void _Doraise() const override { // perform class-specific exception handling
+            _RAISE(*this);
+        }
+#endif // !_HAS_EXCEPTIONS
+    };
+
+    [[noreturn]] inline void _Throw_fs_error(const char* _Op, __std_win_error _Error) {
+        _THROW(filesystem_error(_Op, _Make_ec(_Error)));
+    }
+
+    [[noreturn]] inline void _Throw_fs_error(const char* _Op, __std_win_error _Error, const path& _Path1) {
+        _THROW(filesystem_error(_Op, _Path1, _Make_ec(_Error)));
+    }
+
+    [[noreturn]] inline void _Throw_fs_error(
+        const char* _Op, __std_win_error _Error, const path& _Path1, const path& _Path2) {
+        _THROW(filesystem_error(_Op, _Path1, _Path2, _Make_ec(_Error)));
+    }
+
+    [[noreturn]] inline void _Throw_fs_error(const char* _Op, const error_code& _Error) {
+        _THROW(filesystem_error(_Op, _Error));
+    }
+
+    [[noreturn]] inline void _Throw_fs_error(const char* _Op, const error_code& _Error, const path& _Path1) {
+        _THROW(filesystem_error(_Op, _Path1, _Error));
+    }
+
+    [[noreturn]] inline void _Throw_fs_error(
+        const char* _Op, const error_code& _Error, const path& _Path1, const path& _Path2) {
+        _THROW(filesystem_error(_Op, _Path1, _Path2, _Error));
+    }
+
+    _EXPORT_STD enum class file_type {
+        none,
+        not_found,
+        regular,
+        directory,
+        symlink,
+
+        block, // not used on Windows
+        character, // not used in this implementation; theoretically some special files like CON
+                   // might qualify, but querying for this is extremely expensive and unlikely
+                   // to be useful in practice
+
+        fifo, // not used on Windows (\\.\pipe named pipes don't behave exactly like POSIX fifos)
+        socket, // not used on Windows
+        unknown,
+
+        junction // implementation-defined value indicating an NT junction
+    };
+
+    _EXPORT_STD enum class perms {
+        none = 0,
+
+        owner_read  = 0400,
+        owner_write = 0200,
+        owner_exec  = 0100,
+        owner_all   = 0700,
+
+        group_read  = 0040,
+        group_write = 0020,
+        group_exec  = 0010,
+        group_all   = 0070,
+
+        others_read  = 0004,
+        others_write = 0002,
+        others_exec  = 0001,
+        others_all   = 0007,
+
+        all        = 0777, // returned for all files without FILE_ATTRIBUTE_READONLY
+        set_uid    = 04000,
+        set_gid    = 02000,
+        sticky_bit = 01000,
+        mask       = 07777,
+        unknown    = 0xFFFF,
+
+        _All_write               = owner_write | group_write | others_write,
+        _File_attribute_readonly = all & ~_All_write // returned for files with FILE_ATTRIBUTE_READONLY
+    };
+
+    _BITMASK_OPS(_EXPORT_STD, perms)
+
+    _EXPORT_STD enum class copy_options {
+        none = static_cast<int>(__std_fs_copy_options::_None),
+
+        _Existing_mask     = static_cast<int>(__std_fs_copy_options::_Existing_mask),
+        skip_existing      = static_cast<int>(__std_fs_copy_options::_Skip_existing),
+        overwrite_existing = static_cast<int>(__std_fs_copy_options::_Overwrite_existing),
+        update_existing    = static_cast<int>(__std_fs_copy_options::_Update_existing),
+
+        recursive = 0x10,
+
+        _Symlinks_mask = 0xF00,
+        copy_symlinks  = 0x100,
+        skip_symlinks  = 0x200,
+
+        _Copy_form_mask   = 0xF000,
+        directories_only  = 0x1000,
+        create_symlinks   = 0x2000,
+        create_hard_links = 0x4000,
+
+        _Unspecified_copy_prevention_tag = 0x10000 // to be removed by LWG-3057
+    };
+
+    _BITMASK_OPS(_EXPORT_STD, copy_options)
+
+    _EXPORT_STD class file_status {
+    public:
+        // [fs.file_status.cons], constructors and destructor
+        file_status() noexcept = default;
+        explicit file_status(file_type _Ft, perms _Perms = perms::unknown) noexcept : _Myftype(_Ft), _Myperms(_Perms) {}
+        file_status(const file_status&) noexcept = default;
+        file_status(file_status&&) noexcept      = default;
+        ~file_status() noexcept                  = default;
+
+        // assignments
+        file_status& operator=(const file_status&) noexcept = default;
+        file_status& operator=(file_status&&) noexcept      = default;
+
+        // [fs.file_status.mods], modifiers
+        void type(file_type _Ft) noexcept {
+            _Myftype = _Ft;
+        }
+
+        void permissions(perms _Perms) noexcept {
+            _Myperms = _Perms;
+        }
+
+        // [fs.file_status.obs], observers
+        _NODISCARD file_type type() const noexcept {
+            return _Myftype;
+        }
+
+        _NODISCARD perms permissions() const noexcept {
+            return _Myperms;
+        }
+
+#if _HAS_CXX20
+        _NODISCARD friend bool operator==(const file_status& _Lhs, const file_status& _Rhs) noexcept {
+            return _Lhs._Myftype == _Rhs._Myftype && _Lhs._Myperms == _Rhs._Myperms;
+        }
+#endif // _HAS_CXX20
+
+        void _Refresh(const __std_win_error _Error, const __std_fs_stats& _Stats) noexcept {
+            if (_Error == __std_win_error::_Success) {
+                const auto _Attrs = _Stats._Attributes;
+
+                if (_Bitmask_includes_any(_Attrs, __std_fs_file_attr::_Readonly)) {
+                    this->permissions(perms::_File_attribute_readonly);
+                } else {
+                    this->permissions(perms::all);
+                }
+
+                if (_Bitmask_includes_any(_Attrs, __std_fs_file_attr::_Reparse_point)) {
+                    if (_Stats._Reparse_point_tag == __std_fs_reparse_tag::_Symlink) {
+                        this->type(file_type::symlink);
+                        return;
+                    }
+
+                    if (_Stats._Reparse_point_tag == __std_fs_reparse_tag::_Mount_point) {
+                        this->type(file_type::junction);
+                        return;
+                    }
+
+                    // All other reparse points considered ordinary files or directories
+                }
+
+                if (_Bitmask_includes_any(_Attrs, __std_fs_file_attr::_Directory)) {
+                    this->type(file_type::directory);
+                } else {
+                    this->type(file_type::regular);
+                }
+
+                return;
+            }
+
+            this->permissions(perms::unknown);
+            this->type(__std_is_file_not_found(_Error) ? file_type::not_found : file_type::none);
+        }
+
+    private:
+        file_type _Myftype = file_type::none;
+        perms _Myperms     = perms::unknown;
+    };
+
+    _EXPORT_STD _NODISCARD inline bool exists(const file_status _Status) noexcept {
+        // tests whether _Status indicates an existing file
+        switch (_Status.type()) {
+        case file_type::none:
+        case file_type::not_found:
+            return false;
+        case file_type::regular:
+        case file_type::directory:
+        case file_type::symlink:
+        case file_type::block:
+        case file_type::character:
+        case file_type::fifo:
+        case file_type::socket:
+        case file_type::unknown:
+        case file_type::junction:
+        default:
+            return true;
+        }
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_block_file(const file_status _Status) noexcept {
+        // tests whether _Status indicates a block file
+        return _Status.type() == file_type::block;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_character_file(const file_status _Status) noexcept {
+        // tests whether _Status indicates a character file
+        return _Status.type() == file_type::character;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_directory(const file_status _Status) noexcept {
+        // tests whether _Status indicates a directory
+        return _Status.type() == file_type::directory;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_fifo(const file_status _Status) noexcept {
+        // tests whether _Status indicates a fifo
+        return _Status.type() == file_type::fifo;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_other(const file_status _Status) noexcept {
+        // tests whether _Status indicates other file types
+        switch (_Status.type()) {
+        case file_type::none:
+        case file_type::not_found:
+        case file_type::regular:
+        case file_type::directory:
+        case file_type::symlink:
+            return false;
+        case file_type::block:
+        case file_type::character:
+        case file_type::fifo:
+        case file_type::socket:
+        case file_type::unknown:
+        case file_type::junction:
+        default:
+            return true;
+        }
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_regular_file(const file_status _Status) noexcept {
+        // tests whether _Status indicates a regular file
+        return _Status.type() == file_type::regular;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_socket(const file_status _Status) noexcept {
+        // tests whether _Status indicates a socket
+        return _Status.type() == file_type::socket;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_symlink(const file_status _Status) noexcept {
+        // tests whether _Status indicates a symlink
+        return _Status.type() == file_type::symlink;
+    }
+
+    struct _File_status_and_error {
+        file_status _Status;
+        __std_win_error _Error;
+
+        _NODISCARD bool _Not_good() const noexcept {
+            // [fs.op.status]/Throws: result values of file_status(file_type::not_found) and
+            // file_status(file_type::unknown) are not considered failures and do not cause an exception to be thrown.
+            return _Error != __std_win_error::_Success && _Status.type() != file_type::not_found
+                && _Status.type() != file_type::unknown;
+        }
+    };
+
+    inline constexpr auto _Status_stats_flags =
+        __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Follow_symlinks;
+
+    inline constexpr auto _Symlink_status_stats_flags =
+        __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Reparse_tag;
+
+#if _HAS_CXX20
+    _EXPORT_STD using file_time_type = _CHRONO time_point<_CHRONO file_clock>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using file_time_type = _CHRONO time_point<filesystem::_File_time_clock>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    struct _Dir_enum_impl;
+    struct _Recursive_dir_enum_impl;
+
+    _EXPORT_STD class directory_entry {
+    public:
+        // [fs.dir.entry.cons], constructors and destructor
+        directory_entry() noexcept : _Cached_data{}, _Path() {}
+
+        directory_entry(const directory_entry&)     = default;
+        directory_entry(directory_entry&&) noexcept = default;
+        explicit directory_entry(const filesystem::path& _Path_arg) : _Cached_data{}, _Path(_Path_arg) {
+            refresh();
+        }
+
+        directory_entry(const filesystem::path& _Path_arg, error_code& _Ec) : _Cached_data{}, _Path(_Path_arg) {
+            refresh(_Ec);
+            if (_Ec) {
+                _Path.clear();
+            }
+        }
+
+        ~directory_entry() = default;
+
+        // assignments
+        directory_entry& operator=(const directory_entry&)     = default;
+        directory_entry& operator=(directory_entry&&) noexcept = default;
+
+        // [fs.dir.entry.mods], modifiers
+        void assign(const filesystem::path& _Path_arg) {
+            _Path.assign(_Path_arg);
+            refresh();
+        }
+
+        void assign(const filesystem::path& _Path_arg, error_code& _Ec) {
+            _Ec.clear(); // for exception safety
+            _Path.assign(_Path_arg);
+            refresh(_Ec);
+        }
+
+        void replace_filename(const filesystem::path& _Path_arg) {
+            _Path.replace_filename(_Path_arg);
+            refresh();
+        }
+
+        void replace_filename(const filesystem::path& _Path_arg, error_code& _Ec) {
+            _Ec.clear(); // for exception safety
+            _Path.replace_filename(_Path_arg);
+            refresh(_Ec);
+        }
+
+        void refresh() {
+            const auto _Error = _Refresh(_Cached_data, _Path);
+            if (_Error != __std_win_error::_Success && !__std_is_file_not_found(_Error)) {
+                _Throw_fs_error("directory_entry::refresh", _Error, _Path);
+            }
+        }
+
+        void refresh(error_code& _Ec) noexcept {
+            _Ec.clear();
+            const auto _Error = _Refresh(_Cached_data, _Path);
+            if (_Error != __std_win_error::_Success && !__std_is_file_not_found(_Error)) {
+                _Ec = _Make_ec(_Error);
+            }
+        }
+
+    private:
+        _NODISCARD bool _Has_cached_attribute(const __std_fs_file_attr _Attrs) const noexcept {
+            return _Bitmask_includes_any(_Cached_data._Attributes, _Attrs);
+        }
+
+    public:
+        // [fs.dir.entry.obs], observers
+        _NODISCARD const filesystem::path& path() const noexcept {
+            return _Path;
+        }
+
+        operator const filesystem::path&() const noexcept {
+            return _Path;
+        }
+
+        _NODISCARD bool exists() const {
+            const auto _Type = this->status().type();
+            return _Type != file_type::not_found && _Type != file_type::none;
+        }
+
+        _NODISCARD bool exists(error_code& _Ec) const noexcept {
+            const auto _Type = this->status(_Ec).type();
+            return _Type != file_type::not_found && _Type != file_type::none;
+        }
+
+        _NODISCARD bool is_block_file() const {
+            return false;
+        }
+
+        _NODISCARD bool is_block_file(error_code& _Ec) const noexcept {
+            _Ec.clear();
+            return false;
+        }
+
+        _NODISCARD bool is_character_file() const {
+            return false;
+        }
+
+        _NODISCARD bool is_character_file(error_code& _Ec) const noexcept {
+            _Ec.clear();
+            return false;
+        }
+
+        _NODISCARD bool is_directory() const {
+            return _STD filesystem::is_directory(this->status());
+        }
+
+        _NODISCARD bool is_directory(error_code& _Ec) const noexcept {
+            return _STD filesystem::is_directory(this->status(_Ec));
+        }
+
+        _NODISCARD bool is_fifo() const {
+            return false;
+        }
+
+        _NODISCARD bool is_fifo(error_code& _Ec) const noexcept {
+            _Ec.clear();
+            return false;
+        }
+
+        _NODISCARD bool is_other() const {
+            return _STD filesystem::is_other(this->status());
+        }
+
+        _NODISCARD bool is_other(error_code& _Ec) const noexcept {
+            return _STD filesystem::is_other(this->status(_Ec));
+        }
+
+        _NODISCARD bool is_regular_file() const {
+            return _STD filesystem::is_regular_file(this->status());
+        }
+
+        _NODISCARD bool is_regular_file(error_code& _Ec) const noexcept {
+            return _STD filesystem::is_regular_file(this->status(_Ec));
+        }
+
+        _NODISCARD bool is_socket() const {
+            return false;
+        }
+
+        _NODISCARD bool is_socket(error_code& _Ec) const noexcept {
+            _Ec.clear();
+            return false;
+        }
+
+        _NODISCARD bool _Is_symlink_or_junction() const noexcept {
+            return _Has_cached_attribute(__std_fs_file_attr::_Reparse_point)
+                && (_Cached_data._Reparse_point_tag == __std_fs_reparse_tag::_Symlink
+                    || _Cached_data._Reparse_point_tag == __std_fs_reparse_tag::_Mount_point);
+        }
+
+        _NODISCARD bool is_symlink() const {
+            return _STD filesystem::is_symlink(this->symlink_status());
+        }
+
+        _NODISCARD bool is_symlink(error_code& _Ec) const noexcept {
+            return _STD filesystem::is_symlink(this->symlink_status(_Ec));
+        }
+
+        _NODISCARD bool _Available(const __std_fs_stats_flags _Flags) const noexcept {
+            return _Bitmask_includes_any(_Cached_data._Available, _Flags);
+        }
+
+    private:
+        _NODISCARD __std_win_error _File_size(uintmax_t& _Result) const noexcept {
+            if (_Available(__std_fs_stats_flags::_File_size)) {
+                _Result = _Cached_data._File_size;
+                return __std_win_error::_Success;
+            }
+
+            __std_fs_stats _Stats;
+            constexpr auto _Flags = __std_fs_stats_flags::_File_size | __std_fs_stats_flags::_Follow_symlinks;
+            const auto _Error =
+                __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags, _Cached_data._Symlink_hint_attributes());
+            if (_Error == __std_win_error::_Success) {
+                _Result = _Stats._File_size;
+            } else {
+                _Result = static_cast<uintmax_t>(-1);
+            }
+
+            return _Error;
+        }
+
+    public:
+        _NODISCARD uintmax_t file_size() const {
+            uintmax_t _Result;
+            const auto _Error = _File_size(_Result);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("directory_entry::file_size", _Error, _Path);
+            }
+
+            return _Result;
+        }
+
+        _NODISCARD uintmax_t file_size(error_code& _Ec) const noexcept {
+            uintmax_t _Result;
+            _Ec = _Make_ec(_File_size(_Result));
+            return _Result;
+        }
+
+    private:
+        _NODISCARD __std_win_error _Hard_link_count(uintmax_t& _Result) const noexcept {
+            if (_Available(__std_fs_stats_flags::_Link_count)) {
+                _Result = _Cached_data._Link_count;
+                return __std_win_error::_Success;
+            }
+
+            __std_fs_stats _Stats;
+            constexpr auto _Flags = __std_fs_stats_flags::_Link_count | __std_fs_stats_flags::_Follow_symlinks;
+            const auto _Error =
+                __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags, _Cached_data._Symlink_hint_attributes());
+            if (_Error == __std_win_error::_Success) {
+                _Result = _Stats._Link_count;
+            } else {
+                _Result = static_cast<uintmax_t>(-1);
+            }
+
+            return _Error;
+        }
+
+    public:
+        _NODISCARD uintmax_t hard_link_count() const {
+            uintmax_t _Result;
+            const auto _Error = _Hard_link_count(_Result);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("directory_entry::hard_link_count", _Error, _Path);
+            }
+
+            return _Result;
+        }
+
+        _NODISCARD uintmax_t hard_link_count(error_code& _Ec) const noexcept {
+            uintmax_t _Result;
+            _Ec = _Make_ec(_Hard_link_count(_Result));
+            return _Result;
+        }
+
+    private:
+        _NODISCARD __std_win_error _Last_write_time(file_time_type& _Result) const noexcept {
+            if (_Available(__std_fs_stats_flags::_Last_write_time)) {
+                _Result = file_time_type{file_time_type::duration{_Cached_data._Last_write_time}};
+                return __std_win_error::_Success;
+            }
+
+            __std_fs_stats _Stats;
+            constexpr auto _Flags = __std_fs_stats_flags::_Last_write_time | __std_fs_stats_flags::_Follow_symlinks;
+            const auto _Error =
+                __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags, _Cached_data._Symlink_hint_attributes());
+            if (_Error == __std_win_error::_Success) {
+                _Result = file_time_type{file_time_type::duration{_Stats._Last_write_time}};
+            } else {
+                _Result = file_time_type{file_time_type::duration{LLONG_MIN}};
+            }
+
+            return _Error;
+        }
+
+    public:
+        _NODISCARD file_time_type last_write_time() const {
+            file_time_type _Result;
+            const auto _Error = _Last_write_time(_Result);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("directory_entry::last_write_time", _Error, _Path);
+            }
+
+            return _Result;
+        }
+
+        _NODISCARD file_time_type last_write_time(error_code& _Ec) const noexcept {
+            file_time_type _Result;
+            _Ec = _Make_ec(_Last_write_time(_Result));
+            return _Result;
+        }
+
+    private:
+        _NODISCARD _File_status_and_error _Get_any_status(const __std_fs_stats_flags _Flags) const noexcept {
+            _File_status_and_error _Result;
+            __std_fs_stats _Stats;
+
+            if (_Bitmask_includes_all(_Cached_data._Available, _Flags)) {
+                _Result._Error = __std_win_error::_Success;
+                _Result._Status._Refresh(__std_win_error::_Success, _Cached_data);
+            } else {
+                const auto _Error =
+                    __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags, _Cached_data._Symlink_hint_attributes());
+                _Result._Error = _Error;
+                _Result._Status._Refresh(_Error, _Stats);
+            }
+
+            return _Result;
+        }
+
+    public:
+        _NODISCARD file_status status() const {
+            const auto _Result = _Get_any_status(_Status_stats_flags);
+            if (_Result._Not_good()) {
+                _Throw_fs_error("directory_entry::status", _Result._Error, _Path);
+            }
+
+            return _Result._Status;
+        }
+
+        _NODISCARD file_status status(error_code& _Ec) const noexcept {
+            const auto _Result = _Get_any_status(_Status_stats_flags);
+            _Ec                = _Make_ec(_Result._Error);
+            return _Result._Status;
+        }
+
+        _NODISCARD file_status symlink_status() const {
+            const auto _Result = _Get_any_status(_Symlink_status_stats_flags);
+            if (_Result._Not_good()) {
+                _Throw_fs_error("directory_entry::symlink_status", _Result._Error, _Path);
+            }
+
+            return _Result._Status;
+        }
+
+        _NODISCARD file_status symlink_status(error_code& _Ec) const noexcept {
+            const auto _Result = _Get_any_status(_Symlink_status_stats_flags);
+            _Ec                = _Make_ec(_Result._Error);
+            return _Result._Status;
+        }
+
+        _NODISCARD bool operator==(const directory_entry& _Rhs) const noexcept {
+            return _Path == _Rhs._Path;
+        }
+
+#if _HAS_CXX20
+        _NODISCARD strong_ordering operator<=>(const directory_entry& _Rhs) const noexcept {
+            return _Path <=> _Rhs._Path;
+        }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        _NODISCARD bool operator!=(const directory_entry& _Rhs) const noexcept {
+            return _Path != _Rhs._Path;
+        }
+
+        _NODISCARD bool operator<(const directory_entry& _Rhs) const noexcept {
+            return _Path < _Rhs._Path;
+        }
+
+        _NODISCARD bool operator<=(const directory_entry& _Rhs) const noexcept {
+            return _Path <= _Rhs._Path;
+        }
+
+        _NODISCARD bool operator>(const directory_entry& _Rhs) const noexcept {
+            return _Path > _Rhs._Path;
+        }
+
+        _NODISCARD bool operator>=(const directory_entry& _Rhs) const noexcept {
+            return _Path >= _Rhs._Path;
+        }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+        // [fs.dir.entry.io], inserter
+        template <class _Elem, class _Traits>
+        friend basic_ostream<_Elem, _Traits>& operator<<(
+            basic_ostream<_Elem, _Traits>& _Ostr, const directory_entry& _Entry) {
+            // insert a directory_entry into a stream
+            return _Ostr << _Entry.path();
+        }
+
+    private:
+        void _Refresh(const __std_fs_find_data& _Data) noexcept {
+            _Cached_data._Attributes        = _Data._Attributes;
+            _Cached_data._Reparse_point_tag = _Data._Reparse_point_tag;
+            _Cached_data._Available         = __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Reparse_tag;
+            if (!_Bitmask_includes_any(_Data._Attributes, __std_fs_file_attr::_Reparse_point)) {
+                _Cached_data._File_size = (static_cast<uintmax_t>(_Data._File_size_high) << 32)
+                                        + static_cast<uintmax_t>(_Data._File_size_low);
+                _CSTD memcpy(
+                    &_Cached_data._Last_write_time, &_Data._Last_write_time, sizeof(_Cached_data._Last_write_time));
+                _Cached_data._Available |= __std_fs_stats_flags::_File_size | __std_fs_stats_flags::_Last_write_time;
+            }
+        }
+
+        _NODISCARD static __std_win_error _Refresh(__std_fs_stats& _Stats, const filesystem::path& _Path) noexcept {
+            const auto _Error = __std_fs_get_stats(_Path.c_str(), &_Stats, __std_fs_stats_flags::_All_data);
+            if (_Error == __std_win_error::_Success) {
+                if (_Bitmask_includes_any(_Stats._Attributes, __std_fs_file_attr::_Reparse_point)) {
+                    _Stats._Available = __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Reparse_tag;
+                } else {
+                    _Stats._Available = __std_fs_stats_flags::_All_data;
+                }
+            } else {
+                _Stats._Available = __std_fs_stats_flags::_None;
+            }
+
+            return _Error;
+        }
+
+        friend _Dir_enum_impl;
+        friend _Recursive_dir_enum_impl;
+        friend void _Copy_impl(
+            const directory_entry& _From, const _STD filesystem::path& _To, copy_options _Options, error_code& _Ec);
+
+        __std_fs_stats _Cached_data;
+        filesystem::path _Path;
+    };
+
+    _EXPORT_STD enum class directory_options { none = 0, follow_directory_symlink = 1, skip_permission_denied = 2 };
+    _BITMASK_OPS(_EXPORT_STD, directory_options)
+
+    _EXPORT_STD _NODISCARD inline bool exists(const path& _Target, error_code& _Ec) noexcept;
+
+    struct _Dir_enum_impl {
+        _NODISCARD static __std_win_error _Advance_and_reset_if_no_more_files(shared_ptr<_Dir_enum_impl>& _Ptr) {
+            auto& _Impl = *_Ptr;
+            __std_fs_find_data _Data;
+            do {
+                const auto _Error = __std_fs_directory_iterator_advance(_Impl._Dir._Handle, &_Data);
+                if (_Error == __std_win_error::_No_more_files) {
+                    _Ptr.reset();
+                    return __std_win_error::_Success;
+                }
+
+                if (_Error != __std_win_error::_Success) {
+                    return _Error;
+                }
+            } while (_Is_dot_or_dotdot(_Data));
+            _Impl._Refresh(_Data); // can throw
+            return __std_win_error::_Success;
+        }
+
+        _NODISCARD static __std_win_error _Skip_dots(
+            __std_fs_dir_handle _Dir_handle, __std_fs_find_data& _Data) noexcept {
+            while (_Is_dot_or_dotdot(_Data)) {
+                const auto _Error = __std_fs_directory_iterator_advance(_Dir_handle, &_Data);
+                if (_Error != __std_win_error::_Success) {
+                    return _Error;
+                }
+            }
+
+            return __std_win_error::_Success;
+        }
+
+        _NODISCARD static __std_win_error _Open_dir(
+            path& _Path, const directory_options _Options_arg, _Find_file_handle& _Dir, __std_fs_find_data& _Data) {
+            const size_t _Null_term_len = _CSTD wcslen(_Path.c_str());
+            if (_Null_term_len == 0 || _Null_term_len != _Path.native().size()) {
+                return __std_win_error::_File_not_found;
+            }
+
+            const path _Original_path = _Path;
+            _Path /= L"*"sv;
+            auto _Error = _Dir._Open(_Path.c_str(), &_Data);
+            if (_Error == __std_win_error::_Success) {
+                return _Skip_dots(_Dir._Handle, _Data);
+            }
+
+            if (_Error == __std_win_error::_Access_denied
+                && _Bitmask_includes_any(_Options_arg, directory_options::skip_permission_denied)) {
+                _Error = __std_win_error::_No_more_files;
+            } else if (_Error == __std_win_error::_File_not_found) {
+                error_code _Ignored; // When exists() returns true, that implies that the error_code is successful.
+                // When exists() returns false, we don't want to interfere with _Open_dir()'s behavior,
+                // as it's going to return __std_win_error::_File_not_found.
+                if (_STD filesystem::exists(_Original_path, _Ignored)) {
+                    _Error = __std_win_error::_No_more_files; // Handle empty volumes, see GH-4291
+                }
+            }
+
+            return _Error;
+        }
+
+        struct _Creator { // factored out part common to recursive and non-recursive implementation
+            path _Path;
+            _Find_file_handle _Dir;
+            __std_fs_find_data _Find_data;
+
+            struct _Create_status {
+                bool _Should_create_impl;
+                __std_win_error _Error;
+            };
+
+            _Create_status _Status;
+
+            _Creator(const path& _Path_arg, const directory_options _Options) : _Path(_Path_arg) {
+                const auto _Error = _Open_dir(_Path, _Options, _Dir, _Find_data);
+                if (_Error == __std_win_error::_Success) {
+                    _Status = {true, __std_win_error::_Success};
+                } else if (_Error == __std_win_error::_No_more_files) {
+                    _Status = {false, __std_win_error::_Success};
+                } else {
+                    _Status = {false, _Error};
+                }
+            }
+        };
+
+        void _Refresh(const __std_fs_find_data& _Data) {
+            _Entry._Refresh(_Data);
+            _Entry._Path.replace_filename(wstring_view{_Data._File_name});
+        }
+
+        explicit _Dir_enum_impl(_Creator&& _Create_data, const directory_options = {})
+            : _Dir(_STD move(_Create_data._Dir)) {
+            // directory_options provided, but unused to keep signature identical to recursive_directory_iterator
+            _Entry._Path = _STD move(_Create_data._Path);
+            _Refresh(_Create_data._Find_data);
+        }
+
+        template <class _Dir_enum_kind>
+        _NODISCARD static __std_win_error _Initialize_dir_enum(
+            shared_ptr<_Dir_enum_kind>& _Impl, const path& _Path, const directory_options _Options = {}) {
+            _Creator _Create_data(_Path, _Options);
+            if (_Create_data._Status._Should_create_impl) {
+                _Impl = _STD make_shared<_Dir_enum_kind>(_STD move(_Create_data), _Options);
+            }
+            return _Create_data._Status._Error;
+        }
+
+        directory_entry _Entry;
+        _Find_file_handle _Dir;
+    };
+
+    _EXPORT_STD class directory_iterator;
+    _EXPORT_STD class recursive_directory_iterator;
+
+    struct _Directory_entry_proxy {
+        _NODISCARD directory_entry operator*() && noexcept {
+            return _STD move(_Entry);
+        }
+
+    private:
+        friend directory_iterator;
+        friend recursive_directory_iterator;
+
+        explicit _Directory_entry_proxy(const directory_entry& _Entry_arg) : _Entry(_Entry_arg) {}
+
+        directory_entry _Entry;
+    };
+
+    _EXPORT_STD class directory_iterator {
+    public:
+        using iterator_category = input_iterator_tag;
+        using value_type        = directory_entry;
+        using difference_type   = ptrdiff_t;
+        using pointer           = const directory_entry*;
+        using reference         = const directory_entry&;
+
+        // [fs.dir.itr.members], member functions
+        directory_iterator() noexcept = default;
+        explicit directory_iterator(const path& _Path) {
+            const auto _Error = _Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("directory_iterator::directory_iterator", _Error, _Path);
+            }
+        }
+
+        directory_iterator(const path& _Path, const directory_options _Options) {
+            const auto _Error = _Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path, _Options);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("directory_iterator::directory_iterator", _Error, _Path);
+            }
+        }
+
+        directory_iterator(const path& _Path, error_code& _Ec) {
+            _Ec = _Make_ec(_Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path));
+        }
+
+        directory_iterator(const path& _Path, const directory_options _Options, error_code& _Ec) {
+            _Ec = _Make_ec(_Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path, _Options));
+        }
+
+        directory_iterator(const directory_iterator&) noexcept = default; // strengthened
+        directory_iterator(directory_iterator&&) noexcept      = default;
+        ~directory_iterator() noexcept                         = default;
+
+        directory_iterator& operator=(const directory_iterator&) noexcept = default; // strengthened
+        directory_iterator& operator=(directory_iterator&&) noexcept      = default;
+
+        _NODISCARD const directory_entry& operator*() const noexcept /* strengthened */ {
+            return _Impl->_Entry;
+        }
+
+        _NODISCARD const directory_entry* operator->() const noexcept /* strengthened */ {
+            return &**this;
+        }
+
+        directory_iterator& operator++() {
+            const auto _Error = _Dir_enum_impl::_Advance_and_reset_if_no_more_files(_Impl);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("directory_iterator::operator++", _Error);
+            }
+
+            return *this;
+        }
+
+        directory_iterator& increment(error_code& _Ec) {
+            _Ec = _Make_ec(_Dir_enum_impl::_Advance_and_reset_if_no_more_files(_Impl));
+            return *this;
+        }
+
+        // other members as required by [input.iterators]:
+        _NODISCARD bool operator==(const directory_iterator& _Rhs) const noexcept /* strengthened */ {
+            return _Impl == _Rhs._Impl;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD bool operator!=(const directory_iterator& _Rhs) const noexcept /* strengthened */ {
+            return _Impl != _Rhs._Impl;
+        }
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX20
+        _NODISCARD bool operator==(default_sentinel_t) const noexcept {
+            return !_Impl;
+        }
+#endif // _HAS_CXX20
+
+        _Directory_entry_proxy operator++(int) {
+            _Directory_entry_proxy _Proxy(**this);
+            ++*this;
+            return _Proxy;
+        }
+
+        _NODISCARD bool _At_end() const noexcept {
+            return !_Impl;
+        }
+
+    private:
+        shared_ptr<_Dir_enum_impl> _Impl;
+    };
+
+    _EXPORT_STD _NODISCARD inline directory_iterator begin(directory_iterator _Iter) noexcept {
+        return _Iter;
+    }
+
+    _EXPORT_STD _NODISCARD inline directory_iterator end(directory_iterator) noexcept {
+        return {};
+    }
+
+    struct _Should_recurse_result {
+        bool _Should_recurse;
+        __std_win_error _Error;
+    };
+
+    struct _Recursive_dir_enum_impl : _Dir_enum_impl {
+        vector<_Find_file_handle> _Stack;
+        directory_options _Options = {};
+        bool _Recursion_pending    = true;
+
+        _NODISCARD _Should_recurse_result _Should_recurse() const noexcept {
+            bool _Should_recurse   = false;
+            __std_win_error _Error = __std_win_error::_Success;
+            if (_Recursion_pending) {
+                if (_Entry._Is_symlink_or_junction()) {
+                    if (_Bitmask_includes_any(_Options, directory_options::follow_directory_symlink)) {
+                        // check for broken symlink/junction
+                        __std_fs_stats _Target_stats;
+                        constexpr auto _Flags =
+                            __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Follow_symlinks;
+                        _Error = __std_fs_get_stats(
+                            _Entry._Path.c_str(), &_Target_stats, _Flags, _Entry._Cached_data._Attributes);
+                        if (_Error == __std_win_error::_Success) {
+                            _Should_recurse =
+                                _Bitmask_includes_any(_Target_stats._Attributes, __std_fs_file_attr::_Directory);
+                        } else if (__std_is_file_not_found(_Error)
+                                   || (_Error == __std_win_error::_Access_denied
+                                       && _Bitmask_includes_any(_Options, directory_options::skip_permission_denied))) {
+                            // skip broken symlinks and permission denied (when configured)
+                            _Error = __std_win_error::_Success;
+                        }
+                    }
+                } else {
+                    _Should_recurse = _Entry._Has_cached_attribute(__std_fs_file_attr::_Directory);
+                }
+            }
+
+            return {_Should_recurse, _Error};
+        }
+
+        _NODISCARD __std_win_error _Advance_and_skip_dots(__std_fs_find_data& _Data) noexcept {
+            const auto _Error = __std_fs_directory_iterator_advance(_Dir._Handle, &_Data);
+            if (_Error != __std_win_error::_Success) {
+                return _Error;
+            }
+
+            return _Skip_dots(_Dir._Handle, _Data);
+        }
+
+        _NODISCARD static __std_win_error _Pop_and_reset_if_no_more_files(shared_ptr<_Recursive_dir_enum_impl>& _Ptr) {
+            __std_win_error _Error;
+            auto& _Impl = *_Ptr;
+            __std_fs_find_data _Data;
+
+            _Impl._Recursion_pending = true;
+
+            do {
+                if (_Impl._Stack.empty()) {
+                    _Error = __std_win_error::_Success;
+                    break;
+                }
+
+                _Impl._Dir = _STD move(_Impl._Stack.back());
+                _Impl._Stack.pop_back();
+                _Impl._Entry._Path._Remove_filename_and_separator();
+                _Error = _Impl._Advance_and_skip_dots(_Data);
+
+                if (_Error == __std_win_error::_Success) {
+                    _Impl._Refresh(_Data);
+                    return __std_win_error::_Success;
+                }
+            } while (_Error == __std_win_error::_No_more_files);
+
+            _Ptr.reset();
+            return _Error;
+        }
+
+        _NODISCARD static __std_win_error _Advance_and_reset_if_no_more_files(
+            shared_ptr<_Recursive_dir_enum_impl>& _Ptr) {
+            auto& _Impl = *_Ptr;
+            __std_fs_find_data _Data;
+            auto [_Should_recurse, _Error] = _Impl._Should_recurse();
+            if (_Error != __std_win_error::_Success) {
+                _Ptr.reset();
+                return _Error;
+            }
+
+            if (_Should_recurse) {
+                _Impl._Stack.push_back(_STD move(_Impl._Dir));
+                _Error = _Open_dir(_Impl._Entry._Path, _Impl._Options, _Impl._Dir, _Data);
+            } else {
+                _Error = _Impl._Advance_and_skip_dots(_Data);
+            }
+
+            _Impl._Recursion_pending = true;
+            for (;; _Error = _Impl._Advance_and_skip_dots(_Data)) {
+                if (_Error == __std_win_error::_Success) {
+                    _Impl._Refresh(_Data);
+                    return __std_win_error::_Success;
+                }
+
+                if (_Error != __std_win_error::_No_more_files) {
+                    break;
+                }
+
+                // no more files at this level, see if we can pop
+                if (_Impl._Stack.empty()) { // nothing to pop, clear the error, reset and return
+                    _Error = __std_win_error::_Success;
+                    break;
+                }
+
+                _Impl._Dir = _STD move(_Impl._Stack.back());
+                _Impl._Stack.pop_back();
+                _Impl._Entry._Path._Remove_filename_and_separator();
+            }
+
+            _Ptr.reset();
+            return _Error;
+        }
+
+        _Recursive_dir_enum_impl(_Dir_enum_impl::_Creator&& _Create_data, const directory_options _Options_arg)
+            : _Dir_enum_impl(_STD move(_Create_data)), _Options(_Options_arg) {}
+    };
+
+    _EXPORT_STD class recursive_directory_iterator {
+    public:
+        using iterator_category = input_iterator_tag;
+        using value_type        = directory_entry;
+        using difference_type   = ptrdiff_t;
+        using pointer           = const directory_entry*;
+        using reference         = const directory_entry&;
+
+        // [fs.rec.dir.itr.members], constructors and destructor
+
+        recursive_directory_iterator() noexcept = default;
+        explicit recursive_directory_iterator(const path& _Path) {
+            const auto _Error = _Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("recursive_directory_iterator::recursive_directory_iterator", _Error, _Path);
+            }
+        }
+
+        recursive_directory_iterator(const path& _Path, const directory_options _Options) {
+            const auto _Error = _Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path, _Options);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("recursive_directory_iterator::recursive_directory_iterator", _Error, _Path);
+            }
+        }
+
+        recursive_directory_iterator(const path& _Path, const directory_options _Options, error_code& _Ec) {
+            _Ec = _Make_ec(_Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path, _Options));
+        }
+
+        recursive_directory_iterator(const path& _Path, error_code& _Ec) {
+            _Ec = _Make_ec(_Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path));
+        }
+
+        recursive_directory_iterator(const recursive_directory_iterator&) noexcept = default; // strengthened
+        recursive_directory_iterator(recursive_directory_iterator&&) noexcept      = default;
+        ~recursive_directory_iterator() noexcept                                   = default;
+
+        // [fs.rec.dir.itr.members], observers
+        _NODISCARD directory_options options() const noexcept /* strengthened */ {
+            return _Impl->_Options;
+        }
+        _NODISCARD int depth() const noexcept /* strengthened */ {
+            // NT uses uint32_t to store the length of the path
+            // that allows us 2^31 wchar_t per path.
+            // A directory name should be at least 1 character, otherwise
+            // adjacent directory separators will be treated as one.
+            // Hence, we can only get to 2^30 entries in the stack.
+            return static_cast<int>(_Impl->_Stack.size());
+        }
+        _NODISCARD bool recursion_pending() const noexcept /* strengthened */ {
+            return _Impl->_Recursion_pending;
+        }
+
+        _NODISCARD const directory_entry& operator*() const noexcept /* strengthened */ {
+            return _Impl->_Entry;
+        }
+
+        _NODISCARD const directory_entry* operator->() const noexcept /* strengthened */ {
+            return &**this;
+        }
+
+        // [fs.rec.dir.itr.members], modifiers
+        recursive_directory_iterator& operator=(recursive_directory_iterator&&) noexcept      = default;
+        recursive_directory_iterator& operator=(const recursive_directory_iterator&) noexcept = default; // strengthened
+
+        recursive_directory_iterator& operator++() {
+            const auto _Error = _Recursive_dir_enum_impl::_Advance_and_reset_if_no_more_files(_Impl);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("recursive_directory_iterator::operator++", _Error);
+            }
+            return *this;
+        }
+
+        recursive_directory_iterator& increment(error_code& _Ec) {
+            _Ec = _Make_ec(_Recursive_dir_enum_impl::_Advance_and_reset_if_no_more_files(_Impl));
+            return *this;
+        }
+
+        void pop() {
+            const auto _Error = _Recursive_dir_enum_impl::_Pop_and_reset_if_no_more_files(_Impl);
+            if (_Error != __std_win_error::_Success) {
+                _Throw_fs_error("recursive_directory_iterator::pop", _Error);
+            }
+        }
+
+        void pop(error_code& _Ec) {
+            _Ec = _Make_ec(_Recursive_dir_enum_impl::_Pop_and_reset_if_no_more_files(_Impl));
+        }
+
+        void disable_recursion_pending() noexcept {
+            _Impl->_Recursion_pending = false;
+        }
+
+        // other members as required by [input.iterators]:
+        _NODISCARD bool operator==(const recursive_directory_iterator& _Rhs) const noexcept {
+            return _Impl == _Rhs._Impl;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD bool operator!=(const recursive_directory_iterator& _Rhs) const noexcept {
+            return _Impl != _Rhs._Impl;
+        }
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX20
+        _NODISCARD bool operator==(default_sentinel_t) const noexcept {
+            return !_Impl;
+        }
+#endif // _HAS_CXX20
+
+        _Directory_entry_proxy operator++(int) {
+            _Directory_entry_proxy _Proxy(**this);
+            ++*this;
+            return _Proxy;
+        }
+
+    private:
+        shared_ptr<_Recursive_dir_enum_impl> _Impl;
+    };
+
+    _EXPORT_STD _NODISCARD inline recursive_directory_iterator begin(recursive_directory_iterator _Iter) noexcept {
+        return _Iter;
+    }
+
+    _EXPORT_STD _NODISCARD inline recursive_directory_iterator end(recursive_directory_iterator) noexcept {
+        return {};
+    }
+
+    _EXPORT_STD _NODISCARD inline path absolute(const path& _Input, error_code& _Ec) {
+        // normalize path according to system semantics, without touching the disk
+        // calls GetFullPathNameW
+        _Ec.clear(); // for exception safety
+        path _Result;
+        _Result._Text.resize(__std_fs_max_path);
+        for (;;) {
+            const auto _Requested_size = static_cast<unsigned long>(_Result._Text.size());
+            const auto _Full_path_result =
+                __std_fs_get_full_path_name(_Input._Text.c_str(), _Requested_size, _Result._Text.data());
+            _Result._Text.resize(_Full_path_result._Size);
+            if (_Full_path_result._Size < _Requested_size) {
+                _Ec = _Make_ec(_Full_path_result._Error);
+                break;
+            }
+        }
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline path absolute(const path& _Input) {
+        // normalize path according to system semantics, without touching the disk
+        // calls GetFullPathNameW
+        error_code _Ec;
+        path _Result(_STD filesystem::absolute(_Input, _Ec));
+        if (_Ec) {
+            _Throw_fs_error("absolute", _Ec, _Input);
+        }
+        return _Result;
+    }
+
+    _NODISCARD inline __std_win_error _Canonical(path& _Result, const wstring& _Text) { // pre: _Result.empty()
+        if (_Text.empty()) {
+            return __std_win_error::_Success;
+        }
+
+        auto _Name_kind = __std_fs_volume_name_kind::_Dos;
+        {
+            __std_win_error _Err;
+            const _Fs_file _Handle(_Text.c_str(), __std_access_rights::_File_read_attributes,
+                __std_fs_file_flags::_Backup_semantics, &_Err);
+            if (_Err != __std_win_error::_Success) {
+                return _Err;
+            }
+
+            _Result._Text.resize(__std_fs_max_path);
+            for (;;) {
+                const auto _Requested_size    = static_cast<unsigned long>(_Result._Text.size());
+                const auto _Final_path_result = __std_fs_get_final_path_name_by_handle(
+                    _Handle._Raw, _Result._Text.data(), _Requested_size, _Name_kind);
+                _Err = _Final_path_result._Error;
+                if (_Final_path_result._Size == 0) {
+                    if (_Err == __std_win_error::_Path_not_found && _Name_kind == __std_fs_volume_name_kind::_Dos) {
+                        // maybe there is no DOS name for the supplied path, retry with NT path
+                        _Name_kind = __std_fs_volume_name_kind::_Nt;
+                        continue;
+                    }
+
+                    _Result._Text.clear();
+                    return _Err;
+                }
+
+                _Result._Text.resize(_Final_path_result._Size);
+                if (_Final_path_result._Size < _Requested_size) {
+                    break;
+                }
+            }
+        } // close _Handle
+
+        if (_Name_kind == __std_fs_volume_name_kind::_Dos) {
+            if (_Is_drive_prefix_with_slash_slash_question(_Result._Text)) {
+                // the result contains a \\?\ prefix but is just a drive letter, strip the \\?\ prefix
+                _Result._Text.erase(0, 4);
+            } else if (_Result._Text._Starts_with(LR"(\\?\UNC\)"sv)) {
+                // the result contains a \\?\UNC\ prefix, replace with the simpler \\ prefix
+                _Result._Text.erase(2, 6); // chop out ?\UNC\ leaving two preferred-separators
+            }
+        } else { // result is in the NT namespace, so apply the DOS to NT namespace prefix
+            _Result._Text.insert(0, LR"(\\?\GLOBALROOT)"sv);
+        }
+
+        return __std_win_error::_Success;
+    }
+
+    _EXPORT_STD _NODISCARD inline path canonical(const path& _Input) {
+        // resolve the final path according to system semantics, by opening the file
+        // calls GetFinalPathNameByHandleW
+        path _Result;
+        const auto _Err = _Canonical(_Result, _Input.native());
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("canonical", _Err, _Input);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline path canonical(const path& _Input, error_code& _Ec) {
+        // resolve the final path according to system semantics, by opening the file
+        // calls GetFinalPathNameByHandleW
+        _Ec.clear(); // for exception safety
+        path _Result;
+        _Ec = _Make_ec(_Canonical(_Result, _Input.native()));
+        return _Result;
+    }
+
+    _NODISCARD inline unique_ptr<wchar_t[]> _Get_cleaned_symlink_target(const path& _To) noexcept {
+        // transforms /s in the root-name to \s, and all other directory-separators into single \s
+        // example: a/\/b -> a\b
+        // example: //server/a////////b////////c////////d -> \\server\a\b\c\d
+        const auto& _To_str = _To.native();
+        // protected from overflow by wstring's max_size cap:
+        unique_ptr<wchar_t[]> _Cleaned_link(::new (nothrow) wchar_t[_To_str.size() + 1]);
+        if (!_Cleaned_link) {
+            return _Cleaned_link;
+        }
+
+        const auto _First = _To_str.c_str();
+        const auto _Last  = _First + _To_str.size();
+        auto _Next        = _Find_root_name_end(_First, _Last);
+        auto _Dest        = _STD replace_copy_if(_First, _Next, _Cleaned_link.get(), _Is_slash, L'\\');
+        for (;;) {
+            const wchar_t _Ch = *_Next;
+            if (_Is_slash(_Ch)) {
+                *_Dest = L'\\';
+                do {
+                    ++_Next;
+                } while (_Is_slash(*_Next));
+            } else {
+                *_Dest = _Ch;
+                if (_Ch == L'\0') {
+                    break;
+                }
+
+                ++_Next;
+            }
+
+            ++_Dest;
+        }
+
+        return _Cleaned_link;
+    }
+
+    _EXPORT_STD inline void create_directory_symlink(const path& _To, const path& _New_symlink) {
+        // create a symlink for a directory, _New_symlink -> _To
+        const auto _Cleaned = _Get_cleaned_symlink_target(_To);
+        if (!_Cleaned) {
+            _Xbad_alloc();
+        }
+
+        // note reversed parameter order:
+        const auto _Err = __std_fs_create_directory_symbolic_link(_New_symlink.c_str(), _Cleaned.get());
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("create_directory_symlink", _Err, _To, _New_symlink);
+        }
+    }
+
+    _EXPORT_STD inline void create_directory_symlink(
+        const path& _To, const path& _New_symlink, error_code& _Ec) noexcept {
+        // create a symlink for a directory, _New_symlink -> _To
+        const auto _Cleaned = _Get_cleaned_symlink_target(_To);
+        if (_Cleaned) {
+            // note reversed parameter order:
+            _Ec = _Make_ec(__std_fs_create_directory_symbolic_link(_New_symlink.c_str(), _Cleaned.get()));
+        } else {
+            _Ec = _STD make_error_code(errc::not_enough_memory);
+        }
+    }
+
+    _EXPORT_STD inline void create_hard_link(const path& _To, const path& _New_hard_link) {
+        // create a hard link for a file, _New_hard_link -> _To
+        // note reversed parameter order:
+        const auto _Err = __std_fs_create_hard_link(_New_hard_link.c_str(), _To.c_str());
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("create_hard_link", _Err, _To, _New_hard_link);
+        }
+    }
+
+    _EXPORT_STD inline void create_hard_link(const path& _To, const path& _New_hard_link, error_code& _Ec) noexcept {
+        // create a hard link for a file, _New_hard_link -> _To
+        // note reversed parameter order:
+        _Ec = _Make_ec(__std_fs_create_hard_link(_New_hard_link.c_str(), _To.c_str()));
+    }
+
+    _EXPORT_STD inline void create_symlink(const path& _To, const path& _New_symlink) {
+        // create a symlink for a file, _New_symlink -> _To
+        const auto _Cleaned = _Get_cleaned_symlink_target(_To);
+        if (!_Cleaned) {
+            _Xbad_alloc();
+        }
+
+        // note reversed parameter order:
+        const auto _Err = __std_fs_create_symbolic_link(_New_symlink.c_str(), _Cleaned.get());
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("create_symlink", _Err, _To, _New_symlink);
+        }
+    }
+
+    _EXPORT_STD inline void create_symlink(const path& _To, const path& _New_symlink, error_code& _Ec) noexcept {
+        // create a symlink for a file, _New_symlink -> _To
+        const auto _Cleaned = _Get_cleaned_symlink_target(_To);
+        if (_Cleaned) {
+            // note reversed parameter order:
+            _Ec = _Make_ec(__std_fs_create_symbolic_link(_New_symlink.c_str(), _Cleaned.get()));
+        } else {
+            _Ec = _STD make_error_code(errc::not_enough_memory);
+        }
+    }
+
+    _NODISCARD inline __std_win_error _Read_reparse_data(
+        const _Fs_file& _Handle, unique_ptr<char[]>& _Buffer_unique_ptr) noexcept {
+        constexpr auto _Buffer_size = 16 * 1024; // MAXIMUM_REPARSE_DATA_BUFFER_SIZE
+
+        _Buffer_unique_ptr.reset(::new (nothrow) char[_Buffer_size]);
+        if (!_Buffer_unique_ptr) {
+            return __std_win_error::_Not_enough_memory;
+        }
+
+        const auto _Buffer         = reinterpret_cast<__std_fs_reparse_data_buffer*>(_Buffer_unique_ptr.get());
+        const __std_win_error _Err = __std_fs_read_reparse_data_buffer(_Handle._Raw, _Buffer, _Buffer_size);
+        if (_Err != __std_win_error::_Success) {
+            return _Err;
+        }
+
+        return __std_win_error::_Success;
+    }
+
+    _NODISCARD inline __std_win_error _Read_symlink(const path& _Symlink_path, path& _Result) {
+        __std_win_error _Err;
+        unique_ptr<char[]> _Buffer_unique_ptr;
+        {
+            const _Fs_file _Handle(_Symlink_path.c_str(), __std_access_rights::_File_read_attributes,
+                __std_fs_file_flags::_Backup_semantics | __std_fs_file_flags::_Open_reparse_point, &_Err);
+            if (_Err != __std_win_error::_Success) {
+                return _Err;
+            }
+
+            _Err = _Read_reparse_data(_Handle, _Buffer_unique_ptr);
+            if (_Err != __std_win_error::_Success) {
+                return _Err;
+            }
+        } // Close _Handle
+
+        const auto _Buffer = reinterpret_cast<__std_fs_reparse_data_buffer*>(_Buffer_unique_ptr.get());
+        unsigned short _Length;
+        wchar_t* _Offset;
+        _Err = __std_fs_read_name_from_reparse_data_buffer(_Buffer, &_Offset, &_Length);
+        if (_Err != __std_win_error::_Success) {
+            return _Err;
+        }
+
+        _Result._Text.assign(_Offset, _Length);
+
+        return __std_win_error::_Success;
+    }
+
+    _EXPORT_STD _NODISCARD inline path read_symlink(const path& _Symlink_path, error_code& _Ec) {
+        _Ec.clear();
+        path _Result;
+        _Ec = _Make_ec(_Read_symlink(_Symlink_path, _Result));
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline path read_symlink(const path& _Symlink_path) {
+        path _Result;
+        const auto _Err = _Read_symlink(_Symlink_path, _Result);
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("read_symlink", _Err, _Symlink_path);
+        }
+        return _Result;
+    }
+
+    _NODISCARD inline __std_win_error _Copy_symlink(const path& _Symlink, const path& _New_symlink) noexcept {
+        __std_win_error _Err;
+        unique_ptr<char[]> _Buffer_unique_ptr;
+        bool _Is_directory;
+        {
+            const _Fs_file _Handle(_Symlink.c_str(), __std_access_rights::_File_read_attributes,
+                __std_fs_file_flags::_Backup_semantics | __std_fs_file_flags::_Open_reparse_point, &_Err);
+            if (_Err != __std_win_error::_Success) {
+                return _Err;
+            }
+
+            _Err = _Read_reparse_data(_Handle, _Buffer_unique_ptr);
+            if (_Err != __std_win_error::_Success) {
+                return _Err;
+            }
+
+            unsigned long _File_attributes;
+            _Err = __std_fs_get_file_attributes_by_handle(_Handle._Raw, &_File_attributes);
+            if (_Err != __std_win_error::_Success) {
+                return _Err;
+            }
+
+            _Is_directory = (_File_attributes & static_cast<unsigned long>(__std_fs_file_attr::_Directory)) != 0;
+        } // Close _Handle
+
+        const auto _Buffer = reinterpret_cast<__std_fs_reparse_data_buffer*>(_Buffer_unique_ptr.get());
+
+        // LWG-3744: `copy_symlink(junction, new_symlink)`'s behavior is unclear
+        // `read_symlink(junction)` should be allowed, but `copy_symlink(junction)` is not.
+        if (__std_fs_is_junction_from_reparse_data_buffer(_Buffer)) {
+            _Err = __std_win_error::_Reparse_tag_invalid;
+            return _Err;
+        }
+
+        unsigned short _Length;
+        wchar_t* _Offset;
+        _Err = __std_fs_read_name_from_reparse_data_buffer(_Buffer, &_Offset, &_Length);
+        if (_Err != __std_win_error::_Success) {
+            return _Err;
+        }
+
+        _Offset[_Length] = L'\0';
+
+        if (_Is_directory) {
+            _Err = __std_fs_create_directory_symbolic_link(_New_symlink.c_str(), _Offset);
+        } else {
+            _Err = __std_fs_create_symbolic_link(_New_symlink.c_str(), _Offset);
+        }
+
+        return _Err;
+    }
+
+    _NODISCARD inline __std_win_error _Copy_junction(const path& _Junction, const path& _New_junction) noexcept {
+        __std_win_error _Err;
+        unique_ptr<char[]> _Buffer_unique_ptr;
+        {
+            const _Fs_file _Handle(_Junction.c_str(), __std_access_rights::_File_read_attributes,
+                __std_fs_file_flags::_Backup_semantics | __std_fs_file_flags::_Open_reparse_point, &_Err);
+            if (_Err != __std_win_error::_Success) {
+                return _Err;
+            }
+
+            _Err = _Read_reparse_data(_Handle, _Buffer_unique_ptr);
+            if (_Err != __std_win_error::_Success) {
+                return _Err;
+            }
+        } // Close _Handle
+
+        const auto _Buffer = reinterpret_cast<__std_fs_reparse_data_buffer*>(_Buffer_unique_ptr.get());
+
+        const auto _Create_dir_res = __std_fs_create_directory(_New_junction.c_str());
+
+        if (_Create_dir_res._Error != __std_win_error::_Success) {
+            return _Create_dir_res._Error;
+        } else if (!_Create_dir_res._Created) {
+            return __std_win_error::_Already_exists;
+        }
+
+        struct _NODISCARD _Delete_directory_scope_guard {
+            const wchar_t* _Path;
+            ~_Delete_directory_scope_guard() {
+                if (_Path) {
+                    (void) __std_fs_remove(_Path);
+                }
+            }
+        };
+        _Delete_directory_scope_guard _Delete_directory{_New_junction.c_str()};
+
+        _Fs_file _To_handle{_New_junction.c_str(), __std_access_rights::_File_write_attributes,
+            __std_fs_file_flags::_Backup_semantics, &_Err};
+        if (_Err != __std_win_error::_Success) {
+            return _Err;
+        }
+        _Err = __std_fs_write_reparse_data_buffer(_To_handle._Raw, _Buffer);
+        if (_Err == __std_win_error::_Success) {
+            // don't delete the directory if we succeeded in making it a junction
+            _Delete_directory._Path = nullptr;
+        }
+
+        return _Err;
+    }
+
+    _EXPORT_STD inline void copy_symlink(const path& _Symlink, const path& _New_symlink, error_code& _Ec) {
+        _Ec = _Make_ec(_Copy_symlink(_Symlink, _New_symlink));
+    }
+
+    _EXPORT_STD inline void copy_symlink(const path& _Symlink, const path& _New_symlink) {
+        const auto _Err = _Copy_symlink(_Symlink, _New_symlink);
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("copy_symlink", _Err, _Symlink, _New_symlink);
+        }
+    }
+
+    _EXPORT_STD inline bool copy_file(
+        const path& _From, const path& _To, const copy_options _Options, error_code& _Ec) noexcept /* strengthened */ {
+        // copy a file _From -> _To according to _Options
+        const auto _Result =
+            __std_fs_copy_file(_From.c_str(), _To.c_str(), static_cast<__std_fs_copy_options>(_Options));
+        _Ec = _Make_ec(_Result._Error);
+        return _Result._Copied;
+    }
+
+    _EXPORT_STD inline bool copy_file(const path& _From, const path& _To, const copy_options _Options) {
+        // copy a file _From -> _To according to _Options
+        const auto _Result =
+            __std_fs_copy_file(_From.c_str(), _To.c_str(), static_cast<__std_fs_copy_options>(_Options));
+        if (_Result._Error != __std_win_error::_Success) {
+            _Throw_fs_error("copy_file", _Result._Error, _From, _To);
+        }
+
+        return _Result._Copied;
+    }
+
+    _EXPORT_STD inline bool copy_file(const path& _From, const path& _To, error_code& _Ec) noexcept /* strengthened */ {
+        // copy a file _From -> _To, failing if the destination exists
+        return _STD filesystem::copy_file(_From, _To, copy_options::none, _Ec);
+    }
+
+    _EXPORT_STD inline bool copy_file(const path& _From, const path& _To) {
+        // copy a file _From -> _To, failing if the destination exists
+        return _STD filesystem::copy_file(_From, _To, copy_options::none);
+    }
+
+    _EXPORT_STD _NODISCARD inline bool equivalent(const path& _Lhs, const path& _Rhs) {
+        // test if the paths _Lhs and _Rhs refer to the same file
+        const auto _Result = __std_fs_equivalent(_Lhs.c_str(), _Rhs.c_str());
+        if (_Result._Error != __std_win_error::_Success) {
+            _Throw_fs_error("equivalent", _Result._Error, _Lhs, _Rhs);
+        }
+
+        return _Result._Equivalent;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool equivalent(const path& _Lhs, const path& _Rhs, error_code& _Ec) noexcept {
+        // test if the paths _Lhs and _Rhs refer to the same file
+        const auto _Result = __std_fs_equivalent(_Lhs.c_str(), _Rhs.c_str());
+        _Ec                = _Make_ec(_Result._Error);
+        return _Result._Equivalent;
+    }
+
+    _EXPORT_STD _NODISCARD inline file_status status(const path& _Path);
+    _EXPORT_STD _NODISCARD inline file_status status(const path& _Path, error_code& _Ec) noexcept;
+    _EXPORT_STD _NODISCARD inline file_status symlink_status(const path& _Path);
+    _EXPORT_STD _NODISCARD inline file_status symlink_status(const path& _Path, error_code& _Ec) noexcept;
+
+    _EXPORT_STD _NODISCARD inline bool exists(const path& _Target, error_code& _Ec) noexcept {
+        const auto _Type = _STD filesystem::status(_Target, _Ec).type();
+        if (_Type != file_type::none) {
+            _Ec.clear();
+            return _Type != file_type::not_found;
+        }
+
+        return false;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool exists(const path& _Target) {
+        error_code _Ec;
+        const bool _Result = _STD filesystem::exists(_Target, _Ec);
+        if (_Ec) {
+            _Throw_fs_error("exists", _Ec, _Target);
+        }
+
+        return _Result;
+    }
+
+    _NODISCARD inline __std_win_error _File_size(const path& _Path, uintmax_t& _Result) noexcept {
+        __std_fs_stats _Stats;
+        const auto _Error = __std_fs_get_stats(
+            _Path.c_str(), &_Stats, __std_fs_stats_flags::_Follow_symlinks | __std_fs_stats_flags::_File_size);
+        if (_Error == __std_win_error::_Success) {
+            _Result = _Stats._File_size;
+        } else {
+            _Result = static_cast<uintmax_t>(-1);
+        }
+
+        return _Error;
+    }
+
+    _EXPORT_STD _NODISCARD inline uintmax_t file_size(const path& _Path) {
+        uintmax_t _Result;
+        const auto _Error = _File_size(_Path, _Result);
+        if (_Error != __std_win_error::_Success) {
+            _Throw_fs_error("file_size", _Error, _Path);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline uintmax_t file_size(const path& _Path, error_code& _Ec) noexcept {
+        uintmax_t _Result;
+        _Ec = _Make_ec(_File_size(_Path, _Result));
+        return _Result;
+    }
+
+    _NODISCARD inline __std_win_error _Hard_link_count(const path& _Path, uintmax_t& _Result) noexcept {
+        __std_fs_stats _Stats;
+        const auto _Error = __std_fs_get_stats(
+            _Path.c_str(), &_Stats, __std_fs_stats_flags::_Follow_symlinks | __std_fs_stats_flags::_Link_count);
+        if (_Error == __std_win_error::_Success) {
+            _Result = _Stats._Link_count;
+        } else {
+            _Result = static_cast<uintmax_t>(-1);
+        }
+
+        return _Error;
+    }
+
+    _EXPORT_STD _NODISCARD inline uintmax_t hard_link_count(const path& _Target) {
+        // get the number of hard links to _Target
+        uintmax_t _Result;
+        const auto _Err = _Hard_link_count(_Target.c_str(), _Result);
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("hard_link_count", _Err, _Target);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline uintmax_t hard_link_count(const path& _Target, error_code& _Ec) noexcept {
+        // get the number of hard links to _Target
+        uintmax_t _Result;
+        _Ec = _Make_ec(_Hard_link_count(_Target.c_str(), _Result));
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_block_file(const path&) noexcept /* strengthened */ {
+        // tests whether the input path is a block special file (never on Windows)
+        return false;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_block_file(const path& _Path, error_code& _Ec) noexcept {
+        // tests whether the input path is a block special file (never on Windows)
+        (void) _STD filesystem::status(_Path, _Ec);
+        return false; // note status sets _Ec to an error on nonexistent input
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_character_file(const path&) noexcept /* strengthened */ {
+        // tests whether the input path is a character special file (never on Windows)
+        return false;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_character_file(const path& _Path, error_code& _Ec) noexcept {
+        // tests whether the input path is a character special file (never on Windows)
+        (void) _STD filesystem::status(_Path, _Ec);
+        return false; // note status sets _Ec to an error on nonexistent input
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_directory(const path& _Path) {
+        // tests whether _Path is a directory
+        return _STD filesystem::is_directory(_STD filesystem::status(_Path));
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_directory(const path& _Path, error_code& _Ec) noexcept {
+        // tests whether _Path is a directory
+        return _STD filesystem::is_directory(_STD filesystem::status(_Path, _Ec));
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_empty(const path& _Path, error_code& _Ec) {
+        // test whether _Path refers to a zero sized file or empty directory
+        constexpr auto _Flags = __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_File_size
+                              | __std_fs_stats_flags::_Follow_symlinks;
+        __std_fs_stats _Stats;
+        const auto _Error = __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags);
+        _Ec               = _Make_ec(_Error);
+        if (_Error != __std_win_error::_Success) {
+            return false;
+        }
+
+        if ((_Stats._Attributes & __std_fs_file_attr::_Directory) == __std_fs_file_attr{}) {
+            return _Stats._File_size == 0;
+        } else {
+            directory_iterator _Iter(_Path, _Ec);
+            return !_Ec && _Iter._At_end();
+        }
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_empty(const path& _Path) {
+        // test whether _Path refers to a zero sized file or empty directory
+        error_code _Ec;
+        const bool _Result = is_empty(_Path, _Ec);
+        if (_Ec) {
+            _Throw_fs_error("is_empty", _Ec, _Path);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_fifo(const path&) noexcept /* strengthened */ {
+        // tests whether the input path is a fifo (never on Windows)
+        return false;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_fifo(const path& _Path, error_code& _Ec) noexcept {
+        // tests whether the input path is a fifo (never on Windows)
+        (void) _STD filesystem::status(_Path, _Ec);
+        return false; // note status sets _Ec to an error on nonexistent input
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_other(const path& _Path) {
+        // tests whether _Path is an "other" file (such as a junction)
+        return _STD filesystem::is_other(_STD filesystem::status(_Path));
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_other(const path& _Path, error_code& _Ec) noexcept {
+        // tests whether _Path is an "other" file (such as a junction)
+        return _STD filesystem::is_other(_STD filesystem::status(_Path, _Ec));
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_regular_file(const path& _Path) {
+        // tests whether _Path is a regular file
+        return _STD filesystem::is_regular_file(_STD filesystem::status(_Path));
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_regular_file(const path& _Path, error_code& _Ec) noexcept {
+        // tests whether _Path is a regular file
+        return _STD filesystem::is_regular_file(_STD filesystem::status(_Path, _Ec));
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_socket(const path&) noexcept /* strengthened */ {
+        // tests whether the input path is a socket (never on Windows)
+        return false;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_socket(const path& _Path, error_code& _Ec) noexcept {
+        // tests whether the input path is a socket (never on Windows)
+        (void) _STD filesystem::status(_Path, _Ec);
+        return false; // note status sets _Ec to an error on nonexistent input
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_symlink(const path& _Path) {
+        // tests whether _Path is a symlink
+        return _STD filesystem::is_symlink(_STD filesystem::symlink_status(_Path));
+    }
+
+    _EXPORT_STD _NODISCARD inline bool is_symlink(const path& _Path, error_code& _Ec) noexcept {
+        // tests whether _Path is a symlink
+        return _STD filesystem::is_symlink(_STD filesystem::symlink_status(_Path, _Ec));
+    }
+
+    _EXPORT_STD inline bool remove(const path& _Target) {
+        // remove file _Target (even if it is a directory); returns whether the file was removed
+        // note !exists(_Target) is not an error, and merely returns false
+        const auto _Result = __std_fs_remove(_Target.c_str());
+        if (_Result._Error != __std_win_error::_Success) {
+            _Throw_fs_error("remove", _Result._Error, _Target);
+        }
+
+        return _Result._Removed;
+    }
+
+    _EXPORT_STD inline bool remove(const path& _Target, error_code& _Ec) noexcept {
+        // remove file _Target (even if it is a directory); returns whether the file was removed
+        // note !exists(_Target) is not an error, and merely returns false
+        const auto _Result = __std_fs_remove(_Target.c_str());
+        _Ec                = _Make_ec(_Result._Error);
+        return _Result._Removed;
+    }
+
+    _EXPORT_STD inline void rename(const path& _Old_p, const path& _New_p) {
+        // rename _Old_p to _New_p, overwriting _New_p if it is an existing non-directory file
+        // the standard explicitly allows an implementation to not replace _New_p if it is a directory,
+        // and we take advantage of that here to be able to use MoveFileEx(... MOVEFILE_REPLACE_EXISTING)
+        const auto _Err = __std_fs_rename(_Old_p.c_str(), _New_p.c_str());
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("rename", _Err, _Old_p, _New_p);
+        }
+    }
+
+    _EXPORT_STD inline void rename(const path& _Old_p, const path& _New_p, error_code& _Ec) noexcept {
+        // rename _Old_p to _New_p, overwriting _New_p if it is an existing non-directory file
+        // the standard explicitly allows an implementation to not replace _New_p if it is a directory,
+        // and we take advantage of that here to be able to use MoveFileEx(... MOVEFILE_REPLACE_EXISTING)
+        _Ec = _Make_ec(__std_fs_rename(_Old_p.c_str(), _New_p.c_str()));
+    }
+
+    _EXPORT_STD inline void resize_file(const path& _Target, const uintmax_t _New_size) {
+        // set the size of _Target to _New_size
+        const auto _Err = __std_fs_resize_file(_Target.c_str(), _New_size);
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("resize_file", _Err, _Target);
+        }
+    }
+
+    _EXPORT_STD inline void resize_file(const path& _Target, const uintmax_t _New_size, error_code& _Ec) noexcept {
+        // set the size of _Target to _New_size
+        _Ec = _Make_ec(__std_fs_resize_file(_Target.c_str(), _New_size));
+    }
+
+    _EXPORT_STD struct space_info {
+        uintmax_t capacity;
+        uintmax_t free;
+        uintmax_t available;
+
+#if _HAS_CXX20
+        _NODISCARD friend constexpr bool operator==(const space_info&, const space_info&) noexcept = default;
+#endif // _HAS_CXX20
+    };
+
+    _EXPORT_STD _NODISCARD inline space_info space(const path& _Target) {
+        // get capacity information for the volume on which the file _Target resides
+        space_info _Result;
+        const auto _Last_error = __std_fs_space(_Target.c_str(), &_Result.available, &_Result.capacity, &_Result.free);
+        if (_Last_error != __std_win_error::_Success) {
+            _Throw_fs_error("space", _Last_error, _Target);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline space_info space(const path& _Target, error_code& _Ec) noexcept {
+        // get capacity information for the volume on which the file _Target resides
+        space_info _Result;
+        _Ec = _Make_ec(__std_fs_space(_Target.c_str(), &_Result.available, &_Result.capacity, &_Result.free));
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline bool status_known(const file_status _Status) noexcept {
+        return _Status.type() != file_type::none;
+    }
+
+    _NODISCARD inline _File_status_and_error _Get_any_status(
+        const path& _Path, const __std_fs_stats_flags _Flags) noexcept {
+        _File_status_and_error _Result;
+        __std_fs_stats _Stats;
+
+        const auto _Error = __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags);
+        _Result._Error    = _Error;
+        _Result._Status._Refresh(_Error, _Stats);
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline file_status status(const path& _Path, error_code& _Ec) noexcept {
+        const auto _Result = _Get_any_status(_Path, _Status_stats_flags);
+        _Ec                = _Make_ec(_Result._Error);
+        return _Result._Status;
+    }
+
+    _EXPORT_STD _NODISCARD inline file_status status(const path& _Path) {
+        const auto _Result = _Get_any_status(_Path, _Status_stats_flags);
+        if (_Result._Not_good()) {
+            _Throw_fs_error("status", _Result._Error, _Path);
+        }
+        return _Result._Status;
+    }
+
+    _EXPORT_STD _NODISCARD inline file_status symlink_status(const path& _Path, error_code& _Ec) noexcept {
+        const auto _Result = _Get_any_status(_Path, _Symlink_status_stats_flags);
+        _Ec                = _Make_ec(_Result._Error);
+        return _Result._Status;
+    }
+
+    _EXPORT_STD _NODISCARD inline file_status symlink_status(const path& _Path) {
+        const auto _Result = _Get_any_status(_Path, _Symlink_status_stats_flags);
+        if (_Result._Not_good()) {
+            _Throw_fs_error("symlink_status", _Result._Error, _Path);
+        }
+
+        return _Result._Status;
+    }
+
+    _EXPORT_STD inline bool create_directory(const path& _Path) {
+        const auto _Result = __std_fs_create_directory(_Path.c_str());
+        if (_Result._Error != __std_win_error::_Success) {
+            _Throw_fs_error("create_directory", _Result._Error, _Path);
+        }
+
+        return _Result._Created;
+    }
+
+    _EXPORT_STD inline bool create_directory(const path& _Path, error_code& _Ec) noexcept {
+        const auto _Result = __std_fs_create_directory(_Path.c_str());
+        _Ec                = _Make_ec(_Result._Error);
+        return _Result._Created;
+    }
+
+    _EXPORT_STD inline bool create_directory(const path& _Path, const path& _Existing_p) {
+        const auto _Result = __std_fs_create_directory(_Path.c_str());
+        if (_Result._Error != __std_win_error::_Success) {
+            _Throw_fs_error("create_directory", _Result._Error, _Path, _Existing_p);
+        }
+
+        return _Result._Created;
+    }
+
+    _EXPORT_STD inline bool create_directory(const path& _Path, const path&, error_code& _Ec) noexcept {
+        const auto _Result = __std_fs_create_directory(_Path.c_str());
+        _Ec                = _Make_ec(_Result._Error);
+        return _Result._Created;
+    }
+
+    _EXPORT_STD inline bool create_directories(const path& _Path, error_code& _Ec) {
+        if (_Path.empty()) {
+            _Ec = _Make_ec(__std_win_error::_Path_not_found);
+            return false;
+        }
+
+        _Ec.clear(); // for exception safety
+        const wstring& _Text = _Path.native();
+        wstring _Tmp;
+        _Tmp.reserve(_Text.size());
+        auto _Cursor        = _Text.data();
+        const auto _End     = _Text.data() + _Text.size();
+        auto _Root_path_end = _Find_relative_path(_Cursor, _End);
+        if (_Root_path_end != _Cursor && _End - _Root_path_end >= 3 && _Is_drive_prefix(_Root_path_end)
+            && _Is_slash(_Root_path_end[2])) {
+            // \\?\ prefixes may have a drive letter suffix Windows will reject, strip
+            _Root_path_end += 2;
+        }
+
+        _Tmp.append(_Cursor, _Root_path_end);
+        _Cursor = _Root_path_end;
+
+        // When creating directories, sometimes we get error reports on earlier directories.
+        // Consider a case like X:\cat\dog\elk, where we get the following errors:
+        // X: ERROR_ACCESS_DENIED
+        // X:\cat ERROR_ALREADY_EXISTS
+        // X:\cat\dog ERROR_ACCESS_DENIED
+        // X:\cat\dog\elk ERROR_FILE_NOT_FOUND
+        // Here, the previous access denied error prevented us from creating a parent directory,
+        // and the subsequent ERROR_FILE_NOT_FOUND is not the interesting error for the user.
+        // Therefore:
+        //   If the last directory creation reports success, we return success.
+        //   If the last directory creation fails, we return the most recent non-file-not-found error.
+        //   If there is no such non-file-not-found error, we return the most recent error.
+
+        bool _Created_last                              = false;
+        __std_win_error _Error                          = __std_win_error::_Success;
+        __std_win_error _Most_recent_not_file_not_found = __std_win_error::_Success;
+        while (_Cursor != _End) {
+            const auto _Added_end = _STD find_if(_STD find_if_not(_Cursor, _End, _Is_slash), _End, _Is_slash);
+            _Tmp.append(_Cursor, _Added_end);
+            const auto _Create_result = __std_fs_create_directory(_Tmp.c_str());
+            _Error                    = _Create_result._Error;
+            _Created_last             = _Create_result._Created;
+            if (_Error != __std_win_error::_Success && !__std_is_file_not_found(_Error)) {
+                _Most_recent_not_file_not_found = _Error;
+            }
+
+            _Cursor = _Added_end;
+        }
+
+        if (_Error != __std_win_error::_Success && _Most_recent_not_file_not_found != __std_win_error::_Success) {
+            _Error = _Most_recent_not_file_not_found;
+        }
+
+        _Ec = _Make_ec(_Error);
+        return _Created_last;
+    }
+
+    _EXPORT_STD inline bool create_directories(const path& _Path) {
+        error_code _Ec;
+        const bool _Result = _STD filesystem::create_directories(_Path, _Ec);
+        if (_Ec) {
+            _Throw_fs_error("create_directories", _Ec, _Path);
+        }
+
+        return _Result;
+    }
+
+    inline constexpr int _Remove_all_retry_count = 10;
+
+    inline void _Remove_all_dir(const path& _Path, error_code& _Ec, uintmax_t& _Removed_count) {
+        // remove _Path, including any contents
+        for (directory_iterator _It(_Path, _Ec);; _It.increment(_Ec)) { // remove nonempty directory contents
+            if (_Ec) {
+                if (_Ec.category() != _STD system_category()
+                    || !__std_is_file_not_found(static_cast<__std_win_error>(_Ec.value()))) {
+                    return;
+                }
+
+                break;
+            }
+
+            if (_It._At_end()) {
+                break;
+            }
+
+            const auto& _Subpath  = _It->path();
+            const auto _Substatus = _It->symlink_status(_Ec);
+            if (_Ec) {
+                return;
+            }
+
+            if (_Substatus.type() == file_type::directory) {
+                _Remove_all_dir(_Subpath, _Ec, _Removed_count);
+            } else {
+                _Removed_count += _STD filesystem::remove(_Subpath, _Ec);
+            }
+
+            if (_Ec) {
+                return;
+            }
+        }
+
+        for (int _Retry = 0; _Retry < _Remove_all_retry_count; ++_Retry) {
+            // retry up to _Remove_all_retry_count for resilience against
+            // A/V tools, search indexers, backup tools, etc.
+            const auto _Path_remove_result = __std_fs_remove(_Path.c_str());
+            _Removed_count += _Path_remove_result._Removed;
+            _Ec = _Make_ec(_Path_remove_result._Error);
+            if (_Path_remove_result._Error != __std_win_error::_Directory_not_empty
+                && _Path_remove_result._Error != __std_win_error::_Access_denied) {
+                // ERROR_DIRECTORY_NOT_EMPTY if we're waiting for handles to children to be closed,
+                // ERROR_ACCESS_DENIED if the directory we're targeting itself is marked for deletion.
+                return;
+            }
+        }
+    }
+
+    _EXPORT_STD inline uintmax_t remove_all(const path& _Path, error_code& _Ec) {
+        // remove _Path, including any contents
+        _Ec.clear(); // for exception safety
+        const auto _First_remove_result = __std_fs_remove(_Path.c_str());
+        uintmax_t _Removed_count        = _First_remove_result._Removed;
+        _Ec                             = _Make_ec(_First_remove_result._Error);
+        if (_First_remove_result._Error == __std_win_error::_Directory_not_empty) {
+            _Remove_all_dir(_Path, _Ec, _Removed_count);
+        }
+
+        if (_Ec) {
+            _Removed_count = static_cast<uintmax_t>(-1);
+        }
+
+        return _Removed_count;
+    }
+
+    _EXPORT_STD inline uintmax_t remove_all(const path& _Path) {
+        error_code _Ec;
+        const auto _Removed_count = _STD filesystem::remove_all(_Path, _Ec);
+        if (_Ec) {
+            _Throw_fs_error("remove_all", _Ec, _Path);
+        }
+
+        return _Removed_count;
+    }
+
+    _NODISCARD inline __std_win_error _Last_write_time(const path& _Path, file_time_type& _Result) noexcept {
+        __std_fs_stats _Stats;
+        const auto _Error = __std_fs_get_stats(
+            _Path.c_str(), &_Stats, __std_fs_stats_flags::_Follow_symlinks | __std_fs_stats_flags::_Last_write_time);
+        if (_Error == __std_win_error::_Success) {
+            _Result = file_time_type{file_time_type::duration{_Stats._Last_write_time}};
+        } else {
+            _Result = (file_time_type::min) ();
+        }
+
+        return _Error;
+    }
+
+    _EXPORT_STD _NODISCARD inline file_time_type last_write_time(const path& _Path) {
+        file_time_type _Result;
+        const auto _Error = _Last_write_time(_Path, _Result);
+        if (_Error != __std_win_error::_Success) {
+            _Throw_fs_error("last_write_time", _Error, _Path);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline file_time_type last_write_time(const path& _Path, error_code& _Ec) noexcept {
+        file_time_type _Result;
+        _Ec = _Make_ec(_Last_write_time(_Path, _Result));
+        return _Result;
+    }
+
+    _EXPORT_STD inline void last_write_time(const path& _Target, const file_time_type _New_time) {
+        // set the last write time of _Target to _New_time
+        const auto _Err = __std_fs_set_last_write_time(_New_time.time_since_epoch().count(), _Target.c_str());
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("last_write_time", _Err, _Target);
+        }
+    }
+
+    _EXPORT_STD inline void last_write_time(
+        const path& _Target, const file_time_type _New_time, error_code& _Ec) noexcept {
+        // set the last write time of _Target to _New_time
+        _Ec = _Make_ec(__std_fs_set_last_write_time(_New_time.time_since_epoch().count(), _Target.c_str()));
+    }
+
+    _EXPORT_STD enum class perm_options { replace = 0x1, add = 0x2, remove = 0x4, nofollow = 0x8 };
+
+    _BITMASK_OPS(_EXPORT_STD, perm_options)
+
+    _NODISCARD inline __std_win_error _Permissions(
+        const path& _Target, const perms _Perms, perm_options _Options) noexcept {
+        bool _Readonly;
+        const bool _Follow_symlinks = (_Options & perm_options::nofollow) == perm_options{};
+        _Options &= ~perm_options::nofollow;
+        const auto _Write_perms = _Perms & perms::_All_write;
+        switch (_Options) {
+        case perm_options::replace:
+            // always apply FILE_ATTRIBUTE_READONLY according to _Perms
+            _Readonly = _Write_perms == perms::none;
+            break;
+        case perm_options::add:
+            if (_Write_perms == perms::none) {
+                // if we aren't adding any write bits, then we won't change
+                // FILE_ATTRIBUTE_READONLY, so there's nothing to do
+                return __std_win_error::_Success;
+            }
+
+            _Readonly = false;
+            break;
+        case perm_options::remove:
+            if (_Write_perms != perms::_All_write) {
+                // if we aren't removing all write bits, then we won't change
+                // FILE_ATTRIBUTE_READONLY, so there's nothing to do
+                return __std_win_error::_Success;
+            }
+
+            _Readonly = true;
+            break;
+        case perm_options::nofollow: // avoid C4061
+        default:
+            return __std_win_error::_Invalid_parameter;
+        }
+
+        return __std_fs_change_permissions(_Target.c_str(), _Follow_symlinks, _Readonly);
+    }
+
+    _EXPORT_STD inline void permissions(
+        const path& _Target, const perms _Perms, const perm_options _Options = perm_options::replace) {
+        const auto _Err = _Permissions(_Target, _Perms, _Options);
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("permissions", _Err, _Target);
+        }
+    }
+
+    _EXPORT_STD inline void permissions(
+        const path& _Target, const perms _Perms, const perm_options _Options, error_code& _Ec) noexcept {
+        _Ec = _Make_ec(_Permissions(_Target, _Perms, _Options));
+    }
+
+    _EXPORT_STD inline void permissions(const path& _Target, const perms _Perms, error_code& _Ec) noexcept {
+        _STD filesystem::permissions(_Target, _Perms, perm_options::replace, _Ec);
+    }
+
+    _NODISCARD inline path _Temp_directory_path_impl(error_code& _Ec) {
+        // get a location suitable for temporary storage, and verify that it is a directory
+        path _Result;
+        _Result._Text.resize(__std_fs_temp_path_max);
+        const auto _Temp_result = __std_fs_get_temp_path(_Result._Text.data());
+        _Result._Text.resize(_Temp_result._Size);
+        if (_Temp_result._Error == __std_win_error::_Max) { // path could be retrieved, but was not a directory
+            _Ec = _STD make_error_code(errc::not_a_directory);
+        } else {
+            _Ec = _Make_ec(_Temp_result._Error);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline path temp_directory_path(error_code& _Ec) {
+        _Ec.clear(); // for exception safety
+        path _Result(_STD filesystem::_Temp_directory_path_impl(_Ec));
+        if (_Ec) {
+            // returns path() if an error occurs. (N5008 [fs.op.temp.dir.path]/3)
+            return {};
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline path temp_directory_path() {
+        // get a location suitable for temporary storage, and verify that it is a directory
+        error_code _Ec; // unusual arrangement to allow thrown error_code to have generic_category()
+        path _Result(_STD filesystem::_Temp_directory_path_impl(_Ec));
+        if (_Ec) {
+            _Throw_fs_error("temp_directory_path", _Ec, _Result);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline path current_path(error_code& _Ec) {
+        _Ec.clear(); // for exception safety
+        path _Result;
+        _Result._Text.resize(__std_fs_max_path);
+        for (;;) {
+            const auto _Requested_size = static_cast<unsigned long>(_Result._Text.size());
+            const auto _Temp_result    = __std_fs_get_current_path(_Requested_size, _Result._Text.data());
+            _Result._Text.resize(_Temp_result._Size);
+            if (_Temp_result._Size < _Requested_size) {
+                _Ec = _Make_ec(_Temp_result._Error);
+                return _Result;
+            }
+        }
+    }
+
+    _EXPORT_STD _NODISCARD inline path current_path() {
+        error_code _Ec;
+        path _Result(_STD filesystem::current_path(_Ec));
+        if (_Ec) {
+            _Throw_fs_error("current_path()", _Ec);
+        }
+        return _Result;
+    }
+
+    _EXPORT_STD inline void current_path(const path& _To, error_code& _Ec) noexcept { // set the current path
+        _Ec = _Make_ec(__std_fs_set_current_path(_To._Text.data()));
+    }
+
+    _EXPORT_STD inline void current_path(const path& _To) { // set the current path
+        const auto _Err = __std_fs_set_current_path(_To._Text.data());
+        if (_Err != __std_win_error::_Success) {
+            _Throw_fs_error("current_path(const path&)", _Err, _To);
+        }
+    }
+
+    _EXPORT_STD _NODISCARD inline path weakly_canonical(const path& _Input, error_code& _Ec) {
+        // eventually calls GetFinalPathNameByHandleW
+        _Ec.clear(); // for exception safety
+
+        path _Temp;
+
+        {
+            const auto _Err = _Canonical(_Temp, _Input.native());
+
+            if (_Err == __std_win_error::_Success) {
+                return _Temp;
+            }
+
+            if (!__std_is_file_not_found(_Err)) {
+                _Ec = _Make_ec(_Err);
+                return {};
+            }
+        }
+
+        const path _Normalized = _Input.lexically_normal();
+
+        path _Result = _Normalized.root_path();
+
+        const path _Normalized_relative = _Normalized.relative_path();
+
+        bool _Call_canonical = true;
+
+        for (const auto& _Elem : _Normalized_relative) {
+            _Result /= _Elem;
+
+            if (_Call_canonical) {
+                _Temp.clear();
+
+                const auto _Err = _Canonical(_Temp, _Result.native());
+
+                if (_Err == __std_win_error::_Success) {
+                    _Result = _STD move(_Temp);
+                } else if (__std_is_file_not_found(_Err)) {
+                    _Call_canonical = false;
+                } else {
+                    _Ec = _Make_ec(_Err);
+                    return {};
+                }
+            }
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline path weakly_canonical(const path& _Input) {
+        // eventually calls GetFinalPathNameByHandleW
+        error_code _Ec;
+
+        path _Result = _STD filesystem::weakly_canonical(_Input, _Ec);
+
+        if (_Ec) {
+            _Throw_fs_error("weakly_canonical", _Ec, _Input);
+        }
+
+        return _Result;
+    }
+
+    _EXPORT_STD _NODISCARD inline path proximate(
+        const path& _Path, const path& _Base = _STD filesystem::current_path()) {
+        // eventually calls GetFinalPathNameByHandleW
+        const path _Weakly_canonical_path = _STD filesystem::weakly_canonical(_Path);
+        const path _Weakly_canonical_base = _STD filesystem::weakly_canonical(_Base);
+        return _Weakly_canonical_path.lexically_proximate(_Weakly_canonical_base);
+    }
+
+    _EXPORT_STD _NODISCARD inline path proximate(const path& _Path, const path& _Base, error_code& _Ec) {
+        // eventually calls GetFinalPathNameByHandleW
+        const path _Weakly_canonical_path = _STD filesystem::weakly_canonical(_Path, _Ec);
+
+        if (_Ec) {
+            return {};
+        }
+
+        const path _Weakly_canonical_base = _STD filesystem::weakly_canonical(_Base, _Ec);
+
+        if (_Ec) {
+            return {};
+        }
+
+        return _Weakly_canonical_path.lexically_proximate(_Weakly_canonical_base);
+    }
+
+    _EXPORT_STD _NODISCARD inline path proximate(const path& _Path, error_code& _Ec) {
+        // eventually calls GetFinalPathNameByHandleW
+        const path _Base = _STD filesystem::current_path(_Ec);
+        // N4950 [fs.op.proximate]/1 incorrectly calls current_path()
+        if (_Ec) {
+            return {};
+        }
+
+        return _STD filesystem::proximate(_Path, _Base, _Ec);
+    }
+
+    _EXPORT_STD _NODISCARD inline path relative(
+        const path& _Path, const path& _Base = _STD filesystem::current_path()) {
+        // eventually calls GetFinalPathNameByHandleW
+        const path _Weakly_canonical_path = _STD filesystem::weakly_canonical(_Path);
+        const path _Weakly_canonical_base = _STD filesystem::weakly_canonical(_Base);
+        return _Weakly_canonical_path.lexically_relative(_Weakly_canonical_base);
+    }
+
+    _EXPORT_STD _NODISCARD inline path relative(const path& _Path, const path& _Base, error_code& _Ec) {
+        // eventually calls GetFinalPathNameByHandleW
+        const path _Weakly_canonical_path = _STD filesystem::weakly_canonical(_Path, _Ec);
+
+        if (_Ec) {
+            return {};
+        }
+
+        const path _Weakly_canonical_base = _STD filesystem::weakly_canonical(_Base, _Ec);
+
+        if (_Ec) {
+            return {};
+        }
+
+        return _Weakly_canonical_path.lexically_relative(_Weakly_canonical_base);
+    }
+
+    _EXPORT_STD _NODISCARD inline path relative(const path& _Path, error_code& _Ec) {
+        // eventually calls GetFinalPathNameByHandleW
+        const path _Base = _STD filesystem::current_path(_Ec);
+        // N4950 [fs.op.relative]/1 incorrectly calls current_path()
+        if (_Ec) {
+            return {};
+        }
+
+        return _STD filesystem::relative(_Path, _Base, _Ec);
+    }
+
+    inline void _Copy_impl(
+        const directory_entry& _From, const path& _To, const copy_options _Options, error_code& _Ec) {
+        // implement copy, does not clear _Ec for callers
+        // Standard quotes herein are relative to N4950
+        // The following parts of LWG-3057 are implemented:
+        // * guarding equivalent() from nonexistent to
+        // * replacing unspecified recursion prevention tag with copy_options::directories_only
+        // Other parts of LWG-3057 remain under discussion in the committee and are not yet implemented.
+        //  (In particular, changes to existing destination flags, and error handling).
+        const bool _Flink = (_Options & (copy_options::skip_symlinks | copy_options::copy_symlinks))
+                         != copy_options::none; // create_symlinks intentionally removed by LWG-3057
+        const auto _Fstat = _From._Get_any_status(_Flink ? _Symlink_status_stats_flags : _Status_stats_flags);
+        if (_Fstat._Error != __std_win_error::_Success) { // report an error if exists(f) is false
+            _Ec = _Make_ec(_Fstat._Error);
+            return;
+        }
+
+        const bool _Tlink =
+            (_Options & (copy_options::create_symlinks | copy_options::skip_symlinks)) != copy_options::none;
+        const auto _Tstat = _Get_any_status(_To, _Tlink ? _Symlink_status_stats_flags : _Status_stats_flags);
+        if (_Tstat._Not_good()) {
+            _Ec = _Make_ec(_Tstat._Error);
+            return;
+        }
+
+        if (_STD filesystem::exists(_Tstat._Status)) {
+            if (_STD filesystem::equivalent(_From, _To, _Ec)) { // report an error if equivalent(from, to) is true
+                _Ec = _STD make_error_code(errc::file_exists);
+                return;
+            }
+
+            if (_Ec) {
+                return;
+            }
+        }
+
+        const bool _Fstat_is_other =
+            _STD filesystem::is_other(_Fstat._Status) && _Fstat._Status.type() != file_type::junction;
+        const bool _Tstat_is_other =
+            _STD filesystem::is_other(_Tstat._Status) && _Tstat._Status.type() != file_type::junction;
+        if (_Fstat_is_other || _Tstat_is_other) {
+            // report an error if is_other(f) || is_other(t) is true, and it's not a junction
+            _Ec = _STD make_error_code(errc::operation_not_supported);
+            return;
+        }
+
+        if (_STD filesystem::is_directory(_Fstat._Status) && _STD filesystem::is_regular_file(_Tstat._Status)) {
+            // report an error if is_directory(f) && is_regular_file(t) is true
+            _Ec = _STD make_error_code(errc::file_exists);
+            return;
+        }
+
+        if (_Fstat._Status.type() == file_type::junction) {
+            if ((_Options & copy_options::skip_symlinks) != copy_options::none) {
+                return;
+            }
+
+            // _Options includes copy_options::copy_symlinks,
+            // since _Fstat is only allowed to be a symbolic link when either skip_symlinks or copy_symlinks
+            if (!_STD filesystem::exists(_Tstat._Status)) {
+                _Ec = _Make_ec(_Copy_junction(_From, _To));
+            }
+        }
+
+        if (_STD filesystem::is_symlink(_Fstat._Status)) {
+            if ((_Options & copy_options::skip_symlinks) != copy_options::none) {
+                return;
+            }
+
+            // _Options includes copy_options::copy_symlinks,
+            // since _Fstat is only allowed to be a symbolic link when either skip_symlinks or copy_symlinks
+            if (!_STD filesystem::exists(_Tstat._Status)) {
+                _STD filesystem::copy_symlink(_From, _To, _Ec);
+                return;
+            }
+
+            // otherwise report an error
+            _Ec = _STD make_error_code(errc::operation_not_supported);
+            return;
+        }
+
+        if (_STD filesystem::is_regular_file(_Fstat._Status)) {
+            if ((_Options & copy_options::directories_only) != copy_options::none) {
+                return;
+            }
+
+            if ((_Options & copy_options::create_symlinks) != copy_options::none) {
+                // Otherwise, if (condition) then create a symbolic link to the source file
+                _STD filesystem::create_symlink(_From, _To, _Ec);
+                return;
+            }
+
+            if ((_Options & copy_options::create_hard_links) != copy_options::none) {
+                // Otherwise, if (condition) then create a hard link to the source file
+                _STD filesystem::create_hard_link(_From, _To, _Ec);
+                return;
+            }
+
+            if (_STD filesystem::is_directory(_Tstat._Status)) {
+                // Otherwise, if is_directory(t), then copy_file(from, to / from.filename(), options)
+                _STD filesystem::copy_file(_From, _To / _From.path().filename(), _Options, _Ec);
+                return;
+            }
+
+            // Otherwise, copy_file(_From, _To, _Options)
+            _STD filesystem::copy_file(_From, _To, _Options, _Ec);
+            return;
+        }
+
+        // The following condition modified by LWG-3057:
+        if (_STD filesystem::is_directory(_Fstat._Status)) {
+            if ((_Options & copy_options::create_symlinks) != copy_options::none) {
+                _Ec = _STD make_error_code(errc::is_a_directory);
+                return;
+            }
+
+            _STD filesystem::create_directory(_To, _From, _Ec);
+            if (_Ec) {
+                return;
+            }
+
+            // Note LWG-3057 uses directories_only as the flag, instead of an unspecified copy_options value:
+            if ((_Options & copy_options::recursive) != copy_options::none
+                || (_Options & copy_options::directories_only) == copy_options::none) {
+                for (directory_iterator _It(_From, _Ec);; _It.increment(_Ec)) {
+                    if (_Ec || _It._At_end()) {
+                        return;
+                    }
+
+                    // if ((options & copy_options::recursive) != copy_options::none ||
+                    //      !is_directory(linkf ? symlink_status(x.path()) : status(x.path())))
+                    //        copy(x.path(), to/x.path().filename(), options);
+                    bool _Recurse = (_Options & copy_options::recursive) != copy_options::none;
+                    if (!_Recurse) {
+                        const auto _Child_status_result =
+                            _It->_Get_any_status(_Flink ? _Symlink_status_stats_flags : _Status_stats_flags);
+                        if (_Child_status_result._Error != __std_win_error::_Success) {
+                            _Ec = _Make_ec(_Child_status_result._Error);
+                            return;
+                        }
+
+                        _Recurse = !_STD filesystem::is_directory(_Child_status_result._Status);
+                    }
+
+                    if (_Recurse) {
+                        _Copy_impl(*_It, _To / _It->path().filename(), _Options, _Ec);
+                        if (_Ec) {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Otherwise, no effects.
+    }
+
+    _EXPORT_STD inline void copy(const path& _From, const path& _To, const copy_options _Options, error_code& _Ec) {
+        const directory_entry _From_dir(_From, _Ec);
+        if (_Ec) { // report an error if exists(f) is false
+            return;
+        }
+
+        _Copy_impl(_From_dir, _To, _Options, _Ec);
+    }
+
+    _EXPORT_STD inline void copy(const path& _From, const path& _To, const copy_options _Options) {
+        error_code _Ec;
+        _STD filesystem::copy(_From, _To, _Options, _Ec);
+        if (_Ec) {
+            _Throw_fs_error("copy", _Ec, _From, _To);
+        }
+    }
+
+    _EXPORT_STD inline void copy(const path& _From, const path& _To, error_code& _Ec) {
+        return _STD filesystem::copy(_From, _To, copy_options::none, _Ec);
+    }
+
+    _EXPORT_STD inline void copy(const path& _From, const path& _To) {
+        return _STD filesystem::copy(_From, _To, copy_options::none);
+    }
+} // namespace filesystem
+
+template <>
+struct hash<filesystem::path> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = filesystem::path;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD static size_t operator()(const filesystem::path& _Path) noexcept {
+        return _STD filesystem::hash_value(_Path);
+    }
+};
+
+#if _HAS_CXX20
+namespace ranges {
+    template <>
+    inline constexpr bool enable_borrowed_range<filesystem::directory_iterator> = true;
+    template <>
+    inline constexpr bool enable_borrowed_range<filesystem::recursive_directory_iterator> = true;
+    template <>
+    inline constexpr bool enable_view<filesystem::directory_iterator> = true;
+    template <>
+    inline constexpr bool enable_view<filesystem::recursive_directory_iterator> = true;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX17 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FILESYSTEM_
diff --git a/msvc-stl/stl/inc/flat_map b/msvc-stl/stl/inc/flat_map
new file mode 100644
index 0000000..fa30f1f
--- /dev/null
+++ b/msvc-stl/stl/inc/flat_map
@@ -0,0 +1,1621 @@
+// flat_map standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _FLAT_MAP_
+#define _FLAT_MAP_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <flat_map> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+
+#include <algorithm>
+#include <compare>
+#include <concepts>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include <xmemory>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#undef msvc
+
+_STD_BEGIN
+template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class _Flat_map_base;
+
+template <class _KeyIter, class _MappedIter, class _MappedConvIter>
+struct _Pairing_iterator_provider;
+
+template <class _KeyIter, class _MappedIter, class _MappedConvIter>
+concept _Can_unwrap_pairing_iterator =
+    !conjunction_v<is_same<_Unwrapped_t<_KeyIter>, _KeyIter>, is_same<_Unwrapped_t<_MappedIter>, _MappedIter>>;
+
+template <class _KeyIter, class _MappedIter, class _MappedConvIter>
+struct _Pairing_iterator_provider {
+    class _Iterator {
+    public:
+        using iterator_category = input_iterator_tag;
+        using iterator_concept  = random_access_iterator_tag;
+        using difference_type   = ptrdiff_t;
+        using value_type        = pair<iter_value_t<_KeyIter>, iter_value_t<_MappedIter>>;
+        using reference         = pair<iter_reference_t<_KeyIter>, iter_reference_t<_MappedIter>>;
+
+        _Iterator() = default;
+
+    private:
+        template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer,
+            class _MappedContainer>
+        friend class _Flat_map_base;
+        template <class _KeyIter2, class _MappedIter2, class _MappedConvIter2>
+        friend struct _Pairing_iterator_provider;
+
+        explicit _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter)
+            noexcept(is_nothrow_move_constructible_v<_KeyIter> && is_nothrow_move_constructible_v<_MappedIter>)
+            : _Key_it(_STD move(_Key_iter)), _Mapped_it(_STD move(_Mapped_iter)) {}
+
+        using _Const_iterator     = _Pairing_iterator_provider<_KeyIter, _MappedConvIter, _MappedConvIter>::_Iterator;
+        using _Unwrapped_iterator = _Pairing_iterator_provider<_Unwrapped_t<_KeyIter>, _Unwrapped_t<_MappedIter>,
+            _Unwrapped_t<_MappedConvIter>>::_Iterator;
+
+        class _Arrow_proxy {
+        public:
+            _NODISCARD const reference* operator->() const noexcept {
+                return _STD addressof(_Ref);
+            }
+
+        private:
+            friend _Iterator;
+
+            explicit _Arrow_proxy(const _Iterator& _Iter) : _Ref{*_Iter} {}
+
+            reference _Ref;
+        };
+
+    public:
+        using pointer = _Arrow_proxy;
+
+        _NODISCARD reference operator*() const {
+            return reference{*_Key_it, *_Mapped_it};
+        }
+
+        _NODISCARD friend pair<iter_rvalue_reference_t<_KeyIter>, iter_rvalue_reference_t<_MappedIter>> iter_move(
+            const _Iterator& _It) {
+            return {_RANGES iter_move(_It._Key_it), _RANGES iter_move(_It._Mapped_it)};
+        }
+
+        _NODISCARD pointer operator->() const {
+            return pointer{*this};
+        }
+
+        _Iterator& operator++() {
+            ++_Key_it;
+            ++_Mapped_it;
+            return *this;
+        }
+
+        _Iterator operator++(int) {
+            auto _Old = *this;
+            ++*this;
+            return _Old;
+        }
+
+        _NODISCARD bool operator==(const _Iterator& _Right) const {
+            _Compat(_Right);
+            return _Key_it == _Right._Key_it;
+        }
+
+        _NODISCARD auto operator<=>(const _Iterator& _Right) const {
+            _Compat(_Right);
+            return _Synth_three_way{}(_Key_it, _Right._Key_it);
+        }
+
+        _Iterator& operator--() {
+            --_Key_it;
+            --_Mapped_it;
+            return *this;
+        }
+
+        _Iterator operator--(int) {
+            auto _Old = *this;
+            --*this;
+            return _Old;
+        }
+
+        _Iterator& operator+=(const difference_type _Off) {
+            _Key_it += static_cast<iter_difference_t<_KeyIter>>(_Off);
+            _Mapped_it += static_cast<iter_difference_t<_MappedIter>>(_Off);
+            return *this;
+        }
+
+        _Iterator& operator-=(const difference_type _Off) {
+            _Key_it -= static_cast<iter_difference_t<_KeyIter>>(_Off);
+            _Mapped_it -= static_cast<iter_difference_t<_MappedIter>>(_Off);
+            return *this;
+        }
+
+        _NODISCARD _Iterator operator+(const difference_type _Off) const {
+            auto _Tmp = *this;
+            _Tmp += _Off;
+            return _Tmp;
+        }
+
+        _NODISCARD _Iterator operator-(const difference_type _Off) const {
+            auto _Tmp = *this;
+            _Tmp -= _Off;
+            return _Tmp;
+        }
+
+        _NODISCARD reference operator[](const difference_type _Off) const {
+            return *(*this + _Off);
+        }
+
+        _NODISCARD difference_type operator-(const _Iterator& _Right) const {
+            _Compat(_Right);
+            return _Key_it - _Right._Key_it;
+        }
+
+        _NODISCARD friend _Iterator operator+(const difference_type _Off, const _Iterator& _Right) {
+            return _Right + _Off;
+        }
+
+        _NODISCARD operator _Const_iterator() const
+            requires (!is_same_v<_MappedIter, _MappedConvIter>)
+        {
+            return _Const_iterator{_Key_it, _Mapped_it};
+        }
+
+        void _Compat([[maybe_unused]] const _Iterator& _Right) const noexcept { // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(
+                _Key_it - _Right._Key_it == _Mapped_it - _Right._Mapped_it, "iterators from inconsistent ranges");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        }
+
+        using _Prevent_inheriting_unwrap = _Iterator;
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+        friend void _Verify_range(const _Iterator& _First, const _Iterator& _Last) noexcept {
+            if constexpr (_Range_verifiable_v<_KeyIter>) {
+                _Verify_range(_First._Key_it, _Last._Key_it); // intentional ADL
+            }
+
+            if constexpr (_Range_verifiable_v<_MappedIter>) {
+                _Verify_range(_First._Mapped_it, _Last._Mapped_it); // intentional ADL
+            }
+
+            _First._Compat(_Last);
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        void _Verify_offset(const difference_type _Off) const noexcept {
+            if constexpr (_Offset_verifiable_v<_KeyIter>) {
+                _Key_it._Verify_offset(_Off);
+            }
+
+            if constexpr (_Offset_verifiable_v<_MappedIter>) {
+                _Mapped_it._Verify_offset(_Off);
+            }
+        }
+
+        _NODISCARD auto _Unwrapped() const
+            requires _Can_unwrap_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>
+        {
+            return _Unwrapped_iterator{_STD _Get_unwrapped(_Key_it), _STD _Get_unwrapped(_Mapped_it)};
+        }
+
+        static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_KeyIter>
+                                                     && _Do_unwrap_when_unverified_v<_MappedIter>
+                                                     && _Do_unwrap_when_unverified_v<_MappedConvIter>;
+
+        void _Seek_to(const _Unwrapped_iterator& _Dst)
+            requires _Can_unwrap_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>
+        {
+            _STD _Seek_wrapped(_Key_it, _Dst._Key_it);
+            _STD _Seek_wrapped(_Mapped_it, _Dst._Mapped_it);
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    public:
+#else
+    private:
+#endif
+        _KeyIter _Key_it;
+        _MappedIter _Mapped_it;
+    };
+};
+
+template <bool _IsNoexcept, class _Containers>
+struct _NODISCARD _Flat_map_swap_clear_guard {
+    // Invariant: (_Target1 == nullptr) == (_Target2 == nullptr)
+    _Containers* _Target1;
+    _Containers* _Target2;
+
+    _Flat_map_swap_clear_guard& operator=(const _Flat_map_swap_clear_guard&) = delete;
+
+    void _Dismiss() noexcept {
+        _Target1 = nullptr;
+        _Target2 = nullptr;
+    }
+
+    ~_Flat_map_swap_clear_guard() {
+        if (_Target1) {
+            _Target1->keys.clear();
+            _Target1->values.clear();
+            _Target2->keys.clear();
+            _Target2->values.clear();
+        }
+    }
+};
+template <class _Containers>
+struct _NODISCARD _Flat_map_swap_clear_guard<true, _Containers> {
+    constexpr explicit _Flat_map_swap_clear_guard(_Containers*, _Containers*) noexcept {}
+
+    _Flat_map_swap_clear_guard& operator=(const _Flat_map_swap_clear_guard&) = delete;
+
+    void _Dismiss() noexcept {}
+};
+
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
+    class _MappedContainer = vector<_Mapped>>
+class flat_map;
+
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
+    class _MappedContainer = vector<_Mapped>>
+class flat_multimap;
+
+template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class _Flat_map_base {
+private:
+    using _Sorted_t = conditional_t<_IsUnique, sorted_unique_t, sorted_equivalent_t>;
+    using _Derived  = conditional_t<_IsUnique, flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>,
+        flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
+
+    static constexpr const char* _Msg_not_sorted_maybe_unique =
+        _IsUnique ? "Keys were not sorted-unique! (N5032 [flat.map.overview]/10)"
+                  : "Keys were not sorted! (N5032 [flat.multimap.overview]/10)";
+    static constexpr const char* _Msg_replace_not_sorted_maybe_unique =
+        _IsUnique ? "Keys were not sorted-unique! (N5032 [flat.map.modifiers]/37)"
+                  : "Keys were not sorted! (N5032 [flat.map.modifiers]/37, [flat.multimap.overview]/4)";
+    static constexpr const char* _Msg_different_sizes =
+        _IsUnique ? "Containers were different sizes! (N5032 [flat.map.overview]/9)"
+                  : "Containers were different sizes! (N5032 [flat.multimap.overview]/9)";
+    static constexpr const char* _Msg_replace_different_sizes =
+        _IsUnique ? "Containers were different sizes! (N5032 [flat.map.modifiers]/37)"
+                  : "Containers were different sizes! (N5032 [flat.map.modifiers]/37, [flat.multimap.overview]/4)";
+
+public:
+    // [flat.map.defn] Types
+    using key_type              = _Key;
+    using mapped_type           = _Mapped;
+    using value_type            = pair<key_type, mapped_type>;
+    using key_compare           = _Compare;
+    using reference             = pair<const key_type&, mapped_type&>;
+    using const_reference       = pair<const key_type&, const mapped_type&>;
+    using size_type             = size_t;
+    using difference_type       = ptrdiff_t;
+    using key_container_type    = _KeyContainer;
+    using mapped_container_type = _MappedContainer;
+
+    using iterator = _Pairing_iterator_provider<typename key_container_type::const_iterator,
+        typename mapped_container_type::iterator, typename mapped_container_type::const_iterator>::_Iterator;
+
+    using const_iterator = _Pairing_iterator_provider<typename key_container_type::const_iterator,
+        typename mapped_container_type::const_iterator, typename mapped_container_type::const_iterator>::_Iterator;
+
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    static_assert(is_same_v<key_type, typename key_container_type::value_type>,
+        "key_type and key_container_type::value_type must be the same. "
+        "(N5032 [flat.map.overview]/8, [flat.multimap.overview]/8)");
+    static_assert(is_same_v<mapped_type, typename mapped_container_type::value_type>,
+        "mapped_type and mapped_container_type::value_type must be the same. "
+        "(N5032 [flat.map.overview]/8, [flat.multimap.overview]/8)");
+    static_assert(!_Is_vector_bool<key_container_type>,
+        "key_container_type cannot be vector<bool> because it is not a sequence container. "
+        "(N5032 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+    static_assert(!_Is_vector_bool<mapped_container_type>,
+        "mapped_container_type cannot be vector<bool> because it is not a sequence container. "
+        "(N5032 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+    static_assert(random_access_iterator<typename key_container_type::const_iterator>,
+        "key_container_type must support random-access iterators in order to be adapted. "
+        "(N5032 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+    static_assert(random_access_iterator<typename mapped_container_type::const_iterator>,
+        "mapped_container_type must support random-access iterators in order to be adapted. "
+        "(N5032 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+
+    class value_compare {
+    public:
+        _NODISCARD bool operator()(const_reference _Lhs, const_reference _Rhs) const {
+            return _Key_comparator(_Lhs.first, _Rhs.first);
+        }
+
+    private:
+        friend _Flat_map_base;
+
+        explicit value_compare(const key_compare& _Comp) : _Key_comparator(_Comp) {}
+
+        key_compare _Key_comparator;
+    };
+
+    struct containers {
+        key_container_type keys;
+        mapped_container_type values;
+    };
+
+    // [flat.map.cons] Constructors
+    _Flat_map_base() : _Data(), _Key_compare() {}
+
+    _Flat_map_base(const _Flat_map_base&) = default;
+
+    _Flat_map_base(_Flat_map_base&& _Other) noexcept(is_nothrow_move_constructible_v<key_container_type>
+                                                     && is_nothrow_move_constructible_v<mapped_container_type>
+                                                     && is_nothrow_copy_constructible_v<key_compare>) // strengthened
+        : _Data(_STD move(_Other).extract()),
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
+    {}
+
+    explicit _Flat_map_base(const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {}
+
+    _Flat_map_base(
+        key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
+        : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
+        _Establish_invariants();
+    }
+
+    _Flat_map_base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
+        const key_compare& _Comp = key_compare())
+        : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Iterator_for_container _InIt>
+    _Flat_map_base(const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
+        : _Data(), _Key_compare(_Comp) {
+        insert(_First, _Last);
+    }
+
+    template <_Iterator_for_container _InIt>
+    _Flat_map_base(_Sorted_t _Tag, const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
+        : _Data(), _Key_compare(_Comp) {
+        insert(_Tag, _First, _Last);
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_map_base(from_range_t, _Rng&& _Range) : _Data(), _Key_compare() {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
+
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Data(), _Key_compare(_Comp) {
+        insert(_Ilist);
+    }
+
+    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Data(), _Key_compare(_Comp) {
+        insert(_Tag, _Ilist);
+    }
+
+    // [flat.map.cons.alloc] Constructors with allocators
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    explicit _Flat_map_base(const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al)},
+          _Key_compare() {}
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const key_compare& _Comp, const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al)},
+          _Key_compare(_Comp) {}
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Alloc& _Al)
+        : _Flat_map_base(_Key_cont, _Mapped_cont, key_compare(), _Al) {}
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const key_compare& _Comp, const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al, _Mapped_cont)},
+          _Key_compare(_Comp) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
+        _Establish_invariants();
+    }
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Sorted_t _Tag, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const _Alloc& _Al)
+        : _Flat_map_base(_Tag, _Key_cont, _Mapped_cont, key_compare(), _Al) {}
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const key_compare& _Comp, const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al, _Mapped_cont)},
+          _Key_compare(_Comp) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const _Flat_map_base& _Other, const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al, _Other._Data.keys),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al, _Other._Data.values)},
+          _Key_compare(_Other._Key_compare) {}
+
+private:
+    template <class _Alloc>
+    _NODISCARD containers _Extract_using_allocator(const _Alloc& _Al) && {
+        _Clear_guard _Always_clear{this};
+        return containers{.keys = _STD make_obj_using_allocator<key_container_type>(_Al, _STD move(_Data.keys)),
+            .values             = _STD make_obj_using_allocator<mapped_container_type>(_Al, _STD move(_Data.values))};
+    }
+
+public:
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Flat_map_base&& _Other, const _Alloc& _Al)
+        : _Data{_STD move(_Other)._Extract_using_allocator(_Al)},
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
+    {}
+
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const _InIt _First, const _InIt _Last, const _Alloc& _Al) : _Flat_map_base(_Al) {
+        insert(_First, _Last);
+    }
+
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
+        insert(_First, _Last);
+    }
+
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Sorted_t _Tag, const _InIt _First, const _InIt _Last, const _Alloc& _Al) : _Flat_map_base(_Al) {
+        insert(_Tag, _First, _Last);
+    }
+
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Sorted_t _Tag, const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
+        insert(_Tag, _First, _Last);
+    }
+
+    template <_Container_compatible_range<value_type> _Rng,
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const _Alloc& _Al) : _Flat_map_base(_Al) {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng,
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const _Alloc& _Al) : _Flat_map_base(_Al) {
+        insert(_Ilist);
+    }
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
+        insert(_Ilist);
+    }
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const _Alloc& _Al) : _Flat_map_base(_Al) {
+        insert(_Tag, _Ilist);
+    }
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(
+        _Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
+        insert(_Tag, _Ilist);
+    }
+
+    // Assignment operators
+    _Flat_map_base& operator=(const _Flat_map_base& _Other) {
+        _Clear_guard _Guard{this};
+        _Data          = _Other._Data;
+        _Key_compare   = _Other._Key_compare;
+        _Guard._Target = nullptr;
+        return *this;
+    }
+
+    _Flat_map_base& operator=(_Flat_map_base&& _Other)
+        noexcept(is_nothrow_move_assignable_v<key_container_type> && is_nothrow_move_assignable_v<mapped_container_type>
+                 && is_nothrow_copy_assignable_v<key_compare>) /* strengthened */ {
+        if (this != _STD addressof(_Other)) {
+            _Clear_guard _Guard{this};
+            _Clear_guard _Always_clear{_STD addressof(_Other)};
+            _Data          = _STD move(_Other._Data);
+            _Key_compare   = _Other._Key_compare; // intentionally copy comparator, see LWG-2227
+            _Guard._Target = nullptr;
+        }
+        return *this;
+    }
+
+    // Iterators
+    _NODISCARD iterator begin() noexcept {
+        _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
+        return iterator{_Data.keys.cbegin(), _Data.values.begin()};
+    }
+    _NODISCARD const_iterator begin() const noexcept {
+        _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<const_iterator>);
+        _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
+        return const_iterator{_Data.keys.cbegin(), _Data.values.cbegin()};
+    }
+    _NODISCARD iterator end() noexcept {
+        return iterator{_Data.keys.cend(), _Data.values.end()};
+    }
+    _NODISCARD const_iterator end() const noexcept {
+        return const_iterator{_Data.keys.cend(), _Data.values.cend()};
+    }
+
+    _NODISCARD reverse_iterator rbegin() noexcept {
+        return reverse_iterator{end()};
+    }
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator{end()};
+    }
+    _NODISCARD reverse_iterator rend() noexcept {
+        return reverse_iterator{begin()};
+    }
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator{begin()};
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return const_iterator{_Data.keys.cbegin(), _Data.values.cbegin()};
+    }
+    _NODISCARD const_iterator cend() const noexcept {
+        return const_iterator{_Data.keys.cend(), _Data.values.cend()};
+    }
+
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return const_reverse_iterator{cend()};
+    }
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return const_reverse_iterator{cbegin()};
+    }
+
+    // [flat.map.capacity] Capacity
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Data.keys.empty();
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _Data.keys.size();
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        return (_STD min) (_Data.keys.max_size(), _Data.values.max_size());
+    }
+
+    // [flat.map.modifiers] Modifiers
+    template <class... _ArgTypes>
+    auto emplace(_ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
+    {
+        value_type _Val(_STD forward<_ArgTypes>(_Args)...);
+        return _Try_emplace(_STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    template <class... _ArgTypes>
+    iterator emplace_hint(const const_iterator _Position, _ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
+    {
+        value_type _Val(_STD forward<_ArgTypes>(_Args)...);
+        return _Emplace_hint<false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    auto insert(const value_type& _Val) {
+        return _Try_emplace(_Val.first, _Val.second);
+    }
+    auto insert(value_type&& _Val) {
+        return _Try_emplace(_STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    iterator insert(const const_iterator _Position, const value_type& _Val) {
+        return _Emplace_hint<false>(_Position, _Val.first, _Val.second);
+    }
+    iterator insert(const const_iterator _Position, value_type&& _Val) {
+        return _Emplace_hint<false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    template <class _OtherPair>
+    auto insert(_OtherPair&& _Val)
+        requires is_constructible_v<value_type, _OtherPair>
+    {
+        return emplace(_STD forward<_OtherPair>(_Val));
+    }
+
+    template <class _OtherPair>
+    iterator insert(const const_iterator _Position, _OtherPair&& _Val)
+        requires is_constructible_v<value_type, _OtherPair>
+    {
+        return emplace_hint(_Position, _STD forward<_OtherPair>(_Val));
+    }
+
+    template <_Iterator_for_container _InIt>
+    void insert(const _InIt _First, const _InIt _Last) {
+        _Insert_range<true>(_First, _Last);
+    }
+    template <_Iterator_for_container _InIt>
+    void insert(_Sorted_t, const _InIt _First, const _InIt _Last) {
+        _Insert_range<false>(_First, _Last);
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
+        _Insert_range<true>(_RANGES begin(_Range), _RANGES end(_Range));
+    }
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Sorted_t, _Rng&& _Range) {
+        _Insert_range<false>(_RANGES begin(_Range), _RANGES end(_Range));
+    }
+
+    void insert(const initializer_list<value_type> _Ilist) {
+        _Insert_range<true>(_Ilist.begin(), _Ilist.end());
+    }
+    void insert(_Sorted_t, const initializer_list<value_type> _Ilist) {
+        _Insert_range<false>(_Ilist.begin(), _Ilist.end());
+    }
+
+    _NODISCARD containers extract() && noexcept(
+        is_nothrow_move_constructible_v<key_container_type>
+        && is_nothrow_move_constructible_v<mapped_container_type>) /* strengthened */ {
+        // always clears the container (N5032 [flat.map.modifiers]/35 and [flat.multimap.overview]/4)
+        _Clear_guard _Always_clear{this};
+        return _STD move(_Data);
+    }
+
+    void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
+        _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), _Msg_replace_different_sizes);
+        _STL_ASSERT(_Is_sorted_maybe_unique(_Key_cont.begin(), _Key_cont.end()), _Msg_replace_not_sorted_maybe_unique);
+        _Clear_guard _Guard{this};
+        _Data.keys     = _STD move(_Key_cont);
+        _Data.values   = _STD move(_Mapped_cont);
+        _Guard._Target = nullptr;
+    }
+
+    iterator erase(const iterator _Position) {
+        return erase(static_cast<const_iterator>(_Position));
+    }
+
+    iterator erase(const const_iterator _Position) {
+        _Clear_guard _Guard{this};
+        auto _Key_it   = _Data.keys.erase(_Position._Key_it);
+        auto _Val_it   = _Data.values.erase(_Position._Mapped_it);
+        _Guard._Target = nullptr;
+        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    }
+
+    size_type erase(const key_type& _Key_val) {
+        return _Erase_key(_Key_val);
+    }
+
+    template <class _OtherKey>
+        requires _Transparent<key_compare> && (!is_convertible_v<_OtherKey, iterator>)
+              && (!is_convertible_v<_OtherKey, const_iterator>)
+    size_type erase(_OtherKey&& _Key_val) {
+        return _Erase_key(_STD forward<_OtherKey>(_Key_val));
+    }
+
+    iterator erase(const const_iterator _First, const const_iterator _Last) {
+        _Clear_guard _Guard{this};
+        auto _Key_it   = _Data.keys.erase(_First._Key_it, _Last._Key_it);
+        auto _Val_it   = _Data.values.erase(_First._Mapped_it, _Last._Mapped_it);
+        _Guard._Target = nullptr;
+        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    }
+
+    void swap(_Derived& _Other)
+        noexcept(is_nothrow_swappable_v<key_container_type> && is_nothrow_swappable_v<mapped_container_type>
+                 && is_nothrow_swappable_v<key_compare>) {
+        constexpr bool _Is_noexcept = is_nothrow_swappable_v<key_container_type>
+                                   && is_nothrow_swappable_v<mapped_container_type>
+                                   && is_nothrow_swappable_v<key_compare>;
+        _Flat_map_swap_clear_guard<_Is_noexcept, containers> _Guard{
+            _STD addressof(_Data), _STD addressof(_Other._Data)};
+        _RANGES swap(_Data.keys, _Other._Data.keys);
+        _RANGES swap(_Data.values, _Other._Data.values);
+        _RANGES swap(_Key_compare, _Other._Key_compare);
+        _Guard._Dismiss();
+    }
+
+    void clear() noexcept {
+        _Data.keys.clear();
+        _Data.values.clear();
+    }
+
+    // Observers
+    _NODISCARD key_compare key_comp() const {
+        return _Key_compare;
+    }
+
+    _NODISCARD value_compare value_comp() const {
+        return value_compare{_Key_compare};
+    }
+
+    _NODISCARD const key_container_type& keys() const noexcept {
+        return _Data.keys;
+    }
+
+    _NODISCARD const mapped_container_type& values() const noexcept {
+        return _Data.values;
+    }
+
+    // map operations
+    _NODISCARD iterator find(const key_type& _Key_val) {
+        return _Find(_Key_val);
+    }
+    _NODISCARD const_iterator find(const key_type& _Key_val) const {
+        return _Find(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD iterator find(const _OtherKey& _Key_val)
+        requires _Transparent<key_compare>
+    {
+        return _Find(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD const_iterator find(const _OtherKey& _Key_val) const
+        requires _Transparent<key_compare>
+    {
+        return _Find(_Key_val);
+    }
+
+    _NODISCARD size_type count(const key_type& _Key_val) const {
+        return _Count(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD size_type count(const _OtherKey& _Key_val) const
+        requires _Transparent<key_compare>
+    {
+        return _Count(_Key_val);
+    }
+
+    _NODISCARD bool contains(const key_type& _Key_val) const {
+        return _Contains(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD bool contains(const _OtherKey& _Key_val) const
+        requires _Transparent<key_compare>
+    {
+        return _Contains(_Key_val);
+    }
+
+    _NODISCARD iterator lower_bound(const key_type& _Key_val) {
+        return _Lower_bound(_Key_val);
+    }
+    _NODISCARD const_iterator lower_bound(const key_type& _Key_val) const {
+        return _Lower_bound(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD iterator lower_bound(const _OtherKey& _Key_val)
+        requires _Transparent<key_compare>
+    {
+        return _Lower_bound(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD const_iterator lower_bound(const _OtherKey& _Key_val) const
+        requires _Transparent<key_compare>
+    {
+        return _Lower_bound(_Key_val);
+    }
+
+    _NODISCARD iterator upper_bound(const key_type& _Key_val) {
+        return _Upper_bound(_Key_val);
+    }
+    _NODISCARD const_iterator upper_bound(const key_type& _Key_val) const {
+        return _Upper_bound(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD iterator upper_bound(const _OtherKey& _Key_val)
+        requires _Transparent<key_compare>
+    {
+        return _Upper_bound(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD const_iterator upper_bound(const _OtherKey& _Key_val) const
+        requires _Transparent<key_compare>
+    {
+        return _Upper_bound(_Key_val);
+    }
+
+    _NODISCARD pair<iterator, iterator> equal_range(const key_type& _Key_val) {
+        return _Equal_range(_Key_val);
+    }
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Key_val) const {
+        return _Equal_range(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD pair<iterator, iterator> equal_range(const _OtherKey& _Key_val)
+        requires _Transparent<key_compare>
+    {
+        return _Equal_range(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _OtherKey& _Key_val) const
+        requires _Transparent<key_compare>
+    {
+        return _Equal_range(_Key_val);
+    }
+
+    _NODISCARD friend bool operator==(const _Derived& _Lhs, const _Derived& _Rhs) {
+        return _STD equal(_Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend());
+    }
+
+    _NODISCARD friend auto operator<=>(const _Derived& _Lhs, const _Derived& _Rhs) {
+        return _STD lexicographical_compare_three_way(
+            _Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend(), _Synth_three_way{});
+    }
+
+    friend void swap(_Derived& _Lhs, _Derived& _Rhs) noexcept(noexcept(_Lhs.swap(_Rhs))) {
+        _Lhs.swap(_Rhs);
+    }
+
+protected:
+    template <class _OtherKey, class... _MappedArgTypes>
+    _NODISCARD conditional_t<_IsUnique, pair<iterator, bool>, iterator> _Try_emplace(
+        _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_OtherKey>, key_type>
+                                    || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) );
+
+        const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
+        const auto _Index  = _Key_it - _Data.keys.begin();
+        if constexpr (_IsUnique) {
+            if (_Key_it != _Data.keys.begin() && !_Compare_keys(*(_Key_it - 1), _Key_val)) {
+                // Previous element is equivalent to key, no insert needed
+                return {begin() + (_Index - 1), false};
+            }
+        }
+
+        // Need to insert
+        _Emplace_exact(
+            cbegin() + _Index, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+
+        if constexpr (_IsUnique) {
+            return {begin() + _Index, true};
+        } else {
+            return begin() + _Index;
+        }
+    }
+
+    template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
+    _NODISCARD iterator _Emplace_hint(
+        const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_OtherKey>, key_type>
+                                    || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) );
+
+        // Overwriting is not supported when the container allows multiple copies of a key.
+        _STL_INTERNAL_STATIC_ASSERT(_IsUnique || !_OverwriteIfExists);
+
+        const const_iterator _Begin = cbegin();
+        const const_iterator _End   = cend();
+
+        const weak_ordering _Hint_order = [&] {
+            if constexpr (_IsUnique) {
+                if (_Position == _End || _Compare_keys(_Key_val, *_Position._Key_it)) {
+                    if (_Position == _Begin || _Compare_keys(*(_Position._Key_it - 1), _Key_val)) {
+                        return weak_ordering::equivalent;
+                    } else {
+                        return weak_ordering::greater;
+                    }
+                }
+            } else {
+                if (_Position == _End || !_Compare_keys(*_Position._Key_it, _Key_val)) {
+                    if (_Position == _Begin || !_Compare_keys(_Key_val, *(_Position._Key_it - 1))) {
+                        return weak_ordering::equivalent;
+                    } else {
+                        return weak_ordering::greater;
+                    }
+                }
+            }
+            return weak_ordering::less;
+        }();
+
+        const auto _New_position = _Iterator_from_key_iterator(
+            _Hint_order == weak_ordering::equivalent ? _Position._Key_it
+            : _Hint_order == weak_ordering::less
+                ? _STD lower_bound(_Position._Key_it, _Data.keys.cend(), _Key_val, _Pass_key_comp())
+                : _STD upper_bound(_Data.keys.cbegin(), _Position._Key_it, _Key_val, _Pass_key_comp()));
+
+        if constexpr (_IsUnique) {
+            if (_Hint_order == weak_ordering::less) {
+                if (_New_position != _End && !_Compare_keys(_Key_val, *_New_position._Key_it)) {
+                    if constexpr (_OverwriteIfExists) {
+                        *_New_position._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Mapped_args)...);
+                    }
+                    return _New_position;
+                }
+            } else if (_Hint_order == weak_ordering::greater) {
+                if (_New_position != _Begin && !_Compare_keys(*(_New_position._Key_it - 1), _Key_val)) {
+                    const auto _It = _New_position - 1;
+                    if constexpr (_OverwriteIfExists) {
+                        *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Mapped_args)...);
+                    }
+                    return _It;
+                }
+            }
+        }
+
+        const auto _Dist = _New_position - begin();
+        _Emplace_exact(
+            _New_position, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+        return begin() + _Dist;
+    }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+public:
+#else
+private:
+#endif
+    _NODISCARD bool _Is_sorted_maybe_unique() const {
+        return _Is_sorted_maybe_unique(_Data.keys.begin(), _Data.keys.end());
+    }
+
+private:
+    _NODISCARD bool _Is_sorted_maybe_unique(
+        const key_container_type::const_iterator _It, const key_container_type::const_iterator _End) const {
+        if constexpr (_IsUnique) {
+            // sorted-unique
+            auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare_keys(_Lhs, _Rhs); };
+            return _STD adjacent_find(_It, _End, _Negated) == _End;
+        } else {
+            return _STD is_sorted(_It, _End, _Pass_key_comp());
+        }
+    }
+
+    _NODISCARD auto _View_to_mutate() {
+        using _Mutating_iterator = _Pairing_iterator_provider<typename key_container_type::iterator,
+            typename mapped_container_type::iterator, typename mapped_container_type::iterator>::_Iterator;
+        return _RANGES subrange<_Mutating_iterator>{_Mutating_iterator{_Data.keys.begin(), _Data.values.begin()},
+            _Mutating_iterator{_Data.keys.end(), _Data.values.end()}};
+    }
+
+    struct _Value_compare_to_pass {
+        static constexpr bool _Efficiently_copyable = conjunction_v<bool_constant<sizeof(key_compare) <= sizeof(void*)>,
+            is_trivially_copy_constructible<key_compare>, is_trivially_destructible<key_compare>>;
+
+        using _Copy_or_ref = conditional_t<_Efficiently_copyable, key_compare, const key_compare&>;
+
+        _Copy_or_ref _Key_comparator;
+
+        template <class _Pair1, class _Pair2>
+        _NODISCARD bool operator()(const _Pair1& _Lhs, const _Pair2& _Rhs) const {
+            return _Key_comparator(_Lhs.first, _Rhs.first);
+        }
+    };
+
+    _NODISCARD auto _Erase_dupes_if_not_multi_pred() {
+        _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
+        if constexpr (_Equivalence_is_equality<key_compare, key_type>) {
+            return [](const auto& _Lhs, const auto& _Rhs) static { return _Lhs.first == _Rhs.first; };
+        } else {
+            return [this](const auto& _Lhs, const auto& _Rhs) {
+#ifdef __clang__ // TRANSITION, LLVM-81243
+                return !this->_Compare_keys(_Lhs.first, _Rhs.first);
+#else // ^^^ workaround / no workaround vvv
+                return !_Compare_keys(_Lhs.first, _Rhs.first);
+#endif // ^^^ no workaround ^^^
+            };
+        }
+    }
+
+    template <bool _NeedSorting>
+    void _Restore_invariants(const size_type _Old_size) {
+        // No _Clear_guard needed. This is called only by _Insert_range() (which has a _Clear_guard)
+        // and _Establish_invariants() (which is called only by constructors which don't need guards).
+
+        auto _View          = _View_to_mutate();
+        const auto _Begin   = _View.begin();
+        const auto _Old_end = _Begin + static_cast<difference_type>(_Old_size);
+        const auto _End     = _View.end();
+
+        if constexpr (_NeedSorting) {
+            _RANGES sort(_Old_end, _End, _Value_compare_to_pass{_Key_compare});
+        } else {
+            [[maybe_unused]] const auto _Diff = static_cast<key_container_type::difference_type>(_Old_size);
+            _STL_ASSERT(
+                _Is_sorted_maybe_unique(_Data.keys.begin() + _Diff, _Data.keys.end()), _Msg_not_sorted_maybe_unique);
+        }
+
+        _RANGES inplace_merge(_View, _Old_end, _Value_compare_to_pass{_Key_compare});
+
+        if constexpr (_IsUnique) {
+            const auto _New_last = _RANGES unique(_View, _Erase_dupes_if_not_multi_pred()).begin();
+            _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
+            _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
+        }
+
+        _STL_INTERNAL_CHECK(_Is_sorted_maybe_unique());
+    }
+
+    void _Establish_invariants() {
+        if (_Data.keys.empty()) {
+            return;
+        }
+
+        const auto _Begin        = _Data.keys.begin();
+        const auto _End          = _Data.keys.end();
+        const auto _Sorted_until = _STD is_sorted_until(_Begin, _End, _Pass_key_comp()); // O(N) if already sorted.
+        const auto _Sorted_size  = static_cast<size_type>(_Sorted_until - _Begin);
+        _Restore_invariants<true>(_Sorted_size);
+    }
+
+    template <class _OtherKey, class... _MappedArgTypes>
+    void _Emplace_exact(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        _Clear_guard _Guard{this};
+        _Data.keys.emplace(_Position._Key_it, _STD forward<_OtherKey>(_Key_val));
+        _Data.values.emplace(_Position._Mapped_it, _STD forward<_MappedArgTypes>(_Mapped_args)...);
+        _Guard._Target = nullptr;
+    }
+
+    template <bool _NeedSorting, class _InIt, class _Sentinel>
+    void _Insert_range(_InIt _First, const _Sentinel _Last) {
+        _Clear_guard _Guard{this};
+
+        const size_type _Old_size = size();
+
+        // Insert the new elements at the end
+        for (; _First != _Last; ++_First) {
+            value_type _Val = *_First;
+            if constexpr (_Has_guaranteed_push_back<key_container_type>) {
+                _Data.keys.push_back(_STD move(_Val.first));
+            } else {
+                _Data.keys.insert(_Data.keys.end(), _STD move(_Val.first));
+            }
+
+            if constexpr (_Has_guaranteed_push_back<mapped_container_type>) {
+                _Data.values.push_back(_STD move(_Val.second));
+            } else {
+                _Data.values.insert(_Data.values.end(), _STD move(_Val.second));
+            }
+        }
+
+        _Restore_invariants<_NeedSorting>(_Old_size);
+
+        _Guard._Target = nullptr;
+    }
+
+    template <class _KeyTy>
+    _NODISCARD size_type _Erase_key(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        const auto _Equal_pos = _Equal_range(_Key_val);
+        const auto _Count     = static_cast<size_type>(_Equal_pos.second - _Equal_pos.first);
+        erase(_Equal_pos.first, _Equal_pos.second);
+        return _Count;
+    }
+
+    // size_type is always size_t
+    template <class _Key2, class _Mapped2, class _Compare2, class _KeyContainer2, class _MappedContainer2,
+        class _Predicate2>
+    friend size_t erase_if(flat_map<_Key2, _Mapped2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate2);
+    template <class _Key2, class _Mapped2, class _Compare2, class _KeyContainer2, class _MappedContainer2,
+        class _Predicate2>
+    friend size_t erase_if(flat_multimap<_Key2, _Mapped2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate2);
+
+    template <class _Predicate>
+    _NODISCARD size_t _Erase_if(_Predicate _Pred) {
+        _Clear_guard _Guard{this};
+
+        // N5032 [flat.map.erasure]/2 and [flat.multimap.erasure]/2
+        const auto _Proj     = [](const auto& _Element) static { return const_reference{_Element}; };
+        const auto _New_last = _RANGES remove_if(_View_to_mutate(), _Pred, _Proj).begin();
+        const auto _Old_size = size();
+
+        _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
+        _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
+
+        _Guard._Target = nullptr;
+        return _Old_size - size();
+    }
+
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto _Find(this _SelfTy& _Self, const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        const auto _Position =
+            _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
+        if (_Position != _Self._Data.keys.end() && !_Self._Compare_keys(_Key_val, *_Position)) {
+            return _Self._Iterator_from_key_iterator(_Position);
+        } else {
+            return _Self.end();
+        }
+    }
+
+    template <class _KeyTy>
+    _NODISCARD size_type _Count(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            return _Contains(_Key_val);
+        } else {
+            const auto [_First, _Last] =
+                _STD equal_range(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
+            return static_cast<size_type>(_Last - _First);
+        }
+    }
+
+    template <class _KeyTy>
+    _NODISCARD bool _Contains(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        return _STD binary_search(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
+    }
+
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto _Lower_bound(this _SelfTy& _Self, const _KeyTy& _Key_val) {
+        return _Self._Iterator_from_key_iterator(
+            _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp()));
+    }
+
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto _Upper_bound(this _SelfTy& _Self, const _KeyTy& _Key_val) {
+        return _Self._Iterator_from_key_iterator(
+            _STD upper_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp()));
+    }
+
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto _Equal_range(this _SelfTy& _Self, const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            // In a non-multi container, equal_range can have size at most 1
+            const auto _First =
+                _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
+            const bool _Missing = _First == _Self._Data.keys.end() || _Self._Compare_keys(_Key_val, *_First);
+            return pair{_Self._Iterator_from_key_iterator(_First),
+                _Self._Iterator_from_key_iterator(_Missing ? _First : _First + 1)};
+        } else {
+            const auto [_First, _Last] =
+                _STD equal_range(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
+            return pair{_Self._Iterator_from_key_iterator(_First), _Self._Iterator_from_key_iterator(_Last)};
+        }
+    }
+
+    template <class _SelfTy>
+    _NODISCARD conditional_t<is_const_v<_SelfTy>, const_iterator, iterator> _Iterator_from_key_iterator(
+        this _SelfTy& _Self, const key_container_type::const_iterator& _Iter) {
+        const difference_type _Offset = _Iter - _Self._Data.keys.cbegin();
+        return _Self.begin() + _Offset;
+    }
+
+    template <class _Lty, class _Rty>
+    _NODISCARD bool _Compare_keys(const _Lty& _Lhs, const _Rty& _Rhs) const
+        noexcept(noexcept(_DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs))) {
+        _STL_INTERNAL_STATIC_ASSERT(
+            (is_same_v<_Lty, key_type> && is_same_v<_Rty, key_type>) || _Transparent<key_compare>);
+
+        return _DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs);
+    }
+
+    _NODISCARD auto _Pass_key_comp() const noexcept {
+        return _STD _Pass_fn(_Key_compare);
+    }
+
+    containers _Data;
+    _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
+};
+
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class flat_map : public _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer> {
+private:
+    using _Mybase = _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+
+public:
+    using _Mybase::_Mybase;
+    flat_map(const flat_map&) = default;
+    flat_map(flat_map&&)      = default;
+
+    using typename _Mybase::const_iterator;
+    using typename _Mybase::iterator;
+    using typename _Mybase::key_compare;
+    using typename _Mybase::key_type;
+    using typename _Mybase::mapped_type;
+    using typename _Mybase::value_type;
+
+    flat_map& operator=(const flat_map&) = default;
+    flat_map& operator=(flat_map&&)      = default;
+
+    flat_map& operator=(const initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+
+    // [flat.map.access] Access
+    mapped_type& operator[](const key_type& _Key_val)
+        requires is_default_constructible_v<mapped_type>
+    {
+        return try_emplace(_Key_val).first->second;
+    }
+    mapped_type& operator[](key_type&& _Key_val)
+        requires is_default_constructible_v<mapped_type>
+    {
+        return try_emplace(_STD move(_Key_val)).first->second;
+    }
+    template <class _OtherKey>
+    mapped_type& operator[](_OtherKey&& _Key_val)
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_default_constructible_v<mapped_type>
+    {
+        return try_emplace(_STD forward<_OtherKey>(_Key_val)).first->second;
+    }
+
+    _NODISCARD mapped_type& at(const key_type& _Key_val) {
+        return _At(_Key_val);
+    }
+    _NODISCARD const mapped_type& at(const key_type& _Key_val) const {
+        return _At(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD mapped_type& at(const _OtherKey& _Key_val)
+#ifdef __clang__ // TRANSITION, LLVM-198663
+        requires _Transparent<_Compare>
+#else // ^^^ workaround / no workaround vvv
+        requires _Transparent<key_compare>
+#endif // ^^^ no workaround ^^^
+    {
+        return _At(_Key_val);
+    }
+    template <class _OtherKey>
+    _NODISCARD const mapped_type& at(const _OtherKey& _Key_val) const
+#ifdef __clang__ // TRANSITION, LLVM-198663
+        requires _Transparent<_Compare>
+#else // ^^^ workaround / no workaround vvv
+        requires _Transparent<key_compare>
+#endif // ^^^ no workaround ^^^
+    {
+        return _At(_Key_val);
+    }
+
+    // [flat.map.modifiers] Modifiers
+    template <class... _MappedArgTypes>
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
+    pair<iterator, bool> try_emplace(const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        return this->_Try_emplace(_Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class... _MappedArgTypes>
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
+    pair<iterator, bool> try_emplace(key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        return this->_Try_emplace(_STD move(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class _OtherKey, class... _MappedArgTypes>
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_constructible_v<mapped_type, _MappedArgTypes...> && (!is_convertible_v<_OtherKey, const_iterator>)
+              && (!is_convertible_v<_OtherKey, iterator>)
+    pair<iterator, bool> try_emplace(_OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        return this->_Try_emplace(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class... _MappedArgTypes>
+    iterator try_emplace(const const_iterator _Position, const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args)
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
+    {
+        return this->template _Emplace_hint<false>(_Position, _Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class... _MappedArgTypes>
+    iterator try_emplace(const const_iterator _Position, key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args)
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
+    {
+        return this->template _Emplace_hint<false>(
+            _Position, _STD move(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class _OtherKey, class... _MappedArgTypes>
+    iterator try_emplace(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args)
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_constructible_v<mapped_type, _MappedArgTypes...>
+    {
+        return this->template _Emplace_hint<false>(
+            _Position, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class _OtherMapped>
+    pair<iterator, bool> insert_or_assign(const key_type& _Key_val, _OtherMapped&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
+    {
+        return _Insert_or_assign(_Key_val, _STD forward<_OtherMapped>(_Mapped_val));
+    }
+
+    template <class _OtherMapped>
+    pair<iterator, bool> insert_or_assign(key_type&& _Key_val, _OtherMapped&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
+    {
+        return _Insert_or_assign(_STD move(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
+    }
+
+    template <class _OtherKey, class _OtherMapped>
+    pair<iterator, bool> insert_or_assign(_OtherKey&& _Key_val, _OtherMapped&& _Mapped_val)
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
+    {
+        return _Insert_or_assign(_STD forward<_OtherKey>(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
+    }
+
+    template <class _OtherMapped>
+    iterator insert_or_assign(const const_iterator _Position, const key_type& _Key_val, _OtherMapped&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
+    {
+        return this->template _Emplace_hint<true>(_Position, _Key_val, _STD forward<_OtherMapped>(_Mapped_val));
+    }
+
+    template <class _OtherMapped>
+    iterator insert_or_assign(const const_iterator _Position, key_type&& _Key_val, _OtherMapped&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
+    {
+        return this->template _Emplace_hint<true>(
+            _Position, _STD move(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
+    }
+
+    template <class _OtherKey, class _OtherMapped>
+    iterator insert_or_assign(const const_iterator _Position, _OtherKey&& _Key_val, _OtherMapped&& _Mapped_val)
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
+    {
+        return this->template _Emplace_hint<true>(
+            _Position, _STD forward<_OtherKey>(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
+    }
+
+private:
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto& _At(this _SelfTy& _Self, const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        const auto _Position = _Self.find(_Key_val);
+        if (_Position == _Self.end()) {
+            _Xout_of_range("invalid flat_map key");
+        }
+
+        return _Position->second;
+    }
+
+    template <class _KeyTy, class _OtherMapped>
+    _NODISCARD pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _OtherMapped&& _Mapped_val) {
+        auto _Res = this->_Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
+        if (!_Res.second) { // Already exists
+            _Res.first->second = _STD forward<_OtherMapped>(_Mapped_val);
+        }
+        return _Res;
+    }
+};
+
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class flat_multimap : public _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer> {
+private:
+    using _Mybase = _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+
+public:
+    using typename _Mybase::value_type;
+
+    using _Mybase::_Mybase;
+    flat_multimap(const flat_multimap&) = default;
+    flat_multimap(flat_multimap&&)      = default;
+
+    flat_multimap& operator=(const flat_multimap&) = default;
+    flat_multimap& operator=(flat_multimap&&)      = default;
+
+    flat_multimap& operator=(const initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+};
+
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    class _Predicate>
+size_t erase_if(flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
+}
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    class _Predicate>
+size_t erase_if(flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
+}
+
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Alloc>
+struct uses_allocator<flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Alloc>
+    : bool_constant<uses_allocator_v<_KeyContainer, _Alloc> && uses_allocator_v<_MappedContainer, _Alloc>> {};
+
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Alloc>
+struct uses_allocator<flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Alloc>
+    : bool_constant<uses_allocator_v<_KeyContainer, _Alloc> && uses_allocator_v<_MappedContainer, _Alloc>> {};
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
+flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(_KeyContainer, _MappedContainer, _Alloc) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare, _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(_KeyContainer, _MappedContainer, _Compare, _Alloc) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Alloc) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare, _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Alloc)
+    -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Alloc)
+    -> flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+#endif // ^^^ workaround ^^^
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<_Guide_key_t<_InIt>>>
+flat_map(_InIt, _InIt, _Compare = _Compare()) -> flat_map<_Guide_key_t<_InIt>, _Guide_val_t<_InIt>, _Compare>;
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<_Guide_key_t<_InIt>>>
+flat_map(sorted_unique_t, _InIt, _InIt, _Compare = _Compare())
+    -> flat_map<_Guide_key_t<_InIt>, _Guide_val_t<_InIt>, _Compare>;
+
+#ifdef __cpp_lib_byte
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>,
+    class _Alloc = allocator<byte>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Alloc = _Alloc()) -> flat_map<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
+#else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>>
+flat_map(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
+
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, class _Alloc,
+    enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_map(from_range_t, _Rng&&, _Compare, _Alloc) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
+#endif // ^^^ !defined(__cpp_lib_byte) ^^^
+
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_map(from_range_t, _Rng&&, _Alloc) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
+
+template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
+flat_map(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_map<_Key, _Mapped, _Compare>;
+
+template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
+flat_map(sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
+    -> flat_map<_Key, _Mapped, _Compare>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
+flat_multimap(_KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(_KeyContainer, _MappedContainer, _Alloc) -> flat_multimap<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare, _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(_KeyContainer, _MappedContainer, _Compare, _Alloc) -> flat_multimap<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Alloc)
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+        less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare, _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Alloc)
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Alloc)
+    -> flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+#endif // ^^^ workaround ^^^
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<_Guide_key_t<_InIt>>>
+flat_multimap(_InIt, _InIt, _Compare = _Compare()) -> flat_multimap<_Guide_key_t<_InIt>, _Guide_val_t<_InIt>, _Compare>;
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<_Guide_key_t<_InIt>>>
+flat_multimap(sorted_equivalent_t, _InIt, _InIt, _Compare = _Compare())
+    -> flat_multimap<_Guide_key_t<_InIt>, _Guide_val_t<_InIt>, _Compare>;
+
+#ifdef __cpp_lib_byte
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>,
+    class _Alloc = allocator<byte>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Alloc = _Alloc()) -> flat_multimap<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
+#else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>>
+flat_multimap(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
+
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, class _Alloc,
+    enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multimap(from_range_t, _Rng&&, _Compare, _Alloc) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
+#endif // ^^^ !defined(__cpp_lib_byte) ^^^
+
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multimap(from_range_t, _Rng&&, _Alloc) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
+
+template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
+flat_multimap(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_multimap<_Key, _Mapped, _Compare>;
+
+template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
+flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
+    -> flat_multimap<_Key, _Mapped, _Compare>;
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX23 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FLAT_MAP_
diff --git a/msvc-stl/stl/inc/flat_set b/msvc-stl/stl/inc/flat_set
new file mode 100644
index 0000000..52494d3
--- /dev/null
+++ b/msvc-stl/stl/inc/flat_set
@@ -0,0 +1,993 @@
+// flat_set standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _FLAT_SET_
+#define _FLAT_SET_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <flat_set> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+#include <algorithm>
+#include <compare>
+#include <initializer_list>
+#include <vector>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#undef msvc
+
+_STD_BEGIN
+template <bool _IsNoexcept, class _Container>
+struct _NODISCARD _Flat_set_swap_clear_guard {
+    // Invariant: (_Target1 == nullptr) == (_Target2 == nullptr)
+    _Container* _Target1;
+    _Container* _Target2;
+
+    _Flat_set_swap_clear_guard& operator=(const _Flat_set_swap_clear_guard&) = delete;
+
+    void _Dismiss() noexcept {
+        _Target1 = nullptr;
+        _Target2 = nullptr;
+    }
+
+    ~_Flat_set_swap_clear_guard() {
+        if (_Target1) {
+            _Target1->clear();
+            _Target2->clear();
+        }
+    }
+};
+template <class _Container>
+struct _NODISCARD _Flat_set_swap_clear_guard<true, _Container> {
+    constexpr explicit _Flat_set_swap_clear_guard(_Container*, _Container*) noexcept {}
+
+    _Flat_set_swap_clear_guard& operator=(const _Flat_set_swap_clear_guard&) = delete;
+
+    void _Dismiss() noexcept {}
+};
+
+_EXPORT_STD template <class _Key, class _Compare = less<_Key>, class _Container = vector<_Key>>
+class flat_set;
+
+_EXPORT_STD template <class _Key, class _Compare = less<_Key>, class _Container = vector<_Key>>
+class flat_multiset;
+
+template <bool _IsUnique, class _Key, class _Compare, class _Container>
+class _Flat_set_base {
+private:
+    using _Sorted_t = conditional_t<_IsUnique, sorted_unique_t, sorted_equivalent_t>;
+    using _Derived =
+        conditional_t<_IsUnique, flat_set<_Key, _Compare, _Container>, flat_multiset<_Key, _Compare, _Container>>;
+
+    static constexpr const char* _Msg_not_sorted_maybe_unique =
+        _IsUnique ? "Input was not sorted-unique! (N5032 [flat.set.overview]/9)"
+                  : "Input was not sorted! (N5032 [flat.multiset.overview]/9)";
+    static constexpr const char* _Msg_replace_not_sorted_maybe_unique =
+        _IsUnique ? "Input was not sorted-unique! (N5032 [flat.set.modifiers]/18)"
+                  : "Input was not sorted! (N5032 [flat.multiset.modifiers]/17)";
+    static constexpr const char* _Msg_heterogeneous_insertion_inconsistent_with_lookup =
+        "The conversion from the heterogeneous key to key_type should be consistent with the heterogeneous lookup!";
+
+public:
+    // [flat.set.defn] Types
+    using key_type               = _Key;
+    using value_type             = _Key;
+    using key_compare            = _Compare;
+    using value_compare          = _Compare;
+    using reference              = value_type&;
+    using const_reference        = const value_type&;
+    using size_type              = _Container::size_type;
+    using difference_type        = _Container::difference_type;
+    using const_iterator         = _Container::const_iterator;
+    using iterator               = const_iterator;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+    using reverse_iterator       = const_reverse_iterator;
+    using container_type         = _Container;
+
+    static_assert(same_as<key_type, typename container_type::value_type>,
+        "key_type and container_type::value_type must be the same. "
+        "(N5032 [flat.set.overview]/8, [flat.multiset.overview]/8)");
+    static_assert(!_Is_vector_bool<container_type>,
+        "vector<bool> cannot be adapted because it is not a sequence container. "
+        "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
+    static_assert(random_access_iterator<typename container_type::const_iterator>,
+        "Sequence containers must support random-access iterators in order to be adapted. "
+        "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
+
+    // [flat.set.cons] Constructors
+    _Flat_set_base() : _Data(), _Key_compare() {}
+
+    _Flat_set_base(const _Flat_set_base&) = default;
+
+    _Flat_set_base(_Flat_set_base&& _Other) noexcept(
+        is_nothrow_move_constructible_v<container_type> && is_nothrow_copy_constructible_v<key_compare>) // strengthened
+        : _Data(_STD move(_Other).extract()),
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
+    {}
+
+    explicit _Flat_set_base(const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {}
+
+    explicit _Flat_set_base(container_type _Cont, const key_compare& _Comp = key_compare())
+        : _Data(_STD move(_Cont)), _Key_compare(_Comp) {
+        _Establish_invariants();
+    }
+
+    _Flat_set_base(_Sorted_t, container_type _Cont, const key_compare& _Comp = key_compare())
+        : _Data(_STD move(_Cont)), _Key_compare(_Comp) {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Iterator_for_container _InIt>
+    _Flat_set_base(const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
+        : _Data(_First, _Last), _Key_compare(_Comp) {
+        _Establish_invariants();
+    }
+
+    template <_Iterator_for_container _InIt>
+    _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
+        : _Data(_First, _Last), _Key_compare(_Comp) {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_set_base(from_range_t, _Rng&& _Range) : _Data(from_range, _STD forward<_Rng>(_Range)), _Key_compare() {
+        _Establish_invariants();
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp)
+        : _Data(from_range, _STD forward<_Rng>(_Range)), _Key_compare(_Comp) {
+        _Establish_invariants();
+    }
+
+    _Flat_set_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Data(_Ilist.begin(), _Ilist.end()), _Key_compare(_Comp) {
+        _Establish_invariants();
+    }
+
+    _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Data(_Ilist.begin(), _Ilist.end()), _Key_compare(_Comp) {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    // [flat.set.cons.alloc] Constructors with allocators
+    template <_Usable_allocator_for<container_type> _Alloc>
+    explicit _Flat_set_base(const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al)), _Key_compare() {}
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al)), _Key_compare(_Comp) {}
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const container_type& _Cont, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare() {
+        _Establish_invariants();
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare(_Comp) {
+        _Establish_invariants();
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const container_type& _Cont, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare() {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare(_Comp) {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const _Flat_set_base& _Other, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Other._Data)), _Key_compare(_Other._Key_compare) {}
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Flat_set_base&& _Other, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Other).extract())),
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
+    {}
+
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const _InIt _First, const _InIt _Last, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare() {
+        _Establish_invariants();
+    }
+
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare(_Comp) {
+        _Establish_invariants();
+    }
+
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare() {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare(_Comp) {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Container_compatible_range<value_type> _Rng, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))),
+          _Key_compare() {
+        _Establish_invariants();
+    }
+
+    template <_Container_compatible_range<value_type> _Rng, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))),
+          _Key_compare(_Comp) {
+        _Establish_invariants();
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const initializer_list<value_type> _Ilist, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare() {
+        _Establish_invariants();
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare(_Comp) {
+        _Establish_invariants();
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare() {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare(_Comp) {
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
+    }
+
+    // Assignment operators
+    _Flat_set_base& operator=(const _Flat_set_base& _Other) {
+        _Clear_guard _Guard{this};
+        _Data          = _Other._Data;
+        _Key_compare   = _Other._Key_compare;
+        _Guard._Target = nullptr;
+        return *this;
+    }
+
+    _Flat_set_base& operator=(_Flat_set_base&& _Other) noexcept(
+        is_nothrow_move_assignable_v<container_type> && is_nothrow_copy_assignable_v<key_compare>) /* strengthened */ {
+        if (this != _STD addressof(_Other)) {
+            _Clear_guard _Guard{this};
+            _Clear_guard _Always_clear{_STD addressof(_Other)};
+            _Data          = _STD move(_Other._Data);
+            _Key_compare   = _Other._Key_compare; // intentionally copy comparator, see LWG-2227
+            _Guard._Target = nullptr;
+        }
+        return *this;
+    }
+
+    // Iterators
+    // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
+    _NODISCARD const_iterator begin() const noexcept {
+        return _Data.begin();
+    }
+    _NODISCARD const_iterator end() const noexcept {
+        return _Data.end();
+    }
+
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator{_Data.end()};
+    }
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator{_Data.begin()};
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return _Data.begin();
+    }
+    _NODISCARD const_iterator cend() const noexcept {
+        return _Data.end();
+    }
+
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return const_reverse_iterator{_Data.end()};
+    }
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return const_reverse_iterator{_Data.begin()};
+    }
+
+    // Capacity
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Data.empty();
+    }
+    _NODISCARD size_type size() const noexcept {
+        return _Data.size();
+    }
+    _NODISCARD size_type max_size() const noexcept {
+        return _Data.max_size();
+    }
+
+    // [flat.set.modifiers] Modifiers
+    template <class... _ArgTypes>
+    auto emplace(_ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
+    {
+        constexpr bool _Is_key_type = _In_place_key_extract_set<key_type, _ArgTypes...>::_Extractable;
+        if constexpr (_Is_key_type) {
+            return _Emplace(_STD forward<_ArgTypes>(_Args)...);
+        } else {
+            return _Emplace(key_type(_STD forward<_ArgTypes>(_Args)...));
+        }
+    }
+
+    template <class... _ArgTypes>
+    iterator emplace_hint(const const_iterator _Position, _ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
+    {
+        constexpr bool _Is_key_type = _In_place_key_extract_set<key_type, _ArgTypes...>::_Extractable;
+        if constexpr (_Is_key_type) {
+            return _Emplace_hint(_Position, _STD forward<_ArgTypes>(_Args)...);
+        } else {
+            return _Emplace_hint(_Position, key_type(_STD forward<_ArgTypes>(_Args)...));
+        }
+    }
+
+    auto insert(const value_type& _Val) {
+        return _Emplace(_Val);
+    }
+    auto insert(value_type&& _Val) {
+        return _Emplace(_STD move(_Val));
+    }
+    template <_Different_from<value_type> _Other>
+        requires _IsUnique && _Transparent<key_compare> && is_constructible_v<value_type, _Other>
+    auto insert(_Other&& _Val) {
+        return _Emplace(_STD forward<_Other>(_Val));
+    }
+
+    iterator insert(const const_iterator _Position, const value_type& _Val) {
+        return _Emplace_hint(_Position, _Val);
+    }
+    iterator insert(const const_iterator _Position, value_type&& _Val) {
+        return _Emplace_hint(_Position, _STD move(_Val));
+    }
+    template <_Different_from<value_type> _Other>
+        requires _IsUnique && _Transparent<key_compare> && is_constructible_v<value_type, _Other>
+    iterator insert(const const_iterator _Position, _Other&& _Val) {
+        return _Emplace_hint(_Position, _STD forward<_Other>(_Val));
+    }
+
+    template <_Iterator_for_container _InIt>
+    void insert(const _InIt _First, const _InIt _Last) {
+        _Insert_range<true>(_First, _Last);
+    }
+    template <_Iterator_for_container _InIt>
+    void insert(_Sorted_t, const _InIt _First, const _InIt _Last) {
+        _Insert_range<false>(_First, _Last);
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
+        _Insert_range<true>(_STD forward<_Rng>(_Range));
+    }
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Sorted_t, _Rng&& _Range) {
+        _Insert_range<false>(_STD forward<_Rng>(_Range));
+    }
+
+    void insert(const initializer_list<value_type> _Ilist) {
+        _Insert_range<true>(_Ilist.begin(), _Ilist.end());
+    }
+    void insert(_Sorted_t, const initializer_list<value_type> _Ilist) {
+        _Insert_range<false>(_Ilist.begin(), _Ilist.end());
+    }
+
+    _NODISCARD container_type extract() && noexcept(
+        is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
+        // always clears the container (N5032 [flat.set.modifiers]/16 and [flat.multiset.modifiers]/15)
+        _Clear_guard _Always_clear{this};
+        return _STD move(_Data);
+    }
+
+    void replace(container_type&& _Cont) {
+        _STL_ASSERT(_Is_sorted_maybe_unique(_Cont.begin(), _Cont.end()), _Msg_replace_not_sorted_maybe_unique);
+        _Clear_guard _Guard{this};
+        _Data          = _STD move(_Cont);
+        _Guard._Target = nullptr;
+    }
+
+    // NB: `erase(iterator)` is identical to `erase(const_iterator)`
+    iterator erase(const const_iterator _Position) {
+        _Clear_guard _Guard{this};
+        const auto _Ret = _Data.erase(_Position);
+        _Guard._Target  = nullptr;
+        return _Ret;
+    }
+
+    size_type erase(const key_type& _Val) {
+        return _Erase_key(_Val);
+    }
+    template <_Different_from<key_type> _Other>
+        requires _Transparent<key_compare> && (!is_convertible_v<_Other, const_iterator>)
+    size_type erase(_Other&& _Val) {
+        return _Erase_key(_Val);
+    }
+
+    iterator erase(const const_iterator _First, const const_iterator _Last) {
+        _Clear_guard _Guard{this};
+        const auto _Ret = _Data.erase(_First, _Last);
+        _Guard._Target  = nullptr;
+        return _Ret;
+    }
+
+    void swap(_Derived& _Other)
+        noexcept(is_nothrow_swappable_v<container_type> && is_nothrow_swappable_v<key_compare>) {
+        constexpr bool _Is_noexcept = is_nothrow_swappable_v<container_type> && is_nothrow_swappable_v<key_compare>;
+        _Flat_set_swap_clear_guard<_Is_noexcept, container_type> _Guard{
+            _STD addressof(_Data), _STD addressof(_Other._Data)};
+        _RANGES swap(_Data, _Other._Data);
+        _RANGES swap(_Key_compare, _Other._Key_compare);
+        _Guard._Dismiss();
+    }
+
+    void clear() noexcept {
+        _Data.clear();
+    }
+
+    // Observers
+    _NODISCARD key_compare key_comp() const {
+        return _Key_compare;
+    }
+    _NODISCARD value_compare value_comp() const {
+        return _Key_compare;
+    }
+
+    // Set operations
+    // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
+    _NODISCARD const_iterator find(const key_type& _Val) const {
+        return _Find(_Val);
+    }
+    template <class _Other>
+        requires _Transparent<key_compare>
+    _NODISCARD const_iterator find(const _Other& _Val) const {
+        return _Find(_Val);
+    }
+
+    _NODISCARD size_type count(const key_type& _Val) const {
+        return _Count(_Val);
+    }
+    template <class _Other>
+        requires _Transparent<key_compare>
+    _NODISCARD size_type count(const _Other& _Val) const {
+        return _Count(_Val);
+    }
+
+    _NODISCARD bool contains(const key_type& _Val) const {
+        return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
+    }
+    template <class _Other>
+        requires _Transparent<key_compare>
+    _NODISCARD bool contains(const _Other& _Val) const {
+        return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
+    }
+
+    _NODISCARD const_iterator lower_bound(const key_type& _Val) const {
+        return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
+    }
+    template <class _Other>
+        requires _Transparent<key_compare>
+    _NODISCARD const_iterator lower_bound(const _Other& _Val) const {
+        return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
+    }
+
+    _NODISCARD const_iterator upper_bound(const key_type& _Val) const {
+        return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
+    }
+    template <class _Other>
+        requires _Transparent<key_compare>
+    _NODISCARD const_iterator upper_bound(const _Other& _Val) const {
+        return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
+    }
+
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Val) const {
+        return _Equal_range(_Val);
+    }
+    template <class _Other>
+        requires _Transparent<key_compare>
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Val) const {
+        return _Equal_range(_Val);
+    }
+
+    _NODISCARD friend bool operator==(const _Derived& _Lhs, const _Derived& _Rhs) {
+        return _STD equal(_Lhs._Data.begin(), _Lhs._Data.end(), _Rhs._Data.begin(), _Rhs._Data.end());
+    }
+
+    _NODISCARD friend auto operator<=>(const _Derived& _Lhs, const _Derived& _Rhs) {
+        return _STD lexicographical_compare_three_way(
+            _Lhs._Data.begin(), _Lhs._Data.end(), _Rhs._Data.begin(), _Rhs._Data.end(), _Synth_three_way{});
+    }
+
+    friend void swap(_Derived& _Lhs, _Derived& _Rhs) noexcept(noexcept(_Lhs.swap(_Rhs))) {
+        _Lhs.swap(_Rhs);
+    }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+public:
+#else
+private:
+#endif
+    _NODISCARD bool _Is_sorted_maybe_unique() const {
+        return _Is_sorted_maybe_unique(_Data.begin(), _Data.end());
+    }
+
+private:
+    _NODISCARD bool _Is_sorted_maybe_unique(const const_iterator _It, const const_iterator _End) const {
+        if constexpr (_IsUnique) {
+            // sorted-unique
+            auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare_keys(_Lhs, _Rhs); };
+            return _STD adjacent_find(_It, _End, _Negated) == _End;
+        } else {
+            return _STD is_sorted(_It, _End, _Pass_comp());
+        }
+    }
+
+    _NODISCARD auto _Erase_dupes_if_not_multi_pred() {
+        _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
+        if constexpr (_Equivalence_is_equality<key_compare, key_type>) {
+            return equal_to<>{};
+        } else {
+            return [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare_keys(_Lhs, _Rhs); };
+        }
+    }
+
+    template <bool _NeedSorting>
+    void _Restore_invariants(const size_type _Old_size) {
+        // No _Clear_guard needed. This is called only by _Insert_range() (which has a _Clear_guard)
+        // and _Establish_invariants() (which is called only by constructors which don't need guards).
+
+        const auto _Begin   = _Data.begin();
+        const auto _Old_end = _Begin + static_cast<difference_type>(_Old_size);
+        const auto _End     = _Data.end();
+
+        if constexpr (_NeedSorting) {
+            _STD sort(_Old_end, _End, _Pass_comp());
+        } else {
+            _STL_ASSERT(_Is_sorted_maybe_unique(_Old_end, _End), _Msg_not_sorted_maybe_unique);
+        }
+
+        _STD inplace_merge(_Begin, _Old_end, _End, _Pass_comp());
+
+        if constexpr (_IsUnique) {
+            _Data.erase(_STD unique(_Begin, _End, _Erase_dupes_if_not_multi_pred()), _End);
+        }
+
+        _STL_INTERNAL_CHECK(_Is_sorted_maybe_unique());
+    }
+
+    void _Establish_invariants() {
+        if (_Data.empty()) {
+            return;
+        }
+
+        const auto _Begin        = _Data.begin();
+        const auto _End          = _Data.end();
+        const auto _Sorted_until = _STD is_sorted_until(_Begin, _End, _Pass_comp()); // O(N) if already sorted.
+        const auto _Sorted_size  = static_cast<size_type>(_Sorted_until - _Begin);
+        _Restore_invariants<true>(_Sorted_size);
+    }
+
+    template <class _Ty>
+    _NODISCARD bool _Can_insert(const const_iterator _Where, const _Ty& _Val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty, key_type>); // only accepts key_type
+
+        // check that _Val can be inserted before _Where
+        if constexpr (_IsUnique) {
+            // check that _Where is the lower_bound for _Val, and *_Where is not equivalent to _Val
+            // equivalent to checking *(_Where-1) < _Val < *_Where
+            return (_Where == cend() || _Compare_keys(_Val, *_Where))
+                && (_Where == cbegin() || _Compare_keys(*(_Where - 1), _Val));
+        } else {
+            // check that _Where is the upper_bound for _Val
+            // equivalent to checking *(_Where-1) <= _Val < *_Where
+            return (_Where == cend() || _Compare_keys(_Val, *_Where))
+                && (_Where == cbegin() || !_Compare_keys(_Val, *(_Where - 1)));
+        }
+    }
+
+    template <class _Ty>
+    _NODISCARD iterator _Emplace_with_clear_guard(const const_iterator _Where, _Ty&& _Val) {
+        if constexpr (_Has_guaranteed_single_insertion<container_type>) {
+            return _Data.emplace(_Where, _STD forward<_Ty>(_Val));
+        } else {
+            _Clear_guard _Guard{this};
+            auto _Iter     = _Data.emplace(_Where, _STD forward<_Ty>(_Val));
+            _Guard._Target = nullptr;
+            return _Iter;
+        }
+    }
+
+    template <class _Ty>
+    _NODISCARD conditional_t<_IsUnique, pair<iterator, bool>, iterator> _Emplace(_Ty&& _Val) {
+        if constexpr (_IsUnique) {
+            const const_iterator _Where = lower_bound(_Val);
+            if (_Where != cend() && !_Compare_keys(_Val, *_Where)) {
+                return pair{_Where, false};
+            }
+
+            if constexpr (is_same_v<remove_cvref_t<_Ty>, key_type>) {
+                _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
+                return pair{_Emplace_with_clear_guard(_Where, _STD forward<_Ty>(_Val)), true};
+            } else {
+                // heterogeneous insertion
+                _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<key_type, _Ty>);
+                key_type _Keyval(_STD forward<_Ty>(_Val));
+                _STL_ASSERT(_Can_insert(_Where, _Keyval), _Msg_heterogeneous_insertion_inconsistent_with_lookup);
+                return pair{_Emplace_with_clear_guard(_Where, _STD move(_Keyval)), true};
+            }
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, key_type>);
+            return _Emplace_with_clear_guard(upper_bound(_Val), _STD forward<_Ty>(_Val));
+        }
+    }
+
+    template <class _Ty>
+    _NODISCARD iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
+        const const_iterator _Begin = cbegin();
+        const const_iterator _End   = cend();
+
+        if constexpr (_IsUnique) {
+            // look for lower_bound(_Val)
+            if (_Where == _End || !_Compare_keys(*_Where, _Val)) {
+                // _Val <= *_Where
+                if (_Where == _Begin || _Compare_keys(*(_Where - 1), _Val)) {
+                    // _Val > *(_Where-1) ~ lower_bound is _Where
+                } else {
+                    // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
+                    _Where = _STD lower_bound(_Begin, _Where - 1, _Val, _Pass_comp());
+                }
+            } else {
+                // _Val > *_Where ~ lower_bound is in [_Where+1,_End]
+                _Where = _STD lower_bound(_Where + 1, _End, _Val, _Pass_comp());
+            }
+
+            if (_Where != _End && !_Compare_keys(_Val, *_Where)) {
+                return _Where;
+            }
+
+            if constexpr (is_same_v<remove_cvref_t<_Ty>, key_type>) {
+                _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
+                return _Emplace_with_clear_guard(_Where, _STD forward<_Ty>(_Val));
+            } else {
+                // heterogeneous insertion
+                _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<key_type, _Ty>);
+                key_type _Keyval(_STD forward<_Ty>(_Val));
+                _STL_ASSERT(_Can_insert(_Where, _Keyval), _Msg_heterogeneous_insertion_inconsistent_with_lookup);
+                return _Emplace_with_clear_guard(_Where, _STD move(_Keyval));
+            }
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, key_type>);
+
+            // look for closest position just prior to _Where, respecting ordering
+            if (_Where == _End || _Compare_keys(_Val, *_Where)) {
+                // _Val < *_Where
+                if (_Where == _Begin || !_Compare_keys(_Val, *(_Where - 1))) {
+                    // _Val >= *(_Where-1) ~ closest valid position is _Where
+                } else {
+                    // _Val < *(_Where-1) ~ closest valid position is upper_bound(_Val) located in [_Begin,_Where-1]
+                    _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Pass_comp());
+                }
+                // _Val < *_Where, so upper_bound is indeed "as close as possible"
+                _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
+            } else {
+                // _Val >= *_Where ~ search for lower_bound in [_Where,_End] to place _Val "as close as possible"
+                _Where = _STD lower_bound(_Where, _End, _Val, _Pass_comp());
+            }
+
+            return _Emplace_with_clear_guard(_Where, _STD forward<_Ty>(_Val));
+        }
+    }
+
+    template <bool _NeedSorting, class _InIt>
+    void _Insert_range(const _InIt _First, const _InIt _Last) {
+        _Clear_guard _Guard{this};
+        const size_type _Old_size = size();
+        _Data.insert(_Data.end(), _First, _Last);
+        _Restore_invariants<_NeedSorting>(_Old_size);
+        _Guard._Target = nullptr;
+    }
+
+    template <bool _NeedSorting, _Container_compatible_range<value_type> _Rng>
+    void _Insert_range(_Rng&& _Range) {
+        _Clear_guard _Guard{this};
+        const size_type _Old_size = size();
+        if constexpr (_Has_guaranteed_append_range<container_type>) {
+            _Data.append_range(_STD forward<_Rng>(_Range));
+        } else {
+            _Data.insert_range(_Data.end(), _STD forward<_Rng>(_Range));
+        }
+        _Restore_invariants<_NeedSorting>(_Old_size);
+        _Guard._Target = nullptr;
+    }
+
+    template <class _KeyTy>
+    _NODISCARD size_type _Erase_key(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            const const_iterator _Where = lower_bound(_Key_val);
+            if (_Where != cend() && !_Compare_keys(_Key_val, *_Where)) {
+                _Clear_guard _Guard{this};
+                _Data.erase(_Where);
+                _Guard._Target = nullptr;
+                return 1;
+            }
+            return 0;
+        } else {
+            const auto [_First, _Last] = equal_range(_Key_val);
+
+            const auto _Removed = static_cast<size_type>(_Last - _First);
+            _Clear_guard _Guard{this};
+            _Data.erase(_First, _Last);
+            _Guard._Target = nullptr;
+            return _Removed;
+        }
+    }
+
+    // typename is a workaround for VSO-2680018 (EDG)
+    template <class _Key2, class _Compare2, class _Container2, class _Predicate2>
+    friend typename _Container2::size_type erase_if(flat_set<_Key2, _Compare2, _Container2>&, _Predicate2);
+    template <class _Key2, class _Compare2, class _Container2, class _Predicate2>
+    friend typename _Container2::size_type erase_if(flat_multiset<_Key2, _Compare2, _Container2>&, _Predicate2);
+
+    template <class _Predicate>
+    _NODISCARD size_type _Erase_if(_Predicate _Pred) {
+        // Maintain invariants when an exception is thrown (N5032 [flat.set.erasure]/5, [flat.multiset.erasure]/5)
+        _Clear_guard _Guard{this};
+        const auto _Erased_count = _STD _Erase_remove_if(_Data, _Pred);
+        _Guard._Target           = nullptr;
+        return _Erased_count;
+    }
+
+    template <class _KeyTy>
+    _NODISCARD const_iterator _Find(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+
+        const const_iterator _End   = cend();
+        const const_iterator _Where = lower_bound(_Key_val);
+        if (_Where != _End && !_Compare_keys(_Key_val, *_Where)) {
+            return _Where;
+        } else {
+            return _End;
+        }
+    }
+
+    template <class _KeyTy>
+    _NODISCARD size_type _Count(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            return contains(_Key_val);
+        } else {
+            const auto [_First, _Last] = _Equal_range(_Key_val);
+            return static_cast<size_type>(_Last - _First);
+        }
+    }
+
+    template <class _KeyTy>
+    _NODISCARD pair<const_iterator, const_iterator> _Equal_range(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            // In a non-multi container, equal_range can have size at most 1
+            const auto _First   = _STD lower_bound(_Data.begin(), _Data.end(), _Key_val, _Pass_comp());
+            const bool _Missing = _First == _Data.end() || _Compare_keys(_Key_val, *_First);
+            return pair{_First, _Missing ? _First : _First + 1};
+        } else {
+            return _STD equal_range(begin(), end(), _Key_val, _Pass_comp());
+        }
+    }
+
+    template <class _Lty, class _Rty>
+    _NODISCARD bool _Compare_keys(const _Lty& _Lhs, const _Rty& _Rhs) const
+        noexcept(noexcept(_DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs))) {
+        _STL_INTERNAL_STATIC_ASSERT(
+            (is_same_v<_Lty, key_type> && is_same_v<_Rty, key_type>) || _Transparent<key_compare>);
+
+        return _DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs);
+    }
+
+    _NODISCARD auto _Pass_comp() const noexcept {
+        return _STD _Pass_fn(_Key_compare);
+    }
+
+    container_type _Data;
+    _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
+};
+
+_EXPORT_STD template <class _Key, class _Compare, class _Container>
+class flat_set : public _Flat_set_base<true, _Key, _Compare, _Container> {
+private:
+    using _Mybase = _Flat_set_base<true, _Key, _Compare, _Container>;
+
+public:
+    using _Mybase::_Mybase;
+    flat_set(const flat_set&) = default;
+    flat_set(flat_set&&)      = default;
+
+    flat_set& operator=(const flat_set&) = default;
+    flat_set& operator=(flat_set&&)      = default;
+
+    flat_set& operator=(const initializer_list<_Key> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+};
+
+_EXPORT_STD template <class _Key, class _Compare, class _Container>
+class flat_multiset : public _Flat_set_base<false, _Key, _Compare, _Container> {
+private:
+    using _Mybase = _Flat_set_base<false, _Key, _Compare, _Container>;
+
+public:
+    using _Mybase::_Mybase;
+    flat_multiset(const flat_multiset&) = default;
+    flat_multiset(flat_multiset&&)      = default;
+
+    flat_multiset& operator=(const flat_multiset&) = default;
+    flat_multiset& operator=(flat_multiset&&)      = default;
+
+    flat_multiset& operator=(const initializer_list<_Key> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+};
+
+_EXPORT_STD template <class _Key, class _Compare, class _Container, class _Predicate>
+_Container::size_type erase_if(flat_set<_Key, _Compare, _Container>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
+}
+_EXPORT_STD template <class _Key, class _Compare, class _Container, class _Predicate>
+_Container::size_type erase_if(flat_multiset<_Key, _Compare, _Container>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
+}
+
+template <class _Key, class _Compare, class _Container, class _Alloc>
+struct uses_allocator<flat_set<_Key, _Compare, _Container>, _Alloc>
+    : bool_constant<uses_allocator_v<_Container, _Alloc>> {};
+
+template <class _Key, class _Compare, class _Container, class _Alloc>
+struct uses_allocator<flat_multiset<_Key, _Compare, _Container>, _Alloc>
+    : bool_constant<uses_allocator_v<_Container, _Alloc>> {};
+
+template <_Not_allocator_for_container _Container,
+    _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
+flat_set(_Container, _Compare = _Compare()) -> flat_set<typename _Container::value_type, _Compare, _Container>;
+template <_Not_allocator_for_container _Container, _Usable_allocator_for<_Container> _Alloc>
+flat_set(_Container, _Alloc)
+    -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+template <_Not_allocator_for_container _Container, _Valid_compare_for_container<_Container> _Compare,
+    _Usable_allocator_for<_Container> _Alloc>
+flat_set(_Container, _Compare, _Alloc) -> flat_set<typename _Container::value_type, _Compare, _Container>;
+
+template <_Not_allocator_for_container _Container,
+    _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
+flat_set(sorted_unique_t, _Container, _Compare = _Compare())
+    -> flat_set<typename _Container::value_type, _Compare, _Container>;
+template <_Not_allocator_for_container _Container, _Usable_allocator_for<_Container> _Alloc>
+flat_set(sorted_unique_t, _Container, _Alloc)
+    -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+template <_Not_allocator_for_container _Container, _Valid_compare_for_container<_Container> _Compare,
+    _Usable_allocator_for<_Container> _Alloc>
+flat_set(sorted_unique_t, _Container, _Compare, _Alloc)
+    -> flat_set<typename _Container::value_type, _Compare, _Container>;
+
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+template <class _Key, class _Compare, class _Container, _Usable_allocator_for<_Container> _Alloc>
+flat_set(flat_set<_Key, _Compare, _Container>, _Alloc) -> flat_set<_Key, _Compare, _Container>;
+#endif // ^^^ workaround ^^^
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<iter_value_t<_InIt>>>
+flat_set(_InIt, _InIt, _Compare = _Compare()) -> flat_set<iter_value_t<_InIt>, _Compare>;
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<iter_value_t<_InIt>>>
+flat_set(sorted_unique_t, _InIt, _InIt, _Compare = _Compare()) -> flat_set<iter_value_t<_InIt>, _Compare>;
+
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Range, _Not_allocator_for_container _Compare = less<_RANGES range_value_t<_Range>>,
+    class _Alloc = allocator<_RANGES range_value_t<_Range>>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_set(from_range_t, _Range&&, _Compare = _Compare(), _Alloc = _Alloc()) -> flat_set<_RANGES range_value_t<_Range>,
+    _Compare, vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Range, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_set(from_range_t, _Range&&, _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
+    vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+
+template <class _Key, _Not_allocator_for_container _Compare = less<_Key>>
+flat_set(initializer_list<_Key>, _Compare = _Compare()) -> flat_set<_Key, _Compare>;
+template <class _Key, _Not_allocator_for_container _Compare = less<_Key>>
+flat_set(sorted_unique_t, initializer_list<_Key>, _Compare = _Compare()) -> flat_set<_Key, _Compare>;
+
+template <_Not_allocator_for_container _Container,
+    _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
+flat_multiset(_Container, _Compare = _Compare())
+    -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
+template <_Not_allocator_for_container _Container, _Usable_allocator_for<_Container> _Alloc>
+flat_multiset(_Container, _Alloc)
+    -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+template <_Not_allocator_for_container _Container, _Valid_compare_for_container<_Container> _Compare,
+    _Usable_allocator_for<_Container> _Alloc>
+flat_multiset(_Container, _Compare, _Alloc) -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
+
+template <_Not_allocator_for_container _Container,
+    _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
+flat_multiset(sorted_equivalent_t, _Container, _Compare = _Compare())
+    -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
+template <_Not_allocator_for_container _Container, _Usable_allocator_for<_Container> _Alloc>
+flat_multiset(sorted_equivalent_t, _Container, _Alloc)
+    -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+template <_Not_allocator_for_container _Container, _Valid_compare_for_container<_Container> _Compare,
+    _Usable_allocator_for<_Container> _Alloc>
+flat_multiset(sorted_equivalent_t, _Container, _Compare, _Alloc)
+    -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
+
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+template <class _Key, class _Compare, class _Container, _Usable_allocator_for<_Container> _Alloc>
+flat_multiset(flat_multiset<_Key, _Compare, _Container>, _Alloc) -> flat_multiset<_Key, _Compare, _Container>;
+#endif // ^^^ workaround ^^^
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<iter_value_t<_InIt>>>
+flat_multiset(_InIt, _InIt, _Compare = _Compare()) -> flat_multiset<iter_value_t<_InIt>, _Compare>;
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<iter_value_t<_InIt>>>
+flat_multiset(sorted_equivalent_t, _InIt, _InIt, _Compare = _Compare()) -> flat_multiset<iter_value_t<_InIt>, _Compare>;
+
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Range, _Not_allocator_for_container _Compare = less<_RANGES range_value_t<_Range>>,
+    class _Alloc = allocator<_RANGES range_value_t<_Range>>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multiset(from_range_t, _Range&&, _Compare = _Compare(), _Alloc = _Alloc())
+    -> flat_multiset<_RANGES range_value_t<_Range>, _Compare,
+        vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Range, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multiset(from_range_t, _Range&&, _Alloc)
+    -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
+        vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+
+template <class _Key, _Not_allocator_for_container _Compare = less<_Key>>
+flat_multiset(initializer_list<_Key>, _Compare = _Compare()) -> flat_multiset<_Key, _Compare>;
+template <class _Key, _Not_allocator_for_container _Compare = less<_Key>>
+flat_multiset(sorted_equivalent_t, initializer_list<_Key>, _Compare = _Compare()) -> flat_multiset<_Key, _Compare>;
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // ^^^ _HAS_CXX23 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FLAT_SET_
diff --git a/msvc-stl/stl/inc/format b/msvc-stl/stl/inc/format
new file mode 100644
index 0000000..67fa7af
--- /dev/null
+++ b/msvc-stl/stl/inc/format
@@ -0,0 +1,3747 @@
+// format standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// NOTE:
+// The contents of this header are derived in part from libfmt under the following license:
+
+// Copyright (c) 2012 - present, Victor Zverovich
+//
+// 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.
+//
+// --- Optional exception to the license ---
+//
+// As an exception, if, as a result of your compiling your source code, portions
+// of this Software are embedded into a machine-executable object form of such
+// source code, you may redistribute such embedded portions in such object form
+// without including the above copyright and permission notices.
+
+#ifndef _FORMAT_
+#define _FORMAT_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <format> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+
+#include <__msvc_format_ucd_tables.hpp>
+#include <__msvc_formatter.hpp>
+#include <__msvc_print.hpp>
+#include <__msvc_ranges_tuple_formatter.hpp>
+#include <bit>
+#include <charconv>
+#include <concepts>
+#include <cstdint>
+#include <iterator>
+#include <locale>
+#include <stdexcept>
+#include <xcall_once.h>
+#include <xfilesystem_abi.h>
+#include <xstring>
+#include <xutility>
+
+#if _HAS_CXX23
+#include <tuple>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" _NODISCARD __std_win_error __stdcall __std_get_cvt(__std_code_page _Codepage, _Cvtvec* _Pcvt) noexcept;
+
+_STD_BEGIN
+_NODISCARD constexpr bool _Is_integral_fmt_type(_Basic_format_arg_type _Ty) {
+    return _Ty > _Basic_format_arg_type::_None && _Ty <= _Basic_format_arg_type::_Char_type;
+}
+
+_NODISCARD constexpr bool _Is_arithmetic_fmt_type(_Basic_format_arg_type _Ty) {
+    return _Ty > _Basic_format_arg_type::_None && _Ty <= _Basic_format_arg_type::_Long_double_type;
+}
+
+struct _Auto_id_tag {
+    explicit _Auto_id_tag() = default;
+};
+
+template <class _Ty, class _CharT>
+concept _Parse_arg_id_callbacks = requires(_Ty _At) {
+    { _At._On_auto_id() } -> same_as<void>;
+    { _At._On_manual_id(size_t{}) } -> same_as<void>;
+};
+
+template <class _Ty, class _CharT>
+concept _Parse_replacement_field_callbacks = requires(_Ty _At, const _CharT* _First, const _CharT* _Last) {
+    { _At._Parse_context };
+    { _At._On_text(_First, _Last) } -> same_as<void>;
+    { _At._On_replacement_field(size_t{}, static_cast<const _CharT*>(nullptr)) } -> same_as<void>;
+    { _At._On_format_specs(size_t{}, _First, _Last) } -> same_as<const _CharT*>;
+};
+
+template <class _Ty, class _CharT>
+concept _Parse_align_callbacks = requires(_Ty _At, basic_string_view<_CharT> _Sv, _Fmt_align _Aln) {
+    { _At._On_fill(_Sv) } -> same_as<void>;
+    { _At._On_align(_Aln) } -> same_as<void>;
+};
+
+template <class _Ty, class _CharT>
+concept _Parse_width_callbacks = requires(_Ty _At) {
+    { _At._On_width(int{}) } -> same_as<void>;
+};
+
+template <class _Ty, class _CharT>
+concept _Parse_precision_callbacks = requires(_Ty _At) {
+    { _At._On_precision(int{}) } -> same_as<void>;
+};
+
+template <class _Ty, class _CharT>
+concept _Width_adapter_callbacks = requires(_Ty _At) {
+    { _At._On_dynamic_width(_Auto_id_tag{}) } -> same_as<void>;
+    { _At._On_dynamic_width(size_t{}) } -> same_as<void>;
+};
+
+template <class _Ty, class _CharT>
+concept _Precision_adapter_callbacks = requires(_Ty _At) {
+    { _At._On_dynamic_precision(_Auto_id_tag{}) } -> same_as<void>;
+    { _At._On_dynamic_precision(size_t{}) } -> same_as<void>;
+};
+
+template <class _Ty, class _CharT>
+concept _Parse_spec_callbacks = _Parse_align_callbacks<_Ty, _CharT> && _Parse_width_callbacks<_Ty, _CharT>
+                             && _Parse_precision_callbacks<_Ty, _CharT> && _Width_adapter_callbacks<_Ty, _CharT>
+                             && _Precision_adapter_callbacks<_Ty, _CharT> && requires(_Ty _At, _Fmt_sign _Sgn) {
+                                    { _At._On_sign(_Sgn) } -> same_as<void>;
+                                    { _At._On_hash() } -> same_as<void>;
+                                    { _At._On_zero() } -> same_as<void>;
+                                    { _At._On_localized() } -> same_as<void>;
+                                    { _At._On_type(_CharT{}) } -> same_as<void>;
+                                };
+
+template <class _CharT>
+struct _Decode_result {
+    const _CharT* _Next_ptr;
+    bool _Is_unicode_scalar_value; // Also _Is_usv below, see https://www.unicode.org/glossary/#unicode_scalar_value
+    // _Is_unicode_scalar_value is also used for non-Unicode encodings, to indicate that the input can be converted to
+    // Unicode.
+};
+
+// _Decode_utf decodes UTF-8 or UTF-16 encoded unsigned char or wchar_t strings respectively
+_NODISCARD constexpr _Decode_result<wchar_t> _Decode_utf(
+    const wchar_t* _First, const wchar_t* _Last, char32_t& _Val) noexcept {
+    _STL_INTERNAL_CHECK(_First < _Last);
+    _Val = static_cast<char32_t>(*_First);
+    if (_Val < 0xD800) {
+        return {_First + 1, true};
+    } else if (_Val <= 0xDBFF) {
+        // 0xD800 <= _Val <= 0xDBFF: High surrogate
+        if (_First + 1 == _Last) {
+            _Val = 0xFFFD;
+            return {_Last, false};
+        }
+
+        if (_First[1] < 0xDC00 || _First[1] > 0xDFFF) {
+            // unpaired high surrogate
+            _Val = 0xFFFD;
+            return {_First + 1, false};
+        }
+
+        _Val = (_Val - 0xD800) << 10;
+        _Val += _First[1] - 0xDC00;
+        _Val += 0x10000;
+        return {_First + 2, true};
+    } else if (_Val <= 0xDFFF) {
+        // unpaired low surrogate
+        _Val = 0xFFFD;
+        return {_First + 1, false};
+    }
+
+    return {_First + 1, true};
+}
+
+_NODISCARD constexpr _Decode_result<char> _Decode_utf(const char* _First, const char* _Last, char32_t& _Val) noexcept {
+    _STL_INTERNAL_CHECK(_First < _Last);
+    // Decode a UTF-8 encoded codepoint starting at _First and not exceeding _Last, returning
+    // one past the end of the character decoded. Any invalid codepoints will result in
+    // _Val == U+FFFD and _Decode_utf will return one past the
+    // maximal subpart of the ill-formed subsequence. So, most invalid UTF-8 will result in
+    // one U+FFFD for each byte of invalid data. Truncated but otherwise valid UTF-8 may
+    // result in one U+FFFD for more than one input byte.
+    _Val = static_cast<char32_t>(static_cast<unsigned char>(*_First));
+
+    // All UTF-8 text is at least one byte.
+    // The zero extended values of the "prefix" bytes for
+    // a multi-byte sequence are the lowest numeric value (in two's complement)
+    // that any leading byte could have for a code unit of that size, so
+    // we just sum the comparisons to get the number of trailing bytes.
+    int _Num_bytes;
+    if (_Val <= 0x7F) {
+        return {_First + 1, true};
+    } else if (_Val >= 0xC2 && _Val <= 0xDF) {
+        _Num_bytes = 2;
+    } else if (_Val >= 0xE0 && _Val <= 0xEF) {
+        _Num_bytes = 3;
+    } else if (_Val >= 0xF0 && _Val <= 0xF4) {
+        _Num_bytes = 4;
+    } else {
+        // definitely not valid
+        _Val = 0xFFFD;
+        return {_First + 1, false};
+    }
+
+    if (_First + 1 == _Last) {
+        // We got a multibyte sequence and the next byte is off the end, we need
+        // to check just the next byte here since we need to look for overlong sequences.
+        // We want to return one past the end of a truncated sequence if everything is
+        // otherwise valid, so we can't check if _First + _Num_bytes is off the end.
+        _Val = 0xFFFD;
+        return {_Last, false};
+    }
+
+    switch (_Val) {
+    case 0xE0:
+        // we know _First[1] is in range because we just checked above,
+        // and a leader of 0xE0 implies _Num_bytes == 3
+        if (static_cast<unsigned char>(_First[1]) < 0xA0) {
+            // note, we just increment forward one-byte,
+            // even though _Num_bytes would imply the next
+            // codepoint starts at _First + 2, this is because
+            // we don't consume trailing bytes of ill-formed subsequences
+            _Val = 0xFFFD;
+            return {_First + 1, false};
+        }
+        break;
+    case 0xED:
+        if (static_cast<unsigned char>(_First[1]) > 0x9F) {
+            _Val = 0xFFFD;
+            return {_First + 1, false};
+        }
+        break;
+    case 0xF0:
+        if (static_cast<unsigned char>(_First[1]) < 0x90) {
+            _Val = 0xFFFD;
+            return {_First + 1, false};
+        }
+        break;
+    case 0xF4:
+        if (static_cast<unsigned char>(_First[1]) > 0x8F) {
+            _Val = 0xFFFD;
+            return {_First + 1, false};
+        }
+        break;
+    default:
+        break;
+    }
+
+    // mask out the "value bits" in the leading byte,
+    // for one-byte codepoints there is no leader,
+    // two-byte codepoints have the same number of value
+    // bits as trailing bytes (including the leading zero)
+    switch (_Num_bytes) {
+    case 2:
+        _Val &= 0b1'1111u;
+        break;
+    case 3:
+        _Val &= 0b1111u;
+        break;
+    case 4:
+        _Val &= 0b111u;
+        break;
+    default:
+        _STL_UNREACHABLE; // can't happen, see how the value of _Num_bytes is determined
+        break;
+    }
+
+    for (int _Idx = 1; _Idx < _Num_bytes; ++_Idx) {
+        if (_First + _Idx >= _Last || static_cast<unsigned char>(_First[_Idx]) < 0x80
+            || static_cast<unsigned char>(_First[_Idx]) > 0xBF) {
+            // truncated sequence
+            _Val = 0xFFFD;
+            return {_First + _Idx, false};
+        }
+        // we know we're always in range due to the above check.
+        _Val = (_Val << 6) | (static_cast<unsigned char>(_First[_Idx]) & 0b11'1111u);
+    }
+    return {_First + _Num_bytes, true};
+}
+
+_NODISCARD constexpr _Decode_result<char32_t> _Decode_utf(
+    const char32_t* _First, const char32_t* _Last, char32_t& _Val) noexcept {
+    _STL_INTERNAL_CHECK(_First < _Last);
+    (void) _Last;
+    _Val               = *_First;
+    const bool _Is_usv = _Val < 0xD800 || (_Val > 0xDFFF && _Val <= 0x10FFFF);
+    return {_First + 1, _Is_usv};
+}
+
+template <class _CharT>
+class _Unicode_codepoint_iterator {
+private:
+    const _CharT* _First = nullptr;
+    const _CharT* _Last  = nullptr;
+    const _CharT* _Next  = nullptr;
+    char32_t _Val        = 0;
+
+public:
+    using value_type      = char32_t;
+    using difference_type = ptrdiff_t;
+
+    constexpr _Unicode_codepoint_iterator(const _CharT* _First_val, const _CharT* _Last_val) noexcept
+        : _First(_First_val), _Last(_Last_val) {
+        if (_First != _Last) {
+            _Next = _Decode_utf(_First, _Last, _Val)._Next_ptr;
+        }
+    }
+
+    constexpr _Unicode_codepoint_iterator() = default;
+
+    constexpr _Unicode_codepoint_iterator& operator++() noexcept {
+        _First = _Next;
+        if (_First != _Last) {
+            _Next = _Decode_utf(_First, _Last, _Val)._Next_ptr;
+        }
+
+        return *this;
+    }
+    constexpr _Unicode_codepoint_iterator operator++(int) noexcept {
+        auto _Old = *this;
+        ++*this;
+        return _Old;
+    }
+
+    _NODISCARD constexpr value_type operator*() const noexcept {
+        return _Val;
+    }
+
+    _NODISCARD constexpr const _CharT* _Position() const noexcept {
+        return _First;
+    }
+
+    _NODISCARD constexpr bool operator==(default_sentinel_t) const noexcept {
+        return _First == _Last;
+    }
+    _NODISCARD constexpr bool operator==(const _Unicode_codepoint_iterator& _Other) const noexcept {
+        _STL_INTERNAL_CHECK(_Last == _Other._Last);
+        return _First == _Other._First && _Last == _Other._Last;
+    }
+};
+
+// Implements a DFA matching the regex of the rule GB9c. The DFA is:
+//
+//                             Consonant
+//                       +-------------------+
+//                       |                   |
+// +---+   Consonant   +-v-+    Linker     +-+-+
+// | 1 +---------------> 2 +---------------> 3 |
+// +---+               ++-^+               ++-^+
+//                      | |                 | |
+//                      +-+                 +-+
+//                      Extend       Linker or Extend
+//
+// State '3' is the accepting state.
+class _GB9c_regex {
+private:
+    enum _State_t : uint8_t { _Start, _Consonant, _Linker };
+
+    _State_t _State = _Start;
+
+public:
+    _NODISCARD constexpr bool operator==(const _GB9c_regex&) const noexcept = default;
+
+    _NODISCARD constexpr bool _Match(const _Indic_Conjunct_Break_property_values _Left_InCB) noexcept {
+        switch (_State) {
+        case _Start:
+            if (_Left_InCB == _Indic_Conjunct_Break_property_values::_Consonant_value) {
+                _State = _Consonant;
+            }
+            return false;
+
+        case _Consonant:
+            if (_Left_InCB == _Indic_Conjunct_Break_property_values::_Consonant_value) {
+                return false;
+            }
+
+            if (_Left_InCB == _Indic_Conjunct_Break_property_values::_Extend_value) {
+                return false;
+            }
+
+            if (_Left_InCB == _Indic_Conjunct_Break_property_values::_Linker_value) {
+                _State = _Linker;
+                return true;
+            }
+            break;
+
+        case _Linker:
+            if (_Left_InCB == _Indic_Conjunct_Break_property_values::_Consonant_value) {
+                _State = _Consonant;
+                return false;
+            }
+
+            if (_Left_InCB == _Indic_Conjunct_Break_property_values::_Extend_value
+                || _Left_InCB == _Indic_Conjunct_Break_property_values::_Linker_value) {
+                return true;
+            }
+            break;
+
+        default:
+            _STL_INTERNAL_CHECK(false);
+            break;
+        }
+
+        _State = _Start;
+        return false;
+    }
+};
+
+// Implements a DFA matching the regex on the left side of rule GB11. The DFA is:
+//
+// +---+   ExtPic      +---+    ZWJ        +---+
+// | 1 +---------------> 2 +---------------> 3 |
+// +---+               ++-^+               +---+
+//                      | |
+//                      +-+
+//                      Extend
+//
+// Note state 3 is never explicitly transitioned to, since it's the "accept" state, we just
+// transition back to state 1 and return true.
+class _GB11_LeftHand_regex {
+private:
+    enum _State_t : bool { _Start, _ExtPic };
+
+    _State_t _State = _Start;
+
+public:
+    _NODISCARD constexpr bool operator==(const _GB11_LeftHand_regex&) const noexcept = default;
+
+    _NODISCARD constexpr bool _Match(
+        const _Grapheme_Break_property_values _Left_gbp, _Extended_Pictographic_property_values _Left_ExtPic) noexcept {
+        switch (_State) {
+        case _Start:
+            if (_Left_ExtPic == _Extended_Pictographic_property_values::_Extended_Pictographic_value) {
+                _State = _ExtPic;
+            }
+            return false;
+        case _ExtPic:
+            if (_Left_gbp == _Grapheme_Break_property_values::_ZWJ_value) {
+                _State = _Start;
+                return true;
+            } else if (_Left_gbp != _Grapheme_Break_property_values::_Extend_value) {
+                _State = _Start;
+                return false;
+            }
+            return false;
+        default:
+            _STL_INTERNAL_CHECK(false);
+            return false;
+        }
+    }
+};
+
+template <class _CharT>
+class _Grapheme_break_property_iterator2 {
+private:
+    using _Wrapped_iter_type = _Unicode_codepoint_iterator<_CharT>;
+
+    _Wrapped_iter_type _WrappedIter;
+    _GB9c_regex _GB9c_rx;
+    _GB11_LeftHand_regex _GB11_rx;
+
+public:
+    using value_type      = iter_value_t<_Wrapped_iter_type>;
+    using difference_type = ptrdiff_t;
+
+    _NODISCARD constexpr bool operator==(default_sentinel_t) const noexcept {
+        return _WrappedIter == default_sentinel;
+    }
+
+    _NODISCARD constexpr bool operator==(const _Grapheme_break_property_iterator2&) const noexcept = default;
+
+    constexpr _Grapheme_break_property_iterator2(const _CharT* _First, const _CharT* _Last)
+        : _WrappedIter(_First, _Last) {}
+
+    constexpr _Grapheme_break_property_iterator2() = default;
+
+    constexpr _Grapheme_break_property_iterator2& operator++() noexcept {
+        auto _Left_gbp     = _Grapheme_Break_property_data._Get_property_for_codepoint(*_WrappedIter);
+        auto _Left_InCB    = _Indic_Conjunct_Break_property_data._Get_property_for_codepoint(*_WrappedIter);
+        auto _Left_ExtPic  = _Extended_Pictographic_property_data._Get_property_for_codepoint(*_WrappedIter);
+        auto _Right_gbp    = _Grapheme_Break_property_values::_No_value;
+        auto _Right_ExtPic = _Extended_Pictographic_property_values::_No_value;
+        size_t _Num_RIs    = 0;
+        for (;; _Left_gbp    = _Right_gbp,
+                _Left_InCB   = _Indic_Conjunct_Break_property_data._Get_property_for_codepoint(*_WrappedIter),
+                _Left_ExtPic = _Right_ExtPic) {
+            ++_WrappedIter;
+            if (_WrappedIter == default_sentinel) {
+                return *this; // GB2 Any % eot
+            }
+            _Right_gbp    = _Grapheme_Break_property_data._Get_property_for_codepoint(*_WrappedIter);
+            _Right_ExtPic = _Extended_Pictographic_property_data._Get_property_for_codepoint(*_WrappedIter);
+            // match GB9c and GB11 now, so that we're sure to update them for every character,
+            // not just ones where the rules are considered
+            const bool _GB9c_Match = _GB9c_rx._Match(_Left_InCB);
+            const bool _GB11_Match = _GB11_rx._Match(_Left_gbp, _Left_ExtPic);
+            // Also update the number of sequential RIs immediately
+            if (_Left_gbp == _Grapheme_Break_property_values::_Regional_Indicator_value) {
+                ++_Num_RIs;
+            } else {
+                _Num_RIs = 0;
+            }
+
+            if (_Left_gbp == _Grapheme_Break_property_values::_CR_value
+                && _Right_gbp == _Grapheme_Break_property_values::_LF_value) {
+                continue; // GB3 CR x LF
+            }
+
+            if (_Left_gbp == _Grapheme_Break_property_values::_Control_value
+                || _Left_gbp == _Grapheme_Break_property_values::_CR_value
+                || _Left_gbp == _Grapheme_Break_property_values::_LF_value) {
+                return *this; // GB4 (Control | CR | LF) % Any
+            }
+
+            if (_Right_gbp == _Grapheme_Break_property_values::_Control_value
+                || _Right_gbp == _Grapheme_Break_property_values::_CR_value
+                || _Right_gbp == _Grapheme_Break_property_values::_LF_value) {
+                return *this; // GB5 Any % (Control | CR | LF)
+            }
+
+            if (_Left_gbp == _Grapheme_Break_property_values::_L_value
+                && (_Right_gbp == _Grapheme_Break_property_values::_L_value
+                    || _Right_gbp == _Grapheme_Break_property_values::_V_value
+                    || _Right_gbp == _Grapheme_Break_property_values::_LV_value
+                    || _Right_gbp == _Grapheme_Break_property_values::_LVT_value)) {
+                continue; // GB6 L x (L | V | LV | LVT)
+            }
+
+            if ((_Left_gbp == _Grapheme_Break_property_values::_LV_value
+                    || _Left_gbp == _Grapheme_Break_property_values::_V_value)
+                && (_Right_gbp == _Grapheme_Break_property_values::_V_value
+                    || _Right_gbp == _Grapheme_Break_property_values::_T_value)) {
+                continue; // GB7 (LV | V) x (V | T)
+            }
+
+            if ((_Left_gbp == _Grapheme_Break_property_values::_LVT_value
+                    || _Left_gbp == _Grapheme_Break_property_values::_T_value)
+                && _Right_gbp == _Grapheme_Break_property_values::_T_value) {
+                continue; // GB8 (LVT | T) x T
+            }
+
+            if (_Right_gbp == _Grapheme_Break_property_values::_Extend_value
+                || _Right_gbp == _Grapheme_Break_property_values::_ZWJ_value) {
+                continue; // GB9 x (Extend | ZWJ)
+            }
+
+            if (_Right_gbp == _Grapheme_Break_property_values::_SpacingMark_value) {
+                continue; // GB9a x SpacingMark
+            }
+
+            if (_Left_gbp == _Grapheme_Break_property_values::_Prepend_value) {
+                continue; // GB9b Prepend x
+            }
+
+            if (_GB9c_Match) {
+                // GB9c (since Unicode 15.1)
+                // \p{InCB=Consonant}[ \p{InCB=Extend} \p{InCB=Linker} ]* \p{InCB=Linker} [ \p{InCB=Extend}
+                // \p{InCB=Linker} ]* x \p{InCB=Consonant}
+                continue;
+            }
+
+            if (_GB11_Match && _Right_ExtPic == _Extended_Pictographic_property_values::_Extended_Pictographic_value) {
+                continue; // GB11 \p{ExtendedPictographic} Extend* ZWJ x \p{ExtendedPictographic}
+            }
+
+            if (_Left_gbp == _Grapheme_Break_property_values::_Regional_Indicator_value
+                && _Right_gbp == _Grapheme_Break_property_values::_Regional_Indicator_value && _Num_RIs % 2 != 0) {
+                continue; // GB12 and 13, do not break between RIs if there are an odd number of RIs before the
+                          // breakpoint
+            }
+            return *this;
+        }
+    }
+    constexpr _Grapheme_break_property_iterator2 operator++(int) noexcept {
+        auto _Old = *this;
+        ++*this;
+        return _Old;
+    }
+
+    _NODISCARD constexpr const _CharT* _Position() const noexcept {
+        return _WrappedIter._Position();
+    }
+
+    _NODISCARD constexpr value_type operator*() const noexcept {
+        return *_WrappedIter;
+    }
+};
+
+template <class _Ty, class _CharT>
+concept _CharT_or_bool = same_as<_Ty, _CharT> || same_as<_Ty, bool>;
+
+template <class _Ty, class _Context, class _Formatter = _Context::template formatter_type<remove_const_t<_Ty>>>
+concept _Formattable_with_non_const = semiregular<_Formatter>
+                                   && requires(_Formatter& __f, _Ty&& __t, _Context __fc,
+                                       basic_format_parse_context<typename _Context::char_type> __pc) {
+                                          { __f.parse(__pc) } -> same_as<typename decltype(__pc)::iterator>;
+                                          { __f.format(__t, __fc) } -> same_as<typename _Context::iterator>;
+                                      };
+
+// we need to implement this ourselves because from_chars does not work with wide characters and isn't constexpr
+template <class _CharT>
+_NODISCARD constexpr const _CharT* _Parse_nonnegative_integer(
+    const _CharT* _First, const _CharT* _Last, unsigned int& _Value) {
+    _STL_INTERNAL_CHECK(_First != _Last && '0' <= *_First && *_First <= '9');
+
+    constexpr auto _Max_int = static_cast<unsigned int>(_STD _Max_limit<int>());
+    constexpr auto _Big_int = _Max_int / 10u;
+
+    _Value = 0;
+
+    do {
+        if (_Value > _Big_int) {
+            _Value = _Max_int + 1;
+            break;
+        }
+        _Value = _Value * 10 + static_cast<unsigned int>(*_First - '0');
+        ++_First;
+    } while (_First != _Last && '0' <= *_First && *_First <= '9');
+
+    if (_Value > _Max_int) {
+        _Throw_format_error("Number is too big");
+    }
+
+    return _First;
+}
+
+template <class _CharT>
+_NODISCARD constexpr const _CharT* _Parse_nonnegative_integer(const _CharT* _First, const _CharT* _Last, int& _Value) {
+    unsigned int _Val_unsigned = 0;
+
+    _First = _Parse_nonnegative_integer(_First, _Last, _Val_unsigned);
+    // Never invalid because _Parse_nonnegative_integer throws an error for values that don't fit in signed integers
+    _Value = static_cast<int>(_Val_unsigned);
+    return _First;
+}
+
+template <class _CharT, _Parse_arg_id_callbacks<_CharT> _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_arg_id(
+    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
+    _STL_INTERNAL_CHECK(_First != _Last);
+    _CharT _Ch = *_First;
+    // No id provided, format string is using automatic indexing.
+    if (_Ch == '}' || _Ch == ':') {
+        _Callbacks._On_auto_id();
+        return _First;
+    }
+
+    if (_Ch >= '0' && _Ch <= '9') {
+        unsigned int _Index = 0;
+        // arg_id is not allowed to have any leading zeros, but is allowed to be
+        // equal to zero (but not '00'). So if _Ch is zero we skip the parsing, leave
+        // _Index set to zero and let the validity checks below ensure that the arg_id
+        // wasn't something like "00", or "023".
+        if (_Ch == '0') {
+            ++_First;
+        } else {
+            _First = _Parse_nonnegative_integer(_First, _Last, _Index);
+        }
+
+        // The format string shouldn't end right after the index number.
+        // The only things permitted after the index are the end of the replacement field ('}')
+        // or the beginning of the format spec (':').
+        if (_First == _Last || (*_First != '}' && *_First != ':')) {
+            _Throw_format_error("Invalid format string.");
+        }
+
+        _Callbacks._On_manual_id(_Index);
+        return _First;
+    }
+    // This is where we would parse named arg ids if std::format were to support them.
+    _Throw_format_error("Invalid format string.");
+}
+
+_NODISCARD constexpr bool _Is_execution_charset_self_synchronizing() {
+#ifdef _MSVC_EXECUTION_CHARACTER_SET
+    // This is a list of charset codes (as reported by _MSVC_EXECUTION_CHARACTER_SET) that are
+    // self-synchronizing (and "narrow" so 1200 (utf-16) and 1201 (unicodeFFFE) are not listed).
+    // We care about this because if a charset is self-synchronizing then we can search through it
+    // for formatting control characters _without_ generally decoding the format string.
+    switch (_MSVC_EXECUTION_CHARACTER_SET) {
+    // See: https://learn.microsoft.com/windows/win32/intl/code-page-identifiers
+    case 874: // Thai (Windows)
+    case 1250: // ANSI Central European; Central European (Windows)
+    case 1251: // ANSI Cyrillic; Cyrillic (Windows)
+    case 1252: // ANSI Latin 1; Western European (Windows)
+    case 1253: // ANSI Greek; Greek (Windows)
+    case 1254: // ANSI Turkish; Turkish (Windows)
+    case 1255: // ANSI Hebrew; Hebrew (Windows)
+    case 1256: // ANSI Arabic; Arabic (Windows)
+    case 1257: // ANSI Baltic; Baltic (Windows)
+    case 1258: // ANSI/OEM Vietnamese; Vietnamese (Windows)
+    case 65001: // Unicode (UTF-8)
+        return true;
+    default:
+        return false;
+    }
+#else // ^^^ no workaround / EDG workaround vvv
+    return false; // TRANSITION, VSO-1468747 (EDG) - safe fallback response
+#endif // ^^^ EDG workaround ^^^
+}
+
+_NODISCARD constexpr int _Unicode_width_estimate(const char32_t _Ch) noexcept {
+    // Computes the width estimation for Unicode characters from N4950 [format.string.std]/13
+    // The two branches are functionally equivalent; `12` is chosen for performance here.
+    constexpr char32_t _Linear_search_threshold = _Width_estimate_intervals_v2[12];
+    if (_Ch < _Linear_search_threshold) {
+        int _Result = 1;
+        for (const auto& _Bound : _Width_estimate_intervals_v2) {
+            if (_Ch < _Bound) {
+                return _Result;
+            }
+            _Result ^= 0b11u; // Flip between 1 and 2 on each iteration
+        }
+        return 1;
+    } else {
+        const ptrdiff_t _Upper_bound_index =
+            _STD upper_bound(_Width_estimate_intervals_v2, _STD end(_Width_estimate_intervals_v2), _Ch)
+            - _Width_estimate_intervals_v2;
+        return 1 + (_Upper_bound_index & 1);
+    }
+}
+
+template <class _CharT, bool _Statically_Utf8 = _Is_execution_charset_self_synchronizing()>
+class _Fmt_codec;
+
+template <bool _Statically_Utf8>
+class _Fmt_codec_base {};
+
+template <>
+class _Fmt_codec_base<false> {
+protected:
+    _Cvtvec _Cvt;
+
+    _NODISCARD int _Double_byte_encoding_code_units_in_next_character(
+        const char* const _First, const char* const _Last) const {
+        // Returns the number of code units that compose the first encoded character in [_First, _Last),
+        // or -1 if [_First, _Last) doesn't contain an entire encoded character or *_First is not a valid lead byte.
+        wchar_t _Wide;
+        mbstate_t _St{};
+        const auto _Len   = static_cast<size_t>(_Last - _First);
+        const int _Result = _Mbrtowc(&_Wide, _First, _Len, &_St, &_Cvt);
+        if (_Result > 0) {
+            return _Result;
+        } else if (_Result < 0) { // invalid or incomplete encoded character
+            return -1;
+        } else { // next code unit is '\0'
+            return 1;
+        }
+    }
+
+    _Fmt_codec_base() {
+#ifdef _MSVC_EXECUTION_CHARACTER_SET
+        constexpr __std_code_page _Format_codepage{_MSVC_EXECUTION_CHARACTER_SET};
+#else // ^^^ no workaround / workaround vvv
+      // TRANSITION, VSO-1468747 (EDG) - constructor isn't constexpr, so value is unimportant
+        constexpr __std_code_page _Format_codepage{65001};
+#endif // ^^^ workaround ^^^
+        [[maybe_unused]] const __std_win_error _Result = __std_get_cvt(_Format_codepage, &_Cvt);
+        _STL_INTERNAL_CHECK(_Result == __std_win_error::_Success);
+    }
+};
+
+template <bool _Statically_Utf8>
+class _Fmt_codec<char, _Statically_Utf8> : private _Fmt_codec_base<_Statically_Utf8> {
+private:
+    _NODISCARD static constexpr int _Utf8_code_units_in_next_character(
+        const char* const _First, const char* const _Last) noexcept {
+        char32_t _Ch;
+        const auto [_Next, _Is_usv] = _Decode_utf(_First, _Last, _Ch);
+        _STL_INTERNAL_CHECK(_Next - _First <= 4);
+        return _Is_usv ? static_cast<int>(_Next - _First) : -1;
+    }
+
+public:
+    _NODISCARD constexpr const char* _Find_encoded(const char* _First, const char* const _Last, const char _Val) const {
+        // Returns the first occurrence of _Val as an encoded character (and not, for example, as a
+        // continuation byte) in [_First, _Last).
+        if constexpr (_Statically_Utf8) {
+            return _STD _Find_unchecked(_First, _Last, _Val);
+        } else {
+            if (this->_Cvt._Mbcurmax == 1 || this->_Cvt._Mbcurmax == 4) {
+                // As above and in _Mbrtowc, assume 4-byte encodings are UTF-8
+                return _STD _Find_unchecked(_First, _Last, _Val);
+            }
+
+            while (_First != _Last && *_First != _Val) {
+                const int _Units = this->_Double_byte_encoding_code_units_in_next_character(_First, _Last);
+                if (_Units < 0) {
+                    _Throw_format_error("Invalid encoded character in format string.");
+                }
+                _First += _Units;
+            }
+
+            return _First;
+        }
+    }
+
+    _NODISCARD constexpr int _Units_in_next_character(
+        const char* const _First, const char* const _Last) const noexcept {
+        // Returns the number of code units that compose the first encoded character in
+        // [_First, _Last), or -1 if [_First, _Last) doesn't contain an entire encoded character or
+        // *_First is not a valid lead byte.
+        _STL_INTERNAL_CHECK(_First < _Last);
+
+        if constexpr (_Statically_Utf8) {
+            return _Utf8_code_units_in_next_character(_First, _Last);
+        } else {
+            switch (this->_Cvt._Mbcurmax) {
+            default:
+                _STL_INTERNAL_CHECK(!"Bad number of encoding units for this code page");
+                [[fallthrough]];
+            case 1:
+                return 1; // all characters have only one code unit
+
+            case 2:
+                return this->_Double_byte_encoding_code_units_in_next_character(_First, _Last);
+
+            case 4: // Assume UTF-8 (as does _Mbrtowc)
+                return _Utf8_code_units_in_next_character(_First, _Last);
+            }
+        }
+    }
+
+#if _HAS_CXX23
+    _NODISCARD _Decode_result<char> _Decode(const char* const _First, const char* const _Last, char32_t& _Val) const {
+        _STL_INTERNAL_CHECK(_First < _Last);
+
+        if constexpr (_Is_ordinary_literal_encoding_utf8()) {
+            return _Decode_utf(_First, _Last, _Val);
+#ifdef _MSVC_EXECUTION_CHARACTER_SET // TRANSITION, VSO-1468747 (EDG)
+        } else if constexpr (_Is_execution_charset_self_synchronizing()) {
+            wchar_t _Wide;
+            const auto _Res =
+                __std_fs_convert_narrow_to_wide(__std_code_page{_MSVC_EXECUTION_CHARACTER_SET}, _First, 1, &_Wide, 1);
+            _Val = _Wide;
+            return {_First + 1, _Res._Len != 0};
+#endif // ^^^ no workaround ^^^
+        } else {
+            if (*_First == '\0') {
+                _Val = U'\0';
+                return {_First + 1, true};
+            }
+
+            wchar_t _Wide;
+            mbstate_t _St{};
+            const auto _Len   = static_cast<size_t>(_Last - _First);
+            const int _Result = _Mbrtowc(&_Wide, _First, _Len, &_St, &this->_Cvt);
+            if (_Result < 0) {
+                return {_First + 1, false};
+            } else {
+                _Val = _Wide;
+                return {_First + _Result, true};
+            }
+        }
+    }
+#endif // _HAS_CXX23
+};
+
+template <bool _Statically_Utf8>
+class _Fmt_codec<wchar_t, _Statically_Utf8> {
+public:
+    _NODISCARD constexpr const wchar_t* _Find_encoded(
+        const wchar_t* const _First, const wchar_t* const _Last, const wchar_t _Val) const {
+        return _STD _Find_unchecked(_First, _Last, _Val);
+    }
+
+    _NODISCARD constexpr int _Units_in_next_character(
+        const wchar_t* _First, const wchar_t* const _Last) const noexcept {
+        char32_t _Ch;
+        const auto [_Next, _Is_usv] = _Decode_utf(_First, _Last, _Ch);
+        _STL_INTERNAL_CHECK(_Next - _First <= 2);
+        return _Is_usv ? static_cast<int>(_Next - _First) : -1;
+    }
+
+#if _HAS_CXX23
+    _NODISCARD constexpr _Decode_result<wchar_t> _Decode(
+        const wchar_t* const _First, const wchar_t* const _Last, char32_t& _Val) const noexcept {
+        return _Decode_utf(_First, _Last, _Val);
+    }
+#endif // _HAS_CXX23
+};
+
+template <class _CharT>
+_NODISCARD constexpr _Fmt_codec<_CharT> _Get_fmt_codec() {
+    return {};
+}
+
+template <class _CharT>
+    requires (is_same_v<_CharT, char> && !_Is_execution_charset_self_synchronizing())
+_NODISCARD const _Fmt_codec<_CharT>& _Get_fmt_codec() {
+    using _CodecType = _Fmt_codec<_CharT>;
+
+    static once_flag _Flag;
+    alignas(_CodecType) static unsigned char _Storage[sizeof(_CodecType)];
+
+    _STD call_once(_Flag, [] { _STD construct_at(reinterpret_cast<_CodecType*>(&_Storage)); });
+
+    return *_STD launder(reinterpret_cast<const _CodecType*>(&_Storage));
+}
+
+template <class _CharT, _Parse_align_callbacks<_CharT> _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_align(
+    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
+    // align and fill
+    _STL_INTERNAL_CHECK(_First != _Last && *_First != '}');
+    auto _Parsed_align = _Fmt_align::_None;
+
+    const int _Units = _Get_fmt_codec<_CharT>()._Units_in_next_character(_First, _Last);
+    if (_Units < 0) { // invalid fill character encoding
+        _Throw_format_error("Invalid format string.");
+    }
+    auto _Align_pt = _First + _Units;
+
+    if (_Align_pt == _Last) {
+        _Align_pt = _First;
+    }
+
+    for (;;) {
+        switch (*_Align_pt) {
+        case '<':
+            _Parsed_align = _Fmt_align::_Left;
+            break;
+        case '>':
+            _Parsed_align = _Fmt_align::_Right;
+            break;
+        case '^':
+            _Parsed_align = _Fmt_align::_Center;
+            break;
+        default:
+            break;
+        }
+
+        if (_Parsed_align != _Fmt_align::_None) {
+            if (_Align_pt != _First) {
+                if (*_First == '{') {
+                    _Throw_format_error("invalid fill character '{'");
+                }
+                _Callbacks._On_fill({_First, static_cast<size_t>(_Align_pt - _First)});
+                _First = _Align_pt + 1;
+            } else {
+                ++_First;
+            }
+            _Callbacks._On_align(_Parsed_align);
+            break;
+        } else if (_Align_pt == _First) {
+            break;
+        }
+        _Align_pt = _First;
+    }
+
+    return _First;
+}
+
+// Adapts a type modeling _Width_adapter_callbacks to model _Parse_arg_id_callbacks.
+// Used in _Parse_width so that _Parse_arg_id can be used to parse dynamic widths.
+template <class _CharT, _Width_adapter_callbacks<_CharT> _Callbacks_type>
+struct _Width_adapter {
+    _Callbacks_type& _Callbacks;
+
+    constexpr explicit _Width_adapter(_Callbacks_type& _Handler) : _Callbacks(_Handler) {}
+
+    constexpr void _On_auto_id() {
+        _Callbacks._On_dynamic_width(_Auto_id_tag{});
+    }
+    constexpr void _On_manual_id(const size_t _Id) {
+        _Callbacks._On_dynamic_width(_Id);
+    }
+};
+
+// Adapts a type modeling _Precision_adapter_callbacks to model _Parse_arg_id_callbacks.
+// Used in _Parse_precision so that _Parse_arg_id can be used to parse dynamic precisions.
+template <class _CharT, _Precision_adapter_callbacks<_CharT> _Callbacks_type>
+struct _Precision_adapter {
+    _Callbacks_type& _Callbacks;
+
+    constexpr explicit _Precision_adapter(_Callbacks_type& _Handler) : _Callbacks(_Handler) {}
+
+    constexpr void _On_auto_id() {
+        _Callbacks._On_dynamic_precision(_Auto_id_tag{});
+    }
+    constexpr void _On_manual_id(const size_t _Id) {
+        _Callbacks._On_dynamic_precision(_Id);
+    }
+};
+
+// _Parse_arg_id expects a handler when it finds an argument id, however
+// _Parse_replacement_field actually needs to know the value of that argument ID to pass on
+// to _Handler._On_replacement_field or _Handler._On_format_specs. This _Parse_arg_id wrapper
+// stores the value of the arg id for later use, so _Parse_replacement_field has access to it.
+template <class _CharT>
+struct _Id_adapter {
+    basic_format_parse_context<_CharT>& _Parse_context;
+    size_t _Arg_id = static_cast<size_t>(-1);
+
+    constexpr void _On_auto_id() {
+        _Arg_id = _Parse_context.next_arg_id();
+        _STL_INTERNAL_CHECK(_Arg_id != static_cast<size_t>(-1));
+    }
+    constexpr void _On_manual_id(const size_t _Id) {
+        _Parse_context.check_arg_id(_Id);
+        _Arg_id = _Id;
+        _STL_INTERNAL_CHECK(_Arg_id != static_cast<size_t>(-1));
+    }
+};
+
+template <class _CharT, _Parse_width_callbacks<_CharT> _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_width(
+    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
+    _STL_INTERNAL_CHECK(_First != _Last);
+    if ('1' <= *_First && *_First <= '9') {
+        int _Value = 0;
+        _First     = _Parse_nonnegative_integer(_First, _Last, _Value);
+        _Callbacks._On_width(_Value);
+    } else if (*_First == '{') {
+        ++_First;
+        if (_First != _Last) {
+            _First = _Parse_arg_id(_First, _Last, _Width_adapter<_CharT, _Callbacks_type>{_Callbacks});
+        }
+
+        if (_First == _Last || *_First != '}') {
+            _Throw_format_error("Invalid format string.");
+        }
+        ++_First;
+    }
+    return _First;
+}
+
+template <class _CharT, _Parse_precision_callbacks<_CharT> _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_precision(
+    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
+    ++_First;
+    _CharT _Ch = '\0';
+    if (_First != _Last) {
+        _Ch = *_First;
+    }
+
+    if ('0' <= _Ch && _Ch <= '9') {
+        int _Precision = 0;
+        _First         = _Parse_nonnegative_integer(_First, _Last, _Precision);
+        _Callbacks._On_precision(_Precision);
+    } else if (_Ch == '{') {
+        ++_First;
+        if (_First != _Last) {
+            _First = _Parse_arg_id(_First, _Last, _Precision_adapter<_CharT, _Callbacks_type>{_Callbacks});
+        }
+
+        if (_First == _Last || *_First != '}') {
+            _Throw_format_error("Invalid format string.");
+        }
+        ++_First;
+    } else {
+        _Throw_format_error("Missing precision specifier.");
+    }
+
+    return _First;
+}
+
+template <class _CharT, _Parse_spec_callbacks<_CharT> _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_format_specs(
+    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
+    if (_First == _Last || *_First == '}') {
+        return _First;
+    }
+
+    _First = _Parse_align(_First, _Last, _Callbacks);
+    if (_First == _Last) {
+        return _First;
+    }
+
+    switch (*_First) {
+    case '+':
+        _Callbacks._On_sign(_Fmt_sign::_Plus);
+        ++_First;
+        break;
+    case '-':
+        _Callbacks._On_sign(_Fmt_sign::_Minus);
+        ++_First;
+        break;
+    case ' ':
+        _Callbacks._On_sign(_Fmt_sign::_Space);
+        ++_First;
+        break;
+    default:
+        break;
+    }
+
+    if (_First == _Last) {
+        return _First;
+    }
+
+    if (*_First == '#') {
+        _Callbacks._On_hash();
+        if (++_First == _Last) {
+            return _First;
+        }
+    }
+
+    if (*_First == '0') {
+        _Callbacks._On_zero();
+        if (++_First == _Last) {
+            return _First;
+        }
+    }
+
+    _First = _Parse_width(_First, _Last, _Callbacks);
+    if (_First == _Last) {
+        return _First;
+    }
+
+    if (*_First == '.') {
+        _First = _Parse_precision(_First, _Last, _Callbacks);
+        if (_First == _Last) {
+            return _First;
+        }
+    }
+
+    if (*_First == 'L') {
+        _Callbacks._On_localized();
+        if (++_First == _Last) {
+            return _First;
+        }
+    }
+
+    // If there's anything remaining we assume it's a type.
+    if (*_First != '}') {
+        _Callbacks._On_type(*_First);
+        ++_First;
+    } else {
+        // call the type callback so it gets a default type, this is required
+        // since _Specs_checker needs to be able to tell that it got a default type
+        // to raise an error for default formatted bools with a sign modifier
+        _Callbacks._On_type(static_cast<_CharT>('\0'));
+    }
+
+    return _First;
+}
+
+template <class _CharT, _Parse_replacement_field_callbacks<_CharT> _HandlerT>
+_NODISCARD constexpr const _CharT* _Parse_replacement_field(
+    const _CharT* _First, const _CharT* _Last, _HandlerT&& _Handler) {
+    ++_First;
+    if (_First == _Last) {
+        _Throw_format_error("Invalid format string.");
+    }
+
+    if (*_First == '}') {
+        // string was "{}", and we have a replacement field
+        _Handler._On_replacement_field(_Handler._Parse_context.next_arg_id(), _First);
+    } else if (*_First == '{') {
+        // string was "{{", so we have a literal "{" to print
+        _Handler._On_text(_First, _First + 1);
+    } else {
+        _Id_adapter<_CharT> _Adapter{_Handler._Parse_context};
+        _First = _Parse_arg_id(_First, _Last, _Adapter);
+        _CharT _Ch{};
+        if (_First != _Last) {
+            _Ch = *_First;
+        }
+
+        if (_Ch == '}') {
+            _Handler._On_replacement_field(_Adapter._Arg_id, _First);
+        } else if (_Ch == ':') {
+            _First = _Handler._On_format_specs(_Adapter._Arg_id, _First + 1, _Last);
+            if (_First == _Last || *_First != '}') {
+                _Throw_format_error("Unknown format specifier.");
+            }
+        } else {
+            _Throw_format_error("Missing '}' in format string.");
+        }
+    }
+
+    return _First + 1;
+}
+
+template <class _CharT, _Parse_replacement_field_callbacks<_CharT> _HandlerT>
+constexpr void _Parse_format_string(basic_string_view<_CharT> _Format_str, _HandlerT&& _Handler) {
+    auto _First        = _Format_str.data();
+    auto _Last         = _First + _Format_str.size();
+    const auto& _Codec = _Get_fmt_codec<_CharT>();
+
+    while (_First != _Last) {
+        const _CharT* _OpeningCurl = _First;
+        if (*_First != '{') {
+            _OpeningCurl = _Codec._Find_encoded(_First, _Last, _CharT{'{'});
+
+            for (;;) {
+                const _CharT* _ClosingCurl = _Codec._Find_encoded(_First, _OpeningCurl, _CharT{'}'});
+
+                // In this case there are neither closing nor opening curls in [_First, _OpeningCurl)
+                // Write the whole thing out.
+                if (_ClosingCurl == _OpeningCurl) {
+                    _Handler._On_text(_First, _OpeningCurl);
+                    break;
+                }
+                // We know _ClosingCurl isn't past the end because
+                // the above condition was not met.
+                ++_ClosingCurl;
+                if (_ClosingCurl == _OpeningCurl || *_ClosingCurl != '}') {
+                    _Throw_format_error("Unmatched '}' in format string.");
+                }
+                // We found two closing curls, so output only one of them
+                _Handler._On_text(_First, _ClosingCurl);
+
+                // skip over the second closing curl
+                _First = _ClosingCurl + 1;
+            }
+
+            // We are done, there were no replacement fields.
+            if (_OpeningCurl == _Last) {
+                return;
+            }
+        }
+        // Parse the replacement field starting at _OpeningCurl and ending sometime before _Last.
+        _First = _Parse_replacement_field(_OpeningCurl, _Last, _Handler);
+    }
+}
+
+// Model of _Parse_spec_callbacks that fills a _Basic_format_specs with the parsed data.
+template <class _CharT>
+class _Specs_setter {
+public:
+    constexpr explicit _Specs_setter(_Basic_format_specs<_CharT>& _Specs_) : _Specs(_Specs_) {}
+
+    constexpr void _On_align(const _Fmt_align _Aln) {
+        _Specs._Alignment = _Aln;
+    }
+
+    constexpr void _On_fill(const basic_string_view<_CharT> _Sv) {
+        if (_Sv.size() > _STD size(_Specs._Fill)) {
+            _Throw_format_error("Invalid fill (too long).");
+        }
+
+        const auto _Pos = _STD _Copy_unchecked(_Sv._Unchecked_begin(), _Sv._Unchecked_end(), _Specs._Fill);
+        _STD fill(_Pos, _STD end(_Specs._Fill), _CharT{});
+        _Specs._Fill_length = static_cast<uint8_t>(_Sv.size());
+    }
+
+    constexpr void _On_sign(const _Fmt_sign _Sgn) {
+        _Specs._Sgn = _Sgn;
+    }
+
+    constexpr void _On_hash() {
+        _Specs._Alt = true;
+    }
+
+    constexpr void _On_zero() {
+        _Specs._Leading_zero = true;
+    }
+
+    constexpr void _On_width(const int _Width) {
+        _Specs._Width = _Width;
+    }
+
+    constexpr void _On_precision(const int _Precision) {
+        _Specs._Precision = _Precision;
+    }
+
+    constexpr void _On_localized() {
+        _Specs._Localized = true;
+    }
+
+    constexpr void _On_type(const _CharT _Type) {
+        _Specs._Type = static_cast<char>(_Type);
+    }
+
+protected:
+    _Basic_format_specs<_CharT>& _Specs;
+};
+
+template <class _Context>
+_NODISCARD constexpr basic_format_arg<_Context> _Get_arg(const _Context& _Ctx, const size_t _Arg_id) {
+    // note: while this is parameterized on the _Arg_id type in libfmt we don't
+    // need to do that in std::format because it's only called with either an integer
+    // id or a named id (which we do not support in std::format)
+    auto _Arg = _Ctx.arg(_Arg_id);
+    if (!_Arg) {
+        _Throw_format_error("Argument not found.");
+    }
+
+    return _Arg;
+}
+
+template <class _Ty>
+constexpr bool _Is_signed_or_unsigned_large_integer_t =
+    _Is_any_of_v<remove_cv_t<_Ty>, int, unsigned int, long, unsigned long, long long, unsigned long long>;
+
+// Checks that the type and value of an argument associated with a dynamic
+// width specifier are valid.
+class _Width_checker {
+public:
+    template <class _Ty>
+    _NODISCARD static constexpr unsigned long long operator()(const _Ty _Value) {
+        if constexpr (_Is_signed_or_unsigned_large_integer_t<_Ty>) {
+            if constexpr (is_signed_v<_Ty>) {
+                if (_Value < 0) {
+                    _Throw_format_error("Negative width.");
+                }
+            }
+            return static_cast<unsigned long long>(_Value);
+        } else {
+            _Throw_format_error("Width is not an integer.");
+        }
+    }
+};
+
+// Checks that the type and value of an argument associated with a dynamic
+// precision specifier are valid.
+class _Precision_checker {
+public:
+    template <class _Ty>
+    _NODISCARD static constexpr unsigned long long operator()(const _Ty _Value) {
+        if constexpr (_Is_signed_or_unsigned_large_integer_t<_Ty>) {
+            if constexpr (is_signed_v<_Ty>) {
+                if (_Value < 0) {
+                    _Throw_format_error("Negative precision.");
+                }
+            }
+            return static_cast<unsigned long long>(_Value);
+        } else {
+            _Throw_format_error("Precision is not an integer.");
+        }
+    }
+};
+
+// Fetch the value of an argument associated with a dynamic
+// width or precision specifier. This will be called with either
+// _Width_checker or _Precision_checker as "_Handler".
+template <class _Handler, class _FormatArg>
+_NODISCARD constexpr int _Get_dynamic_specs(const _FormatArg _Arg) {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_Handler, _Width_checker, _Precision_checker>);
+    const unsigned long long _Val = _STD visit_format_arg(_Handler{}, _Arg);
+    if (!_STD in_range<int>(_Val)) {
+        _Throw_format_error("Number is too big.");
+    }
+
+    return static_cast<int>(_Val);
+}
+
+// Parses standard format specs into a _Basic_format_specs using _Specs_setter, and
+// additionally handles dynamic width and precision. This is separate from _Specs_setter
+// because it needs to know about the current basic_format_parse_context and basic_format_context
+// in order to fetch the width from the arguments.
+template <class _ParseContext, class _Context>
+class _Specs_handler : public _Specs_setter<typename _Context::char_type> {
+public:
+    using _CharT = _Context::char_type;
+
+    constexpr _Specs_handler(_Basic_format_specs<_CharT>& _Specs_, _ParseContext& _Parse_ctx_, _Context& _Ctx_)
+        : _Specs_setter<_CharT>(_Specs_), _Parse_ctx(_Parse_ctx_), _Ctx(_Ctx_) {}
+
+    template <class _Id>
+    constexpr void _On_dynamic_width(const _Id _Arg_id) {
+        this->_Specs._Width = _Get_dynamic_specs<_Width_checker>(_Get_arg(_Arg_id));
+    }
+
+    template <class _Id>
+    constexpr void _On_dynamic_precision(const _Id _Arg_id) {
+        this->_Specs._Precision = _Get_dynamic_specs<_Precision_checker>(_Get_arg(_Arg_id));
+    }
+
+private:
+    _ParseContext& _Parse_ctx;
+    _Context& _Ctx;
+
+    _NODISCARD constexpr basic_format_arg<_Context> _Get_arg(_Auto_id_tag) {
+        return _STD _Get_arg(_Ctx, _Parse_ctx.next_arg_id());
+    }
+
+    _NODISCARD constexpr basic_format_arg<_Context> _Get_arg(const size_t _Arg_id) {
+        _Parse_ctx.check_arg_id(_Arg_id);
+        return _STD _Get_arg(_Ctx, _Arg_id);
+    }
+};
+
+template <class _ParseContext>
+class _Dynamic_specs_handler : public _Specs_setter<typename _ParseContext::char_type> {
+public:
+    using _CharT = _ParseContext::char_type;
+
+    constexpr _Dynamic_specs_handler(_Dynamic_format_specs<_CharT>& _Specs_, _ParseContext& _Parse_ctx_)
+        : _Specs_setter<_CharT>(_Specs_), _Dynamic_specs(_Specs_), _Parse_ctx(_Parse_ctx_) {}
+
+    constexpr void _On_dynamic_width(const size_t _Arg_id) {
+        _Parse_ctx.check_arg_id(_Arg_id);
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Dynamic_specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_dynamic_width(_Auto_id_tag) {
+        const size_t _Arg_id = _Parse_ctx.next_arg_id();
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Dynamic_specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_dynamic_precision(const size_t _Arg_id) {
+        _Parse_ctx.check_arg_id(_Arg_id);
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Dynamic_specs._Dynamic_precision_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_dynamic_precision(_Auto_id_tag) {
+        const size_t _Arg_id = _Parse_ctx.next_arg_id();
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Dynamic_specs._Dynamic_precision_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+private:
+    _Dynamic_format_specs<_CharT>& _Dynamic_specs;
+    _ParseContext& _Parse_ctx;
+
+    _NODISCARD static constexpr int _Verify_dynamic_arg_index_in_range(const size_t _Idx) {
+        if (!_STD in_range<int>(_Idx)) {
+            _Throw_format_error("Dynamic width or precision index too large.");
+        }
+
+        return static_cast<int>(_Idx);
+    }
+};
+
+// Checks that the type of the argument printed by a replacement
+// field with format specs actually satisfies the requirements for
+// that format spec. If the requirements are met then calls the base class
+// handler method.
+template <class _Handler>
+class _Specs_checker : public _Handler {
+private:
+    _Basic_format_arg_type _Arg_type;
+
+    // Set for the hash and sign modifiers.
+    bool _Need_arithmetic_presentation_type = false;
+
+    // Set for the zero modifier.
+    bool _Need_arithmetic_or_pointer_presentation_type = false;
+
+public:
+    constexpr explicit _Specs_checker(const _Handler& _Handler_inst, const _Basic_format_arg_type _Arg_type_)
+        : _Handler(_Handler_inst), _Arg_type(_Arg_type_) {}
+
+    constexpr void _Require_numeric_argument() const {
+        if (!_Is_arithmetic_fmt_type(_Arg_type)) {
+            _Throw_format_error("Format specifier requires numeric argument.");
+        }
+    }
+
+    constexpr void _Require_numeric_or_pointer_argument() const {
+        if (!_Is_arithmetic_fmt_type(_Arg_type) && _Arg_type != _Basic_format_arg_type::_Pointer_type) {
+            _Throw_format_error("Format specifier requires numeric or pointer argument.");
+        }
+    }
+
+    constexpr void _Check_precision() const {
+        if (_Is_integral_fmt_type(_Arg_type) || _Arg_type == _Basic_format_arg_type::_Pointer_type) {
+            _Throw_format_error("Precision not allowed for this argument type.");
+        }
+    }
+
+    // _On_align has no checking, since we don't implement numeric alignments.
+
+    constexpr void _On_localized() {
+        _Require_numeric_argument();
+        _Handler::_On_localized();
+    }
+
+    constexpr void _On_hash() {
+        _Need_arithmetic_presentation_type = true;
+        _Require_numeric_argument();
+        _Handler::_On_hash();
+    }
+
+    constexpr void _On_sign(_Fmt_sign _Sgn) {
+        _Need_arithmetic_presentation_type = true;
+        _Require_numeric_argument();
+        _Handler::_On_sign(_Sgn);
+    }
+
+    constexpr void _On_zero() {
+        _Need_arithmetic_or_pointer_presentation_type = true;
+        _Require_numeric_or_pointer_argument();
+        _Handler::_On_zero();
+    }
+
+    constexpr void _On_precision(int _Precision) {
+        _Check_precision();
+        _Handler::_On_precision(_Precision);
+    }
+
+    template <class _Ty>
+    constexpr void _On_dynamic_precision(const _Ty _Val) {
+        _Check_precision();
+        _Handler::_On_dynamic_precision(_Val);
+    }
+
+    template <class _CharT>
+    constexpr void _On_type(_CharT _Type) {
+        if (_Type < 0 || _Type > _STD _Max_limit<signed char>()) {
+            _Throw_format_error("Invalid type specification.");
+        }
+        const char _Narrow_type = static_cast<char>(_Type);
+        enum class _Presentation_type_category {
+            _Default,
+            _Integer,
+            _Floating,
+            _String,
+            _Pointer,
+            _Char,
+#if _HAS_CXX23
+            _Escape,
+#endif // _HAS_CXX23
+        };
+        auto _Cat = _Presentation_type_category::_Default;
+        switch (_Narrow_type) {
+        case '\0':
+            break;
+#if _HAS_CXX23
+        case '?':
+            _Cat = _Presentation_type_category::_Escape;
+            break;
+#endif // _HAS_CXX23
+        case 's':
+            _Cat = _Presentation_type_category::_String;
+            break;
+        case 'c':
+            _Cat = _Presentation_type_category::_Char;
+            break;
+        case 'd':
+        case 'B':
+        case 'b':
+        case 'X':
+        case 'x':
+        case 'o':
+            _Cat = _Presentation_type_category::_Integer;
+            break;
+        case 'A':
+        case 'a':
+        case 'E':
+        case 'e':
+        case 'F':
+        case 'f':
+        case 'G':
+        case 'g':
+            _Cat = _Presentation_type_category::_Floating;
+            break;
+        case 'p':
+        case 'P':
+            _Cat = _Presentation_type_category::_Pointer;
+            break;
+        default:
+            _Throw_format_error("Invalid presentation type specifier");
+        }
+
+        switch (_Arg_type) {
+        case _Basic_format_arg_type::_None:
+            _STL_INTERNAL_CHECK(!"Invalid argument type.");
+            break;
+        case _Basic_format_arg_type::_Bool_type:
+            if (_Cat == _Presentation_type_category::_Default) {
+                _Cat = _Presentation_type_category::_String;
+            }
+            // note, we don't get a call if there isn't a type, but none is valid for everything.
+            if (_Cat != _Presentation_type_category::_String && _Cat != _Presentation_type_category::_Integer) {
+                _Throw_format_error("Invalid presentation type for bool");
+            }
+            break;
+        case _Basic_format_arg_type::_Char_type:
+            if (_Cat == _Presentation_type_category::_Default) {
+                _Cat = _Presentation_type_category::_Char;
+            }
+
+            if (_Cat != _Presentation_type_category::_Char && _Cat != _Presentation_type_category::_Integer
+#if _HAS_CXX23
+                && _Cat != _Presentation_type_category::_Escape
+#endif // _HAS_CXX23
+            ) {
+                if constexpr (is_same_v<_CharT, char>) {
+                    _Throw_format_error("Invalid presentation type for char");
+                } else {
+                    _Throw_format_error("Invalid presentation type for wchar_t");
+                }
+            }
+            break;
+        case _Basic_format_arg_type::_Int_type:
+        case _Basic_format_arg_type::_UInt_type:
+        case _Basic_format_arg_type::_Long_long_type:
+        case _Basic_format_arg_type::_ULong_long_type:
+            if (_Cat == _Presentation_type_category::_Default) {
+                _Cat = _Presentation_type_category::_Integer;
+            }
+
+            if (_Cat != _Presentation_type_category::_Integer && _Cat != _Presentation_type_category::_Char) {
+                _Throw_format_error("Invalid presentation type for integer");
+            }
+            break;
+        case _Basic_format_arg_type::_Float_type:
+        case _Basic_format_arg_type::_Double_type:
+        case _Basic_format_arg_type::_Long_double_type:
+            if (_Cat == _Presentation_type_category::_Default) {
+                _Cat = _Presentation_type_category::_Floating;
+            }
+
+            if (_Cat != _Presentation_type_category::_Floating) {
+                _Throw_format_error("Invalid presentation type for floating-point");
+            }
+            break;
+        case _Basic_format_arg_type::_CString_type:
+        case _Basic_format_arg_type::_String_type:
+            if (_Cat == _Presentation_type_category::_Default) {
+                _Cat = _Presentation_type_category::_String;
+            }
+
+            if (_Cat != _Presentation_type_category::_String
+#if _HAS_CXX23
+                && _Cat != _Presentation_type_category::_Escape
+#endif // _HAS_CXX23
+            ) {
+                _Throw_format_error("Invalid presentation type for string");
+            }
+            break;
+        case _Basic_format_arg_type::_Pointer_type:
+            if (_Cat == _Presentation_type_category::_Default) {
+                _Cat = _Presentation_type_category::_Pointer;
+            }
+
+            if (_Cat != _Presentation_type_category::_Pointer) {
+                _Throw_format_error("Invalid presentation type for pointer");
+            }
+            break;
+        case _Basic_format_arg_type::_Custom_type:
+            // there's no checking we can do here for custom types
+            // (however if a custom type uses a standard formatter
+            // to do its spec parsing it should get the above checks)
+            break;
+        }
+
+        if (_Need_arithmetic_presentation_type && _Cat != _Presentation_type_category::_Integer
+            && _Cat != _Presentation_type_category::_Floating) {
+            // N4971 [format.string.std]/5: "The sign option is only valid for arithmetic types
+            // other than charT and bool or when an integer presentation type is specified."
+            // N4971 [format.string.std]/7: "The # option [...] is valid for arithmetic types
+            // other than charT and bool or when an integer presentation type is specified, and not otherwise."
+            _Throw_format_error("Hash/sign modifier requires an arithmetic presentation type");
+        }
+
+        if (_Need_arithmetic_or_pointer_presentation_type && _Cat != _Presentation_type_category::_Integer
+            && _Cat != _Presentation_type_category::_Floating && _Cat != _Presentation_type_category::_Pointer) {
+            // N4971 [format.string.std]/8: "The 0 option is valid for arithmetic types
+            // other than charT and bool, pointer types, or when an integer presentation type is specified."
+            _Throw_format_error("Zero modifier requires an arithmetic or pointer presentation type");
+        }
+        _Handler::_On_type(_Type);
+    }
+};
+
+class _Fmt_fixed_buffer_traits {
+private:
+    ptrdiff_t _Count_ = 0;
+    ptrdiff_t _Limit_;
+
+public:
+    explicit _Fmt_fixed_buffer_traits(const ptrdiff_t _Limit) noexcept : _Limit_(_Limit) {}
+
+    _NODISCARD size_t _Count() const noexcept {
+        return static_cast<size_t>(_Count_);
+    }
+
+    _NODISCARD size_t _Limit(const size_t _Size) noexcept {
+        size_t _Avail = static_cast<size_t>(_Limit_ > _Count_ ? _Limit_ - _Count_ : 0);
+        _Count_ += _Size;
+        return _Size < _Avail ? _Size : _Avail;
+    }
+};
+
+template <class _Ty>
+class _Fmt_counting_buffer final : public _Fmt_buffer<_Ty> {
+private:
+    _Ty _Data[_Fmt_buffer_size];
+    size_t _Count_ = 0;
+
+    void _Grow(size_t) final {
+        if (this->_Size() != _Fmt_buffer_size) {
+            return;
+        }
+        _Count_ += this->_Size();
+        this->_Clear();
+    }
+
+public:
+    _Fmt_counting_buffer() : _Fmt_buffer<_Ty>(_Data, 0, _Fmt_buffer_size) {}
+
+    _NODISCARD size_t _Count() const noexcept {
+        return _Count_ + this->_Size();
+    }
+};
+
+template <class _CharT>
+using _Basic_fmt_it = back_insert_iterator<_Fmt_buffer<_CharT>>;
+
+using _Fmt_it  = _Basic_fmt_it<char>;
+using _Fmt_wit = _Basic_fmt_it<wchar_t>;
+
+template <class _CharT>
+using _Default_format_context = basic_format_context<_Basic_fmt_it<_CharT>, _CharT>;
+
+_EXPORT_STD using format_context  = _Default_format_context<char>;
+_EXPORT_STD using wformat_context = _Default_format_context<wchar_t>;
+
+_FMT_P2286_BEGIN
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, monostate) {
+    _STL_INTERNAL_CHECK(false);
+    return _Out;
+}
+
+// This size is derived from the maximum length of an arithmetic type. The contenders for widest are:
+// (a) long long has a max length of 20 characters: LLONG_MIN is "-9223372036854775807".
+// (b) unsigned long long has a max length of 20 characters: ULLONG_MAX is "18446744073709551615".
+// (c) double has a max length of 24 characters: -DBL_MAX is "-1.7976931348623158e+308".
+// That's 17 characters for numeric_limits<double>::max_digits10,
+// plus 1 character for the sign,
+// plus 1 character for the decimal point,
+// plus 1 character for 'e',
+// plus 1 character for the exponent's sign,
+// plus 3 characters for the max exponent.
+inline constexpr size_t _Format_min_buffer_length = 24;
+
+template <class _CharT, class _OutputIt, class _Arithmetic>
+    requires (is_arithmetic_v<_Arithmetic> && !_CharT_or_bool<_Arithmetic, _CharT>)
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, _Arithmetic _Value);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, bool _Value);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, _CharT _Value);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, const void* _Value);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, const _CharT* _Value);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, basic_string_view<_CharT> _Value);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Widen_and_copy(const char* _First, const char* const _Last, _OutputIt _Out) {
+    for (; _First != _Last; ++_First, (void) ++_Out) {
+        *_Out = static_cast<_CharT>(*_First);
+    }
+
+    return _Out;
+}
+
+template <class _CharT, class _OutputIt, class _Arithmetic>
+    requires (is_arithmetic_v<_Arithmetic> && !_CharT_or_bool<_Arithmetic, _CharT>)
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, const _Arithmetic _Value) {
+    // TRANSITION, Reusable buffer
+    char _Buffer[_Format_min_buffer_length];
+    char* _End = _Buffer;
+
+    if constexpr (is_floating_point_v<_Arithmetic>) {
+        if ((_STD isnan) (_Value)) {
+            if ((_STD signbit) (_Value)) {
+                *_End++ = '-';
+            }
+
+            _CSTD memcpy(_End, "nan", 3);
+            _End += 3;
+        }
+    }
+
+    if (_End == _Buffer) {
+        const to_chars_result _Result = _STD to_chars(_Buffer, _STD end(_Buffer), _Value);
+        _STL_INTERNAL_CHECK(_Result.ec == errc{});
+        _End = _Result.ptr;
+    }
+
+    return _Widen_and_copy<_CharT>(_Buffer, _End, _STD move(_Out));
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, const bool _Value) {
+    if constexpr (is_same_v<_CharT, wchar_t>) {
+        return _Fmt_write(_STD move(_Out), _Value ? L"true" : L"false");
+    } else {
+        return _Fmt_write(_STD move(_Out), _Value ? "true" : "false");
+    }
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, const _CharT _Value) {
+    *_Out++ = _Value;
+    return _Out;
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, const void* const _Value) {
+    // TRANSITION, Reusable buffer
+    char _Buffer[_Format_min_buffer_length];
+    const auto [_End, _Ec] = _STD to_chars(_Buffer, _STD end(_Buffer), reinterpret_cast<uintptr_t>(_Value), 16);
+    _STL_INTERNAL_CHECK(_Ec == errc{});
+    *_Out++ = '0';
+    *_Out++ = 'x';
+    return _Widen_and_copy<_CharT>(_Buffer, _End, _STD move(_Out));
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, const _CharT* _Value) {
+    if (!_Value) {
+        _Throw_format_error("String pointer is null.");
+    }
+
+    while (*_Value) {
+        *_Out++ = *_Value++;
+    }
+
+    return _Out;
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, const basic_string_view<_CharT> _Value) {
+    return _RANGES copy(_Value, _STD move(_Out)).out;
+}
+
+template <class _OutputIt, class _Specs_type, class _Func>
+_NODISCARD _OutputIt _Write_aligned(
+    _OutputIt _Out, const int _Width, const _Specs_type& _Specs, const _Fmt_align _Default_align, _Func&& _Fn) {
+    int _Fill_left  = 0;
+    int _Fill_right = 0;
+    auto _Alignment = _Specs._Alignment;
+
+    if (_Alignment == _Fmt_align::_None) {
+        _Alignment = _Default_align;
+    }
+
+    if (_Width < _Specs._Width) {
+        switch (_Alignment) {
+        case _Fmt_align::_Left:
+            _Fill_right = _Specs._Width - _Width;
+            break;
+        case _Fmt_align::_Right:
+            _Fill_left = _Specs._Width - _Width;
+            break;
+        case _Fmt_align::_Center:
+            _Fill_left  = (_Specs._Width - _Width) / 2;
+            _Fill_right = _Specs._Width - _Width - _Fill_left;
+            break;
+        case _Fmt_align::_None:
+            _STL_ASSERT(false, "Invalid alignment");
+            break;
+        }
+    }
+
+    const basic_string_view _Fill_char{_Specs._Fill, _Specs._Fill_length};
+    for (; _Fill_left > 0; --_Fill_left) {
+        _Out = _RANGES copy(_Fill_char, _STD move(_Out)).out;
+    }
+
+    _Out = _Fn(_STD move(_Out));
+
+    for (; _Fill_right > 0; --_Fill_right) {
+        _Out = _RANGES copy(_Fill_char, _STD move(_Out)).out;
+    }
+
+    return _Out;
+}
+
+template <integral _Integral>
+_NODISCARD constexpr string_view _Get_integral_prefix(const char _Type, const _Integral _Value) noexcept {
+    switch (_Type) {
+    case 'b':
+        return "0b"sv;
+    case 'B':
+        return "0B"sv;
+    case 'x':
+        return "0x"sv;
+    case 'X':
+        return "0X"sv;
+    case 'o':
+        if (_Value != _Integral{0}) {
+            return "0"sv;
+        }
+        return {};
+    default:
+        return {};
+    }
+}
+
+template <class _OutputIt>
+_NODISCARD _OutputIt _Write_sign(_OutputIt _Out, const _Fmt_sign _Sgn, const bool _Is_negative) {
+    if (_Is_negative) {
+        *_Out++ = '-';
+    } else {
+        switch (_Sgn) {
+        case _Fmt_sign::_Plus:
+            *_Out++ = '+';
+            break;
+        case _Fmt_sign::_Space:
+            *_Out++ = ' ';
+            break;
+        case _Fmt_sign::_None:
+        case _Fmt_sign::_Minus:
+            break;
+        }
+    }
+    return _Out;
+}
+
+inline void _Buffer_to_uppercase(char* _First, const char* _Last) noexcept {
+    for (; _First != _Last; ++_First) {
+        if (*_First >= 'a' && *_First <= 'z') {
+            *_First -= 'a' - 'A';
+        }
+    }
+}
+
+template <class _Ty>
+using _Make_standard_integer = conditional_t<is_signed_v<_Ty>, make_signed_t<_Ty>, make_unsigned_t<_Ty>>;
+
+template <class _CharT, integral _Ty>
+_NODISCARD constexpr bool _In_bounds(const _Ty _Value) {
+    return _STD in_range<_Make_standard_integer<_CharT>>(static_cast<_Make_standard_integer<_Ty>>(_Value));
+}
+
+_NODISCARD inline int _Count_separators(size_t _Digits, const string_view _Groups) {
+    if (_Groups.empty()) {
+        return 0;
+    }
+
+    // Calculate the amount of separators that are going to be inserted based on the groupings of the locale.
+    int _Separators = 0;
+    auto _Group_it  = _Groups.begin();
+    while (_Digits > static_cast<size_t>(*_Group_it)) {
+        _Digits -= static_cast<size_t>(*_Group_it);
+        ++_Separators;
+        if (_Group_it + 1 != _Groups.end()) {
+            ++_Group_it;
+        }
+    }
+
+    return _Separators;
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Write_separated_integer(const char* _First, const char* const _Last, const string_view _Groups,
+    const _CharT _Separator, int _Separators, _OutputIt _Out) {
+    auto _Group_it = _Groups.begin();
+    auto _Repeats  = 0;
+    auto _Grouped  = 0;
+
+    for (int _Section = 0; _Section < _Separators; ++_Section) {
+        _Grouped += *_Group_it;
+        if (_Group_it + 1 != _Groups.end()) {
+            ++_Group_it;
+        } else {
+            ++_Repeats;
+        }
+    }
+    _Out   = _Widen_and_copy<_CharT>(_First, _Last - _Grouped, _STD move(_Out));
+    _First = _Last - _Grouped;
+
+    for (; _Separators > 0; --_Separators) {
+        if (_Repeats > 0) {
+            --_Repeats;
+        } else {
+            --_Group_it;
+        }
+
+        *_Out++ = _Separator;
+        _Out    = _Widen_and_copy<_CharT>(_First, _First + *_Group_it, _STD move(_Out));
+        _First += *_Group_it;
+    }
+    _STL_INTERNAL_CHECK(_First == _Last);
+    return _Out;
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, monostate, const _Basic_format_specs<_CharT>&, _Lazy_locale) {
+    _STL_INTERNAL_CHECK(false);
+    return _Out;
+}
+
+template <class _CharT, class _OutputIt, integral _Integral>
+_NODISCARD _OutputIt _Write_integral(
+    _OutputIt _Out, _Integral _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale);
+
+#if _HAS_CXX23
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Write_escaped(
+    _OutputIt _Out, basic_string_view<_CharT> _Value, _Basic_format_specs<_CharT> _Specs, char _Delim);
+#endif // _HAS_CXX23
+
+template <class _CharT, class _OutputIt, integral _Integral>
+    requires (!_CharT_or_bool<_Integral, _CharT>)
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, _Integral _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(_OutputIt _Out, bool _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, _CharT _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale);
+
+template <class _CharT, class _OutputIt, floating_point _Float>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, _Float _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const void* _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const _CharT* _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale);
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, basic_string_view<_CharT> _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale);
+
+template <class _CharT, class _OutputIt, integral _Integral>
+_NODISCARD _OutputIt _Write_integral(
+    _OutputIt _Out, const _Integral _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale) {
+    if (_Specs._Type == 'c') {
+        if (!_In_bounds<_CharT>(_Value)) {
+            if constexpr (is_same_v<_CharT, char>) {
+                _Throw_format_error("integral cannot be stored in char");
+            } else {
+                _Throw_format_error("integral cannot be stored in wchar_t");
+            }
+        }
+        _Specs._Alt = false;
+        return _Fmt_write(_STD move(_Out), static_cast<_CharT>(_Value), _Specs, _Locale);
+    }
+
+    _STL_INTERNAL_CHECK(_Specs._Precision == -1);
+
+    if (_Specs._Sgn == _Fmt_sign::_None) {
+        _Specs._Sgn = _Fmt_sign::_Minus;
+    }
+
+    int _Base = 10;
+
+    switch (_Specs._Type) {
+    case 'B':
+    case 'b':
+        _Base = 2;
+        break;
+    case 'X':
+    case 'x':
+        _Base = 16;
+        break;
+    case 'o':
+        _Base = 8;
+        break;
+    default:
+        break;
+    }
+
+    // long long -1 representation in binary is 64 bits + sign
+    char _Buffer[65];
+    const auto [_End, _Ec] = _STD to_chars(_Buffer, _STD end(_Buffer), _Value, _Base);
+    _STL_INTERNAL_CHECK(_Ec == errc{});
+
+    auto _Buffer_start = _Buffer;
+    auto _Width        = static_cast<int>(_End - _Buffer_start);
+
+    bool _Negative = false;
+    if constexpr (signed_integral<_Integral>) {
+        _Negative = _Value < _Integral{0};
+    }
+
+    if (_Negative) {
+        // Remove the '-', it will be dealt with directly
+        _Buffer_start += 1;
+    } else if (_Specs._Sgn != _Fmt_sign::_Minus) {
+        _Width += 1;
+    }
+
+    if (_Specs._Type == 'X') {
+        _Buffer_to_uppercase(_Buffer_start, _End);
+    }
+
+    string_view _Prefix;
+    if (_Specs._Alt) {
+        _Prefix = _Get_integral_prefix(_Specs._Type, _Value);
+        _Width += static_cast<int>(_Prefix.size());
+    }
+
+    auto _Separators = 0;
+    string _Groups;
+    if (_Specs._Localized) {
+        _Groups     = _STD use_facet<numpunct<_CharT>>(_Locale._Get()).grouping();
+        _Separators = _Count_separators(static_cast<size_t>(_End - _Buffer_start), _Groups);
+        // TRANSITION, separators may be wider for wide chars
+        _Width += _Separators;
+    }
+
+    const bool _Write_leading_zeroes = _Specs._Leading_zero && _Specs._Alignment == _Fmt_align::_None;
+    auto _Writer                     = [&, _End = _End](_OutputIt _Out) {
+        if constexpr (signed_integral<_Integral>) {
+            _Out = _Write_sign(_STD move(_Out), _Specs._Sgn, _Value < _Integral{0});
+        } else {
+            _Out = _Write_sign(_STD move(_Out), _Specs._Sgn, false);
+        }
+        _Out = _Widen_and_copy<_CharT>(_Prefix.data(), _Prefix.data() + _Prefix.size(), _STD move(_Out));
+        if (_Write_leading_zeroes && _Width < _Specs._Width) {
+            _Out = _RANGES fill_n(_STD move(_Out), _Specs._Width - _Width, _CharT{'0'});
+        }
+
+        if (_Separators > 0) {
+            return _Write_separated_integer(_Buffer_start, _End, _Groups,
+                _STD use_facet<numpunct<_CharT>>(_Locale._Get()).thousands_sep(), _Separators, _STD move(_Out));
+        }
+        return _Widen_and_copy<_CharT>(_Buffer_start, _End, _STD move(_Out));
+    };
+
+    if (_Write_leading_zeroes) {
+        return _Writer(_STD move(_Out));
+    }
+
+    return _Write_aligned(_STD move(_Out), _Width, _Specs, _Fmt_align::_Right, _Writer);
+}
+
+template <class _CharT, class _OutputIt, integral _Integral>
+    requires (!_CharT_or_bool<_Integral, _CharT>)
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const _Integral _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale) {
+    return _Write_integral(_STD move(_Out), _Value, _Specs, _Locale);
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const bool _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale) {
+    if (_Specs._Type != '\0' && _Specs._Type != 's') {
+        return _Write_integral(_STD move(_Out), static_cast<unsigned char>(_Value), _Specs, _Locale);
+    }
+
+    _STL_INTERNAL_CHECK(_Specs._Precision == -1);
+
+    if (_Specs._Localized) {
+        _Specs._Localized  = false;
+        const auto& _Facet = _STD use_facet<numpunct<_CharT>>(_Locale._Get());
+        return _Fmt_write(_STD move(_Out),
+            _Value ? static_cast<basic_string_view<_CharT>>(_Facet.truename())
+                   : static_cast<basic_string_view<_CharT>>(_Facet.falsename()),
+            _Specs, _Locale);
+    }
+
+    if constexpr (is_same_v<_CharT, wchar_t>) {
+        return _Fmt_write(_STD move(_Out), _Value ? L"true" : L"false", _Specs, _Locale);
+    } else {
+        return _Fmt_write(_STD move(_Out), _Value ? "true" : "false", _Specs, _Locale);
+    }
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const _CharT _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale) {
+    if (_Specs._Type != '\0' && _Specs._Type != 'c'
+#if _HAS_CXX23
+        && _Specs._Type != '?'
+#endif // _HAS_CXX23
+    ) {
+        return _Write_integral(_STD move(_Out), static_cast<make_unsigned_t<_CharT>>(_Value), _Specs, _Locale);
+    }
+
+    _STL_INTERNAL_CHECK(_Specs._Precision == -1);
+
+#if _HAS_CXX23
+    if (_Specs._Type == '?') {
+        return _Write_escaped(_STD move(_Out), basic_string_view<_CharT>{&_Value, 1}, _Specs, '\'');
+    }
+#endif // _HAS_CXX23
+
+    return _Fmt_write(_STD move(_Out), basic_string_view<_CharT>{&_Value, 1}, _Specs, _Locale);
+}
+
+template <class _CharT, class _OutputIt, floating_point _Float>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const _Float _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale) {
+    auto _Sgn = _Specs._Sgn;
+    if (_Sgn == _Fmt_sign::_None) {
+        _Sgn = _Fmt_sign::_Minus;
+    }
+
+    auto _To_upper  = false;
+    auto _Format    = chars_format::general;
+    auto _Exponent  = 'e';
+    auto _Precision = _Specs._Precision;
+    auto _None_type = false;
+
+    switch (_Specs._Type) {
+    case 'A':
+        _To_upper = true;
+        [[fallthrough]];
+    case 'a':
+        _Format   = chars_format::hex;
+        _Exponent = 'p';
+        break;
+    case 'E':
+        _To_upper = true;
+        [[fallthrough]];
+    case 'e':
+        if (_Precision == -1) {
+            _Precision = 6;
+        }
+        _Format = chars_format::scientific;
+        break;
+    case 'F':
+        _To_upper = true;
+        [[fallthrough]];
+    case 'f':
+        if (_Precision == -1) {
+            _Precision = 6;
+        }
+        _Format = chars_format::fixed;
+        break;
+    case 'G':
+        _To_upper = true;
+        [[fallthrough]];
+    case 'g':
+        if (_Precision == -1) {
+            _Precision = 6;
+        } else if (_Precision == 0) {
+            _Precision = 1;
+        }
+        _Format = chars_format::general;
+        break;
+    default:
+        _None_type = true;
+        break;
+    }
+
+    // Consider the powers of 2 in decimal:
+    // 2^-1 = 0.5
+    // 2^-2 = 0.25
+    // 2^-3 = 0.125
+    // 2^-4 = 0.0625
+    // Each power of 2 consumes one more decimal digit. This is because:
+    // 2^-N * 5^-N = 10^-N
+    // 2^-N = 10^-N * 5^N
+    // Example: 2^-4 = 10^-4 * 5^4 = 0.0001 * 625
+    // Therefore, the min subnormal 2^-1074 consumes 1074 digits of precision (digits after the decimal point).
+    // We need 3 more characters for a potential negative sign, the zero integer part, and the decimal point.
+    // Therefore, the precision can be clamped to 1074.
+    // The largest number consumes 309 digits before the decimal point. With a precision of 1074, and it being
+    // negative, it would use a buffer of size 1074+309+2. We need to add an additional number to the max
+    // exponent to accommodate the ones place.
+    constexpr auto _Max_precision = 1074;
+    constexpr auto _Buffer_size   = _Max_precision + DBL_MAX_10_EXP + 3;
+    char _Buffer[_Buffer_size];
+    to_chars_result _Result;
+
+    auto _Extra_precision = 0;
+    if (_Precision > _Max_precision) {
+        _Extra_precision = _Precision - _Max_precision;
+        _Precision       = _Max_precision;
+    }
+
+    const auto _Is_negative = (_STD signbit) (_Value);
+
+    if ((_STD isnan) (_Value)) {
+        _Result.ptr = _Buffer;
+        if (_Is_negative) {
+            ++_Result.ptr; // pretend to skip over a '-' that to_chars would put in _Buffer[0]
+        }
+
+        _CSTD memcpy(_Result.ptr, "nan", 3);
+        _Result.ptr += 3;
+    } else {
+        if (_Precision == -1) {
+            if (_None_type) {
+                _Result = _STD to_chars(_Buffer, _STD end(_Buffer), _Value);
+            } else {
+                _Result = _STD to_chars(_Buffer, _STD end(_Buffer), _Value, _Format);
+            }
+        } else {
+            _Result = _STD to_chars(_Buffer, _STD end(_Buffer), _Value, _Format, _Precision);
+        }
+
+        _STL_INTERNAL_CHECK(_Result.ec == errc{});
+    }
+
+    auto _Buffer_start = _Buffer;
+    auto _Width        = static_cast<int>(_Result.ptr - _Buffer_start);
+
+    if (_Is_negative) {
+        // Remove the '-', it will be dealt with directly
+        _Buffer_start += 1;
+    } else {
+        if (_Sgn != _Fmt_sign::_Minus) {
+            _Width += 1;
+        }
+    }
+
+    _STL_INTERNAL_CHECK(_Exponent == 'e' || _Exponent == 'p');
+    if (_To_upper) {
+        _Buffer_to_uppercase(_Buffer_start, _Result.ptr);
+        _Exponent -= 'a' - 'A';
+    }
+
+    const auto _Is_finite = (_STD isfinite) (_Value);
+
+    auto _Append_decimal   = false;
+    auto _Exponent_start   = _Result.ptr;
+    auto _Radix_point      = _Result.ptr;
+    auto _Integral_end     = _Result.ptr;
+    auto _Zeroes_to_append = 0;
+    auto _Separators       = 0;
+    string _Groups;
+
+    if (_Is_finite) {
+        if (_Specs._Alt || _Specs._Localized) {
+            for (auto _It = _Buffer_start; _It < _Result.ptr; ++_It) {
+                if (*_It == '.') {
+                    _Radix_point = _It;
+                } else if (*_It == _Exponent) {
+                    _Exponent_start = _It;
+                }
+            }
+            _Integral_end = (_STD min) (_Radix_point, _Exponent_start);
+
+            if (_Specs._Alt && _Radix_point == _Result.ptr) {
+                // TRANSITION, decimal point may be wider
+                ++_Width;
+                _Append_decimal = true;
+            }
+
+            if (_Specs._Localized) {
+                _Groups     = _STD use_facet<numpunct<_CharT>>(_Locale._Get()).grouping();
+                _Separators = _Count_separators(static_cast<size_t>(_Integral_end - _Buffer_start), _Groups);
+                _Width += _Separators;
+            }
+        }
+
+        switch (_Format) {
+        case chars_format::hex:
+        case chars_format::scientific:
+            if (_Extra_precision != 0 && !_Specs._Alt && !_Specs._Localized) {
+                // Trailing zeroes are in front of the exponent
+                while (*--_Exponent_start != _Exponent) {
+                }
+            }
+            [[fallthrough]];
+        case chars_format::fixed:
+            _Zeroes_to_append = _Extra_precision;
+            break;
+        case chars_format::general:
+            if (_Specs._Alt && (_Specs._Type == 'g' || _Specs._Type == 'G')) {
+                auto _Digits = static_cast<int>(_Exponent_start - _Buffer_start);
+
+                if (!_Append_decimal) {
+                    --_Digits;
+                }
+
+                _Zeroes_to_append = _Extra_precision + _Precision - _Digits;
+
+                // Leading zeroes are not significant if we used fixed point notation.
+                if (_Exponent_start == _Result.ptr && _STD abs(_Value) < 1.0 && _Value != 0.0) {
+                    for (auto _It = _Buffer_start; _It < _Result.ptr; ++_It) {
+                        if (*_It == '0') {
+                            ++_Zeroes_to_append;
+                        } else if (*_It != '.') {
+                            break;
+                        }
+                    }
+                }
+            }
+            break;
+        default:
+            _STL_UNREACHABLE;
+        }
+    }
+
+    _Width += _Zeroes_to_append;
+
+    const bool _Write_leading_zeroes = _Specs._Leading_zero && _Specs._Alignment == _Fmt_align::_None && _Is_finite;
+
+    auto _Writer = [&](_OutputIt _Out) {
+        _Out = _Write_sign(_STD move(_Out), _Sgn, _Is_negative);
+
+        if (_Write_leading_zeroes && _Width < _Specs._Width) {
+            _Out = _RANGES fill_n(_STD move(_Out), _Specs._Width - _Width, _CharT{'0'});
+        }
+
+        if (_Specs._Localized) {
+            const auto& _Facet = _STD use_facet<numpunct<_CharT>>(_Locale._Get());
+
+            _Out = _Write_separated_integer(
+                _Buffer_start, _Integral_end, _Groups, _Facet.thousands_sep(), _Separators, _STD move(_Out));
+            if (_Radix_point != _Result.ptr || _Append_decimal) {
+                *_Out++         = _Facet.decimal_point();
+                _Append_decimal = false;
+            }
+            _Buffer_start = _Integral_end;
+            if (_Radix_point != _Result.ptr) {
+                ++_Buffer_start;
+            }
+        }
+
+        _Out = _Widen_and_copy<_CharT>(_Buffer_start, _Exponent_start, _STD move(_Out));
+        if (_Specs._Alt && _Append_decimal) {
+            *_Out++ = '.';
+        }
+
+        for (; _Zeroes_to_append > 0; --_Zeroes_to_append) {
+            *_Out++ = '0';
+        }
+
+        return _Widen_and_copy<_CharT>(_Exponent_start, _Result.ptr, _STD move(_Out));
+    };
+
+    if (_Write_leading_zeroes) {
+        return _Writer(_STD move(_Out));
+    }
+
+    return _Write_aligned(_STD move(_Out), _Width, _Specs, _Fmt_align::_Right, _Writer);
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const void* const _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale) {
+    _STL_INTERNAL_CHECK(_Specs._Type == '\0' || _Specs._Type == 'p' || _Specs._Type == 'P');
+    _STL_INTERNAL_CHECK(_Specs._Sgn == _Fmt_sign::_None);
+    _STL_INTERNAL_CHECK(!_Specs._Alt);
+    _STL_INTERNAL_CHECK(_Specs._Precision == -1);
+    _STL_INTERNAL_CHECK(!_Specs._Localized);
+
+    char _Buffer[2 * sizeof(void*)]; // 2 hexits per byte: 8 hexits for 32-bit, 16 hexits for 64-bit
+    const auto [_End, _Ec] = _STD to_chars(_Buffer, _STD end(_Buffer), reinterpret_cast<uintptr_t>(_Value), 16);
+    _STL_INTERNAL_CHECK(_Ec == errc{});
+    const int _Width = 2 + static_cast<int>(_End - _Buffer);
+
+    _CharT _Prefix[2] = {_CharT{'0'}, _CharT{'x'}};
+    if (_Specs._Type == 'P') {
+        _Prefix[1] = _CharT{'X'};
+        _Buffer_to_uppercase(_Buffer, _End);
+    }
+
+    const bool _Write_leading_zeroes = _Specs._Leading_zero && _Specs._Alignment == _Fmt_align::_None;
+    auto _Writer                     = [&](_OutputIt _Out) {
+        _Out = _RANGES copy(_Prefix, _Prefix + 2, _STD move(_Out)).out;
+        if (_Write_leading_zeroes && _Width < _Specs._Width) {
+            _Out = _RANGES fill_n(_STD move(_Out), _Specs._Width - _Width, _CharT{'0'});
+        }
+        return _STD _Widen_and_copy<_CharT>(_Buffer, _End, _STD move(_Out));
+    };
+
+    if (_Write_leading_zeroes) {
+        return _Writer(_STD move(_Out));
+    }
+
+    return _STD _Write_aligned(_STD move(_Out), _Width, _Specs, _Fmt_align::_Right, _Writer);
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const _CharT* _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale) {
+    return _Fmt_write(_STD move(_Out), basic_string_view<_CharT>{_Value}, _Specs, _Locale);
+}
+
+// width iterator for UTF-8 and UTF-16
+template <class _CharT>
+class _Measure_string_prefix_iterator_utf2 {
+private:
+    _Grapheme_break_property_iterator2<_CharT> _WrappedIter;
+
+public:
+    using value_type      = int;
+    using difference_type = ptrdiff_t;
+
+    _NODISCARD constexpr bool operator==(const _Measure_string_prefix_iterator_utf2&) const noexcept = default;
+
+    _NODISCARD constexpr bool operator==(default_sentinel_t) const noexcept {
+        return _WrappedIter == default_sentinel;
+    }
+
+    constexpr _Measure_string_prefix_iterator_utf2(const _CharT* _First, const _CharT* _Last)
+        : _WrappedIter(_First, _Last) {}
+
+    constexpr _Measure_string_prefix_iterator_utf2() = default;
+
+    _NODISCARD constexpr value_type operator*() const {
+        return _Unicode_width_estimate(*_WrappedIter);
+    }
+
+    constexpr _Measure_string_prefix_iterator_utf2& operator++() noexcept {
+        ++_WrappedIter;
+        return *this;
+    }
+
+    constexpr _Measure_string_prefix_iterator_utf2 operator++(int) noexcept {
+        auto _Old = *this;
+        ++*this;
+        return _Old;
+    }
+
+    _NODISCARD constexpr const _CharT* _Position() const {
+        return _WrappedIter._Position();
+    }
+};
+
+class _Measure_string_prefix_iterator_legacy {
+private:
+    _Fmt_codec<char> _Codec = _Get_fmt_codec<char>();
+    const char* _First      = nullptr;
+    const char* _Last       = nullptr;
+    int _Units              = 0;
+
+    void _Update_units() {
+        if (_First < _Last) {
+            _Units = _Codec._Units_in_next_character(_First, _Last);
+        } else {
+            _Units = -1;
+        }
+    }
+
+public:
+    using value_type      = int;
+    using difference_type = ptrdiff_t;
+
+    _NODISCARD bool operator==(default_sentinel_t) const noexcept {
+        return _First == _Last;
+    }
+    _NODISCARD bool operator==(const _Measure_string_prefix_iterator_legacy& _Rhs) const noexcept {
+        return _First == _Rhs._First && _Last == _Rhs._Last;
+    }
+
+    _Measure_string_prefix_iterator_legacy(const char* _First_val, const char* _Last_val)
+        : _First(_First_val), _Last(_Last_val) {
+        _Update_units();
+    }
+
+    _Measure_string_prefix_iterator_legacy() = default;
+
+    _Measure_string_prefix_iterator_legacy& operator++() noexcept {
+        _First += _Units;
+        _Update_units();
+        return *this;
+    }
+    _Measure_string_prefix_iterator_legacy operator++(int) noexcept {
+        auto _Old = *this;
+        ++*this;
+        return _Old;
+    }
+    _NODISCARD value_type operator*() const noexcept {
+        return _Units;
+    }
+
+    _NODISCARD const char* _Position() const noexcept {
+        return _First;
+    }
+};
+
+template <class _CharT>
+using _Measure_string_prefix_iterator =
+    conditional_t<is_same_v<_CharT, char> && !_Is_execution_charset_self_synchronizing(),
+        _Measure_string_prefix_iterator_legacy, _Measure_string_prefix_iterator_utf2<_CharT>>;
+
+template <class _CharT>
+_NODISCARD const _CharT* _Measure_string_prefix(const basic_string_view<_CharT> _Value, int& _Width) {
+    // Returns a pointer past-the-end of the largest prefix of _Value that fits in _Width, or all
+    // of _Value if _Width is negative. Updates _Width to the estimated width of that prefix.
+    const int _Max_width = _Width;
+    const auto _First    = _Value.data();
+    const auto _Last     = _First + _Value.size();
+    _Measure_string_prefix_iterator<_CharT> _Pfx_iter(_First, _Last);
+    int _Estimated_width = 0; // the estimated width of [_First, _Pfx_iter)
+
+    constexpr auto _Max_int = _STD _Max_limit<int>();
+
+    while (_Pfx_iter != default_sentinel) {
+        if (_Estimated_width == _Max_width && _Max_width >= 0) {
+            // We're at our maximum length
+            break;
+        }
+
+        const int _Character_width = *_Pfx_iter;
+
+        if (_Max_int - _Character_width < _Estimated_width) { // avoid overflow
+            // Either _Max_width isn't set, or adding this character will exceed it.
+            if (_Max_width < 0) { // unset; saturate width estimate and take all characters
+                _Width = _Max_int;
+                return _Last;
+            }
+            break;
+        }
+
+        _Estimated_width += _Character_width;
+        if (_Estimated_width > _Max_width && _Max_width >= 0) {
+            // with this character, we exceed the maximum length
+            _Estimated_width -= _Character_width;
+            break;
+        }
+        ++_Pfx_iter;
+    }
+
+    _Width = _Estimated_width;
+    return _Pfx_iter._Position();
+}
+
+#if _HAS_CXX23
+_NODISCARD constexpr bool _Is_printable(char32_t _Val) {
+    return __printable_property_data._Get_property_for_codepoint(_Val) == __printable_property_values::_Yes_value;
+}
+
+_NODISCARD constexpr bool _Is_grapheme_extend(char32_t _Val) {
+    // TRANSITION, should reuse _Grapheme_Break_property_data to save space.
+    // (Grapheme_Extend=Yes is Grapheme_Cluster_Break=Extend minus Emoji_Modifier=Yes.)
+    return _Grapheme_Extend_property_data._Get_property_for_codepoint(_Val)
+        == _Grapheme_Extend_property_values::_Grapheme_Extend_value;
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Write_escaped(_OutputIt _Out, basic_string_view<_CharT> _Value, char _Delim) {
+    auto _First        = _Value.data();
+    const auto _Last   = _First + _Value.size();
+    const auto& _Codec = _Get_fmt_codec<_CharT>();
+
+    _STL_INTERNAL_CHECK(_Delim == '"' || _Delim == '\'');
+    *_Out++ = static_cast<_CharT>(_Delim);
+
+    bool _Escape_grapheme_extend = true;
+
+    char _Buffer[8];
+
+    while (_First != _Last) {
+        const auto _Ch = *_First;
+
+        if (_Ch == static_cast<_CharT>('\t')) {
+            _Out                    = _Fmt_write(_STD move(_Out), _STATICALLY_WIDEN(_CharT, R"(\t)"));
+            _Escape_grapheme_extend = true;
+            ++_First;
+        } else if (_Ch == static_cast<_CharT>('\n')) {
+            _Out                    = _Fmt_write(_STD move(_Out), _STATICALLY_WIDEN(_CharT, R"(\n)"));
+            _Escape_grapheme_extend = true;
+            ++_First;
+        } else if (_Ch == static_cast<_CharT>('\r')) {
+            _Out                    = _Fmt_write(_STD move(_Out), _STATICALLY_WIDEN(_CharT, R"(\r)"));
+            _Escape_grapheme_extend = true;
+            ++_First;
+        } else if (_Ch == static_cast<_CharT>(_Delim)) {
+            *_Out++                 = static_cast<_CharT>('\\');
+            *_Out++                 = static_cast<_CharT>(_Delim);
+            _Escape_grapheme_extend = true;
+            ++_First;
+        } else if (_Ch == static_cast<_CharT>('\\')) {
+            _Out                    = _Fmt_write(_STD move(_Out), _STATICALLY_WIDEN(_CharT, R"(\\)"));
+            _Escape_grapheme_extend = true;
+            ++_First;
+        } else {
+            char32_t _Decoded_ch;
+            const auto [_Next, _Is_usv] = _Codec._Decode(_First, _Last, _Decoded_ch);
+
+            if (_Is_usv) {
+                const bool _Needs_escape =
+                    !_Is_printable(_Decoded_ch) || (_Escape_grapheme_extend && _Is_grapheme_extend(_Decoded_ch));
+
+                if (_Needs_escape) {
+                    _Out = _Fmt_write(_STD move(_Out), _STATICALLY_WIDEN(_CharT, R"(\u{)"));
+
+                    const auto [_End, _Ec] =
+                        _STD to_chars(_Buffer, _STD end(_Buffer), static_cast<uint32_t>(_Decoded_ch), 16);
+                    _STL_INTERNAL_CHECK(_Ec == errc{});
+
+                    _Out = _Widen_and_copy<_CharT>(_Buffer, _End, _STD move(_Out));
+
+                    *_Out++                 = static_cast<_CharT>('}');
+                    _Escape_grapheme_extend = true;
+                } else {
+                    _Out                    = _STD _Copy_unchecked(_First, _Next, _STD move(_Out));
+                    _Escape_grapheme_extend = false;
+                }
+
+                _First = _Next;
+            } else {
+                for (; _First != _Next; ++_First) {
+                    _Out = _Fmt_write(_STD move(_Out), _STATICALLY_WIDEN(_CharT, R"(\x{)"));
+
+                    const auto [_End, _Ec] =
+                        _STD to_chars(_Buffer, _STD end(_Buffer), static_cast<make_unsigned_t<_CharT>>(*_First), 16);
+                    _STL_INTERNAL_CHECK(_Ec == errc{});
+
+                    _Out = _Widen_and_copy<_CharT>(_Buffer, _End, _STD move(_Out));
+
+                    *_Out++ = static_cast<_CharT>('}');
+                }
+                _Escape_grapheme_extend = true;
+            }
+        }
+    }
+
+    *_Out++ = static_cast<_CharT>(_Delim);
+
+    return _STD move(_Out);
+}
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Write_escaped(
+    _OutputIt _Out, basic_string_view<_CharT> _Value, _Basic_format_specs<_CharT> _Specs, char _Delim) {
+    if (_Specs._Precision < 0 && _Specs._Width <= 0) {
+        return _Write_escaped(_STD move(_Out), _Value, _Delim);
+    }
+
+    basic_string<_CharT> _Temp;
+    {
+        _Fmt_iterator_buffer<back_insert_iterator<basic_string<_CharT>>, _CharT> _Buf(back_insert_iterator{_Temp});
+        (void) _Write_escaped(back_insert_iterator<_Fmt_buffer<_CharT>>{_Buf}, _Value, _Delim);
+    }
+
+    int _Width          = _Specs._Precision;
+    const _CharT* _Last = _Measure_string_prefix<_CharT>(_Temp, _Width);
+
+    return _Write_aligned(_STD move(_Out), _Width, _Specs, _Fmt_align::_Left, [&_Temp, _Last](_OutputIt _Out) {
+        return _Fmt_write(_STD move(_Out), basic_string_view<_CharT>{_Temp.data(), _Last});
+    });
+}
+#endif // _HAS_CXX23
+
+template <class _CharT, class _OutputIt>
+_NODISCARD _OutputIt _Fmt_write(
+    _OutputIt _Out, const basic_string_view<_CharT> _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale) {
+    _STL_INTERNAL_CHECK(_Specs._Type == '\0' || _Specs._Type == 'c' || _Specs._Type == 's' || _Specs._Type == '?');
+    _STL_INTERNAL_CHECK(_Specs._Sgn == _Fmt_sign::_None);
+    _STL_INTERNAL_CHECK(!_Specs._Alt);
+    _STL_INTERNAL_CHECK(!_Specs._Leading_zero);
+
+#if _HAS_CXX23
+    if (_Specs._Type == '?') {
+        return _Write_escaped(_STD move(_Out), _Value, _Specs, '"');
+    }
+#endif // _HAS_CXX23
+
+    if (_Specs._Precision < 0 && _Specs._Width <= 0) {
+        return _Fmt_write(_STD move(_Out), _Value);
+    }
+
+    int _Width          = _Specs._Precision;
+    const _CharT* _Last = _Measure_string_prefix(_Value, _Width);
+
+    return _Write_aligned(_STD move(_Out), _Width, _Specs, _Fmt_align::_Left,
+        [=](_OutputIt _Out) { return _Fmt_write(_STD move(_Out), basic_string_view<_CharT>{_Value.data(), _Last}); });
+}
+
+// This is the visitor that's used for "simple" replacement fields.
+// It could be a generic lambda, but that's bad for throughput.
+// A simple replacement field is a replacement field that's just "{}",
+// without any format specs.
+template <class _OutputIt, class _CharT>
+struct _Default_arg_formatter {
+    using _Context = basic_format_context<_OutputIt, _CharT>;
+
+    _OutputIt _Out;
+    basic_format_args<_Context> _Args;
+    _Lazy_locale _Loc;
+    basic_format_parse_context<_CharT>& _Parse_ctx;
+
+    template <class _Ty>
+    _OutputIt operator()(_Ty _Val) && {
+        return _Fmt_write<_CharT>(_STD move(_Out), _Val);
+    }
+
+    _OutputIt operator()(basic_format_arg<_Context>::handle _Handle) && {
+        auto _Format_ctx = _Context::_Make_from(_STD move(_Out), _Args, _Loc);
+        _Handle.format(_Parse_ctx, _Format_ctx);
+        return _Format_ctx.out();
+    }
+};
+
+// Visitor used for replacement fields that contain specs
+template <class _OutputIt, class _CharT>
+struct _Arg_formatter {
+    using _Context = basic_format_context<_OutputIt, _CharT>;
+
+    _Context* _Ctx                      = nullptr;
+    _Basic_format_specs<_CharT>* _Specs = nullptr;
+
+    _OutputIt operator()(basic_format_arg<_Context>::handle) {
+        _STL_REPORT_ERROR("The custom handler should be structurally unreachable for _Arg_formatter");
+        _STL_INTERNAL_CHECK(_Ctx);
+        return _Ctx->out();
+    }
+
+    template <class _Ty>
+    _OutputIt operator()(_Ty _Val) {
+        _STL_INTERNAL_CHECK(_Specs);
+        _STL_INTERNAL_CHECK(_Ctx);
+        return _Fmt_write(_Ctx->out(), _Val, *_Specs, _Ctx->_Get_lazy_locale());
+    }
+};
+
+// Special compile time version of _Parse_format_specs. This version is parameterized on
+// the type of the argument associated with the format specifier, since we don't really
+// care about avoiding code bloat for code that never runs at runtime, and we can't form
+// the erased basic_format_args structure at compile time.
+template <class _Ty, class _ParseContext>
+consteval _ParseContext::iterator _Compile_time_parse_format_specs(_ParseContext& _Parse_ctx) {
+    using _CharT                = _ParseContext::char_type;
+    using _Context              = basic_format_context<back_insert_iterator<_Fmt_buffer<_CharT>>, _CharT>;
+    using _ArgTraits            = _Format_arg_traits<_Context>;
+    using _FormattedTypeMapping = _ArgTraits::template _Storage_type<_Ty>;
+    // If the type is going to use a custom formatter we should just use that,
+    // instead of trying to instantiate a custom formatter for its erased handle
+    // type
+    using _FormattedType = conditional_t<is_same_v<_FormattedTypeMapping, typename basic_format_arg<_Context>::handle>,
+        _Ty, _FormattedTypeMapping>;
+    formatter<_FormattedType, _CharT> _Formatter{};
+    return _Formatter.parse(_Parse_ctx);
+}
+
+// set of format parsing actions that only checks for validity
+template <class _CharT, class... _Args>
+struct _Format_checker {
+    using _ParseContext = basic_format_parse_context<_CharT>;
+    using _ParseFunc    = _ParseContext::iterator (*)(_ParseContext&);
+
+    static constexpr size_t _Num_args = sizeof...(_Args);
+    _Compile_time_parse_context<_CharT> _Parse_context;
+    _ParseFunc _Parse_funcs[_Num_args > 0 ? _Num_args : 1];
+
+    consteval explicit _Format_checker(basic_string_view<_CharT> _Fmt, const _Basic_format_arg_type* _Arg_type) noexcept
+        : _Parse_context(_Fmt, _Num_args, _Arg_type),
+          _Parse_funcs{&_Compile_time_parse_format_specs<_Args, _ParseContext>...} {}
+    constexpr void _On_text(const _CharT*, const _CharT*) const noexcept {}
+    constexpr void _On_replacement_field(const size_t _Id, const _CharT* _Last) {
+        _Parse_context.advance_to(_Parse_context.begin() + (_Last - _Parse_context.begin()._Unwrapped()));
+        (void) _Parse_funcs[_Id](_Parse_context);
+    }
+    constexpr const _CharT* _On_format_specs(const size_t _Id, const _CharT* _First, const _CharT*) {
+        _Parse_context.advance_to(_Parse_context.begin() + (_First - _Parse_context.begin()._Unwrapped()));
+        if (_Id < _Num_args) {
+            auto _Iter = _Parse_funcs[_Id](_Parse_context); // TRANSITION, VSO-1451773 (workaround: named variable)
+            return _Iter._Unwrapped();
+        } else {
+            return _First;
+        }
+    }
+};
+
+// The top level set of parsing "actions".
+template <class _CharT>
+struct _Format_handler {
+    using _OutputIt = back_insert_iterator<_Fmt_buffer<_CharT>>;
+    using _Context  = basic_format_context<_OutputIt, _CharT>;
+
+    basic_format_parse_context<_CharT> _Parse_context;
+    _Context _Ctx;
+
+    explicit _Format_handler(_OutputIt _Out, basic_string_view<_CharT> _Str, basic_format_args<_Context> _Format_args,
+        const _Lazy_locale& _Loc)
+        : _Parse_context(_Str), _Ctx(_Context::_Make_from(_STD move(_Out), _Format_args, _Loc)) {}
+
+    void _On_text(const _CharT* _First, const _CharT* _Last) {
+        _Ctx.advance_to(_RANGES _Copy_unchecked(_First, _Last, _Ctx.out()).out);
+    }
+
+    void _On_replacement_field(const size_t _Id, const _CharT* _Last) {
+        auto _Arg = _Get_arg(_Ctx, _Id);
+        if (_Arg._Active_state == _Basic_format_arg_type::_Custom_type) {
+            _Parse_context.advance_to(_Parse_context.begin() + (_Last - _Parse_context.begin()._Unwrapped()));
+        }
+        _Ctx.advance_to(_STD visit_format_arg(_Default_arg_formatter<_OutputIt, _CharT>{_Ctx.out(), _Ctx._Get_args(),
+                                                  _Ctx._Get_lazy_locale(), _Parse_context},
+            _Arg));
+    }
+
+    const _CharT* _On_format_specs(const size_t _Id, const _CharT* _First, const _CharT* _Last) {
+        _Parse_context.advance_to(_Parse_context.begin() + (_First - _Parse_context.begin()._Unwrapped()));
+        auto _Arg = _Get_arg(_Ctx, _Id);
+        if (_Arg._Active_state == _Basic_format_arg_type::_Custom_type) {
+            _Arg._Custom_state.format(_Parse_context, _Ctx);
+            return _Parse_context.begin()._Unwrapped();
+        }
+
+        _Basic_format_specs<_CharT> _Specs;
+        _Specs_checker<_Specs_handler<basic_format_parse_context<_CharT>, _Context>> _Handler(
+            _Specs_handler<basic_format_parse_context<_CharT>, _Context>{_Specs, _Parse_context, _Ctx},
+            _Arg._Active_state);
+        _First = _Parse_format_specs(_First, _Last, _Handler);
+        if (_First == _Last || *_First != '}') {
+            _Throw_format_error("Missing '}' in format string.");
+        }
+
+        _Ctx.advance_to(_STD visit_format_arg(
+            _Arg_formatter<_OutputIt, _CharT>{._Ctx = _STD addressof(_Ctx), ._Specs = _STD addressof(_Specs)}, _Arg));
+        return _First;
+    }
+};
+
+// declared in <__msvc_formatter.hpp>
+template <class _Ty, class _CharT, _Basic_format_arg_type _ArgType>
+template <class _ParseContext>
+constexpr _ParseContext::iterator _Formatter_base<_Ty, _CharT, _ArgType>::parse(
+    type_identity_t<_ParseContext&> _Parse_ctx) {
+    _Specs_checker<_Dynamic_specs_handler<_ParseContext>> _Handler(
+        _Dynamic_specs_handler<_ParseContext>{_Specs, _Parse_ctx}, _ArgType);
+    const auto _It = _Parse_format_specs(_Parse_ctx._Unchecked_begin(), _Parse_ctx._Unchecked_end(), _Handler);
+    if (_It != _Parse_ctx._Unchecked_end() && *_It != '}') {
+        _Throw_format_error("Missing '}' in format string.");
+    }
+    return _Parse_ctx.begin() + (_It - _Parse_ctx._Unchecked_begin());
+}
+
+// declared in <__msvc_formatter.hpp>
+template <class _Ty, class _CharT, _Basic_format_arg_type _ArgType>
+template <class _FormatContext>
+_FormatContext::iterator _Formatter_base<_Ty, _CharT, _ArgType>::format(
+    const _Ty& _Val, _FormatContext& _Format_ctx) const {
+    _Dynamic_format_specs<_CharT> _Format_specs = _Specs;
+    if (_Specs._Dynamic_width_index >= 0) {
+        _Format_specs._Width =
+            _Get_dynamic_specs<_Width_checker>(_Format_ctx.arg(static_cast<size_t>(_Specs._Dynamic_width_index)));
+    }
+
+    if (_Specs._Dynamic_precision_index >= 0) {
+        _Format_specs._Precision = _Get_dynamic_specs<_Precision_checker>(
+            _Format_ctx.arg(static_cast<size_t>(_Specs._Dynamic_precision_index)));
+    }
+
+    return _STD visit_format_arg(
+        _Arg_formatter<typename _FormatContext::iterator, _CharT>{
+            ._Ctx = _STD addressof(_Format_ctx), ._Specs = _STD addressof(_Format_specs)},
+        basic_format_arg<_FormatContext>::_Make_from(_Val));
+}
+_FMT_P2286_END
+
+_EXPORT_STD template <class _CharT, class... _Args>
+struct basic_format_string {
+public:
+    template <class _Ty>
+        requires convertible_to<const _Ty&, basic_string_view<_CharT>>
+    consteval basic_format_string(const _Ty& _Str_val) : _Str(_Str_val) {
+        if constexpr (!is_same_v<_CharT, char> || _Is_execution_charset_self_synchronizing()) {
+            using _Context             = basic_format_context<back_insert_iterator<_Fmt_buffer<_CharT>>, _CharT>;
+            constexpr size_t _Num_args = sizeof...(_Args);
+            constexpr _Basic_format_arg_type _Arg_types[_Num_args > 0 ? _Num_args : 1] = {
+                _STD _Get_format_arg_type<_Context, _Args>()...};
+
+            _Parse_format_string(_Str, _Format_checker<_CharT, remove_cvref_t<_Args>...>{_Str, _Arg_types});
+        }
+    }
+
+    _NODISCARD constexpr basic_string_view<_CharT> get() const noexcept {
+        return _Str;
+    }
+
+private:
+    basic_string_view<_CharT> _Str;
+};
+
+_EXPORT_STD template <class... _Args>
+using format_string = basic_format_string<char, type_identity_t<_Args>...>;
+
+_EXPORT_STD template <class... _Args>
+using wformat_string = basic_format_string<wchar_t, type_identity_t<_Args>...>;
+
+_EXPORT_STD using format_args  = basic_format_args<format_context>;
+_EXPORT_STD using wformat_args = basic_format_args<wformat_context>;
+
+_EXPORT_STD template <class _Context = format_context, class... _Args>
+_NODISCARD auto make_format_args(_Args&... _Vals) {
+    if constexpr ((_Formattable_with_non_const<remove_const_t<_Args>, _Context> && ...)) {
+        static_assert((_Formattable_with<remove_const_t<_Args>, _Context> && ...),
+            "The format() member function can't be called on const formatter<T>. "
+            "To make the formatter usable, add const to format(). "
+            "See N4971 [format.arg.store]/2 and [formatter.requirements].");
+    } else {
+        static_assert((_Formattable_with<remove_const_t<_Args>, _Context> && ...),
+            "Cannot format an argument. To make T formattable, provide a formatter<T> specialization. "
+            "See N4971 [format.arg.store]/2 and [formatter.requirements].");
+    }
+    return _Format_arg_store<_Context, _Args...>{_Vals...};
+}
+
+_EXPORT_STD template <class... _Args>
+_NODISCARD auto make_wformat_args(_Args&... _Vals) {
+    return _STD make_format_args<wformat_context>(_Vals...);
+}
+
+_FMT_P2286_BEGIN
+template <class _CharT, output_iterator<const _CharT&> _OutputIt, class _Context>
+_OutputIt _Format_to_it(_OutputIt _Out, const basic_string_view<_CharT> _Fmt, const basic_format_args<_Context> _Args,
+    const _Lazy_locale _Loc) {
+    using _Fmt_it_char = _Basic_fmt_it<_CharT>;
+    if constexpr (is_same_v<_OutputIt, _Fmt_it_char>) {
+        _Format_handler<_CharT> _Handler(_Out, _Fmt, _Args, _Loc);
+        _Parse_format_string(_Fmt, _Handler);
+        return _Out;
+    } else {
+        _Fmt_iterator_buffer<_OutputIt, _CharT> _Buf(_STD move(_Out));
+        _Format_handler<_CharT> _Handler(_Fmt_it_char{_Buf}, _Fmt, _Args, _Loc);
+        _Parse_format_string(_Fmt, _Handler);
+        return _Buf._Out();
+    }
+}
+
+_EXPORT_STD template <output_iterator<const char&> _OutputIt>
+_OutputIt vformat_to(_OutputIt _Out, const string_view _Fmt, const format_args _Args) {
+    return _Format_to_it(_STD move(_Out), _Fmt, _Args, _Lazy_locale{});
+}
+
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt>
+_OutputIt vformat_to(_OutputIt _Out, const wstring_view _Fmt, const wformat_args _Args) {
+    return _Format_to_it(_STD move(_Out), _Fmt, _Args, _Lazy_locale{});
+}
+
+_EXPORT_STD template <output_iterator<const char&> _OutputIt>
+_OutputIt vformat_to(_OutputIt _Out, const locale& _Loc, const string_view _Fmt, const format_args _Args) {
+    return _Format_to_it(_STD move(_Out), _Fmt, _Args, _Lazy_locale{_Loc});
+}
+
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt>
+_OutputIt vformat_to(_OutputIt _Out, const locale& _Loc, const wstring_view _Fmt, const wformat_args _Args) {
+    return _Format_to_it(_STD move(_Out), _Fmt, _Args, _Lazy_locale{_Loc});
+}
+
+_EXPORT_STD template <output_iterator<const char&> _OutputIt, class... _Types>
+_OutputIt format_to(_OutputIt _Out, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    return _STD vformat_to(_STD move(_Out), _Fmt.get(), _STD make_format_args(_Args...));
+}
+
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
+_OutputIt format_to(_OutputIt _Out, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
+    return _STD vformat_to(_STD move(_Out), _Fmt.get(), _STD make_wformat_args(_Args...));
+}
+
+_EXPORT_STD template <output_iterator<const char&> _OutputIt, class... _Types>
+_OutputIt format_to(_OutputIt _Out, const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    return _STD vformat_to(_STD move(_Out), _Loc, _Fmt.get(), _STD make_format_args(_Args...));
+}
+
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
+_OutputIt format_to(_OutputIt _Out, const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
+    return _STD vformat_to(_STD move(_Out), _Loc, _Fmt.get(), _STD make_wformat_args(_Args...));
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+_NODISCARD string vformat(const string_view _Fmt, const format_args _Args) {
+    string _Str;
+    _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
+    _STD vformat_to(back_insert_iterator{_Str}, _Fmt, _Args);
+    return _Str;
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+_NODISCARD wstring vformat(const wstring_view _Fmt, const wformat_args _Args) {
+    wstring _Str;
+    _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
+    _STD vformat_to(back_insert_iterator{_Str}, _Fmt, _Args);
+    return _Str;
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+_NODISCARD string vformat(const locale& _Loc, const string_view _Fmt, const format_args _Args) {
+    string _Str;
+    _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
+    _STD vformat_to(back_insert_iterator{_Str}, _Loc, _Fmt, _Args);
+    return _Str;
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+_NODISCARD wstring vformat(const locale& _Loc, const wstring_view _Fmt, const wformat_args _Args) {
+    wstring _Str;
+    _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
+    _STD vformat_to(back_insert_iterator{_Str}, _Loc, _Fmt, _Args);
+    return _Str;
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD string format(const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    return _STD vformat(_Fmt.get(), _STD make_format_args(_Args...));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD wstring format(const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
+    return _STD vformat(_Fmt.get(), _STD make_wformat_args(_Args...));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD string format(const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    return _STD vformat(_Loc, _Fmt.get(), _STD make_format_args(_Args...));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD wstring format(const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
+    return _STD vformat(_Loc, _Fmt.get(), _STD make_wformat_args(_Args...));
+}
+_FMT_P2286_END
+
+_EXPORT_STD template <class _OutputIt>
+struct format_to_n_result {
+    _OutputIt out;
+    iter_difference_t<_OutputIt> size;
+};
+
+_FMT_P2286_BEGIN
+_EXPORT_STD template <output_iterator<const char&> _OutputIt, class... _Types>
+format_to_n_result<_OutputIt> format_to_n(
+    _OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _Fmt_iterator_buffer<_OutputIt, char, _Fmt_fixed_buffer_traits> _Buf(_STD move(_Out), _Max);
+    _STD vformat_to(_Fmt_it{_Buf}, _Fmt.get(), _STD make_format_args(_Args...));
+    return {.out = _Buf._Out(), .size = _Buf._Count()};
+}
+
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
+format_to_n_result<_OutputIt> format_to_n(
+    _OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
+    _Fmt_iterator_buffer<_OutputIt, wchar_t, _Fmt_fixed_buffer_traits> _Buf(_STD move(_Out), _Max);
+    _STD vformat_to(_Fmt_wit{_Buf}, _Fmt.get(), _STD make_wformat_args(_Args...));
+    return {.out = _Buf._Out(), .size = _Buf._Count()};
+}
+
+_EXPORT_STD template <output_iterator<const char&> _OutputIt, class... _Types>
+format_to_n_result<_OutputIt> format_to_n(_OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const locale& _Loc,
+    const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _Fmt_iterator_buffer<_OutputIt, char, _Fmt_fixed_buffer_traits> _Buf(_STD move(_Out), _Max);
+    _STD vformat_to(_Fmt_it{_Buf}, _Loc, _Fmt.get(), _STD make_format_args(_Args...));
+    return {.out = _Buf._Out(), .size = _Buf._Count()};
+}
+
+_EXPORT_STD template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
+format_to_n_result<_OutputIt> format_to_n(_OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const locale& _Loc,
+    const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
+    _Fmt_iterator_buffer<_OutputIt, wchar_t, _Fmt_fixed_buffer_traits> _Buf(_STD move(_Out), _Max);
+    _STD vformat_to(_Fmt_wit{_Buf}, _Loc, _Fmt.get(), _STD make_wformat_args(_Args...));
+    return {.out = _Buf._Out(), .size = _Buf._Count()};
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD size_t formatted_size(const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _Fmt_counting_buffer<char> _Buf;
+    _STD vformat_to(_Fmt_it{_Buf}, _Fmt.get(), _STD make_format_args(_Args...));
+    return _Buf._Count();
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD size_t formatted_size(const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
+    _Fmt_counting_buffer<wchar_t> _Buf;
+    _STD vformat_to(_Fmt_wit{_Buf}, _Fmt.get(), _STD make_wformat_args(_Args...));
+    return _Buf._Count();
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD size_t formatted_size(const locale& _Loc, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _Fmt_counting_buffer<char> _Buf;
+    _STD vformat_to(_Fmt_it{_Buf}, _Loc, _Fmt.get(), _STD make_format_args(_Args...));
+    return _Buf._Count();
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD size_t formatted_size(const locale& _Loc, const wformat_string<_Types...> _Fmt, _Types&&... _Args) {
+    _Fmt_counting_buffer<wchar_t> _Buf;
+    _STD vformat_to(_Fmt_wit{_Buf}, _Loc, _Fmt.get(), _STD make_wformat_args(_Args...));
+    return _Buf._Count();
+}
+_FMT_P2286_END
+
+#if _HAS_CXX23
+template <class _CharT>
+_NODISCARD int _Measure_display_width(const basic_string_view<_CharT> _Value) {
+    int _Width = -1;
+    (void) _Measure_string_prefix(_Value, _Width);
+    return _Width;
+}
+
+template <class _CharT>
+class _Fill_align_and_width_specs_setter {
+public:
+    constexpr explicit _Fill_align_and_width_specs_setter(
+        _Fill_align_and_width_specs<_CharT>& _Specs_, basic_format_parse_context<_CharT>& _Parse_ctx_)
+        : _Specs(_Specs_), _Parse_ctx(_Parse_ctx_) {}
+
+    constexpr void _On_align(const _Fmt_align _Aln) {
+        _Specs._Alignment = _Aln;
+    }
+
+    constexpr void _On_fill(const basic_string_view<_CharT> _Sv) {
+        if (_Sv.size() > _STD size(_Specs._Fill)) {
+            _Throw_format_error("Invalid fill (too long).");
+        }
+
+        const auto _Pos = _STD _Copy_unchecked(_Sv._Unchecked_begin(), _Sv._Unchecked_end(), _Specs._Fill);
+        _STD fill(_Pos, _STD end(_Specs._Fill), _CharT{});
+        _Specs._Fill_length = static_cast<uint8_t>(_Sv.size());
+    }
+
+    constexpr void _On_width(const int _Width) {
+        _Specs._Width = _Width;
+    }
+
+    constexpr void _On_dynamic_width(const size_t _Arg_id) {
+        _Parse_ctx.check_arg_id(_Arg_id);
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_dynamic_width(_Auto_id_tag) {
+        const size_t _Arg_id = _Parse_ctx.next_arg_id();
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+protected:
+    _Fill_align_and_width_specs<_CharT>& _Specs;
+
+private:
+    basic_format_parse_context<_CharT>& _Parse_ctx;
+
+    _NODISCARD static constexpr int _Verify_dynamic_arg_index_in_range(const size_t _Idx) {
+        if (!_STD in_range<int>(_Idx)) {
+            _Throw_format_error("Dynamic width index is too large.");
+        }
+
+        return static_cast<int>(_Idx);
+    }
+};
+
+template <class _CharT>
+class _Range_specs_setter : public _Fill_align_and_width_specs_setter<_CharT> {
+public:
+    constexpr explicit _Range_specs_setter(
+        _Range_specs<_CharT>& _Specs_, basic_format_parse_context<_CharT>& _Parse_ctx_)
+        : _Fill_align_and_width_specs_setter<_CharT>(_Specs_, _Parse_ctx_) {}
+
+    constexpr void _On_no_brackets() {
+        static_cast<_Range_specs<_CharT>&>(this->_Specs)._No_brackets = true;
+    }
+
+    constexpr void _On_type(const _CharT _Type) {
+        _STL_INTERNAL_CHECK(_Type == 'm' || _Type == 's' || _Type == '?');
+        static_cast<_Range_specs<_CharT>&>(this->_Specs)._Type = static_cast<char>(_Type);
+    }
+};
+
+template <class _CharT>
+_NODISCARD constexpr const _CharT* _Parse_range_specs(
+    const _CharT* _Begin, const _CharT* const _End, _Range_specs_setter<_CharT>& _Callbacks) {
+    if (_Begin == _End || *_Begin == '}' || *_Begin == ':') {
+        return _Begin;
+    }
+
+    _Begin = _Parse_align(_Begin, _End, _Callbacks);
+    if (_Begin == _End) {
+        return _Begin;
+    }
+
+    _Begin = _Parse_width(_Begin, _End, _Callbacks);
+    if (_Begin == _End) {
+        return _Begin;
+    }
+
+    if (*_Begin == 'n') {
+        _Callbacks._On_no_brackets();
+        if (++_Begin == _End) {
+            return _Begin;
+        }
+    }
+
+    switch (const _CharT _Maybe_type = *_Begin) {
+    case '?':
+        if (++_Begin == _End || *_Begin != 's') {
+            _Throw_format_error("Invalid range-type '?'; was '?s' intended?");
+        }
+        [[fallthrough]];
+    case 'm':
+    case 's':
+        _Callbacks._On_type(_Maybe_type);
+        ++_Begin;
+        break;
+    default:
+        break;
+    }
+
+    return _Begin;
+}
+
+// declared in <__msvc_ranges_tuple_formatter.hpp>
+template <class _Ty, class _CharT>
+    requires same_as<remove_cvref_t<_Ty>, _Ty> && formattable<_Ty, _CharT>
+template <class _ParseContext>
+constexpr _ParseContext::iterator range_formatter<_Ty, _CharT>::parse(_ParseContext& _Ctx) {
+    _Range_specs_setter<_CharT> _Callback{_Specs, _Ctx};
+    auto _It = _STD _Parse_range_specs(_Ctx._Unchecked_begin(), _Ctx._Unchecked_end(), _Callback);
+
+    _Ctx.advance_to(_Ctx.begin() + (_It - _Ctx._Unchecked_begin()));
+    bool _Has_underlying_spec = false;
+    if (_It != _Ctx._Unchecked_end()) {
+        if (*_It == ':') {
+            _Has_underlying_spec = true;
+            _Ctx.advance_to(_Ctx.begin() + 1);
+        } else if (*_It != '}') {
+            _Throw_format_error("Invalid range-format-spec.");
+        }
+    }
+
+    _It = _Underlying.parse(_Ctx)._Unwrapped();
+    if (_It != _Ctx._Unchecked_end() && *_It != '}') {
+        _Throw_format_error("Missing '}' in format string.");
+    }
+
+    switch (_Specs._Type) {
+    case 'm':
+        if constexpr (_Is_two_tuple<_Ty>) {
+            _Opening_bracket = _STATICALLY_WIDEN(_CharT, "{");
+            _Closing_bracket = _STATICALLY_WIDEN(_CharT, "}");
+            _Separator       = _STATICALLY_WIDEN(_CharT, ", ");
+            _Underlying.set_brackets({}, {});
+            _Underlying.set_separator(_STATICALLY_WIDEN(_CharT, ": "));
+        } else {
+            _Throw_format_error("Range-type 'm' requires type T to be a pair or a 2-element tuple.");
+        }
+        [[fallthrough]];
+
+    case '\0':
+        if constexpr (requires { _Underlying.set_debug_format(); }) {
+            if (!_Has_underlying_spec) {
+                _Underlying.set_debug_format();
+            }
+        }
+        break;
+
+    case 's':
+    case '?':
+        if constexpr (same_as<_Ty, _CharT>) {
+            if (_Specs._No_brackets) {
+                _Throw_format_error("Range-types 's' and '?s' cannot be combined with the 'n' option.");
+            } else if (_Has_underlying_spec) {
+                _Throw_format_error("Range-types 's' and '?s' cannot be combined with a range-underlying-spec.");
+            }
+        } else {
+            _Throw_format_error("Range-types 's' and '?s' require type T to be charT.");
+        }
+
+        break;
+
+    default:
+        _STL_UNREACHABLE; // can't happen, we've handled all possible outputs from _Parse_range_specs()
+        break;
+    }
+
+    if (_Specs._No_brackets) {
+        _Opening_bracket = basic_string_view<_CharT>{};
+        _Closing_bracket = basic_string_view<_CharT>{};
+    }
+
+    return _Ctx.begin() + (_It - _Ctx._Unchecked_begin());
+}
+
+template <class _Ty, class _CharT, _RANGES input_range _Range, class _FormatContext>
+void _Range_formatter_format_as_sequence(const formatter<_Ty, _CharT>& _Underlying,
+    const basic_string_view<_CharT> _Separator, const basic_string_view<_CharT> _Opening_bracket,
+    const basic_string_view<_CharT> _Closing_bracket, _Range&& _Rng, _FormatContext& _Ctx) {
+    _Ctx.advance_to(_STD _Fmt_write(_Ctx.out(), _Opening_bracket));
+    bool _Separate   = false;
+    auto _Iter       = _RANGES begin(_Rng);
+    const auto _Sent = _RANGES end(_Rng);
+    for (; _Iter != _Sent; ++_Iter) {
+        auto&& _Elem = *_Iter;
+        if (_Separate) {
+            _Ctx.advance_to(_STD _Fmt_write(_Ctx.out(), _Separator));
+        }
+
+        _Separate = true;
+        _Ctx.advance_to(_Underlying.format(_Elem, _Ctx));
+    }
+
+    (void) _STD _Fmt_write(_Ctx.out(), _Closing_bracket);
+}
+
+template <class _CharT, _RANGES input_range _Range, class _FormatContext>
+void _Range_formatter_format_as_string(_Range&& _Rng, _FormatContext& _Ctx, const bool _Debug) {
+    if constexpr (_RANGES contiguous_range<_Range>) {
+        const auto _Dist = _RANGES distance(_Rng);
+
+#ifdef _DEBUG
+        const auto _Size = _STD _To_unsigned_like(_Dist);
+        if constexpr (sizeof(_Size) > sizeof(size_t)) {
+            _STL_VERIFY(_Size <= size_t{PTRDIFF_MAX}, "contiguous range has impossible size.");
+        }
+#endif // defined(_DEBUG)
+
+        formatter<basic_string_view<_CharT>, _CharT> _String_view_formatter;
+        if (_Debug) {
+            _String_view_formatter.set_debug_format();
+        }
+
+        const auto _First = _RANGES begin(_Rng);
+        const basic_string_view<_CharT> _Str(_STD to_address(_First), _STD to_address(_First + _Dist));
+        _String_view_formatter.format(_Str, _Ctx);
+    } else {
+        using _String = basic_string<_CharT>;
+        formatter<_String, _CharT> _String_formatter;
+        if (_Debug) {
+            _String_formatter.set_debug_format();
+        }
+
+        _String_formatter.format(_String{from_range, _Rng}, _Ctx);
+    }
+}
+
+// declared in <__msvc_ranges_tuple_formatter.hpp>
+template <class _Ty, class _CharT>
+    requires same_as<remove_cvref_t<_Ty>, _Ty>
+          && formattable<_Ty, _CharT>
+             template <_RANGES input_range _Range, class _FormatContext>
+                 requires _Is_specialization_v<typename _FormatContext::iterator, back_insert_iterator>
+                       && derived_from<typename _FormatContext::iterator::container_type, _Fmt_buffer<_CharT>>
+_FormatContext::iterator range_formatter<_Ty, _CharT>::_Format(_Range&& _Rng, _FormatContext& _Ctx) const {
+    auto _Format_specs = _Specs;
+    if (_Specs._Dynamic_width_index >= 0) {
+        _Format_specs._Width =
+            _STD _Get_dynamic_specs<_Width_checker>(_Ctx.arg(static_cast<size_t>(_Specs._Dynamic_width_index)));
+    }
+
+    basic_string<_CharT> _Buffer;
+    {
+        _Fmt_iterator_buffer<back_insert_iterator<basic_string<_CharT>>, _CharT> _Fmt_buf(
+            back_insert_iterator{_Buffer});
+        using _Inserter      = back_insert_iterator<_Fmt_buffer<_CharT>>;
+        auto _Nested_context = basic_format_context<_Inserter, _CharT>::_Make_from(
+            _Inserter{_Fmt_buf}, _Ctx._Get_args(), _Ctx._Get_lazy_locale());
+
+        if constexpr (same_as<_Ty, _CharT>) {
+            if (_Specs._Type == 's' || _Specs._Type == '?') {
+                _STD _Range_formatter_format_as_string<_CharT>(
+                    _STD forward<_Range>(_Rng), _Nested_context, _Specs._Type == '?');
+            } else {
+                _STD _Range_formatter_format_as_sequence(_Underlying, _Separator, _Opening_bracket, _Closing_bracket,
+                    _STD forward<_Range>(_Rng), _Nested_context);
+            }
+        } else {
+            _STD _Range_formatter_format_as_sequence(_Underlying, _Separator, _Opening_bracket, _Closing_bracket,
+                _STD forward<_Range>(_Rng), _Nested_context);
+        }
+    }
+
+    const int _Width = _STD _Measure_display_width<_CharT>(_Buffer);
+    return _STD _Write_aligned(_Ctx.out(), _Width, _Format_specs, _Fmt_align::_Left,
+        [&](_FormatContext::iterator _Out) { return _STD _Fmt_write(_STD move(_Out), basic_string_view{_Buffer}); });
+}
+
+enum class _Fmt_tuple_type : uint8_t { _None, _Key_value, _No_brackets };
+
+template <class _CharT, bool _IsTwoTuple>
+class _Tuple_format_specs_setter {
+public:
+    constexpr explicit _Tuple_format_specs_setter(_Fill_align_and_width_specs<_CharT>& _Specs_,
+        _Fmt_tuple_type& _Fmt_type_, basic_format_parse_context<_CharT>& _Parse_ctx_)
+        : _Specs(_Specs_), _Fmt_type(_Fmt_type_), _Parse_ctx(_Parse_ctx_) {}
+
+    constexpr void _On_align(const _Fmt_align _Aln) {
+        _Specs._Alignment = _Aln;
+    }
+
+    constexpr void _On_fill(const basic_string_view<_CharT> _Sv) {
+        if (_Sv.size() > _STD size(_Specs._Fill)) {
+            _Throw_format_error("Invalid fill (too long).");
+        }
+
+        if (_Sv == _STATICALLY_WIDEN(_CharT, ":")) {
+            _Throw_format_error(R"(Invalid fill ":" for tuples and pairs.)");
+        }
+
+        const auto _Pos = _STD _Copy_unchecked(_Sv._Unchecked_begin(), _Sv._Unchecked_end(), _Specs._Fill);
+        _STD fill(_Pos, _STD end(_Specs._Fill), _CharT{});
+        _Specs._Fill_length = static_cast<uint8_t>(_Sv.size());
+    }
+
+    constexpr void _On_width(const int _Width) {
+        _Specs._Width = _Width;
+    }
+
+    constexpr void _On_dynamic_width(const size_t _Arg_id) {
+        _Parse_ctx.check_arg_id(_Arg_id);
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_dynamic_width(_Auto_id_tag) {
+        const size_t _Arg_id = _Parse_ctx.next_arg_id();
+        _Parse_ctx._Check_dynamic_spec_integral(_Arg_id);
+        _Specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
+    }
+
+    constexpr void _On_type(const _CharT _Type) {
+        if (_Type == _CharT{}) {
+            return;
+        }
+
+        if (_Type == static_cast<_CharT>('n')) {
+            _Fmt_type = _Fmt_tuple_type::_No_brackets;
+            return;
+        }
+
+        if constexpr (_IsTwoTuple) {
+            if (_Type == static_cast<_CharT>('m')) {
+                _Fmt_type = _Fmt_tuple_type::_Key_value;
+                return;
+            }
+        }
+
+        _Throw_format_error("Invalid type specification.");
+    }
+
+private:
+    _Fill_align_and_width_specs<_CharT>& _Specs;
+    _Fmt_tuple_type& _Fmt_type;
+    basic_format_parse_context<_CharT>& _Parse_ctx;
+
+    _NODISCARD static constexpr int _Verify_dynamic_arg_index_in_range(const size_t _Idx) {
+        if (!_STD in_range<int>(_Idx)) {
+            _Throw_format_error("Dynamic width index is too large.");
+        }
+
+        return static_cast<int>(_Idx);
+    }
+};
+
+template <class _CharT, class _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_tuple_format_specs(
+    const _CharT* _Begin, const _CharT* _End, _Callbacks_type&& _Callbacks) {
+    if (_Begin == _End || *_Begin == '}') {
+        return _Begin;
+    }
+
+    _Begin = _STD _Parse_align(_Begin, _End, _Callbacks);
+    if (_Begin == _End) {
+        return _Begin;
+    }
+
+    _Begin = _STD _Parse_width(_Begin, _End, _Callbacks);
+    if (_Begin == _End) {
+        return _Begin;
+    }
+
+    // If there's anything remaining we assume it's a type.
+    if (*_Begin != '}') {
+        _Callbacks._On_type(*_Begin);
+        ++_Begin;
+    } else {
+        // call the type callback so it gets a default type, this is required
+        // since _Specs_checker needs to be able to tell that it got a default type
+        // to raise an error for default formatted bools with a sign modifier
+        _Callbacks._On_type(_CharT{});
+    }
+
+    return _Begin;
+}
+
+template <class _FormatterType, class _ParseContext>
+constexpr void _Set_tuple_debug_format(_FormatterType& _Formatter, _ParseContext& _Parse_ctx) {
+    _Formatter.parse(_Parse_ctx);
+    if constexpr (requires { _Formatter.set_debug_format(); }) {
+        _Formatter.set_debug_format();
+    }
+}
+
+// declared in <__msvc_ranges_tuple_formatter.hpp>
+template <class _CharT, formattable<_CharT>... _Types>
+template <class _ParseContext>
+constexpr _ParseContext::iterator _Tuple_formatter_common_base<_CharT, _Types...>::parse(_ParseContext& _Ctx) {
+    _Fmt_tuple_type _Fmt_type = _Fmt_tuple_type::_None;
+    _Tuple_format_specs_setter<_CharT, sizeof...(_Types) == 2> _Callback{_Specs, _Fmt_type, _Ctx};
+    const auto _It = _STD _Parse_tuple_format_specs(_Ctx._Unchecked_begin(), _Ctx._Unchecked_end(), _Callback);
+    if (_It != _Ctx._Unchecked_end() && *_It != '}') {
+        _STD _Throw_format_error("Missing '}' in format string.");
+    }
+
+    if (_Fmt_type == _Fmt_tuple_type::_No_brackets) {
+        _Opening_bracket = basic_string_view<_CharT>{};
+        _Closing_bracket = basic_string_view<_CharT>{};
+    } else if constexpr (sizeof...(_Types) == 2) {
+        if (_Fmt_type == _Fmt_tuple_type::_Key_value) {
+            _Separator       = _STATICALLY_WIDEN(_CharT, ": ");
+            _Opening_bracket = basic_string_view<_CharT>{};
+            _Closing_bracket = basic_string_view<_CharT>{};
+        }
+    }
+
+    _Ctx.advance_to(_Ctx.begin() + (_It - _Ctx._Unchecked_begin()));
+    _STD apply([&_Ctx](auto&... _Elems) { (_STD _Set_tuple_debug_format(_Elems, _Ctx), ...); }, _Underlying);
+
+    return _Ctx.begin();
+}
+
+template <class... _Types, class _CharT, class _FormatContext, class... _ArgTypes>
+void _Tuple_formatter_format_to_context(const tuple<formatter<_Types, _CharT>...>& _Underlying,
+    const basic_string_view<_CharT> _Separator, const basic_string_view<_CharT> _Opening_bracket,
+    const basic_string_view<_CharT> _Closing_bracket, _FormatContext& _Fmt_ctx, _ArgTypes&... _Args) {
+    _STD _Copy_unchecked(_Opening_bracket._Unchecked_begin(), _Opening_bracket._Unchecked_end(), _Fmt_ctx.out());
+    [&]<size_t... _Indices>(index_sequence<_Indices...>) {
+        auto _Single_writer = [&]<size_t _Idx>(auto& _Arg) {
+            if constexpr (_Idx != 0) {
+                _STD _Copy_unchecked(_Separator._Unchecked_begin(), _Separator._Unchecked_end(), _Fmt_ctx.out());
+            }
+            _STD get<_Idx>(_Underlying).format(_Arg, _Fmt_ctx);
+        };
+        (_Single_writer.template operator()<_Indices>(_Args), ...);
+    }(index_sequence_for<_ArgTypes...>{});
+    _STD _Copy_unchecked(_Closing_bracket._Unchecked_begin(), _Closing_bracket._Unchecked_end(), _Fmt_ctx.out());
+}
+
+// declared in <__msvc_ranges_tuple_formatter.hpp>
+template <class _CharT, formattable<_CharT>... _Types>
+template <class _FormatContext, class... _ArgTypes>
+_FormatContext::iterator _Tuple_formatter_common_base<_CharT, _Types...>::_Format(
+    _FormatContext& _Fmt_ctx, _ArgTypes&... _Args) const {
+    _STL_INTERNAL_STATIC_ASSERT(
+        (is_same_v<_ArgTypes, remove_reference_t<_Maybe_const<_Is_const_formattable, _Types>>> && ...));
+
+    auto _Format_specs = _Specs;
+    if (_Specs._Dynamic_width_index >= 0) {
+        _Format_specs._Width =
+            _STD _Get_dynamic_specs<_Width_checker>(_Fmt_ctx.arg(static_cast<size_t>(_Specs._Dynamic_width_index)));
+    }
+
+    if (_Format_specs._Width <= 0) {
+        _STD _Tuple_formatter_format_to_context(
+            _Underlying, _Separator, _Opening_bracket, _Closing_bracket, _Fmt_ctx, _Args...);
+        return _Fmt_ctx.out();
+    }
+
+    basic_string<_CharT> _Tmp_str;
+    if constexpr (is_same_v<_FormatContext, _Default_format_context<_CharT>>) {
+        _Fmt_iterator_buffer<back_insert_iterator<basic_string<_CharT>>, _CharT> _Tmp_buf{
+            back_insert_iterator{_Tmp_str}};
+        auto _Tmp_ctx = _FormatContext::_Make_from(
+            _Basic_fmt_it<_CharT>{_Tmp_buf}, _Fmt_ctx._Get_args(), _Fmt_ctx._Get_lazy_locale());
+        _STD _Tuple_formatter_format_to_context(
+            _Underlying, _Separator, _Opening_bracket, _Closing_bracket, _Tmp_ctx, _Args...);
+    } else {
+        _STL_REPORT_ERROR("no basic_format_context object other than _Default_format_context can be created");
+    }
+
+    const int _Width = _STD _Measure_display_width<_CharT>(_Tmp_str);
+    return _STD _Write_aligned(
+        _Fmt_ctx.out(), _Width, _Format_specs, _Fmt_align::_Left, [&](_FormatContext::iterator _Out) {
+            return _STD _Fmt_write(_STD move(_Out), basic_string_view<_CharT>{_Tmp_str});
+        });
+}
+
+enum class _Add_newline : bool { _Nope, _Yes };
+
+_NODISCARD inline string _Unescape_braces(const _Add_newline _Add_nl, const string_view _Old_str) {
+    string _Unescaped_str;
+
+    if (_Old_str.empty()) {
+        if (_Add_nl == _Add_newline::_Yes) {
+            _Unescaped_str.push_back('\n');
+        }
+
+        return _Unescaped_str;
+    }
+
+    size_t _Unescaped_str_expected_size = _Old_str.size();
+
+    if (_Add_nl == _Add_newline::_Yes) {
+        ++_Unescaped_str_expected_size;
+    }
+
+    _Unescaped_str.resize_and_overwrite(_Unescaped_str_expected_size, [_Add_nl, _Old_str](char* _Dest_ptr, size_t) {
+        char _Prev_char           = _Old_str.front();
+        size_t _Num_chars_written = 1;
+        *_Dest_ptr++              = _Prev_char;
+
+        for (const auto _Curr_char : _Old_str.substr(1)) {
+            if ((_Curr_char == '{' && _Prev_char == '{') || (_Curr_char == '}' && _Prev_char == '}')) {
+                _Prev_char = '\0';
+            } else {
+                *_Dest_ptr++ = _Curr_char;
+                ++_Num_chars_written;
+
+                _Prev_char = _Curr_char;
+            }
+        }
+
+        if (_Add_nl == _Add_newline::_Yes) {
+            *_Dest_ptr = '\n';
+            ++_Num_chars_written;
+        }
+
+        return _Num_chars_written;
+    });
+
+    return _Unescaped_str;
+}
+
+template <class _CharT, class _Callbacks_type>
+_NODISCARD constexpr const _CharT* _Parse_fill_align_and_width_specs(
+    const _CharT* _Begin, const _CharT* _End, _Callbacks_type&& _Callbacks) {
+    if (_Begin == _End || *_Begin == '}') {
+        return _Begin;
+    }
+
+    _Begin = _Parse_align(_Begin, _End, _Callbacks);
+    if (_Begin == _End) {
+        return _Begin;
+    }
+
+    return _Parse_width(_Begin, _End, _Callbacks);
+}
+
+// declared in <__msvc_formatter.hpp>
+template <class _CharT>
+template <class _ParseContext>
+_NODISCARD constexpr _ParseContext::iterator _Fill_align_and_width_formatter<_CharT>::_Parse(
+    type_identity_t<_ParseContext&> _Parse_ctx) {
+    _Fill_align_and_width_specs_setter<_CharT> _Callback{_Specs, _Parse_ctx};
+    const auto _It =
+        _Parse_fill_align_and_width_specs(_Parse_ctx._Unchecked_begin(), _Parse_ctx._Unchecked_end(), _Callback);
+    if (_It != _Parse_ctx._Unchecked_end() && *_It != '}') {
+        _Throw_format_error("Missing '}' in format string.");
+    }
+
+    return _Parse_ctx.begin() + (_It - _Parse_ctx._Unchecked_begin());
+}
+
+// declared in <__msvc_formatter.hpp>
+template <class _CharT>
+template <class _FormatContext, class _Func>
+_NODISCARD _FormatContext::iterator _Fill_align_and_width_formatter<_CharT>::_Format(
+    _FormatContext& _Format_ctx, const int _Width, _Fmt_align _Default_align, _Func&& _Fn) const {
+    _Fill_align_and_width_specs _Format_specs = _Specs;
+    if (_Specs._Dynamic_width_index >= 0) {
+        _Format_specs._Width =
+            _Get_dynamic_specs<_Width_checker>(_Format_ctx.arg(static_cast<size_t>(_Specs._Dynamic_width_index)));
+    }
+
+    return _Write_aligned(_Format_ctx.out(), _Width, _Format_specs, _Default_align, _STD forward<_Func>(_Fn));
+}
+#endif // _HAS_CXX23
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // ^^^ _HAS_CXX20 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FORMAT_
diff --git a/msvc-stl/stl/inc/forward_list b/msvc-stl/stl/inc/forward_list
new file mode 100644
index 0000000..dc0ae54
--- /dev/null
+++ b/msvc-stl/stl/inc/forward_list
@@ -0,0 +1,1652 @@
+// forward_list standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _FORWARD_LIST_
+#define _FORWARD_LIST_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xmemory>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Mylist, class _Base = _Iterator_base0>
+class _Flist_unchecked_const_iterator : public _Base {
+public:
+    using iterator_category = forward_iterator_tag;
+
+    using _Nodeptr        = typename _Mylist::_Nodeptr;
+    using value_type      = typename _Mylist::value_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::const_pointer;
+    using reference       = const value_type&;
+
+    _Flist_unchecked_const_iterator() noexcept : _Ptr() {}
+
+    _Flist_unchecked_const_iterator(_Nodeptr _Pnode, const _Mylist* _Plist) noexcept : _Ptr(_Pnode) {
+        this->_Adopt(_Plist);
+    }
+
+    _NODISCARD reference operator*() const noexcept {
+        return _Ptr->_Myval;
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Flist_unchecked_const_iterator& operator++() noexcept {
+        _Ptr = _Ptr->_Next;
+        return *this;
+    }
+
+    _Flist_unchecked_const_iterator operator++(int) noexcept {
+        _Flist_unchecked_const_iterator _Tmp = *this;
+        _Ptr                                 = _Ptr->_Next;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const _Flist_unchecked_const_iterator& _Right) const noexcept {
+        return _Ptr == _Right._Ptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const _Flist_unchecked_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _NODISCARD bool operator==(_Default_sentinel) const noexcept {
+        return _Ptr == nullptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(_Default_sentinel) const noexcept {
+        return _Ptr != nullptr;
+    }
+#endif // !_HAS_CXX20
+
+    _Nodeptr _Ptr; // pointer to node
+};
+
+template <class _Mylist>
+class _Flist_unchecked_iterator : public _Flist_unchecked_const_iterator<_Mylist> {
+public:
+    using _Mybase           = _Flist_unchecked_const_iterator<_Mylist>;
+    using iterator_category = forward_iterator_tag;
+
+    using _Nodeptr        = typename _Mylist::_Nodeptr;
+    using value_type      = typename _Mylist::value_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::pointer;
+    using reference       = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Flist_unchecked_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Flist_unchecked_iterator operator++(int) noexcept {
+        _Flist_unchecked_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+};
+
+template <class _Mylist>
+class _Flist_const_iterator : public _Flist_unchecked_const_iterator<_Mylist, _Iterator_base> {
+public:
+    using _Mybase           = _Flist_unchecked_const_iterator<_Mylist, _Iterator_base>;
+    using iterator_category = forward_iterator_tag;
+
+    using _Nodeptr        = typename _Mylist::_Nodeptr;
+    using value_type      = typename _Mylist::value_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::const_pointer;
+    using reference       = const value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Mycont = static_cast<const _Mylist*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot dereference value-initialized forward_list iterator");
+        _STL_VERIFY(this->_Ptr != _Mycont->_Before_head(), "cannot dereference forward_list before_begin");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return this->_Ptr->_Myval;
+    }
+
+    _Flist_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(this->_Getcont(), "forward_list iterator not incrementable");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        this->_Ptr = this->_Ptr->_Next;
+        return *this;
+    }
+
+    _Flist_const_iterator operator++(int) noexcept {
+        _Flist_const_iterator _Tmp = *this;
+        this->_Ptr                 = this->_Ptr->_Next;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const _Flist_const_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "forward_list iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return this->_Ptr == _Right._Ptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const _Flist_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    friend void _Verify_range(const _Flist_const_iterator& _First, const _Flist_const_iterator& _Last) noexcept {
+        _STL_VERIFY(
+            _First._Getcont() == _Last._Getcont(), "forward_list iterators in range are from different containers");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    using _Prevent_inheriting_unwrap = _Flist_const_iterator;
+
+    _NODISCARD _Flist_unchecked_const_iterator<_Mylist> _Unwrapped() const noexcept {
+        return _Flist_unchecked_const_iterator<_Mylist>(this->_Ptr, static_cast<const _Mylist*>(this->_Getcont()));
+    }
+
+    void _Seek_to(const _Flist_unchecked_const_iterator<_Mylist> _It) noexcept {
+        this->_Ptr = _It._Ptr;
+    }
+};
+
+template <class _Mylist>
+class _Flist_iterator : public _Flist_const_iterator<_Mylist> {
+public:
+    using _Mybase           = _Flist_const_iterator<_Mylist>;
+    using iterator_category = forward_iterator_tag;
+
+    using _Nodeptr        = typename _Mylist::_Nodeptr;
+    using value_type      = typename _Mylist::value_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::pointer;
+    using reference       = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Flist_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Flist_iterator operator++(int) noexcept {
+        _Flist_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    using _Prevent_inheriting_unwrap = _Flist_iterator;
+
+    _NODISCARD _Flist_unchecked_iterator<_Mylist> _Unwrapped() const noexcept {
+        return _Flist_unchecked_iterator<_Mylist>(this->_Ptr, static_cast<const _Mylist*>(this->_Getcont()));
+    }
+};
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
+    class _Nodeptr_type>
+struct _Flist_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+    using _Nodeptr        = _Nodeptr_type;
+};
+
+template <class _Value_type, class _Voidptr>
+struct _Flist_node { // forward_list node
+    using _Nodeptr = _Rebind_pointer_t<_Voidptr, _Flist_node>;
+
+    _Nodeptr _Next;
+    _Value_type _Myval = _Returns_exactly<_Value_type>(); // fake a viable constructor to workaround GH-2749
+
+    _Flist_node()                              = default;
+    _Flist_node(const _Flist_node&)            = delete;
+    _Flist_node& operator=(const _Flist_node&) = delete;
+
+    template <class _Alnode>
+    static void _Freenode(_Alnode& _Al, _Nodeptr _Pnode) noexcept {
+        _Destroy_in_place(_Pnode->_Next);
+        allocator_traits<_Alnode>::destroy(_Al, _STD addressof(_Pnode->_Myval));
+        _Al.deallocate(_Pnode, 1);
+    }
+};
+
+template <class _Ty>
+struct _Flist_simple_types : _Simple_types<_Ty> {
+    using _Node    = _Flist_node<_Ty, void*>;
+    using _Nodeptr = _Node*;
+};
+
+template <class _Val_types>
+class _Flist_val : public _Container_base {
+public:
+    using _Nodeptr = typename _Val_types::_Nodeptr;
+    using _Node    = typename pointer_traits<_Nodeptr>::element_type;
+
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    _Flist_val() noexcept : _Myhead() {} // initialize data
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    ~_Flist_val() noexcept {
+        if constexpr (is_pointer_v<_Nodeptr>) {
+            const auto _Tombstone{reinterpret_cast<_Nodeptr>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+            _Myhead = _Tombstone;
+        }
+    }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+
+    _Nodeptr _Before_head() const noexcept { // return pointer to the "before begin" pseudo node
+        return pointer_traits<_Nodeptr>::pointer_to(reinterpret_cast<_Node&>(const_cast<_Nodeptr&>(_Myhead)));
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    void _Orphan_ptr(_Nodeptr _Ptr) noexcept { // orphan iterators with specified node pointers
+        const auto _BHead = _Before_head();
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
+        while (*_Pnext) {
+            const auto _Pnextptr = static_cast<_Flist_const_iterator<_Flist_val>&>(**_Pnext)._Ptr;
+            if (_Pnextptr == _BHead || (_Ptr != nullptr && _Pnextptr != _Ptr)) {
+                _Pnext = &(*_Pnext)->_Mynextiter;
+            } else { // orphan the iterator
+                (*_Pnext)->_Myproxy = nullptr;
+                *_Pnext             = (*_Pnext)->_Mynextiter;
+            }
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    template <class _Pr2>
+    static _Nodeptr _Inplace_merge(_Nodeptr _BFirst1, const _Nodeptr _BMid, const _Nodeptr _BLast, _Pr2 _Pred) {
+        // Merge the sorted ranges (_BFirst1, _BMid] and (_BMid, _BLast)
+        // Returns one before the new logical end of the range.
+        auto _First2 = _BMid->_Next;
+        for (;;) { // process 1 splice
+            _Nodeptr _First1;
+            for (;;) { // advance _BFirst1 over elements already in position
+                if (_BFirst1 == _BMid) {
+                    return _BLast;
+                }
+
+                _First1 = _BFirst1->_Next;
+                if (_DEBUG_LT_PRED(_Pred, _First2->_Myval, _First1->_Myval)) {
+                    // _First2->_Myval is out of order
+                    break;
+                }
+
+                // _First1->_Myval is already in position; advance
+                _BFirst1 = _First1;
+            }
+
+            // find the end of the "run" of elements less than _First1->_Myval in the 2nd range
+            auto _BRun_end = _First2;
+            _Nodeptr _Run_end;
+            for (;;) {
+                _Run_end = _BRun_end->_Next;
+                if (_BRun_end == _BLast) {
+                    break;
+                }
+
+                if (!_DEBUG_LT_PRED(_Pred, _Run_end->_Myval, _First1->_Myval)) {
+                    // _Run_end is the first element in (_BMid->_Myval, _BLast->_Myval) that shouldn't precede
+                    // _First1->_Myval.
+                    // After the splice _First1->_Myval will be in position and must not be compared again.
+                    break;
+                }
+
+                _BRun_end = _Run_end;
+            }
+
+            _BMid->_Next     = _Run_end; // snip out the run from its old position
+            _BFirst1->_Next  = _First2; // insert into new position
+            _BRun_end->_Next = _First1;
+            if (_BRun_end == _BLast) {
+                return _BMid;
+            }
+
+            _BFirst1 = _First1;
+            _First2  = _Run_end;
+        }
+    }
+
+    template <class _Pr2>
+    static _Nodeptr _Sort2(const _Nodeptr _BFirst, _Pr2 _Pred) {
+        // Sort (_BFirst, _BFirst + 2], unless nullptr is encountered.
+        // Returns a pointer one before the end of the sorted region.
+        const auto _First1 = _BFirst->_Next;
+        if (!_First1) {
+            return _BFirst;
+        }
+
+        auto _First2 = _First1->_Next;
+        if (!_First2 || !_DEBUG_LT_PRED(_Pred, _First2->_Myval, _First1->_Myval)) {
+            return _First1;
+        }
+
+        // swap _First2 and _First1
+        _First1->_Next = _First2->_Next; // snip out *_First2
+        _BFirst->_Next = _First2; // insert *_First2 before *_First1
+        _First2->_Next = _First1;
+        return _First2;
+    }
+
+    template <class _Pr2>
+    static _Nodeptr _Sort(const _Nodeptr _BFirst, size_type _Bound, _Pr2 _Pred) {
+        // Sort (_BFirst, _BFirst + _Bound), unless nullptr is encountered.
+        // Returns a pointer one before the end of the sorted region.
+        if (_Bound <= 2) {
+            return _Sort2(_BFirst, _Pred);
+        }
+
+        const auto _Half_bound = _Bound / 2;
+        const auto _BMid       = _Sort(_BFirst, _Half_bound, _Pred);
+        if (!_BMid->_Next) {
+            return _BMid;
+        }
+
+        const auto _BLast = _Sort(_BMid, _Half_bound, _Pred);
+        return _Inplace_merge(_BFirst, _BMid, _BLast, _Pred);
+    }
+
+    template <class _Pr2>
+    static void _Sort(_Nodeptr _BFirst, _Pr2 _Pred) {
+        auto _BMid       = _Sort2(_BFirst, _Pred);
+        size_type _Bound = 2;
+        do {
+            if (!_BMid->_Next) {
+                return;
+            }
+
+            const auto _BLast = _Sort(_BMid, _Bound, _Pred);
+            _BMid             = _Inplace_merge(_BFirst, _BMid, _BLast, _Pred);
+            _Bound <<= 1;
+        } while (_Bound != 0);
+    }
+
+    _Nodeptr _Myhead; // pointer to head node
+};
+
+template <class _Alnode>
+struct _Flist_insert_after_op2 {
+    // forward_list insert-after operation which maintains exception safety
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using pointer        = typename _Alnode_traits::pointer;
+    using value_type     = typename _Alnode_traits::value_type;
+
+    explicit _Flist_insert_after_op2(_Alnode& _Al_) : _Al(_Al_), _Tail() {}
+
+    _Flist_insert_after_op2(const _Flist_insert_after_op2&)            = delete;
+    _Flist_insert_after_op2& operator=(const _Flist_insert_after_op2&) = delete;
+
+    template <class... _CArgT>
+    void _Append_n(typename _Alnode_traits::size_type _Count, const _CArgT&... _Carg) {
+        // Append _Count elements, constructed from _Carg
+        if (_Count <= 0) {
+            return;
+        }
+
+        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
+        if (_Tail == pointer{}) {
+            _Newnode._Allocate(); // throws
+            _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), _Carg...); // throws
+            _Head = _Newnode._Ptr;
+            _Tail = _Newnode._Ptr;
+            --_Count;
+        }
+
+        for (; 0 < _Count; --_Count) {
+            _Newnode._Allocate(); // throws
+            _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), _Carg...); // throws
+            _Construct_in_place(_Tail->_Next, _Newnode._Ptr);
+            _Tail = _Newnode._Ptr;
+        }
+
+        (void) _Newnode._Release();
+    }
+
+    template <class _InIt, class _Sentinel>
+    void _Append_range_unchecked(_InIt _First, const _Sentinel _Last) {
+        // Append the values in [_First, _Last)
+        if (_First == _Last) { // throws
+            return;
+        }
+
+        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
+        if (_Tail == pointer{}) {
+            _Newnode._Allocate(); // throws
+            _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), *_First); // throws
+            const auto _Newhead = _Newnode._Release();
+            _Head               = _Newhead;
+            _Tail               = _Newhead;
+            ++_First; // throws
+        }
+
+        while (_First != _Last) { // throws
+            _Newnode._Allocate(); // throws
+            _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), *_First); // throws
+            const auto _Newtail = _Newnode._Release();
+            _Construct_in_place(_Tail->_Next, _Newtail);
+            _Tail = _Newtail;
+            ++_First; // throws
+        }
+    }
+
+    pointer _Attach_after(pointer _After) noexcept {
+        // Attaches the elements in *this after _After, and resets *this to the default-initialized state
+        const auto _Local_tail = _Tail;
+        if (_Local_tail == pointer{}) {
+            return _After;
+        }
+
+        _Construct_in_place(_Local_tail->_Next, _After->_Next);
+        _After->_Next = _Head;
+        _Tail         = pointer{};
+
+        return _Local_tail;
+    }
+
+    ~_Flist_insert_after_op2() {
+        if (_Tail == pointer{}) {
+            return;
+        }
+
+        _Construct_in_place(_Tail->_Next, pointer{});
+        pointer _Subject = _Head;
+        while (_Subject) {
+            value_type::_Freenode(_Al, _STD exchange(_Subject, _Subject->_Next));
+        }
+    }
+
+private:
+    _Alnode& _Al;
+    pointer _Tail; // Points to the most recently constructed node. If pointer{}, the value of _Head is indeterminate.
+                   // _Tail->_Next is not constructed.
+    pointer _Head; // Points at the first constructed node.
+};
+
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
+class forward_list { // singly linked list
+private:
+    using _Alty          = _Rebind_alloc_t<_Alloc, _Ty>;
+    using _Alty_traits   = allocator_traits<_Alty>;
+    using _Node          = _Flist_node<_Ty, typename _Alty_traits::void_pointer>;
+    using _Alnode        = _Rebind_alloc_t<_Alloc, _Node>;
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using _Nodeptr       = typename _Alnode_traits::pointer;
+
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Ty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("forward_list<T, Allocator>", "T"));
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
+                                    "because of [container.requirements].");
+
+    using _Scary_val = _Flist_val<conditional_t<_Is_simple_alloc_v<_Alnode>, _Flist_simple_types<_Ty>,
+        _Flist_iter_types<_Ty, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
+            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Nodeptr>>>;
+
+public:
+    using value_type      = _Ty;
+    using allocator_type  = _Alloc;
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using iterator                  = _Flist_iterator<_Scary_val>;
+    using const_iterator            = _Flist_const_iterator<_Scary_val>;
+    using _Unchecked_iterator       = _Flist_unchecked_iterator<_Scary_val>;
+    using _Unchecked_const_iterator = _Flist_unchecked_const_iterator<_Scary_val>;
+
+    forward_list() noexcept(is_nothrow_default_constructible_v<_Alnode>) // strengthened
+        : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Alloc_proxy();
+    }
+
+    explicit forward_list(_CRT_GUARDOVERFLOW size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct list from _Count * _Ty(), optional allocator
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_n(_Count);
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+    forward_list(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val)
+        : _Mypair(_Zero_then_variadic_args_t{}) { // construct list from _Count * _Val
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_n(_Count, _Val);
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    forward_list(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct list from _Count * _Val, allocator
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_n(_Count, _Val);
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+    explicit forward_list(const _Alloc& _Al) noexcept // strengthened
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Alloc_proxy();
+    }
+
+    forward_list(const forward_list& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+    forward_list(const forward_list& _Right, const _Identity_t<_Alloc>& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    forward_list(_Iter _First, _Iter _Last) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    forward_list(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    forward_list(from_range_t, _Rng&& _Range) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    forward_list(from_range_t, _Rng&& _Range, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Alloc_proxy();
+        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+    }
+#endif // _HAS_CXX23
+
+    forward_list(forward_list&& _Right) noexcept // strengthened
+        : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
+        _Alloc_proxy();
+        _Take_head(_Right);
+    }
+
+    forward_list(forward_list&& _Right, const _Identity_t<_Alloc>& _Al)
+        noexcept(_Alnode_traits::is_always_equal::value) // strengthened
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (!_Alty_traits::is_always_equal::value) {
+            if (_Getal() != _Right._Getal()) {
+                _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+                _Insert_op._Append_range_unchecked(
+                    _STD make_move_iterator(_Right._Unchecked_begin()), _Default_sentinel{});
+                _Alloc_proxy();
+                _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
+                return;
+            }
+        }
+
+        _Alloc_proxy();
+        _Take_head(_Right);
+    }
+
+    forward_list& operator=(forward_list&& _Right)
+        noexcept(_Choose_pocma_v<_Alnode> != _Pocma_values::_No_propagate_allocators) /* strengthened */ {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                _Mypair._Myval2._Orphan_all();
+                clear();
+                _Mypair._Myval2._Reload_proxy(_STD _Get_proxy_allocator(_Al), _STD _Get_proxy_allocator(_Right_al));
+                _Pocma(_Al, _Right_al);
+                _Take_head(_Right);
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                _Assign_unchecked(_STD make_move_iterator(_Right._Unchecked_begin()), _Right._Unchecked_end());
+                return *this;
+            }
+        }
+
+        clear();
+        _Pocma(_Al, _Right_al);
+        _Take_head(_Right);
+        return *this;
+    }
+
+private:
+    void _Take_head(forward_list& _Right) noexcept { // take contents from _Right, same allocator
+        _Swap_proxy_and_iterators(_Right);
+        _Mypair._Myval2._Myhead = _STD exchange(_Right._Mypair._Myval2._Myhead, nullptr);
+    }
+
+public:
+    void push_front(_Ty&& _Val) { // insert element at beginning
+        _Insert_after(_Mypair._Myval2._Before_head(), _STD move(_Val));
+    }
+
+    iterator insert_after(const_iterator _Where, _Ty&& _Val) { // insert _Val after _Where
+        return emplace_after(_Where, _STD move(_Val));
+    }
+
+    template <class... _Valty>
+    _CONTAINER_EMPLACE_RETURN emplace_front(_Valty&&... _Val) { // insert element at beginning
+        _Insert_after(_Mypair._Myval2._Before_head(), _STD forward<_Valty>(_Val)...);
+
+#if _HAS_CXX17
+        return front();
+#endif // _HAS_CXX17
+    }
+
+    template <class... _Valty>
+    iterator emplace_after(const_iterator _Where, _Valty&&... _Val) { // insert element after _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list emplace_after iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _Insert_after(_Where._Ptr, _STD forward<_Valty>(_Val)...);
+        return _Make_iter(_Where._Ptr->_Next);
+    }
+
+private:
+    template <class... _Valty>
+    void _Insert_after(_Nodeptr _Pnode, _Valty&&... _Val) { // insert element after _Where
+        _Alloc_construct_ptr<_Alnode> _Newnode(_Getal());
+        _Newnode._Allocate(); // throws
+        _Alnode_traits::construct(
+            _Newnode._Al, _STD addressof(_Newnode._Ptr->_Myval), _STD forward<_Valty>(_Val)...); // throws
+        _Construct_in_place(_Newnode._Ptr->_Next, _Pnode->_Next);
+        _Pnode->_Next = _Newnode._Release();
+    }
+
+public:
+    forward_list(initializer_list<_Ty> _Ilist, const _Alloc& _Al = allocator_type())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+        insert_after(before_begin(), _Ilist.begin(), _Ilist.end());
+        _Proxy._Release();
+    }
+
+    forward_list& operator=(initializer_list<_Ty> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+
+    void assign(initializer_list<_Ty> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+    }
+
+    iterator insert_after(const_iterator _Where,
+        initializer_list<_Ty> _Ilist) { // insert initializer_list
+        return insert_after(_Where, _Ilist.begin(), _Ilist.end());
+    }
+
+    ~forward_list() noexcept {
+        clear();
+#if _ITERATOR_DEBUG_LEVEL != 0 // TRANSITION, ABI
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Delete_plain_internal(_Alproxy, _Mypair._Myval2._Myproxy);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    forward_list& operator=(const forward_list& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al       = _Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alnode>) {
+            if (_Al != _Right_al) {
+                _Mypair._Myval2._Orphan_all();
+                clear();
+                _Mypair._Myval2._Reload_proxy(_STD _Get_proxy_allocator(_Al), _STD _Get_proxy_allocator(_Right_al));
+            }
+        }
+
+        _Pocca(_Al, _Right_al);
+        _Assign_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
+
+        return *this;
+    }
+
+    _NODISCARD iterator before_begin() noexcept {
+        return iterator(_Mypair._Myval2._Before_head(), _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD const_iterator before_begin() const noexcept {
+        return const_iterator(_Mypair._Myval2._Before_head(), _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD const_iterator cbefore_begin() const noexcept {
+        return before_begin();
+    }
+
+    _NODISCARD iterator begin() noexcept {
+        return iterator(_Mypair._Myval2._Myhead, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        return const_iterator(_Mypair._Myval2._Myhead, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD iterator end() noexcept {
+        return iterator(nullptr, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        return const_iterator(nullptr, _STD addressof(_Mypair._Myval2));
+    }
+
+    _Unchecked_iterator _Unchecked_before_begin() noexcept {
+        return _Unchecked_iterator(_Mypair._Myval2._Before_head(), nullptr);
+    }
+
+    _Unchecked_iterator _Unchecked_begin() noexcept {
+        return _Unchecked_iterator(_Mypair._Myval2._Myhead, nullptr);
+    }
+
+    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
+        return _Unchecked_const_iterator(_Mypair._Myval2._Myhead, nullptr);
+    }
+
+    _Default_sentinel _Unchecked_end() const noexcept {
+        return {};
+    }
+
+    _Unchecked_const_iterator _Unchecked_end_iter() const noexcept {
+        return _Unchecked_const_iterator(nullptr, nullptr);
+    }
+
+    iterator _Make_iter(_Nodeptr _Where) const noexcept {
+        return iterator(_Where, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return end();
+    }
+
+private:
+    template <class... _Args>
+    void _Resize(_CRT_GUARDOVERFLOW size_type _Newsize, const _Args&... _Vals) {
+        auto& _Al = _Getal();
+        auto _Ptr = _Mypair._Myval2._Before_head();
+        for (;;) {
+            auto _Next = _Ptr->_Next;
+            if (!_Next) {
+                // list too short, insert remaining _Newsize objects initialized from _Vals...
+                _Flist_insert_after_op2<_Alnode> _Insert_op(_Al);
+                _Insert_op._Append_n(_Newsize, _Vals...);
+                _Insert_op._Attach_after(_Ptr);
+                return;
+            }
+
+            if (_Newsize == 0) {
+                // list is too long, erase the _Next and after
+                _Ptr->_Next = nullptr;
+                do {
+                    const auto _Nextafter = _Next->_Next;
+#if _ITERATOR_DEBUG_LEVEL == 2
+                    _Mypair._Myval2._Orphan_ptr(_Next);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+                    _Node::_Freenode(_Al, _Next);
+                    _Next = _Nextafter;
+                } while (_Next);
+
+                return;
+            }
+
+            _Ptr = _Next;
+            --_Newsize;
+        }
+    }
+
+public:
+    void resize(_CRT_GUARDOVERFLOW size_type _Newsize) {
+        _Resize(_Newsize);
+    }
+
+    void resize(_CRT_GUARDOVERFLOW size_type _Newsize, const _Ty& _Val) {
+        _Resize(_Newsize, _Val);
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        constexpr auto _Diff_max = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        return (_STD min) (_Diff_max, _Alnode_traits::max_size(_Getal()));
+    }
+
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Mypair._Myval2._Myhead == nullptr;
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+    _NODISCARD reference front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_FORWARD_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Myhead != nullptr, "front() called on empty forward_list");
+#endif
+
+        return _Mypair._Myval2._Myhead->_Myval;
+    }
+
+    _NODISCARD const_reference front() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_FORWARD_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Myhead != nullptr, "front() called on empty forward_list");
+#endif
+
+        return _Mypair._Myval2._Myhead->_Myval;
+    }
+
+    void push_front(const _Ty& _Val) {
+        _Insert_after(_Mypair._Myval2._Before_head(), _Val);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void prepend_range(_Rng&& _Range) {
+        _Insert_range_after(_Mypair._Myval2._Before_head(), _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    void pop_front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_FORWARD_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Myhead != nullptr, "pop_front() called on empty forward_list");
+#endif
+
+        _Erase_after(_Mypair._Myval2._Before_head());
+    }
+
+private:
+    template <class _UIter, class _Sentinel>
+    void _Assign_unchecked(_UIter _UFirst, const _Sentinel _ULast) {
+        auto _Myfirst = _Mypair._Myval2._Before_head();
+        for (; _UFirst != _ULast; ++_UFirst) {
+            const auto _Next = _Myfirst->_Next;
+            if (!_Next) {
+                _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+                _Insert_op._Append_range_unchecked(_STD move(_UFirst), _ULast);
+                _Insert_op._Attach_after(_Myfirst);
+                return;
+            }
+
+            _Next->_Myval = *_UFirst;
+            _Myfirst      = _Next;
+        }
+
+        for (auto _To_delete = _STD exchange(_Myfirst->_Next, nullptr); _To_delete;) {
+            const auto _Next = _To_delete->_Next;
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _Mypair._Myval2._Orphan_ptr(_To_delete);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            _Node::_Freenode(_Getal(), _To_delete);
+            _To_delete = _Next;
+        }
+    }
+
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    void assign(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Assign_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void assign_range(_Rng&& _Range) {
+        static_assert(assignable_from<_Ty&, _RANGES range_reference_t<_Rng>>,
+            "Elements must be assignable from the range's reference type (N4993 [sequence.reqmts]/60).");
+        _Assign_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    void assign(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) {
+        clear();
+        insert_after(before_begin(), _Count, _Val);
+    }
+
+    iterator insert_after(const_iterator _Where, const _Ty& _Val) { // insert _Val after _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _Insert_after(_Where._Ptr, _Val);
+        return _Make_iter(_Where._Ptr->_Next);
+    }
+
+    iterator insert_after(const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) {
+        // insert _Count * _Val after _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Count != 0) {
+            _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+            _Insert_op._Append_n(_Count, _Val);
+            _Where._Ptr = _Insert_op._Attach_after(_Where._Ptr);
+        }
+
+        return _Make_iter(_Where._Ptr);
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    iterator _Insert_range_after(_Nodeptr _Pnode, _Iter _First, const _Sent _Last) {
+        // insert [_First, _Last) after _Pnode
+        if (_First == _Last) {
+            return _Make_iter(_Pnode);
+        }
+
+        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
+        _Insert_op._Append_range_unchecked(_STD move(_First), _Last);
+        return _Make_iter(_Insert_op._Attach_after(_Pnode));
+    }
+
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    iterator insert_after(const_iterator _Where, _Iter _First, _Iter _Last) {
+        // insert [_First, _Last) after _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list insert_after location incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _STD _Adl_verify_range(_First, _Last);
+        return _Insert_range_after(_Where._Ptr, _STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    iterator insert_range_after(const_iterator _Where, _Rng&& _Range) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2),
+            "forward_list insert_range_after location incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return _Insert_range_after(_Where._Ptr, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+private:
+    void _Erase_after(_Nodeptr _Pnode) noexcept { // erase element after _Pnode
+        auto _Subject = _Pnode->_Next;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Mypair._Myval2._Orphan_ptr(_Subject);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _Pnode->_Next = _Subject->_Next;
+        _Node::_Freenode(_Getal(), _Subject);
+    }
+
+public:
+    iterator erase_after(const_iterator _Where) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list erase_after iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _Erase_after(_Where._Ptr);
+        return _Make_iter(_Where._Ptr->_Next);
+    }
+
+    iterator erase_after(const_iterator _First, const_iterator _Last) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Mycont = _STD addressof(_Mypair._Myval2);
+        _STL_VERIFY(_First._Getcont() == _Mycont && _Last._Getcont() == _Mycont,
+            "forward_list erase_after iterator range from incorrect container");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        auto _Before = _First._Ptr;
+        if (_Before != _Last._Ptr) {
+            auto& _Al = _Getal();
+            for (;;) {
+                const auto _Subject = _Before->_Next;
+                if (_Subject == _Last._Ptr) {
+                    break;
+                }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+                _Mypair._Myval2._Orphan_ptr(_Subject);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+                _Before->_Next = _Subject->_Next;
+                _Node::_Freenode(_Al, _Subject);
+            }
+        }
+
+        return _Make_iter(_Last._Ptr);
+    }
+
+    void clear() noexcept { // erase all
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Mypair._Myval2._Orphan_ptr(nullptr);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Nodeptr _Pnext;
+        _Nodeptr _Pnode = _STD exchange(_Mypair._Myval2._Myhead, nullptr);
+
+        auto& _Al = _Getal();
+        for (; _Pnode; _Pnode = _Pnext) { // delete an element
+            _Pnext = _Pnode->_Next;
+            _Node::_Freenode(_Al, _Pnode);
+        }
+    }
+
+    void swap(forward_list& _Right) noexcept /* strengthened */ {
+        using _STD swap;
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+            _Swap_proxy_and_iterators(_Right);
+            swap(_Mypair._Myval2._Myhead, _Right._Mypair._Myval2._Myhead); // intentional ADL
+        }
+    }
+
+    void splice_after(const_iterator _Where, forward_list& _Right) noexcept /* strengthened */ {
+        // splice all of _Right after _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list splice_after iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (this != _STD addressof(_Right) && !_Right.empty()) { // worth splicing, do it
+            _Splice_after(_Where._Unwrapped(), _Right, _Right._Unchecked_before_begin(), _Default_sentinel{});
+        }
+    }
+
+    void splice_after(const_iterator _Where, forward_list&& _Right) noexcept /* strengthened */ {
+        // splice all of _Right after _Where
+        splice_after(_Where, _Right);
+    }
+
+    void splice_after(const_iterator _Where, forward_list& _Right, const_iterator _First) noexcept /* strengthened */ {
+        // splice _Right (_First, _First + 2) after _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list splice_after iterator outside range");
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Right._Mypair._Myval2),
+            "forward_list splice_after iterator outside range");
+        _STL_VERIFY(_First._Ptr->_Next != nullptr, "forward_list splice_after iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Splice_after(_Where._Ptr, _Right, _First._Ptr);
+    }
+
+    void splice_after(const_iterator _Where, forward_list&& _Right, const_iterator _First) noexcept /* strengthened */ {
+        // splice _Right (_First, _First + 2) after _Where
+        splice_after(_Where, _Right, _First);
+    }
+
+    void splice_after(const_iterator _Where, forward_list& _Right, const_iterator _First, const_iterator _Last) noexcept
+    /* strengthened */ {
+        // splice _Right (_First, _Last) after _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_Mypair._Myval2), "forward_list splice_after iterator outside range");
+        const auto _Rightcont = _STD addressof(_Right._Mypair._Myval2);
+        _STL_VERIFY(_First._Getcont() == _Rightcont && _Last._Getcont() == _Rightcont,
+            "forward_list splice_after range outside right");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Splice_after(_Where._Unwrapped(), _Right, _First._Unwrapped(), _Last._Unwrapped());
+    }
+
+    void splice_after(const_iterator _Where, forward_list&& _Right, const_iterator _First,
+        const_iterator _Last) noexcept /* strengthened */ {
+        // splice _Right [_First, _Last) after _Where
+        splice_after(_Where, _Right, _First, _Last);
+    }
+
+    struct _Flist_node_remove_op {
+        // tracks nodes pending removal in a remove operation, so that program-defined predicates may reference those
+        // elements until the removal is complete.
+
+        explicit _Flist_node_remove_op(forward_list& _List_) noexcept
+            : _List(_List_), _Head(), _Tail(_STD addressof(_Head)) {}
+
+        _Flist_node_remove_op(const _Flist_node_remove_op&)            = delete;
+        _Flist_node_remove_op& operator=(const _Flist_node_remove_op&) = delete;
+
+        _Nodeptr _Transfer_back(const _Nodeptr _Predecessor) noexcept {
+            // extract _Predecessor->_Next from the container, and add it to the singly-linked list of nodes to destroy
+            // returns the successor of the removed node
+
+            // snip the node out
+            const auto _Removed = _Predecessor->_Next;
+            const auto _Next    = _Removed->_Next;
+            _Removed->_Next     = nullptr;
+            _Predecessor->_Next = _Next;
+
+            *_Tail = _Removed;
+            _Tail  = _STD addressof(_Removed->_Next);
+
+            return _Next;
+        }
+
+        ~_Flist_node_remove_op() {
+            auto& _Al    = _List._Getal();
+            auto _Target = _Head;
+            while (_Target) {
+                auto _Next = _Target->_Next;
+#if _ITERATOR_DEBUG_LEVEL == 2
+                _List._Mypair._Myval2._Orphan_ptr(_Target);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+                _Alnode_traits::destroy(_Al, _STD addressof(_Target->_Next));
+                _Alnode_traits::destroy(_Al, _STD addressof(_Target->_Myval));
+                _Al.deallocate(_Target, 1);
+                _Target = _Next;
+            }
+        }
+
+        forward_list& _List;
+        _Nodeptr _Head;
+        _Nodeptr* _Tail;
+    };
+
+    _LIST_REMOVE_RETURN remove(const _Ty& _Val) { // erase each element matching _Val
+        return remove_if([&](const _Ty& _Other) -> bool { return _Other == _Val; });
+    }
+
+    template <class _Pr1>
+    _LIST_REMOVE_RETURN remove_if(_Pr1 _Pred) { // erase each element satisfying _Pr1
+        _Flist_node_remove_op _Op(*this);
+        auto _Firstb       = _Unchecked_before_begin();
+        size_type _Removed = 0;
+
+        for (auto _First = _Unchecked_begin(); _First._Ptr;) {
+            if (_Pred(*_First)) {
+                _First._Ptr = _Op._Transfer_back(_Firstb._Ptr);
+                ++_Removed;
+            } else { // advance iterators
+                _Firstb = _First;
+                ++_First;
+            }
+        }
+
+#if _HAS_CXX20
+        return _Removed;
+#else
+        (void) _Removed;
+#endif
+    }
+
+    _LIST_REMOVE_RETURN unique() { // erase each element matching previous
+        return unique(equal_to<>{});
+    }
+
+    template <class _Pr2>
+    _LIST_REMOVE_RETURN unique(_Pr2 _Pred) { // erase each element satisfying _Pred with previous
+        _Flist_node_remove_op _Op(*this);
+        auto _First        = _Unchecked_begin();
+        size_type _Removed = 0;
+        if (_First._Ptr) { // worth doing
+            auto _After = _First;
+            ++_After;
+            while (_After._Ptr) {
+                if (_Pred(*_First, *_After)) {
+                    _After._Ptr = _Op._Transfer_back(_First._Ptr);
+                    ++_Removed;
+                } else {
+                    _First = _After;
+                    ++_After;
+                }
+            }
+        }
+
+#if _HAS_CXX20
+        return _Removed;
+#else
+        (void) _Removed;
+#endif
+    }
+
+    void merge(forward_list& _Right) { // merge in elements from _Right, both ordered by operator<
+        _Merge1(_Right, less<>{});
+    }
+
+    void merge(forward_list&& _Right) { // merge in elements from _Right, both ordered by operator<
+        _Merge1(_Right, less<>{});
+    }
+
+    template <class _Pr2>
+    void merge(forward_list& _Right, _Pr2 _Pred) { // merge in elements from _Right, both ordered by _Pred
+        _Merge1(_Right, _STD _Pass_fn(_Pred));
+    }
+
+    template <class _Pr2>
+    void merge(forward_list&& _Right, _Pr2 _Pred) { // merge in elements from _Right, both ordered by _Pred
+        _Merge1(_Right, _STD _Pass_fn(_Pred));
+    }
+
+private:
+    template <class _Pr2>
+    void _Merge1(forward_list& _Right, _Pr2 _Pred) { // merge in elements from _Right, both ordered by _Pred
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _DEBUG_ORDER_UNWRAPPED(_Unchecked_begin(), _Default_sentinel{}, _Pred);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        if (this == _STD addressof(_Right)) {
+            return;
+        }
+
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _DEBUG_ORDER_UNWRAPPED(_Right._Unchecked_begin(), _Default_sentinel{}, _Pred);
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            _STL_VERIFY(_Getal() == _Right._Getal(), "forward_list allocators incompatible for merge");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        if (!_My_data._Myhead) {
+            // *this is empty; take all elements of _Right with no comparisons
+#if _ITERATOR_DEBUG_LEVEL == 2
+            {
+                _Lockit _Lock(_LOCK_DEBUG);
+                _Transfer_non_before_begin_ownership(_Right);
+            } // unlock
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            _My_data._Myhead    = _Right_data._Myhead;
+            _Right_data._Myhead = nullptr;
+            return;
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        constexpr bool _Noexcept =
+            noexcept(_DEBUG_LT_PRED(_Pred, _My_data._Myhead->_Myval, _Right_data._Myhead->_Myval));
+        if constexpr (_Noexcept) {
+            // if the comparison is noexcept, we can take all the iterators in one go and avoid quadratic updates of
+            // the iterator chain
+            _Lockit _Lock(_LOCK_DEBUG);
+            _Transfer_non_before_begin_ownership(_Right);
+        } // unlock
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (!_Right_data._Myhead) {
+            return;
+        }
+
+        auto _BFirst1 = _My_data._Before_head();
+        auto _First2  = _Right_data._Myhead;
+        for (;;) { // process 1 splice
+            _Nodeptr _First1;
+            for (;;) { // advance _BFirst1 over elements already in position
+                _First1 = _BFirst1->_Next;
+                if (!_First1) { // all elements in _Right are greater than elements in *this, splice them all
+                    _BFirst1->_Next     = _First2;
+                    _Right_data._Myhead = nullptr;
+                    return;
+                }
+
+                if (_DEBUG_LT_PRED(_Pred, _First2->_Myval, _First1->_Myval)) {
+                    // _First2->_Myval is out of order
+                    break;
+                }
+
+                // _First1->_Myval is already in position; advance
+                _BFirst1 = _First1;
+            }
+
+            // find the end of the "run" of elements less than _First1->_Myval in _Right
+            auto _BRun_end = _First2;
+            _Nodeptr _Run_end;
+            for (;;) {
+                _Run_end = _BRun_end->_Next;
+                if (!_Run_end) {
+                    break;
+                }
+
+                if (!_DEBUG_LT_PRED(_Pred, _Run_end->_Myval, _First1->_Myval)) {
+                    // _Run_end is the first element in _Right that shouldn't precede _First1->_Myval.
+                    // After the splice _First1->_Myval will be in position and must not be compared again.
+                    break;
+                }
+
+                _BRun_end = _Run_end;
+            }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+            if constexpr (!_Noexcept) {
+                _Lockit _Lock(_LOCK_DEBUG);
+                for (auto _Next = _First2; _Next != _Run_end; _Next = _Next->_Next) {
+                    _Transfer_ownership(_Right, _Next);
+                }
+            } // unlock
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+            _Right_data._Myhead = _Run_end; // snip out the run from its old position
+            _BFirst1->_Next     = _First2; // insert into new position
+            _BRun_end->_Next    = _First1;
+            if (!_Run_end) {
+                return;
+            }
+
+            _BFirst1 = _First1;
+            _First2  = _Run_end;
+        }
+    }
+
+public:
+    void sort() { // order sequence
+        _Scary_val::_Sort(_Mypair._Myval2._Before_head(), less<>{});
+    }
+
+    template <class _Pr2>
+    void sort(_Pr2 _Pred) { // order sequence
+        _Scary_val::_Sort(_Mypair._Myval2._Before_head(), _STD _Pass_fn(_Pred));
+    }
+
+    void reverse() noexcept { // reverse sequence
+        auto _Current = _Mypair._Myval2._Myhead;
+        if (!_Current) {
+            // empty forward_list
+            return;
+        }
+
+        _Nodeptr _Prev{};
+        for (;;) {
+            const auto _Next = _Current->_Next;
+            _Current->_Next  = _Prev;
+            if (!_Next) {
+                _Mypair._Myval2._Myhead = _Current;
+                return;
+            }
+
+            _Prev    = _Current;
+            _Current = _Next;
+        }
+    }
+
+private:
+#if _ITERATOR_DEBUG_LEVEL == 2
+    void _Transfer_non_before_begin_ownership(forward_list& _Right) noexcept {
+        // requires holding the debug lock
+        const auto _Mycont            = _STD addressof(_Mypair._Myval2);
+        const auto _Myproxy           = _Mycont->_Myproxy;
+        const auto _Right_before_head = _Right._Mypair._Myval2._Before_head();
+        _Iterator_base12** _Pnext     = &_Right._Mypair._Myval2._Myproxy->_Myfirstiter;
+        while (*_Pnext) {
+            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
+            if (_Pnextptr == _Right_before_head) {
+                _Pnext = &(*_Pnext)->_Mynextiter;
+            } else { // take the iterator
+                const auto _Extracted   = *_Pnext;
+                *_Pnext                 = (*_Pnext)->_Mynextiter;
+                _Extracted->_Myproxy    = _Myproxy;
+                _Extracted->_Mynextiter = _Myproxy->_Myfirstiter;
+                _Myproxy->_Myfirstiter  = _Extracted;
+            }
+        }
+    }
+
+    void _Transfer_ownership(forward_list& _Right, _Nodeptr _Target) noexcept {
+        // requires holding the debug lock
+        const auto _Mycont        = _STD addressof(_Mypair._Myval2);
+        const auto _Myproxy       = _Mycont->_Myproxy;
+        _Iterator_base12** _Pnext = &_Right._Mypair._Myval2._Myproxy->_Myfirstiter;
+        while (*_Pnext) {
+            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
+            if (_Pnextptr != _Target) {
+                _Pnext = &(*_Pnext)->_Mynextiter;
+            } else { // take the iterator
+                const auto _Extracted   = *_Pnext;
+                *_Pnext                 = (*_Pnext)->_Mynextiter;
+                _Extracted->_Myproxy    = _Myproxy;
+                _Extracted->_Mynextiter = _Myproxy->_Myfirstiter;
+                _Myproxy->_Myfirstiter  = _Extracted;
+            }
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    void _Splice_after(_Nodeptr _Where, forward_list& _Right, _Nodeptr _Prev) noexcept {
+        // splice _Right (_Prev, _Prev + 2) after _Where
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Right;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            _STL_VERIFY(_Getal() == _Right._Getal(), "forward_list containers incompatible for splice_after");
+        }
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        if (this != _STD addressof(_Right)) {
+            _Lockit _Lock(_LOCK_DEBUG);
+            _Transfer_ownership(_Right, _Prev->_Next);
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Where != _Prev) {
+            const auto _First = _Prev->_Next;
+            if (_Where != _First) {
+                _Prev->_Next  = _First->_Next;
+                _First->_Next = _Where->_Next;
+                _Where->_Next = _First;
+            }
+        }
+    }
+
+    template <class _Sentinel>
+    void _Splice_after(_Unchecked_const_iterator _Where, forward_list& _Right, _Unchecked_const_iterator _First,
+        _Sentinel _Last) noexcept {
+        // splice _Right (_First, _Last) just after _Where
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Right;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            _STL_VERIFY(_Getal() == _Right._Getal(), "forward_list containers incompatible for splice_after");
+        }
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+
+        if (_First == _Last) {
+            return;
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        if (this != _STD addressof(_Right)) { // transfer ownership of (_First, _Last)
+            _Lockit _Lock(_LOCK_DEBUG);
+            _Unchecked_const_iterator _Next = _First;
+            while (++_Next != _Last) { // transfer ownership
+                _Transfer_ownership(_Right, _Next._Ptr);
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        // find prev(_Last)
+        _Unchecked_const_iterator _After = _First;
+        ++_After;
+        if (_After == _Last) {
+            return;
+        }
+
+        _Unchecked_const_iterator _Prev_last = _First;
+        do {
+            _Prev_last = _After;
+            ++_After;
+        } while (_After != _Last);
+
+        const auto _Extracted_head = _First._Ptr->_Next;
+        _First._Ptr->_Next         = _After._Ptr;
+        _Prev_last._Ptr->_Next     = _Where._Ptr->_Next;
+        _Where._Ptr->_Next         = _Extracted_head;
+    }
+
+    void _Alloc_proxy() {
+        _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    void _Swap_proxy_and_iterators(forward_list& _Right) noexcept {
+        _Mypair._Myval2._Swap_proxy_and_iterators(_Right._Mypair._Myval2);
+    }
+
+    _Alnode& _Getal() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    const _Alnode& _Getal() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _Compressed_pair<_Alnode, _Scary_val> _Mypair;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+forward_list(_Iter, _Iter, _Alloc = _Alloc()) -> forward_list<_Iter_value_t<_Iter>, _Alloc>;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+forward_list(from_range_t, _Rng&&, _Alloc = _Alloc()) -> forward_list<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+void swap(forward_list<_Ty, _Alloc>& _Left, forward_list<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD bool operator==(const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
+    return _STD equal(
+        _Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin(), _Right._Unchecked_end_iter());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD _Synth_three_way_result<_Ty> operator<=>(
+    const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
+    return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
+        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator!=(const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator<(const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
+    return _STD lexicographical_compare(
+        _Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin(), _Right._Unchecked_end_iter());
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator>(const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator<=(const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator>=(const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
+forward_list<_Ty, _Alloc>::size_type erase(forward_list<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
+    return _Cont.remove_if([&](const _Ty& _Elem) -> bool { return _Elem == _Val; });
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
+forward_list<_Ty, _Alloc>::size_type erase_if(forward_list<_Ty, _Alloc>& _Cont, _Pr _Pred) {
+    return _Cont.remove_if(_STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Ty>
+    using forward_list = _STD forward_list<_Ty, polymorphic_allocator<_Ty>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FORWARD_LIST_
diff --git a/msvc-stl/stl/inc/fstream b/msvc-stl/stl/inc/fstream
new file mode 100644
index 0000000..35d48b2
--- /dev/null
+++ b/msvc-stl/stl/inc/fstream
@@ -0,0 +1,477 @@
+// fstream standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _FSTREAM_
+#define _FSTREAM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_filebuf.hpp>
+#include <istream>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_ifstream : public basic_istream<_Elem, _Traits> { // input stream associated with a C stream
+public:
+    using _Mybase = basic_istream<_Elem, _Traits>;
+    using _Myfb   = basic_filebuf<_Elem, _Traits>;
+    using _Myios  = basic_ios<_Elem, _Traits>;
+
+    basic_ifstream() : _Mybase(_STD addressof(_Filebuffer)) {}
+
+    explicit basic_ifstream(
+        const char* _Filename, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
+        : _Mybase(_STD addressof(_Filebuffer)) {
+        // _Prot is an extension
+        if (!_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot)) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    explicit basic_ifstream(
+        const string& _Str, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
+        : basic_ifstream(_Str.c_str(), _Mode, _Prot) {} // _Prot is an extension
+
+    explicit basic_ifstream(
+        const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
+        : _Mybase(_STD addressof(_Filebuffer)) {
+        // in standard as const std::filesystem::path::value_type *; _Prot is an extension
+        if (!_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot)) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    explicit basic_ifstream(
+        const wstring& _Str, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
+        : basic_ifstream(_Str.c_str(), _Mode, _Prot) {} // extension
+
+#if _HAS_CXX17
+    template <class _Ty, enable_if_t<is_same_v<_Ty, filesystem::path>, int> = 0>
+    explicit basic_ifstream(
+        const _Ty& _Path, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
+        : basic_ifstream(_Path.c_str(), _Mode, _Prot) {} // _Prot is an extension
+#endif // _HAS_CXX17
+
+    explicit basic_ifstream(FILE* _File)
+        : _Mybase(_STD addressof(_Filebuffer)), _Filebuffer(_File) {} // extension, no ownership taking
+
+    basic_ifstream(basic_ifstream&& _Right) : _Mybase(_STD addressof(_Filebuffer)) {
+        _Assign_rv(_STD move(_Right));
+    }
+
+    basic_ifstream& operator=(basic_ifstream&& _Right) {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void _Assign_rv(basic_ifstream&& _Right) {
+        if (this != _STD addressof(_Right)) {
+            _Filebuffer.close();
+            this->swap(_Right);
+        }
+    }
+
+    void swap(basic_ifstream& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Filebuffer.swap(_Right._Filebuffer);
+        }
+    }
+
+    basic_ifstream(const basic_ifstream&)            = delete;
+    basic_ifstream& operator=(const basic_ifstream&) = delete;
+
+    void open(
+        const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot) {
+        // in standard as const std::filesystem::path::value_type *; _Prot is an extension
+        if (_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot)) {
+            _Myios::clear();
+        } else {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    void open(const wstring& _Str, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot) {
+        // extension
+        open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_CXX17
+    template <int = 0, class _Path_ish = filesystem::path>
+    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::in,
+        int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        open(_Path.c_str(), _Mode, _Prot);
+    }
+#endif // _HAS_CXX17
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void open(const wchar_t* _Filename, ios_base::open_mode _Mode) {
+        // in standard as const std::filesystem::path::value_type *
+        open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    __CLR_OR_THIS_CALL ~basic_ifstream() noexcept override {}
+
+    _NODISCARD _Myfb* rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Myfb*>(_STD addressof(_Filebuffer));
+    }
+
+    _NODISCARD bool is_open() const noexcept /* strengthened */ {
+        return _Filebuffer.is_open();
+    }
+
+    void open(
+        const char* _Filename, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        if (_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot)) {
+            _Myios::clear();
+        } else {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    void open(const string& _Str, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void open(const char* _Filename, ios_base::open_mode _Mode) {
+        open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    void close() {
+        if (!_Filebuffer.close()) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+private:
+    _Myfb _Filebuffer;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_ifstream<_Elem, _Traits>& _Left, basic_ifstream<_Elem, _Traits>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_ofstream : public basic_ostream<_Elem, _Traits> { // output stream associated with a C stream
+public:
+    using _Mybase = basic_ostream<_Elem, _Traits>;
+    using _Myfb   = basic_filebuf<_Elem, _Traits>;
+    using _Myios  = basic_ios<_Elem, _Traits>;
+
+    basic_ofstream() : _Mybase(_STD addressof(_Filebuffer)) {}
+
+    explicit basic_ofstream(const char* _Filename, ios_base::openmode _Mode = ios_base::out,
+        int _Prot = ios_base::_Default_open_prot)
+        : _Mybase(_STD addressof(_Filebuffer)) { // _Prot is an extension
+        if (!_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot)) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    explicit basic_ofstream(
+        const string& _Str, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot)
+        : basic_ofstream(_Str.c_str(), _Mode, _Prot) {} // _Prot is an extension
+
+    explicit basic_ofstream(
+        const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot)
+        : _Mybase(_STD addressof(_Filebuffer)) {
+        // in standard as const std::filesystem::path::value_type *; _Prot is an extension
+        if (!_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot)) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    explicit basic_ofstream(
+        const wstring& _Str, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot)
+        : basic_ofstream(_Str.c_str(), _Mode, _Prot) {} // extension
+
+#if _HAS_CXX17
+    template <class _Ty, enable_if_t<is_same_v<_Ty, filesystem::path>, int> = 0>
+    explicit basic_ofstream(
+        const _Ty& _Path, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot)
+        : basic_ofstream(_Path.c_str(), _Mode, _Prot) {} // _Prot is an extension
+#endif // _HAS_CXX17
+
+    explicit basic_ofstream(FILE* _File)
+        : _Mybase(_STD addressof(_Filebuffer)), _Filebuffer(_File) {} // extension, no ownership taking
+
+    basic_ofstream(basic_ofstream&& _Right) : _Mybase(_STD addressof(_Filebuffer)) {
+        _Assign_rv(_STD move(_Right));
+    }
+
+    basic_ofstream& operator=(basic_ofstream&& _Right) {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void _Assign_rv(basic_ofstream&& _Right) {
+        if (this != _STD addressof(_Right)) {
+            _Filebuffer.close();
+            this->swap(_Right);
+        }
+    }
+
+    void swap(basic_ofstream& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Filebuffer.swap(_Right._Filebuffer);
+        }
+    }
+
+    basic_ofstream(const basic_ofstream&)            = delete;
+    basic_ofstream& operator=(const basic_ofstream&) = delete;
+
+    void open(
+        const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot) {
+        // in standard as const std::filesystem::path::value_type *; _Prot is an extension
+        if (_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot)) {
+            _Myios::clear();
+        } else {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    void open(const wstring& _Str, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot) {
+        // extension
+        open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_CXX17
+    template <int = 0, class _Path_ish = filesystem::path>
+    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::out,
+        int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        open(_Path.c_str(), _Mode, _Prot);
+    }
+#endif // _HAS_CXX17
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void open(const wchar_t* _Filename, ios_base::open_mode _Mode) {
+        // in standard as const std::filesystem::path::value_type *
+        open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    __CLR_OR_THIS_CALL ~basic_ofstream() noexcept override {}
+
+    _NODISCARD _Myfb* rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Myfb*>(_STD addressof(_Filebuffer));
+    }
+
+    _NODISCARD bool is_open() const noexcept /* strengthened */ {
+        return _Filebuffer.is_open();
+    }
+
+    void open(
+        const char* _Filename, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        if (_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot)) {
+            _Myios::clear();
+        } else {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    void open(const string& _Str, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void open(const char* _Filename, ios_base::open_mode _Mode) {
+        open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    void close() {
+        if (!_Filebuffer.close()) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+private:
+    _Myfb _Filebuffer;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_ofstream<_Elem, _Traits>& _Left, basic_ofstream<_Elem, _Traits>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_fstream : public basic_iostream<_Elem, _Traits> { // input/output stream associated with a C stream
+public:
+    using _Mybase     = basic_iostream<_Elem, _Traits>;
+    using _Myfb       = basic_filebuf<_Elem, _Traits>;
+    using _Myios      = basic_ios<_Elem, _Traits>;
+    using char_type   = _Elem;
+    using traits_type = _Traits;
+    using int_type    = typename _Traits::int_type;
+    using pos_type    = typename _Traits::pos_type;
+    using off_type    = typename _Traits::off_type;
+
+    basic_fstream() : _Mybase(_STD addressof(_Filebuffer)) {}
+
+    explicit basic_fstream(const char* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot)
+        : _Mybase(_STD addressof(_Filebuffer)) { // _Prot is an extension
+        if (!_Filebuffer.open(_Filename, _Mode, _Prot)) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    explicit basic_fstream(const string& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot)
+        : basic_fstream(_Str.c_str(), _Mode, _Prot) {} // _Prot is an extension
+
+    explicit basic_fstream(const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot)
+        : _Mybase(_STD addressof(_Filebuffer)) {
+        // in standard as const std::filesystem::path::value_type *; _Prot is an extension
+        if (!_Filebuffer.open(_Filename, _Mode, _Prot)) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    explicit basic_fstream(const wstring& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot)
+        : basic_fstream(_Str.c_str(), _Mode, _Prot) {} // extension
+
+#if _HAS_CXX17
+    template <class _Ty, enable_if_t<is_same_v<_Ty, filesystem::path>, int> = 0>
+    explicit basic_fstream(const _Ty& _Path, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot)
+        : basic_fstream(_Path.c_str(), _Mode, _Prot) {} // _Prot is an extension
+#endif // _HAS_CXX17
+
+    explicit basic_fstream(FILE* _File)
+        : _Mybase(_STD addressof(_Filebuffer)), _Filebuffer(_File) {} // extension, no ownership taking
+
+    basic_fstream(basic_fstream&& _Right) : _Mybase(_STD addressof(_Filebuffer)) {
+        _Assign_rv(_STD move(_Right));
+    }
+
+    basic_fstream& operator=(basic_fstream&& _Right) {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void _Assign_rv(basic_fstream&& _Right) {
+        if (this != _STD addressof(_Right)) {
+            _Filebuffer.close();
+            this->swap(_Right);
+        }
+    }
+
+    void swap(basic_fstream& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Filebuffer.swap(_Right._Filebuffer);
+        }
+    }
+
+    basic_fstream(const basic_fstream&)            = delete;
+    basic_fstream& operator=(const basic_fstream&) = delete;
+
+    void open(const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot) {
+        // in standard as const std::filesystem::path::value_type *; _Prot is an extension
+        if (_Filebuffer.open(_Filename, _Mode, _Prot)) {
+            _Myios::clear();
+        } else {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    void open(const wstring& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot) {
+        // extension
+        open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_CXX17
+    template <int = 0, class _Path_ish = filesystem::path>
+    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        open(_Path.c_str(), _Mode, _Prot);
+    }
+#endif // _HAS_CXX17
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void open(const wchar_t* _Filename, ios_base::open_mode _Mode) {
+        // in standard as const std::filesystem::path::value_type *
+        open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    __CLR_OR_THIS_CALL ~basic_fstream() noexcept override {}
+
+    _NODISCARD _Myfb* rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Myfb*>(_STD addressof(_Filebuffer));
+    }
+
+    _NODISCARD bool is_open() const noexcept /* strengthened */ {
+        return _Filebuffer.is_open();
+    }
+
+    void open(const char* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        if (_Filebuffer.open(_Filename, _Mode, _Prot)) {
+            _Myios::clear();
+        } else {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+    void open(const string& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out,
+        int _Prot = ios_base::_Default_open_prot) {
+        // _Prot is an extension
+        open(_Str.c_str(), _Mode, _Prot);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void open(const char* _Filename, ios_base::open_mode _Mode) {
+        open(_Filename, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    void close() {
+        if (!_Filebuffer.close()) {
+            _Myios::setstate(ios_base::failbit);
+        }
+    }
+
+private:
+    _Myfb _Filebuffer;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_fstream<_Elem, _Traits>& _Left, basic_fstream<_Elem, _Traits>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FSTREAM_
diff --git a/msvc-stl/stl/inc/functional b/msvc-stl/stl/inc/functional
new file mode 100644
index 0000000..b2eacf6
--- /dev/null
+++ b/msvc-stl/stl/inc/functional
@@ -0,0 +1,3454 @@
+// functional standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _FUNCTIONAL_
+#define _FUNCTIONAL_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <exception>
+#include <tuple>
+#include <typeinfo>
+#include <xmemory>
+
+#if _HAS_CXX17
+#ifdef _LEGACY_CODE_ASSUMES_FUNCTIONAL_INCLUDES_MEMORY
+#include <memory>
+#endif // defined(_LEGACY_CODE_ASSUMES_FUNCTIONAL_INCLUDES_MEMORY)
+#include <unordered_map>
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+// plus, minus, and multiplies are defined in <xutility>
+
+_EXPORT_STD template <class _Ty = void>
+struct divides {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left / _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct modulus {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left % _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct negate {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left) const {
+        return -_Left;
+    }
+};
+
+// less is defined in <type_traits>
+// equal_to, not_equal_to, greater, greater_equal, and less_equal are defined in <xutility>
+
+_EXPORT_STD template <class _Ty = void>
+struct logical_and {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left && _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct logical_or {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left || _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct logical_not {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left) const {
+        return !_Left;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct bit_and {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left & _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct bit_or {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left | _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct bit_xor {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left ^ _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct bit_not {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left) const {
+        return ~_Left;
+    }
+};
+
+// void specializations of plus, minus, and multiplies are defined in <xutility>
+
+template <>
+struct divides<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) / _STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) / _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct modulus<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) % _STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) % _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct negate<void> {
+    template <class _Ty>
+    _NODISCARD constexpr auto operator()(_Ty&& _Left) const -> decltype(-_STD forward<_Ty>(_Left)) {
+        return -_STD forward<_Ty>(_Left);
+    }
+
+    using is_transparent = int;
+};
+// void specialization of less is defined in <type_traits>
+// void specializations of equal_to, not_equal_to, greater, greater_equal, and less_equal are defined in <xutility>
+
+template <>
+struct logical_and<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) && _STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) && _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct logical_or<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) || _STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) || _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct logical_not<void> {
+    template <class _Ty>
+    _NODISCARD constexpr auto operator()(_Ty&& _Left) const -> decltype(!_STD forward<_Ty>(_Left)) {
+        return !_STD forward<_Ty>(_Left);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct bit_and<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) & _STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) & _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct bit_or<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) | _STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) | _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct bit_xor<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) ^ _STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) ^ _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct bit_not<void> {
+    template <class _Ty>
+    _NODISCARD constexpr auto operator()(_Ty&& _Left) const -> decltype(~_STD forward<_Ty>(_Left)) {
+        return ~_STD forward<_Ty>(_Left);
+    }
+
+    using is_transparent = int;
+};
+
+struct _Bit_xnor {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(~(_STD forward<_Ty1>(_Left) ^ _STD forward<_Ty2>(_Right))) {
+        return ~(_STD forward<_Ty1>(_Left) ^ _STD forward<_Ty2>(_Right));
+    }
+
+    using is_transparent = int;
+};
+
+struct _Bit_imply {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(~_STD forward<_Ty1>(_Left) | _STD forward<_Ty2>(_Right)) {
+        return ~_STD forward<_Ty1>(_Left) | _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+struct _Bit_cimply {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) | ~_STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) | ~_STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+struct _Bit_nimply {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(_STD forward<_Ty1>(_Left) & ~_STD forward<_Ty2>(_Right)) {
+        return _STD forward<_Ty1>(_Left) & ~_STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+struct _Bit_cnimply {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        -> decltype(~_STD forward<_Ty1>(_Left) & _STD forward<_Ty2>(_Right)) {
+        return ~_STD forward<_Ty1>(_Left) & _STD forward<_Ty2>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <class _Ty>
+constexpr bool _Is_vbool_functor_arg = is_void_v<_Ty> || is_integral_v<_Ty>;
+
+template <class _Ty>
+struct _Map_vb_functor<logical_and<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, bit_and<>, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<bit_and<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, bit_and<>, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<logical_or<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, bit_or<>, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<bit_or<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, bit_or<>, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<not_equal_to<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, bit_xor<>, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<bit_xor<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, bit_xor<>, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<equal_to<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, _Bit_xnor, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<less_equal<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, _Bit_imply, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<greater_equal<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, _Bit_cimply, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<less<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, _Bit_cnimply, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<greater<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, _Bit_nimply, void>;
+};
+
+template <class _Ty>
+struct _Map_vb_functor<logical_not<_Ty>> {
+    using type = conditional_t<_Is_vbool_functor_arg<_Ty>, bit_not<>, void>;
+};
+
+// bit_not isn't mapped to itself because it emits MSVC warning C4804 "'~': unsafe use of type 'bool' in operation"
+// and Clang -Wbool-operation "bitwise negation of a boolean expression; did you mean logical negation?".
+
+#if _HAS_DEPRECATED_NEGATORS
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <class _Fn>
+class _CXX17_DEPRECATE_NEGATORS unary_negate {
+public:
+    using argument_type = typename _Fn::argument_type;
+    using result_type   = bool;
+
+    constexpr explicit unary_negate(const _Fn& _Func) : _Functor(_Func) {}
+
+    _NODISCARD constexpr bool operator()(const argument_type& _Left) const {
+        return !_Functor(_Left);
+    }
+
+private:
+    _Fn _Functor;
+};
+
+_EXPORT_STD template <class _Fn>
+_CXX17_DEPRECATE_NEGATORS _NODISCARD constexpr unary_negate<_Fn> not1(const _Fn& _Func) {
+    return unary_negate<_Fn>(_Func);
+}
+
+_EXPORT_STD template <class _Fn>
+class _CXX17_DEPRECATE_NEGATORS binary_negate {
+public:
+    using first_argument_type  = typename _Fn::first_argument_type;
+    using second_argument_type = typename _Fn::second_argument_type;
+    using result_type          = bool;
+
+    constexpr explicit binary_negate(const _Fn& _Func) : _Functor(_Func) {}
+
+    _NODISCARD constexpr bool operator()(const first_argument_type& _Left, const second_argument_type& _Right) const {
+        return !_Functor(_Left, _Right);
+    }
+
+private:
+    _Fn _Functor;
+};
+
+_EXPORT_STD template <class _Fn>
+_CXX17_DEPRECATE_NEGATORS _NODISCARD constexpr binary_negate<_Fn> not2(const _Fn& _Func) {
+    return binary_negate<_Fn>(_Func);
+}
+_STL_RESTORE_DEPRECATED_WARNING
+#endif // _HAS_DEPRECATED_NEGATORS
+
+#if _HAS_AUTO_PTR_ETC
+_EXPORT_STD template <class _Arg, class _Result>
+struct _NO_SPECIALIZATIONS_CITING("N4140 [depr.base]/1") unary_function { // base class for unary functions
+    using argument_type = _Arg;
+    using result_type   = _Result;
+};
+
+_EXPORT_STD template <class _Arg1, class _Arg2, class _Result>
+struct _NO_SPECIALIZATIONS_CITING("N4140 [depr.base]/1") binary_function { // base class for binary functions
+    using first_argument_type  = _Arg1;
+    using second_argument_type = _Arg2;
+    using result_type          = _Result;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <class _Fn>
+class binder1st : public unary_function<typename _Fn::second_argument_type,
+                      typename _Fn::result_type> { // functor adapter _Func(stored, right)
+public:
+    using _Base         = unary_function<typename _Fn::second_argument_type, typename _Fn::result_type>;
+    using argument_type = typename _Base::argument_type;
+    using result_type   = typename _Base::result_type;
+
+    binder1st(const _Fn& _Func, const typename _Fn::first_argument_type& _Left) : op(_Func), value(_Left) {}
+
+    result_type operator()(const argument_type& _Right) const {
+        return op(value, _Right);
+    }
+
+    result_type operator()(argument_type& _Right) const {
+        return op(value, _Right);
+    }
+
+protected:
+    _Fn op;
+    typename _Fn::first_argument_type value; // the left operand
+};
+
+_EXPORT_STD template <class _Fn, class _Ty>
+_NODISCARD binder1st<_Fn> bind1st(const _Fn& _Func, const _Ty& _Left) {
+    typename _Fn::first_argument_type _Val(_Left);
+    return binder1st<_Fn>(_Func, _Val);
+}
+
+_EXPORT_STD template <class _Fn>
+class binder2nd : public unary_function<typename _Fn::first_argument_type,
+                      typename _Fn::result_type> { // functor adapter _Func(left, stored)
+public:
+    using _Base         = unary_function<typename _Fn::first_argument_type, typename _Fn::result_type>;
+    using argument_type = typename _Base::argument_type;
+    using result_type   = typename _Base::result_type;
+
+    binder2nd(const _Fn& _Func, const typename _Fn::second_argument_type& _Right) : op(_Func), value(_Right) {}
+
+    result_type operator()(const argument_type& _Left) const {
+        return op(_Left, value);
+    }
+
+    result_type operator()(argument_type& _Left) const {
+        return op(_Left, value);
+    }
+
+protected:
+    _Fn op;
+    typename _Fn::second_argument_type value; // the right operand
+};
+
+_EXPORT_STD template <class _Fn, class _Ty>
+_NODISCARD binder2nd<_Fn> bind2nd(const _Fn& _Func, const _Ty& _Right) {
+    typename _Fn::second_argument_type _Val(_Right);
+    return binder2nd<_Fn>(_Func, _Val);
+}
+_STL_RESTORE_DEPRECATED_WARNING
+
+_EXPORT_STD template <class _Arg, class _Result, class _Fn = _Result (*)(_Arg)>
+class pointer_to_unary_function : public unary_function<_Arg, _Result> { // functor adapter (*pfunc)(left)
+public:
+    explicit pointer_to_unary_function(_Fn _Left) : _Pfun(_Left) {}
+
+    _Result operator()(_Arg _Left) const {
+        return _Pfun(_Left);
+    }
+
+protected:
+    _Fn _Pfun; // the function pointer
+};
+
+_EXPORT_STD template <class _Arg1, class _Arg2, class _Result, class _Fn = _Result (*)(_Arg1, _Arg2)>
+class pointer_to_binary_function
+    : public binary_function<_Arg1, _Arg2, _Result> { // functor adapter (*pfunc)(left, right)
+public:
+    explicit pointer_to_binary_function(_Fn _Left) : _Pfun(_Left) {}
+
+    _Result operator()(_Arg1 _Left, _Arg2 _Right) const {
+        return _Pfun(_Left, _Right);
+    }
+
+protected:
+    _Fn _Pfun; // the function pointer
+};
+
+#define _PTR_FUN(CALL_OPT, X1, X2, X3)                                                                      \
+    _EXPORT_STD template <class _Arg, class _Result>                                                        \
+    _NODISCARD pointer_to_unary_function<_Arg, _Result, _Result(CALL_OPT*)(_Arg)> ptr_fun(                  \
+        _Result(CALL_OPT* _Left)(_Arg)) {                                                                   \
+        return pointer_to_unary_function<_Arg, _Result, _Result(CALL_OPT*)(_Arg)>(_Left);                   \
+    }                                                                                                       \
+    _EXPORT_STD template <class _Arg1, class _Arg2, class _Result>                                          \
+    _NODISCARD pointer_to_binary_function<_Arg1, _Arg2, _Result, _Result(CALL_OPT*)(_Arg1, _Arg2)> ptr_fun( \
+        _Result(CALL_OPT* _Left)(_Arg1, _Arg2)) {                                                           \
+        return pointer_to_binary_function<_Arg1, _Arg2, _Result, _Result(CALL_OPT*)(_Arg1, _Arg2)>(_Left);  \
+    }
+
+_NON_MEMBER_CALL(_PTR_FUN, X1, X2, X3)
+#undef _PTR_FUN
+
+_EXPORT_STD template <class _Result, class _Ty>
+class mem_fun_t : public unary_function<_Ty*, _Result> { // functor adapter (*p->*pfunc)(), non-const *pfunc
+public:
+    explicit mem_fun_t(_Result (_Ty::*_Pm)()) : _Pmemfun(_Pm) {}
+
+    _Result operator()(_Ty* _Pleft) const {
+        return (_Pleft->*_Pmemfun)();
+    }
+
+private:
+    _Result (_Ty::*_Pmemfun)(); // the member function pointer
+};
+
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
+class mem_fun1_t : public binary_function<_Ty*, _Arg, _Result> { // functor adapter (*p->*pfunc)(val), non-const *pfunc
+public:
+    explicit mem_fun1_t(_Result (_Ty::*_Pm)(_Arg)) : _Pmemfun(_Pm) {}
+
+    _Result operator()(_Ty* _Pleft, _Arg _Right) const {
+        return (_Pleft->*_Pmemfun)(_Right);
+    }
+
+private:
+    _Result (_Ty::*_Pmemfun)(_Arg); // the member function pointer
+};
+
+_EXPORT_STD template <class _Result, class _Ty>
+class const_mem_fun_t : public unary_function<const _Ty*, _Result> { // functor adapter (*p->*pfunc)(), const *pfunc
+public:
+    explicit const_mem_fun_t(_Result (_Ty::*_Pm)() const) : _Pmemfun(_Pm) {}
+
+    _Result operator()(const _Ty* _Pleft) const {
+        return (_Pleft->*_Pmemfun)();
+    }
+
+private:
+    _Result (_Ty::*_Pmemfun)() const; // the member function pointer
+};
+
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
+class const_mem_fun1_t
+    : public binary_function<const _Ty*, _Arg, _Result> { // functor adapter (*p->*pfunc)(val), const *pfunc
+public:
+    explicit const_mem_fun1_t(_Result (_Ty::*_Pm)(_Arg) const) : _Pmemfun(_Pm) {}
+
+    _Result operator()(const _Ty* _Pleft, _Arg _Right) const {
+        return (_Pleft->*_Pmemfun)(_Right);
+    }
+
+private:
+    _Result (_Ty::*_Pmemfun)(_Arg) const; // the member function pointer
+};
+
+_EXPORT_STD template <class _Result, class _Ty>
+_NODISCARD mem_fun_t<_Result, _Ty> mem_fun(_Result (_Ty::*_Pm)()) {
+    return mem_fun_t<_Result, _Ty>(_Pm);
+}
+
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
+_NODISCARD mem_fun1_t<_Result, _Ty, _Arg> mem_fun(_Result (_Ty::*_Pm)(_Arg)) {
+    return mem_fun1_t<_Result, _Ty, _Arg>(_Pm);
+}
+
+_EXPORT_STD template <class _Result, class _Ty>
+_NODISCARD const_mem_fun_t<_Result, _Ty> mem_fun(_Result (_Ty::*_Pm)() const) {
+    return const_mem_fun_t<_Result, _Ty>(_Pm);
+}
+
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
+_NODISCARD const_mem_fun1_t<_Result, _Ty, _Arg> mem_fun(_Result (_Ty::*_Pm)(_Arg) const) {
+    return const_mem_fun1_t<_Result, _Ty, _Arg>(_Pm);
+}
+
+_EXPORT_STD template <class _Result, class _Ty>
+class mem_fun_ref_t : public unary_function<_Ty, _Result> { // functor adapter (*left.*pfunc)(), non-const *pfunc
+public:
+    explicit mem_fun_ref_t(_Result (_Ty::*_Pm)()) : _Pmemfun(_Pm) {}
+
+    _Result operator()(_Ty& _Left) const {
+        return (_Left.*_Pmemfun)();
+    }
+
+private:
+    _Result (_Ty::*_Pmemfun)(); // the member function pointer
+};
+
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
+class mem_fun1_ref_t
+    : public binary_function<_Ty, _Arg, _Result> { // functor adapter (*left.*pfunc)(val), non-const *pfunc
+public:
+    explicit mem_fun1_ref_t(_Result (_Ty::*_Pm)(_Arg)) : _Pmemfun(_Pm) {}
+
+    _Result operator()(_Ty& _Left, _Arg _Right) const {
+        return (_Left.*_Pmemfun)(_Right);
+    }
+
+private:
+    _Result (_Ty::*_Pmemfun)(_Arg); // the member function pointer
+};
+
+_EXPORT_STD template <class _Result, class _Ty>
+class const_mem_fun_ref_t : public unary_function<_Ty, _Result> { // functor adapter (*left.*pfunc)(), const *pfunc
+public:
+    explicit const_mem_fun_ref_t(_Result (_Ty::*_Pm)() const) : _Pmemfun(_Pm) {}
+
+    _Result operator()(const _Ty& _Left) const {
+        return (_Left.*_Pmemfun)();
+    }
+
+private:
+    _Result (_Ty::*_Pmemfun)() const; // the member function pointer
+};
+
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
+class const_mem_fun1_ref_t
+    : public binary_function<_Ty, _Arg, _Result> { // functor adapter (*left.*pfunc)(val), const *pfunc
+public:
+    explicit const_mem_fun1_ref_t(_Result (_Ty::*_Pm)(_Arg) const) : _Pmemfun(_Pm) {}
+
+    _Result operator()(const _Ty& _Left, _Arg _Right) const {
+        return (_Left.*_Pmemfun)(_Right);
+    }
+
+private:
+    _Result (_Ty::*_Pmemfun)(_Arg) const; // the member function pointer
+};
+
+_EXPORT_STD template <class _Result, class _Ty>
+_NODISCARD mem_fun_ref_t<_Result, _Ty> mem_fun_ref(_Result (_Ty::*_Pm)()) {
+    return mem_fun_ref_t<_Result, _Ty>(_Pm);
+}
+
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
+_NODISCARD mem_fun1_ref_t<_Result, _Ty, _Arg> mem_fun_ref(_Result (_Ty::*_Pm)(_Arg)) {
+    return mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm);
+}
+
+_EXPORT_STD template <class _Result, class _Ty>
+_NODISCARD const_mem_fun_ref_t<_Result, _Ty> mem_fun_ref(_Result (_Ty::*_Pm)() const) {
+    return const_mem_fun_ref_t<_Result, _Ty>(_Pm);
+}
+
+_EXPORT_STD template <class _Result, class _Ty, class _Arg>
+_NODISCARD const_mem_fun1_ref_t<_Result, _Ty, _Arg> mem_fun_ref(_Result (_Ty::*_Pm)(_Arg) const) {
+    return const_mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm);
+}
+#endif // _HAS_AUTO_PTR_ETC
+
+template <class _Memptr>
+class _Mem_fn : public _Weak_types<_Memptr> {
+private:
+    _Memptr _Pm;
+
+public:
+    constexpr explicit _Mem_fn(_Memptr _Val) noexcept : _Pm(_Val) {}
+
+    template <class... _Types>
+    _CONSTEXPR20 auto operator()(_Types&&... _Args) const
+        noexcept(noexcept(_STD invoke(_Pm, _STD forward<_Types>(_Args)...)))
+            -> decltype(_STD invoke(_Pm, _STD forward<_Types>(_Args)...)) {
+        return _STD invoke(_Pm, _STD forward<_Types>(_Args)...);
+    }
+};
+
+_EXPORT_STD template <class _Rx, class _Ty>
+_NODISCARD _CONSTEXPR20 _Mem_fn<_Rx _Ty::*> mem_fn(_Rx _Ty::* _Pm) noexcept {
+    return _Mem_fn<_Rx _Ty::*>(_Pm);
+}
+
+#if _HAS_CXX17
+#if _HAS_CXX20
+template <class _Callable, class... _Types>
+concept _Can_invoke_then_negate = requires(
+    _Callable&& _Fx, _Types&&... _Args) { !_STD invoke(_STD forward<_Callable>(_Fx), _STD forward<_Types>(_Args)...); };
+#endif // _HAS_CXX20
+
+struct _Not_fn_tag {
+    explicit _Not_fn_tag() = default;
+};
+
+template <class _Decayed>
+class _Not_fn : private _Ebco_base<_Decayed> {
+private:
+    using _Mybase = _Ebco_base<_Decayed>;
+
+public:
+    template <class _Callable, class _Tag, enable_if_t<is_same_v<_Tag, _Not_fn_tag>, int> = 0>
+    constexpr explicit _Not_fn(_Callable&& _Obj, _Tag)
+        noexcept(is_nothrow_constructible_v<_Decayed, _Callable>) // strengthened
+        : _Mybase(_STD forward<_Callable>(_Obj)) {} // store a callable object
+
+    constexpr _Not_fn(const _Not_fn&) = default;
+    constexpr _Not_fn(_Not_fn&&)      = default;
+
+#if _HAS_CXX20
+    template <class... _Types>
+        requires _Can_invoke_then_negate<_Decayed&, _Types...>
+    constexpr decltype(auto) operator()(_Types&&... _Args) & noexcept(
+        noexcept(!_STD invoke(this->_Get_val(), _STD forward<_Types>(_Args)...))) {
+        return !_STD invoke(this->_Get_val(), _STD forward<_Types>(_Args)...);
+    }
+
+    template <class... _Types>
+        requires _Can_invoke_then_negate<const _Decayed&, _Types...>
+    constexpr decltype(auto) operator()(_Types&&... _Args) const& noexcept(
+        noexcept(!_STD invoke(this->_Get_val(), _STD forward<_Types>(_Args)...))) {
+        return !_STD invoke(this->_Get_val(), _STD forward<_Types>(_Args)...);
+    }
+
+    template <class... _Types>
+        requires _Can_invoke_then_negate<_Decayed, _Types...>
+    constexpr decltype(auto) operator()(_Types&&... _Args) && noexcept(
+        noexcept(!_STD invoke(_STD move(this->_Get_val()), _STD forward<_Types>(_Args)...))) {
+        return !_STD invoke(_STD move(this->_Get_val()), _STD forward<_Types>(_Args)...);
+    }
+
+    template <class... _Types>
+        requires _Can_invoke_then_negate<const _Decayed, _Types...>
+    constexpr decltype(auto) operator()(_Types&&... _Args) const&& noexcept(
+        noexcept(!_STD invoke(_STD move(this->_Get_val()), _STD forward<_Types>(_Args)...))) {
+        return !_STD invoke(_STD move(this->_Get_val()), _STD forward<_Types>(_Args)...);
+    }
+
+    template <class... _Types>
+    void operator()(_Types&&...) & = delete;
+
+    template <class... _Types>
+    void operator()(_Types&&...) const& = delete;
+
+    template <class... _Types>
+    void operator()(_Types&&...) && = delete;
+
+    template <class... _Types>
+    void operator()(_Types&&...) const&& = delete;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    template <class... _Types>
+    auto operator()(_Types&&... _Args) & noexcept(
+        noexcept(!_STD invoke(this->_Get_val(), _STD forward<_Types>(_Args)...)))
+        -> decltype(!_STD declval<invoke_result_t<_Decayed&, _Types...>>()) {
+        return !_STD invoke(this->_Get_val(), _STD forward<_Types>(_Args)...);
+    }
+
+    template <class... _Types>
+    auto operator()(_Types&&... _Args) const& noexcept(
+        noexcept(!_STD invoke(this->_Get_val(), _STD forward<_Types>(_Args)...)))
+        -> decltype(!_STD declval<invoke_result_t<const _Decayed&, _Types...>>()) {
+        return !_STD invoke(this->_Get_val(), _STD forward<_Types>(_Args)...);
+    }
+
+    template <class... _Types>
+    auto operator()(_Types&&... _Args) && noexcept(
+        noexcept(!_STD invoke(_STD move(this->_Get_val()), _STD forward<_Types>(_Args)...)))
+        -> decltype(!_STD declval<invoke_result_t<_Decayed, _Types...>>()) {
+        return !_STD invoke(_STD move(this->_Get_val()), _STD forward<_Types>(_Args)...);
+    }
+
+    template <class... _Types>
+    auto operator()(_Types&&... _Args) const&& noexcept(
+        noexcept(!_STD invoke(_STD move(this->_Get_val()), _STD forward<_Types>(_Args)...)))
+        -> decltype(!_STD declval<invoke_result_t<const _Decayed, _Types...>>()) {
+        return !_STD invoke(_STD move(this->_Get_val()), _STD forward<_Types>(_Args)...);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+};
+
+_EXPORT_STD template <class _Callable>
+_NODISCARD _CONSTEXPR20 _Not_fn<decay_t<_Callable>> not_fn(_Callable&& _Obj)
+    noexcept(is_nothrow_constructible_v<decay_t<_Callable>, _Callable>) /* strengthened */ {
+    // wrap a callable object to be negated
+    static_assert(is_move_constructible_v<decay_t<_Callable>>,
+        "the callable type used with std::not_fn should be move constructible.");
+    return _Not_fn<decay_t<_Callable>>(_STD forward<_Callable>(_Obj), _Not_fn_tag{});
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD class _NODISCARD bad_function_call : public exception {
+    // exception thrown when an empty std::function is called
+public:
+    bad_function_call() noexcept {}
+
+    _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
+        // return pointer to message string
+        return "bad function call";
+    }
+};
+
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_function_call();
+
+_EXPORT_STD template <class _Fty>
+class function;
+
+template <class _Ty>
+constexpr bool _Testable_callable_v =
+    disjunction_v<is_pointer<_Ty>, _Is_specialization<_Ty, function>, is_member_pointer<_Ty>>;
+
+template <class _Ty>
+bool _Test_callable(const _Ty& _Arg) noexcept { // determine whether std::function must store _Arg
+    if constexpr (_Testable_callable_v<_Ty>) {
+        return static_cast<bool>(_Arg);
+    } else {
+        return true;
+    }
+}
+
+template <class _Rx, class... _Types>
+class __declspec(novtable) _Func_base { // abstract base for implementation types
+public:
+    virtual _Func_base* _Copy(void*) const                 = 0;
+    virtual _Func_base* _Move(void*) noexcept              = 0;
+    virtual _Rx _Do_call(_Types&&...)                      = 0;
+    virtual const type_info& _Target_type() const noexcept = 0;
+    virtual void _Delete_this(bool) noexcept               = 0;
+
+#if _HAS_STATIC_RTTI
+    const void* _Target(const type_info& _Info) const noexcept {
+        return _Target_type() == _Info ? _Get() : nullptr;
+    }
+#endif // _HAS_STATIC_RTTI
+
+    _Func_base()                             = default;
+    _Func_base(const _Func_base&)            = delete;
+    _Func_base& operator=(const _Func_base&) = delete;
+    // dtor non-virtual due to _Delete_this()
+
+private:
+    virtual const void* _Get() const noexcept = 0;
+};
+
+_INLINE_VAR constexpr size_t _Space_size = (_Small_object_num_ptrs - 1) * sizeof(void*);
+
+template <class _Impl> // determine whether _Impl must be dynamically allocated
+constexpr bool _Is_large = sizeof(_Impl) > _Space_size || alignof(_Impl) > alignof(max_align_t)
+                        || !_Impl::_Nothrow_move::value;
+
+template <class _Callable, class _Alloc, class _Rx, class... _Types>
+class _Func_impl final : public _Func_base<_Rx, _Types...> {
+    // derived class for specific implementation types that use allocators
+public:
+    using _Mybase        = _Func_base<_Rx, _Types...>;
+    using _Myalty        = _Rebind_alloc_t<_Alloc, _Func_impl>;
+    using _Myalty_traits = allocator_traits<_Myalty>;
+    using _Nothrow_move  = is_nothrow_move_constructible<_Callable>;
+
+    template <class _Other1, class _Other2>
+    _Func_impl(_Other1&& _Val, _Other2&& _Ax)
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Other2>(_Ax), _STD forward<_Other1>(_Val)) {}
+
+    // dtor non-virtual due to _Delete_this()
+
+private:
+    _Mybase* _Copy(void* _Where) const override {
+        auto& _Myax = _Mypair._Get_first();
+        if constexpr (!is_copy_constructible_v<_Callable>) { // used exclusively for packaged_task
+            (void) _Myax;
+            _STL_REPORT_ERROR("this callable object should not be copied");
+            return nullptr;
+        } else if constexpr (_Is_large<_Func_impl>) {
+            _Myalty _Rebound(_Myax);
+            _Alloc_construct_ptr<_Myalty> _Constructor{_Rebound};
+            _Constructor._Allocate();
+            _STD _Construct_in_place(*_Constructor._Ptr, _Mypair._Myval2, _Myax);
+            return _Constructor._Release();
+        } else {
+            const auto _Ptr = static_cast<_Func_impl*>(_Where);
+            _STD _Construct_in_place(*_Ptr, _Mypair._Myval2, _Myax);
+            return _Ptr;
+        }
+    }
+
+    _Mybase* _Move(void* _Where) noexcept override {
+        if constexpr (_Is_large<_Func_impl>) {
+            return nullptr;
+        } else {
+            const auto _Ptr = static_cast<_Func_impl*>(_Where);
+            _STD _Construct_in_place(*_Ptr, _STD move(_Mypair._Myval2), _STD move(_Mypair._Get_first()));
+            return _Ptr;
+        }
+    }
+
+    _Rx _Do_call(_Types&&... _Args) override { // call wrapped function
+        if constexpr (is_void_v<_Rx>) {
+            (void) _STD invoke(_Mypair._Myval2, _STD forward<_Types>(_Args)...);
+        } else {
+            return _STD invoke(_Mypair._Myval2, _STD forward<_Types>(_Args)...);
+        }
+    }
+
+#if _HAS_STATIC_RTTI
+    const type_info& _Target_type() const noexcept override {
+        return typeid(_Callable);
+    }
+#else // ^^^ _HAS_STATIC_RTTI / !_HAS_STATIC_RTTI vvv
+    [[noreturn]] const type_info& _Target_type() const noexcept override {
+        _STL_REPORT_ERROR("type info is disabled");
+        _STL_UNREACHABLE; // no return value available for "continue on error"
+    }
+#endif // ^^^ !_HAS_STATIC_RTTI ^^^
+
+    const void* _Get() const noexcept override {
+        return _STD addressof(_Mypair._Myval2);
+    }
+
+    void _Delete_this(bool _Deallocate) noexcept override { // destroy self
+        _Myalty _Al(_Mypair._Get_first());
+        _STD _Destroy_in_place(*this);
+        if (_Deallocate) {
+            _STD _Deallocate_plain(_Al, this);
+        }
+    }
+
+    _Compressed_pair<_Alloc, _Callable> _Mypair;
+};
+
+template <class _Ty, class... _Types>
+_Ty* _Global_new(_Types&&... _Args) { // acts as "new" while disallowing user overload selection
+    struct _NODISCARD _Guard_type {
+        void* _Result;
+        ~_Guard_type() {
+            if (_Result) {
+                _STD _Deallocate<_New_alignof<_Ty>>(_Result, sizeof(_Ty));
+            }
+        }
+    };
+
+    _Guard_type _Guard{_Allocate<_New_alignof<_Ty>>(sizeof(_Ty))};
+    ::new (_Guard._Result) _Ty(_STD forward<_Types>(_Args)...);
+    return static_cast<_Ty*>(_STD exchange(_Guard._Result, nullptr));
+}
+
+template <class _Callable, class _Rx, class... _Types>
+class _Func_impl_no_alloc final : public _Func_base<_Rx, _Types...> {
+    // derived class for specific implementation types that don't use allocators
+public:
+    using _Mybase       = _Func_base<_Rx, _Types...>;
+    using _Nothrow_move = is_nothrow_move_constructible<_Callable>;
+
+    template <class _Other, enable_if_t<!is_same_v<_Func_impl_no_alloc, decay_t<_Other>>, int> = 0>
+    explicit _Func_impl_no_alloc(_Other&& _Val) : _Callee(_STD forward<_Other>(_Val)) {}
+
+    // dtor non-virtual due to _Delete_this()
+
+private:
+    _Mybase* _Copy(void* _Where) const override {
+        if constexpr (!is_copy_constructible_v<_Callable>) { // used exclusively for packaged_task
+            _STL_REPORT_ERROR("this callable object should not be copied");
+            return nullptr;
+        } else if constexpr (_Is_large<_Func_impl_no_alloc>) {
+            return _STD _Global_new<_Func_impl_no_alloc>(_Callee);
+        } else {
+            return ::new (_Where) _Func_impl_no_alloc(_Callee);
+        }
+    }
+
+    _Mybase* _Move(void* _Where) noexcept override {
+        if constexpr (_Is_large<_Func_impl_no_alloc>) {
+            return nullptr;
+        } else {
+            return ::new (_Where) _Func_impl_no_alloc(_STD move(_Callee));
+        }
+    }
+
+    _Rx _Do_call(_Types&&... _Args) override { // call wrapped function
+        if constexpr (is_void_v<_Rx>) {
+            (void) _STD invoke(_Callee, _STD forward<_Types>(_Args)...);
+        } else {
+            return _STD invoke(_Callee, _STD forward<_Types>(_Args)...);
+        }
+    }
+
+#if _HAS_STATIC_RTTI
+    const type_info& _Target_type() const noexcept override {
+        return typeid(_Callable);
+    }
+#else // ^^^ _HAS_STATIC_RTTI / !_HAS_STATIC_RTTI vvv
+    [[noreturn]] const type_info& _Target_type() const noexcept override {
+        _STL_REPORT_ERROR("type info is disabled");
+        _STL_UNREACHABLE; // no return value available for "continue on error"
+    }
+#endif // ^^^ !_HAS_STATIC_RTTI ^^^
+
+    const void* _Get() const noexcept override {
+        return _STD addressof(_Callee);
+    }
+
+    void _Delete_this(bool _Dealloc) noexcept override { // destroy self
+        this->~_Func_impl_no_alloc();
+        if (_Dealloc) {
+            _STD _Deallocate<alignof(_Func_impl_no_alloc)>(this, sizeof(_Func_impl_no_alloc));
+        }
+    }
+
+    _Callable _Callee;
+};
+
+#if _HAS_CXX23
+template <class _Rx, class... _Types>
+class _Function_base;
+#endif // _HAS_CXX23
+
+template <class _Ret, class... _Types>
+class _Func_class : public _Arg_types<_Types...> {
+public:
+    using result_type = _Ret;
+
+    using _Ptrt = _Func_base<_Ret, _Types...>;
+
+    _Func_class() noexcept {
+        _Set(nullptr);
+    }
+
+    _Ret operator()(_Types... _Args) const {
+        if (_Empty()) {
+            _Xbad_function_call();
+        }
+        const auto _Impl = _Getimpl();
+        return _Impl->_Do_call(_STD forward<_Types>(_Args)...);
+    }
+
+    ~_Func_class() noexcept {
+        _Tidy();
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        const auto _Tombstone{reinterpret_cast<_Ptrt*>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+        _Set(_Tombstone);
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    }
+
+protected:
+    template <class _Fx, class _Function>
+    using _Enable_if_callable_t = enable_if_t<conjunction_v<negation<is_same<_Remove_cvref_t<_Fx>, _Function>>,
+                                                  _Is_invocable_r<_Ret, decay_t<_Fx>&, _Types...>>,
+        int>;
+
+    bool _Empty() const noexcept {
+        return !_Getimpl();
+    }
+
+    void _Reset_copy(const _Func_class& _Right) { // copy _Right's stored object
+        if (!_Right._Empty()) {
+            _Set(_Right._Getimpl()->_Copy(&_Mystorage));
+        }
+    }
+
+    void _Reset_move(_Func_class&& _Right) noexcept { // move _Right's stored object
+        if (!_Right._Empty()) {
+            if (_Right._Local()) { // move and tidy
+                _Set(_Right._Getimpl()->_Move(&_Mystorage));
+                _Right._Tidy();
+            } else { // steal from _Right
+                _Set(_Right._Getimpl());
+                _Right._Set(nullptr);
+            }
+        }
+    }
+
+    template <class _Fx>
+    void _Reset(_Fx&& _Val) { // store copy of _Val
+        if (!_STD _Test_callable(_Val)) { // null member pointer/function pointer/std::function
+            return; // already empty
+        }
+
+        using _Impl = _Func_impl_no_alloc<decay_t<_Fx>, _Ret, _Types...>;
+        if constexpr (_Is_large<_Impl>) {
+            // dynamically allocate _Val
+            _Set(_STD _Global_new<_Impl>(_STD forward<_Fx>(_Val)));
+        } else {
+            // store _Val in-situ
+            _Set(::new (static_cast<void*>(&_Mystorage)) _Impl(_STD forward<_Fx>(_Val)));
+        }
+    }
+
+    template <class _Fx, class _Alloc>
+    void _Reset_alloc(_Fx&& _Val, const _Alloc& _Ax) { // store copy of _Val with allocator
+        if (!_STD _Test_callable(_Val)) { // null member pointer/function pointer/std::function
+            return; // already empty
+        }
+
+        using _Myimpl = _Func_impl<decay_t<_Fx>, _Alloc, _Ret, _Types...>;
+        if constexpr (_Is_large<_Myimpl>) {
+            // dynamically allocate _Val
+            using _Alimpl = _Rebind_alloc_t<_Alloc, _Myimpl>;
+            _Alimpl _Al(_Ax);
+            _Alloc_construct_ptr<_Alimpl> _Constructor{_Al};
+            _Constructor._Allocate();
+            _STD _Construct_in_place(*_Constructor._Ptr, _STD forward<_Fx>(_Val), _Ax);
+            _Set(_STD _Unfancy(_Constructor._Release()));
+        } else {
+            // store _Val in-situ
+            const auto _Ptr = reinterpret_cast<_Myimpl*>(&_Mystorage);
+            _STD _Construct_in_place(*_Ptr, _STD forward<_Fx>(_Val), _Ax);
+            _Set(_Ptr);
+        }
+    }
+
+    void _Tidy() noexcept {
+        if (!_Empty()) { // destroy callable object and maybe delete it
+            _Getimpl()->_Delete_this(!_Local());
+            _Set(nullptr);
+        }
+    }
+
+    void _Swap(_Func_class& _Right) noexcept { // swap contents with contents of _Right
+        if (!_Local() && !_Right._Local()) { // just swap pointers
+            _Ptrt* _Temp = _Getimpl();
+            _Set(_Right._Getimpl());
+            _Right._Set(_Temp);
+        } else { // do three-way move
+            _Func_class _Temp;
+            _Temp._Reset_move(_STD move(*this));
+            _Reset_move(_STD move(_Right));
+            _Right._Reset_move(_STD move(_Temp));
+        }
+    }
+
+#if _HAS_STATIC_RTTI
+    const type_info& _Target_type() const noexcept {
+        return _Getimpl() ? _Getimpl()->_Target_type() : typeid(void);
+    }
+
+    const void* _Target(const type_info& _Info) const noexcept {
+        return _Getimpl() ? _Getimpl()->_Target(_Info) : nullptr;
+    }
+#endif // _HAS_STATIC_RTTI
+
+private:
+#if _HAS_CXX23
+    friend _Function_base<_Ret, _Types...>;
+#endif // _HAS_CXX23
+
+    bool _Local() const noexcept { // test for locally stored copy of object
+        return _Getimpl() == static_cast<const void*>(&_Mystorage);
+    }
+
+    union _Storage { // storage for small objects (basic_string is small)
+        max_align_t _Dummy1; // for maximum alignment
+        char _Dummy2[_Space_size]; // to permit aliasing
+        _Ptrt* _Ptrs[_Small_object_num_ptrs]; // _Ptrs[_Small_object_num_ptrs - 1] is reserved
+    };
+
+    _Storage _Mystorage;
+    enum { _EEN_IMPL = _Small_object_num_ptrs - 1 }; // helper for expression evaluator
+    _Ptrt* _Getimpl() const noexcept { // get pointer to object
+        return _Mystorage._Ptrs[_Small_object_num_ptrs - 1];
+    }
+
+    void _Set(_Ptrt* _Ptr) noexcept { // store pointer to object
+        _Mystorage._Ptrs[_Small_object_num_ptrs - 1] = _Ptr;
+    }
+};
+
+template <class _Tx>
+struct _Get_function_impl {
+    static_assert(false, "std::function only accepts function types as template arguments.");
+};
+
+#define _GET_FUNCTION_IMPL(CALL_OPT, X1, X2, X3)                                                  \
+    template <class _Ret, class... _Types>                                                        \
+    struct _Get_function_impl<_Ret CALL_OPT(_Types...)> { /* determine type from argument list */ \
+        using type = _Func_class<_Ret, _Types...>;                                                \
+    };
+
+_NON_MEMBER_CALL(_GET_FUNCTION_IMPL, X1, X2, X3)
+#undef _GET_FUNCTION_IMPL
+
+#ifdef __cpp_noexcept_function_type
+#define _GET_FUNCTION_IMPL_NOEXCEPT(CALL_OPT, X1, X2, X3)                                                     \
+    template <class _Ret, class... _Types>                                                                    \
+    struct _Get_function_impl<_Ret CALL_OPT(_Types...) noexcept> {                                            \
+        static_assert(false, "std::function does not accept noexcept function types as template arguments."); \
+    };
+_NON_MEMBER_CALL(_GET_FUNCTION_IMPL_NOEXCEPT, X1, X2, X3)
+#undef _GET_FUNCTION_IMPL_NOEXCEPT
+#endif // defined(__cpp_noexcept_function_type)
+
+struct _Secret_copyability_ignoring_tag { // used exclusively for packaged_task
+    explicit _Secret_copyability_ignoring_tag() = default;
+};
+
+_EXPORT_STD template <class _Fty>
+class function : public _Get_function_impl<_Fty>::type { // wrapper for callable objects
+private:
+    using _Mybase = typename _Get_function_impl<_Fty>::type;
+
+public:
+    function() noexcept {}
+
+    function(nullptr_t) noexcept {}
+
+    function(const function& _Right) {
+        this->_Reset_copy(_Right);
+    }
+
+    template <class _Fx, typename _Mybase::template _Enable_if_callable_t<_Fx, function> = 0>
+    function(_Fx&& _Func) {
+        static_assert(is_copy_constructible_v<decay_t<_Fx>>,
+            "The target function object type must be copy constructible (N4988 [func.wrap.func.con]/10.1).");
+        this->_Reset(_STD forward<_Fx>(_Func));
+    }
+
+    template <class _SecretTag, class _Fx,
+        enable_if_t<is_same_v<_SecretTag, _Secret_copyability_ignoring_tag>, int> = 0,
+        typename _Mybase::template _Enable_if_callable_t<_Fx, function>           = 0>
+    explicit function(_SecretTag, _Fx&& _Func) { // used exclusively for packaged_task
+        this->_Reset(_STD forward<_Fx>(_Func));
+    }
+
+#if _HAS_FUNCTION_ALLOCATOR_SUPPORT
+    template <class _Alloc>
+    function(allocator_arg_t, const _Alloc&) noexcept {}
+
+    template <class _Alloc>
+    function(allocator_arg_t, const _Alloc&, nullptr_t) noexcept {}
+
+    template <class _Alloc>
+    function(allocator_arg_t, const _Alloc& _Ax, const function& _Right) {
+        this->_Reset_alloc(_Right, _Ax);
+    }
+
+    template <class _Fx, class _Alloc, typename _Mybase::template _Enable_if_callable_t<_Fx, function> = 0>
+    function(allocator_arg_t, const _Alloc& _Ax, _Fx&& _Func) {
+        static_assert(is_copy_constructible_v<decay_t<_Fx>>,
+            "The target function object type must be copy constructible (N4140 [func.wrap.func.con]/7).");
+        this->_Reset_alloc(_STD forward<_Fx>(_Func), _Ax);
+    }
+#endif // _HAS_FUNCTION_ALLOCATOR_SUPPORT
+
+    template <class _SecretTag, class _Fx, class _Alloc,
+        enable_if_t<is_same_v<_SecretTag, _Secret_copyability_ignoring_tag>, int> = 0,
+        typename _Mybase::template _Enable_if_callable_t<_Fx, function>           = 0>
+    explicit function(_SecretTag, allocator_arg_t, const _Alloc& _Ax, _Fx&& _Func) {
+        // used exclusively for packaged_task
+        this->_Reset_alloc(_STD forward<_Fx>(_Func), _Ax);
+    }
+
+    function& operator=(const function& _Right) {
+        function(_Right).swap(*this);
+        return *this;
+    }
+
+    function(function&& _Right) noexcept {
+        this->_Reset_move(_STD move(_Right));
+    }
+
+    template <class _SecretTag, class _Alloc,
+        enable_if_t<is_same_v<_SecretTag, _Secret_copyability_ignoring_tag>, int> = 0>
+    explicit function(_SecretTag, allocator_arg_t, const _Alloc& _Al, function&& _Right) {
+        this->_Reset_alloc(_STD move(_Right), _Al);
+    }
+
+#if _HAS_FUNCTION_ALLOCATOR_SUPPORT
+    template <class _Alloc>
+    function(allocator_arg_t, const _Alloc& _Al, function&& _Right)
+        : function(_Secret_copyability_ignoring_tag{}, allocator_arg, _Al, _STD move(_Right)) {}
+#endif // _HAS_FUNCTION_ALLOCATOR_SUPPORT
+
+    function& operator=(function&& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            this->_Tidy();
+            this->_Reset_move(_STD move(_Right));
+        }
+        return *this;
+    }
+
+    template <class _Fx, typename _Mybase::template _Enable_if_callable_t<_Fx, function> = 0>
+    function& operator=(_Fx&& _Func) {
+        function(_STD forward<_Fx>(_Func)).swap(*this);
+        return *this;
+    }
+
+#if _HAS_FUNCTION_ALLOCATOR_SUPPORT
+    template <class _Fx, class _Alloc>
+    void assign(_Fx&& _Func, const _Alloc& _Ax) {
+        function(allocator_arg, _Ax, _STD forward<_Fx>(_Func)).swap(*this);
+    }
+#endif // _HAS_FUNCTION_ALLOCATOR_SUPPORT
+
+    function& operator=(nullptr_t) noexcept {
+        this->_Tidy();
+        return *this;
+    }
+
+    template <class _Fx>
+    function& operator=(reference_wrapper<_Fx> _Func) noexcept {
+        this->_Tidy();
+        this->_Reset(_Func);
+        return *this;
+    }
+
+    void swap(function& _Right) noexcept {
+        this->_Swap(_Right);
+    }
+
+    explicit operator bool() const noexcept {
+        return !this->_Empty();
+    }
+
+#if _HAS_STATIC_RTTI
+    _NODISCARD const type_info& target_type() const noexcept {
+        return this->_Target_type();
+    }
+
+    template <class _Fx>
+    _NODISCARD _Fx* target() noexcept {
+        if constexpr (is_function_v<_Fx>) {
+            return nullptr;
+        } else {
+            return reinterpret_cast<_Fx*>(const_cast<void*>(this->_Target(typeid(_Fx))));
+        }
+    }
+
+    template <class _Fx>
+    _NODISCARD const _Fx* target() const noexcept {
+        if constexpr (is_function_v<_Fx>) {
+            return nullptr;
+        } else {
+            return reinterpret_cast<const _Fx*>(this->_Target(typeid(_Fx)));
+        }
+    }
+#else // ^^^ _HAS_STATIC_RTTI / !_HAS_STATIC_RTTI vvv
+    const type_info& target_type() const noexcept = delete; // requires static RTTI
+
+    template <class _Fx>
+    _Fx* target() noexcept = delete; // requires static RTTI
+
+    template <class _Fx>
+    const _Fx* target() const noexcept = delete; // requires static RTTI
+#endif // ^^^ !_HAS_STATIC_RTTI ^^^
+};
+
+#if _HAS_CXX17
+#define _FUNCTION_POINTER_DEDUCTION_GUIDE(CALL_OPT, X1, X2, X3) \
+    template <class _Ret, class... _Types>                      \
+    function(_Ret(CALL_OPT*)(_Types...)) -> function<_Ret(_Types...)>; // intentionally discards CALL_OPT
+
+_NON_MEMBER_CALL(_FUNCTION_POINTER_DEDUCTION_GUIDE, X1, X2, X3)
+#undef _FUNCTION_POINTER_DEDUCTION_GUIDE
+
+template <class _Fx, class _Call_op, class = void>
+struct _Deduce_from_call_operator : _Is_memfunptr<_Call_op>::_Guide_type {}; // N4958 [func.wrap.func.con]/16.1
+
+#if _HAS_CXX23
+template <class>
+struct _Inspect_static_call_operator {};
+
+#define _STATIC_CALL_OPERATOR_GUIDES(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT)      \
+    template <class _Ret, class... _Args>                                          \
+    struct _Inspect_static_call_operator<_Ret(CALL_OPT*)(_Args...) NOEXCEPT_OPT> { \
+        using type = _Ret(_Args...);                                               \
+    };
+
+_NON_MEMBER_CALL(_STATIC_CALL_OPERATOR_GUIDES, , , )
+#ifdef __cpp_noexcept_function_type
+_NON_MEMBER_CALL(_STATIC_CALL_OPERATOR_GUIDES, , , noexcept)
+#endif // ^^^ defined(__cpp_noexcept_function_type) ^^^
+
+#undef _STATIC_CALL_OPERATOR_GUIDES
+
+template <class _Fx, class _Call_op>
+struct _Deduce_from_call_operator<_Fx, _Call_op, void_t<decltype(_STD declval<_Fx>().operator())>>
+    : _Inspect_static_call_operator<_Call_op> {}; // N4958 [func.wrap.func.con]/16.2
+#endif // _HAS_CXX23
+
+template <class _Fx, class = void>
+struct _Deduce_signature {}; // can't deduce signature when &_Fx::operator() is missing, inaccessible, or ambiguous
+
+template <class _Fx>
+struct _Deduce_signature<_Fx, void_t<decltype(&_Fx::operator())>>
+    : _Deduce_from_call_operator<_Fx, decltype(&_Fx::operator())> {};
+
+template <class _Fx>
+function(_Fx) -> function<typename _Deduce_signature<_Fx>::type>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Fty>
+void swap(function<_Fty>& _Left, function<_Fty>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Fty>
+_NODISCARD bool operator==(const function<_Fty>& _Other, nullptr_t) noexcept {
+    return !_Other;
+}
+
+#if !_HAS_CXX20
+template <class _Fty>
+_NODISCARD bool operator==(nullptr_t, const function<_Fty>& _Other) noexcept {
+    return !_Other;
+}
+
+template <class _Fty>
+_NODISCARD bool operator!=(const function<_Fty>& _Other, nullptr_t) noexcept {
+    return static_cast<bool>(_Other);
+}
+
+template <class _Fty>
+_NODISCARD bool operator!=(nullptr_t, const function<_Fty>& _Other) noexcept {
+    return static_cast<bool>(_Other);
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX23
+enum class _Function_storage_mode { _Small, _Large };
+
+// _Function_data is defined as an array of pointers.
+// The first element is always a pointer to _Function_base::_Impl_t; it emulates a vtable pointer.
+// The other pointers are used as storage for a small functor;
+// if the functor does not fit in, the second pointer is the pointer to allocated storage, the rest are unused.
+union alignas(max_align_t) _Function_data {
+    void* _Pointers[_Small_object_num_ptrs];
+    const void* _Impl;
+    char _Data; // For aliasing
+
+    template <class _Fn>
+    static constexpr size_t _Buf_offset =
+        alignof(_Fn) <= sizeof(_Impl) ? sizeof(_Impl) // Store _Fn immediately after _Impl
+                                      : alignof(_Fn); // Pad _Fn to next alignment
+
+    template <class _Fn>
+    static constexpr size_t _Buf_size = sizeof(_Pointers) - _Buf_offset<_Fn>;
+
+    template <class _Fn>
+    _NODISCARD void* _Buf_ptr() noexcept {
+        return &_Data + _Buf_offset<_Fn>;
+    }
+
+    template <class _Fn, _Function_storage_mode _Mode>
+    _NODISCARD _Fn* _Fn_ptr() noexcept {
+        if constexpr (_Mode == _Function_storage_mode::_Small) {
+            return static_cast<_Fn*>(_Buf_ptr<_Fn>());
+        } else {
+            return static_cast<_Fn*>(_Pointers[1]);
+        }
+    }
+
+    void _Set_large_fn_ptr(void* const _Value) noexcept {
+        _Pointers[1] = _Value;
+    }
+};
+
+// Size of a large function. Treat an empty function as if it has this size.
+// Treat a small function as if it has this size too if it fits and is trivially copyable.
+inline constexpr size_t _Minimum_function_size = 2 * sizeof(void*);
+
+// The below functions are __stdcall as they are called by pointers from _Function_base::_Impl_t.
+// (We use explicit __stdcall to make the ABI stable for translation units with different calling convention options.)
+// Non-template functions are still defined inline, as the compiler may be able to devirtualize some calls.
+
+template <class _Rx, class... _Types>
+[[noreturn]] _Rx __stdcall _Function_not_callable(void*, _Types&&...) noexcept {
+    _STL_REPORT_ERROR("empty move_only_function call (N5008 [func.wrap.move.inv]/2)");
+    _STL_UNREACHABLE; // no return value available for "continue on error"
+}
+
+template <class _Rx, class... _Types>
+[[noreturn]] _Rx __stdcall _Function_old_not_callable(void*, _Types&&...) {
+    _Xbad_function_call();
+}
+
+template <class _Vt, class _VtInvQuals, _Function_storage_mode _Mode, class _Rx, bool _Noex, class... _Types>
+_NODISCARD _Rx __stdcall _Function_inv(void* const _Self, _Types&&... _Args) noexcept(_Noex) {
+    const auto _Ptr = static_cast<_Function_data*>(_Self)->_Fn_ptr<_Vt, _Mode>();
+    if constexpr (is_void_v<_Rx>) {
+        (void) _STD invoke(static_cast<_VtInvQuals>(*_Ptr), _STD forward<_Types>(_Args)...);
+    } else {
+        return _STD invoke(static_cast<_VtInvQuals>(*_Ptr), _STD forward<_Types>(_Args)...);
+    }
+}
+
+template <class _Fn, _Function_storage_mode _Mode, class _Rx, class... _Types>
+_NODISCARD _Rx __stdcall _Function_inv_old(void* const _Self, _Types&&... _Args) {
+    const auto _Ptr = static_cast<_Function_data*>(_Self)->_Fn_ptr<_Fn, _Mode>();
+    return _Ptr->_Do_call(_STD forward<_Types>(_Args)...);
+}
+
+template <class _Vt>
+void __stdcall _Function_move_small(_Function_data& _Self, _Function_data& _Src) noexcept {
+    const auto _Src_fn_ptr = _Src._Fn_ptr<_Vt, _Function_storage_mode::_Small>();
+    ::new (_Self._Buf_ptr<_Vt>()) _Vt(_STD move(*_Src_fn_ptr));
+    _Src_fn_ptr->~_Vt();
+    _Self._Impl = _Src._Impl;
+}
+
+template <size_t _Size>
+void __stdcall _Function_move_memcpy(_Function_data& _Self, _Function_data& _Src) noexcept {
+    _CSTD memcpy(&_Self._Data, &_Src._Data, _Size); // Copy Impl* and functor data
+}
+
+inline void __stdcall _Function_move_large(_Function_data& _Self, _Function_data& _Src) noexcept {
+    _CSTD memcpy(&_Self._Data, &_Src._Data, _Minimum_function_size); // Copy Impl* and functor data
+}
+
+#ifdef _WIN64
+template <class _Fn>
+void __stdcall _Function_move_old_small(_Function_data& _Self, _Function_data& _Src) noexcept {
+    _Fn* const _Old_fn_impl = _Src._Fn_ptr<_Fn, _Function_storage_mode::_Small>();
+    _Old_fn_impl->_Move(_Self._Buf_ptr<void*>());
+    _Old_fn_impl->_Delete_this(false);
+    _Self._Impl = _Src._Impl;
+}
+#endif // ^^^ 64-bit ^^^
+
+template <class _Vt>
+void __stdcall _Function_destroy_small(_Function_data& _Self) noexcept {
+    _Self._Fn_ptr<_Vt, _Function_storage_mode::_Small>()->~_Vt();
+}
+
+inline void __stdcall _Function_deallocate_large_default_aligned(_Function_data& _Self) noexcept {
+    ::operator delete(_Self._Fn_ptr<void, _Function_storage_mode::_Large>());
+}
+
+template <class _Fn>
+void __stdcall _Function_destroy_old_large(_Function_data& _Self) noexcept {
+    _Self._Fn_ptr<_Fn, _Function_storage_mode::_Large>()->_Delete_this(true);
+}
+
+#ifdef _WIN64
+template <class _Fn>
+void __stdcall _Function_destroy_old_small(_Function_data& _Self) noexcept {
+    _Self._Fn_ptr<_Fn, _Function_storage_mode::_Small>()->_Delete_this(false);
+}
+#else // ^^^ 64-bit / 32-bit vvv
+template <class _Fn>
+void __stdcall _Function_destroy_old_small_as_large(_Function_data& _Self) noexcept {
+    _Fn* const _Old_fn_impl = _Self._Fn_ptr<_Fn, _Function_storage_mode::_Large>();
+    _Old_fn_impl->_Delete_this(false);
+    ::operator delete(static_cast<void*>(_Old_fn_impl));
+}
+#endif // ^^^ 32-bit ^^^
+
+template <size_t _Align>
+void __stdcall _Function_deallocate_large_overaligned(_Function_data& _Self) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__);
+#ifdef __cpp_aligned_new
+    ::operator delete(_Self._Fn_ptr<void, _Function_storage_mode::_Large>(), align_val_t{_Align});
+#else // ^^^ defined(__cpp_aligned_new) / !defined(__cpp_aligned_new) vvv
+    ::operator delete(_Self._Fn_ptr<void, _Function_storage_mode::_Large>());
+#endif // ^^^ !defined(__cpp_aligned_new) ^^^
+}
+
+template <class _Vt>
+void __stdcall _Function_destroy_large(_Function_data& _Self) noexcept {
+    const auto _Pfn = _Self._Fn_ptr<_Vt, _Function_storage_mode::_Large>();
+    _Pfn->~_Vt();
+#ifdef __cpp_aligned_new
+    if constexpr (alignof(_Vt) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        ::operator delete(static_cast<void*>(_Pfn), align_val_t{alignof(_Vt)});
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+        ::operator delete(static_cast<void*>(_Pfn));
+    }
+}
+
+template <class _Vt>
+constexpr size_t _Function_small_copy_size = // We copy Impl* and the functor data at once
+    _Function_data::_Buf_offset<_Vt> // Impl* plus possible alignment
+    + (size_t{sizeof(_Vt) + sizeof(void*) - 1} & ~size_t{sizeof(void*) - 1}); // size in whole pointers
+
+template <class _Vt, class... _CTypes>
+_NODISCARD void* _Function_new_large(_CTypes&&... _Args) {
+    struct _NODISCARD _Guard_type {
+        void* _Ptr;
+
+        ~_Guard_type() {
+            // _Ptr is not nullptr only if an exception is thrown as a result of _Vt construction.
+            // Check _Ptr before calling operator delete to save the call in the common case.
+            if (_Ptr) {
+#ifdef __cpp_aligned_new
+                if constexpr (alignof(_Vt) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+                    ::operator delete(_Ptr, align_val_t{alignof(_Vt)});
+                } else
+#endif // defined(__cpp_aligned_new)
+                {
+                    ::operator delete(_Ptr);
+                }
+            }
+        }
+    };
+
+    void* _Ptr;
+#ifdef __cpp_aligned_new
+    if constexpr (alignof(_Vt) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        _Ptr = ::operator new(sizeof(_Vt), align_val_t{alignof(_Vt)});
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+        _Ptr = ::operator new(sizeof(_Vt));
+    }
+    _Guard_type _Guard{_Ptr};
+    ::new (_Ptr) _Vt(_STD forward<_CTypes>(_Args)...);
+    _Guard._Ptr = nullptr;
+    return _Ptr;
+}
+
+template <class _Rx, class... _Types>
+class _Function_base {
+public:
+    using result_type                    = _Rx;
+    using _Signature_without_cv_ref_noex = _Rx(_Types...);
+
+    struct _Impl_t { // A per-callable-type structure acting as a virtual function table.
+        // Using vtable emulations gives more flexibility for optimizations and reduces the amount of RTTI data.
+        // (The RTTI savings may be significant as with lambdas and binds there may be many distinct callable types.
+        // Here we don't have a distinct wrapper class for each callable type, only distinct functions when needed.)
+
+        // _Move and _Destroy are nullptr if trivial. Besides being an optimization, this enables assigning an
+        // empty function from a DLL that is unloaded later, and then safely moving/destroying that empty function.
+
+        // Calls target
+        _Rx(__stdcall* _Invoke)(void*, _Types&&...);
+        // Moves the data, including pointer to "vtable", AND destroys old data (not resetting its "vtable").
+        // nullptr if we can trivially move two pointers.
+        void(__stdcall* _Move)(_Function_data&, _Function_data&) _NOEXCEPT_FNPTR;
+        // Destroys data (not resetting its "vtable").
+        // nullptr if destruction is a no-op.
+        void(__stdcall* _Destroy)(_Function_data&) _NOEXCEPT_FNPTR;
+    };
+
+    enum class _Impl_kind {
+        _Usual        = 0,
+        _Old_fn_null  = 1,
+        _Old_fn_large = 2,
+#ifdef _WIN64
+        _Old_fn_small = 3,
+#else // ^^^ 64-bit / 32-bit vvv
+        _Old_fn_small_as_large = 4,
+#endif // ^^^ 32-bit ^^^
+    };
+
+    _Function_data _Data;
+
+    _Function_base() noexcept = default; // leaves the data member uninitialized
+
+    _Function_base(_Function_base&& _Other) noexcept {
+        _Checked_move(_Data, _Other._Data);
+        _Other._Reset_to_null();
+    }
+
+    void _Reset_to_null() noexcept {
+        _Data._Impl = nullptr;
+    }
+
+    template <class _Vt, class _Fn>
+    void _Construct_with_old_fn(_Fn&& _Func) {
+        const auto _Old_fn_impl = _Func._Getimpl();
+        if (_Old_fn_impl == nullptr) {
+            _Data._Impl = _Create_impl_ptr<_Impl_kind::_Old_fn_null, _Vt, false, void>();
+        } else if (_Func._Local()) {
+#ifdef _WIN64
+            _STL_INTERNAL_STATIC_ASSERT(alignof(max_align_t) == alignof(void*));
+            // 64-bit target, can put small function into small move_only_function directly
+            _Data._Impl = _Create_impl_ptr<_Impl_kind::_Old_fn_small, _Vt, false, void>();
+            if constexpr (is_lvalue_reference_v<_Fn>) {
+                _Old_fn_impl->_Copy(_Data._Buf_ptr<void*>());
+            } else {
+                _Old_fn_impl->_Move(_Data._Buf_ptr<void*>());
+                _Func._Tidy();
+            }
+#else // ^^^ 64-bit / 32-bit vvv
+            _STL_INTERNAL_STATIC_ASSERT(alignof(max_align_t) > alignof(void*));
+            // 32-bit target, cannot put small function into small move_only_function directly
+            // due to potentially not enough alignment. Allocate large function
+            void* _Where = ::operator new((_Small_object_num_ptrs - 1) * sizeof(void*));
+            if constexpr (is_lvalue_reference_v<_Fn>) {
+                struct _NODISCARD _Guard_type {
+                    void* _Ptr;
+
+                    ~_Guard_type() {
+                        // _Ptr is not nullptr only if an exception is thrown as a result of _Copy.
+                        // Check _Ptr before calling operator delete to save the call in the common case.
+                        if (_Ptr) {
+                            ::operator delete(_Ptr);
+                        }
+                    }
+                };
+
+                _Guard_type _Guard{_Where};
+                _Old_fn_impl->_Copy(_Where);
+                _Guard._Ptr = nullptr;
+            } else {
+                _Old_fn_impl->_Move(_Where);
+                _Func._Tidy();
+            }
+
+            _Data._Impl = _Create_impl_ptr<_Impl_kind::_Old_fn_small_as_large, _Vt, false, void>();
+            _Data._Set_large_fn_ptr(_Where);
+#endif // ^^^ 32-bit ^^^
+        } else {
+            // Just take ownership of the inner impl pointer
+            _Data._Impl = _Create_impl_ptr<_Impl_kind::_Old_fn_large, _Vt, false, void>();
+            if constexpr (is_lvalue_reference_v<_Fn>) {
+                _Data._Set_large_fn_ptr(_Old_fn_impl->_Copy(nullptr));
+            } else {
+                _Data._Set_large_fn_ptr(_Old_fn_impl);
+                _Func._Set(nullptr);
+            }
+        }
+    }
+
+    template <class _Vt, bool _Noexcept, class _VtInvQuals, class... _CTypes>
+    void _Construct_with_fn(_CTypes&&... _Args) {
+        _Data._Impl = _Create_impl_ptr<_Impl_kind::_Usual, _Vt, _Noexcept, _VtInvQuals>();
+        if constexpr (_Large_function_engaged<_Vt>) {
+            _Data._Set_large_fn_ptr(_STD _Function_new_large<_Vt>(_STD forward<_CTypes>(_Args)...));
+        } else {
+            ::new (_Data._Buf_ptr<_Vt>()) _Vt(_STD forward<_CTypes>(_Args)...);
+        }
+    }
+
+    static void _Checked_destroy(_Function_data& _Data) noexcept {
+        const auto _Impl = _Get_impl(_Data);
+        if (_Impl->_Destroy) {
+            _Impl->_Destroy(_Data);
+        }
+    }
+
+    static void _Checked_move(_Function_data& _Data, _Function_data& _Src) noexcept {
+        const auto _Impl = _Get_impl(_Src);
+        if (_Impl->_Move) {
+            _Impl->_Move(_Data, _Src);
+        } else {
+            _Function_move_large(_Data, _Src);
+        }
+    }
+
+    void _Move_assign(_Function_base&& _Other) noexcept {
+        // As specified in N4950 [func.wrap.move.ctor]/22, we are expected to first move the new target,
+        // then finally destroy the old target.
+        // It is more efficient to do the reverse - this way no temporary storage for the old target will be used.
+        // In some cases when some operations are trivial, it can be optimized,
+        // as the order change is unobservable, and everything is noexcept here.
+        const auto _This_impl         = _Get_impl(_Data);
+        const auto _Other_impl_move   = _Get_impl(_Other._Data)->_Move;
+        const auto _This_impl_destroy = _This_impl->_Destroy;
+
+        if (!_Other_impl_move) {
+            // Move is trivial, destroy first if needed
+            if (_This_impl_destroy) {
+                _This_impl_destroy(_Data);
+            }
+            _Function_move_large(_Data, _Other._Data);
+        } else if (!_This_impl_destroy) {
+            // Destroy is trivial, just move
+            _Other_impl_move(_Data, _Other._Data);
+        } else {
+            // General case involving a temporary
+            _Function_data _Tmp;
+
+            if (_This_impl->_Move) {
+                _This_impl->_Move(_Tmp, _Data);
+            } else {
+                _Function_move_large(_Tmp, _Data);
+            }
+
+            _Other_impl_move(_Data, _Other._Data);
+            _This_impl_destroy(_Tmp);
+        }
+        _Other._Reset_to_null();
+    }
+
+    void _Swap(_Function_base& _Other) noexcept {
+        _Function_data _Tmp;
+
+        _Checked_move(_Tmp, _Data);
+        _Checked_move(_Data, _Other._Data);
+        _Checked_move(_Other._Data, _Tmp);
+    }
+
+    _NODISCARD bool _Is_null() const noexcept {
+        return _Data._Impl == nullptr;
+    }
+
+    template <class _Vt>
+    static constexpr bool _Large_function_engaged = alignof(_Vt) > alignof(max_align_t)
+                                                 || sizeof(_Vt) > _Function_data::_Buf_size<_Vt>
+                                                 || !is_nothrow_move_constructible_v<_Vt>;
+
+    template <bool _Noexcept>
+    _NODISCARD auto _Get_invoke() const noexcept {
+        if constexpr (_Noexcept) {
+#ifdef __cpp_noexcept_function_type
+            return reinterpret_cast<_Rx(__stdcall*)(void*, _Types&&...) noexcept>(_Get_impl(_Data)->_Invoke);
+#else
+            static_assert(false); // when noexcept isn't in the type system, this should never be selected
+#endif
+        } else {
+            return _Get_impl(_Data)->_Invoke;
+        }
+    }
+
+    _NODISCARD static const _Impl_t* _Get_impl(const _Function_data& _Data) noexcept {
+        static constexpr _Impl_t _Null_move_only_function = {
+            _Function_not_callable<_Rx, _Types...>,
+            nullptr,
+            nullptr,
+        };
+
+        const auto _Ret = static_cast<const _Impl_t*>(_Data._Impl);
+        return _Ret ? _Ret : &_Null_move_only_function;
+    }
+
+    template <_Impl_kind _Kind, class _Vt, bool _Noexcept, class _VtInvQuals>
+    _NODISCARD static constexpr _Impl_t _Create_impl() noexcept {
+        _Impl_t _Impl{};
+        if constexpr (_Kind != _Impl_kind::_Usual) {
+            _STL_INTERNAL_STATIC_ASSERT(!_Noexcept);
+            _STL_INTERNAL_STATIC_ASSERT(is_void_v<_VtInvQuals>);
+            using _Fn = remove_pointer_t<decltype(_STD declval<_Vt>()._Getimpl())>;
+            if constexpr (_Kind == _Impl_kind::_Old_fn_null) {
+                _Impl._Invoke  = _Function_old_not_callable<_Rx, _Types...>;
+                _Impl._Move    = nullptr;
+                _Impl._Destroy = nullptr;
+            } else if constexpr (_Kind == _Impl_kind::_Old_fn_large) {
+                _Impl._Invoke  = _Function_inv_old<_Fn, _Function_storage_mode::_Large, _Rx, _Types...>;
+                _Impl._Move    = nullptr;
+                _Impl._Destroy = _Function_destroy_old_large<_Fn>;
+            } else {
+#ifdef _WIN64
+                static_assert(_Kind == _Impl_kind::_Old_fn_small);
+                _Impl._Invoke  = _Function_inv_old<_Fn, _Function_storage_mode::_Small, _Rx, _Types...>;
+                _Impl._Move    = _Function_move_old_small<_Fn>;
+                _Impl._Destroy = _Function_destroy_old_small<_Fn>;
+#else // ^^^ 64-bit / 32-bit vvv
+                static_assert(_Kind == _Impl_kind::_Old_fn_small_as_large);
+                _Impl._Invoke  = _Function_inv_old<_Fn, _Function_storage_mode::_Large, _Rx, _Types...>;
+                _Impl._Move    = nullptr;
+                _Impl._Destroy = _Function_destroy_old_small_as_large<_Fn>;
+#endif // ^^^ 32-bit ^^^
+            }
+        } else if constexpr (_Large_function_engaged<_Vt>) {
+            _Impl._Invoke = _Function_inv<_Vt, _VtInvQuals, _Function_storage_mode::_Large, _Rx, _Noexcept, _Types...>;
+            _Impl._Move   = nullptr;
+
+            if constexpr (is_trivially_destructible_v<_Vt>) {
+                if constexpr (alignof(_Vt) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+                    _Impl._Destroy = _Function_deallocate_large_default_aligned;
+                } else {
+                    _Impl._Destroy = _Function_deallocate_large_overaligned<alignof(_Vt)>;
+                }
+            } else {
+                _Impl._Destroy = _Function_destroy_large<_Vt>;
+            }
+        } else {
+            _Impl._Invoke = _Function_inv<_Vt, _VtInvQuals, _Function_storage_mode::_Small, _Rx, _Noexcept, _Types...>;
+
+            if constexpr (is_trivially_copyable_v<_Vt> && is_trivially_destructible_v<_Vt>) {
+                if constexpr ((_Function_small_copy_size<_Vt>) > _Minimum_function_size) {
+                    _Impl._Move = _Function_move_memcpy<_Function_small_copy_size<_Vt>>;
+                } else {
+                    _Impl._Move = nullptr;
+                }
+            } else {
+                _Impl._Move = _Function_move_small<_Vt>;
+            }
+
+            if constexpr (is_trivially_destructible_v<_Vt>) {
+                _Impl._Destroy = nullptr;
+            } else {
+                _Impl._Destroy = _Function_destroy_small<_Vt>;
+            }
+        }
+        return _Impl;
+    }
+
+    template <_Impl_kind _Kind, class _Vt, bool _Noexcept, class _VtInvQuals>
+    _NODISCARD static const _Impl_t* _Create_impl_ptr() noexcept {
+        static constexpr _Impl_t _Impl = _Create_impl<_Kind, _Vt, _Noexcept, _VtInvQuals>();
+        return &_Impl;
+    }
+};
+
+template <class... _Signature>
+class _Function_call {
+    static_assert(false, "std::move_only_function only accepts function types as template arguments, "
+                         "with possibly const/ref/noexcept qualifiers. Also, unlike std::function, "
+                         "std::move_only_function does not define class template argument deduction guides.");
+};
+
+// A script to generate the specializations is at
+// /tools/scripts/move_only_function_specializations.py
+// (Avoiding C++ preprocessor for better IDE navigation and debugging experience)
+
+// Beginning of generated code - DO NOT EDIT manually!
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...)> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = _Vt&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from =
+        is_invocable_r_v<_Rx, _Vt, _Types...> && is_invocable_r_v<_Rx, _Vt&, _Types...>;
+
+    static constexpr bool _Noexcept = false;
+
+    _Rx operator()(_Types... _Args) {
+        return this->template _Get_invoke<_Noexcept>()(&this->_Data, _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) &> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = _Vt&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from = is_invocable_r_v<_Rx, _Vt&, _Types...>;
+
+    static constexpr bool _Noexcept = false;
+
+    _Rx operator()(_Types... _Args) & {
+        return this->template _Get_invoke<_Noexcept>()(&this->_Data, _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) &&> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = _Vt&&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from = is_invocable_r_v<_Rx, _Vt, _Types...>;
+
+    static constexpr bool _Noexcept = false;
+
+    _Rx operator()(_Types... _Args) && {
+        return this->template _Get_invoke<_Noexcept>()(&this->_Data, _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) const> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = const _Vt&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from =
+        is_invocable_r_v<_Rx, const _Vt, _Types...> && is_invocable_r_v<_Rx, const _Vt&, _Types...>;
+
+    static constexpr bool _Noexcept = false;
+
+    _Rx operator()(_Types... _Args) const {
+        return this->template _Get_invoke<_Noexcept>()(
+            const_cast<_Function_data*>(&this->_Data), _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) const&> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = const _Vt&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from = is_invocable_r_v<_Rx, const _Vt&, _Types...>;
+
+    static constexpr bool _Noexcept = false;
+
+    _Rx operator()(_Types... _Args) const& {
+        return this->template _Get_invoke<_Noexcept>()(
+            const_cast<_Function_data*>(&this->_Data), _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) const&&> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = const _Vt&&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from = is_invocable_r_v<_Rx, const _Vt, _Types...>;
+
+    static constexpr bool _Noexcept = false;
+
+    _Rx operator()(_Types... _Args) const&& {
+        return this->template _Get_invoke<_Noexcept>()(
+            const_cast<_Function_data*>(&this->_Data), _STD forward<_Types>(_Args)...);
+    }
+};
+
+#ifdef __cpp_noexcept_function_type
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) noexcept> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = _Vt&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from =
+        is_nothrow_invocable_r_v<_Rx, _Vt, _Types...> && is_nothrow_invocable_r_v<_Rx, _Vt&, _Types...>;
+
+    static constexpr bool _Noexcept = true;
+
+    _Rx operator()(_Types... _Args) noexcept {
+        return this->template _Get_invoke<_Noexcept>()(&this->_Data, _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) & noexcept> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = _Vt&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from = is_nothrow_invocable_r_v<_Rx, _Vt&, _Types...>;
+
+    static constexpr bool _Noexcept = true;
+
+    _Rx operator()(_Types... _Args) & noexcept {
+        return this->template _Get_invoke<_Noexcept>()(&this->_Data, _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) && noexcept> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = _Vt&&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from = is_nothrow_invocable_r_v<_Rx, _Vt, _Types...>;
+
+    static constexpr bool _Noexcept = true;
+
+    _Rx operator()(_Types... _Args) && noexcept {
+        return this->template _Get_invoke<_Noexcept>()(&this->_Data, _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) const noexcept> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = const _Vt&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from =
+        is_nothrow_invocable_r_v<_Rx, const _Vt, _Types...> && is_nothrow_invocable_r_v<_Rx, const _Vt&, _Types...>;
+
+    static constexpr bool _Noexcept = true;
+
+    _Rx operator()(_Types... _Args) const noexcept {
+        return this->template _Get_invoke<_Noexcept>()(
+            const_cast<_Function_data*>(&this->_Data), _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) const & noexcept> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = const _Vt&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from = is_nothrow_invocable_r_v<_Rx, const _Vt&, _Types...>;
+
+    static constexpr bool _Noexcept = true;
+
+    _Rx operator()(_Types... _Args) const& noexcept {
+        return this->template _Get_invoke<_Noexcept>()(
+            const_cast<_Function_data*>(&this->_Data), _STD forward<_Types>(_Args)...);
+    }
+};
+
+template <class _Rx, class... _Types>
+class _Function_call<_Rx(_Types...) const && noexcept> // Generated code - DO NOT EDIT manually!
+    : public _Function_base<_Rx, _Types...> {
+public:
+    template <class _Vt>
+    using _VtInvQuals = const _Vt&&;
+
+    template <class _Vt>
+    static constexpr bool _Is_callable_from = is_nothrow_invocable_r_v<_Rx, const _Vt, _Types...>;
+
+    static constexpr bool _Noexcept = true;
+
+    _Rx operator()(_Types... _Args) const&& noexcept {
+        return this->template _Get_invoke<_Noexcept>()(
+            const_cast<_Function_data*>(&this->_Data), _STD forward<_Types>(_Args)...);
+    }
+};
+#endif // defined(__cpp_noexcept_function_type)
+// End of generated code - DO NOT EDIT manually!
+
+_EXPORT_STD template <class... _Signature>
+class move_only_function : private _Function_call<_Signature...> {
+private:
+    using _Call = _Function_call<_Signature...>;
+
+    template <class _Fn>
+    static constexpr bool _Enable_one_arg_constructor = !is_same_v<remove_cvref_t<_Fn>, move_only_function>
+                                                     && !_Is_specialization_v<remove_cvref_t<_Fn>, in_place_type_t>
+                                                     && _Call::template _Is_callable_from<decay_t<_Fn>>;
+
+    template <class _Fn, class... _CTypes>
+    static constexpr bool _Enable_in_place_constructor =
+        is_constructible_v<decay_t<_Fn>, _CTypes...> && _Call::template _Is_callable_from<decay_t<_Fn>>;
+
+    template <class _Fn, class _Ux, class... _CTypes>
+    static constexpr bool _Enable_in_place_list_constructor =
+        is_constructible_v<decay_t<_Fn>, initializer_list<_Ux>&, _CTypes...>
+        && _Call::template _Is_callable_from<decay_t<_Fn>>;
+
+    template <class...>
+    friend class move_only_function;
+
+    template <class _Vt>
+    static constexpr bool _Is_move_only_function_varying_cv_ref_noex() {
+        if constexpr (_Is_specialization_v<_Vt, move_only_function>) {
+            return is_same_v<typename _Call::_Signature_without_cv_ref_noex,
+                typename _Vt::_Signature_without_cv_ref_noex>;
+        } else {
+            return false;
+        }
+    }
+
+public:
+    using typename _Call::result_type;
+
+    move_only_function() noexcept {
+        this->_Reset_to_null();
+    }
+
+    move_only_function(nullptr_t) noexcept {
+        this->_Reset_to_null();
+    }
+
+    move_only_function(move_only_function&&) noexcept = default;
+
+    template <class _Fn>
+        requires _Enable_one_arg_constructor<_Fn>
+    move_only_function(_Fn&& _Callable) {
+        using _Vt = decay_t<_Fn>;
+        static_assert(is_constructible_v<_Vt, _Fn>, "_Vt should be constructible from _Fn. "
+                                                    "(N4950 [func.wrap.move.ctor]/6)");
+        if constexpr (is_same_v<_Vt, function<typename _Call::_Signature_without_cv_ref_noex>>) {
+            this->template _Construct_with_old_fn<_Vt>(_STD forward<_Fn>(_Callable));
+        } else {
+            if constexpr (is_member_pointer_v<_Vt> || is_pointer_v<_Vt>
+                          || _Is_specialization_v<_Vt, move_only_function>) {
+                if (_Callable == nullptr) {
+                    this->_Reset_to_null();
+                    return;
+                }
+            }
+
+            if constexpr (_Is_move_only_function_varying_cv_ref_noex<_Vt>()) {
+                _Call::_Checked_move(this->_Data, _Callable._Data);
+                _Callable._Reset_to_null();
+            } else {
+                using _VtInvQuals = _Call::template _VtInvQuals<_Vt>;
+                this->template _Construct_with_fn<_Vt, _Call::_Noexcept, _VtInvQuals>(_STD forward<_Fn>(_Callable));
+            }
+        }
+    }
+
+    template <class _Fn, class... _CTypes>
+        requires _Enable_in_place_constructor<_Fn, _CTypes...>
+    explicit move_only_function(in_place_type_t<_Fn>, _CTypes&&... _Args) {
+        using _Vt = decay_t<_Fn>;
+        static_assert(is_same_v<_Vt, _Fn>, "_Vt should be the same type as _Fn. (N4950 [func.wrap.move.ctor]/12)");
+
+        using _VtInvQuals = _Call::template _VtInvQuals<_Vt>;
+        this->template _Construct_with_fn<_Vt, _Call::_Noexcept, _VtInvQuals>(_STD forward<_CTypes>(_Args)...);
+    }
+
+    template <class _Fn, class _Ux, class... _CTypes>
+        requires _Enable_in_place_list_constructor<_Fn, _Ux, _CTypes...>
+    explicit move_only_function(in_place_type_t<_Fn>, initializer_list<_Ux> _Li, _CTypes&&... _Args) {
+        using _Vt = decay_t<_Fn>;
+        static_assert(is_same_v<_Vt, _Fn>, "_Vt should be the same type as _Fn. (N4950 [func.wrap.move.ctor]/18)");
+
+        using _VtInvQuals = _Call::template _VtInvQuals<_Vt>;
+        this->template _Construct_with_fn<_Vt, _Call::_Noexcept, _VtInvQuals>(_Li, _STD forward<_CTypes>(_Args)...);
+    }
+
+    ~move_only_function() {
+        // Do cleanup in this class destructor rather than base,
+        // so that if object construction throws, the unnecessary cleanup isn't called.
+        this->_Checked_destroy(this->_Data);
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        const auto _Tombstone{reinterpret_cast<const void*>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+        this->_Data._Impl = _Tombstone;
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    }
+
+    move_only_function& operator=(nullptr_t) noexcept {
+        this->_Checked_destroy(this->_Data);
+        this->_Reset_to_null();
+        return *this;
+    }
+
+    move_only_function& operator=(move_only_function&& _Other)
+    // intentionally noexcept(false), leaving the door open to adding allocator support in the future; see GH-2278
+    {
+        if (this != _STD addressof(_Other)) {
+            this->_Move_assign(_STD move(_Other));
+        }
+        return *this;
+    }
+
+    template <class _Fn>
+        requires is_constructible_v<move_only_function, _Fn>
+    move_only_function& operator=(_Fn&& _Callable) {
+        this->_Move_assign(move_only_function{_STD forward<_Fn>(_Callable)});
+        return *this;
+    }
+
+    _NODISCARD explicit operator bool() const noexcept {
+        return !this->_Is_null();
+    }
+
+    using _Call::operator();
+
+    void swap(move_only_function& _Other) noexcept {
+        this->_Swap(_Other);
+    }
+
+    friend void swap(move_only_function& _Fn1, move_only_function& _Fn2) noexcept {
+        _Fn1._Swap(_Fn2);
+    }
+
+    _NODISCARD friend bool operator==(const move_only_function& _This, nullptr_t) noexcept {
+        return _This._Is_null();
+    }
+};
+#endif // _HAS_CXX23
+
+template <int _Nx>
+struct _Ph { // placeholder
+    static_assert(_Nx > 0, "invalid placeholder index");
+};
+
+_EXPORT_STD template <class _Tx>
+struct is_placeholder : integral_constant<int, 0> {}; // _Tx is not a placeholder
+
+template <int _Nx>
+struct is_placeholder<_Ph<_Nx>> : integral_constant<int, _Nx> {}; // _Ph is a placeholder
+
+template <class _Tx>
+struct is_placeholder<const _Tx> : is_placeholder<_Tx>::type {}; // ignore cv-qualifiers
+
+template <class _Tx>
+struct is_placeholder<volatile _Tx> : is_placeholder<_Tx>::type {}; // ignore cv-qualifiers
+
+template <class _Tx>
+struct is_placeholder<const volatile _Tx> : is_placeholder<_Tx>::type {}; // ignore cv-qualifiers
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr int is_placeholder_v = is_placeholder<_Ty>::value;
+
+template <class _Ret, class _Fx, class... _Types>
+class _Binder;
+
+_EXPORT_STD template <class _Tx>
+struct is_bind_expression : false_type {}; // _Tx is not a bind expression
+
+template <class _Ret, class _Fx, class... _Types>
+struct is_bind_expression<_Binder<_Ret, _Fx, _Types...>> : true_type {}; // _Binder is a bind expression
+
+template <class _Tx>
+struct is_bind_expression<const _Tx> : is_bind_expression<_Tx>::type {}; // ignore cv-qualifiers
+
+template <class _Tx>
+struct is_bind_expression<volatile _Tx> : is_bind_expression<_Tx>::type {}; // ignore cv-qualifiers
+
+template <class _Tx>
+struct is_bind_expression<const volatile _Tx> : is_bind_expression<_Tx>::type {}; // ignore cv-qualifiers
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool is_bind_expression_v = is_bind_expression<_Ty>::value;
+
+template <class _Cv_TiD, bool = _Is_specialization_v<remove_cv_t<_Cv_TiD>, reference_wrapper>,
+    bool = is_bind_expression_v<_Cv_TiD>, int = is_placeholder_v<_Cv_TiD>>
+struct _Select_fixer;
+
+template <class _Cv_TiD>
+struct _Select_fixer<_Cv_TiD, true, false, 0> { // reference_wrapper fixer
+    template <class _Untuple>
+    static constexpr auto _Fix(_Cv_TiD& _Tid, _Untuple&&) noexcept -> typename _Cv_TiD::type& {
+        // unwrap a reference_wrapper
+        return _Tid.get();
+    }
+};
+
+template <class _Cv_TiD>
+struct _Select_fixer<_Cv_TiD, false, true, 0> { // nested bind fixer
+    template <class _Untuple, size_t... _Jx,
+        enable_if_t<conjunction_v<bool_constant<(_Jx < tuple_size_v<_Untuple>)>...>, int> = 0>
+    static constexpr auto _Apply(_Cv_TiD& _Tid, _Untuple&& _Ut, index_sequence<_Jx...>)
+        noexcept(noexcept(_Tid(_STD get<_Jx>(_STD move(_Ut))...))) -> decltype(_Tid(_STD get<_Jx>(_STD move(_Ut))...)) {
+        // call a nested bind expression
+        return _Tid(_STD get<_Jx>(_STD move(_Ut))...);
+    }
+
+    template <class _Untuple>
+    static constexpr auto _Fix(_Cv_TiD& _Tid, _Untuple&& _Ut)
+        noexcept(noexcept(_Apply(_Tid, _STD move(_Ut), make_index_sequence<tuple_size_v<_Untuple>>{})))
+            -> decltype(_Apply(_Tid, _STD move(_Ut), make_index_sequence<tuple_size_v<_Untuple>>{})) {
+        // call a nested bind expression
+        return _Apply(_Tid, _STD move(_Ut), make_index_sequence<tuple_size_v<_Untuple>>{});
+    }
+};
+
+template <class _Cv_TiD>
+struct _Select_fixer<_Cv_TiD, false, false, 0> { // identity fixer
+    template <class _Untuple>
+    static constexpr _Cv_TiD& _Fix(_Cv_TiD& _Tid, _Untuple&&) noexcept {
+        // pass a bound argument as an lvalue (important!)
+        return _Tid;
+    }
+};
+
+template <class _Cv_TiD, int _Jx>
+struct _Select_fixer<_Cv_TiD, false, false, _Jx> { // placeholder fixer
+    static_assert(_Jx > 0, "invalid is_placeholder value");
+
+    template <class _Untuple, enable_if_t<(_Jx <= tuple_size_v<_Untuple>), int> = 0>
+    static constexpr auto _Fix(_Cv_TiD&, _Untuple&& _Ut) noexcept
+        -> decltype(_STD get<_Jx - 1>(_STD move(_Ut))) { // choose the Jth unbound argument (1-based indexing)
+        return _STD get<_Jx - 1>(_STD move(_Ut));
+    }
+};
+
+template <class _Cv_TiD, class _Untuple>
+constexpr auto _Fix_arg(_Cv_TiD& _Tid, _Untuple&& _Ut)
+    noexcept(noexcept(_Select_fixer<_Cv_TiD>::_Fix(_Tid, _STD move(_Ut))))
+        -> decltype(_Select_fixer<_Cv_TiD>::_Fix(_Tid, _STD move(_Ut))) { // translate an argument for bind
+    return _Select_fixer<_Cv_TiD>::_Fix(_Tid, _STD move(_Ut));
+}
+
+struct _Unforced { // tag to distinguish bind() from bind<R>()
+    explicit _Unforced() = default;
+};
+
+// helper to give INVOKE an explicit return type; avoids undesirable Expression SFINAE
+template <class _Rx>
+struct _Invoker_ret { // selected for all _Rx other than _Unforced
+    template <class _Fx, class... _Valtys,
+        enable_if_t<_Select_invoke_traits<_Fx, _Valtys...>::template _Is_invocable_r<_Rx>::value, int> = 0>
+    static _CONSTEXPR20 _Rx _Call(_Fx&& _Func, _Valtys&&... _Vals) noexcept(_Select_invoke_traits<_Fx,
+        _Valtys...>::template _Is_nothrow_invocable_r<_Rx>::value) { // INVOKE, implicitly converted
+        if constexpr (is_void_v<_Rx>) {
+            _STL_INTERNAL_STATIC_ASSERT(
+                _Select_invoke_traits<_Fx, _Valtys...>::_Is_nothrow_invocable::value
+                == _Select_invoke_traits<_Fx, _Valtys...>::template _Is_nothrow_invocable_r<_Rx>::value);
+            _STD invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
+        } else {
+            return _STD invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
+        }
+    }
+};
+
+template <>
+struct _Invoker_ret<_Unforced> { // selected for _Rx being _Unforced
+    template <class _Fx, class... _Valtys>
+    static _CONSTEXPR20 auto _Call(_Fx&& _Func, _Valtys&&... _Vals)
+        noexcept(_Select_invoke_traits<_Fx, _Valtys...>::_Is_nothrow_invocable::value)
+            -> decltype(_STD invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...)) { // INVOKE, unchanged
+        return _STD invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
+    }
+};
+
+template <class _Ret, size_t... _Ix, class _Cv_FD, class _Cv_tuple_TiD, class _Untuple>
+_CONSTEXPR20 auto _Call_binder(
+    _Invoker_ret<_Ret>, index_sequence<_Ix...>, _Cv_FD& _Obj, _Cv_tuple_TiD& _Tpl, _Untuple&& _Ut)
+    noexcept(noexcept(_Invoker_ret<_Ret>::_Call(_Obj, _STD _Fix_arg(_STD get<_Ix>(_Tpl), _STD move(_Ut))...)))
+        -> decltype(_Invoker_ret<_Ret>::_Call(_Obj, _STD _Fix_arg(_STD get<_Ix>(_Tpl), _STD move(_Ut))...)) {
+    // bind() and bind<R>() invocation
+    return _Invoker_ret<_Ret>::_Call(_Obj, _STD _Fix_arg(_STD get<_Ix>(_Tpl), _STD move(_Ut))...);
+}
+
+#if _HAS_CXX20
+template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _UnboundTuple>
+concept _Can_call_binder = requires(_CvFD& _Fx, _CvBoundTuple& _Bound_tuple, _UnboundTuple&& _Unbound_tuple) {
+    _STD _Call_binder(_Invoker_ret<_Ret>{}, _IntSeq{}, _Fx, _Bound_tuple, _STD move(_Unbound_tuple));
+};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _UnboundTuple, class = void>
+constexpr bool _Can_call_binder = false;
+
+template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _UnboundTuple>
+constexpr bool _Can_call_binder<_Ret, _CvFD, _IntSeq, _CvBoundTuple, _UnboundTuple,
+    void_t<decltype(_STD _Call_binder(_Invoker_ret<_Ret>{}, _IntSeq{}, _STD declval<_CvFD&>(),
+        _STD declval<_CvBoundTuple&>(), _STD declval<_UnboundTuple>()))>> = true;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Ret>
+struct _Forced_result_type { // used by bind<R>()
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;
+};
+
+template <class _Ret, class _Fx>
+struct _Binder_result_type { // provide result_type (sometimes)
+    using _Decayed = decay_t<_Fx>;
+
+    using _All_weak_types = _Weak_types<_Decayed>;
+
+    using type =
+        conditional_t<is_same_v<_Ret, _Unforced>, _Weak_result_type<_All_weak_types>, _Forced_result_type<_Ret>>;
+};
+
+template <class _Ret, class _Fx, class... _Types>
+class _Binder : public _Binder_result_type<_Ret, _Fx>::type { // wrap bound callable object and arguments
+private:
+    using _Seq         = index_sequence_for<_Types...>;
+    using _Fd          = decay_t<_Fx>;
+    using _Bound_tuple = tuple<decay_t<_Types>...>;
+
+    _Compressed_pair<_Fd, _Bound_tuple> _Mypair;
+
+public:
+    constexpr explicit _Binder(_Fx&& _Func, _Types&&... _Args)
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...) {}
+
+#define _CALL_BINDER                                                                       \
+    _STD _Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, \
+        _STD forward_as_tuple(_STD forward<_Unbound>(_Unbargs)...))
+
+#if _HAS_CXX20
+    template <class... _Unbound>
+        requires _Can_call_binder<_Ret, _Fd, _Seq, _Bound_tuple, tuple<_Unbound&&...>>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) noexcept(noexcept(_CALL_BINDER)) {
+        return _CALL_BINDER;
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) = delete;
+
+    template <class... _Unbound>
+        requires _Can_call_binder<_Ret, const _Fd, _Seq, const _Bound_tuple, tuple<_Unbound&&...>>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) const noexcept(noexcept(_CALL_BINDER)) {
+        return _CALL_BINDER;
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) const = delete;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    template <class... _Unbound,
+        enable_if_t<_Can_call_binder<_Ret, _Fd, _Seq, _Bound_tuple, tuple<_Unbound&&...>>, int> = 0>
+    _CONSTEXPR20 decltype(auto) operator()(_Unbound&&... _Unbargs) noexcept(noexcept(_CALL_BINDER)) {
+        return _CALL_BINDER;
+    }
+
+    template <class... _Unbound,
+        enable_if_t<!_Can_call_binder<_Ret, _Fd, _Seq, _Bound_tuple, tuple<_Unbound&&...>>, int> = 0>
+    void operator()(_Unbound&&...) = delete;
+
+    template <class... _Unbound,
+        enable_if_t<_Can_call_binder<_Ret, const _Fd, _Seq, const _Bound_tuple, tuple<_Unbound&&...>>, int> = 0>
+    _CONSTEXPR20 decltype(auto) operator()(_Unbound&&... _Unbargs) const noexcept(noexcept(_CALL_BINDER)) {
+        return _CALL_BINDER;
+    }
+
+    template <class... _Unbound,
+        enable_if_t<!_Can_call_binder<_Ret, const _Fd, _Seq, const _Bound_tuple, tuple<_Unbound&&...>>, int> = 0>
+    void operator()(_Unbound&&...) const = delete;
+#endif // ^^^ !_HAS_CXX20 ^^^
+#undef _CALL_BINDER
+};
+
+_EXPORT_STD template <class _Fx, class... _Types>
+_NODISCARD _CONSTEXPR20 _Binder<_Unforced, _Fx, _Types...> bind(_Fx&& _Func, _Types&&... _Args) {
+    return _Binder<_Unforced, _Fx, _Types...>(_STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <class _Ret, class _Fx, class... _Types>
+_NODISCARD _CONSTEXPR20 _Binder<_Ret, _Fx, _Types...> bind(_Fx&& _Func, _Types&&... _Args) {
+    return _Binder<_Ret, _Fx, _Types...>(_STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...);
+}
+
+namespace placeholders {
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<1> _1{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<2> _2{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<3> _3{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<4> _4{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<5> _5{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<6> _6{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<7> _7{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<8> _8{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<9> _9{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<10> _10{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<11> _11{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<12> _12{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<13> _13{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<14> _14{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<15> _15{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<16> _16{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<17> _17{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<18> _18{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<19> _19{};
+    _EXPORT_STD _INLINE_VAR constexpr _Ph<20> _20{};
+} // namespace placeholders
+
+#if _HAS_CXX20
+template <size_t... _Ix, class _Cv_FD, class _Cv_tuple_TiD, class... _Unbound>
+constexpr auto _Call_front_binder(index_sequence<_Ix...>, _Cv_FD&& _Obj, _Cv_tuple_TiD&& _Tpl, _Unbound&&... _Unbargs)
+    noexcept(noexcept(_STD invoke(_STD forward<_Cv_FD>(_Obj), _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...,
+        _STD forward<_Unbound>(_Unbargs)...))) //
+    -> decltype(_STD invoke(_STD forward<_Cv_FD>(_Obj), _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...,
+        _STD forward<_Unbound>(_Unbargs)...)) {
+    return _STD invoke(_STD forward<_Cv_FD>(_Obj), _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...,
+        _STD forward<_Unbound>(_Unbargs)...);
+}
+
+template <class _IntSeq, class _CvFD, class _CvBoundTuple, class... _Unbound>
+concept _Can_call_front_binder = requires(_CvFD&& _Fx, _CvBoundTuple&& _Bound_tuple, _Unbound&&... _Unbound_args) {
+    _STD _Call_front_binder(_IntSeq{}, _STD forward<_CvFD>(_Fx), _STD forward<_CvBoundTuple>(_Bound_tuple),
+        _STD forward<_Unbound>(_Unbound_args)...);
+};
+
+template <class _Fx, class... _Types>
+class _Front_binder { // wrap bound callable object and arguments
+private:
+    using _Seq = index_sequence_for<_Types...>;
+
+    _Compressed_pair<_Fx, tuple<_Types...>> _Mypair;
+
+    _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Fx, decay_t<_Fx>>);
+    _STL_INTERNAL_STATIC_ASSERT((is_same_v<_Types, decay_t<_Types>> && ...));
+
+public:
+    template <class _FxInit, class... _TypesInit>
+        requires (sizeof...(_TypesInit) != 0 || !is_same_v<remove_cvref_t<_FxInit>, _Front_binder>)
+    constexpr explicit _Front_binder(_FxInit&& _Func, _TypesInit&&... _Args)
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_FxInit>(_Func), _STD forward<_TypesInit>(_Args)...) {}
+
+    template <class... _Unbound>
+        requires _Can_call_front_binder<_Seq, _Fx&, tuple<_Types...>&, _Unbound...>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) & noexcept(noexcept(
+        _STD _Call_front_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...))) {
+        return _STD _Call_front_binder(
+            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) & = delete;
+
+    template <class... _Unbound>
+        requires _Can_call_front_binder<_Seq, const _Fx&, const tuple<_Types...>&, _Unbound...>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) const& noexcept(noexcept(
+        _STD _Call_front_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...))) {
+        return _STD _Call_front_binder(
+            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) const& = delete;
+
+    template <class... _Unbound>
+        requires _Can_call_front_binder<_Seq, _Fx, tuple<_Types...>, _Unbound...>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) && noexcept(noexcept(_STD _Call_front_binder(
+        _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...))) {
+        return _STD _Call_front_binder(
+            _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) && = delete;
+
+    template <class... _Unbound>
+        requires _Can_call_front_binder<_Seq, const _Fx, const tuple<_Types...>, _Unbound...>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) const&& noexcept(noexcept(_STD _Call_front_binder(
+        _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...))) {
+        return _STD _Call_front_binder(
+            _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) const&& = delete;
+};
+
+_EXPORT_STD template <class _Fx, class... _Types>
+_NODISCARD constexpr auto bind_front(_Fx&& _Func, _Types&&... _Args) {
+    static_assert(is_constructible_v<decay_t<_Fx>, _Fx>,
+        "std::bind_front requires the decayed callable to be constructible from an undecayed callable");
+    static_assert(is_move_constructible_v<decay_t<_Fx>>,
+        "std::bind_front requires the decayed callable to be move constructible");
+    static_assert(conjunction_v<is_constructible<decay_t<_Types>, _Types>...>,
+        "std::bind_front requires the decayed bound arguments to be constructible from undecayed bound arguments");
+    static_assert(conjunction_v<is_move_constructible<decay_t<_Types>>...>,
+        "std::bind_front requires the decayed bound arguments to be move constructible");
+
+    return _Front_binder<decay_t<_Fx>, decay_t<_Types>...>(_STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...);
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+template <size_t... _Ix, class _Cv_FD, class _Cv_tuple_TiD, class... _Unbound>
+constexpr auto _Call_back_binder(index_sequence<_Ix...>, _Cv_FD&& _Obj, _Cv_tuple_TiD&& _Tpl, _Unbound&&... _Unbargs)
+    noexcept(noexcept(_STD invoke(_STD forward<_Cv_FD>(_Obj), _STD forward<_Unbound>(_Unbargs)...,
+        _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...))) -> decltype(_STD invoke(_STD forward<_Cv_FD>(_Obj),
+        _STD forward<_Unbound>(_Unbargs)..., _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...)) {
+    return _STD invoke(_STD forward<_Cv_FD>(_Obj), _STD forward<_Unbound>(_Unbargs)...,
+        _STD get<_Ix>(_STD forward<_Cv_tuple_TiD>(_Tpl))...);
+}
+
+template <class _IntSeq, class _CvFD, class _CvBoundTuple, class... _Unbound>
+concept _Can_call_back_binder = requires(_CvFD&& _Fx, _CvBoundTuple&& _Bound_tuple, _Unbound&&... _Unbound_args) {
+    _STD _Call_back_binder(_IntSeq{}, _STD forward<_CvFD>(_Fx), _STD forward<_CvBoundTuple>(_Bound_tuple),
+        _STD forward<_Unbound>(_Unbound_args)...);
+};
+
+template <class _Fx, class... _Types>
+class _Back_binder { // wrap bound callable object and arguments
+private:
+    using _Seq = index_sequence_for<_Types...>;
+
+    _Compressed_pair<_Fx, tuple<_Types...>> _Mypair;
+
+    _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Fx, decay_t<_Fx>>);
+    _STL_INTERNAL_STATIC_ASSERT((is_same_v<_Types, decay_t<_Types>> && ...));
+
+public:
+    template <class _FxInit, class... _TypesInit>
+        requires (sizeof...(_TypesInit) != 0 || !is_same_v<remove_cvref_t<_FxInit>, _Back_binder>)
+    constexpr explicit _Back_binder(_FxInit&& _Func, _TypesInit&&... _Args)
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_FxInit>(_Func), _STD forward<_TypesInit>(_Args)...) {}
+
+    template <class... _Unbound>
+        requires _Can_call_back_binder<_Seq, _Fx&, tuple<_Types...>&, _Unbound...>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) & noexcept(noexcept(
+        _STD _Call_back_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...))) {
+        return _STD _Call_back_binder(
+            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) & = delete;
+
+    template <class... _Unbound>
+        requires _Can_call_back_binder<_Seq, const _Fx&, const tuple<_Types...>&, _Unbound...>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) const& noexcept(noexcept(
+        _STD _Call_back_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...))) {
+        return _STD _Call_back_binder(
+            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) const& = delete;
+
+    template <class... _Unbound>
+        requires _Can_call_back_binder<_Seq, _Fx, tuple<_Types...>, _Unbound...>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) && noexcept(noexcept(_STD _Call_back_binder(
+        _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...))) {
+        return _STD _Call_back_binder(
+            _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) && = delete;
+
+    template <class... _Unbound>
+        requires _Can_call_back_binder<_Seq, const _Fx, const tuple<_Types...>, _Unbound...>
+    constexpr decltype(auto) operator()(_Unbound&&... _Unbargs) const&& noexcept(noexcept(_STD _Call_back_binder(
+        _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...))) {
+        return _STD _Call_back_binder(
+            _Seq{}, _STD move(_Mypair._Get_first()), _STD move(_Mypair._Myval2), _STD forward<_Unbound>(_Unbargs)...);
+    }
+
+    template <class... _Unbound>
+    void operator()(_Unbound&&...) const&& = delete;
+};
+
+_EXPORT_STD template <class _Fx, class... _Types>
+_NODISCARD constexpr auto bind_back(_Fx&& _Func, _Types&&... _Args) {
+    static_assert(is_constructible_v<decay_t<_Fx>, _Fx>,
+        "std::bind_back requires the decayed callable to be constructible from an undecayed callable");
+    static_assert(
+        is_move_constructible_v<decay_t<_Fx>>, "std::bind_back requires the decayed callable to be move constructible");
+    static_assert(conjunction_v<is_constructible<decay_t<_Types>, _Types>...>,
+        "std::bind_back requires the decayed bound arguments to be constructible from undecayed bound arguments");
+    static_assert(conjunction_v<is_move_constructible<decay_t<_Types>>...>,
+        "std::bind_back requires the decayed bound arguments to be move constructible");
+
+    return _Back_binder<decay_t<_Fx>, decay_t<_Types>...>(_STD forward<_Fx>(_Func), _STD forward<_Types>(_Args)...);
+}
+#endif // _HAS_CXX23
+
+#if _HAS_FUNCTION_ALLOCATOR_SUPPORT
+template <class _Fty, class _Alloc>
+struct uses_allocator<function<_Fty>, _Alloc> : true_type {}; // true_type if container allocator enabled
+#endif // _HAS_FUNCTION_ALLOCATOR_SUPPORT
+
+#if _HAS_CXX17
+inline void _Add_alloc_size(size_t& _Size, const size_t _Size_added, const size_t _Alignment) {
+    // moves _Size up to account for storing an object of size _Size_added with alignment _Alignment in a memory buffer
+    // assumes that the memory buffer will be allocated for the "worst" alignment used in the resulting buffer
+    const size_t _Align_masked = _Size & (_Alignment - 1u);
+    _Size += _Size_added;
+    if (_Align_masked != 0) {
+        _Size += _Alignment - _Align_masked;
+    }
+}
+
+template <class _Ty>
+void _Add_alloc_size(size_t& _Size) { // moves _Size up to account for allocating a _Ty
+    _Add_alloc_size(_Size, sizeof(_Ty), alignof(_Ty));
+}
+
+template <class _Ty>
+void _Add_alloc_size(size_t& _Size, const size_t _Count) {
+    // moves _Size up to account for allocating an array of _Count _Ty instances
+    _Add_alloc_size(_Size, _Get_size_of_n<sizeof(_Ty)>(_Count), alignof(_Ty));
+}
+
+inline void* _Decode_aligned_block(void*& _Base, size_t _Size, const size_t _Alignment) {
+    // "allocates" an object of size _Size and alignment _Alignment from _Base, and shifts
+    // _Base up by the size necessary to decode that object.
+    auto _Space  = static_cast<size_t>(-1);
+    auto _Result = _STD align(_Alignment, _Size, _Base, _Space);
+    _Base        = static_cast<char*>(_Base) + _Size;
+    return _Result;
+}
+
+template <class _Ty>
+_Ty* _Decode_aligned_block(void*& _Base) { // "allocates" a _Ty from _Base
+    return static_cast<_Ty*>(_Decode_aligned_block(_Base, sizeof(_Ty), alignof(_Ty)));
+}
+
+template <class _Ty>
+_Ty* _Decode_aligned_block(void*& _Base, const size_t _Count) {
+    // "allocates" an array of _Count _Ty instances from _Base
+    return static_cast<_Ty*>(_Decode_aligned_block(_Base, sizeof(_Ty) * _Count, alignof(_Ty)));
+}
+
+template <class _FwdItHaystack, class _FwdItPat, class _Pred_eq>
+_CONSTEXPR20 pair<_FwdItHaystack, _FwdItHaystack> _Search_pair_unchecked(
+    _FwdItHaystack _First1, _FwdItHaystack _Last1, _FwdItPat _First2, _FwdItPat _Last2, _Pred_eq& _Eq) {
+    // find first [_First2, _Last2) satisfying _Eq
+    if constexpr (_Is_ranges_random_iter_v<_FwdItHaystack> && _Is_ranges_random_iter_v<_FwdItPat>) {
+        _Iter_diff_t<_FwdItHaystack> _Count1 = _Last1 - _First1;
+        _Iter_diff_t<_FwdItPat> _Count2      = _Last2 - _First2;
+
+#if _VECTORIZED_SEARCH
+        if constexpr (_Vector_alg_in_search_is_safe<_FwdItHaystack, _FwdItPat, _Pred_eq>) {
+            if (!_STD _Is_constant_evaluated()) {
+                const auto _Ptr1 = _STD _To_address(_First1);
+                (void) _STD _To_address(_Last2);
+
+                const auto _Ptr_res1 = _STD _Search_vectorized(
+                    _Ptr1, _STD _To_address(_Last1), _STD _To_address(_First2), static_cast<size_t>(_Count2));
+
+                if constexpr (is_pointer_v<_FwdItHaystack>) {
+                    _First1 = _Ptr_res1;
+                } else {
+                    _First1 += _Ptr_res1 - _Ptr1;
+                }
+
+                if (_First1 != _Last1) {
+                    return {_First1, _First1 + static_cast<_Iter_diff_t<_FwdItHaystack>>(_Count2)};
+                } else {
+                    return {_Last1, _Last1};
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_SEARCH ^^^
+
+        for (; _Count2 <= _Count1; ++_First1, (void) --_Count1) { // room for match, try it
+            _FwdItHaystack _Mid1 = _First1;
+            for (_FwdItPat _Mid2 = _First2;; ++_Mid1, (void) ++_Mid2) {
+                if (_Mid2 == _Last2) {
+                    return {_First1, _Mid1};
+                }
+
+                if (!_Eq(*_Mid1, *_Mid2)) {
+                    break;
+                }
+            }
+        }
+
+        return {_Last1, _Last1};
+    } else {
+        static_assert(_Is_ranges_fwd_iter_v<_FwdItHaystack> && _Is_ranges_fwd_iter_v<_FwdItPat>,
+            "Iterators must be at least forward iterators");
+        for (;; ++_First1) { // loop until match or end of a sequence
+            _FwdItHaystack _Mid1 = _First1;
+            for (_FwdItPat _Mid2 = _First2;; ++_Mid1, (void) ++_Mid2) {
+                if (_Mid2 == _Last2) {
+                    return {_First1, _Mid1};
+                }
+
+                if (_Mid1 == _Last1) {
+                    return {_Last1, _Last1};
+                }
+
+                if (!_Eq(*_Mid1, *_Mid2)) {
+                    break;
+                }
+            }
+        }
+    }
+}
+
+_EXPORT_STD template <class _FwdItPat, class _Pred_eq = equal_to<>>
+class default_searcher { // functor to search haystacks for needles
+public:
+    _CONSTEXPR20 default_searcher(_FwdItPat _First, _FwdItPat _Last, _Pred_eq _Eq = _Pred_eq())
+        : _Data{_One_then_variadic_args_t{}, _STD move(_Eq), pair<_FwdItPat, _FwdItPat>{_First, _Last}} {
+        const auto& _Pat = _Data._Myval2;
+        _STD _Adl_verify_range(_Pat.first, _Pat.second);
+    }
+
+    template <class _FwdItHaystack>
+    _NODISCARD _CONSTEXPR20 pair<_FwdItHaystack, _FwdItHaystack> operator()(
+        _FwdItHaystack _First, _FwdItHaystack _Last) const {
+        // search [_First, _Last) for the searcher's pattern
+        _STD _Adl_verify_range(_First, _Last);
+        const auto& _Eq  = _Data._Get_first();
+        const auto& _Pat = _Data._Myval2;
+        _STD _Adl_verify_range(_Pat.first, _Pat.second); // check again to ensure container is not destroyed
+        const auto _Result = _STD _Search_pair_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last),
+            _STD _Get_unwrapped(_Pat.first), _STD _Get_unwrapped(_Pat.second), _Eq);
+        _STD _Seek_wrapped(_Last, _Result.second);
+        _STD _Seek_wrapped(_First, _Result.first);
+        return {_First, _Last};
+    }
+
+private:
+    _Compressed_pair<_Pred_eq, pair<_FwdItPat, _FwdItPat>> _Data;
+};
+
+template <class _RanItPat, class _Hash_ty, class _Pred_eq>
+struct _Boyer_moore_hash_delta_1_table { // stores the Boyer-Moore delta_1 table using a hash table
+    using _Value_t = _Iter_value_t<_RanItPat>;
+    using _Diff    = _Iter_diff_t<_RanItPat>;
+
+    _Boyer_moore_hash_delta_1_table(_RanItPat _Pat_first_arg, _Unwrapped_t<const _RanItPat&> _UPat_first,
+        const _Diff _Pat_size_arg, _Hash_ty&& _Hash_fn, _Pred_eq&& _Eq)
+        : _Pat_first(_Pat_first_arg), _Pat_size(_Pat_size_arg),
+          _Map(0, _STD move(_Hash_fn), _STD move(_Eq)) { // initialize a delta_1 hash table
+        for (_Diff _Idx = 1; _Idx <= _Pat_size; ++_Idx, (void) ++_UPat_first) {
+            _Map.insert_or_assign(*_UPat_first, _Pat_size - _Idx);
+        }
+    }
+
+    _Diff _Lookup(const _Value_t& _Value) const {
+        // lookup the "character" _Value in the table, returning the maximum shift if found
+        const auto _Iter = _Map.find(_Value);
+        if (_Iter == _Map.end()) {
+            return _Pat_size;
+        }
+
+        return _Iter->second;
+    }
+
+    _Pred_eq _Get_eq() const {
+        return _Map.key_eq();
+    }
+
+    const _RanItPat _Pat_first;
+    const _Diff _Pat_size;
+
+private:
+    unordered_map<_Value_t, _Diff, _Hash_ty, _Pred_eq> _Map;
+};
+
+template <class _RanItPat, _Iter_diff_t<_RanItPat> _Limit>
+struct _Boyer_moore_flat_delta_1_table { // stores the Boyer-Moore delta_1 table using a plain array lookup
+    using _Value_t = _Iter_value_t<_RanItPat>;
+    using _Diff    = _Iter_diff_t<_RanItPat>;
+
+    _Boyer_moore_flat_delta_1_table(_RanItPat _Pat_first_arg, _Unwrapped_t<const _RanItPat&> _UPat_first,
+        const _Diff _Pat_size_arg, _Unused_parameter, _Unused_parameter)
+        : _Pat_first(_Pat_first_arg), _Pat_size(_Pat_size_arg) { // initialize a delta_1 flat table
+        _STD fill(_STD begin(_Table), _STD end(_Table), _Pat_size);
+        for (_Diff _Idx = 1; _Idx <= _Pat_size; ++_Idx, (void) ++_UPat_first) {
+            _Table[_Unsigned_value(*_UPat_first)] = _Pat_size - _Idx;
+        }
+    }
+
+    _Diff _Lookup(const _Value_t _Value) const { // lookup the "character" _Value in the table
+        const auto _UValue = _Unsigned_value(_Value);
+        if (_UValue < _STD size(_Table)) {
+            return _Table[_UValue];
+        }
+
+        return _Pat_size;
+    }
+
+    equal_to<> _Get_eq() const {
+        return {};
+    }
+
+    const _RanItPat _Pat_first;
+    const _Diff _Pat_size;
+
+private:
+    _Diff _Table[_Limit];
+};
+
+// _Mini_ptr avoids needing to include <memory> which includes <atomic>.
+// It doesn't attempt to provide all of unique_ptr's safety features; use carefully.
+enum class _Deletion_kind { _Global_scalar, _Normal_array };
+
+template <class _Ty, _Deletion_kind _Del>
+class _Mini_ptr {
+public:
+    explicit _Mini_ptr(_Ty* const _Ptr_) noexcept : _Ptr(_Ptr_) {}
+
+    ~_Mini_ptr() noexcept {
+        if (_Ptr) {
+            if constexpr (_Del == _Deletion_kind::_Global_scalar) {
+                ::operator delete(_Ptr);
+            } else if constexpr (_Del == _Deletion_kind::_Normal_array) {
+                delete[] _Ptr;
+            } else {
+                static_assert(false); // unexpected strategy
+            }
+        }
+    }
+
+    _NODISCARD _Ty* _Get() const noexcept {
+        return _Ptr;
+    }
+
+    _NODISCARD _Ty* _Release() noexcept {
+        return _STD exchange(_Ptr, nullptr);
+    }
+
+    _Mini_ptr(const _Mini_ptr&)            = delete;
+    _Mini_ptr& operator=(const _Mini_ptr&) = delete;
+
+private:
+    _Ty* _Ptr;
+};
+
+template <class _RanItPat, class _Pred_eq>
+void _Build_boyer_moore_delta_2_table(_Iter_diff_t<_RanItPat>* const _Shifts, const _RanItPat _Pat_first,
+    const _Iter_diff_t<_RanItPat> _Pat_size, _Pred_eq& _Eq) {
+    // Builds Boyer-Moore's delta_2 table from a pattern [_Pat_first, _Pat_first + _Pat_size).
+    // pre: _Shifts is a pointer to _Pat_size _Iter_diff_t<_RanItPat>s.
+    // This is the `dd'` algorithm from "Fast Pattern Matching In Strings" by Knuth, Morris, and Pratt (1977).
+    // Note that the published algorithm used 1-based indexing!
+    using _Diff = _Iter_diff_t<_RanItPat>;
+
+    if (_Pat_size == 0) {
+        return;
+    }
+
+    if (_STD _Max_limit<_Diff>() - _Pat_size < _Pat_size) {
+        _Xlength_error("Boyer-Moore pattern is too long");
+    }
+
+    const auto _Mx = static_cast<size_t>(_Pat_size);
+
+    const _Mini_ptr<size_t, _Deletion_kind::_Normal_array> _Fx_ptr{new size_t[_Mx]};
+    size_t* const _Fx = _Fx_ptr._Get();
+
+    for (size_t _Kx = 1; _Kx <= _Mx; ++_Kx) {
+        _Shifts[_Kx - 1] = static_cast<_Diff>(2 * _Mx - _Kx);
+    }
+
+    size_t _Tx = _Mx + 1;
+    for (size_t _Jx = _Mx; _Jx > 0; --_Jx, --_Tx) {
+        _Fx[_Jx - 1] = _Tx;
+        while (_Tx <= _Mx && !_Eq(_Pat_first[_Jx - 1], _Pat_first[_Tx - 1])) {
+            _Shifts[_Tx - 1] = (_STD min) (_Shifts[_Tx - 1], static_cast<_Diff>(_Mx - _Jx));
+            _Tx              = _Fx[_Tx - 1];
+        }
+    }
+
+    // The code below is the "Rytter correction" from "Algorithms For String Searching: A Survey" by Baeza-Yates (1989),
+    // originally from "A Correct Preprocessing Algorithm For Boyer-Moore String-Searching" by Rytter (1980).
+
+    size_t _Qx = _Tx;
+    _Tx        = _Mx + 1 - _Qx;
+    for (size_t _Jx = 1, _Tx1 = 0; _Jx <= _Tx; ++_Tx1, ++_Jx) {
+        _Fx[_Jx - 1] = _Tx1;
+        while (_Tx1 >= 1 && !_Eq(_Pat_first[_Jx - 1], _Pat_first[_Tx1 - 1])) {
+            _Tx1 = _Fx[_Tx1 - 1];
+        }
+    }
+
+    size_t _Qx1 = 1;
+    while (_Qx < _Mx) {
+        for (size_t _Kx = _Qx1; _Kx <= _Qx; ++_Kx) {
+            _Shifts[_Kx - 1] = (_STD min) (_Shifts[_Kx - 1], static_cast<_Diff>(_Mx + _Qx - _Kx));
+        }
+        _Qx1 = _Qx + 1;
+
+        const size_t _Temp = _Fx[_Tx - 1];
+
+        _Qx = _Qx + _Tx - _Temp;
+        _Tx = _Temp;
+    }
+}
+
+template <class _Delta1_t, class _RanItHaystack>
+pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_search(
+    const _Delta1_t& _Delta1, typename _Delta1_t::_Diff* _Delta2, _RanItHaystack _First, _RanItHaystack _Last) {
+    static_assert(is_same_v<typename _Delta1_t::_Value_t, _Iter_value_t<_RanItHaystack>>,
+        "boyer_moore_searcher requires matching iterator value types");
+    using _Diff = typename _Delta1_t::_Diff;
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst         = _STD _Get_unwrapped(_First);
+    const auto _ULast    = _STD _Get_unwrapped(_Last);
+    const auto _Pat_size = _Delta1._Pat_size;
+    if (_Pat_size == 0) {
+        return {_First, _First};
+    }
+
+    const auto _UPat_first = _STD _Get_unwrapped_n(_Delta1._Pat_first, _Pat_size);
+    const auto _Eq         = _Delta1._Get_eq();
+    _Diff _Shift           = _Pat_size - 1;
+    while (_Shift < _ULast - _UFirst) {
+        _UFirst += _Shift;
+        _Shift = _Delta1._Lookup(*_UFirst);
+        if (_Shift == 0) { // that is, *_UFirst == "_Pat.back()"
+            _Diff _Idx = _Pat_size - 1;
+            do {
+                if (_Idx == 0) {
+                    _STD _Seek_wrapped(_Last, _UFirst + _Pat_size);
+                    _STD _Seek_wrapped(_First, _UFirst);
+                    return {_First, _Last};
+                }
+
+                --_Idx;
+                --_UFirst;
+            } while (_Eq(*_UFirst, _UPat_first[_Idx]));
+            _Shift = (_STD max) (_Delta1._Lookup(*_UFirst), _Delta2[_Idx]);
+        }
+    }
+
+    _STD _Seek_wrapped(_Last, _ULast);
+    _STD _Seek_wrapped(_First, _ULast);
+    return {_First, _Last};
+}
+
+template <class _Delta1_t, class _RanItHaystack>
+pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_horspool_search(
+    const _Delta1_t& _Delta1, _RanItHaystack _First, _RanItHaystack _Last) {
+    static_assert(is_same_v<typename _Delta1_t::_Value_t, _Iter_value_t<_RanItHaystack>>,
+        "boyer_moore_horspool_searcher requires matching iterator value types");
+    using _Diff = typename _Delta1_t::_Diff;
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _Pat_size = _Delta1._Pat_size;
+    if (_Pat_size == 0) {
+        return {_First, _First};
+    }
+
+    auto _UFirst           = _STD _Get_unwrapped(_First);
+    const auto _ULast      = _STD _Get_unwrapped(_Last);
+    const auto _UPat_first = _STD _Get_unwrapped_n(_Delta1._Pat_first, _Pat_size);
+    const auto _Eq         = _Delta1._Get_eq();
+    _Diff _Shift           = _Pat_size - 1;
+    while (_Shift < _ULast - _UFirst) {
+        _UFirst += _Shift;
+        _Shift = _Delta1._Lookup(*_UFirst);
+        if (_Shift == 0) { // that is, *_UFirst == "_Pat.back()"
+            const auto _Candidate = _UFirst - (_Pat_size - 1);
+            if (_STD equal(_UPat_first, _UPat_first + (_Pat_size - 1), _Candidate, _STD _Pass_fn(_Eq))) {
+                _STD _Seek_wrapped(_Last, _Candidate + _Pat_size);
+                _STD _Seek_wrapped(_First, _Candidate);
+                return {_First, _Last};
+            }
+
+            _Shift = 1;
+        }
+    }
+
+    _STD _Seek_wrapped(_Last, _ULast);
+    _STD _Seek_wrapped(_First, _ULast);
+    return {_First, _Last};
+}
+
+template <class _RanItPat, class _Hash_ty, class _Pred_eq, class _Delta1_t>
+struct _Single_delta1_type_boyer_moore_traits {
+    using _Diff = _Iter_diff_t<_RanItPat>;
+
+    // uses buffers of the form {
+    // _Atomic_counter_t _Ref_count
+    // _Delta1_t _Delta1
+    // _Diff _Delta2[_Pattern_size] // not used for Boyer-Moore-Horspool
+    // }
+
+    template <bool _Build_delta2>
+    static void* _Build_boyer_moore(_RanItPat _First, _RanItPat _Last, _Hash_ty _Hash_fn, _Pred_eq _Eq) {
+        // builds data tables for the Boyer-Moore string search algorithm
+        _STD _Adl_verify_range(_First, _Last);
+        const auto _UFirst       = _STD _Get_unwrapped(_First);
+        const auto _Pat_size_raw = _STD _Get_unwrapped(_Last) - _UFirst;
+        using _CT                = common_type_t<_Iter_diff_t<_RanItPat>, size_t>;
+        if (static_cast<_CT>(_Pat_size_raw) > static_cast<_CT>(SIZE_MAX)) {
+            _Xbad_alloc();
+        }
+
+        const auto _Pat_size = static_cast<size_t>(_Pat_size_raw);
+        size_t _Buf_size     = 0;
+        _Add_alloc_size<_Atomic_counter_t>(_Buf_size);
+        _Add_alloc_size<_Delta1_t>(_Buf_size);
+        if (_Build_delta2) {
+            _Add_alloc_size<_Diff>(_Buf_size, _Pat_size);
+        }
+
+        _Mini_ptr<void, _Deletion_kind::_Global_scalar> _Buf_bytes(::operator new(_Buf_size));
+        void* _Buf                                      = _Buf_bytes._Get();
+        *_Decode_aligned_block<_Atomic_counter_t>(_Buf) = 1;
+        void* const _Delta1                             = _Decode_aligned_block<_Delta1_t>(_Buf);
+        if (_Build_delta2) {
+            _STD _Build_boyer_moore_delta_2_table(
+                _Decode_aligned_block<_Diff>(_Buf, _Pat_size), _UFirst, _Pat_size_raw, _Eq);
+        }
+
+        ::new (_Delta1) _Delta1_t(_First, _UFirst, _Pat_size_raw, _STD move(_Hash_fn), _STD move(_Eq));
+        return _Buf_bytes._Release();
+    }
+
+    template <class _RanItHaystack>
+    static pair<_RanItHaystack, _RanItHaystack> _Use_boyer_moore(
+        void* _Data, _RanItHaystack _First, _RanItHaystack _Last) {
+        // decodes data tables for the Boyer-Moore string search algorithm
+        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
+        const auto _Delta1 = _Decode_aligned_block<_Delta1_t>(_Data);
+        const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast<size_t>(_Delta1->_Pat_size));
+        return _STD _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last);
+    }
+
+    template <class _RanItHaystack>
+    static pair<_RanItHaystack, _RanItHaystack> _Use_boyer_moore_horspool(
+        void* _Data, _RanItHaystack _First, _RanItHaystack _Last) {
+        // decodes data tables for the Boyer-Moore string search algorithm
+        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
+        const auto _Delta1 = _Decode_aligned_block<_Delta1_t>(_Data);
+        return _STD _Boyer_moore_horspool_search(*_Delta1, _First, _Last);
+    }
+
+    static void _Destroy(void* const _Base) noexcept {
+        // destroys data tables for either the Boyer-Moore or Boyer-Moore-Horspool string search algorithms
+        void* _Data = _Base;
+        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
+        _Decode_aligned_block<_Delta1_t>(_Data)->~_Delta1_t();
+        ::operator delete(_Base);
+    }
+};
+
+template <class _RanItPat, class _Hash_ty, class _Pred_eq>
+using _Boyer_moore_traits_char_mode = _Single_delta1_type_boyer_moore_traits<_RanItPat, _Hash_ty, _Pred_eq,
+    _Boyer_moore_flat_delta_1_table<_RanItPat, 256>>;
+
+template <class _RanItPat>
+struct _Boyer_moore_traits_wchar_t_mode {
+    using _Value_t       = _Iter_value_t<_RanItPat>;
+    using _Diff          = _Iter_diff_t<_RanItPat>;
+    using _Big_table_t   = _Boyer_moore_flat_delta_1_table<_RanItPat, 65536>;
+    using _Small_table_t = _Boyer_moore_flat_delta_1_table<_RanItPat, 256>;
+
+    // uses buffers of the form {
+    // _Atomic_counter_t _Ref_count
+    // bool _Use_large_table // true if anything in the pattern is > 255
+    // conditional_t<_Use_large_table, _Big_table_t, _Small_table_t> _Delta1
+    // _Diff _Delta2[_Pattern_size] // not used for Boyer-Moore-Horspool
+    // }
+
+    template <bool _Build_delta2>
+    static void* _Build_boyer_moore(_RanItPat _First, _RanItPat _Last, _Unused_parameter, _Unused_parameter) {
+        // builds data tables for the Boyer-Moore string search algorithm
+        _STD _Adl_verify_range(_First, _Last);
+        const auto _UFirst       = _STD _Get_unwrapped(_First);
+        const auto _ULast        = _STD _Get_unwrapped(_Last);
+        const auto _Pat_size_raw = _ULast - _UFirst;
+        using _CT                = common_type_t<_Iter_diff_t<_RanItPat>, size_t>;
+        if (static_cast<_CT>(_Pat_size_raw) > static_cast<_CT>(SIZE_MAX)) {
+            _Xbad_alloc();
+        }
+
+        const auto _Pat_size = static_cast<size_t>(_Pat_size_raw);
+        size_t _Buf_size     = 0;
+        _Add_alloc_size<_Atomic_counter_t>(_Buf_size);
+        bool _Use_large_table = false;
+
+        for (auto _Temp = _UFirst; _Temp != _ULast; ++_Temp) {
+            if (_Unsigned_value(*_Temp) > 255) {
+                _Use_large_table = true;
+                break;
+            }
+        }
+
+        _Add_alloc_size<bool>(_Buf_size);
+        if (_Use_large_table) {
+            _Add_alloc_size<_Big_table_t>(_Buf_size);
+        } else {
+            _Add_alloc_size<_Small_table_t>(_Buf_size);
+        }
+
+        if (_Build_delta2) {
+            _Add_alloc_size<_Diff>(_Buf_size, _Pat_size);
+        }
+
+        _Mini_ptr<void, _Deletion_kind::_Global_scalar> _Buf_bytes(::operator new(_Buf_size));
+        void* _Buf                                      = _Buf_bytes._Get();
+        *_Decode_aligned_block<_Atomic_counter_t>(_Buf) = 1;
+        *_Decode_aligned_block<bool>(_Buf)              = _Use_large_table;
+        if (_Use_large_table) {
+            using _Delta1_t = _Big_table_t;
+            ::new (static_cast<void*>(_Decode_aligned_block<_Delta1_t>(_Buf)))
+                _Delta1_t(_First, _UFirst, _Pat_size_raw, {}, {});
+        } else {
+            using _Delta1_t = _Small_table_t;
+            ::new (static_cast<void*>(_Decode_aligned_block<_Delta1_t>(_Buf)))
+                _Delta1_t(_First, _UFirst, _Pat_size_raw, {}, {});
+        }
+
+        if (_Build_delta2) {
+            equal_to<> _Eq;
+            _STD _Build_boyer_moore_delta_2_table(
+                _Decode_aligned_block<_Diff>(_Buf, _Pat_size), _UFirst, _Pat_size_raw, _Eq);
+        }
+
+        return _Buf_bytes._Release();
+    }
+
+    template <class _RanItHaystack>
+    static pair<_RanItHaystack, _RanItHaystack> _Use_boyer_moore(
+        void* _Data, _RanItHaystack _First, _RanItHaystack _Last) {
+        // decodes data tables for the Boyer-Moore string search algorithm
+        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
+        if (*_Decode_aligned_block<bool>(_Data)) {
+            const auto _Delta1 = _Decode_aligned_block<_Big_table_t>(_Data);
+            const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast<size_t>(_Delta1->_Pat_size));
+            return _STD _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last);
+        } else {
+            const auto _Delta1 = _Decode_aligned_block<_Small_table_t>(_Data);
+            const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast<size_t>(_Delta1->_Pat_size));
+            return _STD _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last);
+        }
+    }
+
+    template <class _RanItHaystack>
+    static pair<_RanItHaystack, _RanItHaystack> _Use_boyer_moore_horspool(
+        void* _Data, _RanItHaystack _First, _RanItHaystack _Last) {
+        // decodes data tables for the Boyer-Moore string search algorithm
+        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
+        if (*_Decode_aligned_block<bool>(_Data)) {
+            const auto _Delta1 = _Decode_aligned_block<_Big_table_t>(_Data);
+            return _STD _Boyer_moore_horspool_search(*_Delta1, _First, _Last);
+        } else {
+            const auto _Delta1 = _Decode_aligned_block<_Small_table_t>(_Data);
+            return _STD _Boyer_moore_horspool_search(*_Delta1, _First, _Last);
+        }
+    }
+
+    static void _Destroy(void* const _Base) noexcept {
+        // destroys data tables for either the Boyer-Moore or Boyer-Moore-Horspool string search algorithms
+        void* _Data = _Base;
+        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
+        if (*_Decode_aligned_block<bool>(_Data)) {
+            const auto _Delta1 = _Decode_aligned_block<_Big_table_t>(_Data);
+            _Delta1->~_Big_table_t();
+        } else {
+            const auto _Delta1 = _Decode_aligned_block<_Small_table_t>(_Data);
+            _Delta1->~_Small_table_t();
+        }
+        static_assert(is_trivially_destructible_v<_Diff>, "allows Boyer-Moore and Boyer-Moore-Horspool to "
+                                                          "share cleanup functions");
+        ::operator delete(_Base);
+    }
+};
+
+template <class _RanItPat, class _Hash_ty, class _Pred_eq>
+using _Boyer_moore_traits_general_mode = _Single_delta1_type_boyer_moore_traits<_RanItPat, _Hash_ty, _Pred_eq,
+    _Boyer_moore_hash_delta_1_table<_RanItPat, _Hash_ty, _Pred_eq>>;
+
+template <class _RanItPat, class _Hash_ty, class _Pred_eq, class _Value_t = _Iter_value_t<_RanItPat>>
+using _Boyer_moore_traits =
+    conditional_t<is_integral_v<_Value_t> && sizeof(_Value_t) <= 2
+                      && (is_same_v<equal_to<>, _Pred_eq> || is_same_v<equal_to<_Value_t>, _Pred_eq>),
+        conditional_t<sizeof(_Value_t) == 1, _Boyer_moore_traits_char_mode<_RanItPat, _Hash_ty, _Pred_eq>,
+            _Boyer_moore_traits_wchar_t_mode<_RanItPat>>,
+        _Boyer_moore_traits_general_mode<_RanItPat, _Hash_ty, _Pred_eq>>;
+
+_EXPORT_STD template <class _RanItPat, class _Hash_ty = hash<_Iter_value_t<_RanItPat>>, class _Pred_eq = equal_to<>>
+class boyer_moore_searcher {
+public:
+    boyer_moore_searcher(
+        const _RanItPat _First, const _RanItPat _Last, _Hash_ty _Hash_fn = _Hash_ty(), _Pred_eq _Eq = _Pred_eq())
+        : _Data(_Traits::template _Build_boyer_moore<true>(_First, _Last, _STD move(_Hash_fn), _STD move(_Eq))) {
+        // preprocess a pattern for use with the Boyer-Moore string search algorithm
+    }
+
+    boyer_moore_searcher(const boyer_moore_searcher& _Other) noexcept // strengthened
+        : _Data(_Other._Data) {
+        _MT_INCR(*static_cast<_Atomic_counter_t*>(_Data));
+    }
+
+    ~boyer_moore_searcher() noexcept {
+        if (_MT_DECR(*static_cast<_Atomic_counter_t*>(_Data)) == 0) {
+            _Traits::_Destroy(_Data);
+        }
+    }
+
+    boyer_moore_searcher& operator=(const boyer_moore_searcher& _Other) noexcept /* strengthened */ {
+        boyer_moore_searcher _Cpy(_Other);
+        _STD swap(_Data, _Cpy._Data);
+        return *this;
+    }
+
+    template <class _RanItHaystack>
+    _NODISCARD pair<_RanItHaystack, _RanItHaystack> operator()(
+        const _RanItHaystack _First, const _RanItHaystack _Last) const {
+        // search for the preprocessed pattern in [_First, _Last)
+        return _Traits::_Use_boyer_moore(_Data, _First, _Last);
+    }
+
+private:
+    using _Traits = _Boyer_moore_traits<_RanItPat, _Hash_ty, _Pred_eq>;
+    void* _Data;
+};
+
+_EXPORT_STD template <class _RanItPat, class _Hash_ty = hash<_Iter_value_t<_RanItPat>>, class _Pred_eq = equal_to<>>
+class boyer_moore_horspool_searcher { // equivalent to Boyer-Moore without the second table
+public:
+    boyer_moore_horspool_searcher(
+        const _RanItPat _First, const _RanItPat _Last, _Hash_ty _Hash_fn = _Hash_ty(), _Pred_eq _Eq = _Pred_eq())
+        : _Data(_Traits::template _Build_boyer_moore<false>(_First, _Last, _STD move(_Hash_fn), _STD move(_Eq))) {
+        // preprocess a pattern for use with the Boyer-Moore-Horspool string search algorithm
+    }
+
+    boyer_moore_horspool_searcher(const boyer_moore_horspool_searcher& _Other) noexcept // strengthened
+        : _Data(_Other._Data) {
+        _MT_INCR(*static_cast<_Atomic_counter_t*>(_Data));
+    }
+
+    ~boyer_moore_horspool_searcher() noexcept {
+        if (_MT_DECR(*static_cast<_Atomic_counter_t*>(_Data)) == 0) {
+            _Traits::_Destroy(_Data);
+        }
+    }
+
+    boyer_moore_horspool_searcher& operator=(const boyer_moore_horspool_searcher& _Other) noexcept /* strengthened */ {
+        boyer_moore_horspool_searcher _Cpy(_Other);
+        _STD swap(_Data, _Cpy._Data);
+        return *this;
+    }
+
+    template <class _RanItHaystack>
+    _NODISCARD pair<_RanItHaystack, _RanItHaystack> operator()(
+        const _RanItHaystack _First, const _RanItHaystack _Last) const {
+        // search for the preprocessed pattern in [_First, _Last)
+        return _Traits::_Use_boyer_moore_horspool(_Data, _First, _Last);
+    }
+
+private:
+    using _Traits = _Boyer_moore_traits<_RanItPat, _Hash_ty, _Pred_eq>;
+    void* _Data;
+};
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD struct not_equal_to {
+        template <class _Ty1, class _Ty2>
+            requires equality_comparable_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right)))) /* strengthened */ {
+            return !static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right));
+        }
+
+        using is_transparent = int;
+    };
+
+    _EXPORT_STD struct greater_equal {
+        template <class _Ty1, class _Ty2>
+            requires totally_ordered_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right)))) /* strengthened */ {
+            return !static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right));
+        }
+
+        using is_transparent = int;
+    };
+
+    _EXPORT_STD struct less_equal {
+        template <class _Ty1, class _Ty2>
+            requires totally_ordered_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left)))) /* strengthened */ {
+            return !static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left));
+        }
+
+        using is_transparent = int;
+    };
+} // namespace ranges
+#endif // _HAS_CXX20
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FUNCTIONAL_
diff --git a/msvc-stl/stl/inc/future b/msvc-stl/stl/inc/future
new file mode 100644
index 0000000..42b70fc
--- /dev/null
+++ b/msvc-stl/stl/inc/future
@@ -0,0 +1,1522 @@
+// future standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _FUTURE_
+#define _FUTURE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <future> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#ifdef _RESUMABLE_FUNCTIONS_SUPPORTED
+#include <experimental/resumable>
+#endif // _RESUMABLE_FUNCTIONS_SUPPORTED
+
+#include <__msvc_chrono.hpp>
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <ppltasks.h>
+#include <system_error>
+#include <thread>
+#include <utility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Alloc>
+struct _Allocator_deleter {
+    _Alloc _Al;
+
+    using pointer = typename allocator_traits<_Alloc>::pointer;
+    void operator()(pointer _Ptr) noexcept { // delete the pointer
+        _STD _Destroy_in_place(*_Ptr);
+        _Al.deallocate(_Ptr, 1);
+    }
+};
+
+template <class _Alloc>
+using _Unique_ptr_alloc = unique_ptr<typename _Alloc::value_type, _Allocator_deleter<_Alloc>>;
+
+template <class _Alloc, class... _Args>
+_NODISCARD _Unique_ptr_alloc<_Alloc> _Make_unique_alloc(_Alloc& _Al, _Args&&... _Vals) {
+    // construct an object with an allocator and return it owned by a unique_ptr
+    _Alloc_construct_ptr<_Alloc> _Constructor{_Al};
+    _Constructor._Allocate();
+    _STD _Construct_in_place(*_Constructor._Ptr, _STD forward<_Args>(_Vals)...);
+    return _Unique_ptr_alloc<_Alloc>(_Constructor._Release(), _Allocator_deleter<_Alloc>{_Al});
+}
+
+struct _From_raw_state_tag { // internal tag type for constructing a future from a raw state
+    explicit _From_raw_state_tag() = default;
+};
+
+_EXPORT_STD enum class future_errc { // names for futures errors
+    broken_promise = 1,
+    future_already_retrieved,
+    promise_already_satisfied,
+    no_state
+};
+
+_EXPORT_STD enum class launch { // names for launch options passed to async
+    async    = 0x1,
+    deferred = 0x2
+};
+
+_BITMASK_OPS(_EXPORT_STD, launch)
+
+_EXPORT_STD enum class future_status { // names for timed wait function returns
+    ready,
+    timeout,
+    deferred
+};
+
+template <>
+struct is_error_code_enum<future_errc> : true_type {};
+
+_EXPORT_STD _NODISCARD const error_category& future_category() noexcept;
+
+_EXPORT_STD _NODISCARD inline error_code make_error_code(future_errc _Ec) noexcept {
+    return error_code(static_cast<int>(_Ec), _STD future_category());
+}
+
+_EXPORT_STD _NODISCARD inline error_condition make_error_condition(future_errc _Ec) noexcept {
+    return error_condition(static_cast<int>(_Ec), _STD future_category());
+}
+
+_NODISCARD inline const char* _Future_error_map(int _Errcode) noexcept { // convert to name of future error
+    switch (static_cast<future_errc>(_Errcode)) { // switch on error code value
+    case future_errc::broken_promise:
+        return "broken promise";
+
+    case future_errc::future_already_retrieved:
+        return "future already retrieved";
+
+    case future_errc::promise_already_satisfied:
+        return "promise already satisfied";
+
+    case future_errc::no_state:
+        return "no state";
+
+    default:
+        return nullptr;
+    }
+}
+
+_EXPORT_STD class _NODISCARD future_error : public logic_error { // future exception
+public:
+    explicit future_error(error_code _Errcode) // internal, TRANSITION, will be removed
+        : logic_error(""), _Mycode(_Errcode) {}
+
+    explicit future_error(future_errc _Ec) : logic_error(""), _Mycode(_STD make_error_code(_Ec)) {}
+
+    _NODISCARD const error_code& code() const noexcept {
+        return _Mycode;
+    }
+
+    _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override { // get message string
+        return _Future_error_map(_Mycode.value());
+    }
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+
+private:
+    error_code _Mycode; // the stored error code
+};
+
+// TRANSITION, ABI: remove `2` suffix
+[[noreturn]] inline void _Throw_future_error2(const future_errc _Ec) {
+    _THROW(future_error{_Ec});
+}
+
+class _Future_error_category2 : public error_category { // categorize a future error
+public:
+    constexpr _Future_error_category2() noexcept : error_category(_Future_addr) {}
+
+    const char* name() const noexcept override {
+        return "future";
+    }
+
+    string message(int _Errcode) const override {
+        const char* _Name = _Future_error_map(_Errcode);
+        if (_Name) {
+            return _Name;
+        }
+
+        return _Syserror_map(_Errcode);
+    }
+};
+
+_EXPORT_STD _NODISCARD inline const error_category& future_category() noexcept {
+    return _Immortalize_memcpy_image<_Future_error_category2>();
+}
+
+template <class _Ty>
+class _Associated_state;
+
+template <class _Ty>
+struct __declspec(novtable) _Deleter_base { // abstract base class for managing deletion of state objects
+    virtual void _Delete(_Associated_state<_Ty>*) noexcept = 0;
+    virtual ~_Deleter_base() = default; // TRANSITION, ABI (make non-virtual, never called polymorphically)
+};
+
+template <class _Ty, class _Derived, class _Alloc>
+struct _State_deleter : _Deleter_base<_Ty> { // manage allocator and deletion state objects
+    _State_deleter(const _Alloc& _Al) : _My_alloc(_Al) {}
+
+    _State_deleter(const _State_deleter&)            = delete;
+    _State_deleter& operator=(const _State_deleter&) = delete;
+
+    void _Delete(_Associated_state<_Ty>* _State) noexcept override;
+
+    _Alloc _My_alloc;
+};
+
+template <class _Ty>
+struct __declspec(novtable) _Clonable_deleter_base : _Deleter_base<_Ty> {
+    // TRANSITION, ABI, should be fused into _Deleter_base
+    virtual _Associated_state<_Ty>* _Move_clone(_Associated_state<_Ty>&&) = 0;
+};
+
+template <class _Ty, class _Derived, class _Alloc>
+struct _State_deleter_v2 : _Clonable_deleter_base<_Ty> { // manage allocator and deletion state objects
+    _State_deleter_v2(const _Alloc& _Al) : _My_alloc(_Al) {}
+
+    _State_deleter_v2(const _State_deleter_v2&)            = delete;
+    _State_deleter_v2& operator=(const _State_deleter_v2&) = delete;
+
+    void _Delete(_Associated_state<_Ty>* _State) noexcept override;
+    _Associated_state<_Ty>* _Move_clone(_Associated_state<_Ty>&& _Src) override;
+
+    _Alloc _My_alloc;
+};
+
+template <class _Ty>
+union _Result_holder {
+    _Result_holder() noexcept {}
+    ~_Result_holder() noexcept {}
+
+    _Ty _Held_value;
+};
+
+template <class _Ty>
+class _Associated_state { // class for managing associated synchronous state
+public:
+    using _State_type = _Ty;
+    using _Mydel      = _Deleter_base<_Ty>;
+
+    // TRANSITION, incorrectly default constructs _Result when _Ty is default constructible
+    _Associated_state(_Mydel* _Dp = nullptr)
+        : _Refs(1), // non-atomic initialization
+          _Result(), _Exception(), _Retrieved(false), _Ready(false), _Ready_at_thread_exit(false),
+          _Has_stored_result(false), _Running(false), _Deleter(_Dp) {}
+
+    virtual ~_Associated_state() noexcept {
+        if (_Already_has_stored_result() && !_Ready) { // registered for release at thread exit
+            _Cond._Unregister(_Mtx);
+        }
+
+        if constexpr (!is_default_constructible_v<_Ty>) {
+            if (_Has_stored_result) {
+                _Result._Held_value.~_Ty();
+            }
+        }
+    }
+
+    void _Retain() noexcept { // increment reference count
+        _MT_INCR(_Refs);
+    }
+
+    void _Release() noexcept { // decrement reference count and destroy when zero
+        if (_MT_DECR(_Refs) == 0) {
+            _Delete_this();
+        }
+    }
+
+private:
+    _Atomic_counter_t _Refs;
+
+public:
+    virtual void _Wait() { // wait for signal
+        unique_lock<mutex> _Lock(_Mtx);
+        _Maybe_run_deferred_function(_Lock);
+        while (!_Ready) {
+            _Cond.wait(_Lock);
+        }
+    }
+
+    struct _Test_ready { // wraps _Associated_state
+        _Test_ready(const _Associated_state* _St) : _State(_St) {}
+
+        bool operator()() const { // test state
+            return _State->_Ready != 0;
+        }
+        const _Associated_state* _State;
+    };
+
+    template <class _Rep, class _Per>
+    future_status _Wait_for(const chrono::duration<_Rep, _Per>& _Rel_time) { // wait for duration
+        unique_lock<mutex> _Lock(_Mtx);
+        if (_Has_deferred_function()) {
+            return future_status::deferred;
+        }
+
+        if (_Cond.wait_for(_Lock, _Rel_time, _Test_ready(this))) {
+            return future_status::ready;
+        }
+
+        return future_status::timeout;
+    }
+
+    template <class _Clock, class _Dur>
+    future_status _Wait_until(const chrono::time_point<_Clock, _Dur>& _Abs_time) { // wait until time point
+        unique_lock<mutex> _Lock(_Mtx);
+        if (_Has_deferred_function()) {
+            return future_status::deferred;
+        }
+
+        if (_Cond.wait_until(_Lock, _Abs_time, _Test_ready(this))) {
+            return future_status::ready;
+        }
+
+        return future_status::timeout;
+    }
+
+    virtual _Ty& _Get_value(bool _Get_only_once) {
+        unique_lock<mutex> _Lock(_Mtx);
+        if (_Get_only_once && _Retrieved) {
+            _Throw_future_error2(future_errc::future_already_retrieved);
+        }
+
+        if (_Exception) {
+            _STD rethrow_exception(_Exception);
+        }
+
+        // TRANSITION: `_Retrieved` should be assigned before `_Exception` is thrown so that a `future::get`
+        // that throws a stored exception invalidates the future (N4950 [futures.unique.future]/17)
+        _Retrieved = true;
+        _Maybe_run_deferred_function(_Lock);
+        while (!_Ready) {
+            _Cond.wait(_Lock);
+        }
+
+        if (_Exception) {
+            _STD rethrow_exception(_Exception);
+        }
+
+        if constexpr (is_default_constructible_v<_Ty>) {
+            return _Result;
+        } else {
+            return _Result._Held_value;
+        }
+    }
+
+    template <class _Ty2>
+    void _Emplace_result(_Ty2&& _Val) {
+        // TRANSITION, incorrectly assigns _Result when _Ty is default constructible
+        if constexpr (is_default_constructible_v<_Ty>) {
+            _Result = _STD forward<_Ty2>(_Val);
+        } else {
+            ::new (static_cast<void*>(_STD addressof(_Result._Held_value))) _Ty(_STD forward<_Ty2>(_Val));
+            _Has_stored_result = true;
+        }
+    }
+
+    void _Set_value(const _Ty& _Val, bool _At_thread_exit) { // store a result
+        unique_lock<mutex> _Lock(_Mtx);
+        _Set_value_raw(_Val, &_Lock, _At_thread_exit);
+    }
+
+    void _Set_value_raw(const _Ty& _Val, unique_lock<mutex>* _Lock, bool _At_thread_exit) {
+        // store a result while inside a locked block
+        if (_Already_has_stored_result()) {
+            _Throw_future_error2(future_errc::promise_already_satisfied);
+        }
+
+        _Emplace_result(_Val);
+        _Do_notify(_Lock, _At_thread_exit);
+    }
+
+    void _Set_value(_Ty&& _Val, bool _At_thread_exit) { // store a result
+        unique_lock<mutex> _Lock(_Mtx);
+        _Set_value_raw(_STD forward<_Ty>(_Val), &_Lock, _At_thread_exit);
+    }
+
+    void _Set_value_raw(_Ty&& _Val, unique_lock<mutex>* _Lock, bool _At_thread_exit) {
+        // store a result while inside a locked block
+        if (_Already_has_stored_result()) {
+            _Throw_future_error2(future_errc::promise_already_satisfied);
+        }
+
+        _Emplace_result(_STD forward<_Ty>(_Val));
+        _Do_notify(_Lock, _At_thread_exit);
+    }
+
+    void _Set_exception(exception_ptr _Exc, bool _At_thread_exit) { // store a result
+        unique_lock<mutex> _Lock(_Mtx);
+        _Set_exception_raw(_Exc, &_Lock, _At_thread_exit);
+    }
+
+    void _Set_exception_raw(exception_ptr _Exc, unique_lock<mutex>* _Lock, bool _At_thread_exit) {
+        // store a result while inside a locked block
+        if (_Already_has_stored_result()) {
+            _Throw_future_error2(future_errc::promise_already_satisfied);
+        }
+
+        _STL_ASSERT(_Exc != nullptr, "promise<T>::set_exception/set_exception_at_thread_exit called with a null "
+                                     "std::exception_ptr, which is invalid per N4950 [futures.promise]/20");
+        _Exception = _Exc;
+        _Do_notify(_Lock, _At_thread_exit);
+    }
+
+    bool _Is_ready() const noexcept {
+        return _Ready != 0;
+    }
+
+    bool _Already_has_stored_result() const noexcept { // Has a result or an exception
+        if constexpr (is_default_constructible_v<_Ty>) {
+            return _Has_stored_result;
+        } else {
+            return _Has_stored_result || _Exception;
+        }
+    }
+
+    bool _Already_retrieved() const noexcept {
+        return _Retrieved;
+    }
+
+    void _Abandon() { // abandon shared state
+        unique_lock<mutex> _Lock(_Mtx);
+        if (!_Already_has_stored_result()) { // queue exception
+            future_error _Fut(_STD make_error_code(future_errc::broken_promise));
+            _Set_exception_raw(_STD make_exception_ptr(_Fut), &_Lock, false);
+        }
+    }
+
+    _Mydel* _Get_deleter() const noexcept { // get deleter for cloning
+        return _Deleter;
+    }
+
+protected:
+    void _Maybe_run_deferred_function(unique_lock<mutex>& _Lock) { // run a deferred function if not already done
+        if (!_Running) { // run the function
+            _Running = true;
+            _Run_deferred_function(_Lock);
+        }
+    }
+
+public:
+    conditional_t<is_default_constructible_v<_Ty>, _Ty, _Result_holder<_Ty>> _Result;
+    exception_ptr _Exception;
+    mutex _Mtx;
+    condition_variable _Cond;
+    bool _Retrieved;
+    int _Ready;
+    bool _Ready_at_thread_exit; // TRANSITION, ABI
+    bool _Has_stored_result;
+    bool _Running;
+
+private:
+    virtual bool _Has_deferred_function() const noexcept { // overridden by _Deferred_async_state
+        return false;
+    }
+
+    virtual void _Run_deferred_function(unique_lock<mutex>&) {} // do nothing
+
+    virtual void _Do_notify(unique_lock<mutex>* _Lock, bool _At_thread_exit) { // notify waiting threads
+        // TRANSITION, ABI: This is virtual, but never overridden.
+        if constexpr (is_default_constructible_v<_Ty>) {
+            _Has_stored_result = true;
+        }
+
+        if (_At_thread_exit) { // notify at thread exit
+            _Cond._Register(*_Lock, &_Ready);
+        } else { // notify immediately
+            _Ready = true;
+            _Cond.notify_all();
+        }
+    }
+
+    void _Delete_this() noexcept { // delete this object
+        if (_Deleter) {
+            _Deleter->_Delete(this);
+        } else {
+            delete this;
+        }
+    }
+
+    _Mydel* _Deleter;
+
+public:
+    _Associated_state(const _Associated_state&)            = delete;
+    _Associated_state& operator=(const _Associated_state&) = delete;
+};
+
+template <class _Ty, class _Derived, class _Alloc>
+void _State_deleter<_Ty, _Derived, _Alloc>::_Delete(_Associated_state<_Ty>* _State) noexcept {
+    // delete _State and this using stored allocator
+    using _State_allocator = _Rebind_alloc_t<_Alloc, _Derived>;
+    _State_allocator _St_alloc(_My_alloc);
+
+    using _Deleter_allocator = _Rebind_alloc_t<_Alloc, _State_deleter>;
+    _Deleter_allocator _Del_alloc(_My_alloc);
+
+    _Derived* _Ptr = static_cast<_Derived*>(_State);
+
+    _STD _Delete_plain_internal(_St_alloc, _Ptr);
+    _STD _Delete_plain_internal(_Del_alloc, this);
+}
+
+template <class _Fret>
+struct _P_arg_type { // type for functions returning T
+    using type = _Fret;
+};
+
+template <class _Fret>
+struct _P_arg_type<_Fret&> { // type for functions returning reference to T
+    using type = _Fret*;
+};
+
+template <>
+struct _P_arg_type<void> { // type for functions returning void
+    using type = int;
+};
+
+template <class _Ret>
+using _P_arg_type_t = typename _P_arg_type<_Ret>::type;
+
+template <class>
+class _Packaged_state;
+
+// class for managing associated asynchronous state for packaged_task
+template <class _Ret, class... _ArgTypes>
+class _Packaged_state<_Ret(_ArgTypes...)> : public _Associated_state<_P_arg_type_t<_Ret>> {
+public:
+    using _Mybase        = _Associated_state<_P_arg_type_t<_Ret>>;
+    using _Mydel         = typename _Mybase::_Mydel;
+    using _Function_type = function<_Ret(_ArgTypes...)>; // TRANSITION, ABI, should not use std::function
+
+    explicit _Packaged_state(const _Function_type& _Fnarg) : _Fn(_Fnarg) {}
+
+    explicit _Packaged_state(_Function_type&& _Fnarg) noexcept : _Fn(_STD move(_Fnarg)) {}
+
+    template <class _Fty2, enable_if_t<!is_same_v<_Remove_cvref_t<_Fty2>, _Function_type>, int> = 0>
+    explicit _Packaged_state(_Fty2&& _Fnarg) : _Fn(_Secret_copyability_ignoring_tag{}, _STD forward<_Fty2>(_Fnarg)) {}
+
+    template <class _Alloc>
+    _Packaged_state(_Function_type&& _Fnarg, const _Alloc& _Al, _Mydel* _Dp)
+        : _Mybase(_Dp), _Fn(_Secret_copyability_ignoring_tag{}, allocator_arg, _Al, _STD move(_Fnarg)) {}
+
+    template <class _Fty2, class _Alloc, enable_if_t<!is_same_v<_Remove_cvref_t<_Fty2>, _Function_type>, int> = 0>
+    _Packaged_state(_Fty2&& _Fnarg, const _Alloc& _Al, _Mydel* _Dp)
+        : _Mybase(_Dp), _Fn(_Secret_copyability_ignoring_tag{}, allocator_arg, _Al, _STD forward<_Fty2>(_Fnarg)) {}
+
+    void _Call_deferred(_ArgTypes... _Args) { // set deferred call
+        _TRY_BEGIN
+        // call function object and catch exceptions
+        if constexpr (is_same_v<_Ret, void>) {
+            _Fn(_STD forward<_ArgTypes>(_Args)...);
+            this->_Set_value(1, true);
+        } else if constexpr (is_lvalue_reference_v<_Ret>) {
+            this->_Set_value(_STD addressof(_Fn(_STD forward<_ArgTypes>(_Args)...)), true);
+        } else {
+            this->_Set_value(_Fn(_STD forward<_ArgTypes>(_Args)...), true);
+        }
+        _CATCH_ALL
+        // function object threw exception; record result
+        this->_Set_exception(_STD current_exception(), true);
+        _CATCH_END
+    }
+
+    void _Call_immediate(_ArgTypes... _Args) { // call function object
+        _TRY_BEGIN
+        // call function object and catch exceptions
+        if constexpr (is_same_v<_Ret, void>) {
+            _Fn(_STD forward<_ArgTypes>(_Args)...);
+            this->_Set_value(1, false);
+        } else if constexpr (is_lvalue_reference_v<_Ret>) {
+            this->_Set_value(_STD addressof(_Fn(_STD forward<_ArgTypes>(_Args)...)), false);
+        } else {
+            this->_Set_value(_Fn(_STD forward<_ArgTypes>(_Args)...), false);
+        }
+        _CATCH_ALL
+        // function object threw exception; record result
+        this->_Set_exception(_STD current_exception(), false);
+        _CATCH_END
+    }
+
+    _Function_type&& _Get_fn() && noexcept {
+        return _STD move(_Fn);
+    }
+
+private:
+    _Function_type _Fn;
+};
+
+template <class _Ty, class _Alloc>
+_Associated_state<_Ty>* _Make_associated_state(const _Alloc& _Al) {
+    // construct an _Associated_state object with an allocator
+    using _Delty   = _State_deleter<_Ty, _Associated_state<_Ty>, _Alloc>;
+    using _Aldelty = _Rebind_alloc_t<_Alloc, _Delty>;
+    using _Alstate = _Rebind_alloc_t<_Alloc, _Associated_state<_Ty>>;
+
+    _Aldelty _Del_alloc(_Al);
+    _Alstate _State_alloc(_Al);
+    auto _Del = _STD _Make_unique_alloc(_Del_alloc, _Al);
+    auto _Res = _STD _Make_unique_alloc(_State_alloc, _STD _Unfancy(_Del.get()));
+    (void) _Del.release(); // ownership of _Del.get() now transferred to _Res
+    return _STD _Unfancy(_Res.release()); // ownership transferred to caller
+}
+
+template <class _Pack_state, class _Fty2, class _Alloc>
+_Pack_state* _Make_packaged_state(_Fty2&& _Fnarg, const _Alloc& _Al) {
+    // construct a _Packaged_state object with an allocator from an rvalue function object
+#ifdef _CPPRTTI // TRANSITION, ABI, should not rely on RTTI
+    using _Delty = _State_deleter_v2<typename _Pack_state::_Mybase::_State_type, _Pack_state, _Alloc>;
+#else // ^^^ defined(_CPPRTTI) / !defined(_CPPRTTI) vvv
+    using _Delty = _State_deleter<typename _Pack_state::_Mybase::_State_type, _Pack_state, _Alloc>;
+#endif // ^^^ !defined(_CPPRTTI) ^^^
+    using _Aldelty = _Rebind_alloc_t<_Alloc, _Delty>;
+    using _Alstate = _Rebind_alloc_t<_Alloc, _Pack_state>;
+
+    _Aldelty _Del_alloc(_Al);
+    _Alstate _State_alloc(_Al);
+    auto _Del = _STD _Make_unique_alloc(_Del_alloc, _Al);
+    auto _Res = _STD _Make_unique_alloc(_State_alloc, _STD forward<_Fty2>(_Fnarg), _Al, _STD _Unfancy(_Del.get()));
+    (void) _Del.release(); // ownership of _Del.get() now transferred to _Res
+    return _STD _Unfancy(_Res.release()); // ownership transferred to caller
+}
+
+template <class _Ty, class _Derived, class _Alloc>
+void _State_deleter_v2<_Ty, _Derived, _Alloc>::_Delete(_Associated_state<_Ty>* _State) noexcept {
+    // delete _State and this using stored allocator
+    using _State_allocator = _Rebind_alloc_t<_Alloc, _Derived>;
+    _State_allocator _St_alloc(_My_alloc);
+
+    using _Deleter_allocator = _Rebind_alloc_t<_Alloc, _State_deleter_v2>;
+    _Deleter_allocator _Del_alloc(_My_alloc);
+
+    _Derived* _Ptr = static_cast<_Derived*>(_State);
+
+    _STD _Delete_plain_internal(_St_alloc, _Ptr);
+    _STD _Delete_plain_internal(_Del_alloc, this);
+}
+
+template <class _Ty, class _Derived, class _Alloc>
+_Associated_state<_Ty>* _State_deleter_v2<_Ty, _Derived, _Alloc>::_Move_clone(_Associated_state<_Ty>&& _Src) {
+    return _STD _Make_packaged_state<_Derived>(static_cast<_Derived&&>(_Src)._Get_fn(), _My_alloc);
+}
+
+template <class _Rx>
+class _Deferred_async_state : public _Packaged_state<_Rx()> {
+    // class for managing associated synchronous state for deferred execution from async
+public:
+    template <class _Fty2>
+    _Deferred_async_state(const _Fty2& _Fnarg) : _Packaged_state<_Rx()>(_Fnarg) {}
+
+    template <class _Fty2>
+    _Deferred_async_state(_Fty2&& _Fnarg) : _Packaged_state<_Rx()>(_STD forward<_Fty2>(_Fnarg)) {}
+
+private:
+    bool _Has_deferred_function() const noexcept override {
+        // this function is considered to be deferred until it's invoked
+        return !this->_Running;
+    }
+
+    void _Run_deferred_function(unique_lock<mutex>& _Lock) override { // run the deferred function
+        _Lock.unlock();
+        _Packaged_state<_Rx()>::_Call_immediate();
+        _Lock.lock();
+    }
+};
+
+template <class _Rx>
+class _Task_async_state : public _Packaged_state<_Rx()> {
+    // class for managing associated synchronous state for asynchronous execution from async
+public:
+    using _Mybase     = _Packaged_state<_Rx()>;
+    using _State_type = typename _Mybase::_State_type;
+
+    template <class _Fty2>
+    _Task_async_state(_Fty2&& _Fnarg) : _Mybase(_STD forward<_Fty2>(_Fnarg)) {
+        _Task = ::Concurrency::create_task([this]() { // do it now
+            this->_Call_immediate();
+        });
+
+        this->_Running = true;
+    }
+
+    ~_Task_async_state() noexcept override {
+        _Wait();
+    }
+
+    void _Wait() override { // wait for completion
+        _Task.wait();
+    }
+
+    _State_type& _Get_value(bool _Get_only_once) override {
+        // return the stored result or throw stored exception
+        _Task.wait();
+        return _Mybase::_Get_value(_Get_only_once);
+    }
+
+private:
+    ::Concurrency::task<void> _Task;
+};
+
+template <class _Ty>
+class _State_manager {
+    // class for managing possibly non-existent associated asynchronous state object
+public:
+    _State_manager() = default; // construct with no associated asynchronous state object
+
+    _State_manager(_Associated_state<_Ty>* _New_state, bool _Get_once) noexcept
+        : _Assoc_state(_New_state), _Get_only_once(_Get_once) {} // construct with _New_state
+
+    _State_manager(const _State_manager& _Other, bool _Get_once = false) noexcept
+        : _Assoc_state(_Other._Assoc_state), _Get_only_once(_Get_once) {
+        if (_Assoc_state) { // do the copy
+            _Assoc_state->_Retain();
+        }
+    }
+
+    _State_manager(_State_manager&& _Other, bool _Get_once = false) noexcept
+        : _Assoc_state(_STD exchange(_Other._Assoc_state, nullptr)), _Get_only_once(_Get_once) {}
+
+    ~_State_manager() noexcept {
+        if (_Assoc_state) {
+            _Assoc_state->_Release();
+        }
+    }
+
+    _State_manager& operator=(const _State_manager& _Other) noexcept {
+        // copy stored associated asynchronous state object from _Other
+        if (_Other._Assoc_state) {
+            _Other._Assoc_state->_Retain();
+        }
+
+        if (_Assoc_state) {
+            _Assoc_state->_Release();
+        }
+
+        _Assoc_state   = _Other._Assoc_state;
+        _Get_only_once = _Other._Get_only_once;
+        return *this;
+    }
+
+    _State_manager& operator=(_State_manager&& _Other) noexcept {
+        // move stored associated asynchronous state object from _Other
+        if (this != _STD addressof(_Other)) {
+            if (_Assoc_state) {
+                _Assoc_state->_Release();
+            }
+
+            _Assoc_state   = _STD exchange(_Other._Assoc_state, nullptr);
+            _Get_only_once = _Other._Get_only_once;
+        }
+        return *this;
+    }
+
+    _NODISCARD bool valid() const noexcept {
+        return _Assoc_state && !(_Get_only_once && _Assoc_state->_Already_retrieved());
+    }
+
+    void wait() const { // wait for signal
+        if (!valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        _Assoc_state->_Wait();
+    }
+
+    template <class _Rep, class _Per>
+    future_status wait_for(const chrono::duration<_Rep, _Per>& _Rel_time) const { // wait for duration
+        if (!valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        return _Assoc_state->_Wait_for(_Rel_time);
+    }
+
+    template <class _Clock, class _Dur>
+    future_status wait_until(const chrono::time_point<_Clock, _Dur>& _Abs_time) const { // wait until time point
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        if (!valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        return _Assoc_state->_Wait_until(_Abs_time);
+    }
+
+    _Ty& _Get_value() const {
+        if (!valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        return _Assoc_state->_Get_value(_Get_only_once);
+    }
+
+    void _Set_value(const _Ty& _Val, bool _Defer) { // store a result
+        if (!valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        _Assoc_state->_Set_value(_Val, _Defer);
+    }
+
+    void _Set_value(_Ty&& _Val, bool _Defer) { // store a result
+        if (!valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        _Assoc_state->_Set_value(_STD forward<_Ty>(_Val), _Defer);
+    }
+
+    void _Abandon() { // abandon shared state
+        if (_Assoc_state) {
+            _Assoc_state->_Abandon();
+        }
+    }
+
+    void _Set_exception(exception_ptr _Exc, bool _Defer) { // store a result
+        if (!valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        _Assoc_state->_Set_exception(_Exc, _Defer);
+    }
+
+    void _Swap(_State_manager& _Other) noexcept { // exchange with _Other
+        _STD swap(_Assoc_state, _Other._Assoc_state);
+    }
+
+    _Associated_state<_Ty>* _Ptr() const noexcept {
+        return _Assoc_state;
+    }
+
+    bool _Is_ready() const noexcept {
+        return _Assoc_state && _Assoc_state->_Is_ready();
+    }
+
+private:
+    _Associated_state<_Ty>* _Assoc_state = nullptr;
+    bool _Get_only_once                  = false;
+};
+
+_EXPORT_STD template <class _Ty>
+class shared_future;
+
+_EXPORT_STD template <class _Ty>
+class future : public _State_manager<_Ty> {
+    // class that defines a non-copyable asynchronous return object that holds a value
+private:
+    using _Mybase = _State_manager<_Ty>;
+
+public:
+    static_assert(!is_array_v<_Ty> && is_object_v<_Ty> && is_destructible_v<_Ty>,
+        "T in future<T> must meet the Cpp17Destructible requirements (N4950 [futures.unique.future]/4).");
+
+    future() = default;
+
+    future(future&& _Other) noexcept : _Mybase(_STD move(_Other), true) {}
+
+    future& operator=(future&&) = default;
+
+    future(_From_raw_state_tag, const _Mybase& _State) noexcept : _Mybase(_State, true) {}
+
+    _Ty get() {
+        // block until ready then return the stored result or throw the stored exception
+        future _Local{_STD move(*this)};
+        return _STD move(_Local._Get_value());
+    }
+
+    _NODISCARD shared_future<_Ty> share() noexcept {
+        return shared_future<_Ty>(_STD move(*this));
+    }
+
+    future(const future&)            = delete;
+    future& operator=(const future&) = delete;
+};
+
+template <class _Ty>
+class future<_Ty&> : public _State_manager<_Ty*> {
+    // class that defines a non-copyable asynchronous return object that holds a reference
+private:
+    using _Mybase = _State_manager<_Ty*>;
+
+public:
+    future() = default;
+
+    future(future&& _Other) noexcept : _Mybase(_STD move(_Other), true) {}
+
+    future& operator=(future&&) = default;
+
+    future(_From_raw_state_tag, const _Mybase& _State) noexcept : _Mybase(_State, true) {}
+
+    _Ty& get() {
+        // block until ready then return the stored result or throw the stored exception
+        future _Local{_STD move(*this)};
+        return *_Local._Get_value();
+    }
+
+    _NODISCARD shared_future<_Ty&> share() noexcept {
+        return shared_future<_Ty&>(_STD move(*this));
+    }
+
+    future(const future&)            = delete;
+    future& operator=(const future&) = delete;
+};
+
+template <>
+class future<void> : public _State_manager<int> {
+    // class that defines a non-copyable asynchronous return object that does not hold a value
+private:
+    using _Mybase = _State_manager<int>;
+
+public:
+    future() = default;
+
+    future(future&& _Other) noexcept : _Mybase(_STD move(_Other), true) {}
+
+    future& operator=(future&&) = default;
+
+    future(_From_raw_state_tag, const _Mybase& _State) noexcept : _Mybase(_State, true) {}
+
+    void get() {
+        // block until ready then return or throw the stored exception
+        future _Local{_STD move(*this)};
+        _Local._Get_value();
+    }
+
+    _NODISCARD shared_future<void> share() noexcept;
+
+    future(const future&)            = delete;
+    future& operator=(const future&) = delete;
+};
+
+_EXPORT_STD template <class _Ty>
+class shared_future : public _State_manager<_Ty> {
+    // class that defines a copyable asynchronous return object that holds a value
+private:
+    using _Mybase = _State_manager<_Ty>;
+
+public:
+    static_assert(!is_array_v<_Ty> && is_object_v<_Ty> && is_destructible_v<_Ty>,
+        "T in shared_future<T> must meet the Cpp17Destructible requirements (N4950 [futures.shared.future]/4).");
+
+    shared_future() = default;
+
+    shared_future(const shared_future& _Other) noexcept : _Mybase(_Other) {}
+
+    shared_future& operator=(const shared_future&) = default;
+
+    shared_future(future<_Ty>&& _Other) noexcept : _Mybase(static_cast<_Mybase&&>(_Other)) {}
+
+    shared_future(shared_future&& _Other) noexcept : _Mybase(_STD move(_Other)) {}
+
+    shared_future& operator=(shared_future&&) = default;
+
+    const _Ty& get() const {
+        // block until ready then return the stored result or throw the stored exception
+        return this->_Get_value();
+    }
+};
+
+template <class _Ty>
+class shared_future<_Ty&> : public _State_manager<_Ty*> {
+    // class that defines a copyable asynchronous return object that holds a reference
+private:
+    using _Mybase = _State_manager<_Ty*>;
+
+public:
+    shared_future() = default;
+
+    shared_future(const shared_future& _Other) noexcept : _Mybase(_Other) {}
+
+    shared_future& operator=(const shared_future&) = default;
+
+    shared_future(future<_Ty&>&& _Other) noexcept : _Mybase(static_cast<_Mybase&&>(_Other)) {}
+
+    shared_future(shared_future&& _Other) noexcept : _Mybase(_STD move(_Other)) {}
+
+    shared_future& operator=(shared_future&&) = default;
+
+    _Ty& get() const {
+        // block until ready then return the stored result or throw the stored exception
+        return *this->_Get_value();
+    }
+};
+
+template <>
+class shared_future<void> : public _State_manager<int> {
+    // class that defines a copyable asynchronous return object that does not hold a value
+private:
+    using _Mybase = _State_manager<int>;
+
+public:
+    shared_future() noexcept {}
+
+    shared_future(const shared_future& _Other) noexcept : _Mybase(_Other) {}
+
+    shared_future& operator=(const shared_future&) = default;
+
+    shared_future(shared_future&& _Other) noexcept : _Mybase(_STD move(_Other)) {}
+
+    shared_future(future<void>&& _Other) noexcept : _Mybase(static_cast<_Mybase&&>(_Other)) {}
+
+    shared_future& operator=(shared_future&&) = default;
+
+    void get() const { // block until ready then return or throw the stored exception
+        this->_Get_value();
+    }
+};
+
+_NODISCARD inline shared_future<void> future<void>::share() noexcept {
+    return shared_future<void>(_STD move(*this));
+}
+
+template <class _Ty>
+class _Promise {
+public:
+    _Promise(_Associated_state<_Ty>* _State_ptr) noexcept : _State(_State_ptr, false), _Future_retrieved(false) {}
+
+    _Promise(_Promise&&) = default;
+
+    _Promise& operator=(_Promise&&) = default;
+
+    void _Swap(_Promise& _Other) noexcept {
+        _State._Swap(_Other._State);
+        _STD swap(_Future_retrieved, _Other._Future_retrieved);
+    }
+
+    const _State_manager<_Ty>& _Get_state() const noexcept {
+        return _State;
+    }
+    _State_manager<_Ty>& _Get_state() noexcept {
+        return _State;
+    }
+
+    _State_manager<_Ty>& _Get_state_for_set() {
+        if (!_State.valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        return _State;
+    }
+
+    _State_manager<_Ty>& _Get_state_for_future() {
+        if (!_State.valid()) {
+            _Throw_future_error2(future_errc::no_state);
+        }
+
+        if (_Future_retrieved) {
+            _Throw_future_error2(future_errc::future_already_retrieved);
+        }
+
+        _Future_retrieved = true;
+        return _State;
+    }
+
+    bool _Is_valid() const noexcept {
+        return _State.valid();
+    }
+
+    bool _Is_ready() const noexcept {
+        return _State._Is_ready();
+    }
+
+    _Promise(const _Promise&)            = delete;
+    _Promise& operator=(const _Promise&) = delete;
+
+private:
+    _State_manager<_Ty> _State;
+    bool _Future_retrieved;
+};
+
+_EXPORT_STD template <class _Ty>
+class promise { // class that defines an asynchronous provider that holds a value
+public:
+    static_assert(!is_array_v<_Ty> && is_object_v<_Ty> && is_destructible_v<_Ty>,
+        "T in promise<T> must meet the Cpp17Destructible requirements (N4950 [futures.promise]/1).");
+
+    promise() : _MyPromise(new _Associated_state<_Ty>) {}
+
+    template <class _Alloc>
+    promise(allocator_arg_t, const _Alloc& _Al) : _MyPromise(_Make_associated_state<_Ty>(_Al)) {}
+
+    promise(promise&&) = default;
+
+    promise& operator=(promise&& _Other) noexcept {
+        promise(_STD move(_Other)).swap(*this);
+        return *this;
+    }
+
+    ~promise() noexcept {
+        if (_MyPromise._Is_valid() && !_MyPromise._Is_ready()) {
+            // exception if destroyed before function object returns
+            future_error _Fut(_STD make_error_code(future_errc::broken_promise));
+            _MyPromise._Get_state()._Set_exception(_STD make_exception_ptr(_Fut), false);
+        }
+    }
+
+    void swap(promise& _Other) noexcept {
+        _MyPromise._Swap(_Other._MyPromise);
+    }
+
+    _NODISCARD_GET_FUTURE future<_Ty> get_future() {
+        return future<_Ty>(_From_raw_state_tag{}, _MyPromise._Get_state_for_future());
+    }
+
+    void set_value(const _Ty& _Val) {
+        _MyPromise._Get_state_for_set()._Set_value(_Val, false);
+    }
+
+    void set_value_at_thread_exit(const _Ty& _Val) {
+        _MyPromise._Get_state_for_set()._Set_value(_Val, true);
+    }
+
+    void set_value(_Ty&& _Val) {
+        _MyPromise._Get_state_for_set()._Set_value(_STD forward<_Ty>(_Val), false);
+    }
+
+    void set_value_at_thread_exit(_Ty&& _Val) {
+        _MyPromise._Get_state_for_set()._Set_value(_STD forward<_Ty>(_Val), true);
+    }
+
+    void set_exception(exception_ptr _Exc) {
+        _MyPromise._Get_state_for_set()._Set_exception(_Exc, false);
+    }
+
+    void set_exception_at_thread_exit(exception_ptr _Exc) {
+        _MyPromise._Get_state_for_set()._Set_exception(_Exc, true);
+    }
+
+    promise(const promise&)            = delete;
+    promise& operator=(const promise&) = delete;
+
+private:
+    _Promise<_Ty> _MyPromise;
+};
+
+template <class _Ty>
+class promise<_Ty&> { // class that defines an asynchronous provider that holds a reference
+public:
+    promise() : _MyPromise(new _Associated_state<_Ty*>) {}
+
+    template <class _Alloc>
+    promise(allocator_arg_t, const _Alloc& _Al) : _MyPromise(_Make_associated_state<_Ty*>(_Al)) {}
+
+    promise(promise&&) = default;
+
+    promise& operator=(promise&& _Other) noexcept {
+        promise(_STD move(_Other)).swap(*this);
+        return *this;
+    }
+
+    ~promise() noexcept {
+        if (_MyPromise._Is_valid() && !_MyPromise._Is_ready()) {
+            // exception if destroyed before function object returns
+            future_error _Fut(_STD make_error_code(future_errc::broken_promise));
+            _MyPromise._Get_state()._Set_exception(_STD make_exception_ptr(_Fut), false);
+        }
+    }
+
+    void swap(promise& _Other) noexcept {
+        _MyPromise._Swap(_Other._MyPromise);
+    }
+
+    _NODISCARD_GET_FUTURE future<_Ty&> get_future() {
+        return future<_Ty&>(_From_raw_state_tag{}, _MyPromise._Get_state_for_future());
+    }
+
+    void set_value(_Ty& _Val) {
+        _MyPromise._Get_state_for_set()._Set_value(_STD addressof(_Val), false);
+    }
+
+    void set_value_at_thread_exit(_Ty& _Val) {
+        _MyPromise._Get_state_for_set()._Set_value(_STD addressof(_Val), true);
+    }
+
+    void set_exception(exception_ptr _Exc) {
+        _MyPromise._Get_state_for_set()._Set_exception(_Exc, false);
+    }
+
+    void set_exception_at_thread_exit(exception_ptr _Exc) {
+        _MyPromise._Get_state_for_set()._Set_exception(_Exc, true);
+    }
+
+    promise(const promise&)            = delete;
+    promise& operator=(const promise&) = delete;
+
+private:
+    _Promise<_Ty*> _MyPromise;
+};
+
+template <>
+class promise<void> { // defines an asynchronous provider that does not hold a value
+public:
+    promise() : _MyPromise(new _Associated_state<int>) {}
+
+    template <class _Alloc>
+    promise(allocator_arg_t, const _Alloc& _Al) : _MyPromise(_Make_associated_state<int>(_Al)) {}
+
+    promise(promise&&) = default;
+
+    promise& operator=(promise&& _Other) noexcept {
+        promise(_STD move(_Other)).swap(*this);
+        return *this;
+    }
+
+    ~promise() noexcept {
+        if (_MyPromise._Is_valid() && !_MyPromise._Is_ready()) {
+            // exception if destroyed before function object returns
+            future_error _Fut(_STD make_error_code(future_errc::broken_promise));
+            _MyPromise._Get_state()._Set_exception(_STD make_exception_ptr(_Fut), false);
+        }
+    }
+
+    void swap(promise& _Other) noexcept {
+        _MyPromise._Swap(_Other._MyPromise);
+    }
+
+    _NODISCARD_GET_FUTURE future<void> get_future() {
+        return future<void>(_From_raw_state_tag{}, _MyPromise._Get_state_for_future());
+    }
+
+    void set_value() {
+        _MyPromise._Get_state_for_set()._Set_value(1, false);
+    }
+
+    void set_value_at_thread_exit() {
+        _MyPromise._Get_state_for_set()._Set_value(1, true);
+    }
+
+    void set_exception(exception_ptr _Exc) {
+        _MyPromise._Get_state_for_set()._Set_exception(_Exc, false);
+    }
+
+    void set_exception_at_thread_exit(exception_ptr _Exc) {
+        _MyPromise._Get_state_for_set()._Set_exception(_Exc, true);
+    }
+
+    promise(const promise&)            = delete;
+    promise& operator=(const promise&) = delete;
+
+private:
+    _Promise<int> _MyPromise;
+};
+
+_EXPORT_STD template <class _Ty>
+void swap(promise<_Ty>& _Left, promise<_Ty>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class>
+class packaged_task; // not defined
+
+template <class _Ret, class... _ArgTypes>
+class packaged_task<_Ret(_ArgTypes...)> {
+    // class that defines an asynchronous provider that returns the result of a call to a function object
+private:
+    using _Ptype              = _P_arg_type_t<_Ret>;
+    using _MyPromiseType      = _Promise<_Ptype>;
+    using _MyStateManagerType = _State_manager<_Ptype>;
+    using _MyStateType        = _Packaged_state<_Ret(_ArgTypes...)>;
+
+public:
+    packaged_task() = default;
+
+    template <class _Fty2, enable_if_t<!is_same_v<_Remove_cvref_t<_Fty2>, packaged_task>, int> = 0>
+    explicit packaged_task(_Fty2&& _Fnarg) : _MyPromise(new _MyStateType(_STD forward<_Fty2>(_Fnarg))) {
+        static_assert(_Is_invocable_r<_Ret, decay_t<_Fty2>&, _ArgTypes...>::value,
+            "The function object must be callable with _ArgTypes... and return _Ret (N5014 [futures.task.members]/4).");
+    }
+
+    packaged_task(packaged_task&&) noexcept = default;
+
+    packaged_task& operator=(packaged_task&&) noexcept = default;
+
+    template <class _Fty2, class _Alloc, enable_if_t<!is_same_v<_Remove_cvref_t<_Fty2>, packaged_task>, int> = 0>
+    explicit packaged_task(allocator_arg_t, const _Alloc& _Al, _Fty2&& _Fnarg)
+        : _MyPromise(_STD _Make_packaged_state<_MyStateType>(_STD forward<_Fty2>(_Fnarg), _Al)) {
+        static_assert(_Is_invocable_r<_Ret, decay_t<_Fty2>&, _ArgTypes...>::value,
+            "The function object must be callable with _ArgTypes... and return _Ret (N5014 [futures.task.members]/4).");
+    }
+
+    ~packaged_task() noexcept {
+        _MyPromise._Get_state()._Abandon();
+    }
+
+    void swap(packaged_task& _Other) noexcept {
+        _STD swap(_MyPromise, _Other._MyPromise);
+    }
+
+    _NODISCARD bool valid() const noexcept {
+        return _MyPromise._Is_valid();
+    }
+
+    _NODISCARD_GET_FUTURE future<_Ret> get_future() {
+        return future<_Ret>(_From_raw_state_tag{}, _MyPromise._Get_state_for_future());
+    }
+
+    void operator()(_ArgTypes... _Args) {
+        if (_MyPromise._Is_ready()) {
+            _Throw_future_error2(future_errc::promise_already_satisfied);
+        }
+
+        _MyStateManagerType& _State = _MyPromise._Get_state_for_set();
+        _MyStateType* _Ptr          = static_cast<_MyStateType*>(_State._Ptr());
+        _Ptr->_Call_immediate(_STD forward<_ArgTypes>(_Args)...);
+    }
+
+    void make_ready_at_thread_exit(_ArgTypes... _Args) {
+        if (_MyPromise._Is_ready()) {
+            _Throw_future_error2(future_errc::promise_already_satisfied);
+        }
+
+        _MyStateManagerType& _State = _MyPromise._Get_state_for_set();
+        if (_State._Ptr()->_Already_has_stored_result()) {
+            _Throw_future_error2(future_errc::promise_already_satisfied);
+        }
+
+        _MyStateType* _Ptr = static_cast<_MyStateType*>(_State._Ptr());
+        _Ptr->_Call_deferred(_STD forward<_ArgTypes>(_Args)...);
+    }
+
+    void reset() { // reset to newly constructed state
+        _MyStateManagerType& _State_mgr = _MyPromise._Get_state_for_set();
+        _MyStateType& _MyState          = *static_cast<_MyStateType*>(_State_mgr._Ptr());
+
+        const auto _New_state_ptr = [&_MyState]() -> _Associated_state<_P_arg_type_t<_Ret>>* {
+#ifdef _CPPRTTI // TRANSITION, ABI, should not rely on RTTI
+            using _Clonable_deleter_t = _Clonable_deleter_base<_P_arg_type_t<_Ret>>;
+            if (const auto _Clonable_deleter = dynamic_cast<_Clonable_deleter_t*>(_MyState._Get_deleter())) {
+                return _Clonable_deleter->_Move_clone(_STD move(_MyState));
+            } else {
+                return new _MyStateType(_STD move(_MyState)._Get_fn());
+            }
+#else // ^^^ defined(_CPPRTTI) / !defined(_CPPRTTI) vvv
+            return new _MyStateType(_STD move(_MyState)._Get_fn());
+#endif // ^^^ !defined(_CPPRTTI) ^^^
+        }();
+        _MyPromiseType _New_promise{_New_state_ptr};
+        _MyPromise._Get_state()._Abandon();
+        _MyPromise._Swap(_New_promise);
+    }
+
+    packaged_task(const packaged_task&)            = delete;
+    packaged_task& operator=(const packaged_task&) = delete;
+
+private:
+    _MyPromiseType _MyPromise{nullptr};
+};
+
+#if _HAS_CXX17
+#define _PACKAGED_TASK_DEDUCTION_GUIDE(CALL_OPT, X1, X2, X3) \
+    template <class _Ret, class... _Types>                   \
+    packaged_task(_Ret(CALL_OPT*)(_Types...)) -> packaged_task<_Ret(_Types...)>; // intentionally discards CALL_OPT
+
+_NON_MEMBER_CALL(_PACKAGED_TASK_DEDUCTION_GUIDE, X1, X2, X3)
+#undef _PACKAGED_TASK_DEDUCTION_GUIDE
+
+template <class _Fx>
+packaged_task(_Fx) -> packaged_task<typename _Deduce_signature<_Fx>::type>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty>
+void swap(packaged_task<_Ty>& _Left, packaged_task<_Ty>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+template <class... _Types, size_t... _Indices>
+decltype(auto) _Invoke_stored_explicit(
+    tuple<_Types...>&& _Tuple, index_sequence<_Indices...>) { // invoke() a tuple with explicit parameter ordering
+    return _STD invoke(_STD get<_Indices>(_STD move(_Tuple))...);
+}
+
+template <class... _Types>
+decltype(auto) _Invoke_stored(tuple<_Types...>&& _Tuple) { // invoke() a tuple
+    return _Invoke_stored_explicit(_STD move(_Tuple), index_sequence_for<_Types...>{});
+}
+
+template <class... _Types>
+class _Fake_no_copy_callable_adapter {
+    // async() is built on packaged_task internals which incorrectly use
+    // std::function, which requires that things be copyable. We can't fix this in an
+    // update, so this adapter turns copies into _STL_REPORT_ERROR(). When VSO-153581 is
+    // fixed, remove this adapter.
+private:
+    using _Storaget = tuple<decay_t<_Types>...>;
+
+public:
+    explicit _Fake_no_copy_callable_adapter(_Types&&... _Vals) : _Storage(_STD forward<_Types>(_Vals)...) {
+        // Initializes _Fake_no_copy_callable_adapter with a decayed callable object and arguments
+    }
+
+    [[noreturn]] _Fake_no_copy_callable_adapter(const _Fake_no_copy_callable_adapter& _Other)
+        : _Storage(_STD move(_Other._Storage)) {
+        _STL_REPORT_ERROR("this callable object should not be copied"); // shouldn't be called
+    }
+
+    _Fake_no_copy_callable_adapter(_Fake_no_copy_callable_adapter&& _Other)          = default;
+    _Fake_no_copy_callable_adapter& operator=(const _Fake_no_copy_callable_adapter&) = delete;
+    _Fake_no_copy_callable_adapter& operator=(_Fake_no_copy_callable_adapter&&)      = delete;
+
+    decltype(auto) operator()() {
+        return _Invoke_stored(_STD move(_Storage));
+    }
+
+private:
+    mutable _Storaget _Storage;
+};
+
+template <class _Ret, class _Fty>
+_Associated_state<_P_arg_type_t<_Ret>>* _Get_associated_state(launch _Psync, _Fty&& _Fnarg) {
+    // construct associated asynchronous state object for the launch type
+    switch (_Psync) { // select launch type
+    case launch::deferred:
+        return new _Deferred_async_state<_Ret>(_STD forward<_Fty>(_Fnarg));
+    case launch::async: // TRANSITION, ABI, should create a new thread here
+    default:
+        return new _Task_async_state<_Ret>(_STD forward<_Fty>(_Fnarg));
+    }
+}
+
+_EXPORT_STD template <class _Fty, class... _ArgTypes>
+_NODISCARD_ASYNC future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(
+    launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args) {
+    // manages a callable object launched with supplied policy
+    using _Ret   = _Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>;
+    using _Ptype = _P_arg_type_t<_Ret>;
+    _Promise<_Ptype> _Pr(
+        _Get_associated_state<_Ret>(_Policy, _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>(
+                                                 _STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...)));
+
+    return future<_Ret>(_From_raw_state_tag{}, _Pr._Get_state_for_future());
+}
+
+_EXPORT_STD template <class _Fty, class... _ArgTypes>
+_NODISCARD_ASYNC future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(
+    _Fty&& _Fnarg, _ArgTypes&&... _Args) {
+    // manages a callable object launched with default policy
+    return _STD async(launch::async | launch::deferred, _STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...);
+}
+
+#ifdef _RESUMABLE_FUNCTIONS_SUPPORTED
+// Experimental coroutine support for std::future. Subject to change/removal!
+namespace experimental {
+    template <class _Ty, class... _ArgTypes>
+    struct coroutine_traits<future<_Ty>, _ArgTypes...> {
+        // defines resumable traits for functions returning future<_Ty>
+        struct promise_type {
+            promise<_Ty> _MyPromise;
+
+            future<_Ty> get_return_object() {
+                return _MyPromise.get_future();
+            }
+
+            suspend_never initial_suspend() const noexcept {
+                return {};
+            }
+
+            suspend_never final_suspend() const noexcept {
+                return {};
+            }
+
+            template <class _Ut>
+            void return_value(_Ut&& _Value) {
+                _MyPromise.set_value(_STD forward<_Ut>(_Value));
+            }
+
+            void unhandled_exception() {
+                _MyPromise.set_exception(_STD current_exception());
+            }
+        };
+    };
+
+    template <class... _ArgTypes>
+    struct coroutine_traits<future<void>, _ArgTypes...> {
+        // defines resumable traits for functions returning future<void>
+        struct promise_type {
+            promise<void> _MyPromise;
+
+            future<void> get_return_object() {
+                return _MyPromise.get_future();
+            }
+
+            suspend_never initial_suspend() const noexcept {
+                return {};
+            }
+
+            suspend_never final_suspend() const noexcept {
+                return {};
+            }
+
+            void return_void() {
+                _MyPromise.set_value();
+            }
+
+            void unhandled_exception() {
+                _MyPromise.set_exception(_STD current_exception());
+            }
+        };
+    };
+
+    template <class _Ty>
+    struct _Future_awaiter {
+        future<_Ty>& _Fut;
+
+        bool await_ready() const {
+            return _Fut._Is_ready();
+        }
+
+        void await_suspend(experimental::coroutine_handle<> _ResumeCb) {
+            thread _WaitingThread([&_Fut = _Fut, _ResumeCb]() mutable {
+                _Fut.wait();
+                _ResumeCb();
+            });
+            _WaitingThread.detach();
+        }
+
+        decltype(auto) await_resume() {
+            return _Fut.get();
+        }
+    };
+
+} // namespace experimental
+
+// Coroutines TS and C++20 coroutine adapter.
+template <class _Ty>
+auto operator co_await(future<_Ty>&& _Fut) {
+    return experimental::_Future_awaiter<_Ty>{_Fut};
+}
+
+template <class _Ty>
+auto operator co_await(future<_Ty>& _Fut) {
+    return experimental::_Future_awaiter<_Ty>{_Fut};
+}
+#endif // _RESUMABLE_FUNCTIONS_SUPPORTED
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FUTURE_
diff --git a/msvc-stl/stl/inc/generator b/msvc-stl/stl/inc/generator
new file mode 100644
index 0000000..9e1df1e
--- /dev/null
+++ b/msvc-stl/stl/inc/generator
@@ -0,0 +1,622 @@
+// generator standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _GENERATOR_
+#define _GENERATOR_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <generator> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+
+#include <coroutine>
+#include <exception>
+#include <xmemory>
+
+#ifdef __cpp_lib_byte
+#include <xpolymorphic_allocator.h>
+#endif // defined(__cpp_lib_byte)
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#pragma push_macro("empty_bases")
+#undef msvc
+#undef no_specializations
+#undef empty_bases
+
+_STD_BEGIN
+
+struct alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__) _Aligned_block {
+    unsigned char _Pad[__STDCPP_DEFAULT_NEW_ALIGNMENT__];
+};
+
+template <class _Alloc>
+constexpr bool _Stateless_allocator = default_initializable<_Alloc> && allocator_traits<_Alloc>::is_always_equal::value;
+
+_EXPORT_STD template <class _Rty, class _Vty = void, class _Alloc = void>
+class _NO_SPECIALIZATIONS_CITING("N5014 [coro.generator.class]/4") generator;
+
+namespace _Gen_detail {
+    template <class _Alloc>
+    concept _Valid_allocator = same_as<_Alloc, void> || is_pointer_v<typename allocator_traits<_Alloc>::pointer>;
+
+    template <class _Alloc>
+    _NODISCARD _Alloc* _Get_allocator_address(void* const _Ptr, const size_t _Size) noexcept {
+        _STL_INTERNAL_STATIC_ASSERT(!_Stateless_allocator<_Alloc>);
+        const auto _Al_address =
+            (reinterpret_cast<uintptr_t>(_Ptr) + _Size + alignof(_Alloc) - 1) & ~(alignof(_Alloc) - 1);
+        return reinterpret_cast<_Alloc*>(_Al_address);
+    }
+
+    template <class _Proto_allocator>
+    class _Promise_allocator { // statically specified allocator type
+    private:
+        using _Alloc           = _Rebind_alloc_t<_Proto_allocator, _Aligned_block>;
+        using _Alloc_size_type = allocator_traits<_Alloc>::size_type;
+
+        _NODISCARD static size_t _Allocation_block_size(const size_t _Size) noexcept {
+            // Compute the number of _Aligned_blocks needed to store a coroutine
+            // frame of _Size bytes and, if necessary, an _Alloc.
+            if constexpr (_Stateless_allocator<_Alloc>) {
+                // allocator is stateless, we need not store it
+                return (_Size + sizeof(_Aligned_block) - 1) / sizeof(_Aligned_block);
+            } else {
+                // allocator is stateful, we need storage for it
+                constexpr size_t _Align = (_STD max) (alignof(_Alloc), sizeof(_Aligned_block));
+                return (_Size + sizeof(_Alloc) + _Align - 1) / sizeof(_Aligned_block);
+            }
+        }
+
+        _NODISCARD_RAW_PTR_ALLOC static void* _Allocate(_Alloc _Al, const size_t _Size) {
+            // memory layout:
+            // |--- coroutine frame --|- alignment padding -|---- _Alloc -----|
+            // |--- always present ---|----------- stateful only -------------|
+            // all rounded up to an integral number of _Aligned_blocks
+
+            const size_t _Size_in_blocks = _Allocation_block_size(_Size);
+            void* const _Ptr             = _Al.allocate(_Convert_size<_Alloc_size_type>(_Size_in_blocks));
+
+            if constexpr (!_Stateless_allocator<_Alloc>) {
+                // store only stateful allocators
+                const auto _Al_address = _Get_allocator_address<_Alloc>(_Ptr, _Size);
+                _STD construct_at(_Al_address, _STD move(_Al));
+            }
+
+            return _Ptr;
+        }
+
+        _NODISCARD static _Alloc _Get_allocator(
+            [[maybe_unused]] void* const _Ptr, [[maybe_unused]] const size_t _Size) noexcept {
+            // recreate or retrieve a copy of the allocator used to allocate _Ptr
+            if constexpr (_Stateless_allocator<_Alloc>) {
+                return _Alloc{};
+            } else {
+                const auto _Al_address = _Get_allocator_address<_Alloc>(_Ptr, _Size);
+                return *_Al_address;
+            }
+        }
+
+    public:
+        _NODISCARD_RAW_PTR_ALLOC static void* operator new(const size_t _Size)
+            requires default_initializable<_Alloc>
+        {
+            return _Allocate(_Alloc{}, _Size);
+        }
+
+        template <class _Alloc2, class... _Args>
+        _NODISCARD_RAW_PTR_ALLOC static void* operator new(
+            const size_t _Size, allocator_arg_t, const _Alloc2& _Al, const _Args&...) {
+            static_assert(convertible_to<const _Alloc2&, _Proto_allocator>,
+                "Allocator argument must be convertible to the allocator type (N5001 [coro.generator.promise]/18)");
+            return _Allocate(static_cast<_Alloc>(static_cast<_Proto_allocator>(_Al)), _Size);
+        }
+
+        template <class _This, class _Alloc2, class... _Args>
+        _NODISCARD_RAW_PTR_ALLOC static void* operator new(
+            const size_t _Size, const _This&, allocator_arg_t, const _Alloc2& _Al, const _Args&...) {
+            static_assert(convertible_to<const _Alloc2&, _Proto_allocator>,
+                "Allocator argument must be convertible to the allocator type (N5001 [coro.generator.promise]/18)");
+            return _Allocate(static_cast<_Alloc>(static_cast<_Proto_allocator>(_Al)), _Size);
+        }
+
+        static void operator delete(void* const _Ptr, const size_t _Size) noexcept {
+            _Alloc _Al                   = _Get_allocator(_Ptr, _Size);
+            const size_t _Size_in_blocks = _Allocation_block_size(_Size);
+            _Al.deallocate(static_cast<_Aligned_block*>(_Ptr), static_cast<_Alloc_size_type>(_Size_in_blocks));
+        }
+    };
+
+    template <>
+    class _Promise_allocator<void> { // type-erased allocator
+    private:
+        using _Dealloc_fn = void(__stdcall*)(void*, size_t) _NOEXCEPT_FNPTR;
+
+        template <class _Alloc>
+        _NODISCARD static size_t _Allocation_block_size(const size_t _Size) noexcept {
+            size_t _Bytes = _Size + sizeof(_Dealloc_fn);
+            if constexpr (_Stateless_allocator<_Alloc>) {
+                _Bytes += sizeof(_Aligned_block) - 1;
+            } else {
+                constexpr size_t _Align = (_STD max) (alignof(_Alloc), sizeof(_Aligned_block));
+                _Bytes += sizeof(_Alloc) + _Align - 1;
+            }
+            return _Bytes / sizeof(_Aligned_block);
+        }
+
+        template <class _Alloc>
+        static void __stdcall _Dealloc_stateless(void* const _Ptr, const size_t _Size) noexcept {
+            _STL_INTERNAL_STATIC_ASSERT(_Stateless_allocator<_Alloc>);
+            _Alloc _Al{};
+            const size_t _Size_in_blocks = _Allocation_block_size<_Alloc>(_Size);
+            const auto _Alloc_size       = static_cast<allocator_traits<_Alloc>::size_type>(_Size_in_blocks);
+            _Al.deallocate(static_cast<_Aligned_block*>(_Ptr), _Alloc_size);
+        }
+
+        template <class _Alloc>
+        static void __stdcall _Dealloc_stateful(void* const _Ptr, const size_t _Size) noexcept {
+            _STL_INTERNAL_STATIC_ASSERT(!_Stateless_allocator<_Alloc>);
+            const auto _Al_address = _Get_allocator_address<_Alloc>(_Ptr, _Size + sizeof(_Dealloc_fn));
+            auto& _Stored_al       = *_Al_address;
+            _Alloc _Al{_STD move(_Stored_al)};
+            _Stored_al.~_Alloc();
+
+            const size_t _Size_in_blocks = _Allocation_block_size<_Alloc>(_Size);
+            const auto _Alloc_size       = static_cast<allocator_traits<_Alloc>::size_type>(_Size_in_blocks);
+            _Al.deallocate(static_cast<_Aligned_block*>(_Ptr), _Alloc_size);
+        }
+
+        static void __stdcall _Dealloc_default(void* const _Ptr, const size_t _Size) noexcept {
+            ::operator delete(_Ptr, _Size + sizeof(_Dealloc_fn));
+        }
+
+        template <class _ProtoAlloc>
+        _NODISCARD_RAW_PTR_ALLOC static void* _Allocate(const _ProtoAlloc& _Proto, const size_t _Size) {
+            // memory layout:
+            // |--- coroutine frame (_Size bytes) ---|--- _Dealloc_fn ---|-- alignment padding --|--- _Alloc ---|
+            // |-------------------- always present -----(not aligned)---|------------ stateful only -----------|
+            // all rounded up to an integral number of _Aligned_blocks
+
+            using _Alloc           = _Rebind_alloc_t<_ProtoAlloc, _Aligned_block>;
+            using _Alloc_size_type = allocator_traits<_Alloc>::size_type;
+
+            _Alloc _Al{_Proto};
+            const size_t _Size_in_blocks = _Allocation_block_size<_Alloc>(_Size);
+            const auto _Alloc_size       = _Convert_size<_Alloc_size_type>(_Size_in_blocks);
+            void* const _Ptr             = _Al.allocate(_Alloc_size);
+
+            if constexpr (_Stateless_allocator<_Alloc>) {
+                // don't store stateless allocator
+                const _Dealloc_fn _Dealloc = _Dealloc_stateless<_Alloc>;
+                _CSTD memcpy(static_cast<char*>(_Ptr) + _Size, &_Dealloc, sizeof(_Dealloc_fn));
+                return _Ptr;
+            } else {
+                // store stateful allocator
+                const _Dealloc_fn _Dealloc = _Dealloc_stateful<_Alloc>;
+                _CSTD memcpy(static_cast<char*>(_Ptr) + _Size, &_Dealloc, sizeof(_Dealloc_fn));
+
+                const auto _Al_address = _Get_allocator_address<_Alloc>(_Ptr, _Size + sizeof(_Dealloc_fn));
+                _STD construct_at(_Al_address, _STD move(_Al));
+                return _Ptr;
+            }
+        }
+
+    public:
+        _NODISCARD_RAW_PTR_ALLOC static void* operator new(const size_t _Size) {
+            void* const _Ptr           = ::operator new(_Size + sizeof(_Dealloc_fn));
+            const _Dealloc_fn _Dealloc = _Dealloc_default;
+            _CSTD memcpy(static_cast<char*>(_Ptr) + _Size, &_Dealloc, sizeof(_Dealloc_fn));
+            return _Ptr;
+        }
+
+        template <class _Alloc, class... _Args>
+        _NODISCARD_RAW_PTR_ALLOC static void* operator new(
+            const size_t _Size, allocator_arg_t, const _Alloc& _Al, const _Args&...) {
+            static_assert(_Valid_allocator<_Alloc>, "generator allocators must use raw pointers "
+                                                    "(N4988 [coro.generator.class]/1.1)");
+            return _Allocate(_Al, _Size);
+        }
+
+        template <class _This, class _Alloc, class... _Args>
+        _NODISCARD_RAW_PTR_ALLOC static void* operator new(
+            const size_t _Size, const _This&, allocator_arg_t, const _Alloc& _Al, const _Args&...) {
+            static_assert(_Valid_allocator<_Alloc>, "generator allocators must use raw pointers "
+                                                    "(N4988 [coro.generator.class]/1.1)");
+            return _Allocate(_Al, _Size);
+        }
+
+        static void operator delete(void* const _Ptr, const size_t _Size) noexcept {
+            _Dealloc_fn _Dealloc;
+            _CSTD memcpy(&_Dealloc, static_cast<const char*>(_Ptr) + _Size, sizeof(_Dealloc_fn));
+            _Dealloc(_Ptr, _Size);
+        }
+    };
+
+    template <class _Rty, class _Vty>
+    using _Value_t = conditional_t<is_void_v<_Vty>, remove_cvref_t<_Rty>, _Vty>;
+    template <class _Rty, class _Vty>
+    using _Reference_t = conditional_t<is_void_v<_Vty>, _Rty&&, _Rty>;
+    template <class _Ref>
+    using _Yield_t = conditional_t<is_reference_v<_Ref>, _Ref, const _Ref&>;
+
+    template <class, class>
+    struct _Iter_provider {
+        class _Iterator;
+    };
+
+    template <class _Yielded>
+    class _Promise_base {
+    public:
+        _STL_INTERNAL_STATIC_ASSERT(is_reference_v<_Yielded>);
+
+#ifndef _PREFAST_ // TRANSITION, VSO-1662733
+        _NODISCARD
+#endif // ^^^ no workaround ^^^
+        suspend_always initial_suspend() const noexcept {
+            return {};
+        }
+
+        _NODISCARD auto final_suspend() noexcept {
+            return _Final_awaiter{};
+        }
+
+        _NODISCARD suspend_always yield_value(_Yielded _Val) noexcept {
+            _Ptr = _STD addressof(_Val);
+            return {};
+        }
+
+        _NODISCARD auto yield_value(const remove_reference_t<_Yielded>& _Val)
+            noexcept(is_nothrow_constructible_v<remove_cvref_t<_Yielded>,
+                const remove_reference_t<_Yielded>&>) /* strengthened */
+            requires is_rvalue_reference_v<_Yielded>
+                  && constructible_from<remove_cvref_t<_Yielded>, const remove_reference_t<_Yielded>&>
+        {
+            return _Element_awaiter{_Val};
+        }
+
+        template <class _Rty, class _Vty, class _Alloc, class _Unused>
+            requires same_as<_Yield_t<_Reference_t<_Rty, _Vty>>, _Yielded>
+        _NODISCARD auto yield_value(_RANGES elements_of<generator<_Rty, _Vty, _Alloc>&&, _Unused> _Elem) noexcept {
+            using _Nested_awaitable = _Nested_awaitable_provider<_Rty, _Vty, _Alloc>::_Awaitable;
+            return _Nested_awaitable{_STD move(_Elem.range)};
+        }
+
+        template <class _Rty, class _Vty, class _Alloc, class _Unused>
+            requires same_as<_Yield_t<_Reference_t<_Rty, _Vty>>, _Yielded>
+        _NODISCARD auto yield_value(_RANGES elements_of<generator<_Rty, _Vty, _Alloc>&, _Unused> _Elem) noexcept {
+            using _Nested_awaitable = _Nested_awaitable_provider<_Rty, _Vty, _Alloc>::_Awaitable;
+            return _Nested_awaitable{_STD move(_Elem.range)};
+        }
+
+        template <_RANGES input_range _Rng, class _Alloc>
+            requires convertible_to<_RANGES range_reference_t<_Rng>, _Yielded>
+        _NODISCARD auto yield_value(_RANGES elements_of<_Rng, _Alloc> _Elem) {
+            using _Nested_awaitable = _Nested_awaitable_provider<_Yielded, void, _Alloc>::_Awaitable;
+
+            auto _Lambda = [](allocator_arg_t, _Alloc, _RANGES iterator_t<_Rng> _It,
+                               const _RANGES sentinel_t<_Rng> _Se) static -> generator<_Yielded, void, _Alloc> {
+                for (; _It != _Se; ++_It) {
+                    co_yield static_cast<_Yielded>(*_It);
+                }
+            };
+            return _Nested_awaitable{
+                _Lambda(allocator_arg, _Elem.allocator, _RANGES begin(_Elem.range), _RANGES end(_Elem.range))};
+        }
+
+        void await_transform() = delete;
+
+        void return_void() const noexcept {}
+
+        void unhandled_exception() {
+            if (const auto _Info = _Try_get_nest_info()) {
+                _Info->_Except = _STD current_exception();
+            } else {
+                _RERAISE;
+            }
+        }
+
+    private:
+        struct _Element_awaiter {
+            remove_cvref_t<_Yielded> _Val;
+
+            explicit _Element_awaiter(const remove_reference_t<_Yielded>& _Val_)
+                noexcept(is_nothrow_constructible_v<remove_cvref_t<_Yielded>, const remove_reference_t<_Yielded>&>)
+                : _Val(_Val_) {}
+
+            _NODISCARD constexpr bool await_ready() const noexcept {
+                return false;
+            }
+
+            template <class _CoroPromise>
+            constexpr void await_suspend(coroutine_handle<_CoroPromise> _Handle) noexcept {
+#ifdef __cpp_lib_is_pointer_interconvertible // TRANSITION, LLVM-48860
+                _STL_INTERNAL_STATIC_ASSERT(is_pointer_interconvertible_base_of_v<_Promise_base, _CoroPromise>);
+#endif // ^^^ no workaround ^^^
+
+                _Promise_base& _Current = _Handle.promise();
+                _Current._Ptr           = _STD addressof(_Val);
+            }
+
+            constexpr void await_resume() const noexcept {}
+        };
+
+        // generator's stack of nested coroutines is realized as a linked list of promises. The "root" promise is the
+        // original that existed before any nested yields. The "top" promise is the one currently being iterated over.
+        // Iterators hold handles for the root's coroutine and the root promise holds a link to the top promise so
+        // iterators can resume it to generate the next element when incremented. Each promise keeps a link to the root
+        // so they can update the top link as promises are pushed and popped. It looks a bit like:
+        //
+        //    +--------------------------- Top ---------------------------+
+        //    v                                                           |
+        // +=====+             +=====+             +=====+             +=====+
+        // |     |-- Parent -->|     |-- Parent -->|     |-- Parent -->|     |
+        // +=====+             +=====+             +=====+             +=====+
+        //    |                   |                   |                   ^
+        //    +------- Root ------+------- Root ------+------- Root ------+
+        //
+        // The parent and root links are actually stored out-of-line in a _Nest_info. Since a promise is either a root
+        // or is nested, the single promise member _Data can be used to store either a top link or a pointer to a
+        // _Nest_info.
+
+        struct _Nest_info {
+            exception_ptr _Except;
+            coroutine_handle<_Promise_base> _Parent;
+            coroutine_handle<_Promise_base> _Root;
+        };
+
+        struct _Final_awaiter {
+            _NODISCARD bool await_ready() const noexcept {
+                return false;
+            }
+
+            template <class _CoroPromise>
+            _NODISCARD coroutine_handle<> await_suspend(coroutine_handle<_CoroPromise> _Handle) const noexcept {
+                // Resume _Handle's parent coroutine, if any.
+#ifdef __cpp_lib_is_pointer_interconvertible // TRANSITION, LLVM-48860
+                _STL_INTERNAL_STATIC_ASSERT(is_pointer_interconvertible_base_of_v<_Promise_base, _CoroPromise>);
+#endif // ^^^ no workaround ^^^
+
+                if (const auto _Info = _Handle.promise()._Try_get_nest_info()) {
+                    coroutine_handle<_Promise_base> _Cont = _Info->_Parent;
+                    _Info->_Root.promise()._Set_top(_Cont);
+                    return _Cont;
+                }
+
+                return _STD noop_coroutine();
+            }
+
+            void await_resume() const noexcept {}
+        };
+
+        template <class _Rty, class _Vty, class _Alloc>
+        struct _Nested_awaitable_provider {
+            struct _Awaitable {
+                _STL_INTERNAL_STATIC_ASSERT(same_as<_Yield_t<_Reference_t<_Rty, _Vty>>, _Yielded>);
+
+                _Nest_info _Nested;
+                generator<_Rty, _Vty, _Alloc> _Gen;
+
+                explicit _Awaitable(generator<_Rty, _Vty, _Alloc>&& _Gen_) noexcept : _Gen(_STD move(_Gen_)) {}
+
+                _NODISCARD bool await_ready() const noexcept {
+                    return !_Gen._Coro;
+                }
+
+                template <class _CoroPromise>
+                _NODISCARD coroutine_handle<_Promise_base> await_suspend(
+                    coroutine_handle<_CoroPromise> _Current) noexcept {
+                    // Push _Gen's coroutine onto the coroutine stack that _Current is at the top of.
+#ifdef __cpp_lib_is_pointer_interconvertible // TRANSITION, LLVM-48860
+                    _STL_INTERNAL_STATIC_ASSERT(is_pointer_interconvertible_base_of_v<_Promise_base, _CoroPromise>);
+#endif // ^^^ no workaround ^^^
+                    auto _Target    = coroutine_handle<_Promise_base>::from_address(_Gen._Coro.address());
+                    _Nested._Parent = coroutine_handle<_Promise_base>::from_address(_Current.address());
+                    if (const auto _Parent_nest_info = _Nested._Parent.promise()._Try_get_nest_info()) {
+                        _Nested._Root = _Parent_nest_info->_Root;
+                    } else {
+                        _Nested._Root = _Nested._Parent;
+                    }
+                    _Nested._Root.promise()._Set_top(_Target);
+                    _Target.promise()._Set_nest_info(_STD addressof(_Nested));
+                    return _Target;
+                }
+
+                void await_resume() {
+                    if (_Nested._Except) {
+                        _STD rethrow_exception(_STD move(_Nested._Except));
+                    }
+                }
+            };
+        };
+
+        _NODISCARD _Nest_info* _Try_get_nest_info() const noexcept {
+            if ((_Data & 1U) != 0) {
+                return reinterpret_cast<_Nest_info*>(_Data ^ 1U);
+            }
+
+            return nullptr;
+        }
+
+        _NODISCARD coroutine_handle<_Promise_base> _Get_top() const noexcept {
+            _STL_INTERNAL_CHECK((_Data & 1U) == 0);
+            return coroutine_handle<_Promise_base>::from_address(reinterpret_cast<void*>(_Data));
+        }
+
+        void _Set_nest_info(_Nest_info* _Info) noexcept {
+            _Data = reinterpret_cast<uintptr_t>(_Info) | 1U;
+        }
+
+        void _Set_top(coroutine_handle<_Promise_base> _Top) noexcept {
+            _Data = reinterpret_cast<uintptr_t>(_Top.address());
+        }
+
+        template <class, class>
+        friend struct _Iter_provider;
+
+        // Least significant bit of `_Data` indicates stored information:
+        // LSB 0: `_Data` is a top coroutine handle,
+        // LSB 1: `_Data ^ 1U` is a pointer to an object of type `_Nest_info`.
+        uintptr_t _Data = reinterpret_cast<uintptr_t>(coroutine_handle<_Promise_base>::from_promise(*this).address());
+        add_pointer_t<_Yielded> _Ptr = nullptr;
+    };
+
+    struct _Secret_tag {
+        explicit _Secret_tag() = default;
+    };
+
+    template <class _Value, class _Ref>
+    class _Iter_provider<_Value, _Ref>::_Iterator {
+    public:
+        using value_type      = _Value;
+        using difference_type = ptrdiff_t;
+
+        _Iterator(_Iterator&& _That) noexcept : _Coro{_STD exchange(_That._Coro, {})} {}
+
+        _Iterator& operator=(_Iterator&& _That) noexcept {
+            _Coro = _STD exchange(_That._Coro, {});
+            return *this;
+        }
+
+        _NODISCARD _Ref operator*() const
+            noexcept(noexcept(static_cast<_Ref>(*_Coro.promise()._Get_top().promise()._Ptr))) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(!_Coro.done(), "Can't dereference generator end iterator");
+#endif
+            return static_cast<_Ref>(*_Coro.promise()._Get_top().promise()._Ptr);
+        }
+
+        _Iterator& operator++() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(!_Coro.done(), "Can't increment generator end iterator");
+#endif
+            _Coro.promise()._Get_top().resume();
+            return *this;
+        }
+
+        void operator++(int) {
+            ++*this;
+        }
+
+        _NODISCARD friend bool operator==(const _Iterator& _It, default_sentinel_t) noexcept /* strengthened */ {
+            return _It._Coro.done();
+        }
+
+    private:
+        template <class, class, class>
+        friend class _STD generator;
+
+        explicit _Iterator(_Secret_tag, coroutine_handle<_Promise_base<_Yield_t<_Ref>>> _Coro_) noexcept
+            : _Coro{_Coro_} {}
+
+        coroutine_handle<_Promise_base<_Yield_t<_Ref>>> _Coro;
+    };
+} // namespace _Gen_detail
+
+_EXPORT_STD template <class _Rty, class _Vty, class _Alloc>
+class _NO_SPECIALIZATIONS_CITING("N5014 [coro.generator.class]/4") generator
+    : public _RANGES view_interface<generator<_Rty, _Vty, _Alloc>> {
+private:
+    static_assert(_Gen_detail::_Valid_allocator<_Alloc>,
+        "generator allocators must use raw pointers (N4988 [coro.generator.class]/1.1)");
+
+    using _Value = _Gen_detail::_Value_t<_Rty, _Vty>;
+    static_assert(same_as<remove_cvref_t<_Value>, _Value> && is_object_v<_Value>,
+        "generator's value type must be a cv-unqualified object type (N4988 [coro.generator.class]/1.2)");
+
+    using _Ref = _Gen_detail::_Reference_t<_Rty, _Vty>;
+    static_assert(
+        is_reference_v<_Ref> || (is_object_v<_Ref> && same_as<remove_cv_t<_Ref>, _Ref> && copy_constructible<_Ref>),
+        "generator's selected reference type must be an actual reference type or a cv-unqualified copy-constructible "
+        "object type (N4988 [coro.generator.class]/1.3)");
+
+    using _RRef = conditional_t<is_reference_v<_Ref>, remove_reference_t<_Ref>&&, _Ref>;
+
+    static_assert(common_reference_with<_Ref&&, _Value&> && common_reference_with<_Ref&&, _RRef&&>
+                      && common_reference_with<_RRef&&, const _Value&>,
+        "generator's iterator type must model indirectly_readable, but that's impossible with the selected value and "
+        "reference types (N4988 [coro.generator.class]/1.4)");
+
+public:
+    using yielded = _Gen_detail::_Yield_t<_Ref>;
+
+    friend _Gen_detail::_Promise_base<yielded>;
+
+    struct __declspec(empty_bases) promise_type : _Gen_detail::_Promise_allocator<_Alloc>,
+                                                  _Gen_detail::_Promise_base<yielded> {
+        _NODISCARD generator get_return_object() noexcept {
+            return generator{_Gen_detail::_Secret_tag{}, coroutine_handle<promise_type>::from_promise(*this)};
+        }
+    };
+    _STL_INTERNAL_STATIC_ASSERT(is_standard_layout_v<promise_type>);
+#ifdef __cpp_lib_is_pointer_interconvertible // TRANSITION, LLVM-48860
+    _STL_INTERNAL_STATIC_ASSERT(
+        is_pointer_interconvertible_base_of_v<_Gen_detail::_Promise_base<yielded>, promise_type>);
+#endif // ^^^ no workaround ^^^
+
+    generator(generator&& _That) noexcept : _Coro(_STD exchange(_That._Coro, {})) {}
+
+    ~generator() {
+        if (_Coro) {
+            _Coro.destroy();
+        }
+    }
+
+    generator& operator=(generator _That) noexcept {
+        _STD swap(_Coro, _That._Coro);
+        return *this;
+    }
+
+    _NODISCARD _Gen_detail::_Iter_provider<_Value, _Ref>::_Iterator begin() {
+        // Pre: _Coro is suspended at its initial suspend point
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Coro, "Can't call begin on moved-from generator");
+#endif
+        _Coro.resume();
+        return typename _Gen_detail::_Iter_provider<_Value, _Ref>::_Iterator{_Gen_detail::_Secret_tag{},
+            coroutine_handle<_Gen_detail::_Promise_base<yielded>>::from_address(_Coro.address())};
+    }
+
+    _NODISCARD default_sentinel_t end() const noexcept {
+        return default_sentinel;
+    }
+
+private:
+    coroutine_handle<promise_type> _Coro = nullptr;
+    // The stack of coroutine handles depicted in the Standard is realized by a linked structure of promises and
+    // awaitable objects, so all necessary storage is allocated in coroutine frames. See the description in the body of
+    // _Gen_detail::_Promise_base.
+
+    explicit generator(_Gen_detail::_Secret_tag, coroutine_handle<promise_type> _Coro_) noexcept : _Coro(_Coro_) {}
+};
+
+#ifdef __cpp_lib_byte
+namespace pmr {
+    _EXPORT_STD template <class _Rty, class _Vty = void>
+    using generator = _STD generator<_Rty, _Vty, polymorphic_allocator<>>;
+} // namespace pmr
+#endif // defined(__cpp_lib_byte)
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("empty_bases")
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // ^^^ _HAS_CXX23 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _GENERATOR_
diff --git a/msvc-stl/stl/inc/header-units.json b/msvc-stl/stl/inc/header-units.json
new file mode 100644
index 0000000..e94f92b
--- /dev/null
+++ b/msvc-stl/stl/inc/header-units.json
@@ -0,0 +1,178 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+{
+    "Version": "1.0",
+    "BuildAsHeaderUnits": [
+        // "__msvc_all_public_headers.hpp", // for testing, not production
+        "__msvc_bit_utils.hpp",
+        "__msvc_chrono.hpp",
+        "__msvc_cxx_stdatomic.hpp",
+        "__msvc_doom_core.hpp",
+        "__msvc_filebuf.hpp",
+        "__msvc_format_ucd_tables.hpp",
+        "__msvc_formatter.hpp",
+        "__msvc_heap_algorithms.hpp",
+        "__msvc_int128.hpp",
+        "__msvc_iter_core.hpp",
+        "__msvc_minmax.hpp",
+        "__msvc_ostream.hpp",
+        "__msvc_print.hpp",
+        "__msvc_ranges_to.hpp",
+        "__msvc_ranges_tuple_formatter.hpp",
+        "__msvc_sanitizer_annotate_container.hpp",
+        "__msvc_string_view.hpp",
+        "__msvc_system_error_abi.hpp",
+        "__msvc_threads_core.hpp",
+        "__msvc_tzdb.hpp",
+        "__msvc_xlocinfo_types.hpp",
+        "algorithm",
+        "any",
+        "array",
+        "atomic",
+        "barrier",
+        "bit",
+        "bitset",
+        // "cassert", // design is permanently incompatible with header units
+        // "ccomplex", // removed in C++20
+        "cctype",
+        "cerrno",
+        "cfenv",
+        "cfloat",
+        "charconv",
+        "chrono",
+        "cinttypes",
+        // "ciso646", // removed in C++20
+        "climits",
+        "clocale",
+        "cmath",
+        "codecvt",
+        "compare",
+        "complex",
+        "concepts",
+        "condition_variable",
+        "coroutine",
+        "csetjmp",
+        "csignal",
+        // "cstdalign", // removed in C++20
+        "cstdarg",
+        // "cstdbool", // removed in C++20
+        "cstddef",
+        "cstdint",
+        "cstdio",
+        "cstdlib",
+        "cstring",
+        // "ctgmath", // removed in C++20
+        "ctime",
+        "cuchar",
+        "cwchar",
+        "cwctype",
+        "deque",
+        "exception",
+        "execution",
+        "expected",
+        "filesystem",
+        "flat_map",
+        "flat_set",
+        "format",
+        "forward_list",
+        "fstream",
+        "functional",
+        "future",
+        "generator",
+        "initializer_list",
+        "iomanip",
+        "ios",
+        "iosfwd",
+        "iostream",
+        "iso646.h",
+        "istream",
+        "iterator",
+        "latch",
+        "limits",
+        "list",
+        "locale",
+        "map",
+        "mdspan",
+        "memory",
+        "memory_resource",
+        "mutex",
+        "new",
+        "numbers",
+        "numeric",
+        "optional",
+        "ostream",
+        "print",
+        "queue",
+        "random",
+        "ranges",
+        "ratio",
+        "regex",
+        "scoped_allocator",
+        "semaphore",
+        "set",
+        "shared_mutex",
+        "source_location",
+        "span",
+        "spanstream",
+        "sstream",
+        "stack",
+        "stacktrace",
+        "stdexcept",
+        "stdfloat",
+        "stop_token",
+        "streambuf",
+        "string",
+        "string_view",
+        "strstream",
+        "syncstream",
+        "system_error",
+        "thread",
+        "tuple",
+        "type_traits",
+        "typeindex",
+        "typeinfo",
+        "unordered_map",
+        "unordered_set",
+        // "use_ansi.h", // internal header, incompatible with being a separate header unit
+        "utility",
+        "valarray",
+        "variant",
+        "vector",
+        // "version", // importable, but provides feature-test macros only, which can control header inclusion
+        "xatomic.h",
+        "xatomic_wait.h",
+        "xbit_ops.h",
+        "xcall_once.h",
+        "xcharconv.h",
+        "xcharconv_ryu.h",
+        "xcharconv_ryu_tables.h",
+        "xcharconv_tables.h",
+        "xerrc.h",
+        "xfacet",
+        "xfilesystem_abi.h",
+        "xhash",
+        "xiosbase",
+        // "xkeycheck.h", // internal header, provides no machinery, scans for macroized keywords only
+        "xlocale",
+        "xlocbuf",
+        "xlocinfo",
+        "xlocmes",
+        "xlocmon",
+        "xlocnum",
+        "xloctime",
+        "xmemory",
+        "xnode_handle.h",
+        "xpolymorphic_allocator.h",
+        "xsmf_control.h",
+        "xstring",
+        "xthreads.h",
+        "xtimec.h",
+        "xtr1common",
+        "xtree",
+        "xutility",
+        "ymath.h"
+        // "yvals.h", // internal header, provides macros that control header inclusion
+        // "yvals_core.h" // internal header, provides macros that control header inclusion
+    ]
+}
diff --git a/msvc-stl/stl/inc/initializer_list b/msvc-stl/stl/inc/initializer_list
new file mode 100644
index 0000000..9a6279a
--- /dev/null
+++ b/msvc-stl/stl/inc/initializer_list
@@ -0,0 +1,78 @@
+// initializer_list standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _INITIALIZER_LIST_
+#define _INITIALIZER_LIST_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstddef>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+_EXPORT_STD template <class _Elem>
+class _NO_SPECIALIZATIONS_CITING("N5014 [initializer.list.syn]/2") initializer_list {
+public:
+    using value_type      = _Elem;
+    using reference       = const _Elem&;
+    using const_reference = const _Elem&;
+    using size_type       = size_t;
+
+    using iterator       = const _Elem*;
+    using const_iterator = const _Elem*;
+
+    constexpr initializer_list() noexcept : _First(nullptr), _Last(nullptr) {}
+
+    constexpr initializer_list(const _Elem* _First_arg, const _Elem* _Last_arg) noexcept
+        : _First(_First_arg), _Last(_Last_arg) {}
+
+    _NODISCARD constexpr const _Elem* begin() const noexcept {
+        return _First;
+    }
+
+    _NODISCARD constexpr const _Elem* end() const noexcept {
+        return _Last;
+    }
+
+    _NODISCARD constexpr size_t size() const noexcept {
+        return static_cast<size_t>(_Last - _First);
+    }
+
+    _NODISCARD constexpr bool empty() const noexcept {
+        return _First == _Last;
+    }
+
+    _NODISCARD constexpr const _Elem* data() const noexcept {
+        return _First;
+    }
+
+private:
+    const _Elem* _First;
+    const _Elem* _Last;
+};
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _INITIALIZER_LIST_
diff --git a/msvc-stl/stl/inc/iomanip b/msvc-stl/stl/inc/iomanip
new file mode 100644
index 0000000..025eb7a
--- /dev/null
+++ b/msvc-stl/stl/inc/iomanip
@@ -0,0 +1,409 @@
+// iomanip standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _IOMANIP_
+#define _IOMANIP_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <istream>
+#include <type_traits>
+#include <xlocmon>
+#include <xloctime>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Elem>
+struct _Fillobj { // store fill character
+    _Fillobj(_Elem _Ch) : _Fill(_Ch) {}
+
+    template <class _Elem2, class _Traits>
+    friend basic_ostream<_Elem2, _Traits>& operator<<(basic_ostream<_Elem2, _Traits>& _Ostr, const _Fillobj& _Manip) {
+        // set fill character in output stream
+        static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for setfill");
+
+        _Ostr.fill(_Manip._Fill);
+        return _Ostr;
+    }
+
+    _Elem _Fill; // the fill character
+};
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _Fillobj<_Elem> setfill(_Elem _Ch) {
+    return _Fillobj<_Elem>(_Ch);
+}
+
+template <class _Money>
+struct _Monobj { // store reference to monetary amount
+    _Monobj(_Money& _Val_arg, bool _Intl_arg) : _Val(_Val_arg), _Intl(_Intl_arg) {}
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, const _Monobj& _Manip) {
+        // get monetary amount from input stream
+        using _Myis   = basic_istream<_Elem, _Traits>;
+        using _Iter   = istreambuf_iterator<_Elem, _Traits>;
+        using _Mymget = money_get<_Elem, _Iter>;
+
+        ios_base::iostate _State = ios_base::goodbit;
+        const typename _Myis::sentry _Ok(_Istr);
+
+        if (_Ok) { // state okay, extract monetary amount
+            const _Mymget& _Mget_fac = _STD use_facet<_Mymget>(_Istr.getloc());
+            _TRY_IO_BEGIN
+            _Mget_fac.get(_Iter(_Istr.rdbuf()), _Iter(nullptr), _Manip._Intl, _Istr, _State, _Manip._Val);
+            _CATCH_IO_(ios_base, _Istr)
+        }
+
+        _Istr.setstate(_State);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Monobj& _Manip) {
+        // put monetary amount to output stream
+        using _Myos   = basic_ostream<_Elem, _Traits>;
+        using _Iter   = ostreambuf_iterator<_Elem, _Traits>;
+        using _Mymput = money_put<_Elem, _Iter>;
+
+        ios_base::iostate _State = ios_base::goodbit;
+        const typename _Myos::sentry _Ok(_Ostr);
+
+        if (_Ok) { // state okay, insert monetary amount
+            const _Mymput& _Mput_fac = _STD use_facet<_Mymput>(_Ostr.getloc());
+            _TRY_IO_BEGIN
+            if (_Mput_fac.put(_Iter(_Ostr.rdbuf()), _Manip._Intl, _Ostr, _Ostr.fill(), _Manip._Val).failed()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_(ios_base, _Ostr)
+        }
+
+        _Ostr.setstate(_State);
+        return _Ostr;
+    }
+
+    _Money& _Val; // the monetary amount reference
+    bool _Intl; // international flag
+};
+
+_EXPORT_STD template <class _Money>
+_NODISCARD _Monobj<_Money> get_money(_Money& _Val_arg, bool _Intl_arg = false) {
+    static_assert(is_same_v<_Money, long double> || _Is_specialization_v<_Money, basic_string>,
+        "_Money must be either long double or a basic_string specialization (N5032 [ext.manip]/2).");
+    return _Monobj<_Money>(_Val_arg, _Intl_arg);
+}
+
+_EXPORT_STD template <class _Money>
+_NODISCARD _Monobj<const _Money> put_money(const _Money& _Val_arg, bool _Intl_arg = false) {
+    static_assert(is_same_v<_Money, long double> || _Is_specialization_v<_Money, basic_string>,
+        "_Money must be either long double or a basic_string specialization (N5032 [ext.manip]/5).");
+    return _Monobj<const _Money>(_Val_arg, _Intl_arg);
+}
+
+template <class _Elem, class _Ptr>
+struct _Timeobj { // store reference to tm object and format
+    _Timeobj(_Ptr _Tptr_arg, const _Elem* _Fmt_arg) : _Tptr(_Tptr_arg), _Fmtfirst(_Fmt_arg) {
+        for (_Fmtlast = _Fmtfirst; *_Fmtlast != 0; ++_Fmtlast) { // find end of format string
+        }
+    }
+
+    template <class _Elem2, class _Traits>
+    friend basic_istream<_Elem2, _Traits>& operator>>(basic_istream<_Elem2, _Traits>& _Istr, const _Timeobj& _Manip) {
+        // get time information from input stream
+        static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for get_time");
+
+        using _Myis   = basic_istream<_Elem, _Traits>;
+        using _Iter   = istreambuf_iterator<_Elem, _Traits>;
+        using _Mytget = time_get<_Elem, _Iter>;
+
+        ios_base::iostate _State = ios_base::goodbit;
+        const typename _Myis::sentry _Ok(_Istr);
+
+        if (_Ok) { // state okay, extract time amounts
+            const _Mytget& _Tget_fac = _STD use_facet<_Mytget>(_Istr.getloc());
+            _TRY_IO_BEGIN
+            _Tget_fac.get(
+                _Iter(_Istr.rdbuf()), _Iter(nullptr), _Istr, _State, _Manip._Tptr, _Manip._Fmtfirst, _Manip._Fmtlast);
+            _CATCH_IO_(ios_base, _Istr)
+        }
+
+        _Istr.setstate(_State);
+        return _Istr;
+    }
+
+    template <class _Elem2, class _Traits>
+    friend basic_ostream<_Elem2, _Traits>& operator<<(basic_ostream<_Elem2, _Traits>& _Ostr, const _Timeobj& _Manip) {
+        // put time information to output stream
+        static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for put_time");
+
+        using _Myos   = basic_ostream<_Elem, _Traits>;
+        using _Iter   = ostreambuf_iterator<_Elem, _Traits>;
+        using _Mytput = time_put<_Elem, _Iter>;
+
+        const typename _Myos::sentry _Ok(_Ostr);
+
+        if (_Ok) { // state okay, insert monetary amount
+            const _Mytput& _Tput_fac = _STD use_facet<_Mytput>(_Ostr.getloc());
+            _TRY_IO_BEGIN
+            if (_Tput_fac
+                    .put(_Iter(_Ostr.rdbuf()), _Ostr, _Ostr.fill(), _Manip._Tptr, _Manip._Fmtfirst, _Manip._Fmtlast)
+                    .failed()) {
+                _Ostr.setstate(ios_base::badbit);
+            }
+            _CATCH_IO_(ios_base, _Ostr)
+        }
+
+        return _Ostr;
+    }
+
+    _Ptr _Tptr; // the tm struct pointer
+    const _Elem* _Fmtfirst; // format string start
+    const _Elem* _Fmtlast; // format string end
+};
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _Timeobj<_Elem, tm*> get_time(tm* _Tptr_arg, const _Elem* _Fmt_arg) {
+    return _Timeobj<_Elem, tm*>(_Tptr_arg, _Fmt_arg);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _Timeobj<_Elem, const tm*> put_time(const tm* _Tptr_arg, const _Elem* _Fmt_arg) {
+    return _Timeobj<_Elem, const tm*>(_Tptr_arg, _Fmt_arg);
+}
+
+template <class _Elem, class _Traits, class _Sizet>
+struct _Quote_out { // store pointer/length for string
+    _Quote_out(const _Elem* _Ptr_obj, _Sizet _Size_obj, _Elem _Delim_obj, _Elem _Escape_obj)
+        : _Ptr(_Ptr_obj), _Size(_Size_obj), _Delim(_Delim_obj), _Escape(_Escape_obj) {}
+
+    _Quote_out(const _Quote_out&) = default;
+
+    template <class _OsTraits, class _QuTraits = _Traits>
+    friend basic_ostream<_Elem, _OsTraits>& operator<<(
+        basic_ostream<_Elem, _OsTraits>& _Ostr, const _Quote_out& _Manip) {
+        // put quoted string to output stream
+        static_assert(
+            is_void_v<_QuTraits> || is_same_v<_QuTraits, _OsTraits>, "quoted() traits must match basic_ostream traits");
+
+        using _Myos = basic_ostream<_Elem, _OsTraits>;
+
+        const _Elem* const _Last = _Manip._Ptr + _Manip._Size;
+
+        _Sizet _Size = _Manip._Size + 2; // allow for delimiters
+        for (const _Elem* _Ptr = _Manip._Ptr; _Ptr != _Last; ++_Ptr) {
+            if (_OsTraits::eq(*_Ptr, _Manip._Delim) || _OsTraits::eq(*_Ptr, _Manip._Escape)) {
+                ++_Size; // count escapes
+            }
+        }
+
+        ios_base::iostate _State = ios_base::goodbit;
+
+        _Sizet _Pad;
+        if (_Ostr.width() <= 0 || static_cast<_Sizet>(_Ostr.width()) <= _Size) {
+            _Pad = 0;
+        } else {
+            _Pad = static_cast<_Sizet>(_Ostr.width()) - _Size;
+        }
+
+        const typename _Myos::sentry _Ok(_Ostr);
+
+        if (!_Ok) {
+            _State |= ios_base::badbit;
+        } else { // state okay, insert characters
+            _TRY_IO_BEGIN
+            if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
+                for (; 0 < _Pad; --_Pad) { // pad on left
+                    if (_OsTraits::eq_int_type(_OsTraits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                        _State |= ios_base::badbit; // insertion failed, quit
+                        break;
+                    }
+                }
+            }
+
+            if (_State == ios_base::goodbit
+                && _OsTraits::eq_int_type(_OsTraits::eof(),
+                    _Ostr.rdbuf()->sputc(_Manip._Delim))) { // put delimiter
+                _State |= ios_base::badbit;
+            }
+
+            for (const _Elem* _Ptr = _Manip._Ptr; _Ptr != _Last; ++_Ptr) { // put (possibly escaped) element
+                if ((_OsTraits::eq(*_Ptr, _Manip._Delim) || _OsTraits::eq(*_Ptr, _Manip._Escape))
+                    && _State == ios_base::goodbit
+                    && _OsTraits::eq_int_type(_OsTraits::eof(),
+                        _Ostr.rdbuf()->sputc(_Manip._Escape))) { // put escape
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+
+                if (_State == ios_base::goodbit
+                    && _OsTraits::eq_int_type(_OsTraits::eof(),
+                        _Ostr.rdbuf()->sputc(*_Ptr))) { // put element
+                    _State |= ios_base::badbit; // insertion failed, quit
+                    break;
+                }
+            }
+
+            if (_State == ios_base::goodbit
+                && _OsTraits::eq_int_type(_OsTraits::eof(),
+                    _Ostr.rdbuf()->sputc(_Manip._Delim))) { // put delimiter
+                _State |= ios_base::badbit;
+            }
+
+            if (_State == ios_base::goodbit) {
+                for (; 0 < _Pad; --_Pad) { // pad on right
+                    if (_OsTraits::eq_int_type(_OsTraits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
+                        _State |= ios_base::badbit; // insertion failed, quit
+                        break;
+                    }
+                }
+            }
+
+            _Ostr.width(0);
+            _CATCH_IO_(ios_base, _Ostr)
+        }
+
+        _Ostr.setstate(_State);
+        return _Ostr;
+    }
+
+    const _Elem* _Ptr; // pointer to string
+    _Sizet _Size; // length of string
+    _Elem _Delim; // delimiter element
+    _Elem _Escape; // escape element
+
+    _Quote_out& operator=(const _Quote_out&) = delete;
+};
+
+template <class _Elem, class _Traits, class _Alloc>
+struct _Quote_in { // store reference to string
+    using _Mystr = basic_string<_Elem, _Traits, _Alloc>;
+
+    _Quote_in(_Mystr& _Str_obj, _Elem _Delim_obj, _Elem _Escape_obj)
+        : _Str(_Str_obj), _Delim(_Delim_obj), _Escape(_Escape_obj) {}
+
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Quote_in& _Manip) {
+        // put quoted string to output stream
+        using _Out_type = _Quote_out<_Elem, _Traits, typename _Mystr::size_type>;
+
+        return _Ostr << _Out_type{_Manip._Str.c_str(), _Manip._Str.size(), _Manip._Delim, _Manip._Escape};
+    }
+
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, const _Quote_in& _Manip) {
+        // get quoted string from input stream
+        ios_base::iostate _State = ios_base::goodbit;
+        const typename basic_istream<_Elem, _Traits>::sentry _Ok(_Istr);
+
+        if (_Ok) { // state okay, extract characters
+            _TRY_IO_BEGIN
+            const auto _Buf   = _Istr.rdbuf();
+            auto& _Str        = _Manip._Str;
+            const auto _Delim = _Traits::to_int_type(_Manip._Delim);
+            auto _Meta        = _Buf->sgetc();
+
+            if (!_Traits::eq_int_type(_Meta, _Delim)) { // no leading delimiter
+                return _Istr >> _Str;
+            }
+
+            const auto _Escape = _Traits::to_int_type(_Manip._Escape);
+            _Str.clear();
+            for (;;) {
+                _Meta = _Buf->snextc();
+                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // no trailing delimiter; fail
+                    _State = ios_base::eofbit | ios_base::failbit;
+                    break;
+                } else if (_Traits::eq_int_type(_Meta, _Escape)) { // escape; read next character literally
+                    _Meta = _Buf->snextc();
+                    if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // bad escape; fail
+                        _State = ios_base::eofbit | ios_base::failbit;
+                        break;
+                    }
+                } else if (_Traits::eq_int_type(_Meta, _Delim)) { // found trailing delimiter
+                    if (_Traits::eq_int_type(_Traits::eof(), _Buf->sbumpc())) { // consume trailing delimiter
+                        _State = ios_base::eofbit;
+                    }
+
+                    break;
+                }
+
+                _Str.push_back(_Traits::to_char_type(_Meta));
+            }
+            _CATCH_IO_(ios_base, _Istr)
+        }
+
+        _Istr.setstate(_State);
+        return _Istr;
+    }
+
+    _Mystr& _Str; // reference to string
+    _Elem _Delim; // delimiter element
+    _Elem _Escape; // escape element
+};
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _Quote_out<_Elem, void, size_t> quoted(
+    const _Elem* _Ptr, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
+    const size_t _Size = char_traits<_Elem>::length(_Ptr);
+    return {_Ptr, _Size, _Delim, _Escape};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _Quote_out<_Elem, _Traits, typename basic_string<_Elem, _Traits, _Alloc>::size_type> quoted(
+    const basic_string<_Elem, _Traits, _Alloc>& _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
+    return {_Str.c_str(), _Str.size(), _Delim, _Escape};
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Elem, class _Traits>
+_NODISCARD _Quote_out<_Elem, _Traits, size_t> quoted(
+    const basic_string_view<_Elem, _Traits> _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
+    return {_Str.data(), _Str.size(), _Delim, _Escape};
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _Quote_in<_Elem, _Traits, _Alloc> quoted(
+    basic_string<_Elem, _Traits, _Alloc>& _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
+    return {_Str, _Delim, _Escape};
+}
+
+template <class _Arg>
+struct _Smanip { // store function pointer and argument value
+    _Smanip(void(__cdecl* _Left)(ios_base&, _Arg), _Arg _Val) : _Pfun(_Left), _Manarg(_Val) {}
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, const _Smanip& _Manip) {
+        // extract by calling function with input stream and argument
+        (*_Manip._Pfun)(_Istr, _Manip._Manarg);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Smanip& _Manip) {
+        // insert by calling function with output stream and argument
+        (*_Manip._Pfun)(_Ostr, _Manip._Manarg);
+        return _Ostr;
+    }
+
+    void(__cdecl* _Pfun)(ios_base&, _Arg); // the function pointer
+    _Arg _Manarg; // the argument value
+};
+
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl resetiosflags(ios_base::fmtflags);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl setiosflags(ios_base::fmtflags);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<int> __cdecl setbase(int);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<streamsize> __cdecl setprecision(streamsize);
+_EXPORT_STD extern "C++" _NODISCARD _MRTIMP2 _Smanip<streamsize> __cdecl setw(streamsize);
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _IOMANIP_
diff --git a/msvc-stl/stl/inc/ios b/msvc-stl/stl/inc/ios
new file mode 100644
index 0000000..4b7aca1
--- /dev/null
+++ b/msvc-stl/stl/inc/ios
@@ -0,0 +1,310 @@
+// ios standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _IOS_
+#define _IOS_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xlocnum>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
+class basic_ios : public ios_base { // base class for basic_istream/basic_ostream
+public:
+    using _Myos       = basic_ostream<_Elem, _Traits>;
+    using _Mysb       = basic_streambuf<_Elem, _Traits>;
+    using _Ctype      = ctype<_Elem>;
+    using char_type   = _Elem;
+    using traits_type = _Traits;
+    using int_type    = typename _Traits::int_type;
+    using pos_type    = typename _Traits::pos_type;
+    using off_type    = typename _Traits::off_type;
+
+    explicit __CLR_OR_THIS_CALL basic_ios(_Mysb* _Strbuf) {
+        init(_Strbuf);
+    }
+
+    __CLR_OR_THIS_CALL ~basic_ios() noexcept override {}
+
+    void __CLR_OR_THIS_CALL clear(iostate _State = goodbit, bool _Reraise = false) {
+        // set state, possibly reraise exception
+        ios_base::clear(_State | (_Mystrbuf ? ios_base::goodbit : ios_base::badbit), _Reraise);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL clear(io_state _State) { // set state to _State
+        clear(static_cast<iostate>(_State));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    void __CLR_OR_THIS_CALL setstate(iostate _State, bool _Reraise = false) {
+        // merge _State into state, possibly reraise exception
+        clear(rdstate() | _State, _Reraise);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL setstate(io_state _State) { // merge _State into state
+        setstate(static_cast<iostate>(_State));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    basic_ios& __CLR_OR_THIS_CALL copyfmt(const basic_ios& _Right) { // copy format parameters
+        _Tiestr = _Right.tie();
+        _Fillch = _Right.fill();
+        ios_base::copyfmt(_Right);
+        return *this;
+    }
+
+    _Myos* __CLR_OR_THIS_CALL tie() const noexcept /* strengthened */ {
+        return _Tiestr;
+    }
+
+    _Myos* __CLR_OR_THIS_CALL tie(_Myos* _Newtie) noexcept /* strengthened */ { // set tie pointer
+        _Myos* _Oldtie = _Tiestr;
+        _Tiestr        = _Newtie;
+        return _Oldtie;
+    }
+
+    _NODISCARD _Mysb* __CLR_OR_THIS_CALL rdbuf() const noexcept /* strengthened */ {
+        return _Mystrbuf;
+    }
+
+    _Mysb* __CLR_OR_THIS_CALL rdbuf(_Mysb* _Strbuf) { // set stream buffer pointer
+        _Mysb* _Oldstrbuf = _Mystrbuf;
+        _Mystrbuf         = _Strbuf;
+        clear();
+        return _Oldstrbuf;
+    }
+
+    locale __CLR_OR_THIS_CALL imbue(const locale& _Loc) { // set locale to argument
+        locale _Oldlocale = ios_base::imbue(_Loc);
+        const auto _Rdbuf = rdbuf();
+        if (_Rdbuf) {
+            _Rdbuf->pubimbue(_Loc);
+        }
+
+        return _Oldlocale;
+    }
+
+    _Elem __CLR_OR_THIS_CALL fill() const noexcept /* strengthened */ {
+        return _Fillch;
+    }
+
+    _Elem __CLR_OR_THIS_CALL fill(_Elem _Newfill) noexcept /* strengthened */ { // set fill character
+        _Elem _Oldfill = _Fillch;
+        _Fillch        = _Newfill;
+        return _Oldfill;
+    }
+
+    char __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // convert _Ch to byte using imbued locale
+        return _STD use_facet<_Ctype>(getloc()).narrow(_Ch, _Dflt);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // convert _Byte to character using imbued locale
+        return _STD use_facet<_Ctype>(getloc()).widen(_Byte);
+    }
+
+    void __CLR_OR_THIS_CALL move(basic_ios& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mystrbuf = nullptr;
+            _Tiestr   = nullptr;
+            this->swap(_Right);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL move(basic_ios&& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mystrbuf = nullptr;
+            _Tiestr   = nullptr;
+            this->swap(_Right);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL swap(basic_ios& _Right) noexcept { // swap all but rdbuf() with right
+        ios_base::swap(_Right);
+        _STD swap(_Fillch, _Right._Fillch);
+        _STD swap(_Tiestr, _Right._Tiestr);
+    }
+
+    void __CLR_OR_THIS_CALL set_rdbuf(_Mysb* _Strbuf) noexcept /* strengthened */ {
+        // set stream buffer pointer without changing state
+        _Mystrbuf = _Strbuf;
+    }
+
+protected:
+    void __CLR_OR_THIS_CALL init(_Mysb* _Strbuf = nullptr, bool _Isstd = false) {
+        // initialize with stream buffer pointer
+        _Init(); // initialize ios_base
+        _Mystrbuf = _Strbuf;
+        _Tiestr   = nullptr;
+        _Fillch   = widen(' ');
+
+        if (!_Mystrbuf) {
+            setstate(badbit);
+        }
+
+        if (_Isstd) {
+            _Addstd(this); // special handling for standard streams
+        }
+    }
+
+    __CLR_OR_THIS_CALL basic_ios() {}
+
+private:
+    _Mysb* _Mystrbuf{}; // pointer to stream buffer
+    _Myos* _Tiestr{}; // pointer to tied output stream
+    _Elem _Fillch{}; // the fill character
+
+public:
+    __CLR_OR_THIS_CALL basic_ios(const basic_ios&)            = delete;
+    basic_ios& __CLR_OR_THIS_CALL operator=(const basic_ios&) = delete;
+};
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT basic_ios<char, char_traits<char>>;
+template class _CRTIMP2_PURE_IMPORT basic_ios<wchar_t, char_traits<wchar_t>>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template class _CRTIMP2_PURE_IMPORT basic_ios<unsigned short, char_traits<unsigned short>>;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL boolalpha(ios_base& _Iosbase) { // set boolalpha
+    _Iosbase.setf(ios_base::boolalpha);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL dec(ios_base& _Iosbase) { // set basefield to dec
+    _Iosbase.setf(ios_base::dec, ios_base::basefield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL defaultfloat(ios_base& _Iosbase) { // clear floatfield
+    _Iosbase.unsetf(ios_base::floatfield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL fixed(ios_base& _Iosbase) { // set floatfield to fixed
+    _Iosbase.setf(ios_base::fixed, ios_base::floatfield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL hex(ios_base& _Iosbase) { // set basefield to hex
+    _Iosbase.setf(ios_base::hex, ios_base::basefield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL hexfloat(ios_base& _Iosbase) { // set floatfield to (scientific | fixed)
+    _Iosbase.setf(ios_base::scientific | ios_base::fixed, ios_base::floatfield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL internal(ios_base& _Iosbase) { // set adjustfield to internal
+    _Iosbase.setf(ios_base::internal, ios_base::adjustfield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL left(ios_base& _Iosbase) { // set adjustfield to left
+    _Iosbase.setf(ios_base::left, ios_base::adjustfield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noboolalpha(ios_base& _Iosbase) { // clear boolalpha
+    _Iosbase.unsetf(ios_base::boolalpha);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noshowbase(ios_base& _Iosbase) { // clear showbase
+    _Iosbase.unsetf(ios_base::showbase);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noshowpoint(ios_base& _Iosbase) { // clear showpoint
+    _Iosbase.unsetf(ios_base::showpoint);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noshowpos(ios_base& _Iosbase) { // clear showpos
+    _Iosbase.unsetf(ios_base::showpos);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL noskipws(ios_base& _Iosbase) { // clear skipws
+    _Iosbase.unsetf(ios_base::skipws);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL nounitbuf(ios_base& _Iosbase) { // clear unitbuf
+    _Iosbase.unsetf(ios_base::unitbuf);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL nouppercase(ios_base& _Iosbase) { // clear uppercase
+    _Iosbase.unsetf(ios_base::uppercase);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL oct(ios_base& _Iosbase) { // set oct in basefield
+    _Iosbase.setf(ios_base::oct, ios_base::basefield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL right(ios_base& _Iosbase) { // set right in adjustfield
+    _Iosbase.setf(ios_base::right, ios_base::adjustfield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL scientific(ios_base& _Iosbase) { // set scientific in floatfield
+    _Iosbase.setf(ios_base::scientific, ios_base::floatfield);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL showbase(ios_base& _Iosbase) { // set showbase
+    _Iosbase.setf(ios_base::showbase);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL showpoint(ios_base& _Iosbase) { // set showpoint
+    _Iosbase.setf(ios_base::showpoint);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL showpos(ios_base& _Iosbase) { // set showpos
+    _Iosbase.setf(ios_base::showpos);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL skipws(ios_base& _Iosbase) { // set skipws
+    _Iosbase.setf(ios_base::skipws);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL unitbuf(ios_base& _Iosbase) { // set unitbuf
+    _Iosbase.setf(ios_base::unitbuf);
+    return _Iosbase;
+}
+
+_EXPORT_STD inline ios_base& __CLRCALL_OR_CDECL uppercase(ios_base& _Iosbase) { // set uppercase
+    _Iosbase.setf(ios_base::uppercase);
+    return _Iosbase;
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _IOS_
diff --git a/msvc-stl/stl/inc/iosfwd b/msvc-stl/stl/inc/iosfwd
new file mode 100644
index 0000000..8e49430
--- /dev/null
+++ b/msvc-stl/stl/inc/iosfwd
@@ -0,0 +1,283 @@
+// iosfwd standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _IOSFWD_
+#define _IOSFWD_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdio>
+#include <cstring>
+#include <cwchar>
+#include <xtr1common>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+#if _HAS_EXCEPTIONS
+#define _TRY_IO_BEGIN _TRY_BEGIN // begin try block
+
+#define _CATCH_IO_END                                                          \
+    _CATCH_ALL /* catch block for _Myios */                                    \
+        _Myios::setstate(ios_base::badbit, true); /* set badbit and rethrow */ \
+    _CATCH_END
+
+#define _CATCH_IO_(xtype, x)                                             \
+    _CATCH_ALL /* catch block for basic_ios x */                         \
+        (x)                                                              \
+            .setstate(xtype::badbit, true); /* set badbit and rethrow */ \
+    _CATCH_END
+
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+#define _TRY_IO_BEGIN        { // begin try block
+#define _CATCH_IO_END        } // catch block for _Myios
+#define _CATCH_IO_(xtype, x) } // catch block for basic_ios x
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+
+// from <streambuf>
+_EXPORT_STD using streamoff  = long long;
+_EXPORT_STD using streamsize = long long;
+
+_EXPORT_STD template <class _Statetype>
+class fpos { // store arbitrary file position
+public:
+    /* implicit */ fpos(streamoff _Off = 0) : _Myoff(_Off), _Fpos(0), _Mystate() {}
+
+    fpos(_Statetype _State, fpos_t _Fileposition) : _Myoff(_Fileposition), _Fpos(0), _Mystate(_State) {}
+
+    _NODISCARD _Statetype state() const {
+        return _Mystate;
+    }
+
+    void state(_Statetype _State) {
+        _Mystate = _State;
+    }
+
+    operator streamoff() const noexcept /* strengthened */ {
+        // TRANSITION, ABI: We currently always set _Fpos to 0 but older .objs containing old
+        // basic_filebuf would set _Fpos.
+        return _Myoff + _Fpos;
+    }
+
+    _NODISCARD streamoff operator-(const fpos& _Right) const noexcept /* strengthened */ {
+        return static_cast<streamoff>(*this) - static_cast<streamoff>(_Right);
+    }
+
+    fpos& operator+=(streamoff _Off) noexcept /* strengthened */ { // add offset
+        _Myoff += _Off;
+        return *this;
+    }
+
+    fpos& operator-=(streamoff _Off) noexcept /* strengthened */ { // subtract offset
+        _Myoff -= _Off;
+        return *this;
+    }
+
+    _NODISCARD fpos operator+(streamoff _Off) const {
+        fpos _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD fpos operator-(streamoff _Off) const {
+        fpos _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const fpos& _Right) const noexcept /* strengthened */ {
+        return static_cast<streamoff>(*this) == static_cast<streamoff>(_Right);
+    }
+
+    template <class _Int, enable_if_t<is_integral_v<_Int>, int> = 0>
+    _NODISCARD friend bool operator==(const fpos& _Left, const _Int _Right) noexcept /* strengthened */ {
+        return static_cast<streamoff>(_Left) == _Right;
+    }
+
+#if !_HAS_CXX20
+    template <class _Int, enable_if_t<is_integral_v<_Int>, int> = 0>
+    _NODISCARD friend bool operator==(const _Int _Left, const fpos& _Right) noexcept /* strengthened */ {
+        return _Left == static_cast<streamoff>(_Right);
+    }
+
+    _NODISCARD bool operator!=(const fpos& _Right) const noexcept /* strengthened */ {
+        return static_cast<streamoff>(*this) != static_cast<streamoff>(_Right);
+    }
+
+    template <class _Int, enable_if_t<is_integral_v<_Int>, int> = 0>
+    _NODISCARD friend bool operator!=(const fpos& _Left, const _Int _Right) noexcept /* strengthened */ {
+        return static_cast<streamoff>(_Left) != _Right;
+    }
+
+    template <class _Int, enable_if_t<is_integral_v<_Int>, int> = 0>
+    _NODISCARD friend bool operator!=(const _Int _Left, const fpos& _Right) noexcept /* strengthened */ {
+        return _Left != static_cast<streamoff>(_Right);
+    }
+#endif // !_HAS_CXX20
+
+private:
+    streamoff _Myoff; // stream offset
+    fpos_t _Fpos; // TRANSITION, ABI. C file position, not currently used
+    _Statetype _Mystate; // current conversion state
+};
+
+_EXPORT_STD using streampos  = fpos<_Mbstatet>;
+_EXPORT_STD using wstreampos = streampos;
+#ifdef __cpp_lib_char8_t
+_EXPORT_STD using u8streampos = streampos;
+#endif // defined(__cpp_lib_char8_t)
+_EXPORT_STD using u16streampos = streampos;
+_EXPORT_STD using u32streampos = streampos;
+
+_EXPORT_STD extern "C++" class locale;
+_EXPORT_STD template <class _Facet>
+const _Facet& __CRTDECL use_facet(const locale&);
+
+_EXPORT_STD template <class _Elem>
+struct char_traits;
+template <>
+struct char_traits<char>;
+#ifdef __cpp_char8_t
+template <>
+struct char_traits<char8_t>;
+#endif // defined(__cpp_char8_t)
+template <>
+struct char_traits<char16_t>;
+template <>
+struct char_traits<char32_t>;
+template <>
+struct char_traits<wchar_t>;
+#ifdef _CRTBLD
+template <>
+struct char_traits<unsigned short>;
+#endif // defined(_CRTBLD)
+
+_EXPORT_STD template <class _Ty>
+class allocator;
+_EXPORT_STD extern "C++" class ios_base;
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_ios;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class istreambuf_iterator;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class ostreambuf_iterator;
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_streambuf;
+
+#pragma vtordisp(push, 2) // compiler bug workaround
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_istream;
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_ostream;
+#pragma vtordisp(pop) // compiler bug workaround
+
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_iostream;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+class basic_stringbuf;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+class basic_istringstream;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+class basic_ostringstream;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+class basic_stringstream;
+#if _HAS_CXX23
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_spanbuf;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_ispanstream;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_ospanstream;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_spanstream;
+#endif // _HAS_CXX23
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_filebuf;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_ifstream;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_ofstream;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+class basic_fstream;
+#if _HAS_CXX20
+template <class _Elem, class _Traits = char_traits<_Elem>>
+class _Basic_syncbuf_impl;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+class basic_syncbuf;
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+class basic_osyncstream;
+#endif // _HAS_CXX20
+
+#if defined(_DLL_CPPLIB)
+_EXPORT_STD extern "C++" template <class _Elem, class _InIt>
+class num_get;
+_EXPORT_STD extern "C++" template <class _Elem, class _OutIt>
+class num_put;
+_EXPORT_STD template <class _Elem>
+class collate;
+#endif // defined(_DLL_CPPLIB)
+
+_EXPORT_STD using ios           = basic_ios<char, char_traits<char>>;
+_EXPORT_STD using streambuf     = basic_streambuf<char, char_traits<char>>;
+_EXPORT_STD using istream       = basic_istream<char, char_traits<char>>;
+_EXPORT_STD using ostream       = basic_ostream<char, char_traits<char>>;
+_EXPORT_STD using iostream      = basic_iostream<char, char_traits<char>>;
+_EXPORT_STD using stringbuf     = basic_stringbuf<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using istringstream = basic_istringstream<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using ostringstream = basic_ostringstream<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using stringstream  = basic_stringstream<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using filebuf       = basic_filebuf<char, char_traits<char>>;
+_EXPORT_STD using ifstream      = basic_ifstream<char, char_traits<char>>;
+_EXPORT_STD using ofstream      = basic_ofstream<char, char_traits<char>>;
+_EXPORT_STD using fstream       = basic_fstream<char, char_traits<char>>;
+#if _HAS_CXX20
+_EXPORT_STD using syncbuf     = basic_syncbuf<char>;
+_EXPORT_STD using osyncstream = basic_osyncstream<char>;
+#endif // _HAS_CXX20
+#if _HAS_CXX23
+_EXPORT_STD using spanbuf     = basic_spanbuf<char>;
+_EXPORT_STD using ispanstream = basic_ispanstream<char>;
+_EXPORT_STD using ospanstream = basic_ospanstream<char>;
+_EXPORT_STD using spanstream  = basic_spanstream<char>;
+#endif // _HAS_CXX23
+
+_EXPORT_STD using wios           = basic_ios<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wstreambuf     = basic_streambuf<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wistream       = basic_istream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wostream       = basic_ostream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wiostream      = basic_iostream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wstringbuf     = basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using wistringstream = basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using wostringstream = basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using wstringstream  = basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+_EXPORT_STD using wfilebuf       = basic_filebuf<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wifstream      = basic_ifstream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wofstream      = basic_ofstream<wchar_t, char_traits<wchar_t>>;
+_EXPORT_STD using wfstream       = basic_fstream<wchar_t, char_traits<wchar_t>>;
+#if _HAS_CXX20
+_EXPORT_STD using wsyncbuf     = basic_syncbuf<wchar_t>;
+_EXPORT_STD using wosyncstream = basic_osyncstream<wchar_t>;
+#endif // _HAS_CXX20
+#if _HAS_CXX23
+_EXPORT_STD using wspanbuf     = basic_spanbuf<wchar_t>;
+_EXPORT_STD using wispanstream = basic_ispanstream<wchar_t>;
+_EXPORT_STD using wospanstream = basic_ospanstream<wchar_t>;
+_EXPORT_STD using wspanstream  = basic_spanstream<wchar_t>;
+#endif // _HAS_CXX23
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _IOSFWD_
diff --git a/msvc-stl/stl/inc/iostream b/msvc-stl/stl/inc/iostream
new file mode 100644
index 0000000..b433b3a
--- /dev/null
+++ b/msvc-stl/stl/inc/iostream
@@ -0,0 +1,75 @@
+// iostream standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _IOSTREAM_
+#define _IOSTREAM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <istream>
+#include <ostream>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+_STD_BEGIN
+#ifdef _M_CEE_PURE
+__PURE_APPDOMAIN_GLOBAL extern istream cin;
+__PURE_APPDOMAIN_GLOBAL extern ostream cout;
+__PURE_APPDOMAIN_GLOBAL extern ostream cerr;
+__PURE_APPDOMAIN_GLOBAL extern ostream clog;
+__PURE_APPDOMAIN_GLOBAL extern istream* _Ptr_cin;
+__PURE_APPDOMAIN_GLOBAL extern ostream* _Ptr_cout;
+__PURE_APPDOMAIN_GLOBAL extern ostream* _Ptr_cerr;
+__PURE_APPDOMAIN_GLOBAL extern ostream* _Ptr_clog;
+
+__PURE_APPDOMAIN_GLOBAL extern wistream wcin;
+__PURE_APPDOMAIN_GLOBAL extern wostream wcout;
+__PURE_APPDOMAIN_GLOBAL extern wostream wcerr;
+__PURE_APPDOMAIN_GLOBAL extern wostream wclog;
+__PURE_APPDOMAIN_GLOBAL extern wistream* _Ptr_wcin;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wcout;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wcerr;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wclog;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT istream cin;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream cout;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream cerr;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream clog;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT istream* _Ptr_cin;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream* _Ptr_cout;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream* _Ptr_cerr;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT ostream* _Ptr_clog;
+
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wistream wcin;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream wcout;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream wcerr;
+_EXPORT_STD extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream wclog;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wistream* _Ptr_wcin;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream* _Ptr_wcout;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream* _Ptr_wcerr;
+extern "C++" __PURE_APPDOMAIN_GLOBAL _CRTDATA2_IMPORT wostream* _Ptr_wclog;
+
+#ifdef _CRTBLD // TRANSITION, ABI: _Winit appears to be unused
+class _CRTIMP2_PURE_IMPORT _Winit {
+public:
+    __thiscall _Winit();
+    __thiscall ~_Winit() noexcept;
+
+private:
+    __PURE_APPDOMAIN_GLOBAL static int _Init_cnt;
+};
+#endif // defined(_CRTBLD)
+
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _IOSTREAM_
diff --git a/msvc-stl/stl/inc/iso646.h b/msvc-stl/stl/inc/iso646.h
new file mode 100644
index 0000000..707f8d4
--- /dev/null
+++ b/msvc-stl/stl/inc/iso646.h
@@ -0,0 +1,28 @@
+// iso646.h standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _ISO646
+#define _ISO646
+
+#if defined(RC_INVOKED) || defined(Q_MOC_RUN) || defined(__midl)
+// do nothing, see _STL_COMPILER_PREPROCESSOR in yvals_core.h
+#else // ^^^ non-compiler tools / C and C++ compilers vvv
+
+#if !defined(__cplusplus) || defined(_MSC_EXTENSIONS)
+#define and    &&
+#define and_eq &=
+#define bitand &
+#define bitor  |
+#define compl  ~
+#define not    !
+#define not_eq !=
+#define or     ||
+#define or_eq  |=
+#define xor    ^
+#define xor_eq ^=
+#endif // !defined(__cplusplus) || defined(_MSC_EXTENSIONS)
+
+#endif // ^^^ C and C++ compilers ^^^
+#endif // _ISO646
diff --git a/msvc-stl/stl/inc/istream b/msvc-stl/stl/inc/istream
new file mode 100644
index 0000000..49380d7
--- /dev/null
+++ b/msvc-stl/stl/inc/istream
@@ -0,0 +1,959 @@
+// istream standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _ISTREAM_
+#define _ISTREAM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_ostream.hpp>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Elem>
+struct _NODISCARD _Null_terminator_guard {
+    _Elem** _Str_ref;
+    ~_Null_terminator_guard() {
+        if (_Str_ref) {
+            **_Str_ref = _Elem(); // add terminating null character
+        }
+    }
+};
+
+#pragma vtordisp(push, 2) // compiler bug workaround
+
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
+class basic_istream : virtual public basic_ios<_Elem, _Traits> { // control extractions from a stream buffer
+public:
+    using _Myios = basic_ios<_Elem, _Traits>;
+    using _Mysb  = basic_streambuf<_Elem, _Traits>;
+    using _Iter  = istreambuf_iterator<_Elem, _Traits>;
+    using _Ctype = ctype<_Elem>;
+    using _Nget  = num_get<_Elem, _Iter>;
+
+#if defined(__FORCE_INSTANCE)
+    explicit __CLR_OR_THIS_CALL basic_istream(_Mysb* _Strbuf, bool _Isstd, bool _Skip_init) : _Chcount(0) {
+        if (!_Skip_init) {
+            _Myios::init(_Strbuf, _Isstd);
+        }
+    }
+#endif // defined(__FORCE_INSTANCE)
+
+    explicit __CLR_OR_THIS_CALL basic_istream(_Mysb* _Strbuf, bool _Isstd = false) : _Chcount(0) {
+        _Myios::init(_Strbuf, _Isstd);
+    }
+
+    __CLR_OR_THIS_CALL basic_istream(_Uninitialized) {
+        this->_Addstd(this);
+    }
+
+protected:
+    __CLR_OR_THIS_CALL basic_istream(basic_istream&& _Right) noexcept(false) : _Chcount(_Right._Chcount) {
+        _Myios::init();
+        _Myios::move(_STD move(_Right));
+        _Right._Chcount = 0;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator=(basic_istream&& _Right) noexcept /* strengthened */ {
+        this->swap(_Right);
+        return *this;
+    }
+
+    void __CLR_OR_THIS_CALL swap(basic_istream& _Right) noexcept /* strengthened */ {
+        _Myios::swap(_Right);
+        _STD swap(_Chcount, _Right._Chcount);
+    }
+
+public:
+    __CLR_OR_THIS_CALL basic_istream(const basic_istream&)            = delete;
+    basic_istream& __CLR_OR_THIS_CALL operator=(const basic_istream&) = delete;
+
+    __CLR_OR_THIS_CALL ~basic_istream() noexcept override {}
+
+    using int_type = typename _Traits::int_type;
+    using pos_type = typename _Traits::pos_type;
+    using off_type = typename _Traits::off_type;
+
+    class _Sentry_base {
+    public:
+        __CLR_OR_THIS_CALL _Sentry_base(basic_istream& _Istr) : _Myistr(_Istr) {
+            const auto _Rdbuf = _Myistr.rdbuf();
+            if (_Rdbuf) {
+                _Rdbuf->_Lock();
+            }
+        }
+
+        __CLR_OR_THIS_CALL ~_Sentry_base() noexcept {
+            const auto _Rdbuf = _Myistr.rdbuf();
+            if (_Rdbuf) {
+                _Rdbuf->_Unlock();
+            }
+        }
+
+        basic_istream& _Myistr;
+
+        _Sentry_base& operator=(const _Sentry_base&) = delete;
+    };
+
+    class sentry : public _Sentry_base {
+    public:
+        explicit __CLR_OR_THIS_CALL sentry(basic_istream& _Istr, bool _Noskip = false)
+            : _Sentry_base(_Istr), _Ok(_Sentry_base::_Myistr._Ipfx(_Noskip)) {}
+
+        explicit __CLR_OR_THIS_CALL operator bool() const {
+            return _Ok;
+        }
+
+        __CLR_OR_THIS_CALL sentry(const sentry&)            = delete;
+        sentry& __CLR_OR_THIS_CALL operator=(const sentry&) = delete;
+
+    private:
+        bool _Ok; // true if _Ipfx succeeded at construction
+    };
+
+    bool __CLR_OR_THIS_CALL _Ipfx(bool _Noskip = false) { // test stream state and skip whitespace as needed
+        if (!this->good()) {
+            _Myios::setstate(ios_base::failbit);
+            return false;
+        }
+
+        // state okay, flush tied stream and skip whitespace
+        const auto _Tied = _Myios::tie();
+        if (_Tied) {
+            _Tied->flush();
+        }
+
+        bool _Eof = false;
+        if (!_Noskip && this->flags() & ios_base::skipws) { // skip whitespace
+            const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(this->getloc());
+
+            _TRY_IO_BEGIN
+            int_type _Meta = _Myios::rdbuf()->sgetc();
+
+            for (;; _Meta = _Myios::rdbuf()->snextc()) {
+                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                    _Eof = true;
+                    break;
+                } else if (!_Ctype_fac.is(_Ctype::space, _Traits::to_char_type(_Meta))) {
+                    break; // not whitespace, quit
+                }
+            }
+            _CATCH_IO_END
+        }
+
+        if (_Eof) {
+            _Myios::setstate(ios_base::eofbit | ios_base::failbit);
+        }
+
+        return this->good();
+    }
+
+#ifdef _CRTBLD
+    // TRANSITION, ABI: non-Standard ipfx() is preserved for binary compatibility
+    bool __CLR_OR_THIS_CALL ipfx(bool _Noskip = false) {
+        // test stream state and skip whitespace as needed
+        return _Ipfx(_Noskip);
+    }
+
+    // TRANSITION, ABI: non-Standard isfx() is preserved for binary compatibility
+    void __CLR_OR_THIS_CALL isfx() {} // perform any wrapup
+#endif // ^^^ defined(_CRTBLD) ^^^
+
+#ifdef _M_CEE_PURE
+    basic_istream& __CLR_OR_THIS_CALL operator>>(basic_istream&(__clrcall* _Pfn)(basic_istream&) ) {
+        // call basic_istream manipulator
+        return _Pfn(*this);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(_Myios&(__clrcall* _Pfn)(_Myios&) ) { // call basic_ios manipulator
+        _Pfn(*this);
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(ios_base&(__clrcall* _Pfn)(ios_base&) ) { // call ios_base manipulator
+        _Pfn(*this);
+        return *this;
+    }
+#endif // defined(_M_CEE_PURE)
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(basic_istream&(__cdecl* _Pfn)(basic_istream&) ) {
+        // call basic_istream manipulator
+        return _Pfn(*this);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(_Myios&(__cdecl* _Pfn)(_Myios&) ) { // call basic_ios manipulator
+        _Pfn(*this);
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(ios_base&(__cdecl* _Pfn)(ios_base&) ) { // call ios_base manipulator
+        _Pfn(*this);
+        return *this;
+    }
+
+private:
+    template <class _Ty>
+    basic_istream& _Common_extract_with_num_get(_Ty& _Val) { // formatted extract with num_get
+        ios_base::iostate _Err = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to extract
+            _TRY_IO_BEGIN
+            _STD use_facet<_Nget>(this->getloc()).get(*this, {}, *this, _Err, _Val);
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_Err);
+        return *this;
+    }
+
+    template <class = void>
+    void _Increment_gcount() noexcept {
+        if (_Chcount != _STD _Max_limit<streamsize>()) {
+            ++_Chcount;
+        }
+    }
+
+public:
+    basic_istream& __CLR_OR_THIS_CALL operator>>(bool& _Val) { // extract a boolean
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(short& _Val) { // extract a short
+        ios_base::iostate _Err = ios_base::goodbit;
+        const sentry _Ok(*this);
+
+        if (_Ok) { // state okay, use facet to extract
+            _TRY_IO_BEGIN
+            long _Lval;
+            _STD use_facet<_Nget>(this->getloc()).get(*this, {}, *this, _Err, _Lval);
+            if (_Lval < SHRT_MIN) {
+                _Err |= ios_base::failbit;
+                _Val = SHRT_MIN;
+            } else if (_Lval > SHRT_MAX) {
+                _Err |= ios_base::failbit;
+                _Val = SHRT_MAX;
+            } else {
+                _Val = static_cast<short>(_Lval);
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_Err);
+        return *this;
+    }
+
+    // NOTE:
+    // If you are not using native wchar_t, the unsigned short extractor
+    // is masked by an explicit specialization that treats an unsigned
+    // short as a wide character.
+
+    // To read or write unsigned shorts as integers with wchar_t streams,
+    // make wchar_t a native type with the command line option /Zc:wchar_t.
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned short& _Val) { // extract an unsigned short
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(int& _Val) { // extract an int
+        static_assert(sizeof(int) == sizeof(long), "Bad overflow assumptions due to sizeof(int) != sizeof(long)");
+        long _Result = _Val;
+        _Common_extract_with_num_get(_Result);
+        _Val = _Result;
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned int& _Val) { // extract an unsigned int
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(long& _Val) { // extract a long
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned long& _Val) { // extract an unsigned long
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(long long& _Val) { // extract a long long
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned long long& _Val) { // extract an unsigned long long
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(float& _Val) { // extract a float
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(double& _Val) { // extract a double
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(long double& _Val) { // extract a long double
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(void*& _Val) { // extract a void pointer
+        return _Common_extract_with_num_get(_Val);
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL operator>>(_Mysb* _Strbuf) { // extract until end-of-file into a stream buffer
+        _Chcount = 0; // behaves as an unformatted input function
+        const sentry _Ok(*this, true);
+        ios_base::iostate _State = ios_base::goodbit;
+        if (_Ok && _Strbuf) { // state okay, extract characters
+            _TRY_IO_BEGIN
+            for (int_type _Meta = _Myios::rdbuf()->sgetc();; _Meta = _Myios::rdbuf()->snextc()) {
+                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                    _State |= ios_base::eofbit;
+                    break;
+                }
+                // got a character, insert it into buffer
+                _TRY_BEGIN
+                if (_Traits::eq_int_type(_Traits::eof(), _Strbuf->sputc(_Traits::to_char_type(_Meta)))) {
+                    break;
+                }
+
+                _CATCH_ALL
+                break;
+                _CATCH_END
+
+                _Increment_gcount();
+            }
+            _CATCH_IO_END
+        }
+
+        if (_Chcount == 0) { // If the function inserts no characters, it calls setstate(failbit)
+            _State |= ios_base::failbit;
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    int_type __CLR_OR_THIS_CALL get() { // extract a metacharacter
+        int_type _Meta           = 0;
+        ios_base::iostate _State = ios_base::goodbit;
+        _Chcount                 = 0;
+        const sentry _Ok(*this, true);
+
+        if (!_Ok) {
+            _Meta = _Traits::eof(); // state not okay, return EOF
+        } else { // state okay, extract a character
+            _TRY_IO_BEGIN
+            _Meta = _Myios::rdbuf()->sgetc();
+
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+                _State |= ios_base::eofbit | ios_base::failbit; // end of file
+            } else { // got a character, count it
+                _Myios::rdbuf()->sbumpc();
+                _Chcount = 1;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return _Meta;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL get(_Elem* _Str, streamsize _Count) { // get up to _Count characters into NTCS
+        return get(_Str, _Count, _Myios::widen('\n'));
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL get(_Elem* _Str, streamsize _Count, _Elem _Delim) {
+        // get up to _Count characters into NTCS, stop before _Delim
+        ios_base::iostate _State = ios_base::goodbit;
+        _Chcount                 = 0;
+
+        // ensure null termination of buffer with nonzero length
+        const _Null_terminator_guard<_Elem> _Guard{0 < _Count ? &_Str : nullptr};
+
+        const sentry _Ok(*this, true);
+
+        if (_Ok && 0 < _Count) { // state okay, extract characters
+            _TRY_IO_BEGIN
+            int_type _Meta = _Myios::rdbuf()->sgetc();
+
+            for (; 0 < --_Count; _Meta = _Myios::rdbuf()->snextc()) {
+                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                    _State |= ios_base::eofbit;
+                    break;
+                } else if (_Traits::to_char_type(_Meta) == _Delim) {
+                    break; // got a delimiter, quit
+                } else { // got a character, add it to string
+                    *_Str++ = _Traits::to_char_type(_Meta);
+                    _Increment_gcount();
+                }
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL get(_Elem& _Ch) { // get a character
+        int_type _Meta = get();
+        if (!_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            _Ch = _Traits::to_char_type(_Meta);
+        }
+
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL get(_Mysb& _Strbuf) { // extract up to newline and insert into stream buffer
+        return get(_Strbuf, _Myios::widen('\n'));
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL get(_Mysb& _Strbuf, _Elem _Delim) {
+        // extract up to delimiter and insert into stream buffer
+        ios_base::iostate _State = ios_base::goodbit;
+        _Chcount                 = 0;
+        const sentry _Ok(*this, true);
+
+        if (_Ok) { // state okay, use facet to extract
+            _TRY_IO_BEGIN
+            int_type _Meta = _Myios::rdbuf()->sgetc();
+
+            for (;; _Meta = _Myios::rdbuf()->snextc()) {
+                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                    _State |= ios_base::eofbit;
+                    break;
+                } else { // got a character, insert it into stream buffer
+                    _TRY_BEGIN
+                    _Elem _Ch = _Traits::to_char_type(_Meta);
+                    if (_Ch == _Delim || _Traits::eq_int_type(_Traits::eof(), _Strbuf.sputc(_Ch))) {
+                        break;
+                    }
+                    _CATCH_ALL
+                    break;
+                    _CATCH_END
+                    _Increment_gcount();
+                }
+            }
+            _CATCH_IO_END
+        }
+
+        if (_Chcount == 0) {
+            _State |= ios_base::failbit;
+        }
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL getline(_Elem* _Str, streamsize _Count) {
+        // get up to _Count characters into NTCS, discard newline
+        return getline(_Str, _Count, _Myios::widen('\n'));
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL getline(_Elem* _Str, streamsize _Count, _Elem _Delim) {
+        // get up to _Count characters into NTCS, discard _Delim
+        ios_base::iostate _State = ios_base::goodbit;
+        _Chcount                 = 0;
+
+        // ensure null termination of buffer with nonzero length
+        const _Null_terminator_guard<_Elem> _Guard{0 < _Count ? &_Str : nullptr};
+
+        const sentry _Ok(*this, true);
+
+        if (_Ok && 0 < _Count) { // state okay, use facet to extract
+            int_type _Metadelim = _Traits::to_int_type(_Delim);
+
+            _TRY_IO_BEGIN
+            int_type _Meta = _Myios::rdbuf()->sgetc();
+
+            for (;; _Meta = _Myios::rdbuf()->snextc()) {
+                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                    _State |= ios_base::eofbit;
+                    break;
+                } else if (_Meta == _Metadelim) { // got a delimiter, discard it and quit
+                    _Increment_gcount();
+                    _Myios::rdbuf()->sbumpc();
+                    break;
+                } else if (--_Count <= 0) { // buffer full, quit
+                    _State |= ios_base::failbit;
+                    break;
+                } else { // got a character, add it to string
+                    *_Str++ = _Traits::to_char_type(_Meta);
+                    _Increment_gcount();
+                }
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL ignore(streamsize _Count = 1, int_type _Metadelim = _Traits::eof()) {
+        // ignore up to _Count characters, discarding delimiter
+        ios_base::iostate _State = ios_base::goodbit;
+        _Chcount                 = 0;
+        const sentry _Ok(*this, true);
+
+        if (_Ok && 0 < _Count) { // state okay, use facet to extract
+            _TRY_IO_BEGIN
+            for (;;) { // get a metacharacter if more room in buffer
+                int_type _Meta;
+                if (_Count != _STD _Max_limit<streamsize>() && --_Count < 0) {
+                    break; // buffer full, quit
+                } else if (_Traits::eq_int_type(_Traits::eof(),
+                               _Meta = _Myios::rdbuf()->sbumpc())) { // end of file, quit
+                    _State |= ios_base::eofbit;
+                    break;
+                } else { // got a character, count it
+                    _Increment_gcount();
+                    if (_Meta == _Metadelim) {
+                        break; // got a delimiter, quit
+                    }
+                }
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    template <class _CharType = _Elem, enable_if_t<is_same_v<_CharType, char>, int> = 0>
+    basic_istream& ignore(const streamsize _Count, const _Elem _Delim) {
+        return ignore(_Count, _Traits::to_int_type(_Delim));
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL read(_Elem* _Str, streamsize _Count) { // read up to _Count characters into buffer
+        ios_base::iostate _State = ios_base::goodbit;
+        _Chcount                 = 0;
+        const sentry _Ok(*this, true);
+
+        if (_Ok && 0 < _Count) { // state okay, use facet to extract
+            _TRY_IO_BEGIN
+            const streamsize _Num = _Myios::rdbuf()->sgetn(_Str, _Count);
+            _Chcount              = _Num;
+
+            if (_Num != _Count) {
+                _State |= ios_base::eofbit | ios_base::failbit; // short read
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    streamsize __CLR_OR_THIS_CALL readsome(_Elem* _Str, streamsize _Count) {
+        // read up to _Count characters into buffer, without blocking
+        ios_base::iostate _State = ios_base::goodbit;
+        _Chcount                 = 0;
+        const sentry _Ok(*this, true);
+        streamsize _Num;
+
+        if (!_Ok) {
+            _State |= ios_base::failbit; // no buffer, fail
+        } else if ((_Num = _Myios::rdbuf()->in_avail()) < 0) {
+            _State |= ios_base::eofbit; // no characters available
+        } else if (0 < _Count && 0 < _Num) { // read available
+            read(_Str, _Num < _Count ? _Num : _Count);
+        }
+
+        _Myios::setstate(_State);
+        return gcount();
+    }
+
+    int_type __CLR_OR_THIS_CALL peek() {
+        ios_base::iostate _State = ios_base::goodbit;
+        _Chcount                 = 0;
+        int_type _Meta           = 0;
+        const sentry _Ok(*this, true);
+
+        if (!_Ok) {
+            _Meta = _Traits::eof(); // state not okay, return EOF
+        } else { // state okay, read a character
+            _TRY_IO_BEGIN
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Myios::rdbuf()->sgetc())) {
+                _State |= ios_base::eofbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return _Meta;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL putback(_Elem _Ch) { // put back a character
+        _Chcount                    = 0;
+        ios_base::iostate _State    = ios_base::goodbit;
+        ios_base::iostate _Oldstate = _Myios::rdstate();
+        _Myios::clear(_Oldstate & ~ios_base::eofbit);
+        const sentry _Ok(*this, true);
+
+        if (_Ok) { // state okay, put character back
+            _TRY_IO_BEGIN
+            if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sputbackc(_Ch))) {
+                _State |= ios_base::badbit | _Oldstate;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL unget() { // put back last read character
+        _Chcount                    = 0;
+        ios_base::iostate _State    = ios_base::goodbit;
+        ios_base::iostate _Oldstate = _Myios::rdstate();
+        _Myios::clear(_Oldstate & ~ios_base::eofbit);
+        const sentry _Ok(*this, true);
+
+        if (_Ok) { // state okay, put character back
+            _TRY_IO_BEGIN
+            if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sungetc())) {
+                _State |= ios_base::badbit | _Oldstate;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    _NODISCARD streamsize __CLR_OR_THIS_CALL gcount() const noexcept /* strengthened */ {
+        // get count from last extraction
+        return _Chcount;
+    }
+
+    int __CLR_OR_THIS_CALL sync() { // synchronize with input source
+        const sentry _Ok(*this, true);
+
+        const auto _Rdbuf = _Myios::rdbuf();
+        if (!_Rdbuf) {
+            return -1;
+        }
+
+        ios_base::iostate _State = ios_base::goodbit;
+        _TRY_BEGIN
+        if (_Rdbuf->pubsync() == -1) {
+            _State |= ios_base::badbit;
+        }
+        _CATCH_ALL
+        _Myios::setstate(ios_base::badbit, true);
+        return -1;
+        _CATCH_END
+
+        if (_State & ios_base::badbit) {
+            _Myios::setstate(ios_base::badbit);
+            return -1;
+        }
+
+        return 0;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL seekg(pos_type _Pos) { // set input stream position to _Pos
+        ios_base::iostate _State    = ios_base::goodbit;
+        ios_base::iostate _Oldstate = _Myios::rdstate();
+        _Myios::clear(_Oldstate & ~ios_base::eofbit);
+        const sentry _Ok(*this, true);
+
+        if (!this->fail()) {
+            _TRY_IO_BEGIN
+            if (static_cast<off_type>(_Myios::rdbuf()->pubseekpos(_Pos, ios_base::in)) == -1) {
+                _State |= ios_base::failbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    basic_istream& __CLR_OR_THIS_CALL seekg(off_type _Off, ios_base::seekdir _Way) {
+        // change input stream position by _Off, according to _Way
+        ios_base::iostate _State    = ios_base::goodbit;
+        ios_base::iostate _Oldstate = _Myios::rdstate();
+        _Myios::clear(_Oldstate & ~ios_base::eofbit);
+        const sentry _Ok(*this, true);
+
+        if (!this->fail()) {
+            _TRY_IO_BEGIN
+            if (static_cast<off_type>(_Myios::rdbuf()->pubseekoff(_Off, _Way, ios_base::in)) == -1) {
+                _State |= ios_base::failbit;
+            }
+            _CATCH_IO_END
+        }
+
+        _Myios::setstate(_State);
+        return *this;
+    }
+
+    pos_type __CLR_OR_THIS_CALL tellg() {
+        const sentry _Ok(*this, true);
+
+        if (!this->fail()) {
+            _TRY_IO_BEGIN
+            return _Myios::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
+            _CATCH_IO_END
+        }
+
+        return pos_type{off_type{-1}};
+    }
+
+private:
+    streamsize _Chcount{}; // the character count
+};
+
+#pragma vtordisp(pop) // compiler bug workaround
+
+#ifndef _NATIVE_WCHAR_T_DEFINED
+template <class _Elem, class _Traits>
+basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch);
+
+// NOTE:
+// If you are not using native wchar_t, the following explicit
+// specialization will mask the member function (above) that treats
+// an unsigned short as an integer.
+
+// To read or write unsigned shorts as integers with wchar_t streams,
+// make wchar_t a native type with the command line option /Zc:wchar_t.
+
+template <>
+inline basic_istream<unsigned short, char_traits<unsigned short>>& __CLR_OR_THIS_CALL basic_istream<unsigned short,
+    char_traits<unsigned short>>::operator>>(unsigned short& _Ch) { // extract a character
+    return _STD operator>>(*this, _Ch);
+}
+#endif // !defined(_NATIVE_WCHAR_T_DEFINED)
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT basic_istream<char, char_traits<char>>;
+template class _CRTIMP2_PURE_IMPORT basic_istream<wchar_t, char_traits<wchar_t>>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template class _CRTIMP2_PURE_IMPORT basic_istream<unsigned short, char_traits<unsigned short>>;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
+class basic_iostream : public basic_istream<_Elem, _Traits>,
+                       public basic_ostream<_Elem, _Traits> { // control insertions and extractions from a stream buffer
+public:
+    using _Myis       = basic_istream<_Elem, _Traits>;
+    using _Myos       = basic_ostream<_Elem, _Traits>;
+    using _Myios      = basic_ios<_Elem, _Traits>;
+    using char_type   = _Elem;
+    using traits_type = _Traits;
+    using int_type    = typename _Traits::int_type;
+    using pos_type    = typename _Traits::pos_type;
+    using off_type    = typename _Traits::off_type;
+
+    explicit __CLR_OR_THIS_CALL basic_iostream(basic_streambuf<_Elem, _Traits>* _Strbuf)
+        : _Myis(_Strbuf, false), _Myos(_Noinit, false) {}
+
+protected:
+    __CLR_OR_THIS_CALL basic_iostream(basic_iostream&& _Right) noexcept(false)
+        : _Myis(_Right.rdbuf(), false), _Myos(_Noinit, false) {
+        _Myios::init();
+        _Myios::move(_STD move(_Right));
+    }
+
+    basic_iostream& __CLR_OR_THIS_CALL operator=(basic_iostream&& _Right) noexcept /* strengthened */ {
+        this->swap(_Right);
+        return *this;
+    }
+
+    void __CLR_OR_THIS_CALL swap(basic_iostream& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Myios::swap(_Right);
+        }
+    }
+
+public:
+    __CLR_OR_THIS_CALL basic_iostream(const basic_iostream&)            = delete;
+    basic_iostream& __CLR_OR_THIS_CALL operator=(const basic_iostream&) = delete;
+
+    __CLR_OR_THIS_CALL ~basic_iostream() noexcept override {}
+};
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT basic_iostream<char, char_traits<char>>;
+template class _CRTIMP2_PURE_IMPORT basic_iostream<wchar_t, char_traits<wchar_t>>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template class _CRTIMP2_PURE_IMPORT basic_iostream<unsigned short, char_traits<unsigned short>>;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+template <class _Elem, class _Traits>
+basic_istream<_Elem, _Traits>& _Istream_extract_into_buffer(
+    basic_istream<_Elem, _Traits>& _Istr, size_t _Size, _Elem* _Str) {
+    using _Myis              = basic_istream<_Elem, _Traits>;
+    using _Ctype             = ctype<_Elem>;
+    ios_base::iostate _State = ios_base::goodbit;
+    size_t _Current          = 0;
+    const typename _Myis::sentry _Ok(_Istr);
+
+    if (_Ok) { // state okay, extract characters
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Istr.getloc());
+
+        _TRY_IO_BEGIN
+        size_t _Count       = _Size;
+        const size_t _Width = static_cast<size_t>(_Istr.width());
+        if (_Width > 0 && _Width < _Size) {
+            _Count = _Width;
+        }
+
+        typename _Myis::int_type _Meta = _Istr.rdbuf()->sgetc();
+        _Elem _Ch;
+
+        for (; _Current < _Count - 1; _Meta = _Istr.rdbuf()->snextc(), (void) ++_Current) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                _State |= ios_base::eofbit;
+                break;
+            } else if (_Ctype_fac.is(_Ctype::space, _Ch = _Traits::to_char_type(_Meta)) || _Ch == _Elem()) {
+                break; // whitespace or nul, quit
+            } else {
+                _Str[_Current] = _Traits::to_char_type(_Meta); // add it to string
+            }
+        }
+        _CATCH_IO_(ios_base, _Istr)
+    }
+    _Analysis_assume_(static_cast<size_t>(_Current) < _Size); // TRANSITION, VSO-860375
+    _Str[_Current] = _Elem(); // add terminating null character
+    _Istr.width(0);
+    if (_Current == 0) {
+        _State |= ios_base::failbit;
+    }
+    _Istr.setstate(_State);
+    return _Istr;
+}
+
+#if _HAS_CXX20 // P0487R1 Fixing operator>>(basic_istream&, CharT*)
+#pragma warning(push)
+#pragma warning(disable : 6001) // Using uninitialized memory '_Str'.
+_EXPORT_STD template <class _Elem, class _Traits, size_t _Size>
+basic_istream<_Elem, _Traits>& operator>>(
+    basic_istream<_Elem, _Traits>& _Istr, _Out_writes_z_(_Size) _Elem (&_Str)[_Size]) {
+    return _Istream_extract_into_buffer(_Istr, _Size, _Str);
+}
+
+_EXPORT_STD template <class _Traits, size_t _Size>
+basic_istream<char, _Traits>& operator>>(
+    basic_istream<char, _Traits>& _Istr, _Out_writes_z_(_Size) signed char (&_Str)[_Size]) {
+    return _Istream_extract_into_buffer(_Istr, _Size, reinterpret_cast<char*>(_Str));
+}
+
+_EXPORT_STD template <class _Traits, size_t _Size>
+basic_istream<char, _Traits>& operator>>(
+    basic_istream<char, _Traits>& _Istr, _Out_writes_z_(_Size) unsigned char (&_Str)[_Size]) {
+    return _Istream_extract_into_buffer(_Istr, _Size, reinterpret_cast<char*>(_Str));
+}
+#pragma warning(pop)
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Elem, class _Traits>
+basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, _Elem* _Str) {
+    return _Istream_extract_into_buffer(_Istr, SIZE_MAX, _Str);
+}
+
+template <class _Traits>
+basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, signed char* _Str) {
+    return _Istream_extract_into_buffer(_Istr, SIZE_MAX, reinterpret_cast<char*>(_Str));
+}
+
+template <class _Traits>
+basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, unsigned char* _Str) {
+    return _Istream_extract_into_buffer(_Istr, SIZE_MAX, reinterpret_cast<char*>(_Str));
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch) { // extract a character
+    using _Myis = basic_istream<_Elem, _Traits>;
+
+    typename _Myis::int_type _Meta;
+    ios_base::iostate _State = ios_base::goodbit;
+    const typename _Myis::sentry _Ok(_Istr);
+
+    if (_Ok) { // state okay, extract characters
+        _TRY_IO_BEGIN
+        _Meta = _Istr.rdbuf()->sbumpc();
+        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            _State |= ios_base::eofbit | ios_base::failbit; // end of file
+        } else {
+            _Ch = _Traits::to_char_type(_Meta); // got a character
+        }
+        _CATCH_IO_(ios_base, _Istr)
+    }
+
+    _Istr.setstate(_State);
+    return _Istr;
+}
+
+_EXPORT_STD template <class _Traits>
+basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, signed char& _Ch) {
+    // extract a signed char
+    return _Istr >> reinterpret_cast<char&>(_Ch);
+}
+
+_EXPORT_STD template <class _Traits>
+basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, unsigned char& _Ch) {
+    // extract an unsigned char
+    return _Istr >> reinterpret_cast<char&>(_Ch);
+}
+
+template <class _Istr, class _Ty, class = void>
+struct _Can_stream_in : false_type {};
+
+template <class _Istr, class _Ty>
+struct _Can_stream_in<_Istr, _Ty, void_t<decltype(_STD declval<_Istr&>() >> _STD declval<_Ty>())>> : true_type {};
+
+_EXPORT_STD template <class _Istr, class _Ty,
+    enable_if_t<conjunction_v<is_convertible<_Istr*, ios_base*>, _Can_stream_in<_Istr, _Ty>>, int> = 0>
+_Istr&& operator>>(_Istr&& _Is, _Ty&& _Val) { // extract from rvalue stream
+    _Is >> _STD forward<_Ty>(_Val);
+    return _STD move(_Is);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_istream<_Elem, _Traits>& __CLRCALL_OR_CDECL ws(basic_istream<_Elem, _Traits>& _Istr) { // consume whitespace
+    const typename basic_istream<_Elem, _Traits>::sentry _Ok(_Istr, true);
+
+    if (_Ok) { // state okay, extract characters
+        ios_base::iostate _State = ios_base::goodbit;
+        const auto& _Ctype_fac   = _STD use_facet<ctype<_Elem>>(_Istr.getloc());
+
+        _TRY_IO_BEGIN
+        for (typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();; _Meta = _Istr.rdbuf()->snextc()) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                _State |= ios_base::eofbit;
+                break;
+            } else if (!_Ctype_fac.is(ctype<_Elem>::space, _Traits::to_char_type(_Meta))) {
+                break; // not whitespace, quit
+            }
+        }
+        _CATCH_IO_(ios_base, _Istr)
+        _Istr.setstate(_State);
+    }
+
+    return _Istr;
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _ISTREAM_
diff --git a/msvc-stl/stl/inc/iterator b/msvc-stl/stl/inc/iterator
new file mode 100644
index 0000000..cce1ee9
--- /dev/null
+++ b/msvc-stl/stl/inc/iterator
@@ -0,0 +1,1493 @@
+// iterator standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _ITERATOR_
+#define _ITERATOR_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <iosfwd>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD template <class _Container>
+class back_insert_iterator { // wrap pushes to back of container as output iterator
+public:
+    using iterator_category = output_iterator_tag;
+    using value_type        = void;
+    using pointer           = void;
+    using reference         = void;
+
+    using container_type = _Container;
+
+#if _HAS_CXX20
+    using difference_type = ptrdiff_t;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using difference_type = void;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR20 explicit back_insert_iterator(_Container& _Cont) noexcept /* strengthened */
+        : container(_STD addressof(_Cont)) {}
+
+    _CONSTEXPR20 back_insert_iterator& operator=(const typename _Container::value_type& _Val) {
+        container->push_back(_Val);
+        return *this;
+    }
+
+    _CONSTEXPR20 back_insert_iterator& operator=(typename _Container::value_type&& _Val) {
+        container->push_back(_STD move(_Val));
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 back_insert_iterator& operator*() noexcept /* strengthened */ {
+        return *this;
+    }
+
+    _CONSTEXPR20 back_insert_iterator& operator++() noexcept /* strengthened */ {
+        return *this;
+    }
+
+    _CONSTEXPR20 back_insert_iterator operator++(int) noexcept /* strengthened */ {
+        return *this;
+    }
+
+protected:
+    _Container* container;
+};
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR20 back_insert_iterator<_Container> back_inserter(_Container& _Cont) noexcept /* strengthened */ {
+    // return a back_insert_iterator
+    return back_insert_iterator<_Container>(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+class front_insert_iterator { // wrap pushes to front of container as output iterator
+public:
+    using iterator_category = output_iterator_tag;
+    using value_type        = void;
+    using pointer           = void;
+    using reference         = void;
+
+    using container_type = _Container;
+
+#if _HAS_CXX20
+    using difference_type = ptrdiff_t;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using difference_type = void;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR20 explicit front_insert_iterator(_Container& _Cont) : container(_STD addressof(_Cont)) {}
+
+    _CONSTEXPR20 front_insert_iterator& operator=(const typename _Container::value_type& _Val) {
+        // push value into container
+        container->push_front(_Val);
+        return *this;
+    }
+
+    _CONSTEXPR20 front_insert_iterator& operator=(typename _Container::value_type&& _Val) { // push value into container
+        container->push_front(_STD move(_Val));
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 front_insert_iterator& operator*() { // pretend to return designated value
+        return *this;
+    }
+
+    _CONSTEXPR20 front_insert_iterator& operator++() { // pretend to preincrement
+        return *this;
+    }
+
+    _CONSTEXPR20 front_insert_iterator operator++(int) { // pretend to postincrement
+        return *this;
+    }
+
+protected:
+    _Container* container;
+};
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR20 front_insert_iterator<_Container> front_inserter(_Container& _Cont) {
+    return front_insert_iterator<_Container>(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+class insert_iterator { // wrap inserts into container as output iterator
+public:
+    using iterator_category = output_iterator_tag;
+    using value_type        = void;
+    using pointer           = void;
+    using reference         = void;
+
+    using container_type = _Container;
+#if _HAS_CXX20
+    using difference_type = ptrdiff_t;
+    using _Wrapped_iter   = ranges::iterator_t<_Container>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using difference_type = void;
+    using _Wrapped_iter   = typename _Container::iterator;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR20 insert_iterator(_Container& _Cont, _Wrapped_iter _Where)
+        : container(_STD addressof(_Cont)), iter(_STD move(_Where)) {}
+
+    _CONSTEXPR20 insert_iterator& operator=(const typename _Container::value_type& _Val) {
+        // insert into container and increment stored iterator
+        iter = container->insert(iter, _Val);
+        ++iter;
+        return *this;
+    }
+
+    _CONSTEXPR20 insert_iterator& operator=(typename _Container::value_type&& _Val) { // push value into container
+        iter = container->insert(iter, _STD move(_Val));
+        ++iter;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 insert_iterator& operator*() { // pretend to return designated value
+        return *this;
+    }
+
+    _CONSTEXPR20 insert_iterator& operator++() { // pretend to preincrement
+        return *this;
+    }
+
+    _CONSTEXPR20 insert_iterator& operator++(int) { // pretend to postincrement
+        return *this;
+    }
+
+protected:
+    _Container* container;
+    _Wrapped_iter iter;
+};
+
+#if !_HAS_CXX20
+template <class _Container>
+_NODISCARD _CONSTEXPR20 insert_iterator<_Container> inserter(_Container& _Cont, typename _Container::iterator _Where) {
+    return insert_iterator<_Container>(_Cont, _Where);
+}
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr insert_iterator<_Container> inserter(_Container& _Cont, _RANGES iterator_t<_Container> _Where) {
+    return insert_iterator<_Container>(_Cont, _Where);
+}
+
+_EXPORT_STD template <semiregular _Se>
+class move_sentinel {
+public:
+    constexpr move_sentinel() = default;
+
+    constexpr explicit move_sentinel(_Se _Val) noexcept(is_nothrow_move_constructible_v<_Se>) // strengthened
+        : _Last(_STD move(_Val)) {}
+
+    template <class _Se2>
+        requires convertible_to<const _Se2&, _Se>
+    constexpr move_sentinel(const move_sentinel<_Se2>& _Val)
+        noexcept(is_nothrow_constructible_v<_Se, const _Se2&>) // strengthened
+        : _Last(_Val._Get_last()) {}
+
+    template <class _Se2>
+        requires assignable_from<_Se&, const _Se2&>
+    constexpr move_sentinel& operator=(const move_sentinel<_Se2>& _Val)
+        noexcept(is_nothrow_assignable_v<_Se&, const _Se2&>) /* strengthened */ {
+        _Last = _Val._Get_last();
+        return *this;
+    }
+
+    _NODISCARD constexpr _Se base() const noexcept(is_nothrow_copy_constructible_v<_Se>) /* strengthened */ {
+        return _Last;
+    }
+
+    _NODISCARD constexpr const _Se& _Get_last() const noexcept {
+        return _Last;
+    }
+
+    using _Prevent_inheriting_unwrap = move_sentinel;
+
+    _NODISCARD constexpr move_sentinel<_Unwrapped_t<const _Se&>> _Unwrapped() const& noexcept(
+        noexcept(move_sentinel<_Unwrapped_t<const _Se&>>{_Last._Unwrapped()}))
+        requires (_RANGES _Weakly_unwrappable_sentinel<_Se>)
+    {
+        return move_sentinel<_Unwrapped_t<const _Se&>>{_Last._Unwrapped()};
+    }
+    _NODISCARD constexpr move_sentinel<_Unwrapped_t<_Se>> _Unwrapped() && noexcept(
+        noexcept(move_sentinel<_Unwrapped_t<_Se>>{_STD move(_Last)._Unwrapped()}))
+        requires (_RANGES _Weakly_unwrappable_sentinel<_Se>)
+    {
+        return move_sentinel<_Unwrapped_t<_Se>>{_STD move(_Last)._Unwrapped()};
+    }
+
+private:
+    _Se _Last{};
+};
+#endif // ^^^ _HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Ty, class _Elem = char, class _Traits = char_traits<_Elem>, class _Diff = ptrdiff_t>
+class istream_iterator {
+public:
+    using iterator_category = input_iterator_tag;
+    using value_type        = _Ty;
+    using difference_type   = _Diff;
+    using pointer           = const _Ty*;
+    using reference         = const _Ty&;
+    using char_type         = _Elem;
+    using traits_type       = _Traits;
+    using istream_type      = basic_istream<_Elem, _Traits>;
+
+    static_assert(conjunction_v<is_default_constructible<_Ty>, is_copy_constructible<_Ty>, is_copy_assignable<_Ty>>,
+        "istream_iterator<T> requires T to be default constructible, copy constructible, and copy assignable. "
+        "(N4950 [istream.iterator]/2)");
+
+    constexpr istream_iterator() noexcept(is_nothrow_default_constructible_v<_Ty>) /* strengthened */ {}
+
+#if _HAS_CXX20
+    constexpr istream_iterator(default_sentinel_t)
+        noexcept(is_nothrow_default_constructible_v<_Ty>) /* strengthened */ {}
+#endif // _HAS_CXX20
+
+    istream_iterator(istream_type& _Istr) : _Myistr(_STD addressof(_Istr)) {
+        _Getval();
+    }
+
+    _NODISCARD const _Ty& operator*() const noexcept /* strengthened */ {
+        _STL_ASSERT(_Myistr, "The stored stream pointer in_stream must be non-null");
+        return _Myval;
+    }
+
+    _NODISCARD const _Ty* operator->() const noexcept /* strengthened */ {
+        _STL_ASSERT(_Myistr, "The stored stream pointer in_stream must be non-null");
+        return _STD addressof(_Myval);
+    }
+
+    istream_iterator& operator++() {
+        _Getval();
+        return *this;
+    }
+
+    istream_iterator operator++(int) {
+        istream_iterator _Tmp = *this;
+        _Getval();
+        return _Tmp;
+    }
+
+    _NODISCARD bool _Equal(const istream_iterator& _Right) const noexcept {
+        return _Myistr == _Right._Myistr;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend bool operator==(const istream_iterator& _Left, default_sentinel_t) noexcept /* strengthened */ {
+        return !_Left._Myistr;
+    }
+#endif // _HAS_CXX20
+
+private:
+    void _Getval() { // get a _Ty value if possible
+        _STL_ASSERT(_Myistr, "The stored stream pointer in_stream must be non-null");
+        if (!(*_Myistr >> _Myval)) {
+            _Myistr = nullptr;
+        }
+    }
+
+    istream_type* _Myistr{nullptr}; // pointer to input stream
+    _Ty _Myval{}; // lookahead value (valid if _Myistr is not null)
+};
+
+_EXPORT_STD template <class _Ty, class _Elem, class _Traits, class _Diff>
+_NODISCARD bool operator==(const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Left,
+    const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Right) noexcept /* strengthened */ {
+    return _Left._Equal(_Right);
+}
+
+#if !_HAS_CXX20
+template <class _Ty, class _Elem, class _Traits, class _Diff>
+_NODISCARD bool operator!=(const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Left,
+    const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Right) noexcept /* strengthened */ {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Ty, class _Elem = char, class _Traits = char_traits<_Elem>>
+class ostream_iterator {
+public:
+    using iterator_category = output_iterator_tag;
+    using value_type        = void;
+#if _HAS_CXX20
+    using difference_type = ptrdiff_t;
+#else
+    using difference_type = void;
+#endif
+    using pointer      = void;
+    using reference    = void;
+    using char_type    = _Elem;
+    using traits_type  = _Traits;
+    using ostream_type = basic_ostream<_Elem, _Traits>;
+
+    ostream_iterator(ostream_type& _Ostr, const _Elem* const _Delim = nullptr) noexcept /* strengthened */
+        : _Mydelim(_Delim), _Myostr(_STD addressof(_Ostr)) {}
+
+    ostream_iterator& operator=(const _Ty& _Val) { // insert value into output stream, followed by delimiter
+        *_Myostr << _Val;
+        if (_Mydelim) {
+            *_Myostr << _Mydelim;
+        }
+
+        return *this;
+    }
+
+    _NODISCARD ostream_iterator& operator*() noexcept /* strengthened */ {
+        return *this;
+    }
+
+    ostream_iterator& operator++() noexcept /* strengthened */ {
+        return *this;
+    }
+
+    ostream_iterator& operator++(int) noexcept /* strengthened */ {
+        return *this;
+    }
+
+private:
+    const _Elem* _Mydelim; // pointer to delimiter string (NB: not freed)
+    ostream_type* _Myostr; // pointer to output stream
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class istreambuf_iterator {
+public:
+    using iterator_category = input_iterator_tag;
+    using value_type        = _Elem;
+    using difference_type   = typename _Traits::off_type;
+    using pointer           = const _Elem*;
+    using reference         = _Elem;
+    using char_type         = _Elem;
+    using traits_type       = _Traits;
+    using int_type          = typename traits_type::int_type;
+    using streambuf_type    = basic_streambuf<_Elem, _Traits>;
+    using istream_type      = basic_istream<_Elem, _Traits>;
+
+    constexpr istreambuf_iterator() noexcept : _Strbuf(nullptr), _Got(true), _Val() {}
+#if _HAS_CXX20
+    constexpr istreambuf_iterator(default_sentinel_t) noexcept : _Strbuf(nullptr), _Got(true), _Val() {}
+#endif // _HAS_CXX20
+
+    istreambuf_iterator(istream_type& _Istr) noexcept : _Strbuf(_Istr.rdbuf()), _Got(!_Strbuf), _Val() {}
+
+    istreambuf_iterator(streambuf_type* _Sb) noexcept : _Strbuf(_Sb), _Got(!_Sb), _Val() {}
+
+private:
+    class _Istreambuf_proxy {
+    public:
+        _NODISCARD _Elem operator*() const noexcept(is_nothrow_copy_constructible_v<_Elem>) /* strengthened */ {
+            return _Keep;
+        }
+
+    private:
+        friend istreambuf_iterator;
+        _Istreambuf_proxy(streambuf_type* _Strbuf_, _Elem _Keep_)
+            noexcept(is_nothrow_copy_constructible_v<_Elem>) // strengthened
+            : _Strbuf(_Strbuf_), _Keep(_Keep_) {}
+
+        streambuf_type* _Strbuf;
+        _Elem _Keep;
+    };
+
+public:
+    istreambuf_iterator(const _Istreambuf_proxy& _Px) noexcept : _Strbuf(_Px._Strbuf), _Got(!_Strbuf), _Val() {}
+
+    _NODISCARD _Elem operator*() const {
+        if (!_Got) {
+            _Peek();
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Strbuf, "istreambuf_iterator is not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return _Val;
+    }
+
+    istreambuf_iterator& operator++() {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Strbuf, "istreambuf_iterator is not incrementable");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Inc();
+        return *this;
+    }
+
+    _Istreambuf_proxy operator++(int) {
+        if (!_Got) {
+            _Peek();
+        }
+
+        _Istreambuf_proxy _Tmp{_Strbuf, _Val};
+        ++*this;
+        return _Tmp;
+    }
+
+    _NODISCARD bool equal(const istreambuf_iterator& _Right) const {
+        if (!_Got) {
+            _Peek();
+        }
+
+        if (!_Right._Got) {
+            _Right._Peek();
+        }
+
+        return (!_Strbuf && !_Right._Strbuf) || (_Strbuf && _Right._Strbuf);
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend bool operator==(const istreambuf_iterator& _Left, default_sentinel_t) {
+        if (!_Left._Got) {
+            _Left._Peek();
+        }
+
+        return !_Left._Strbuf;
+    }
+#endif // _HAS_CXX20
+
+private:
+    void _Inc() { // skip to next input element
+        if (!_Strbuf || traits_type::eq_int_type(traits_type::eof(), _Strbuf->sbumpc())) {
+            _Strbuf = nullptr;
+            _Got    = true;
+        } else {
+            _Got = false;
+        }
+    }
+
+    _Elem _Peek() const { // peek at next input element
+        int_type _Meta;
+        if (!_Strbuf || traits_type::eq_int_type(traits_type::eof(), _Meta = _Strbuf->sgetc())) {
+            _Strbuf = nullptr;
+        } else {
+            _Val = traits_type::to_char_type(_Meta);
+        }
+
+        _Got = true;
+        return _Val;
+    }
+
+    mutable streambuf_type* _Strbuf; // the wrapped stream buffer
+    mutable bool _Got; // true if _Val is valid
+    mutable _Elem _Val; // next element to deliver
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+_NODISCARD bool operator==(
+    const istreambuf_iterator<_Elem, _Traits>& _Left, const istreambuf_iterator<_Elem, _Traits>& _Right) {
+    return _Left.equal(_Right);
+}
+
+#if !_HAS_CXX20
+template <class _Elem, class _Traits>
+_NODISCARD bool operator!=(
+    const istreambuf_iterator<_Elem, _Traits>& _Left, const istreambuf_iterator<_Elem, _Traits>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX20 && !defined(__clang__) && !defined(__EDG__) // TRANSITION, /permissive, avoid checking constraints
+template <class _Elem, class _Traits>
+constexpr bool _Iterator_is_contiguous<istreambuf_iterator<_Elem, _Traits>> = false;
+#endif // ^^^ workaround ^^^
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class ostreambuf_iterator {
+public:
+    using iterator_category = output_iterator_tag;
+    using value_type        = void;
+#if _HAS_CXX20
+    using difference_type = ptrdiff_t;
+#else
+    using difference_type = void;
+#endif
+    using pointer        = void;
+    using reference      = void;
+    using char_type      = _Elem;
+    using traits_type    = _Traits;
+    using streambuf_type = basic_streambuf<_Elem, _Traits>;
+    using ostream_type   = basic_ostream<_Elem, _Traits>;
+
+    ostreambuf_iterator(streambuf_type* _Sb) noexcept : _Strbuf(_Sb) {}
+
+    ostreambuf_iterator(ostream_type& _Ostr) noexcept : _Strbuf(_Ostr.rdbuf()) {}
+
+    ostreambuf_iterator& operator=(_Elem _Right) { // store element and increment
+        if (!_Strbuf || traits_type::eq_int_type(_Traits::eof(), _Strbuf->sputc(_Right))) {
+            _Failed = true;
+        }
+
+        return *this;
+    }
+
+    _NODISCARD ostreambuf_iterator& operator*() noexcept /* strengthened */ {
+        return *this;
+    }
+
+    ostreambuf_iterator& operator++() noexcept /* strengthened */ {
+        return *this;
+    }
+
+    ostreambuf_iterator& operator++(int) noexcept /* strengthened */ {
+        return *this;
+    }
+
+    _NODISCARD bool failed() const noexcept {
+        return _Failed;
+    }
+
+private:
+    bool _Failed = false; // true if any stores have failed
+    streambuf_type* _Strbuf;
+};
+
+#if _HAS_CXX20 && !defined(__clang__) && !defined(__EDG__) // TRANSITION, /permissive, avoid checking constraints
+template <class _Elem, class _Traits>
+constexpr bool _Iterator_is_contiguous<ostreambuf_iterator<_Elem, _Traits>> = false;
+#endif // ^^^ workaround ^^^
+
+#if _HAS_CXX20
+enum class _Variantish_state : unsigned char { _Nothing, _Holds_first, _Holds_second };
+
+struct _Variantish_empty_tag {
+    explicit _Variantish_empty_tag() = default;
+};
+
+template <class _Ty1, class _Ty2>
+class _Variantish {
+public:
+    constexpr explicit _Variantish(_Variantish_empty_tag) noexcept : _Contains{_Variantish_state::_Nothing} {}
+
+    constexpr _Variantish() noexcept(is_nothrow_default_constructible_v<_Ty1>)
+        requires default_initializable<_Ty1>
+        : _First{}, _Contains{_Variantish_state::_Holds_first} {}
+
+    template <class... _Types>
+    constexpr explicit _Variantish(in_place_type_t<_Ty1>, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty1, _Types...>)
+        : _First(_STD forward<_Types>(_Args)...), _Contains{_Variantish_state::_Holds_first} {}
+
+    template <class... _Types>
+        requires _Different_from<_Ty1, _Ty2>
+    constexpr explicit _Variantish(in_place_type_t<_Ty2>, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty2, _Types...>)
+        : _Second(_STD forward<_Types>(_Args)...), _Contains{_Variantish_state::_Holds_second} {}
+
+    template <class _Uty1, class _Uty2>
+        requires _Different_from<_Variantish<_Uty1, _Uty2>, _Variantish>
+    constexpr _Variantish(const _Variantish<_Uty1, _Uty2>& _That)
+        noexcept(is_nothrow_constructible_v<_Ty1, const _Uty1&> && is_nothrow_constructible_v<_Ty2, const _Uty2&>)
+        : _Contains{_That._Contains} {
+        switch (_That._Contains) {
+        case _Variantish_state::_Holds_first:
+            _STD _Construct_in_place(_First, _That._Get_first());
+            break;
+        case _Variantish_state::_Holds_second:
+            _STD _Construct_in_place(_Second, _That._Get_second());
+            break;
+        case _Variantish_state::_Nothing:
+            break;
+        }
+    }
+
+    constexpr _Variantish(const _Variantish&)
+        requires is_trivially_copy_constructible_v<_Ty1> && is_trivially_copy_constructible_v<_Ty2>
+    = default;
+
+    constexpr _Variantish(const _Variantish& _That)
+        noexcept(is_nothrow_copy_constructible_v<_Ty1> && is_nothrow_copy_constructible_v<_Ty2>)
+        : _Contains{_That._Contains} {
+        switch (_Contains) {
+        case _Variantish_state::_Holds_first:
+            _STD _Construct_in_place(_First, _That._Get_first());
+            break;
+        case _Variantish_state::_Holds_second:
+            _STD _Construct_in_place(_Second, _That._Get_second());
+            break;
+        case _Variantish_state::_Nothing:
+            break;
+        }
+    }
+
+    constexpr _Variantish(_Variantish&&)
+        requires is_trivially_move_constructible_v<_Ty1> && is_trivially_move_constructible_v<_Ty2>
+    = default;
+
+    constexpr _Variantish(_Variantish&& _That)
+        noexcept(is_nothrow_move_constructible_v<_Ty1> && is_nothrow_move_constructible_v<_Ty2>)
+        : _Contains{_That._Contains} {
+        switch (_Contains) {
+        case _Variantish_state::_Holds_first:
+            _STD _Construct_in_place(_First, _STD move(_That._Get_first()));
+            break;
+        case _Variantish_state::_Holds_second:
+            _STD _Construct_in_place(_Second, _STD move(_That._Get_second()));
+            break;
+        case _Variantish_state::_Nothing:
+            break;
+        }
+    }
+
+    constexpr ~_Variantish() {
+        _Raw_clear();
+    }
+
+    constexpr ~_Variantish()
+        requires is_trivially_destructible_v<_Ty1> && is_trivially_destructible_v<_Ty2>
+    = default;
+
+    constexpr _Variantish& operator=(const _Variantish&)
+        requires is_trivially_destructible_v<_Ty1> && is_trivially_destructible_v<_Ty2>
+                  && is_trivially_copy_constructible_v<_Ty1> && is_trivially_copy_constructible_v<_Ty2>
+                  && is_trivially_copy_assignable_v<_Ty1> && is_trivially_copy_assignable_v<_Ty2>
+    = default;
+
+    constexpr _Variantish& operator=(const _Variantish& _That)
+        noexcept(is_nothrow_copy_constructible_v<_Ty1> && is_nothrow_copy_constructible_v<_Ty2>
+                 && is_nothrow_copy_assignable_v<_Ty1> && is_nothrow_copy_assignable_v<_Ty2>) {
+        if (_Contains == _That._Contains) {
+            switch (_Contains) {
+            case _Variantish_state::_Holds_first:
+                _Get_first() = _That._Get_first();
+                break;
+            case _Variantish_state::_Holds_second:
+                _Get_second() = _That._Get_second();
+                break;
+            case _Variantish_state::_Nothing:
+                break;
+            }
+
+            return *this;
+        }
+
+        _Clear();
+
+        switch (_That._Contains) {
+        case _Variantish_state::_Holds_first:
+            _STD _Construct_in_place(_First, _That._Get_first());
+            break;
+        case _Variantish_state::_Holds_second:
+            _STD _Construct_in_place(_Second, _That._Get_second());
+            break;
+        case _Variantish_state::_Nothing:
+            break;
+        }
+
+        _Contains = _That._Contains;
+
+        return *this;
+    }
+
+    constexpr _Variantish& operator=(_Variantish&&)
+        requires is_trivially_destructible_v<_Ty1> && is_trivially_destructible_v<_Ty2>
+                  && is_trivially_move_constructible_v<_Ty1> && is_trivially_move_constructible_v<_Ty2>
+                  && is_trivially_move_assignable_v<_Ty1> && is_trivially_move_assignable_v<_Ty2>
+    = default;
+
+    constexpr _Variantish& operator=(_Variantish&& _That)
+        noexcept(is_nothrow_move_constructible_v<_Ty1> && is_nothrow_move_constructible_v<_Ty2>
+                 && is_nothrow_move_assignable_v<_Ty1> && is_nothrow_move_assignable_v<_Ty2>) {
+        if (_Contains == _That._Contains) {
+            switch (_Contains) {
+            case _Variantish_state::_Holds_first:
+                _Get_first() = _STD move(_That._Get_first());
+                break;
+            case _Variantish_state::_Holds_second:
+                _Get_second() = _STD move(_That._Get_second());
+                break;
+            case _Variantish_state::_Nothing:
+                break;
+            }
+
+            return *this;
+        }
+
+        _Clear();
+
+        switch (_That._Contains) {
+        case _Variantish_state::_Holds_first:
+            _STD _Construct_in_place(_First, _STD move(_That._Get_first()));
+            break;
+        case _Variantish_state::_Holds_second:
+            _STD _Construct_in_place(_Second, _STD move(_That._Get_second()));
+            break;
+        case _Variantish_state::_Nothing:
+            break;
+        }
+
+        _Contains = _That._Contains;
+
+        return *this;
+    }
+
+    template <class _Uty1, class _Uty2>
+        requires _Different_from<_Variantish<_Uty1, _Uty2>, _Variantish>
+    constexpr _Variantish& operator=(const _Variantish<_Uty1, _Uty2>& _That)
+        noexcept(is_nothrow_constructible_v<_Ty1, const _Uty1&> && is_nothrow_constructible_v<_Ty2, const _Uty2&>
+                 && is_nothrow_assignable_v<_Ty1&, const _Uty1&> && is_nothrow_assignable_v<_Ty2&, const _Uty2&>) {
+        if (_Contains == _That._Contains) {
+            switch (_Contains) {
+            case _Variantish_state::_Holds_first:
+                _Get_first() = _That._Get_first();
+                break;
+            case _Variantish_state::_Holds_second:
+                _Get_second() = _That._Get_second();
+                break;
+            case _Variantish_state::_Nothing:
+                break;
+            }
+
+            return *this;
+        }
+
+        _Clear();
+
+        switch (_That._Contains) {
+        case _Variantish_state::_Holds_first:
+            _STD _Construct_in_place(_First, _That._Get_first());
+            break;
+        case _Variantish_state::_Holds_second:
+            _STD _Construct_in_place(_Second, _That._Get_second());
+            break;
+        case _Variantish_state::_Nothing:
+            break;
+        }
+
+        _Contains = _That._Contains;
+
+        return *this;
+    }
+
+    friend constexpr void swap(_Variantish& _Left, _Variantish& _Right)
+        noexcept(is_nothrow_move_constructible_v<_Ty1> && is_nothrow_move_constructible_v<_Ty2>
+                 && is_nothrow_swappable_v<_Ty1> && is_nothrow_swappable_v<_Ty2>)
+        requires (!_Is_trivially_swappable_v<_Ty1> || !_Is_trivially_swappable_v<_Ty2>)
+    {
+        if (_Left._Contains == _Right._Contains) {
+            switch (_Left._Contains) {
+            case _Variantish_state::_Holds_first:
+                _RANGES swap(_Left._Get_first(), _Right._Get_first());
+                break;
+            case _Variantish_state::_Holds_second:
+                _RANGES swap(_Left._Get_second(), _Right._Get_second());
+                break;
+            case _Variantish_state::_Nothing:
+                break;
+            }
+
+            return;
+        }
+
+        auto _Tmp = _STD move(_Left);
+        _Left     = _STD move(_Right);
+        _Right    = _STD move(_Tmp);
+    }
+
+    constexpr void _Raw_clear() noexcept {
+        switch (_Contains) {
+        case _Variantish_state::_Holds_first:
+            _First.~_Ty1();
+            break;
+        case _Variantish_state::_Holds_second:
+            _Second.~_Ty2();
+            break;
+        case _Variantish_state::_Nothing:
+            break;
+        }
+    }
+
+    _NODISCARD constexpr _Ty1& _Get_first() noexcept {
+        return _First;
+    }
+    _NODISCARD constexpr const _Ty1& _Get_first() const noexcept {
+        return _First;
+    }
+
+    _NODISCARD constexpr _Ty2& _Get_second() noexcept {
+        return _Second;
+    }
+    _NODISCARD constexpr const _Ty2& _Get_second() const noexcept {
+        return _Second;
+    }
+
+    constexpr void _Clear() noexcept {
+        _Raw_clear();
+        _Contains = _Variantish_state::_Nothing;
+    }
+
+    template <class... _Types>
+    constexpr void _Emplace_first(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty1, _Types...>) {
+        _Clear();
+
+        _STD _Construct_in_place(_First, _STD forward<_Types>(_Args)...);
+        _Contains = _Variantish_state::_Holds_first;
+    }
+
+    template <class... _Types>
+    constexpr void _Emplace_second(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty2, _Types...>) {
+        _Clear();
+
+        _STD _Construct_in_place(_Second, _STD forward<_Types>(_Args)...);
+        _Contains = _Variantish_state::_Holds_second;
+    }
+
+    union {
+        remove_cv_t<_Ty1> _First;
+        remove_cv_t<_Ty2> _Second;
+    };
+
+    _Variantish_state _Contains;
+};
+
+template <class _Iter>
+concept _Use_postfix_proxy =
+    !requires(_Iter& __it) {
+        { *__it++ } -> _Can_reference;
+    } && indirectly_readable<_Iter> && constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>
+    && move_constructible<iter_value_t<_Iter>>;
+
+_EXPORT_STD template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Se>
+    requires (!same_as<_Iter, _Se> && copyable<_Iter>)
+class common_iterator {
+private:
+    struct _Proxy_base {
+        iter_value_t<_Iter> _Keep;
+
+        constexpr explicit _Proxy_base(iter_reference_t<_Iter>&& _Right)
+            noexcept(is_nothrow_constructible_v<iter_value_t<_Iter>, iter_reference_t<_Iter>>) // strengthened
+            : _Keep(_STD forward<iter_reference_t<_Iter>>(_Right)) {}
+    };
+
+public:
+    constexpr common_iterator()
+        requires default_initializable<_Iter>
+    = default;
+
+    constexpr common_iterator(_Iter _Right) noexcept(is_nothrow_move_constructible_v<_Iter>) // strengthened
+        : _Val{in_place_type<_Iter>, _STD move(_Right)} {}
+
+    constexpr common_iterator(_Se _Right) noexcept(is_nothrow_move_constructible_v<_Se>) // strengthened
+        : _Val{in_place_type<_Se>, _STD move(_Right)} {}
+
+    constexpr explicit common_iterator(_Variantish_empty_tag _Tag) noexcept : _Val{_Tag} {}
+
+    template <class _OIter, class _OSe>
+        requires convertible_to<const _OIter&, _Iter> && convertible_to<const _OSe&, _Se>
+    constexpr common_iterator(const common_iterator<_OIter, _OSe>& _Right)
+        noexcept(is_nothrow_constructible_v<_Iter, const _OIter&>
+                 && is_nothrow_constructible_v<_Se, const _OSe&>) // strengthened
+        : _Val{_Right._Get_val_for_hardened_construction()} {}
+
+    template <class _OIter, class _OSe>
+        requires convertible_to<const _OIter&, _Iter> && convertible_to<const _OSe&, _Se>
+              && assignable_from<_Iter&, const _OIter&> && assignable_from<_Se&, const _OSe&>
+    constexpr common_iterator& operator=(const common_iterator<_OIter, _OSe>& _Right)
+        noexcept(is_nothrow_constructible_v<_Iter, const _OIter&> && is_nothrow_constructible_v<_Se, const _OSe&>
+                 && is_nothrow_assignable_v<_Iter&, const _OIter&>
+                 && is_nothrow_assignable_v<_Se&, const _OSe&>) /* strengthened */ {
+        auto& _Right_val = _Right._Get_val();
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Right_val._Contains != _Variantish_state::_Nothing,
+            "common_iterator can only be assigned from if it holds a value");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _Val = _Right_val;
+        return *this;
+    }
+
+    _NODISCARD constexpr decltype(auto) operator*() {
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Val._Contains == _Variantish_state::_Holds_first,
+            "common_iterator can only be dereferenced if it holds an iterator");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return *_Val._Get_first();
+    }
+
+    _NODISCARD constexpr decltype(auto) operator*() const
+        requires _Dereferenceable<const _Iter>
+    {
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Val._Contains == _Variantish_state::_Holds_first,
+            "common_iterator can only be dereferenced if it holds an iterator");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return *_Val._Get_first();
+    }
+
+    _NODISCARD constexpr auto operator->() const
+        requires indirectly_readable<const _Iter>
+              && (_Has_member_arrow<const _Iter&> || is_reference_v<iter_reference_t<_Iter>>
+                  || constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>)
+    {
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Val._Contains == _Variantish_state::_Holds_first,
+            "common_iterator can only be dereferenced if it holds an iterator");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Has_member_arrow<const _Iter&> || is_pointer_v<_Iter>) {
+            return _Val._Get_first();
+        } else if constexpr (is_reference_v<iter_reference_t<_Iter>>) {
+            auto&& _Tmp = *_Val._Get_first();
+            return _STD addressof(_Tmp);
+        } else {
+            class _Arrow_proxy : private _Proxy_base {
+            public:
+                friend common_iterator;
+
+                using _Proxy_base::_Proxy_base;
+
+                _NODISCARD constexpr const iter_value_t<_Iter>* operator->() const noexcept {
+                    return _STD addressof(this->_Keep);
+                }
+            };
+
+            return _Arrow_proxy{*_Val._Get_first()};
+        }
+    }
+
+    constexpr common_iterator& operator++() {
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Val._Contains == _Variantish_state::_Holds_first,
+            "common_iterator can only be incremented if it holds an iterator");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        ++_Val._Get_first();
+        return *this;
+    }
+
+    constexpr decltype(auto) operator++(int) {
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Val._Contains == _Variantish_state::_Holds_first,
+            "common_iterator can only be incremented if it holds an iterator");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (forward_iterator<_Iter>) {
+            common_iterator _Tmp = *this;
+            ++_Val._Get_first();
+            return _Tmp;
+        } else if constexpr (_Use_postfix_proxy<_Iter>) {
+            class _Postfix_proxy : private _Proxy_base {
+            public:
+                friend common_iterator;
+
+                using _Proxy_base::_Proxy_base;
+
+                _NODISCARD constexpr const iter_value_t<_Iter>& operator*() const noexcept {
+                    return this->_Keep;
+                }
+            };
+
+            _Postfix_proxy _Tmp{*_Val._Get_first()};
+            ++_Val._Get_first();
+            return _Tmp;
+        } else {
+            return _Val._Get_first()++;
+        }
+    }
+
+    template <class _OIter, sentinel_for<_Iter> _OSe>
+        requires sentinel_for<_Se, _OIter>
+    _NODISCARD friend constexpr bool operator==(
+        const common_iterator& _Left, const common_iterator<_OIter, _OSe>& _Right) {
+        auto& _Right_val = _Right._Get_val();
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(
+            _Left._Val._Contains != _Variantish_state::_Nothing && _Right_val._Contains != _Variantish_state::_Nothing,
+            "common_iterators can only be compared if both hold a value");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+
+        if (_Left._Val._Contains == _Variantish_state::_Holds_first) {
+            if (_Right_val._Contains == _Variantish_state::_Holds_first) {
+                if constexpr (equality_comparable_with<_Iter, _OIter>) {
+                    return _Left._Val._Get_first() == _Right_val._Get_first();
+                } else {
+                    return true;
+                }
+            } else {
+                return _Left._Val._Get_first() == _Right_val._Get_second();
+            }
+        } else {
+            if (_Right_val._Contains == _Variantish_state::_Holds_first) {
+                return _Left._Val._Get_second() == _Right_val._Get_first();
+            } else {
+                return true;
+            }
+        }
+    }
+
+    template <sized_sentinel_for<_Iter> _OIter, sized_sentinel_for<_Iter> _OSe>
+        requires sized_sentinel_for<_Se, _OIter>
+    _NODISCARD friend constexpr iter_difference_t<_OIter> operator-(
+        const common_iterator& _Left, const common_iterator<_OIter, _OSe>& _Right) {
+        auto& _Right_val = _Right._Get_val();
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(
+            _Left._Val._Contains != _Variantish_state::_Nothing && _Right_val._Contains != _Variantish_state::_Nothing,
+            "Cannot take difference of valueless common_iterators");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+
+        if (_Left._Val._Contains == _Variantish_state::_Holds_first) {
+            if (_Right_val._Contains == _Variantish_state::_Holds_first) {
+                return _Left._Val._Get_first() - _Right_val._Get_first();
+            } else {
+                return _Left._Val._Get_first() - _Right_val._Get_second();
+            }
+        } else {
+            if (_Right_val._Contains == _Variantish_state::_Holds_first) {
+                return _Left._Val._Get_second() - _Right_val._Get_first();
+            } else {
+                return 0;
+            }
+        }
+    }
+
+    _NODISCARD friend constexpr decltype(auto) iter_move(const common_iterator& _Right)
+        noexcept(noexcept(_RANGES iter_move(_Right._Val._Get_first())))
+        requires input_iterator<_Iter>
+    {
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Right._Val._Contains == _Variantish_state::_Holds_first,
+            "can only iter_move from common_iterator if it holds an iterator");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return _RANGES iter_move(_Right._Val._Get_first());
+    }
+
+    template <indirectly_swappable<_Iter> _OIter, class _OSe>
+    friend constexpr void iter_swap(const common_iterator& _Left, const common_iterator<_OIter, _OSe>& _Right)
+        noexcept(noexcept(_RANGES iter_swap(_Left._Val._Get_first(), _Right._Get_val()._Get_first()))) {
+        auto& _Right_val = _Right._Get_val();
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Left._Val._Contains == _Variantish_state::_Holds_first
+                        && _Right_val._Contains == _Variantish_state::_Holds_first,
+            "can only iter_swap common_iterators if both hold iterators");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return _RANGES iter_swap(_Left._Val._Get_first(), _Right_val._Get_first());
+    }
+
+    _NODISCARD constexpr _Variantish<_Iter, _Se>& _Get_val() noexcept {
+        return _Val;
+    }
+    _NODISCARD constexpr const _Variantish<_Iter, _Se>& _Get_val() const noexcept {
+        return _Val;
+    }
+
+    _NODISCARD constexpr const _Variantish<_Iter, _Se>& _Get_val_for_hardened_construction() const noexcept {
+#if _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Val._Contains != _Variantish_state::_Nothing,
+            "common_iterator can only be constructed from if it holds a value");
+#endif // _MSVC_STL_HARDENING_COMMON_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return _Val;
+    }
+
+private:
+    _Variantish<_Iter, _Se> _Val;
+};
+
+template <class _Iter, class _Se>
+struct incrementable_traits<common_iterator<_Iter, _Se>> {
+    using difference_type = iter_difference_t<_Iter>;
+};
+
+template <class, class>
+struct _Common_iterator_pointer_type {
+    using pointer = void;
+};
+
+template <class _Iter, class _Se>
+    requires _Has_member_arrow<const common_iterator<_Iter, _Se>&>
+struct _Common_iterator_pointer_type<_Iter, _Se> {
+    using pointer = decltype(_STD declval<const common_iterator<_Iter, _Se>&>().operator->());
+};
+
+template <class _Iter>
+concept _Has_forward_category = requires {
+    typename _Iter_cat_t<_Iter>;
+    requires derived_from<_Iter_cat_t<_Iter>, forward_iterator_tag>;
+};
+
+template <class _Iter>
+struct _Common_iterator_category_base {};
+
+template <class _Iter>
+    requires is_integral_v<iter_difference_t<_Iter>>
+struct _Common_iterator_category_base<_Iter> {
+    using iterator_category = conditional_t<_Has_forward_category<_Iter>, forward_iterator_tag, input_iterator_tag>;
+};
+
+template <input_iterator _Iter, class _Se>
+struct iterator_traits<common_iterator<_Iter, _Se>> : _Common_iterator_category_base<_Iter> {
+    using iterator_concept = conditional_t<forward_iterator<_Iter>, forward_iterator_tag, input_iterator_tag>;
+    using value_type       = iter_value_t<_Iter>;
+    using difference_type  = iter_difference_t<_Iter>;
+    using pointer          = _Common_iterator_pointer_type<_Iter, _Se>::pointer;
+    using reference        = iter_reference_t<_Iter>;
+};
+
+template <class _Iter>
+struct _Counted_iterator_value_type_base {};
+
+template <indirectly_readable _Iter>
+struct _Counted_iterator_value_type_base<_Iter> {
+    using value_type = iter_value_t<_Iter>;
+};
+
+template <class _Iter>
+struct _Counted_iterator_category_base : _Counted_iterator_value_type_base<_Iter> {};
+
+template <_Has_member_iterator_category _Iter>
+struct _Counted_iterator_category_base<_Iter> : _Counted_iterator_value_type_base<_Iter> {
+    using iterator_category = _Iter::iterator_category;
+};
+
+template <class _Iter>
+struct _Counted_iterator_concept_base : _Counted_iterator_category_base<_Iter> {};
+
+template <_Has_member_iterator_concept _Iter>
+struct _Counted_iterator_concept_base<_Iter> : _Counted_iterator_category_base<_Iter> {
+    using iterator_concept = _Iter::iterator_concept;
+};
+
+_EXPORT_STD template <input_or_output_iterator _Iter>
+class counted_iterator : public _Counted_iterator_concept_base<_Iter> {
+public:
+    using iterator_type   = _Iter;
+    using difference_type = iter_difference_t<_Iter>;
+
+    // [counted.iter.const]
+    constexpr counted_iterator()
+        requires default_initializable<_Iter>
+    = default;
+
+    constexpr counted_iterator(_Iter _Right, const iter_difference_t<_Iter> _Diff)
+        noexcept(is_nothrow_move_constructible_v<_Iter>) // strengthened
+        : _Current(_STD move(_Right)), _Length(_Diff) {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Diff >= 0, "counted_iterator requires non-negative length n");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <class _Other>
+        requires convertible_to<const _Other&, _Iter>
+    constexpr counted_iterator(const counted_iterator<_Other>& _Right)
+        noexcept(is_nothrow_constructible_v<_Iter, const _Other&>) // strengthened
+        : _Current(_Right.base()), _Length(_Right.count()) {}
+
+    template <class _Other>
+        requires assignable_from<_Iter&, const _Other&>
+    constexpr counted_iterator& operator=(const counted_iterator<_Other>& _Right)
+        noexcept(is_nothrow_assignable_v<_Iter&, const _Other&>) /* strengthened */ {
+        _Current = _Right.base();
+        _Length  = _Right.count();
+        return *this;
+    }
+
+    // [counted.iter.access]
+    _NODISCARD constexpr const _Iter& base() const& noexcept {
+        return _Current;
+    }
+
+    _NODISCARD constexpr _Iter base() && noexcept(is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
+        return _STD move(_Current);
+    }
+
+    _NODISCARD constexpr iter_difference_t<_Iter> count() const noexcept {
+        return _Length;
+    }
+
+    // [counted.iter.elem]
+    _NODISCARD constexpr decltype(auto) operator*() noexcept(noexcept(*_Current)) /* strengthened */ {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Length > 0, "counted_iterator dereference beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return *_Current;
+    }
+
+    _NODISCARD constexpr decltype(auto) operator*() const noexcept(noexcept(*_Current)) /* strengthened */
+        requires _Dereferenceable<const _Iter>
+    {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Length > 0, "counted_iterator dereference beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return *_Current;
+    }
+
+    _NODISCARD constexpr auto operator->() const noexcept
+        requires contiguous_iterator<_Iter>
+    {
+        return _STD to_address(_Current);
+    }
+
+    _NODISCARD constexpr decltype(auto) operator[](const iter_difference_t<_Iter> _Diff) const
+        requires random_access_iterator<_Iter>
+    {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Diff < _Length, "counted_iterator index out of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return _Current[_Diff];
+    }
+
+    // [counted.iter.nav]
+    constexpr counted_iterator& operator++() {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Length > 0, "counted_iterator increment beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        ++_Current;
+        --_Length;
+        return *this;
+    }
+
+    constexpr decltype(auto) operator++(int) {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Length > 0, "counted_iterator increment beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        --_Length;
+        _TRY_BEGIN
+        return _Current++;
+
+        _CATCH_ALL
+        ++_Length;
+
+        _RERAISE;
+        _CATCH_END
+    }
+
+    constexpr counted_iterator operator++(int)
+        requires forward_iterator<_Iter>
+    {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Length > 0, "counted_iterator increment beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        counted_iterator _Tmp = *this;
+        ++_Current;
+        --_Length;
+        return _Tmp;
+    }
+
+    constexpr counted_iterator& operator--()
+        requires bidirectional_iterator<_Iter>
+    {
+        --_Current;
+        ++_Length;
+        return *this;
+    }
+
+    constexpr counted_iterator operator--(int)
+        requires bidirectional_iterator<_Iter>
+    {
+        counted_iterator _Tmp = *this;
+        --_Current;
+        ++_Length;
+        return _Tmp;
+    }
+
+    _NODISCARD constexpr counted_iterator operator+(const iter_difference_t<_Iter> _Diff) const
+        requires random_access_iterator<_Iter>
+    {
+        return counted_iterator{_Current + _Diff, static_cast<iter_difference_t<_Iter>>(_Length - _Diff)};
+    }
+
+    _NODISCARD friend constexpr counted_iterator operator+(
+        const iter_difference_t<_Iter> _Diff, const counted_iterator& _Right)
+        requires random_access_iterator<_Iter>
+    {
+        return counted_iterator{_Right._Current + _Diff, static_cast<iter_difference_t<_Iter>>(_Right._Length - _Diff)};
+    }
+
+    constexpr counted_iterator& operator+=(const iter_difference_t<_Iter> _Diff)
+        requires random_access_iterator<_Iter>
+    {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Diff <= _Length, "counted_iterator seek beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _Current += _Diff;
+        _Length -= _Diff;
+        return *this;
+    }
+
+    _NODISCARD constexpr counted_iterator operator-(const iter_difference_t<_Iter> _Diff) const
+        requires random_access_iterator<_Iter>
+    {
+        return counted_iterator{_Current - _Diff, static_cast<iter_difference_t<_Iter>>(_Length + _Diff)};
+    }
+
+    template <common_with<_Iter> _Other>
+    _NODISCARD friend constexpr iter_difference_t<_Other> operator-(
+        const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _Same_sequence(_Left, _Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return _Right.count() - _Left._Length;
+    }
+
+    _NODISCARD friend constexpr iter_difference_t<_Iter> operator-(
+        const counted_iterator& _Left, default_sentinel_t) noexcept {
+        return -_Left._Length;
+    }
+
+    _NODISCARD friend constexpr iter_difference_t<_Iter> operator-(
+        default_sentinel_t, const counted_iterator& _Right) noexcept {
+        return _Right._Length;
+    }
+
+    constexpr counted_iterator& operator-=(const iter_difference_t<_Iter> _Diff)
+        requires random_access_iterator<_Iter>
+    {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(-_Diff <= _Length, "counted_iterator decrement beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _Current -= _Diff;
+        _Length += _Diff;
+        return *this;
+    }
+
+    // [counted.iter.cmp]
+    template <common_with<_Iter> _Other>
+    _NODISCARD friend constexpr bool operator==(
+        const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _Same_sequence(_Left, _Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return _Left._Length == _Right.count();
+    }
+
+    _NODISCARD friend constexpr bool operator==(const counted_iterator& _Left, default_sentinel_t) noexcept {
+        return _Left._Length == 0;
+    }
+
+    template <common_with<_Iter> _Other>
+    _NODISCARD friend constexpr strong_ordering operator<=>(
+        const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _Same_sequence(_Left, _Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return _Right.count() <=> _Left._Length;
+    }
+
+    // [counted.iter.cust]
+    _NODISCARD friend constexpr decltype(auto) iter_move(const counted_iterator& _Right)
+        noexcept(noexcept(_RANGES iter_move(_Right._Current)))
+        requires input_iterator<_Iter>
+    {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Right._Length > 0, "iter_move on a counted_iterator beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        return _RANGES iter_move(_Right._Current);
+    }
+
+    template <indirectly_swappable<_Iter> _Other>
+    friend constexpr void iter_swap(const counted_iterator& _Left, const counted_iterator<_Other>& _Right)
+        noexcept(noexcept(_RANGES iter_swap(_Left._Current, _Right.base()))) {
+#if _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Left._Length > 0 && _Right.count() > 0, "iter_swap on a counted_iterator beyond end of range");
+#endif // _MSVC_STL_HARDENING_COUNTED_ITERATOR || _ITERATOR_DEBUG_LEVEL != 0
+        _RANGES iter_swap(_Left._Current, _Right.base());
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+    template <common_with<_Iter> _Other>
+    friend constexpr void _Same_sequence(
+        const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept {
+#ifdef _M_CEE // TRANSITION, VSO-1665606
+        (void) _Left;
+        (void) _Right;
+#else // ^^^ workaround / no workaround vvv
+
+        // Per N4950 [counted.iterator]/3, two counted_iterators x and y refer to elements of the same sequence iff
+        // for some integer n, next(x.base(), x.count() + n) and next(y.base(), y.count() + n)
+        // "refer to the same (possibly past-the-end) element".
+        // Iterator equality is a fair proxy for the vaguely-defined "refer to the same element".
+        if constexpr (forward_iterator<_Iter> && forward_iterator<_Other>) {
+            using _CIter = common_type_t<_Iter, _Other>;
+            using _CDiff = common_type_t<iter_difference_t<_Iter>, iter_difference_t<_Other>>;
+
+            const _CDiff _Diff = static_cast<_CDiff>(_Left._Length) - static_cast<_CDiff>(_Right.count());
+            if (_Diff < 0) {
+                _STL_VERIFY(
+                    static_cast<_CIter>(_Left._Current) == _RANGES next(static_cast<_CIter>(_Right.base()), -_Diff),
+                    "counted_iterators are from different ranges");
+            } else {
+                _STL_VERIFY(
+                    _RANGES next(static_cast<_CIter>(_Left._Current), _Diff) == static_cast<_CIter>(_Right.base()),
+                    "counted_iterators are from different ranges");
+            }
+        }
+#endif // ^^^ no workaround ^^^
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+    template <common_with<_Iter> _Other>
+    friend constexpr void _Verify_range(const counted_iterator& _Left, const counted_iterator<_Other>& _Right) {
+        if constexpr (_Range_verifiable_v<_Iter, _Other>) {
+            _Verify_range(_Left._Current, _Right.base());
+        }
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _Same_sequence(_Left, _Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    constexpr void _Verify_offset(const iter_difference_t<_Iter> _Off) const {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off <= _Length, "Offset larger than counted_iterator length");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Offset_verifiable_v<_Iter>) {
+            _Current._Verify_offset(_Off);
+        }
+    }
+
+    using _Prevent_inheriting_unwrap = counted_iterator;
+
+    _NODISCARD constexpr counted_iterator<_Unwrapped_t<const _Iter&>> _Unwrapped() const& noexcept(
+        noexcept(counted_iterator<_Unwrapped_t<const _Iter&>>{_Current._Unwrapped(), _Length}))
+        requires _Unwrappable_v<const _Iter&>
+    {
+        return counted_iterator<_Unwrapped_t<const _Iter&>>{_Current._Unwrapped(), _Length};
+    }
+
+    _NODISCARD constexpr counted_iterator<_Unwrapped_t<_Iter>> _Unwrapped() && noexcept(
+        noexcept(counted_iterator<_Unwrapped_t<_Iter>>{_STD move(_Current)._Unwrapped(), _Length}))
+        requires _Unwrappable_v<_Iter>
+    {
+        return counted_iterator<_Unwrapped_t<_Iter>>{_STD move(_Current)._Unwrapped(), _Length};
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_Iter>;
+
+    template <class _Other>
+        requires _Wrapped_seekable_v<_Iter, const _Other&>
+    constexpr void _Seek_to(const counted_iterator<_Other>& _It) {
+        _Current._Seek_to(_It.base());
+        _Length = _It.count();
+    }
+
+    template <class _Other>
+        requires _Wrapped_seekable_v<_Iter, _Other>
+    constexpr void _Seek_to(counted_iterator<_Other>&& _It) {
+        _Current._Seek_to(_STD move(_It).base());
+        _Length = _It.count();
+    }
+
+private:
+    _Iter _Current{};
+    iter_difference_t<_Iter> _Length = 0;
+};
+
+template <input_iterator _Iter>
+    requires (!_Is_from_primary<iterator_traits<_Iter>>)
+struct iterator_traits<counted_iterator<_Iter>> : iterator_traits<_Iter> {
+    using pointer = conditional_t<contiguous_iterator<_Iter>, add_pointer_t<iter_reference_t<_Iter>>, void>;
+};
+#endif // _HAS_CXX20
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _ITERATOR_
diff --git a/msvc-stl/stl/inc/latch b/msvc-stl/stl/inc/latch
new file mode 100644
index 0000000..bea8aa7
--- /dev/null
+++ b/msvc-stl/stl/inc/latch
@@ -0,0 +1,100 @@
+// latch standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _LATCH_
+#define _LATCH_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <latch> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <latch> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+
+#include <atomic>
+#include <climits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_EXPORT_STD class latch {
+public:
+    _NODISCARD static constexpr ptrdiff_t(max)() noexcept {
+        return PTRDIFF_MAX;
+    }
+
+    constexpr explicit latch(const ptrdiff_t _Expected) noexcept /* strengthened */ : _Counter{_Expected} {
+        _STL_VERIFY(_Expected >= 0, "Precondition: expected >= 0 (N4950 [thread.latch.class]/4)");
+    }
+
+    latch(const latch&)            = delete;
+    latch& operator=(const latch&) = delete;
+
+    void count_down(const ptrdiff_t _Update = 1) noexcept /* strengthened */ {
+        _STL_VERIFY(_Update >= 0, "Precondition: update >= 0 (N4950 [thread.latch.class]/7)");
+        // TRANSITION, GH-1133: should be memory_order_release
+        const ptrdiff_t _Current = _Counter.fetch_sub(_Update) - _Update;
+        if (_Current == 0) {
+            _Counter.notify_all();
+        } else {
+            _STL_VERIFY(_Current >= 0, "Precondition: update <= counter (N4950 [thread.latch.class]/7)");
+        }
+    }
+
+    _NODISCARD_TRY_WAIT bool try_wait() const noexcept {
+        // TRANSITION, GH-1133: should be memory_order_acquire
+        return _Counter.load() == 0;
+    }
+
+    void wait() const noexcept /* strengthened */ {
+        for (;;) {
+            // TRANSITION, GH-1133: should be memory_order_acquire
+            const ptrdiff_t _Current = _Counter.load();
+            if (_Current == 0) {
+                return;
+            } else {
+                _STL_VERIFY(_Current > 0, "Invariant counter >= 0, possibly caused by preconditions violation "
+                                          "(N4950 [thread.latch.class]/7)");
+            }
+            _Counter.wait(_Current, memory_order_relaxed);
+        }
+    }
+
+    void arrive_and_wait(const ptrdiff_t _Update = 1) noexcept /* strengthened */ {
+        _STL_VERIFY(_Update >= 0, "Precondition: update >= 0 (N4950 [thread.latch.class]/7)");
+        // TRANSITION, GH-1133: should be memory_order_acq_rel
+        const ptrdiff_t _Current = _Counter.fetch_sub(_Update) - _Update;
+        if (_Current == 0) {
+            _Counter.notify_all();
+        } else {
+            _STL_VERIFY(_Current > 0, "Precondition: update <= counter (N4950 [thread.latch.class]/7)");
+            _Counter.wait(_Current, memory_order_relaxed);
+            wait();
+        }
+    }
+
+private:
+    atomic<ptrdiff_t> _Counter;
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _LATCH_
diff --git a/msvc-stl/stl/inc/limits b/msvc-stl/stl/inc/limits
new file mode 100644
index 0000000..38e71fc
--- /dev/null
+++ b/msvc-stl/stl/inc/limits
@@ -0,0 +1,1020 @@
+// limits standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _LIMITS_
+#define _LIMITS_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cfloat>
+#include <climits>
+#include <cwchar> // TRANSITION, see GH-3631: Lots of user code assumes that <limits> drags in <cwchar>
+#include <xtr1common>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+// constants for different IEEE float denormalization styles
+_EXPORT_STD enum _CXX23_DEPRECATE_DENORM float_denorm_style {
+    denorm_indeterminate = -1,
+    denorm_absent        = 0,
+    denorm_present       = 1
+};
+
+_EXPORT_STD enum float_round_style { // constants for different IEEE rounding styles
+    round_indeterminate       = -1,
+    round_toward_zero         = 0,
+    round_to_nearest          = 1,
+    round_toward_infinity     = 2,
+    round_toward_neg_infinity = 3
+};
+
+struct _Num_base { // base for all types, with common defaults
+    _STL_DISABLE_DEPRECATED_WARNING
+    _CXX23_DEPRECATE_DENORM static constexpr float_denorm_style has_denorm = denorm_absent;
+    _CXX23_DEPRECATE_DENORM static constexpr bool has_denorm_loss          = false;
+    _STL_RESTORE_DEPRECATED_WARNING
+
+    static constexpr bool has_infinity             = false;
+    static constexpr bool has_quiet_NaN            = false;
+    static constexpr bool has_signaling_NaN        = false;
+    static constexpr bool is_bounded               = false;
+    static constexpr bool is_exact                 = false;
+    static constexpr bool is_iec559                = false;
+    static constexpr bool is_integer               = false;
+    static constexpr bool is_modulo                = false;
+    static constexpr bool is_signed                = false;
+    static constexpr bool is_specialized           = false;
+    static constexpr bool tinyness_before          = false;
+    static constexpr bool traps                    = false;
+    static constexpr float_round_style round_style = round_toward_zero;
+    static constexpr int digits                    = 0;
+    static constexpr int digits10                  = 0;
+    static constexpr int max_digits10              = 0;
+    static constexpr int max_exponent              = 0;
+    static constexpr int max_exponent10            = 0;
+    static constexpr int min_exponent              = 0;
+    static constexpr int min_exponent10            = 0;
+    static constexpr int radix                     = 0;
+};
+
+_EXPORT_STD template <class _Ty>
+class numeric_limits : public _Num_base { // numeric limits for arbitrary type _Ty (say little or nothing)
+public:
+    _NODISCARD static constexpr _Ty(min)() noexcept {
+        return _Ty();
+    }
+
+    _NODISCARD static constexpr _Ty(max)() noexcept {
+        return _Ty();
+    }
+
+    _NODISCARD static constexpr _Ty lowest() noexcept {
+        return _Ty();
+    }
+
+    _NODISCARD static constexpr _Ty epsilon() noexcept {
+        return _Ty();
+    }
+
+    _NODISCARD static constexpr _Ty round_error() noexcept {
+        return _Ty();
+    }
+
+    _NODISCARD static constexpr _Ty denorm_min() noexcept {
+        return _Ty();
+    }
+
+    _NODISCARD static constexpr _Ty infinity() noexcept {
+        return _Ty();
+    }
+
+    _NODISCARD static constexpr _Ty quiet_NaN() noexcept {
+        return _Ty();
+    }
+
+    _NODISCARD static constexpr _Ty signaling_NaN() noexcept {
+        return _Ty();
+    }
+};
+
+template <class _Ty>
+class numeric_limits<const _Ty> : public numeric_limits<_Ty> {}; // numeric limits for const types
+
+template <class _Ty>
+class numeric_limits<volatile _Ty> : public numeric_limits<_Ty> {}; // numeric limits for volatile types
+
+template <class _Ty>
+class numeric_limits<const volatile _Ty> : public numeric_limits<_Ty> {}; // numeric limits for const volatile types
+
+struct _Num_int_base : _Num_base { // base for integer types
+    static constexpr bool is_bounded     = true;
+    static constexpr bool is_exact       = true;
+    static constexpr bool is_integer     = true;
+    static constexpr bool is_specialized = true;
+#if !defined(__clang__) || (defined(_M_X64) && !defined(_M_ARM64EC)) || defined(_M_IX86)
+    static constexpr bool traps = true;
+#endif
+    static constexpr int radix = 2;
+};
+
+struct _Num_float_base : _Num_base { // base for floating-point types
+    _STL_DISABLE_DEPRECATED_WARNING
+    _CXX23_DEPRECATE_DENORM static constexpr float_denorm_style has_denorm = denorm_present;
+    _STL_RESTORE_DEPRECATED_WARNING
+
+    static constexpr bool has_infinity             = true;
+    static constexpr bool has_quiet_NaN            = true;
+    static constexpr bool has_signaling_NaN        = true;
+    static constexpr bool is_bounded               = true;
+    static constexpr bool is_iec559                = true;
+    static constexpr bool is_signed                = true;
+    static constexpr bool is_specialized           = true;
+    static constexpr float_round_style round_style = round_to_nearest;
+    static constexpr int radix                     = FLT_RADIX;
+};
+
+template <>
+class numeric_limits<bool> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr bool(min)() noexcept {
+        return false;
+    }
+
+    _NODISCARD static constexpr bool(max)() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr bool epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr bool round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr bool denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr bool infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr bool quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr bool signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool traps = false;
+    static constexpr int digits = 1;
+};
+
+template <>
+class numeric_limits<char> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr char(min)() noexcept {
+        return CHAR_MIN;
+    }
+
+    _NODISCARD static constexpr char(max)() noexcept {
+        return CHAR_MAX;
+    }
+
+    _NODISCARD static constexpr char lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr char epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_signed = CHAR_MIN != 0;
+    static constexpr bool is_modulo = CHAR_MIN == 0;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 8 - (CHAR_MIN != 0);
+    static constexpr int digits10   = 2;
+};
+
+template <>
+class numeric_limits<signed char> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr signed char(min)() noexcept {
+        return SCHAR_MIN;
+    }
+
+    _NODISCARD static constexpr signed char(max)() noexcept {
+        return SCHAR_MAX;
+    }
+
+    _NODISCARD static constexpr signed char lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr signed char epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr signed char round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr signed char denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr signed char infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr signed char quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr signed char signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_signed = true;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 7;
+    static constexpr int digits10   = 2;
+};
+
+template <>
+class numeric_limits<unsigned char> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr unsigned char(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned char(max)() noexcept {
+        return UCHAR_MAX;
+    }
+
+    _NODISCARD static constexpr unsigned char lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr unsigned char epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned char round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned char denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned char infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned char quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned char signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 8;
+    static constexpr int digits10   = 2;
+};
+
+#ifdef __cpp_char8_t
+template <>
+class numeric_limits<char8_t> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr char8_t(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char8_t(max)() noexcept {
+        return UCHAR_MAX;
+    }
+
+    _NODISCARD static constexpr char8_t lowest() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char8_t epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char8_t round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char8_t denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char8_t infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char8_t quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char8_t signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 8;
+    static constexpr int digits10   = 2;
+};
+#endif // defined(__cpp_char8_t)
+
+template <>
+class numeric_limits<char16_t> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr char16_t(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char16_t(max)() noexcept {
+        return USHRT_MAX;
+    }
+
+    _NODISCARD static constexpr char16_t lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr char16_t epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char16_t round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char16_t denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char16_t infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char16_t quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char16_t signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 16;
+    static constexpr int digits10   = 4;
+};
+
+template <>
+class numeric_limits<char32_t> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr char32_t(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char32_t(max)() noexcept {
+        return UINT_MAX;
+    }
+
+    _NODISCARD static constexpr char32_t lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr char32_t epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char32_t round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char32_t denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char32_t infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char32_t quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr char32_t signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 32;
+    static constexpr int digits10   = 9;
+};
+
+template <>
+class numeric_limits<wchar_t> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr wchar_t(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr wchar_t(max)() noexcept {
+        return 0xffff;
+    }
+
+    _NODISCARD static constexpr wchar_t lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr wchar_t epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr wchar_t round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr wchar_t denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr wchar_t infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr wchar_t quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr wchar_t signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 16;
+    static constexpr int digits10   = 4;
+};
+
+template <>
+class numeric_limits<short> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr short(min)() noexcept {
+        return SHRT_MIN;
+    }
+
+    _NODISCARD static constexpr short(max)() noexcept {
+        return SHRT_MAX;
+    }
+
+    _NODISCARD static constexpr short lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr short epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr short round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr short denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr short infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr short quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr short signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_signed = true;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 15;
+    static constexpr int digits10   = 4;
+};
+
+template <>
+class numeric_limits<int> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr int(min)() noexcept {
+        return INT_MIN;
+    }
+
+    _NODISCARD static constexpr int(max)() noexcept {
+        return INT_MAX;
+    }
+
+    _NODISCARD static constexpr int lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr int epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr int round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr int denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr int infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr int quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr int signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_signed = true;
+    static constexpr int digits     = 31;
+    static constexpr int digits10   = 9;
+};
+
+template <>
+class numeric_limits<long> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr long(min)() noexcept {
+        return LONG_MIN;
+    }
+
+    _NODISCARD static constexpr long(max)() noexcept {
+        return LONG_MAX;
+    }
+
+    _NODISCARD static constexpr long lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr long epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static_assert(sizeof(int) == sizeof(long), "LLP64 assumption");
+    static constexpr bool is_signed = true;
+    static constexpr int digits     = 31;
+    static constexpr int digits10   = 9;
+};
+
+template <>
+class numeric_limits<long long> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr long long(min)() noexcept {
+        return LLONG_MIN;
+    }
+
+    _NODISCARD static constexpr long long(max)() noexcept {
+        return LLONG_MAX;
+    }
+
+    _NODISCARD static constexpr long long lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr long long epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long long round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long long denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long long infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long long quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr long long signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_signed = true;
+    static constexpr int digits     = 63;
+    static constexpr int digits10   = 18;
+};
+
+#ifdef _NATIVE_WCHAR_T_DEFINED
+template <>
+class numeric_limits<unsigned short> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr unsigned short(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned short(max)() noexcept {
+        return USHRT_MAX;
+    }
+
+    _NODISCARD static constexpr unsigned short lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr unsigned short epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned short round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned short denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned short infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned short quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned short signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr bool traps     = false;
+    static constexpr int digits     = 16;
+    static constexpr int digits10   = 4;
+};
+#endif // _NATIVE_WCHAR_T_DEFINED
+
+template <>
+class numeric_limits<unsigned int> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr unsigned int(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned int(max)() noexcept {
+        return UINT_MAX;
+    }
+
+    _NODISCARD static constexpr unsigned int lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr unsigned int epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned int round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned int denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned int infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned int quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned int signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr int digits     = 32;
+    static constexpr int digits10   = 9;
+};
+
+template <>
+class numeric_limits<unsigned long> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr unsigned long(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long(max)() noexcept {
+        return ULONG_MAX;
+    }
+
+    _NODISCARD static constexpr unsigned long lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr unsigned long epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static_assert(sizeof(unsigned int) == sizeof(unsigned long), "LLP64 assumption");
+    static constexpr bool is_modulo = true;
+    static constexpr int digits     = 32;
+    static constexpr int digits10   = 9;
+};
+
+template <>
+class numeric_limits<unsigned long long> : public _Num_int_base {
+public:
+    _NODISCARD static constexpr unsigned long long(min)() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long long(max)() noexcept {
+        return ULLONG_MAX;
+    }
+
+    _NODISCARD static constexpr unsigned long long lowest() noexcept {
+        return (min) ();
+    }
+
+    _NODISCARD static constexpr unsigned long long epsilon() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long long round_error() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long long denorm_min() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long long infinity() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long long quiet_NaN() noexcept {
+        return 0;
+    }
+
+    _NODISCARD static constexpr unsigned long long signaling_NaN() noexcept {
+        return 0;
+    }
+
+    static constexpr bool is_modulo = true;
+    static constexpr int digits     = 64;
+    static constexpr int digits10   = 19;
+};
+
+template <>
+class numeric_limits<float> : public _Num_float_base {
+public:
+    _NODISCARD static constexpr float(min)() noexcept {
+        return FLT_MIN;
+    }
+
+    _NODISCARD static constexpr float(max)() noexcept {
+        return FLT_MAX;
+    }
+
+    _NODISCARD static constexpr float lowest() noexcept {
+        return -(max) ();
+    }
+
+    _NODISCARD static constexpr float epsilon() noexcept {
+        return FLT_EPSILON;
+    }
+
+    _NODISCARD static constexpr float round_error() noexcept {
+        return 0.5F;
+    }
+
+    _NODISCARD static constexpr float denorm_min() noexcept {
+        return FLT_TRUE_MIN;
+    }
+
+    _STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED
+    _NODISCARD static constexpr float infinity() noexcept {
+        return __builtin_huge_valf();
+    }
+
+    _NODISCARD static constexpr float quiet_NaN() noexcept {
+        return __builtin_nanf("0");
+    }
+
+    _NODISCARD static constexpr float signaling_NaN() noexcept {
+        return __builtin_nansf("1");
+    }
+    _STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED
+
+    static constexpr int digits         = FLT_MANT_DIG;
+    static constexpr int digits10       = FLT_DIG;
+    static constexpr int max_digits10   = 9;
+    static constexpr int max_exponent   = FLT_MAX_EXP;
+    static constexpr int max_exponent10 = FLT_MAX_10_EXP;
+    static constexpr int min_exponent   = FLT_MIN_EXP;
+    static constexpr int min_exponent10 = FLT_MIN_10_EXP;
+};
+
+template <>
+class numeric_limits<double> : public _Num_float_base {
+public:
+    _NODISCARD static constexpr double(min)() noexcept {
+        return DBL_MIN;
+    }
+
+    _NODISCARD static constexpr double(max)() noexcept {
+        return DBL_MAX;
+    }
+
+    _NODISCARD static constexpr double lowest() noexcept {
+        return -(max) ();
+    }
+
+    _NODISCARD static constexpr double epsilon() noexcept {
+        return DBL_EPSILON;
+    }
+
+    _NODISCARD static constexpr double round_error() noexcept {
+        return 0.5;
+    }
+
+    _NODISCARD static constexpr double denorm_min() noexcept {
+        return DBL_TRUE_MIN;
+    }
+
+    _STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED
+    _NODISCARD static constexpr double infinity() noexcept {
+        return __builtin_huge_val();
+    }
+
+    _NODISCARD static constexpr double quiet_NaN() noexcept {
+        return __builtin_nan("0");
+    }
+
+    _NODISCARD static constexpr double signaling_NaN() noexcept {
+        return __builtin_nans("1");
+    }
+    _STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED
+
+    static constexpr int digits         = DBL_MANT_DIG;
+    static constexpr int digits10       = DBL_DIG;
+    static constexpr int max_digits10   = 17;
+    static constexpr int max_exponent   = DBL_MAX_EXP;
+    static constexpr int max_exponent10 = DBL_MAX_10_EXP;
+    static constexpr int min_exponent   = DBL_MIN_EXP;
+    static constexpr int min_exponent10 = DBL_MIN_10_EXP;
+};
+
+template <>
+class numeric_limits<long double> : public _Num_float_base {
+public:
+    _NODISCARD static constexpr long double(min)() noexcept {
+        return LDBL_MIN;
+    }
+
+    _NODISCARD static constexpr long double(max)() noexcept {
+        return LDBL_MAX;
+    }
+
+    _NODISCARD static constexpr long double lowest() noexcept {
+        return -(max) ();
+    }
+
+    _NODISCARD static constexpr long double epsilon() noexcept {
+        return LDBL_EPSILON;
+    }
+
+    _NODISCARD static constexpr long double round_error() noexcept {
+        return 0.5L;
+    }
+
+    _NODISCARD static constexpr long double denorm_min() noexcept {
+        return LDBL_TRUE_MIN;
+    }
+
+    _STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED
+    _NODISCARD static constexpr long double infinity() noexcept {
+        return __builtin_huge_val();
+    }
+
+    _NODISCARD static constexpr long double quiet_NaN() noexcept {
+        return __builtin_nan("0");
+    }
+
+    _NODISCARD static constexpr long double signaling_NaN() noexcept {
+        return __builtin_nans("1");
+    }
+    _STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED
+
+    static constexpr int digits         = LDBL_MANT_DIG;
+    static constexpr int digits10       = LDBL_DIG;
+    static constexpr int max_digits10   = 2 + LDBL_MANT_DIG * 301L / 1000;
+    static constexpr int max_exponent   = LDBL_MAX_EXP;
+    static constexpr int max_exponent10 = LDBL_MAX_10_EXP;
+    static constexpr int min_exponent   = LDBL_MIN_EXP;
+    static constexpr int min_exponent10 = LDBL_MIN_10_EXP;
+};
+
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _LIMITS_
diff --git a/msvc-stl/stl/inc/list b/msvc-stl/stl/inc/list
new file mode 100644
index 0000000..0fa804f
--- /dev/null
+++ b/msvc-stl/stl/inc/list
@@ -0,0 +1,1953 @@
+// list standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _LIST_
+#define _LIST_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xmemory>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Mylist, class _Base = _Iterator_base0>
+class _List_unchecked_const_iterator : public _Base {
+public:
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mylist::_Nodeptr;
+    using value_type      = typename _Mylist::value_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::const_pointer;
+    using reference       = const value_type&;
+
+    _List_unchecked_const_iterator() noexcept : _Ptr() {}
+
+    _List_unchecked_const_iterator(_Nodeptr _Pnode, const _Mylist* _Plist) noexcept : _Ptr(_Pnode) {
+        this->_Adopt(_Plist);
+    }
+
+    _NODISCARD reference operator*() const noexcept {
+        return _Ptr->_Myval;
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _List_unchecked_const_iterator& operator++() noexcept {
+        _Ptr = _Ptr->_Next;
+        return *this;
+    }
+
+    _List_unchecked_const_iterator operator++(int) noexcept {
+        _List_unchecked_const_iterator _Tmp = *this;
+        _Ptr                                = _Ptr->_Next;
+        return _Tmp;
+    }
+
+    _List_unchecked_const_iterator& operator--() noexcept {
+        _Ptr = _Ptr->_Prev;
+        return *this;
+    }
+
+    _List_unchecked_const_iterator operator--(int) noexcept {
+        _List_unchecked_const_iterator _Tmp = *this;
+        _Ptr                                = _Ptr->_Prev;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const _List_unchecked_const_iterator& _Right) const noexcept {
+        return _Ptr == _Right._Ptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const _List_unchecked_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _Nodeptr _Ptr; // pointer to node
+};
+
+template <class _Mylist>
+class _List_unchecked_iterator : public _List_unchecked_const_iterator<_Mylist> {
+public:
+    using _Mybase           = _List_unchecked_const_iterator<_Mylist>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mylist::_Nodeptr;
+    using value_type      = typename _Mylist::value_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::pointer;
+    using reference       = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _List_unchecked_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _List_unchecked_iterator operator++(int) noexcept {
+        _List_unchecked_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _List_unchecked_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _List_unchecked_iterator operator--(int) noexcept {
+        _List_unchecked_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+};
+
+template <class _Mylist>
+class _List_const_iterator : public _List_unchecked_const_iterator<_Mylist, _Iterator_base> {
+public:
+    using _Mybase           = _List_unchecked_const_iterator<_Mylist, _Iterator_base>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mylist::_Nodeptr;
+    using value_type      = typename _Mylist::value_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::const_pointer;
+    using reference       = const value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Mycont = static_cast<const _Mylist*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot dereference value-initialized list iterator");
+        _STL_VERIFY(this->_Ptr != _Mycont->_Myhead, "cannot dereference end list iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return this->_Ptr->_Myval;
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _List_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Mycont = static_cast<const _Mylist*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot increment value-initialized list iterator");
+        _STL_VERIFY(this->_Ptr != _Mycont->_Myhead, "cannot increment end list iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        this->_Ptr = this->_Ptr->_Next;
+        return *this;
+    }
+
+    _List_const_iterator operator++(int) noexcept {
+        _List_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _List_const_iterator& operator--() noexcept {
+        const auto _New_ptr = this->_Ptr->_Prev;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Mycont = static_cast<const _Mylist*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot decrement value-initialized list iterator");
+        _STL_VERIFY(_New_ptr != _Mycont->_Myhead, "cannot decrement begin list iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        this->_Ptr = _New_ptr;
+        return *this;
+    }
+
+    _List_const_iterator operator--(int) noexcept {
+        _List_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const _List_const_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "list iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return this->_Ptr == _Right._Ptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const _List_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    friend void _Verify_range(const _List_const_iterator& _First, const _List_const_iterator& _Last) noexcept {
+        _STL_VERIFY(_First._Getcont() == _Last._Getcont(), "list iterators in range are from different containers");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    using _Prevent_inheriting_unwrap = _List_const_iterator;
+
+    _NODISCARD _List_unchecked_const_iterator<_Mylist> _Unwrapped() const noexcept {
+        return _List_unchecked_const_iterator<_Mylist>(this->_Ptr, static_cast<const _Mylist*>(this->_Getcont()));
+    }
+
+    void _Seek_to(const _List_unchecked_const_iterator<_Mylist> _It) noexcept {
+        this->_Ptr = _It._Ptr;
+    }
+};
+
+template <class _Mylist>
+class _List_iterator : public _List_const_iterator<_Mylist> {
+public:
+    using _Mybase           = _List_const_iterator<_Mylist>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mylist::_Nodeptr;
+    using value_type      = typename _Mylist::value_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::pointer;
+    using reference       = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _List_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _List_iterator operator++(int) noexcept {
+        _List_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _List_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _List_iterator operator--(int) noexcept {
+        _List_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    using _Prevent_inheriting_unwrap = _List_iterator;
+
+    _NODISCARD _List_unchecked_iterator<_Mylist> _Unwrapped() const noexcept {
+        return _List_unchecked_iterator<_Mylist>(this->_Ptr, static_cast<const _Mylist*>(this->_Getcont()));
+    }
+};
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
+    class _Nodeptr_type>
+struct _List_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+    using _Nodeptr        = _Nodeptr_type;
+};
+
+template <class _Value_type, class _Voidptr>
+struct _List_node { // list node
+    using value_type = _Value_type;
+    using _Nodeptr   = _Rebind_pointer_t<_Voidptr, _List_node>;
+    _Nodeptr _Next; // successor node, or first element if head
+    _Nodeptr _Prev; // predecessor node, or last element if head
+    _Value_type _Myval = // the stored value, unused if head
+        _Returns_exactly<_Value_type>(); // fake a viable constructor to workaround GH-2749
+
+    _List_node()                             = default;
+    _List_node(const _List_node&)            = delete;
+    _List_node& operator=(const _List_node&) = delete;
+
+    template <class _Alnode>
+    static _Nodeptr _Buyheadnode(_Alnode& _Al) {
+        const auto _Result = _Al.allocate(1);
+        _Construct_in_place(_Result->_Next, _Result);
+        _Construct_in_place(_Result->_Prev, _Result);
+        return _Result;
+    }
+
+    template <class _Alnode>
+    static void _Freenode0(_Alnode& _Al, _Nodeptr _Ptr) noexcept {
+        // destroy pointer members in _Ptr and deallocate with _Al
+        static_assert(is_same_v<typename _Alnode::value_type, _List_node>, "Bad _Freenode0 call");
+        _Destroy_in_place(_Ptr->_Next);
+        _Destroy_in_place(_Ptr->_Prev);
+        allocator_traits<_Alnode>::deallocate(_Al, _Ptr, 1);
+    }
+
+    template <class _Alnode>
+    static void _Freenode(_Alnode& _Al, _Nodeptr _Ptr) noexcept { // destroy all members in _Ptr and deallocate with _Al
+        allocator_traits<_Alnode>::destroy(_Al, _STD addressof(_Ptr->_Myval));
+        _Freenode0(_Al, _Ptr);
+    }
+
+    template <class _Alnode>
+    static void _Free_non_head(
+        _Alnode& _Al, _Nodeptr _Head) noexcept { // free a list starting at _First and terminated at nullptr
+        _Head->_Prev->_Next = nullptr;
+
+        auto _Pnode = _Head->_Next;
+        for (_Nodeptr _Pnext; _Pnode; _Pnode = _Pnext) {
+            _Pnext = _Pnode->_Next;
+            _Freenode(_Al, _Pnode);
+        }
+    }
+};
+
+template <class _Ty>
+struct _List_simple_types : _Simple_types<_Ty> {
+    using _Node    = _List_node<_Ty, void*>;
+    using _Nodeptr = _Node*;
+};
+
+template <class _Val_types>
+class _List_val : public _Container_base {
+public:
+    using _Nodeptr = typename _Val_types::_Nodeptr;
+
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    _List_val() noexcept : _Myhead(), _Mysize(0) {} // initialize data
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    ~_List_val() noexcept {
+        if constexpr (is_pointer_v<_Nodeptr>) {
+            const auto _Tombstone{reinterpret_cast<_Nodeptr>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+            _Myhead = _Tombstone;
+            _Mysize = 0;
+        }
+    }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+
+    void _Orphan_ptr2(_Nodeptr _Ptr) noexcept { // orphan iterators with specified node pointers
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
+        const auto _Head          = _Myhead;
+        while (*_Pnext) {
+            _Iterator_base12** _Pnextnext = &(*_Pnext)->_Mynextiter;
+            const auto _Pnextptr          = static_cast<_List_const_iterator<_List_val>&>(**_Pnext)._Ptr;
+            if (_Pnextptr == _Head || _Pnextptr != _Ptr) {
+                // iterator is end() or doesn't point at the one we are orphaning, move on
+                _Pnext = _Pnextnext;
+            } else { // orphan the iterator
+                (*_Pnext)->_Myproxy = nullptr;
+                *_Pnext             = *_Pnextnext;
+            }
+        }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+        (void) _Ptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+    }
+
+    void _Orphan_non_end() noexcept { // orphan iterators except end()
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
+        const auto _Head          = _Myhead;
+        while (*_Pnext) {
+            _Iterator_base12** _Pnextnext = &(*_Pnext)->_Mynextiter;
+            if (static_cast<_List_const_iterator<_List_val>&>(**_Pnext)._Ptr == _Head) { // iterator is end(), move on
+                _Pnext = _Pnextnext;
+            } else { // orphan the iterator
+                (*_Pnext)->_Myproxy = nullptr;
+                *_Pnext             = *_Pnextnext;
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+    }
+
+    _Nodeptr _Unlinknode(_Nodeptr _Pnode) noexcept { // unlink node at _Where from the list
+        _Orphan_ptr2(_Pnode);
+        _Pnode->_Prev->_Next = _Pnode->_Next;
+        _Pnode->_Next->_Prev = _Pnode->_Prev;
+        --_Mysize;
+        return _Pnode;
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    void _Adopt_unique(_List_val& _Other, _Nodeptr _Pnode) noexcept {
+        // adopt iterators pointing to the spliced node
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &_Other._Myproxy->_Myfirstiter;
+        const auto _Myproxy       = this->_Myproxy;
+        while (*_Pnext) {
+            auto& _Iter = static_cast<_List_const_iterator<_List_val>&>(**_Pnext);
+            if (_Iter._Ptr == _Pnode) { // adopt the iterator
+                *_Pnext                = _Iter._Mynextiter;
+                _Iter._Myproxy         = _Myproxy;
+                _Iter._Mynextiter      = _Myproxy->_Myfirstiter;
+                _Myproxy->_Myfirstiter = _STD addressof(_Iter);
+            } else { // skip the iterator
+                _Pnext = &_Iter._Mynextiter;
+            }
+        }
+    }
+
+    void _Adopt_all(_List_val& _Other) noexcept {
+        // adopt all iterators (except _Other.end())
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &_Other._Myproxy->_Myfirstiter;
+        const auto _Myproxy       = this->_Myproxy;
+        const auto _Otherhead     = _Other._Myhead;
+        while (*_Pnext) {
+            auto& _Iter = static_cast<_List_const_iterator<_List_val>&>(**_Pnext);
+            if (_Iter._Ptr != _Otherhead) { // adopt the iterator
+                *_Pnext                = _Iter._Mynextiter;
+                _Iter._Myproxy         = _Myproxy;
+                _Iter._Mynextiter      = _Myproxy->_Myfirstiter;
+                _Myproxy->_Myfirstiter = _STD addressof(_Iter);
+            } else { // skip the iterator
+                _Pnext = &_Iter._Mynextiter;
+            }
+        }
+    }
+
+    void _Adopt_range(_List_val& _Other, const _Nodeptr _First, const _Nodeptr _Last) noexcept {
+        // adopt all iterators pointing to nodes in the "range" [_First, _Last) by marking nodes
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &_Other._Myproxy->_Myfirstiter;
+        const auto _Myproxy       = this->_Myproxy;
+        _Nodeptr _Oldprev         = _First->_Prev;
+        for (_Nodeptr _Ptr = _First; _Ptr != _Last; _Ptr = _Ptr->_Next) { // mark _Prev pointers
+            _Ptr->_Prev = nullptr;
+        }
+
+        while (*_Pnext) { // check the iterator
+            auto& _Iter = static_cast<_List_const_iterator<_List_val>&>(**_Pnext);
+            if (_Iter._Ptr->_Prev) { // skip the iterator
+                _Pnext = &_Iter._Mynextiter;
+            } else { // adopt the iterator
+                *_Pnext                = _Iter._Mynextiter;
+                _Iter._Myproxy         = _Myproxy;
+                _Iter._Mynextiter      = _Myproxy->_Myfirstiter;
+                _Myproxy->_Myfirstiter = _STD addressof(_Iter);
+            }
+        }
+
+        for (_Nodeptr _Ptr = _First; _Ptr != _Last; _Ptr = _Ptr->_Next) { // restore _Prev pointers
+            _Ptr->_Prev = _Oldprev;
+            _Oldprev    = _Ptr;
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    static _Nodeptr _Unchecked_splice(const _Nodeptr _Before, const _Nodeptr _First, const _Nodeptr _Last) noexcept {
+        // splice [_First, _Last) before _Before; returns _Last
+        _STL_INTERNAL_CHECK(_Before != _First && _Before != _Last && _First != _Last);
+        // 3 reads and 6 writes
+
+        // fixup the _Next values
+        const auto _First_prev  = _First->_Prev;
+        _First_prev->_Next      = _Last;
+        const auto _Last_prev   = _Last->_Prev;
+        _Last_prev->_Next       = _Before;
+        const auto _Before_prev = _Before->_Prev;
+        _Before_prev->_Next     = _First;
+
+        // fixup the _Prev values
+        _Before->_Prev = _Last_prev;
+        _Last->_Prev   = _First_prev;
+        _First->_Prev  = _Before_prev;
+
+        return _Last;
+    }
+
+    static _Nodeptr _Unchecked_splice(const _Nodeptr _Before, const _Nodeptr _First) noexcept {
+        // splice [_First, _First->_Next) before _Before; returns _First->_Next
+        _STL_INTERNAL_CHECK(_Before != _First && _First->_Next != _Before);
+        // still 3 reads and 6 writes, but 1 less read if the caller was going to get _First->_Next
+        const auto _Last = _First->_Next;
+
+        // fixup the _Next values
+        const auto _First_prev = _First->_Prev;
+        _First_prev->_Next     = _Last;
+        // const auto _Last_prev = _First;
+        _First->_Next           = _Before;
+        const auto _Before_prev = _Before->_Prev;
+        _Before_prev->_Next     = _First;
+
+        // fixup the _Prev values
+        _Before->_Prev = _First;
+        _Last->_Prev   = _First_prev;
+        _First->_Prev  = _Before_prev;
+
+        return _Last;
+    }
+
+    template <class _Pr2>
+    static _Nodeptr _Merge_same(_Nodeptr _First, _Nodeptr _Mid, const _Nodeptr _Last, _Pr2 _Pred) {
+        // Merge the sorted ranges [_First, _Mid) and [_Mid, _Last)
+        // Returns the new beginning of the range (which won't be _First if it was spliced elsewhere)
+        _STL_INTERNAL_CHECK(_First != _Mid && _Mid != _Last);
+        _Nodeptr _Newfirst;
+        if (_DEBUG_LT_PRED(_Pred, _Mid->_Myval, _First->_Myval)) {
+            // _Mid will be spliced to the front of the range
+            _Newfirst = _Mid;
+        } else {
+            // Establish _Pred(_Mid->_Myval, _First->_Myval) by skipping over elements from the first
+            // range already in position.
+            _Newfirst = _First;
+            do {
+                _First = _First->_Next;
+                if (_First == _Mid) {
+                    return _Newfirst;
+                }
+            } while (!_DEBUG_LT_PRED(_Pred, _Mid->_Myval, _First->_Myval));
+        }
+
+        for (;;) { // process one run splice
+            auto _Run_start = _Mid;
+            do { // find the end of the "run" of elements we need to splice from the second range into the first
+                _Mid = _Mid->_Next;
+            } while (_Mid != _Last && _DEBUG_LT_PRED(_Pred, _Mid->_Myval, _First->_Myval));
+
+            // [_Run_start, _Mid) goes before _First->_Myval
+            _Unchecked_splice(_First, _Run_start, _Mid);
+            if (_Mid == _Last) {
+                return _Newfirst;
+            }
+
+            // Reestablish _Pred(_Mid->_Myval, _First->_Myval) by skipping over elements from the first
+            // range already in position.
+            do {
+                _First = _First->_Next;
+                if (_First == _Mid) {
+                    return _Newfirst;
+                }
+            } while (!_DEBUG_LT_PRED(_Pred, _Mid->_Myval, _First->_Myval));
+        }
+    }
+
+    template <class _Pr2>
+    static _Nodeptr _Sort(_Nodeptr& _First, const size_type _Size, _Pr2 _Pred) {
+        // order [_First, _First + _Size), return _First + _Size
+        switch (_Size) {
+        case 0:
+            return _First;
+        case 1:
+            return _First->_Next;
+        default:
+            break;
+        }
+
+        auto _Mid        = _Sort(_First, _Size / 2, _Pred);
+        const auto _Last = _Sort(_Mid, _Size - _Size / 2, _Pred);
+        _First           = _Merge_same(_First, _Mid, _Last, _Pred);
+        return _Last;
+    }
+
+    _Nodeptr _Myhead; // pointer to head node
+    size_type _Mysize; // number of elements
+};
+
+template <class _Alnode>
+struct _List_node_emplace_op2 : _Alloc_construct_ptr<_Alnode> {
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using pointer        = typename _Alnode_traits::pointer;
+
+    template <class... _Valtys>
+    explicit _List_node_emplace_op2(_Alnode& _Al_, _Valtys&&... _Vals) : _Alloc_construct_ptr<_Alnode>(_Al_) {
+        this->_Allocate();
+        _Alnode_traits::construct(this->_Al, _STD addressof(this->_Ptr->_Myval), _STD forward<_Valtys>(_Vals)...);
+    }
+
+    ~_List_node_emplace_op2() {
+        if (this->_Ptr != pointer{}) {
+            _Alnode_traits::destroy(this->_Al, _STD addressof(this->_Ptr->_Myval));
+        }
+    }
+
+    _List_node_emplace_op2(const _List_node_emplace_op2&)            = delete;
+    _List_node_emplace_op2& operator=(const _List_node_emplace_op2&) = delete;
+
+    pointer _Transfer_before(const pointer _Insert_before) noexcept {
+        const pointer _Insert_after = _Insert_before->_Prev;
+        _Construct_in_place(this->_Ptr->_Next, _Insert_before);
+        _Construct_in_place(this->_Ptr->_Prev, _Insert_after);
+        const auto _Result    = this->_Ptr;
+        this->_Ptr            = pointer{};
+        _Insert_before->_Prev = _Result;
+        _Insert_after->_Next  = _Result;
+        return _Result;
+    }
+};
+
+template <class _Alnode>
+struct _List_node_insert_op2 {
+    // list insert operation which maintains exception safety
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using pointer        = typename _Alnode_traits::pointer;
+    using size_type      = typename _Alnode_traits::size_type;
+    using value_type     = typename _Alnode_traits::value_type;
+
+    explicit _List_node_insert_op2(_Alnode& _Al_) : _Al(_Al_), _Added(0) {}
+
+    _List_node_insert_op2(const _List_node_insert_op2&)            = delete;
+    _List_node_insert_op2& operator=(const _List_node_insert_op2&) = delete;
+
+    template <class... _CArgT>
+    void _Append_n(size_type _Count, const _CArgT&... _Carg) {
+        // Append _Count elements constructed from _Carg
+        if (_Count <= 0) {
+            return;
+        }
+
+        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
+        if (_Added == 0) {
+            _Newnode._Allocate(); // throws
+            _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), _Carg...); // throws
+            _Head = _Newnode._Ptr;
+            _Tail = _Newnode._Ptr;
+            ++_Added;
+            --_Count;
+        }
+
+        for (; 0 < _Count; --_Count) {
+            _Newnode._Allocate(); // throws
+            _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), _Carg...); // throws
+            _Construct_in_place(_Tail->_Next, _Newnode._Ptr);
+            _Construct_in_place(_Newnode._Ptr->_Prev, _Tail);
+            _Tail = _Newnode._Ptr;
+            ++_Added;
+        }
+
+        _Newnode._Ptr = pointer{};
+    }
+
+    template <class _InIt, class _Sentinel>
+    void _Append_range_unchecked(_InIt _First, const _Sentinel _Last) {
+        // Append the values in [_First, _Last)
+        if (_First == _Last) { // throws
+            return;
+        }
+
+        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
+        if (_Added == 0) {
+            _Newnode._Allocate(); // throws
+            _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), *_First); // throws
+            const auto _Newhead = _STD exchange(_Newnode._Ptr, pointer{});
+            _Head               = _Newhead;
+            _Tail               = _Newhead;
+            ++_Added;
+            ++_First; // throws
+        }
+
+        while (_First != _Last) { // throws
+            _Newnode._Allocate(); // throws
+            _Alnode_traits::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), *_First); // throws
+            _Construct_in_place(_Tail->_Next, _Newnode._Ptr);
+            _Construct_in_place(_Newnode._Ptr->_Prev, _Tail);
+            _Tail = _STD exchange(_Newnode._Ptr, pointer{});
+            ++_Added;
+            ++_First; // throws
+        }
+    }
+
+    template <class _Val_types>
+    pointer _Attach_before(_List_val<_Val_types>& _List_data, const pointer _Insert_before) noexcept {
+        // Attach the elements in *this before _Insert_before.
+        // If *this is empty, returns _Insert_before; otherwise returns a pointer to the first inserted list node.
+        // Resets *this to the default-initialized state.
+
+        const auto _Local_added = _Added;
+        if (_Local_added == 0) {
+            return _Insert_before;
+        }
+
+        const auto _Local_head   = _Head;
+        const auto _Local_tail   = _Tail;
+        const auto _Insert_after = _Insert_before->_Prev;
+
+        _Construct_in_place(_Local_head->_Prev, _Insert_after);
+        _Insert_after->_Next = _Local_head;
+        _Construct_in_place(_Local_tail->_Next, _Insert_before);
+        _Insert_before->_Prev = _Local_tail;
+
+        _List_data._Mysize += _Local_added;
+        _Added = 0;
+        return _Local_head;
+    }
+
+    template <class _Val_types>
+    void _Attach_at_end(_List_val<_Val_types>& _List_data) noexcept {
+        _Attach_before(_List_data, _List_data._Myhead);
+    }
+
+    template <class _Val_types>
+    void _Attach_head(_List_val<_Val_types>& _List_data) {
+        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
+        _Newnode._Allocate(); // throws
+        const auto _Local_added = _STD exchange(_Added, size_type{0});
+        if (_Local_added == 0) {
+            _Construct_in_place(_Newnode._Ptr->_Next, _Newnode._Ptr);
+            _Construct_in_place(_Newnode._Ptr->_Prev, _Newnode._Ptr);
+        } else {
+            const auto _Local_head = _Head;
+            const auto _Local_tail = _Tail;
+            _Construct_in_place(_Newnode._Ptr->_Next, _Local_head);
+            _Construct_in_place(_Newnode._Ptr->_Prev, _Local_tail);
+            _Construct_in_place(_Local_head->_Prev, _Newnode._Ptr);
+            _Construct_in_place(_Local_tail->_Next, _Newnode._Ptr);
+        }
+
+        _List_data._Mysize = _Local_added;
+        _List_data._Myhead = _Newnode._Release();
+    }
+
+    ~_List_node_insert_op2() {
+        if (_Added == 0) {
+            return;
+        }
+
+        _Construct_in_place(_Head->_Prev, pointer{});
+        _Construct_in_place(_Tail->_Next, pointer{});
+        pointer _Subject = _Head;
+        while (_Subject) {
+            value_type::_Freenode(_Al, _STD exchange(_Subject, _Subject->_Next));
+        }
+    }
+
+private:
+    _Alnode& _Al;
+    size_type _Added; // if 0, the values of _Head and _Tail are indeterminate
+    pointer _Tail{}; // points to the most recently appended element; it doesn't have _Next constructed
+    pointer _Head{}; // points to the first appended element; it doesn't have _Prev constructed
+};
+
+template <class _Traits>
+class _Hash;
+
+struct _Move_allocator_tag {
+    explicit _Move_allocator_tag() = default;
+};
+
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
+class list { // bidirectional linked list
+private:
+    template <class>
+    friend class _Hash;
+    template <class _Traits>
+    friend bool _Hash_equal(const _Hash<_Traits>&, const _Hash<_Traits>&);
+
+    using _Alty          = _Rebind_alloc_t<_Alloc, _Ty>;
+    using _Alty_traits   = allocator_traits<_Alty>;
+    using _Node          = _List_node<_Ty, typename allocator_traits<_Alloc>::void_pointer>;
+    using _Alnode        = _Rebind_alloc_t<_Alloc, _Node>;
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using _Nodeptr       = typename _Alnode_traits::pointer;
+
+    using _Val_types = conditional_t<_Is_simple_alloc_v<_Alnode>, _List_simple_types<_Ty>,
+        _List_iter_types<_Ty, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
+            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Nodeptr>>;
+
+    using _Scary_val = _List_val<_Val_types>;
+
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Ty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("list<T, Allocator>", "T"));
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
+                                    "because of [container.requirements].");
+
+    using value_type      = _Ty;
+    using allocator_type  = _Alloc;
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using iterator                  = _List_iterator<_Scary_val>;
+    using const_iterator            = _List_const_iterator<_Scary_val>;
+    using _Unchecked_iterator       = _List_unchecked_iterator<_Scary_val>;
+    using _Unchecked_const_iterator = _List_unchecked_const_iterator<_Scary_val>;
+
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    list() : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Alloc_sentinel_and_proxy();
+    }
+
+    explicit list(const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Alloc_sentinel_and_proxy();
+    }
+
+private:
+    template <class _Tag, class _Any_alloc, enable_if_t<is_same_v<_Tag, _Move_allocator_tag>, int> = 0>
+    explicit list(_Tag, _Any_alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _STD move(_Al)) {
+        _Alloc_sentinel_and_proxy();
+    }
+
+    void _Construct_n(_CRT_GUARDOVERFLOW size_type _Count) {
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+        _List_node_insert_op2<_Alnode> _Appended(_Getal());
+        _Appended._Append_n(_Count);
+        _Appended._Attach_head(_Mypair._Myval2);
+        _Proxy._Release();
+    }
+
+public:
+    explicit list(_CRT_GUARDOVERFLOW size_type _Count)
+        : _Mypair(_Zero_then_variadic_args_t{}) { // construct list from _Count * _Ty()
+        _Construct_n(_Count);
+    }
+
+    explicit list(_CRT_GUARDOVERFLOW size_type _Count, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct list from _Count * _Ty(), with allocator
+        _Construct_n(_Count);
+    }
+
+private:
+    void _Construct_n(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) {
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+        _List_node_insert_op2<_Alnode> _Appended(_Getal());
+        _Appended._Append_n(_Count, _Val);
+        _Appended._Attach_head(_Mypair._Myval2);
+        _Proxy._Release();
+    }
+
+public:
+    list(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val)
+        : _Mypair(_Zero_then_variadic_args_t{}) { // construct list from _Count * _Val
+        _Construct_n(_Count, _Val);
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    list(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct list from _Count * _Val, allocator
+        _Construct_n(_Count, _Val);
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    void _Construct_range_unchecked(_Iter _First, const _Sent _Last) {
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+        _List_node_insert_op2<_Alnode> _Appended(_Getal());
+        _Appended._Append_range_unchecked(_STD move(_First), _Last);
+        _Appended._Attach_head(_Mypair._Myval2);
+        _Proxy._Release();
+    }
+
+public:
+    list(const list& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {
+        _Construct_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
+    }
+
+    list(const list& _Right, const _Identity_t<_Alloc>& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    list(_Iter _First, _Iter _Last) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Construct_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    list(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Construct_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    list(from_range_t, _Rng&& _Range) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    list(from_range_t, _Rng&& _Range, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    list(list&& _Right) noexcept(false) : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
+        _Alloc_sentinel_and_proxy();
+        _Swap_val(_Right);
+    }
+
+    list(list&& _Right, const _Identity_t<_Alloc>& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            if (_Getal() != _Right._Getal()) {
+                _Construct_range_unchecked(_STD make_move_iterator(_Right._Unchecked_begin()),
+                    _STD make_move_iterator(_Right._Unchecked_end()));
+                return;
+            }
+        }
+
+        _Alloc_sentinel_and_proxy();
+        _Swap_val(_Right);
+    }
+
+    list& operator=(list&& _Right) noexcept(_Alnode_traits::is_always_equal::value) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                auto _Alproxy       = _STD _Get_proxy_allocator(_Al);
+                auto _Right_alproxy = _STD _Get_proxy_allocator(_Right_al);
+                _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                auto& _My_data      = _Mypair._Myval2;
+                auto& _Right_data   = _Right._Mypair._Myval2;
+                const auto _Newhead = _STD exchange(_Right_data._Myhead, _Node::_Buyheadnode(_Right_al));
+                const auto _Newsize = _STD exchange(_Right_data._Mysize, size_type{0});
+                _Tidy();
+                _Pocma(_Al, _Right_al);
+                _My_data._Myhead = _Newhead;
+                _My_data._Mysize = _Newsize;
+                _Proxy._Bind(_Alproxy, _STD addressof(_My_data));
+                _My_data._Swap_proxy_and_iterators(_Right_data);
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                assign(_STD make_move_iterator(_Right._Unchecked_begin()),
+                    _STD make_move_iterator(_Right._Unchecked_end()));
+                return *this;
+            }
+        }
+
+        clear();
+        _Pocma(_Al, _Right_al);
+        _Swap_val(_Right);
+
+        return *this;
+    }
+
+private:
+    void _Swap_val(list& _Right) noexcept { // swap with _Right, same allocator
+        using _STD swap;
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _My_data._Swap_proxy_and_iterators(_Right_data);
+        swap(_My_data._Myhead, _Right_data._Myhead); // intentional ADL
+        _STD swap(_My_data._Mysize, _Right_data._Mysize);
+    }
+
+public:
+    void push_front(_Ty&& _Val) { // insert element at beginning
+        _Emplace(_Mypair._Myval2._Myhead->_Next, _STD move(_Val));
+    }
+
+    void push_back(_Ty&& _Val) { // insert element at end
+        _Emplace(_Mypair._Myval2._Myhead, _STD move(_Val));
+    }
+
+    iterator insert(const_iterator _Where, _Ty&& _Val) { // insert _Val at _Where
+        return emplace(_Where, _STD move(_Val));
+    }
+
+    template <class... _Valty>
+    _CONTAINER_EMPLACE_RETURN emplace_front(_Valty&&... _Val) { // insert element at beginning
+        reference _Result = _Emplace(_Mypair._Myval2._Myhead->_Next, _STD forward<_Valty>(_Val)...)->_Myval;
+
+#if _HAS_CXX17
+        return _Result;
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        (void) _Result;
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    template <class... _Valty>
+    _CONTAINER_EMPLACE_RETURN emplace_back(_Valty&&... _Val) { // insert element at end
+        reference _Result = _Emplace(_Mypair._Myval2._Myhead, _STD forward<_Valty>(_Val)...)->_Myval;
+
+#if _HAS_CXX17
+        return _Result;
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        (void) _Result;
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    template <class... _Valty>
+    iterator emplace(const const_iterator _Where, _Valty&&... _Val) { // insert element at _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list emplace iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return _Make_iter(_Emplace(_Where._Ptr, _STD forward<_Valty>(_Val)...));
+    }
+
+    template <class... _Valty>
+    _Nodeptr _Emplace(const _Nodeptr _Where, _Valty&&... _Val) { // insert element at _Where
+        size_type& _Mysize = _Mypair._Myval2._Mysize;
+        if (_Mysize == max_size()) {
+            _Xlength_error("list too long");
+        }
+
+        _List_node_emplace_op2<_Alnode> _Op{_Getal(), _STD forward<_Valty>(_Val)...};
+        ++_Mysize;
+        return _Op._Transfer_before(_Where);
+    }
+
+    list(initializer_list<_Ty> _Ilist) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct_range_unchecked(_Ilist.begin(), _Ilist.end());
+    }
+
+    list(initializer_list<_Ty> _Ilist, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_range_unchecked(_Ilist.begin(), _Ilist.end());
+    }
+
+    list& operator=(initializer_list<_Ty> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+
+    void assign(initializer_list<_Ty> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+    }
+
+    iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) { // insert initializer_list
+        return insert(_Where, _Ilist.begin(), _Ilist.end());
+    }
+
+    ~list() noexcept {
+        _Tidy();
+#if _ITERATOR_DEBUG_LEVEL != 0 // TRANSITION, ABI
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Delete_plain_internal(_Alproxy, _Mypair._Myval2._Myproxy);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+private:
+    void _Reload_sentinel_and_proxy(const list& _Right) { // reload sentinel / proxy from unequal POCCA _Right
+        auto& _Al           = _Getal();
+        auto _Alproxy       = _STD _Get_proxy_allocator(_Al);
+        auto& _Right_al     = _Right._Getal();
+        auto _Right_alproxy = _STD _Get_proxy_allocator(_Right_al);
+        _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
+        auto _Right_al_non_const = _Right_al;
+        auto _Newhead            = _Node::_Buyheadnode(_Right_al_non_const);
+        _Tidy();
+        _Pocca(_Al, _Right_al);
+        _Mypair._Myval2._Myhead = _Newhead;
+        _Mypair._Myval2._Mysize = 0;
+        _Proxy._Bind(_Alproxy, _STD addressof(_Mypair._Myval2));
+    }
+
+public:
+    list& operator=(const list& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al       = _Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alnode>) {
+            if (_Al != _Right_al) {
+                _Reload_sentinel_and_proxy(_Right);
+            }
+        } else {
+            _Pocca(_Al, _Right_al);
+        }
+
+        assign(_Right._Unchecked_begin(), _Right._Unchecked_end());
+        return *this;
+    }
+
+    _NODISCARD iterator begin() noexcept {
+        return iterator(_Mypair._Myval2._Myhead->_Next, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        return const_iterator(_Mypair._Myval2._Myhead->_Next, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD iterator end() noexcept {
+        return iterator(_Mypair._Myval2._Myhead, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        return const_iterator(_Mypair._Myval2._Myhead, _STD addressof(_Mypair._Myval2));
+    }
+
+    _Unchecked_iterator _Unchecked_begin() noexcept {
+        return _Unchecked_iterator(_Mypair._Myval2._Myhead->_Next, nullptr);
+    }
+
+    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
+        return _Unchecked_const_iterator(_Mypair._Myval2._Myhead->_Next, nullptr);
+    }
+
+    _Unchecked_iterator _Unchecked_end() noexcept {
+        return _Unchecked_iterator(_Mypair._Myval2._Myhead, nullptr);
+    }
+
+    _Unchecked_const_iterator _Unchecked_end() const noexcept {
+        return _Unchecked_const_iterator(_Mypair._Myval2._Myhead, nullptr);
+    }
+
+    iterator _Make_iter(_Nodeptr _Where) const noexcept {
+        return iterator(_Where, _STD addressof(_Mypair._Myval2));
+    }
+
+    const_iterator _Make_const_iter(_Nodeptr _Where) const noexcept {
+        return const_iterator(_Where, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    void resize(_CRT_GUARDOVERFLOW size_type _Newsize) { // determine new length, padding with _Ty() elements as needed
+        auto& _My_data = _Mypair._Myval2;
+        if (_My_data._Mysize < _Newsize) { // pad to make larger
+            _List_node_insert_op2<_Alnode> _Op(_Getal());
+            _Op._Append_n(_Newsize - _My_data._Mysize);
+            _Op._Attach_at_end(_My_data);
+        } else {
+            while (_Newsize < _My_data._Mysize) {
+                pop_back();
+            }
+        }
+    }
+
+    void resize(_CRT_GUARDOVERFLOW size_type _Newsize, const _Ty& _Val) {
+        // determine new length, padding with _Val elements as needed
+        auto& _My_data = _Mypair._Myval2;
+        if (_My_data._Mysize < _Newsize) { // pad to make larger
+            _List_node_insert_op2<_Alnode> _Op(_Getal());
+            _Op._Append_n(_Newsize - _My_data._Mysize, _Val);
+            _Op._Attach_at_end(_My_data);
+        } else {
+            while (_Newsize < _My_data._Mysize) {
+                pop_back();
+            }
+        }
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        constexpr auto _Diff_max = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        return (_STD min) (_Diff_max, _Alnode_traits::max_size(_Getal()));
+    }
+
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Mypair._Myval2._Mysize == 0;
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+    _NODISCARD reference front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "front() called on empty list");
+#endif
+
+        return _Mypair._Myval2._Myhead->_Next->_Myval;
+    }
+
+    _NODISCARD const_reference front() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "front() called on empty list");
+#endif
+
+        return _Mypair._Myval2._Myhead->_Next->_Myval;
+    }
+
+    _NODISCARD reference back() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "back() called on empty list");
+#endif
+
+        return _Mypair._Myval2._Myhead->_Prev->_Myval;
+    }
+
+    _NODISCARD const_reference back() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "back() called on empty list");
+#endif
+
+        return _Mypair._Myval2._Myhead->_Prev->_Myval;
+    }
+
+    void push_front(const _Ty& _Val) {
+        _Emplace(_Mypair._Myval2._Myhead->_Next, _Val);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void prepend_range(_Rng&& _Range) {
+        _List_node_insert_op2<_Alnode> _Op(_Getal());
+        _Op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Op._Attach_before(_Mypair._Myval2, _Mypair._Myval2._Myhead->_Next);
+    }
+#endif // _HAS_CXX23
+
+    void pop_front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "pop_front() called on empty list");
+#endif
+
+        _Unchecked_erase(_Mypair._Myval2._Myhead->_Next);
+    }
+
+    void push_back(const _Ty& _Val) {
+        _Emplace(_Mypair._Myval2._Myhead, _Val);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void append_range(_Rng&& _Range) {
+        _List_node_insert_op2<_Alnode> _Op(_Getal());
+        _Op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        _Op._Attach_at_end(_Mypair._Myval2);
+    }
+#endif // _HAS_CXX23
+
+    void pop_back() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_LIST || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "pop_back() called on empty list");
+#endif
+
+        _Unchecked_erase(_Mypair._Myval2._Myhead->_Prev);
+    }
+
+private:
+    template <class _Target_ref, class _UIter>
+    void _Assign_cast(_UIter _UFirst, const _UIter _ULast) {
+        // assign [_UFirst, _ULast), casting existing nodes to _Target_ref
+        const auto _Myend = _Mypair._Myval2._Myhead;
+        auto _Old         = _Myend->_Next;
+        for (;;) { // attempt to reuse a node
+            if (_Old == _Myend) { // no more nodes to reuse, append the rest
+                _List_node_insert_op2<_Alnode> _Op(_Getal());
+                _Op._Append_range_unchecked(_UFirst, _ULast);
+                _Op._Attach_at_end(_Mypair._Myval2);
+                return;
+            }
+
+            if (_UFirst == _ULast) {
+                // input sequence was shorter than existing list, destroy and deallocate what's left
+                _Unchecked_erase(_Old, _Myend);
+                return;
+            }
+
+            // reuse the node
+            reinterpret_cast<_Target_ref>(_Old->_Myval) = *_UFirst;
+            _Old                                        = _Old->_Next;
+            ++_UFirst;
+        }
+    }
+
+    template <class _Iter, class _Sent>
+    void _Assign_unchecked(_Iter _First, const _Sent _Last) {
+        // assign [_First, _Last)
+        const auto _Myend = _Mypair._Myval2._Myhead;
+        auto _Old         = _Myend->_Next;
+        for (;;) { // attempt to reuse a node
+            if (_First == _Last) {
+                // input sequence exhausted; destroy and deallocate any tail of unneeded nodes
+                _Unchecked_erase(_Old, _Myend);
+                return;
+            }
+
+            if (_Old == _Myend) { // no more nodes to reuse, append the rest
+                _List_node_insert_op2<_Alnode> _Op(_Getal());
+                _Op._Append_range_unchecked(_STD move(_First), _Last);
+                _Op._Attach_at_end(_Mypair._Myval2);
+                return;
+            }
+
+            // reuse the node
+            _Old->_Myval = *_First;
+            _Old         = _Old->_Next;
+            ++_First;
+        }
+    }
+
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    void assign(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Assign_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void assign_range(_Rng&& _Range) {
+        static_assert(assignable_from<_Ty&, _RANGES range_reference_t<_Rng>>,
+            "Elements must be assignable from the range's reference type (N4993 [sequence.reqmts]/60).");
+        _Assign_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    void assign(_CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) { // assign _Count * _Val
+        const auto _Myend = _Mypair._Myval2._Myhead;
+        auto _Old         = _Myend->_Next;
+        for (;;) { // attempt to reuse a node
+            if (_Old == _Myend) { // no more nodes to reuse, append the rest
+                _List_node_insert_op2<_Alnode> _Op(_Getal());
+                _Op._Append_n(_Count, _Val);
+                _Op._Attach_at_end(_Mypair._Myval2);
+                return;
+            }
+
+            if (_Count == 0) {
+                // input sequence was shorter than existing list, destroy and deallocate what's left
+                _Unchecked_erase(_Old, _Myend);
+                return;
+            }
+
+            // reuse the node
+            _Old->_Myval = _Val;
+            _Old         = _Old->_Next;
+            --_Count;
+        }
+    }
+
+    iterator insert(const_iterator _Where, const _Ty& _Val) { // insert _Val at _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return _Make_iter(_Emplace(_Where._Ptr, _Val));
+    }
+
+    iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const _Ty& _Val) {
+        // insert _Count * _Val before _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _List_node_insert_op2<_Alnode> _Op(_Getal());
+        _Op._Append_n(_Count, _Val);
+        return _Make_iter(_Op._Attach_before(_Mypair._Myval2, _Where._Ptr));
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    iterator insert(const const_iterator _Where, _Iter _First, _Iter _Last) { // insert [_First, _Last) before _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _STD _Adl_verify_range(_First, _Last);
+        _List_node_insert_op2<_Alnode> _Op(_Getal());
+        _Op._Append_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+        return _Make_iter(_Op._Attach_before(_Mypair._Myval2, _Where._Ptr));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list insert_range iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        _List_node_insert_op2<_Alnode> _Op(_Getal());
+        _Op._Append_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        return _Make_iter(_Op._Attach_before(_Mypair._Myval2, _Where._Ptr));
+    }
+#endif // _HAS_CXX23
+
+    iterator erase(const const_iterator _Where) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list erase iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Result = _Where._Ptr->_Next;
+        _Node::_Freenode(_Getal(), _Mypair._Myval2._Unlinknode(_Where._Ptr));
+        return _Make_iter(_Result);
+    }
+
+private:
+    _Nodeptr _Unchecked_erase(const _Nodeptr _Pnode) noexcept { // erase element at _Pnode
+        const auto _Result = _Pnode->_Next;
+        _Mypair._Myval2._Orphan_ptr2(_Pnode);
+        --_Mypair._Myval2._Mysize;
+        _Pnode->_Prev->_Next = _Result;
+        _Result->_Prev       = _Pnode->_Prev;
+        _Node::_Freenode(_Getal(), _Pnode);
+        return _Result;
+    }
+
+public:
+    iterator erase(const const_iterator _First, const const_iterator _Last) noexcept /* strengthened */ {
+        _STD _Adl_verify_range(_First, _Last);
+        return _Make_iter(_Unchecked_erase(_First._Ptr, _Last._Ptr));
+    }
+
+private:
+    _Nodeptr _Unchecked_erase(_Nodeptr _First, const _Nodeptr _Last) noexcept { // erase [_First, _Last)
+        if (_First == _Last) {
+            return _Last;
+        }
+
+        const auto _Predecessor = _First->_Prev;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Head = _Mypair._Myval2._Myhead;
+        if (_First == _Head->_Next && _Last == _Head) { // orphan all non-end iterators
+            _Mypair._Myval2._Orphan_non_end();
+        } else { // orphan erased iterators
+            _Lockit _Lock(_LOCK_DEBUG);
+            for (auto _Marked = _First; _Marked != _Last; _Marked = _Marked->_Next) { // mark erased nodes
+                _Marked->_Prev = nullptr;
+            }
+
+            _Iterator_base12** _Pnext = &_Mypair._Myval2._Myproxy->_Myfirstiter;
+            while (*_Pnext) {
+                _Iterator_base12** _Pnextnext = &(*_Pnext)->_Mynextiter;
+                if (static_cast<const_iterator&>(**_Pnext)._Ptr->_Prev) { // node still has a _Prev, skip
+                    _Pnext = _Pnextnext;
+                } else { // orphan the iterator
+                    (*_Pnext)->_Myproxy = nullptr;
+                    *_Pnext             = *_Pnextnext;
+                }
+            }
+
+            // _Prev pointers not restored because we're about to delete the nodes of which they are a member anyway
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        // snip out the removed range
+        _Predecessor->_Next = _Last;
+        _Last->_Prev        = _Predecessor;
+
+        // count and deallocate the removed nodes
+        auto& _Al           = _Getal();
+        size_type _Erasures = 0;
+        do {
+            const auto _Next = _First->_Next;
+            _Node::_Freenode(_Al, _First);
+            _First = _Next;
+            ++_Erasures;
+        } while (_First != _Last);
+
+        _Mypair._Myval2._Mysize -= _Erasures;
+        return _Last;
+    }
+
+public:
+    void clear() noexcept { // erase all
+        auto& _My_data = _Mypair._Myval2;
+        _My_data._Orphan_non_end();
+        _Node::_Free_non_head(_Getal(), _My_data._Myhead);
+        _My_data._Myhead->_Next = _My_data._Myhead;
+        _My_data._Myhead->_Prev = _My_data._Myhead;
+        _My_data._Mysize        = 0;
+    }
+
+private:
+    void _Tidy() noexcept {
+        auto& _Al      = _Getal();
+        auto& _My_data = _Mypair._Myval2;
+        _My_data._Orphan_all();
+        _Node::_Free_non_head(_Al, _My_data._Myhead);
+        _Node::_Freenode0(_Al, _My_data._Myhead);
+    }
+
+public:
+    void swap(list& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+            _Swap_val(_Right);
+        }
+    }
+
+    void splice(const const_iterator _Where, list& _Right) { // splice all of _Right at _Where
+        auto& _Right_data = _Right._Mypair._Myval2;
+        if (this != _STD addressof(_Right) && _Right_data._Mysize != 0) { // worth splicing, do it
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "list splice iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            const auto _Right_head = _Right_data._Myhead;
+            _Splice(_Where._Ptr, _Right, _Right_head->_Next, _Right_head, _Right_data._Mysize);
+        }
+    }
+
+    void splice(const const_iterator _Where, list&& _Right) { // splice all of _Right at _Where
+        splice(_Where, _Right);
+    }
+
+    void splice(const const_iterator _Where, list& _Right, const const_iterator _First) {
+        // splice _Right [_First, _First + 1) at _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2)
+                        && _First._Getcont() == _STD addressof(_Right._Mypair._Myval2),
+            "list splice iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        const auto _UWhere = _Where._Ptr;
+        const auto _UFirst = _First._Ptr;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_UFirst != _Right._Mypair._Myval2._Myhead, "list splice iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto _ULast = _UFirst->_Next;
+        if (this != _STD addressof(_Right) || (_UWhere != _UFirst && _UWhere != _ULast)) {
+            _Splice(_UWhere, _Right, _UFirst, _ULast, 1);
+        }
+    }
+
+    void splice(const const_iterator _Where, list&& _Right, const const_iterator _First) {
+        // splice _Right [_First, _First + 1) at _Where
+        splice(_Where, _Right, _First);
+    }
+
+    void splice(const const_iterator _Where, list& _Right, const const_iterator _First, const const_iterator _Last) {
+        // splice _Right [_First, _Last) at _Where
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Right_data_ptr = _STD addressof(_Right._Mypair._Myval2);
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2) && _First._Getcont() == _Right_data_ptr
+                        && _Last._Getcont() == _Right_data_ptr,
+            "list splice iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto _UWhere = _Where._Ptr;
+        const auto _UFirst = _First._Ptr;
+        const auto _ULast  = _Last._Ptr;
+
+        if (_UFirst != _ULast && (this != _STD addressof(_Right) || _UWhere != _ULast)) { // worth splicing, do it
+            size_type _Count = 0;
+
+            if (this != _STD addressof(_Right)) {
+                const auto _Right_end = _Right._Mypair._Myval2._Myhead;
+                if (_UFirst == _Right_end->_Next && _ULast == _Right_end) {
+                    _Count = _Right._Mypair._Myval2._Mysize; // splice in whole list
+                } else { // count nodes and check for knot
+                    for (auto _To_check = _UFirst; _To_check != _ULast; _To_check = _To_check->_Next, (void) ++_Count) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                        _STL_VERIFY(_To_check != _Right_end, "list bad splice");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                    }
+                }
+            }
+
+            _Splice(_UWhere, _Right, _UFirst, _ULast, _Count);
+        }
+    }
+
+    void splice(const const_iterator _Where, list&& _Right, const const_iterator _First, const const_iterator _Last) {
+        // splice _Right [_First, _Last) at _Where
+        splice(_Where, _Right, _First, _Last);
+    }
+
+    struct _List_node_remove_op {
+        // tracks nodes pending removal in a remove operation, so that program-defined predicates may reference those
+        // elements until the removal is complete.
+
+        explicit _List_node_remove_op(list& _List_) noexcept : _List(_List_), _Head(), _Tail(_STD addressof(_Head)) {}
+
+        _List_node_remove_op(const _List_node_remove_op&)            = delete;
+        _List_node_remove_op& operator=(const _List_node_remove_op&) = delete;
+
+        _Nodeptr _Transfer_back(const _Nodeptr _Removed) noexcept {
+            // extract _Removed from the list, and add it to the singly-linked list of nodes to destroy
+            // returns the node after _Removed
+            _STL_INTERNAL_CHECK(_List._Mypair._Myval2._Myhead != _Removed);
+
+            // snip the node out
+            --_List._Mypair._Myval2._Mysize;
+            const auto _Next = _STD exchange(_Removed->_Next, nullptr);
+            const auto _Prev = _Removed->_Prev;
+            _Prev->_Next     = _Next;
+            _Next->_Prev     = _Prev;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+            // mark removed node for IDL to snip out later
+            _Removed->_Prev = nullptr;
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+            *_Tail = _Removed;
+            _Tail  = _STD addressof(_Removed->_Next);
+
+            return _Next;
+        }
+
+        ~_List_node_remove_op() {
+            auto& _Al = _List._Getal();
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+            {
+                _Lockit _Lock(_LOCK_DEBUG);
+                _Iterator_base12** _Pnext = &_List._Mypair._Myval2._Myproxy->_Myfirstiter;
+                while (*_Pnext) {
+                    _Iterator_base12** _Pnextnext = &(*_Pnext)->_Mynextiter;
+                    const auto _Pnextptr          = static_cast<const_iterator&>(**_Pnext)._Ptr;
+                    if (_Pnextptr->_Prev) {
+                        // iterator doesn't point to one of the elements we're removing
+                        _Pnext = _Pnextnext;
+                    } else { // orphan the iterator
+                        (*_Pnext)->_Myproxy = nullptr;
+                        *_Pnext             = *_Pnextnext;
+                    }
+                }
+            }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+            auto _Target = _Head;
+            while (_Target) {
+                auto _Next = _Target->_Next;
+                _List._Mypair._Myval2._Orphan_ptr2(_Target);
+                _Alnode_traits::destroy(_Al, _STD addressof(_Target->_Next));
+                _Alnode_traits::destroy(_Al, _STD addressof(_Target->_Prev));
+                _Alnode_traits::destroy(_Al, _STD addressof(_Target->_Myval));
+                _Al.deallocate(_Target, 1);
+                _Target = _Next;
+            }
+        }
+
+        list& _List;
+        _Nodeptr _Head; // singly linked list of nodes to remove; their _Prev pointers set to nullptr
+        _Nodeptr* _Tail;
+    };
+
+    _LIST_REMOVE_RETURN remove(const _Ty& _Val) { // erase each element matching _Val
+        return remove_if([&](const _Ty& _Other) -> bool { return _Other == _Val; });
+    }
+
+    template <class _Pr1>
+    _LIST_REMOVE_RETURN remove_if(_Pr1 _Pred) { // erase each element satisfying _Pred
+        auto& _My_data = _Mypair._Myval2;
+        _List_node_remove_op _Op(*this);
+        const auto _Last         = _My_data._Myhead;
+        const size_type _Oldsize = _My_data._Mysize;
+        for (auto _First = _Last->_Next; _First != _Last;) {
+            auto _Next = _First->_Next;
+            if (_Pred(_First->_Myval)) {
+                _Op._Transfer_back(_First);
+            }
+
+            _First = _Next;
+        }
+
+#if _HAS_CXX20
+        return _Oldsize - _My_data._Mysize;
+#else
+        (void) _Oldsize;
+#endif
+    }
+
+    _LIST_REMOVE_RETURN unique() { // erase each element matching previous
+        return unique(equal_to<>{});
+    }
+
+    template <class _Pr2>
+    _LIST_REMOVE_RETURN unique(_Pr2 _Pred) { // erase each element satisfying _Pred with previous
+        _List_node_remove_op _Op(*this);
+        const _Nodeptr _Phead    = _Mypair._Myval2._Myhead;
+        _Nodeptr _Pprev          = _Phead->_Next;
+        _Nodeptr _Pnode          = _Pprev->_Next;
+        const size_type _Oldsize = _Mypair._Myval2._Mysize;
+        while (_Pnode != _Phead) {
+            if (_Pred(_Pprev->_Myval, _Pnode->_Myval)) { // match, remove it
+                _Pnode = _Op._Transfer_back(_Pnode);
+            } else { // no match, advance
+                _Pprev = _Pnode;
+                _Pnode = _Pnode->_Next;
+            }
+        }
+
+#if _HAS_CXX20
+        return _Oldsize - _Mypair._Myval2._Mysize;
+#else
+        (void) _Oldsize;
+#endif
+    }
+
+    void merge(list& _Right) { // merge in elements from _Right, both ordered by operator<
+        _Merge1(_Right, less<>{});
+    }
+
+    void merge(list&& _Right) { // merge in elements from _Right, both ordered by operator<
+        _Merge1(_Right, less<>{});
+    }
+
+    template <class _Pr2>
+    void merge(list& _Right, _Pr2 _Pred) { // merge in elements from _Right, both ordered by _Pred
+        _Merge1(_Right, _STD _Pass_fn(_Pred));
+    }
+
+    template <class _Pr2>
+    void merge(list&& _Right, _Pr2 _Pred) { // merge in elements from _Right, both ordered by _Pred
+        _Merge1(_Right, _STD _Pass_fn(_Pred));
+    }
+
+private:
+    template <class _Pr2>
+    void _Merge1(list& _Right, _Pr2 _Pred) { // merge in elements from _Right, both ordered by _Pred
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _DEBUG_ORDER_UNWRAPPED(_Unchecked_begin(), _Unchecked_end(), _Pred);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        if (this == _STD addressof(_Right)) {
+            return;
+        }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _DEBUG_ORDER_UNWRAPPED(_Right._Unchecked_begin(), _Right._Unchecked_end(), _Pred);
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            _STL_VERIFY(_Getal() == _Right._Getal(), "list allocators incompatible for merge");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        const auto _Right_size = _Right._Mypair._Myval2._Mysize;
+        if (_Right_size == 0) {
+            // nothing to do
+            return;
+        }
+
+        // splice all _Right's nodes on the end of *this
+        const auto _Myhead     = _Mypair._Myval2._Myhead;
+        const auto _Right_head = _Right._Mypair._Myval2._Myhead;
+        const auto _Mid        = _Right_head->_Next;
+        _Splice(_Myhead, _Right, _Mid, _Right_head, _Right_size);
+
+        // if *this had any elements, run the merge op between the range we just spliced and the old elements
+        if (_Myhead->_Next != _Mid) {
+            _Scary_val::_Merge_same(_Myhead->_Next, _Mid, _Myhead, _Pred);
+        }
+    }
+
+public:
+    void sort() { // order sequence
+        sort(less<>{});
+    }
+
+    template <class _Pr2>
+    void sort(_Pr2 _Pred) { // order sequence
+        auto& _My_data = _Mypair._Myval2;
+        _Scary_val::_Sort(_My_data._Myhead->_Next, _My_data._Mysize, _STD _Pass_fn(_Pred));
+    }
+
+    void reverse() noexcept { // reverse sequence
+        const _Nodeptr _Phead = _Mypair._Myval2._Myhead;
+        _Nodeptr _Pnode       = _Phead;
+
+        for (;;) { // flip pointers in a node
+            const _Nodeptr _Pnext = _Pnode->_Next;
+            _Pnode->_Next         = _Pnode->_Prev;
+            _Pnode->_Prev         = _Pnext;
+
+            if (_Pnext == _Phead) {
+                break;
+            }
+
+            _Pnode = _Pnext;
+        }
+    }
+
+private:
+    _Nodeptr _Splice(
+        const _Nodeptr _Where, list& _Right, const _Nodeptr _First, const _Nodeptr _Last, const size_type _Count) {
+        // splice _Right [_First, _Last) before _Where; returns _Last
+        if (this != _STD addressof(_Right)) { // splicing from another list, adjust counts
+#if _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (!_Alnode_traits::is_always_equal::value) {
+                _STL_VERIFY(_Getal() == _Right._Getal(), "list allocators incompatible for splice");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+            auto& _My_data = _Mypair._Myval2;
+            if (max_size() - _My_data._Mysize < _Count) {
+                _Xlength_error("list too long");
+            }
+
+            auto& _Right_data = _Right._Mypair._Myval2;
+#if _ITERATOR_DEBUG_LEVEL == 2
+            // transfer ownership
+            if (_Count == 1) {
+                _My_data._Adopt_unique(_Right_data, _First);
+            } else if (_Count == _Right_data._Mysize) {
+                _My_data._Adopt_all(_Right_data);
+            } else {
+                _My_data._Adopt_range(_Right_data, _First, _Last);
+            }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+            _My_data._Mysize += _Count;
+            _Right_data._Mysize -= _Count;
+        }
+
+        return _Scary_val::_Unchecked_splice(_Where, _First, _Last);
+    }
+
+    void _Alloc_sentinel_and_proxy() {
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+        auto& _Al     = _Getal();
+        auto _Newhead = _Al.allocate(1);
+        _Construct_in_place(_Newhead->_Next, _Newhead);
+        _Construct_in_place(_Newhead->_Prev, _Newhead);
+        _Mypair._Myval2._Myhead = _Newhead;
+        _Proxy._Release();
+    }
+
+    void _Orphan_all() noexcept {
+        _Mypair._Myval2._Orphan_all();
+    }
+
+    _Alnode& _Getal() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    const _Alnode& _Getal() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _Compressed_pair<_Alnode, _Scary_val> _Mypair;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+list(_Iter, _Iter, _Alloc = _Alloc()) -> list<_Iter_value_t<_Iter>, _Alloc>;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+list(from_range_t, _Rng&&, _Alloc = _Alloc()) -> list<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+void swap(list<_Ty, _Alloc>& _Left, list<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD bool operator==(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
+    return _Left.size() == _Right.size()
+        && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD _Synth_three_way_result<_Ty> operator<=>(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
+    return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
+        _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator!=(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator<(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
+    return _STD lexicographical_compare(
+        _Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin(), _Right._Unchecked_end());
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator>(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator<=(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator>=(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
+list<_Ty, _Alloc>::size_type erase(list<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
+    return _Cont.remove_if([&](const _Ty& _Elem) -> bool { return _Elem == _Val; });
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
+list<_Ty, _Alloc>::size_type erase_if(list<_Ty, _Alloc>& _Cont, _Pr _Pred) {
+    return _Cont.remove_if(_STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Ty>
+    using list = _STD list<_Ty, polymorphic_allocator<_Ty>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _LIST_
diff --git a/msvc-stl/stl/inc/locale b/msvc-stl/stl/inc/locale
new file mode 100644
index 0000000..64d71c3
--- /dev/null
+++ b/msvc-stl/stl/inc/locale
@@ -0,0 +1,290 @@
+// locale standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _LOCALE_
+#define _LOCALE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xlocbuf>
+#include <xlocmes>
+#include <xlocmon>
+#include <xlocnum>
+#include <xloctime>
+#include <xstring>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Elem>
+int _LStrcoll(const _Elem* _First1, const _Elem* _Last1, const _Elem* _First2, const _Elem* _Last2,
+    const _Locinfo::_Collvec* _Vector) { // perform locale-specific comparison of _Elem sequences
+    if constexpr (is_same_v<_Elem, char>) {
+        return _Strcoll(_First1, _Last1, _First2, _Last2, _Vector);
+    } else if constexpr (_Is_wchar_or_crtbld_ushort<_Elem>) { // no-op casts if _Elem is wchar_t
+        return _Wcscoll(reinterpret_cast<const wchar_t*>(_First1), reinterpret_cast<const wchar_t*>(_Last1),
+            reinterpret_cast<const wchar_t*>(_First2), reinterpret_cast<const wchar_t*>(_Last2), _Vector);
+    } else {
+        for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2) {
+            if (*_First1 < *_First2) {
+                return -1; // [_First1, _Last1) < [_First2, _Last2)
+            } else if (*_First2 < *_First1) {
+                return +1; // [_First1, _Last1) > [_First2, _Last2)
+            }
+        }
+
+        return _First2 != _Last2 ? -1 : _First1 != _Last1 ? +1 : 0;
+    }
+}
+
+template <class _Elem>
+size_t _LStrxfrm(_Out_writes_(_Last1 - _First1) _Post_readable_size_(return) _Elem* _First1, _Elem* _Last1,
+    _In_reads_(_Last2 - _First2) const _Elem* _First2, const _Elem* _Last2,
+    _In_opt_ const _Locinfo::_Collvec* _Vector) {
+    // perform locale-specific transform of _Elems [_First1, _Last1)
+    if constexpr (is_same_v<_Elem, char>) {
+        return _Strxfrm(_First1, _Last1, _First2, _Last2, _Vector);
+    } else if constexpr (_Is_wchar_or_crtbld_ushort<_Elem>) { // no-op casts if _Elem is wchar_t
+        return _Wcsxfrm(reinterpret_cast<wchar_t*>(_First1), reinterpret_cast<wchar_t*>(_Last1),
+            reinterpret_cast<const wchar_t*>(_First2), reinterpret_cast<const wchar_t*>(_Last2), _Vector);
+    } else {
+        const ptrdiff_t _Count = _Last2 - _First2;
+        if (_Count <= _Last1 - _First1) {
+            _CSTD memcpy(_First1, _First2, _Count * sizeof(_Elem));
+        }
+
+        return _Count;
+    }
+}
+
+template <class _Elem>
+class _Regex_traits;
+
+_EXPORT_STD template <class _Elem>
+class collate : public locale::facet { // facet for ordering sequences of elements
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type   = _Elem;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    _NODISCARD int compare(const _Elem* _First1, const _Elem* _Last1, const _Elem* _First2, const _Elem* _Last2) const {
+        // compare [_First1, _Last1) to [_First2, _Last2)
+        return do_compare(_First1, _Last1, _First2, _Last2);
+    }
+
+    _NODISCARD string_type transform(const _Elem* _First, const _Elem* _Last) const {
+        // transform [_First, _Last) to key string
+        return do_transform(_First, _Last);
+    }
+
+    _NODISCARD long hash(const _Elem* _First, const _Elem* _Last) const { // compute hash code for [_First, _Last)
+        return do_hash(_First, _Last);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit collate(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    collate(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new collate<_Elem>(_Locinfo(_Ploc->name().c_str()));
+        }
+
+        return _X_COLLATE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~collate() noexcept override {
+        _CSTD free(_Coll._LocaleName);
+    }
+
+    collate(const char* _Locname, size_t _Refs = 0) : locale::facet(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    void _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Coll = _Lobj._Getcoll();
+    }
+
+    _NODISCARD virtual int __CLR_OR_THIS_CALL do_compare(
+        const _Elem* _First1, const _Elem* _Last1, const _Elem* _First2, const _Elem* _Last2) const {
+        // compare [_First1, _Last1) to [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        int _Ans = _LStrcoll(_First1, _Last1, _First2, _Last2, &_Coll);
+        return _Ans < 0 ? -1 : _Ans == 0 ? 0 : +1;
+    }
+
+    _NODISCARD virtual string_type __CLR_OR_THIS_CALL do_transform(const _Elem* _First, const _Elem* _Last) const {
+        // transform [_First, _Last) to key string
+        _Adl_verify_range(_First, _Last);
+        size_t _Count;
+        string_type _Str;
+
+        for (_Count = static_cast<size_t>(_Last - _First); _Str.size() < _Count;) {
+            // grow string if locale-specific strxfrm fails
+            _Str.resize(_Count);
+            _Count = _LStrxfrm(&_Str[0], &_Str[0] + _Str.size(), _First, _Last, &_Coll);
+
+            if (_Count == static_cast<size_t>(-1)) {
+                // return empty string in case of error
+                _Count = 0;
+                break;
+            }
+        }
+        _Str.resize(_Count);
+        return _Str;
+    }
+
+    _NODISCARD virtual long __CLR_OR_THIS_CALL do_hash(const _Elem* _First, const _Elem* _Last) const {
+        // compute hash code for [_First, _Last)
+        const auto _Sortkey = collate::do_transform(_First, _Last);
+        return static_cast<long>(_Hash_array_representation(_Sortkey.data(), _Sortkey.size()));
+    }
+
+private:
+    _Locinfo::_Collvec _Coll; // used by _LStrcoll and _LStrxfrm
+
+    friend _Regex_traits<_Elem>;
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem>
+__PURE_APPDOMAIN_GLOBAL locale::id collate<_Elem>::id;
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template __PURE_APPDOMAIN_GLOBAL locale::id collate<char>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id collate<wchar_t>::id;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template __PURE_APPDOMAIN_GLOBAL locale::id collate<unsigned short>::id;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem>
+class collate_byname : public collate<_Elem> { // collate for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit collate_byname(const char* _Locname, size_t _Refs = 0)
+        : collate<_Elem>(_Locname, _Refs) {} // construct for named locale
+
+    explicit collate_byname(const string& _Str, size_t _Refs = 0)
+        : collate<_Elem>(_Locinfo(_Str.c_str()), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~collate_byname() noexcept override {}
+};
+
+_EXPORT_STD template <class _Facet>
+_NODISCARD bool has_facet(const locale& _Loc) noexcept {
+    _BEGIN_LOCK(_LOCK_LOCALE) // the thread lock, make get atomic
+    size_t _Id = _Facet::id._Get_index();
+    return _Loc._Getfacet(_Id) || _Facet::_Getcat() != static_cast<size_t>(-1);
+    _END_LOCK()
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isalnum(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::alnum, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isalpha(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::alpha, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isblank(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::blank, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool iscntrl(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::cntrl, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isdigit(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::digit, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isgraph(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::graph, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool islower(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::lower, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isprint(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::print, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool ispunct(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::punct, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isspace(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::space, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isupper(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::upper, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD bool isxdigit(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).is(ctype_base::xdigit, _Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _Elem tolower(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).tolower(_Ch);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _Elem toupper(_Elem _Ch, const locale& _Loc) {
+    return _STD use_facet<ctype<_Elem>>(_Loc).toupper(_Ch);
+}
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _LOCALE_
diff --git a/msvc-stl/stl/inc/map b/msvc-stl/stl/inc/map
new file mode 100644
index 0000000..860d463
--- /dev/null
+++ b/msvc-stl/stl/inc/map
@@ -0,0 +1,703 @@
+// map standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _MAP_
+#define _MAP_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <tuple>
+#include <xtree>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+_STD_BEGIN
+template <class _Kty, // key type
+    class _Ty, // mapped type
+    class _Pr, // comparator predicate type
+    class _Alloc, // actual allocator type (should be value allocator)
+    bool _Mfl> // true if multiple equivalent keys are permitted
+class _Tmap_traits { // traits required to make _Tree behave like a map
+public:
+    using key_type       = _Kty;
+    using value_type     = pair<const _Kty, _Ty>;
+    using key_compare    = _Pr;
+    using allocator_type = _Alloc;
+#if _HAS_CXX17
+    using node_type = _Node_handle<_Tree_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
+        _Node_handle_map_base, _Kty, _Ty>;
+#endif // _HAS_CXX17
+
+    static constexpr bool _Multi = _Mfl;
+
+    template <class... _Args>
+    using _In_place_key_extractor = _In_place_key_extract_map<_Kty, _Args...>;
+
+    class value_compare {
+    public:
+        using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = value_type;
+        using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = value_type;
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+        _NODISCARD bool operator()(const value_type& _Left, const value_type& _Right) const {
+            // test if _Left precedes _Right by comparing just keys
+            return comp(_Left.first, _Right.first);
+        }
+
+    protected:
+        friend _Tree<_Tmap_traits>;
+
+        value_compare(key_compare _Pred) : comp(_Pred) {}
+
+        key_compare comp; // the comparator predicate for keys
+    };
+
+    template <class _Ty1, class _Ty2>
+    static const _Kty& _Kfn(const pair<_Ty1, _Ty2>& _Val) { // extract key from element value
+        return _Val.first;
+    }
+};
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>>
+class map : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>> {
+    // ordered red-black tree of {key, mapped} values, unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("map<Key, Value, Compare, Allocator>", "pair<const Key, Value>"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+    using _Mybase                = _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>>;
+    using _Nodeptr               = typename _Mybase::_Nodeptr;
+    using key_type               = _Kty;
+    using mapped_type            = _Ty;
+    using key_compare            = _Pr;
+    using value_compare          = typename _Mybase::value_compare;
+    using value_type             = pair<const _Kty, _Ty>;
+    using allocator_type         = typename _Mybase::allocator_type;
+    using size_type              = typename _Mybase::size_type;
+    using difference_type        = typename _Mybase::difference_type;
+    using pointer                = typename _Mybase::pointer;
+    using const_pointer          = typename _Mybase::const_pointer;
+    using reference              = value_type&;
+    using const_reference        = const value_type&;
+    using iterator               = typename _Mybase::iterator;
+    using const_iterator         = typename _Mybase::const_iterator;
+    using reverse_iterator       = typename _Mybase::reverse_iterator;
+    using const_reverse_iterator = typename _Mybase::const_reverse_iterator;
+
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+
+#if _HAS_CXX17
+    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
+#endif // _HAS_CXX17
+
+    map() : _Mybase(key_compare()) {}
+
+    explicit map(const allocator_type& _Al) : _Mybase(key_compare(), _Al) {}
+
+    map(const map& _Right) : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    map(const map& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit map(const key_compare& _Pred) : _Mybase(_Pred) {}
+
+    map(const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {}
+
+    template <class _Iter>
+    map(_Iter _First, _Iter _Last) : _Mybase(key_compare()) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    map(_Iter _First, _Iter _Last, const key_compare& _Pred) : _Mybase(_Pred) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    map(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    map(_Iter _First, _Iter _Last, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    map(from_range_t, _Rng&& _Range) : _Mybase(key_compare()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    map(from_range_t, _Rng&& _Range, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    map(from_range_t, _Rng&& _Range, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    map(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    map& operator=(const map& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    map(map&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    map(map&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    map& operator=(map&& _Right) noexcept(_Alnode_traits::is_always_equal::value && is_nothrow_move_assignable_v<_Pr>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    mapped_type& operator[](key_type&& _Keyval) { // find element matching _Keyval or insert value-initialized value
+        return _Try_emplace(_STD move(_Keyval)).first->_Myval.second;
+    }
+
+    void swap(map& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    using _Mybase::insert;
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    pair<iterator, bool> insert(_Valty&& _Val) {
+        return this->emplace(_STD forward<_Valty>(_Val));
+    }
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(const_iterator _Where, _Valty&& _Val) {
+        return this->emplace_hint(_Where, _STD forward<_Valty>(_Val));
+    }
+
+private:
+    template <class _Keyty, class... _Mappedty>
+    pair<_Nodeptr, bool> _Try_emplace(_Keyty&& _Keyval, _Mappedty&&... _Mapval) {
+        const auto _Loc = _Mybase::_Find_lower_bound(_Keyval);
+        if (_Mybase::_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+            return {_Loc._Bound, false};
+        }
+
+        _Mybase::_Check_grow_by_1();
+
+        const auto _Scary    = _Mybase::_Get_scary();
+        const auto _Inserted = _Tree_temp_node<_Alnode>(_Mybase::_Getal(), _Scary->_Myhead, piecewise_construct,
+            _STD forward_as_tuple(_STD forward<_Keyty>(_Keyval)),
+            _STD forward_as_tuple(_STD forward<_Mappedty>(_Mapval)...))
+                                   ._Release();
+
+        // nothrow hereafter
+        return {_Scary->_Insert_node(_Loc._Location, _Inserted), true};
+    }
+
+    template <class _Keyty, class... _Mappedty>
+    _Nodeptr _Try_emplace_hint(const _Nodeptr _Hint, _Keyty&& _Keyval, _Mappedty&&... _Mapval) {
+        const auto _Loc = _Mybase::_Find_hint(_Hint, _Keyval);
+        if (_Loc._Duplicate) {
+            return _Loc._Location._Parent;
+        }
+
+        _Mybase::_Check_grow_by_1();
+
+        const auto _Scary    = _Mybase::_Get_scary();
+        const auto _Inserted = _Tree_temp_node<_Alnode>(_Mybase::_Getal(), _Scary->_Myhead, piecewise_construct,
+            _STD forward_as_tuple(_STD forward<_Keyty>(_Keyval)),
+            _STD forward_as_tuple(_STD forward<_Mappedty>(_Mapval)...))
+                                   ._Release();
+
+        // nothrow hereafter
+        return _Scary->_Insert_node(_Loc._Location, _Inserted);
+    }
+
+public:
+    template <class... _Mappedty>
+    pair<iterator, bool> try_emplace(const key_type& _Keyval, _Mappedty&&... _Mapval) {
+        const auto _Result = _Try_emplace(_Keyval, _STD forward<_Mappedty>(_Mapval)...);
+        return {iterator(_Result.first, _Mybase::_Get_scary()), _Result.second};
+    }
+
+    template <class... _Mappedty>
+    iterator try_emplace(const const_iterator _Hint, const key_type& _Keyval, _Mappedty&&... _Mapval) {
+        return iterator(
+            _Try_emplace_hint(_Hint._Ptr, _Keyval, _STD forward<_Mappedty>(_Mapval)...), _Mybase::_Get_scary());
+    }
+
+    template <class... _Mappedty>
+    pair<iterator, bool> try_emplace(key_type&& _Keyval, _Mappedty&&... _Mapval) {
+        const auto _Result = _Try_emplace(_STD move(_Keyval), _STD forward<_Mappedty>(_Mapval)...);
+        return {iterator(_Result.first, _Mybase::_Get_scary()), _Result.second};
+    }
+
+    template <class... _Mappedty>
+    iterator try_emplace(const const_iterator _Hint, key_type&& _Keyval, _Mappedty&&... _Mapval) {
+        return iterator(_Try_emplace_hint(_Hint._Ptr, _STD move(_Keyval), _STD forward<_Mappedty>(_Mapval)...),
+            _Mybase::_Get_scary());
+    }
+
+private:
+    template <class _Keyty, class _Mappedty>
+    pair<_Nodeptr, bool> _Insert_or_assign(_Keyty&& _Keyval, _Mappedty&& _Mapval) {
+        const auto _Loc = _Mybase::_Find_lower_bound(_Keyval);
+        if (_Mybase::_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+            _Loc._Bound->_Myval.second = _STD forward<_Mappedty>(_Mapval);
+            return {_Loc._Bound, false};
+        }
+
+        _Mybase::_Check_grow_by_1();
+
+        const auto _Scary    = _Mybase::_Get_scary();
+        const auto _Inserted = _Tree_temp_node<_Alnode>(
+            _Mybase::_Getal(), _Scary->_Myhead, _STD forward<_Keyty>(_Keyval), _STD forward<_Mappedty>(_Mapval))
+                                   ._Release();
+
+        // nothrow hereafter
+        return {_Scary->_Insert_node(_Loc._Location, _Inserted), true};
+    }
+
+    template <class _Keyty, class _Mappedty>
+    _Nodeptr _Insert_or_assign_hint(const _Nodeptr _Hint, _Keyty&& _Keyval, _Mappedty&& _Mapval) {
+        const auto _Loc = _Mybase::_Find_hint(_Hint, _Keyval);
+        if (_Loc._Duplicate) {
+            _Loc._Location._Parent->_Myval.second = _STD forward<_Mappedty>(_Mapval);
+            return _Loc._Location._Parent;
+        }
+
+        _Mybase::_Check_grow_by_1();
+
+        const auto _Scary    = _Mybase::_Get_scary();
+        const auto _Inserted = _Tree_temp_node<_Alnode>(
+            _Mybase::_Getal(), _Scary->_Myhead, _STD forward<_Keyty>(_Keyval), _STD forward<_Mappedty>(_Mapval))
+                                   ._Release();
+
+        // nothrow hereafter
+        return _Scary->_Insert_node(_Loc._Location, _Inserted);
+    }
+
+public:
+    template <class _Mappedty>
+    pair<iterator, bool> insert_or_assign(const key_type& _Keyval, _Mappedty&& _Mapval) {
+        const auto _Result = _Insert_or_assign(_Keyval, _STD forward<_Mappedty>(_Mapval));
+        return {iterator(_Result.first, _Mybase::_Get_scary()), _Result.second};
+    }
+
+    template <class _Mappedty>
+    iterator insert_or_assign(const const_iterator _Hint, const key_type& _Keyval, _Mappedty&& _Mapval) {
+        return iterator(
+            _Insert_or_assign_hint(_Hint._Ptr, _Keyval, _STD forward<_Mappedty>(_Mapval)), _Mybase::_Get_scary());
+    }
+
+    template <class _Mappedty>
+    pair<iterator, bool> insert_or_assign(key_type&& _Keyval, _Mappedty&& _Mapval) {
+        const auto _Result = _Insert_or_assign(_STD move(_Keyval), _STD forward<_Mappedty>(_Mapval));
+        return {iterator(_Result.first, _Mybase::_Get_scary()), _Result.second};
+    }
+
+    template <class _Mappedty>
+    iterator insert_or_assign(const const_iterator _Hint, key_type&& _Keyval, _Mappedty&& _Mapval) {
+        return iterator(_Insert_or_assign_hint(_Hint._Ptr, _STD move(_Keyval), _STD forward<_Mappedty>(_Mapval)),
+            _Mybase::_Get_scary());
+    }
+
+    map(initializer_list<value_type> _Ilist) : _Mybase(key_compare()) {
+        insert(_Ilist);
+    }
+
+    map(initializer_list<value_type> _Ilist, const key_compare& _Pred) : _Mybase(_Pred) {
+        insert(_Ilist);
+    }
+
+    map(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        insert(_Ilist);
+    }
+
+    map(initializer_list<value_type> _Ilist, const key_compare& _Pred, const allocator_type& _Al)
+        : _Mybase(_Pred, _Al) {
+        insert(_Ilist);
+    }
+
+    map& operator=(initializer_list<value_type> _Ilist) {
+        _Mybase::clear();
+        insert(_Ilist);
+        return *this;
+    }
+
+    mapped_type& operator[](const key_type& _Keyval) {
+        return _Try_emplace(_Keyval).first->_Myval.second;
+    }
+
+    _NODISCARD mapped_type& at(const key_type& _Keyval) {
+        const auto _Loc = _Mybase::_Find_lower_bound(_Keyval);
+        if (!_Mybase::_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+            _Xout_of_range("invalid map<K, T> key");
+        }
+
+        return _Loc._Bound->_Myval.second;
+    }
+
+    _NODISCARD const mapped_type& at(const key_type& _Keyval) const {
+        const auto _Loc = _Mybase::_Find_lower_bound(_Keyval);
+        if (!_Mybase::_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+            _Xout_of_range("invalid map<K, T> key");
+        }
+
+        return _Loc._Bound->_Myval.second;
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Pr = less<_Guide_key_t<_Iter>>, class _Alloc = allocator<_Guide_pair_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+map(_Iter, _Iter, _Pr = _Pr(), _Alloc = _Alloc()) -> map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Pr, _Alloc>;
+
+template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+map(initializer_list<pair<_Kty, _Ty>>, _Pr = _Pr(), _Alloc = _Alloc()) -> map<_Kty, _Ty, _Pr, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+map(_Iter, _Iter, _Alloc) -> map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, less<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+map(initializer_list<pair<_Kty, _Ty>>, _Alloc) -> map<_Kty, _Ty, less<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Pr = less<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Alloc = allocator<_Range_to_alloc_type<_Rng>>>
+map(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc())
+    -> map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Pr, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+map(from_range_t, _Rng&&, _Alloc)
+    -> map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, less<_Range_key_type<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator==(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return _Left.size() == _Right.size()
+        && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD _Synth_three_way_result<pair<const _Kty, _Ty>> operator<=>(
+    const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
+        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator!=(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator<(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return _STD lexicographical_compare(
+        _Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin(), _Right._Unchecked_end_iter());
+}
+
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator>(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator<=(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator>=(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
+void swap(map<_Kty, _Ty, _Pr, _Alloc>& _Left, map<_Kty, _Ty, _Pr, _Alloc>& _Right)
+    noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Ty, class _Keylt, class _Alloc, class _Pr>
+map<_Kty, _Ty, _Keylt, _Alloc>::size_type erase_if(map<_Kty, _Ty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>>
+class multimap : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true>> {
+    // ordered red-black tree of {key, mapped} values, non-unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("multimap<Key, Value, Compare, Allocator>", "pair<const Key, Value>"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+    using _Mybase                = _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true>>;
+    using key_type               = _Kty;
+    using mapped_type            = _Ty;
+    using key_compare            = _Pr;
+    using value_compare          = typename _Mybase::value_compare;
+    using value_type             = pair<const _Kty, _Ty>;
+    using allocator_type         = typename _Mybase::allocator_type;
+    using size_type              = typename _Mybase::size_type;
+    using difference_type        = typename _Mybase::difference_type;
+    using pointer                = typename _Mybase::pointer;
+    using const_pointer          = typename _Mybase::const_pointer;
+    using reference              = value_type&;
+    using const_reference        = const value_type&;
+    using iterator               = typename _Mybase::iterator;
+    using const_iterator         = typename _Mybase::const_iterator;
+    using reverse_iterator       = typename _Mybase::reverse_iterator;
+    using const_reverse_iterator = typename _Mybase::const_reverse_iterator;
+
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+
+    multimap() : _Mybase(key_compare()) {}
+
+    explicit multimap(const allocator_type& _Al) : _Mybase(key_compare(), _Al) {}
+
+    multimap(const multimap& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    multimap(const multimap& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit multimap(const key_compare& _Pred) : _Mybase(_Pred) {}
+
+    multimap(const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {}
+
+    template <class _Iter>
+    multimap(_Iter _First, _Iter _Last) : _Mybase(key_compare()) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    multimap(_Iter _First, _Iter _Last, const key_compare& _Pred) : _Mybase(_Pred) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    multimap(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    multimap(_Iter _First, _Iter _Last, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    multimap(from_range_t, _Rng&& _Range) : _Mybase(key_compare()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multimap(from_range_t, _Rng&& _Range, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multimap(from_range_t, _Rng&& _Range, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multimap(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    multimap& operator=(const multimap& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    multimap(multimap&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    multimap(multimap&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    multimap& operator=(multimap&& _Right)
+        noexcept(_Alnode_traits::is_always_equal::value && is_nothrow_move_assignable_v<_Pr>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    template <class... _Valty>
+    iterator emplace(_Valty&&... _Val) {
+        return _Mybase::emplace(_STD forward<_Valty>(_Val)...).first;
+    }
+
+    void swap(multimap& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    using _Mybase::insert;
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(_Valty&& _Val) {
+        return this->emplace(_STD forward<_Valty>(_Val));
+    }
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(const_iterator _Where, _Valty&& _Val) {
+        return this->emplace_hint(_Where, _STD forward<_Valty>(_Val));
+    }
+
+    multimap(initializer_list<value_type> _Ilist) : _Mybase(key_compare()) {
+        insert(_Ilist);
+    }
+
+    multimap(initializer_list<value_type> _Ilist, const key_compare& _Pred) : _Mybase(_Pred) {
+        insert(_Ilist);
+    }
+
+    multimap(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        insert(_Ilist);
+    }
+
+    multimap(initializer_list<value_type> _Ilist, const key_compare& _Pred, const allocator_type& _Al)
+        : _Mybase(_Pred, _Al) {
+        insert(_Ilist);
+    }
+
+    multimap& operator=(initializer_list<value_type> _Ilist) {
+        _Mybase::clear();
+        insert(_Ilist);
+        return *this;
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Pr = less<_Guide_key_t<_Iter>>, class _Alloc = allocator<_Guide_pair_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+multimap(_Iter, _Iter, _Pr = _Pr(), _Alloc = _Alloc())
+    -> multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Pr, _Alloc>;
+
+template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+multimap(initializer_list<pair<_Kty, _Ty>>, _Pr = _Pr(), _Alloc = _Alloc()) -> multimap<_Kty, _Ty, _Pr, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+multimap(_Iter, _Iter, _Alloc) -> multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, less<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+multimap(initializer_list<pair<_Kty, _Ty>>, _Alloc) -> multimap<_Kty, _Ty, less<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Pr = less<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Alloc = allocator<_Range_to_alloc_type<_Rng>>>
+multimap(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc())
+    -> multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Pr, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+multimap(from_range_t, _Rng&&, _Alloc)
+    -> multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, less<_Range_key_type<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator==(
+    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return _Left.size() == _Right.size()
+        && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD _Synth_three_way_result<pair<const _Kty, _Ty>> operator<=>(
+    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
+        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator!=(
+    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator<(
+    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return _STD lexicographical_compare(
+        _Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin(), _Right._Unchecked_end_iter());
+}
+
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator>(
+    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator<=(
+    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Kty, class _Ty, class _Pr, class _Alloc>
+_NODISCARD bool operator>=(
+    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Pr, class _Alloc>
+void swap(multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, multimap<_Kty, _Ty, _Pr, _Alloc>& _Right)
+    noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Ty, class _Keylt, class _Alloc, class _Pr>
+multimap<_Kty, _Ty, _Keylt, _Alloc>::size_type erase_if(multimap<_Kty, _Ty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Kty, class _Ty, class _Pr = less<_Kty>>
+    using map = _STD map<_Kty, _Ty, _Pr, polymorphic_allocator<pair<const _Kty, _Ty>>>;
+
+    _EXPORT_STD template <class _Kty, class _Ty, class _Pr = less<_Kty>>
+    using multimap = _STD multimap<_Kty, _Ty, _Pr, polymorphic_allocator<pair<const _Kty, _Ty>>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _MAP_
diff --git a/msvc-stl/stl/inc/mdspan b/msvc-stl/stl/inc/mdspan
new file mode 100644
index 0000000..e877ec7
--- /dev/null
+++ b/msvc-stl/stl/inc/mdspan
@@ -0,0 +1,1574 @@
+// mdspan standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _MDSPAN_
+#define _MDSPAN_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <mdspan> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+#include <algorithm>
+#include <array>
+#include <span>
+#include <tuple>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+template <class _IndexType, size_t _Size>
+struct _Maybe_empty_array {
+    array<_IndexType, _Size> _Array{};
+};
+
+template <class _IndexType>
+struct _Maybe_empty_array<_IndexType, 0> {};
+
+template <size_t... _Extents>
+constexpr size_t _Calculate_rank_dynamic = (static_cast<size_t>(_Extents == dynamic_extent) + ... + 0);
+
+struct _Extents_from_tuple {
+    explicit _Extents_from_tuple() = default;
+};
+
+_EXPORT_STD template <class _IndexType, size_t... _Extents>
+class extents : private _Maybe_empty_array<_IndexType, _Calculate_rank_dynamic<_Extents...>> {
+public:
+    using index_type = _IndexType;
+    using size_type  = make_unsigned_t<index_type>;
+    using rank_type  = size_t;
+
+    static_assert(_Is_standard_integer<index_type>,
+        "IndexType must be a signed or unsigned integer type (N4950 [mdspan.extents.overview]/1.1).");
+    static_assert(((_Extents == dynamic_extent || _STD in_range<index_type>(_Extents)) && ...),
+        "Each element of Extents must either be equal to dynamic_extent, or be representable as a value of type "
+        "IndexType (N4950 [mdspan.extents.overview]/1.2).");
+
+    static constexpr rank_type _Rank                                = sizeof...(_Extents);
+    static constexpr rank_type _Rank_dynamic                        = _Calculate_rank_dynamic<_Extents...>;
+    static constexpr array<rank_type, _Rank> _Static_extents        = {_Extents...};
+    static constexpr bool _Multidim_index_space_size_is_always_zero = ((_Extents == 0) || ...);
+
+private:
+    _NODISCARD static consteval auto _Make_dynamic_indices() noexcept {
+        array<rank_type, _Rank + 1> _Result{};
+        rank_type _Counter = 0;
+        for (rank_type _Idx = 0; _Idx < _Rank; ++_Idx) {
+            _Result[_Idx] = _Counter;
+            if (_Static_extents[_Idx] == dynamic_extent) {
+                ++_Counter;
+            }
+        }
+        _Result[_Rank] = _Counter;
+        return _Result;
+    }
+
+    static constexpr array<rank_type, _Rank + 1> _Dynamic_indices = _Make_dynamic_indices();
+
+    _NODISCARD static consteval auto _Make_dynamic_indices_inv() noexcept {
+        array<rank_type, _Rank_dynamic> _Result{};
+        rank_type _Counter = 0;
+        for (rank_type _Idx = 0; _Idx < _Rank; ++_Idx) {
+            if (_Static_extents[_Idx] == dynamic_extent) {
+                _Analysis_assume_(_Counter < _Rank_dynamic); // guaranteed by how _Rank_dynamic is calculated
+                _Result[_Counter] = _Idx;
+                ++_Counter;
+            }
+        }
+        return _Result;
+    }
+
+    static constexpr array<rank_type, _Rank_dynamic> _Dynamic_indices_inv = _Make_dynamic_indices_inv();
+
+    using _Base = _Maybe_empty_array<_IndexType, _Rank_dynamic>;
+
+    template <class _OtherIndexType, size_t... _OtherExtents, size_t... _Indices>
+    constexpr explicit extents(
+        const extents<_OtherIndexType, _OtherExtents...>& _Other, index_sequence<_Indices...>) noexcept
+        : _Base{static_cast<index_type>(_Other.extent(_Dynamic_indices_inv[_Indices]))...} {
+        _STL_INTERNAL_STATIC_ASSERT(sizeof...(_OtherExtents) == _Rank);
+        _STL_INTERNAL_STATIC_ASSERT(
+            ((_OtherExtents == dynamic_extent || _Extents == dynamic_extent || _OtherExtents == _Extents) && ...));
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (rank() > 0) {
+            for (rank_type _Idx = 0; _Idx < _Rank; ++_Idx) {
+                if constexpr (rank() != rank_dynamic()) {
+                    _STL_VERIFY(_Static_extents[_Idx] == dynamic_extent
+                                    || _STD cmp_equal(_Static_extents[_Idx], _Other.extent(_Idx)),
+                        "Value of other.extent(r) must be equal to extent(r) for each r for which extent(r) is a "
+                        "static extent (N4950 [mdspan.extents.cons]/2.1)");
+                }
+                _STL_VERIFY(_STD in_range<index_type>(_Other.extent(_Idx)),
+                    "Value of other.extent(r) must be representable as a value of type index_type for every rank index "
+                    "r (N4950 [mdspan.extents.cons]/2.2)");
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <class _ExtsTuple, size_t... _Indices>
+        requires (tuple_size_v<_ExtsTuple> == _Rank_dynamic)
+    constexpr explicit extents(_Extents_from_tuple, _ExtsTuple _Tpl, index_sequence<_Indices...>) noexcept
+        : _Base{static_cast<index_type>(_STD move(_STD get<_Indices>(_Tpl)))...} {}
+
+    template <class _ExtsTuple, size_t... _DynIndices>
+        requires (tuple_size_v<_ExtsTuple> != _Rank_dynamic)
+    constexpr explicit extents(_Extents_from_tuple, _ExtsTuple _Tpl, index_sequence<_DynIndices...>) noexcept
+        : _Base{static_cast<index_type>(_STD move(_STD get<_Dynamic_indices_inv[_DynIndices]>(_Tpl)))...} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        [&]<size_t... _MixedIndices>(index_sequence<_MixedIndices...>) {
+            _STL_VERIFY(((_Static_extents[_MixedIndices] == dynamic_extent
+                             || _STD cmp_equal(_Static_extents[_MixedIndices],
+                                 static_cast<index_type>(_STD move(_STD get<_MixedIndices>(_Tpl)))))
+                            && ...),
+                "Value of exts_arr[r] must be equal to extent(r) for each r for which extent(r) is a static extent "
+                "(N4950 [mdspan.extents.cons]/7.1)");
+        }(make_index_sequence<rank()>{});
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <class _OtherIndexType, size_t... _Indices>
+    constexpr explicit extents(span<_OtherIndexType, _Rank_dynamic> _Dynamic_exts, index_sequence<_Indices...>) noexcept
+        : _Base{static_cast<index_type>(_STD as_const(_Dynamic_exts[_Indices]))...} {
+        _STL_INTERNAL_STATIC_ASSERT(is_convertible_v<const _OtherIndexType&, index_type>
+                                    && is_nothrow_constructible_v<index_type, const _OtherIndexType&>);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Is_standard_integer<remove_cv_t<_OtherIndexType>> && _Rank_dynamic != 0) {
+            _STL_VERIFY(((_Dynamic_exts[_Indices] >= 0 && _STD in_range<index_type>(_Dynamic_exts[_Indices])) && ...),
+                "exts[r] must be representable as a nonnegative value of type index_type for every rank index r "
+                "(N4950 [mdspan.extents.cons]/10.2)");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <class _OtherIndexType, size_t _Size, size_t... _Indices>
+    constexpr explicit extents(span<_OtherIndexType, _Size> _Mixed_exts, index_sequence<_Indices...>) noexcept
+        : _Base{static_cast<index_type>(_STD as_const(_Mixed_exts[_Dynamic_indices_inv[_Indices]]))...} {
+        _STL_INTERNAL_STATIC_ASSERT(_Size != _Rank_dynamic);
+        _STL_INTERNAL_STATIC_ASSERT(is_convertible_v<const _OtherIndexType&, index_type>
+                                    && is_nothrow_constructible_v<index_type, const _OtherIndexType&>);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Is_standard_integer<remove_cv_t<_OtherIndexType>>) {
+            for (rank_type _Idx = 0; _Idx < _Rank; ++_Idx) {
+                _STL_VERIFY(
+                    _Static_extents[_Idx] == dynamic_extent || _STD cmp_equal(_Static_extents[_Idx], _Mixed_exts[_Idx]),
+                    "Value of exts[r] must be equal to extent(r) for each r for which extent(r) is a static extent "
+                    "(N4950 [mdspan.extents.cons]/10.1)");
+                _STL_VERIFY(_Mixed_exts[_Idx] >= 0 && _STD in_range<index_type>(_Mixed_exts[_Idx]),
+                    "exts[r] must be representable as a nonnegative value of type index_type for every rank index r "
+                    "(N4950 [mdspan.extents.cons]/10.2)");
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+public:
+    _NODISCARD _Ret_range_(==, _Rank) static constexpr rank_type rank() noexcept {
+        return _Rank;
+    }
+
+    _NODISCARD static constexpr rank_type rank_dynamic() noexcept {
+        return _Rank_dynamic;
+    }
+
+    _NODISCARD static constexpr size_t static_extent(_In_range_(<, _Rank) const rank_type _Idx) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Idx < _Rank, "Index must be less than rank() (N4950 [mdspan.extents.obs]/1)");
+#endif
+        return _Static_extents[_Idx];
+    }
+
+    _NODISCARD constexpr index_type extent(_In_range_(<, _Rank) const rank_type _Idx) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Idx < _Rank, "Index must be less than rank() (N4950 [mdspan.extents.obs]/3)");
+#endif
+        if constexpr (rank_dynamic() == 0) {
+            return static_cast<index_type>(_Static_extents[_Idx]);
+        } else if constexpr (rank_dynamic() == rank()) {
+            return this->_Array[_Idx];
+        } else {
+            if (_Static_extents[_Idx] == dynamic_extent) {
+                return this->_Array[_Dynamic_indices[_Idx]];
+            } else {
+                return static_cast<index_type>(_Static_extents[_Idx]);
+            }
+        }
+    }
+
+    constexpr extents() noexcept = default;
+
+    template <class _OtherIndexType, size_t... _OtherExtents>
+        requires (sizeof...(_OtherExtents) == rank())
+              && ((_OtherExtents == dynamic_extent || _Extents == dynamic_extent || _OtherExtents == _Extents) && ...)
+    constexpr explicit(((_Extents != dynamic_extent && _OtherExtents == dynamic_extent) || ...)
+                       || _STD _Max_limit<index_type>() < _STD _Max_limit<_OtherIndexType>())
+        extents(const extents<_OtherIndexType, _OtherExtents...>& _Other) noexcept
+        : extents(_Other, make_index_sequence<rank_dynamic()>{}) {}
+
+    template <class... _OtherIndexTypes>
+        requires conjunction_v<is_convertible<_OtherIndexTypes, index_type>...,
+                     is_nothrow_constructible<index_type, _OtherIndexTypes>...>
+              && (sizeof...(_OtherIndexTypes) == rank_dynamic() || sizeof...(_OtherIndexTypes) == rank())
+    constexpr explicit extents(_OtherIndexTypes... _Exts) noexcept
+        : extents(_Extents_from_tuple{}, _STD tie(_Exts...), make_index_sequence<rank_dynamic()>{}) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        auto _Check_extent = []<class _Ty>(const _Ty& _Ext) {
+            if constexpr (_Is_standard_integer<_Ty>) {
+                return _Ext >= 0 && _STD in_range<index_type>(_Ext);
+            } else if constexpr (integral<_Ty> && !same_as<_Ty, bool>) { // NB: character types
+                const auto _Integer_ext = static_cast<long long>(_Ext);
+                return _Integer_ext >= 0 && _STD in_range<index_type>(_Integer_ext);
+            } else {
+                return true; // NB: We cannot check preconditions
+            }
+        };
+        _STL_VERIFY((_Check_extent(_Exts) && ...), "Each argument must be representable as a nonnegative value of type "
+                                                   "index_type (N4950 [mdspan.extents.cons]/7.2)");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <class _OtherIndexType, size_t _Size>
+        requires is_convertible_v<const _OtherIndexType&, index_type>
+              && is_nothrow_constructible_v<index_type, const _OtherIndexType&>
+              && (_Size == rank_dynamic() || _Size == rank())
+    constexpr explicit(_Size != rank_dynamic()) extents(span<_OtherIndexType, _Size> _Exts) noexcept
+        : extents(_Exts, make_index_sequence<rank_dynamic()>{}) {}
+
+    template <class _OtherIndexType, size_t _Size>
+        requires is_convertible_v<const _OtherIndexType&, index_type>
+              && is_nothrow_constructible_v<index_type, const _OtherIndexType&>
+              && (_Size == rank_dynamic() || _Size == rank())
+    constexpr explicit(_Size != rank_dynamic()) extents(const array<_OtherIndexType, _Size>& _Exts) noexcept
+        : extents(span{_Exts}, make_index_sequence<rank_dynamic()>{}) {}
+
+    template <class _OtherIndexType, size_t... _OtherExtents>
+    _NODISCARD friend constexpr bool operator==(
+        const extents& _Left, const extents<_OtherIndexType, _OtherExtents...>& _Right) noexcept {
+        if constexpr (rank() != sizeof...(_OtherExtents)) {
+            return false;
+        } else {
+            for (rank_type _Idx = 0; _Idx < _Rank; ++_Idx) {
+                if (_STD cmp_not_equal(_Left.extent(_Idx), _Right.extent(_Idx))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    _NODISCARD static consteval bool _Is_static_multidim_index_space_size_representable() noexcept {
+        // Pre: rank_dynamic() == 0
+        if constexpr (_Multidim_index_space_size_is_always_zero) {
+            return true;
+        } else {
+            index_type _Result{1};
+            const bool _Overflow = (_Mul_overflow(static_cast<index_type>(_Extents), _Result, _Result) || ...);
+            return !_Overflow;
+        }
+    }
+
+    template <integral _Ty = index_type>
+    _NODISCARD constexpr bool _Is_dynamic_multidim_index_space_size_representable() const noexcept {
+        // Pre: rank_dynamic() != 0
+        if constexpr (_Multidim_index_space_size_is_always_zero) {
+            return true;
+        } else {
+            bool _Overflow = false;
+            _Ty _Result    = 1;
+            for (rank_type _Idx = 0; _Idx < _Rank; ++_Idx) {
+                const auto _Ext = static_cast<_Ty>(extent(_Idx));
+                if (_Ext == 0) {
+                    return true;
+                }
+
+                if (!_Overflow) {
+                    _Overflow = _Mul_overflow(_Ext, _Result, _Result);
+                }
+            }
+
+            return !_Overflow;
+        }
+    }
+
+    template <size_t... _Seq, class... _IndexTypes>
+    _NODISCARD constexpr bool _Contains_multidimensional_index(
+        index_sequence<_Seq...>, _IndexTypes... _Indices) const noexcept {
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_IndexTypes, index_type>...>);
+        if constexpr (unsigned_integral<index_type>) {
+            return ((_Indices < extent(_Seq)) && ...);
+        } else {
+            return ((0 <= _Indices && _Indices < extent(_Seq)) && ...);
+        }
+    }
+
+    template <class _ExtentsT>
+    friend constexpr size_t _Count_dynamic_extents_equal_to_one(
+        const _ExtentsT&) noexcept; // NB: used by 'layout_stride::mapping<E>::is_exhaustive'
+};
+
+template <class>
+constexpr size_t _Repeat_dynamic_extent = dynamic_extent;
+
+template <class... _Integrals>
+    requires conjunction_v<is_convertible<_Integrals, size_t>...>
+explicit extents(_Integrals...) -> extents<size_t, _Repeat_dynamic_extent<_Integrals>...>;
+
+template <class _IndexType, class _Indices>
+struct _Dextents_impl;
+
+template <class _IndexType, size_t... _Indices>
+struct _Dextents_impl<_IndexType, index_sequence<_Indices...>> {
+    using type = extents<_IndexType, ((void) _Indices, dynamic_extent)...>;
+};
+
+_EXPORT_STD template <class _IndexType, size_t _Rank>
+using dextents = _Dextents_impl<_IndexType, make_index_sequence<_Rank>>::type;
+
+template <class _Ty>
+constexpr bool _Is_extents = false;
+
+template <class _IndexType, size_t... _Args>
+constexpr bool _Is_extents<extents<_IndexType, _Args...>> = true;
+
+template <class _Extents>
+class _Fwd_prod_of_extents {
+public:
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents>);
+
+    _NODISCARD static constexpr _Extents::index_type _Calculate(const _Extents& _Exts, const size_t _Idx) noexcept {
+        _STL_INTERNAL_CHECK(_Idx <= _Extents::_Rank);
+        if constexpr (_Extents::rank() == 0) {
+            return 1;
+        } else {
+            // Use an unsigned type to prevent overflow when called from mdspan::size.
+            typename _Extents::size_type _Result = 1;
+            for (size_t _Dim = 0; _Dim < _Idx; ++_Dim) {
+                _Result *= static_cast<_Extents::size_type>(_Exts.extent(_Dim));
+            }
+
+            return static_cast<_Extents::index_type>(_Result);
+        }
+    }
+};
+
+template <class _Extents>
+    requires (_Extents::rank() > 0) && (_Extents::rank_dynamic() == 0)
+class _Fwd_prod_of_extents<_Extents> {
+private:
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents>);
+
+    _NODISCARD static consteval auto _Make_prods() noexcept {
+        array<typename _Extents::index_type, _Extents::rank() + 1> _Result;
+        _Result.front() = 1;
+        for (size_t _Idx = 1; _Idx < _Extents::_Rank + 1; ++_Idx) {
+            _Result[_Idx] = static_cast<_Extents::index_type>(_Result[_Idx - 1] * _Extents::_Static_extents[_Idx - 1]);
+        }
+        return _Result;
+    }
+
+    static constexpr array<typename _Extents::index_type, _Extents::rank() + 1> _Cache = _Make_prods();
+
+public:
+    _NODISCARD static constexpr _Extents::index_type _Calculate(const _Extents&, const size_t _Idx) noexcept {
+        _STL_INTERNAL_CHECK(_Idx <= _Extents::_Rank);
+        return _Cache[_Idx];
+    }
+};
+
+template <class _Extents>
+class _Rev_prod_of_extents {
+public:
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents>);
+    _STL_INTERNAL_STATIC_ASSERT(_Extents::rank() > 0);
+
+    _NODISCARD static constexpr _Extents::index_type _Calculate(const _Extents& _Exts, const size_t _Idx) noexcept {
+        _STL_INTERNAL_CHECK(_Idx < _Extents::_Rank);
+        typename _Extents::index_type _Result = 1;
+        for (size_t _Dim = _Idx + 1; _Dim < _Extents::_Rank; ++_Dim) {
+            _Result *= _Exts.extent(_Dim);
+        }
+        return _Result;
+    }
+};
+
+template <class _Extents>
+    requires (_Extents::rank_dynamic() == 0)
+class _Rev_prod_of_extents<_Extents> {
+private:
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents>);
+    _STL_INTERNAL_STATIC_ASSERT(_Extents::rank() > 0);
+
+    _NODISCARD static consteval auto _Make_prods() noexcept {
+        array<typename _Extents::index_type, _Extents::rank()> _Result;
+        _Result.back() = 1;
+        for (size_t _Idx = _Extents::_Rank; _Idx-- > 1;) {
+            _Result[_Idx - 1] = static_cast<_Extents::index_type>(_Result[_Idx] * _Extents::_Static_extents[_Idx]);
+        }
+        return _Result;
+    }
+
+    static constexpr array<typename _Extents::index_type, _Extents::rank()> _Cache = _Make_prods();
+
+public:
+    _NODISCARD static constexpr _Extents::index_type _Calculate(const _Extents&, const size_t _Idx) noexcept {
+        _STL_INTERNAL_CHECK(_Idx < _Extents::_Rank);
+        return _Cache[_Idx];
+    }
+};
+
+template <class _Layout, class _Mapping>
+constexpr bool _Is_mapping_of =
+    is_same_v<typename _Layout::template mapping<typename _Mapping::extents_type>, _Mapping>;
+
+_EXPORT_STD struct layout_left {
+    template <class _Extents>
+    class _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES mapping;
+};
+
+_EXPORT_STD struct layout_right {
+    template <class _Extents>
+    class _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES mapping;
+};
+
+_EXPORT_STD struct layout_stride {
+    template <class _Extents>
+    class _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES mapping;
+};
+
+template <class _Extents>
+struct _Maybe_fully_static_extents {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents>);
+
+    constexpr _Maybe_fully_static_extents() noexcept = default;
+
+    template <class _OtherExtents>
+    constexpr explicit _Maybe_fully_static_extents(const _OtherExtents& _Exts_) : _Exts(_Exts_) {}
+
+    _Extents _Exts{};
+};
+
+template <class _Extents>
+    requires (_Extents::rank_dynamic() == 0)
+struct _Maybe_fully_static_extents<_Extents> {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents>);
+
+    constexpr _Maybe_fully_static_extents() noexcept = default;
+
+    template <class _OtherExtents>
+    constexpr explicit _Maybe_fully_static_extents([[maybe_unused]] const _OtherExtents& _Exts_) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        (void) _Extents{_Exts_}; // NB: temporary created for preconditions check
+#endif
+    }
+
+    static constexpr _Extents _Exts{};
+};
+
+template <class _Extents>
+class _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES layout_left::mapping
+    : private _Maybe_fully_static_extents<_Extents> {
+public:
+    using extents_type = _Extents;
+    using index_type   = extents_type::index_type;
+    using size_type    = extents_type::size_type;
+    using rank_type    = extents_type::rank_type;
+    using layout_type  = layout_left;
+
+private:
+    using _Base = _Maybe_fully_static_extents<extents_type>;
+
+    static_assert(_Is_extents<extents_type>,
+        "Extents must be a specialization of std::extents (N4950 [mdspan.layout.left.overview]/2).");
+    static_assert(
+        extents_type::rank_dynamic() != 0 || extents_type::_Is_static_multidim_index_space_size_representable(),
+        "If Extents::rank_dynamic() == 0 is true, then the size of the multidimensional index space Extents() must be "
+        "representable as a value of type typename Extents::index_type (N4950 [mdspan.layout.left.overview]/4).");
+
+public:
+    constexpr mapping() noexcept               = default;
+    constexpr mapping(const mapping&) noexcept = default;
+
+    constexpr mapping(const extents_type& _Exts_) noexcept : _Base(_Exts_) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (extents_type::rank_dynamic() != 0) {
+            _STL_VERIFY(_Exts_._Is_dynamic_multidim_index_space_size_representable(),
+                "The size of the multidimensional index space e must be representable as a value of type index_type "
+                "(N4950 [mdspan.layout.left.cons]/1).");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <class _OtherExtents>
+        requires is_constructible_v<extents_type, _OtherExtents>
+    constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+        mapping(const mapping<_OtherExtents>& _Other) noexcept
+        : _Base(_Other.extents()) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_STD in_range<index_type>(_Other.required_span_size()),
+            "Value of other.required_span_size() must be representable as a value of type index_type (N4950 "
+            "[mdspan.layout.left.cons]/4).");
+#endif
+    }
+
+    template <class _OtherExtents>
+        requires (extents_type::rank() <= 1) && is_constructible_v<extents_type, _OtherExtents>
+    constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+        mapping(const layout_right::mapping<_OtherExtents>& _Other) noexcept
+        : _Base(_Other.extents()) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_STD in_range<index_type>(_Other.required_span_size()),
+            "Value of other.required_span_size() must be representable as a value of type index_type (N4950 "
+            "[mdspan.layout.left.cons]/7).");
+#endif
+    }
+
+    template <class _OtherExtents>
+        requires is_constructible_v<extents_type, _OtherExtents>
+    constexpr explicit(!(extents_type::rank() == 0 && is_convertible_v<_OtherExtents, extents_type>) )
+        mapping(const layout_stride::mapping<_OtherExtents>& _Other) noexcept // strengthened
+        : _Base(_Other.extents()) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (extents_type::rank() > 0) {
+            index_type _Prod = 1;
+            for (size_t _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+                _STL_VERIFY(_STD cmp_equal(_Other.stride(_Idx), _Prod),
+                    "For all r in the range [0, extents_type::rank()), other.stride(r) must be equal to "
+                    "extents().fwd-prod-of-extents(r) (N4950 [mdspan.layout.left.cons]/10.1).");
+                _Prod = static_cast<index_type>(_Prod * this->_Exts.extent(_Idx));
+            }
+        }
+        _STL_VERIFY(_STD in_range<index_type>(_Other.required_span_size()),
+            "Value of other.required_span_size() must be representable as a value of type index_type (N4950 "
+            "[mdspan.layout.left.cons]/10.2).");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+
+    _NODISCARD constexpr const extents_type& extents() const noexcept {
+        return this->_Exts;
+    }
+
+    _NODISCARD constexpr index_type required_span_size() const noexcept {
+        return _Fwd_prod_of_extents<extents_type>::_Calculate(this->_Exts, extents_type::_Rank);
+    }
+
+    template <class... _IndexTypes>
+        requires (sizeof...(_IndexTypes) == extents_type::rank())
+              && conjunction_v<is_convertible<_IndexTypes, index_type>...,
+                  is_nothrow_constructible<index_type, _IndexTypes>...>
+    _NODISCARD constexpr index_type operator()(_IndexTypes... _Indices) const noexcept {
+        return _Index_impl(
+            make_index_sequence<extents_type::rank()>{}, static_cast<index_type>(_STD move(_Indices))...);
+    }
+
+    _NODISCARD static constexpr bool is_always_unique() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_always_exhaustive() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_always_strided() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_unique() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_exhaustive() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_strided() noexcept {
+        return true;
+    }
+
+    _NODISCARD constexpr index_type stride(_In_range_(<, extents_type::_Rank) const rank_type _Idx) const noexcept
+        requires (extents_type::rank() > 0)
+    {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Idx < extents_type::_Rank,
+            "Value of i must be less than extents_type::rank() (N4950 [mdspan.layout.left.obs]/6).");
+#endif
+        return _Fwd_prod_of_extents<extents_type>::_Calculate(this->_Exts, _Idx);
+    }
+
+    template <class _OtherExtents>
+        requires (extents_type::rank() == _OtherExtents::rank())
+    _NODISCARD friend constexpr bool operator==(const mapping& _Left, const mapping<_OtherExtents>& _Right) noexcept {
+        return _Left._Exts == _Right.extents();
+    }
+
+private:
+    template <class... _IndexTypes, size_t... _Seq>
+    _NODISCARD constexpr index_type _Index_impl(
+        [[maybe_unused]] index_sequence<_Seq...> _Index_seq, _IndexTypes... _Indices) const noexcept {
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_IndexTypes, index_type>...>);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Exts._Contains_multidimensional_index(_Index_seq, _Indices...),
+            "Value of extents_type::index-cast(i) must be a multidimensional index in extents_ (N4950 "
+            "[mdspan.layout.left.obs]/3).");
+#endif
+
+        index_type _Stride = 1;
+        index_type _Result = 0;
+        (((_Result += _Indices * _Stride), (_Stride *= this->_Exts.extent(_Seq))), ...);
+        return _Result;
+    }
+};
+
+template <class _Extents>
+class _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES layout_right::mapping
+    : private _Maybe_fully_static_extents<_Extents> {
+public:
+    using extents_type = _Extents;
+    using index_type   = extents_type::index_type;
+    using size_type    = extents_type::size_type;
+    using rank_type    = extents_type::rank_type;
+    using layout_type  = layout_right;
+
+private:
+    using _Base = _Maybe_fully_static_extents<extents_type>;
+
+    static_assert(_Is_extents<extents_type>,
+        "Extents must be a specialization of std::extents (N4950 [mdspan.layout.right.overview]/2).");
+    static_assert(
+        extents_type::rank_dynamic() != 0 || extents_type::_Is_static_multidim_index_space_size_representable(),
+        "If Extents::rank_dynamic() == 0 is true, then the size of the multidimensional index space Extents() must be "
+        "representable as a value of type typename Extents::index_type (N4950 [mdspan.layout.right.overview]/4).");
+
+public:
+    constexpr mapping() noexcept               = default;
+    constexpr mapping(const mapping&) noexcept = default;
+
+    constexpr mapping(const extents_type& _Exts_) noexcept : _Base(_Exts_) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (extents_type::rank_dynamic() != 0) {
+            _STL_VERIFY(_Exts_._Is_dynamic_multidim_index_space_size_representable(),
+                "The size of the multidimensional index space e must be representable as a value of type index_type "
+                "(N4950 [mdspan.layout.right.cons]/1).");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <class _OtherExtents>
+        requires is_constructible_v<extents_type, _OtherExtents>
+    constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+        mapping(const mapping<_OtherExtents>& _Other) noexcept
+        : _Base(_Other.extents()) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_STD in_range<index_type>(_Other.required_span_size()),
+            "Value of other.required_span_size() must be representable as a value of type index_type (N4950 "
+            "[mdspan.layout.right.cons]/4).");
+#endif
+    }
+
+    template <class _OtherExtents>
+        requires (extents_type::rank() <= 1) && is_constructible_v<extents_type, _OtherExtents>
+    constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+        mapping(const layout_left::mapping<_OtherExtents>& _Other) noexcept
+        : _Base(_Other.extents()) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_STD in_range<index_type>(_Other.required_span_size()),
+            "Value of other.required_span_size() must be representable as a value of type index_type (N4950 "
+            "[mdspan.layout.right.cons]/7).");
+#endif
+    }
+
+    template <class _OtherExtents>
+        requires is_constructible_v<extents_type, _OtherExtents>
+    constexpr explicit(!(extents_type::rank() == 0 && is_convertible_v<_OtherExtents, extents_type>) )
+        mapping(const layout_stride::mapping<_OtherExtents>& _Other) noexcept
+        : _Base(_Other.extents()) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (extents_type::rank() > 0) {
+            index_type _Prod = 1;
+            for (size_t _Idx = extents_type::_Rank; _Idx-- > 0;) {
+                _STL_VERIFY(_STD cmp_equal(_Prod, _Other.stride(_Idx)),
+                    "For all r in the range [0, extents_type::rank()), other.stride(r) must be equal to "
+                    "extents().rev-prod-of-extents(r) (N4950 [mdspan.layout.right.cons]/10.1).");
+                _Prod = static_cast<index_type>(_Prod * this->_Exts.extent(_Idx));
+            }
+        }
+        _STL_VERIFY(_STD in_range<index_type>(_Other.required_span_size()),
+            "Value of other.required_span_size() must be representable as a value of type index_type (N4950 "
+            "[mdspan.layout.right.cons]/10.2).");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+
+    _NODISCARD constexpr const extents_type& extents() const noexcept {
+        return this->_Exts;
+    }
+
+    _NODISCARD constexpr index_type required_span_size() const noexcept {
+        return _Fwd_prod_of_extents<extents_type>::_Calculate(this->_Exts, extents_type::_Rank);
+    }
+
+    template <class... _IndexTypes>
+        requires (sizeof...(_IndexTypes) == extents_type::rank())
+              && conjunction_v<is_convertible<_IndexTypes, index_type>...,
+                  is_nothrow_constructible<index_type, _IndexTypes>...>
+    _NODISCARD constexpr index_type operator()(_IndexTypes... _Indices) const noexcept {
+        return _Index_impl(
+            make_index_sequence<extents_type::rank()>{}, static_cast<index_type>(_STD move(_Indices))...);
+    }
+
+    _NODISCARD static constexpr bool is_always_unique() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_always_exhaustive() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_always_strided() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_unique() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_exhaustive() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_strided() noexcept {
+        return true;
+    }
+
+    _NODISCARD constexpr index_type stride(_In_range_(<, extents_type::_Rank) const rank_type _Idx) const noexcept
+        requires (extents_type::rank() > 0)
+    {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Idx < extents_type::_Rank,
+            "Value of i must be less than extents_type::rank() (N4950 [mdspan.layout.right.obs]/6).");
+#endif
+        return _Rev_prod_of_extents<extents_type>::_Calculate(this->_Exts, _Idx);
+    }
+
+    template <class _OtherExtents>
+        requires (extents_type::rank() == _OtherExtents::rank())
+    _NODISCARD friend constexpr bool operator==(const mapping& _Left, const mapping<_OtherExtents>& _Right) noexcept {
+        return _Left._Exts == _Right.extents();
+    }
+
+private:
+    template <class... _IndexTypes, size_t... _Seq>
+    _NODISCARD constexpr index_type _Index_impl(
+        [[maybe_unused]] index_sequence<_Seq...> _Index_seq, _IndexTypes... _Indices) const noexcept {
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_IndexTypes, index_type>...>);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Exts._Contains_multidimensional_index(_Index_seq, _Indices...),
+            "Value of extents_type::index-cast(i) must be a multidimensional index in extents_ (N4950 "
+            "[mdspan.layout.right.obs]/3).");
+#endif
+
+        index_type _Result = 0;
+        ((_Result = static_cast<index_type>(_Indices + this->_Exts.extent(_Seq) * _Result)), ...);
+        return _Result;
+    }
+};
+
+template <class _Mp>
+concept _Layout_mapping_alike = requires {
+    requires _Is_extents<typename _Mp::extents_type>;
+    { _Mp::is_always_strided() } -> same_as<bool>;
+    { _Mp::is_always_exhaustive() } -> same_as<bool>;
+    { _Mp::is_always_unique() } -> same_as<bool>;
+    bool_constant<_Mp::is_always_strided()>::value;
+    bool_constant<_Mp::is_always_exhaustive()>::value;
+    bool_constant<_Mp::is_always_unique()>::value;
+};
+
+template <class _Extents>
+_NODISCARD constexpr size_t _Count_dynamic_extents_equal_to_one(const _Extents& _Exts) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents> && _Extents::rank_dynamic() != 0);
+    return static_cast<size_t>(_RANGES count(_Exts._Array, static_cast<_Extents::index_type>(1)));
+}
+
+template <class _Extents>
+class _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES layout_stride::mapping
+    : private _Maybe_fully_static_extents<_Extents>,
+      private _Maybe_empty_array<typename _Extents::index_type, _Extents::rank()> {
+public:
+    using extents_type = _Extents;
+    using index_type   = extents_type::index_type;
+    using size_type    = extents_type::size_type;
+    using rank_type    = extents_type::rank_type;
+    using layout_type  = layout_stride;
+
+private:
+    using _Extents_base       = _Maybe_fully_static_extents<extents_type>;
+    using _Strides_base       = _Maybe_empty_array<index_type, _Extents::rank()>;
+    using _Stride_extent_pair = pair<index_type, index_type>;
+
+    static_assert(_Is_extents<extents_type>,
+        "Extents must be a specialization of std::extents (N4950 [mdspan.layout.stride.overview]/2).");
+    static_assert(
+        extents_type::rank_dynamic() != 0 || extents_type::_Is_static_multidim_index_space_size_representable(),
+        "If Extents::rank_dynamic() == 0 is true, then the size of the multidimensional index space Extents() must be "
+        "representable as a value of type typename Extents::index_type (N4950 [mdspan.layout.stride.overview]/4).");
+
+    template <class _OtherIndexType, size_t... _Indices>
+    constexpr mapping(const extents_type& _Exts_, span<_OtherIndexType, extents_type::rank()> _Strides_,
+        index_sequence<_Indices...>) noexcept
+        : _Extents_base(_Exts_), _Strides_base{static_cast<index_type>(_STD as_const(_Strides_[_Indices]))...} {
+        _STL_INTERNAL_STATIC_ASSERT(is_convertible_v<const _OtherIndexType&, index_type>
+                                    && is_nothrow_constructible_v<index_type, const _OtherIndexType&>);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (extents_type::rank() != 0) {
+            bool _Found_zero          = false;
+            bool _Overflow            = false;
+            index_type _Req_span_size = 0;
+            array<_Stride_extent_pair, extents_type::rank()> _Pairs;
+            for (rank_type _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+                const index_type _Stride = this->_Array[_Idx];
+                _STL_VERIFY(_Stride > 0, "Value of s[i] must be greater than 0 for all i in the range [0, rank_) "
+                                         "(N4950 [mdspan.layout.stride.cons]/4.1).");
+                const index_type _Ext = this->_Exts.extent(_Idx);
+                if (_Ext == 0) {
+                    _Found_zero = true;
+                }
+
+                if (!_Found_zero && !_Overflow) {
+                    index_type _Prod;
+                    _Overflow = _Mul_overflow(static_cast<index_type>(_Ext - 1), _Stride, _Prod)
+                             || _Add_overflow(_Req_span_size, _Prod, _Req_span_size);
+                }
+
+                _Pairs[_Idx] = {_Stride, _Ext};
+            }
+            _STL_VERIFY(_Found_zero || !_Overflow, "REQUIRED-SPAN-SIZE(e, s) must be representable as a value of type "
+                                                   "index_type (N4950 [mdspan.layout.stride.cons]/4.2).");
+
+            if (!_Found_zero) {
+                _RANGES sort(_Pairs);
+                for (rank_type _Idx = 1; _Idx < extents_type::_Rank; ++_Idx) {
+                    _STL_VERIFY(_Pairs[_Idx].first >= _Pairs[_Idx - 1].first * _Pairs[_Idx - 1].second,
+                        "If rank_ is greater than 0, then there must exist a permutation P of the integers in the "
+                        "range [0, rank_), such that 's[p(i)] >= s[p(i-1)] * e.extent(p(i-1))' is true for all i in "
+                        "the range [1, rank_), where p(i) is the i-th element of P (N5008 "
+                        "[mdspan.layout.stride.cons]/4.3).");
+                }
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+public:
+    constexpr mapping() noexcept : _Extents_base(extents_type{}) {
+        if constexpr (extents_type::rank() != 0) {
+            this->_Array.back() = 1;
+            for (rank_type _Idx = extents_type::_Rank - 1; _Idx-- > 0;) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                const bool _Overflow =
+                    _Mul_overflow(this->_Array[_Idx + 1], this->_Exts.extent(_Idx + 1), this->_Array[_Idx]);
+                // NB: N4950 requires value of 'layout_right::mapping<extents_type>().required_span_size()' to be
+                // representable as a value of type 'index_type', but this is not enough. We need to require every
+                // single stride to be representable as a value of type 'index_type', so we can get desired effects.
+                _STL_VERIFY(!_Overflow,
+                    "Value of layout_right::mapping<extents_type>().required_span_size() must be "
+                    "representable as a value of type index_type (N4950 [mdspan.layout.stride.cons]/1).");
+#else // ^^^ _ITERATOR_DEBUG_LEVEL != 0 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+                this->_Array[_Idx] = static_cast<index_type>(this->_Array[_Idx + 1] * this->_Exts.extent(_Idx + 1));
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+            }
+        }
+    }
+
+    constexpr mapping(const mapping&) noexcept = default;
+
+    template <class _OtherIndexType>
+        requires is_convertible_v<const _OtherIndexType&, index_type>
+              && is_nothrow_constructible_v<index_type, const _OtherIndexType&>
+    constexpr mapping(const extents_type& _Exts_, span<_OtherIndexType, extents_type::rank()> _Strides_) noexcept
+        : mapping(_Exts_, _Strides_, make_index_sequence<extents_type::rank()>{}) {}
+
+    template <class _OtherIndexType>
+        requires is_convertible_v<const _OtherIndexType&, index_type>
+              && is_nothrow_constructible_v<index_type, const _OtherIndexType&>
+    constexpr mapping(
+        const extents_type& _Exts_, const array<_OtherIndexType, extents_type::rank()>& _Strides_) noexcept
+        : mapping(_Exts_, span{_Strides_}, make_index_sequence<extents_type::rank()>{}) {}
+
+    template <class _StridedLayoutMapping>
+        requires _Layout_mapping_alike<_StridedLayoutMapping>
+              && is_constructible_v<extents_type, typename _StridedLayoutMapping::extents_type>
+              && (_StridedLayoutMapping::is_always_unique()) && (_StridedLayoutMapping::is_always_strided())
+    constexpr explicit(!(
+        is_convertible_v<typename _StridedLayoutMapping::extents_type, extents_type>
+        && (_Is_mapping_of<layout_left, _StridedLayoutMapping> || _Is_mapping_of<layout_right, _StridedLayoutMapping>
+            || _Is_mapping_of<layout_stride, _StridedLayoutMapping>) ))
+        mapping(const _StridedLayoutMapping& _Other) noexcept
+        : _Extents_base(_Other.extents()) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_STD in_range<index_type>(_Other.required_span_size()),
+            "Value of other.required_span_size() must be representable as a value of type index_type (N4950 "
+            "[mdspan.layout.stride.cons]/7.3).");
+        _STL_VERIFY(
+            _Offset(_Other) == 0, "Value of OFFSET(other) must be equal to 0 (N4950 [mdspan.layout.stride.cons]/7.4).");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (extents_type::_Rank != 0) {
+            for (rank_type _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+                const auto _Stride = _Other.stride(_Idx);
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Stride > 0, "Value of other.stride(r) must be greater than 0 for every rank index r of "
+                                         "extents() (N4950 [mdspan.layout.stride.cons]/7.2).");
+#endif
+                this->_Array[_Idx] = static_cast<index_type>(_Stride);
+            }
+        }
+    }
+
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+
+    _NODISCARD constexpr const extents_type& extents() const noexcept {
+        return this->_Exts;
+    }
+
+    _NODISCARD constexpr array<index_type, extents_type::rank()> strides() const noexcept {
+        if constexpr (extents_type::rank() == 0) {
+            return {};
+        } else {
+            return this->_Array;
+        }
+    }
+
+    _NODISCARD constexpr index_type required_span_size() const noexcept {
+        if constexpr (extents_type::rank() == 0) {
+            return 1;
+        } else {
+            index_type _Result = 1;
+            for (rank_type _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+                const index_type _Ext = this->_Exts.extent(_Idx);
+                if (_Ext == 0) {
+                    return 0;
+                }
+
+                _Result += (_Ext - 1) * this->_Array[_Idx];
+            }
+
+            return _Result;
+        }
+    }
+
+    template <class... _IndexTypes>
+        requires (sizeof...(_IndexTypes) == extents_type::rank())
+              && conjunction_v<is_convertible<_IndexTypes, index_type>...,
+                  is_nothrow_constructible<index_type, _IndexTypes>...>
+    _NODISCARD constexpr index_type operator()(_IndexTypes... _Indices) const noexcept {
+        return _Index_impl(
+            make_index_sequence<extents_type::rank()>{}, static_cast<index_type>(_STD move(_Indices))...);
+    }
+
+    _NODISCARD static constexpr bool is_always_unique() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_always_exhaustive() noexcept {
+        return extents_type::_Rank == 0 || extents_type::_Multidim_index_space_size_is_always_zero;
+    }
+
+    _NODISCARD static constexpr bool is_always_strided() noexcept {
+        return true;
+    }
+
+    _NODISCARD static constexpr bool is_unique() noexcept {
+        return true;
+    }
+
+    _NODISCARD constexpr bool is_exhaustive() const noexcept {
+        if constexpr (is_always_exhaustive()) {
+            return true;
+        } else if constexpr (extents_type::rank() == 1) {
+            return this->_Array[0] == 1 || this->_Exts.extent(0) == 0;
+        } else if constexpr (extents_type::rank() == 2) {
+            return (this->_Array[0] == 1 && this->_Array[1] == this->_Exts.extent(0))
+                || (this->_Array[1] == 1 && this->_Array[0] == this->_Exts.extent(1)) || this->_Exts.extent(0) == 0
+                || this->_Exts.extent(1) == 0;
+        } else if constexpr (_RANGES count(extents_type::_Static_extents, static_cast<rank_type>(1)) != 0) {
+            // NB: Extents equal to 1 are problematic - sometimes in such cases even when the mapping is exhaustive
+            // this function should return false.
+            // For example, when the extents are [2, 1, 2] and the strides are [1, 5, 2], the mapping is exhaustive
+            // per N5008 [mdspan.layout.reqmts]/16 but not per N5008 [mdspan.layout.stride.obs]/5.2.
+            return _Is_exhaustive_special_case();
+        } else if constexpr (extents_type::rank_dynamic() == 0) {
+            return _Is_exhaustive_common_case();
+        } else {
+            if (_Count_dynamic_extents_equal_to_one(this->_Exts) != 0) {
+                return _Is_exhaustive_special_case();
+            }
+
+            return _Is_exhaustive_common_case();
+        }
+    }
+
+    _NODISCARD static constexpr bool is_strided() noexcept {
+        return true;
+    }
+
+    _NODISCARD constexpr index_type stride(_In_range_(<, extents_type::_Rank) const rank_type _Idx) const noexcept {
+        if constexpr (extents_type::rank() == 0) {
+            _STL_REPORT_ERROR("The argument to stride must be nonnegative and less than extents_type::rank().");
+            return 1;
+        } else {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Idx < extents_type::_Rank,
+                "The argument to stride must be nonnegative and less than extents_type::rank().");
+#endif
+            return this->_Array[_Idx];
+        }
+    }
+
+    template <class _OtherMapping>
+        requires _Layout_mapping_alike<_OtherMapping> && (extents_type::rank() == _OtherMapping::extents_type::rank())
+              && (_OtherMapping::is_always_strided())
+    _NODISCARD friend constexpr bool operator==(const mapping& _Left, const _OtherMapping& _Right) noexcept {
+        if constexpr (extents_type::rank() != 0) {
+            if (_Left.extents() != _Right.extents()) {
+                return false;
+            }
+
+            for (rank_type _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+                if (_STD cmp_not_equal(_Left.stride(_Idx), _Right.stride(_Idx))) {
+                    return false;
+                }
+            }
+        }
+
+        return _Offset(_Right) == 0;
+    }
+
+private:
+    template <class _OtherMapping>
+    _NODISCARD static constexpr _OtherMapping::index_type _Offset(_OtherMapping& _Mapping) noexcept {
+        if constexpr (extents_type::rank() == 0) {
+            return _Mapping();
+        } else {
+            for (rank_type _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+                if (_Mapping.extents().extent(_Idx) == 0) {
+                    return 0;
+                }
+            }
+
+            return [&]<size_t... _Indices>(index_sequence<_Indices...>) { return _Mapping(((void) _Indices, 0)...); }(
+                       make_index_sequence<extents_type::rank()>{});
+        }
+    }
+
+    template <class... _IndexTypes, size_t... _Seq>
+    _NODISCARD constexpr index_type _Index_impl(
+        [[maybe_unused]] index_sequence<_Seq...> _Index_seq, _IndexTypes... _Indices) const noexcept {
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_IndexTypes, index_type>...>);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Exts._Contains_multidimensional_index(_Index_seq, _Indices...),
+            "Value of extents_type::index-cast(i) must be a multidimensional index in extents_ (N4950 "
+            "[mdspan.layout.stride.obs]/3).");
+#endif
+
+        return static_cast<index_type>(((_Indices * this->_Array[_Seq]) + ... + 0));
+    }
+
+    _NODISCARD constexpr bool _Is_exhaustive_common_case() const noexcept {
+        const index_type _Prod = _Fwd_prod_of_extents<extents_type>::_Calculate(this->_Exts, extents_type::_Rank);
+        return _Prod == required_span_size() || _Prod == 0;
+    }
+
+    _NODISCARD constexpr bool _Is_exhaustive_special_case() const noexcept {
+        array<_Stride_extent_pair, extents_type::rank()> _Pairs;
+        for (rank_type _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+            const index_type _Ext = this->_Exts.extent(_Idx);
+            if (_Ext == 0) {
+                return true;
+            }
+
+            _Pairs[_Idx] = {this->_Array[_Idx], _Ext};
+        }
+
+        _RANGES sort(_Pairs);
+        if (_Pairs[0].first != 1) {
+            return false;
+        }
+
+        for (rank_type _Idx = 1; _Idx < extents_type::_Rank; ++_Idx) {
+            if (_Pairs[_Idx].first != _Pairs[_Idx - 1].first * _Pairs[_Idx - 1].second) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+_EXPORT_STD template <class _ElementType>
+struct default_accessor {
+    using offset_policy    = default_accessor;
+    using element_type     = _ElementType;
+    using reference        = _ElementType&;
+    using data_handle_type = _ElementType*;
+
+    static_assert(
+        sizeof(element_type) > 0, "ElementType must be a complete type (N4950 [mdspan.accessor.default.overview]/2).");
+    static_assert(!is_abstract_v<element_type>,
+        "ElementType cannot be an abstract type (N4950 [mdspan.accessor.default.overview]/2).");
+    static_assert(
+        !is_array_v<element_type>, "ElementType cannot be an array type (N4950 [mdspan.accessor.default.overview]/2).");
+
+    constexpr default_accessor() noexcept = default;
+
+    template <class _OtherElementType>
+        requires is_convertible_v<_OtherElementType (*)[], element_type (*)[]>
+    constexpr default_accessor(default_accessor<_OtherElementType>) noexcept {}
+
+    _NODISCARD constexpr reference access(data_handle_type _Ptr, size_t _Idx) const noexcept {
+        return _Ptr[_Idx];
+    }
+
+    _NODISCARD constexpr data_handle_type offset(data_handle_type _Ptr, size_t _Idx) const noexcept {
+        return _Ptr + _Idx;
+    }
+};
+
+template <class _LayoutPolicy, class _Extents>
+concept _Elidable_layout_mapping =
+    (_Is_any_of_v<_LayoutPolicy, layout_left, layout_right> && _Extents::rank_dynamic() == 0)
+    || (same_as<_LayoutPolicy, layout_stride> && _Extents::rank() == 0);
+
+template <class _Extents, class _LayoutPolicy>
+struct _Mdspan_mapping_holder {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents>);
+
+    using _Mapping = _LayoutPolicy::template mapping<_Extents>;
+
+    constexpr _Mdspan_mapping_holder() noexcept = default;
+
+    constexpr explicit _Mdspan_mapping_holder(const _Extents& _Exts) : _Map(_Exts) {}
+
+    constexpr explicit _Mdspan_mapping_holder(_Extents&& _Exts) : _Map(_STD move(_Exts)) {}
+
+    template <class _OtherMapping>
+    constexpr explicit _Mdspan_mapping_holder(const _OtherMapping& _Map_) : _Map(_Map_) {}
+
+    _MSVC_NO_UNIQUE_ADDRESS _Mapping _Map = _Mapping();
+};
+
+template <class _Extents, _Elidable_layout_mapping<_Extents> _LayoutPolicy>
+struct _Mdspan_mapping_holder<_Extents, _LayoutPolicy> {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_extents<_Extents>);
+
+    using _Mapping = _LayoutPolicy::template mapping<_Extents>;
+
+    constexpr _Mdspan_mapping_holder() noexcept = default;
+
+    constexpr explicit _Mdspan_mapping_holder(const _Extents&) noexcept {}
+
+    constexpr explicit _Mdspan_mapping_holder(_Extents&&) noexcept {}
+
+    template <class _OtherMapping>
+    constexpr explicit _Mdspan_mapping_holder(const _OtherMapping& _Map_) {
+        // NB: Constructing _Mapping from _OtherMapping may have side effects - we should create a temporary.
+        if constexpr (!_Elidable_layout_mapping<typename _OtherMapping::layout_type, _Extents>) {
+            (void) _Mapping{_Map_};
+        }
+    }
+
+    static constexpr _Mapping _Map{};
+};
+
+template <class _AccessorPolicy>
+concept _Elidable_accessor_policy = _Is_specialization_v<_AccessorPolicy, default_accessor>;
+
+template <class _AccessorPolicy>
+struct _Mdspan_accessor_holder {
+    constexpr _Mdspan_accessor_holder() noexcept = default;
+
+    template <class _OtherAccessorPolicy>
+    constexpr explicit _Mdspan_accessor_holder(const _OtherAccessorPolicy& _Acc_) : _Acc(_Acc_) {}
+
+    _MSVC_NO_UNIQUE_ADDRESS _AccessorPolicy _Acc = _AccessorPolicy();
+};
+
+template <_Elidable_accessor_policy _AccessorPolicy>
+struct _Mdspan_accessor_holder<_AccessorPolicy> {
+    constexpr _Mdspan_accessor_holder() noexcept = default;
+
+    template <class _OtherAccessorPolicy>
+    constexpr explicit _Mdspan_accessor_holder(const _OtherAccessorPolicy& _Acc_) {
+        // NB: Constructing _AccessorPolicy from _OtherAccessorPolicy may have side effects - we should create a
+        // temporary.
+        if constexpr (!_Elidable_accessor_policy<_OtherAccessorPolicy>) {
+            (void) _AccessorPolicy{_Acc_};
+        }
+    }
+
+    static constexpr _AccessorPolicy _Acc{};
+};
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+template <class _IndexType, class _OtherIndexType>
+_NODISCARD constexpr _IndexType _Mdspan_checked_index_cast(_OtherIndexType&& _Idx)
+    noexcept(is_nothrow_constructible_v<_IndexType, _OtherIndexType>) {
+    _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_IndexType> && is_constructible_v<_IndexType, _OtherIndexType>);
+
+    using _Arg_value_t = remove_cvref_t<_OtherIndexType>;
+    if constexpr (is_integral_v<_Arg_value_t> && !is_same_v<_Arg_value_t, bool>) {
+        _STL_VERIFY(_STD in_range<_IndexType>(_Idx),
+            "Each argument to operator[] must be representable by index_type in order for the pack of arguments to be "
+            "a valid multidimensional index (N4964 [mdspan.mdspan.members]/3).");
+    }
+    return static_cast<_IndexType>(_STD forward<_OtherIndexType>(_Idx));
+}
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+_EXPORT_STD template <class _ElementType, class _Extents, class _LayoutPolicy = layout_right,
+    class _AccessorPolicy = default_accessor<_ElementType>>
+class mdspan {
+public:
+    using extents_type     = _Extents;
+    using layout_type      = _LayoutPolicy;
+    using accessor_type    = _AccessorPolicy;
+    using mapping_type     = layout_type::template mapping<extents_type>;
+    using element_type     = _ElementType;
+    using value_type       = remove_cv_t<element_type>;
+    using index_type       = extents_type::index_type;
+    using size_type        = extents_type::size_type;
+    using rank_type        = extents_type::rank_type;
+    using data_handle_type = accessor_type::data_handle_type;
+    using reference        = accessor_type::reference;
+
+private:
+    static_assert(
+        sizeof(element_type) > 0, "ElementType must be a complete type (N4950 [mdspan.mdspan.overview]/2.1).");
+    static_assert(
+        is_object_v<element_type>, "ElementType must be an object type (N5032 [mdspan.mdspan.overview]/2.1).");
+    static_assert(
+        !is_abstract_v<element_type>, "ElementType cannot be an abstract type (N4950 [mdspan.mdspan.overview]/2.1).");
+    static_assert(
+        !is_array_v<element_type>, "ElementType cannot be an array type (N4950 [mdspan.mdspan.overview]/2.1).");
+    static_assert(_Is_extents<extents_type>,
+        "Extents must be a specialization of std::extents (N4950 [mdspan.mdspan.overview]/2.2).");
+    static_assert(is_same_v<element_type, typename accessor_type::element_type>,
+        "ElementType and typename AccessorPolicy::element_type must be the same type (N4950 "
+        "[mdspan.mdspan.overview]/2.3).");
+
+public:
+    _NODISCARD _Ret_range_(==, extents_type::_Rank) static constexpr rank_type rank() noexcept {
+        return extents_type::_Rank;
+    }
+
+    _NODISCARD static constexpr rank_type rank_dynamic() noexcept {
+        return extents_type::_Rank_dynamic;
+    }
+
+    _NODISCARD static constexpr size_t static_extent(_In_range_(<, extents_type::_Rank) const rank_type _Idx) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Idx < extents_type::_Rank, "Index must be less than rank() (N4950 [mdspan.extents.obs]/1)");
+#endif
+        return extents_type::_Static_extents[_Idx];
+    }
+
+    _NODISCARD constexpr index_type extent(_In_range_(<, extents_type::_Rank) const rank_type _Idx) const noexcept {
+        return _Mapping._Map.extents().extent(_Idx);
+    }
+
+    constexpr mdspan() noexcept(is_nothrow_default_constructible_v<data_handle_type>
+                                && is_nothrow_default_constructible_v<mapping_type>
+                                && is_nothrow_default_constructible_v<accessor_type>) // strengthened
+        requires (rank_dynamic() > 0) && is_default_constructible_v<data_handle_type>
+              && is_default_constructible_v<mapping_type> && is_default_constructible_v<accessor_type>
+    {}
+
+    constexpr mdspan(const mdspan&) = default;
+    constexpr mdspan(mdspan&&)      = default;
+
+    template <class... _OtherIndexTypes>
+        requires conjunction_v<is_convertible<_OtherIndexTypes, index_type>...,
+                     is_nothrow_constructible<index_type, _OtherIndexTypes>...>
+                  && (sizeof...(_OtherIndexTypes) == rank() || sizeof...(_OtherIndexTypes) == rank_dynamic())
+                  && is_constructible_v<mapping_type, extents_type> && is_default_constructible_v<accessor_type>
+    constexpr explicit mdspan(data_handle_type _Ptr_, _OtherIndexTypes... _Exts)
+        noexcept(is_nothrow_constructible_v<mapping_type, extents_type>
+                 && is_nothrow_default_constructible_v<accessor_type>) // strengthened
+        : _Mapping(extents_type{static_cast<index_type>(_STD move(_Exts))...}), _Accessor(), _Ptr(_STD move(_Ptr_)) {}
+
+    template <class _OtherIndexType, size_t _Size>
+        requires is_convertible_v<const _OtherIndexType&, index_type>
+                  && is_nothrow_constructible_v<index_type, const _OtherIndexType&>
+                  && (_Size == rank() || _Size == rank_dynamic())
+                  && is_constructible_v<mapping_type, extents_type> && is_default_constructible_v<accessor_type>
+    constexpr explicit(_Size != rank_dynamic()) mdspan(data_handle_type _Ptr_, span<_OtherIndexType, _Size> _Exts)
+        noexcept(is_nothrow_constructible_v<mapping_type, extents_type>
+                 && is_nothrow_default_constructible_v<accessor_type>) // strengthened
+        : _Mapping(extents_type{_Exts}), _Accessor(), _Ptr(_STD move(_Ptr_)) {}
+
+    template <class _OtherIndexType, size_t _Size>
+        requires is_convertible_v<const _OtherIndexType&, index_type>
+                  && is_nothrow_constructible_v<index_type, const _OtherIndexType&>
+                  && (_Size == rank() || _Size == rank_dynamic())
+                  && is_constructible_v<mapping_type, extents_type> && is_default_constructible_v<accessor_type>
+    constexpr explicit(_Size != rank_dynamic())
+        mdspan(data_handle_type _Ptr_, const array<_OtherIndexType, _Size>& _Exts)
+            noexcept(is_nothrow_constructible_v<mapping_type, extents_type>
+                     && is_nothrow_default_constructible_v<accessor_type>) // strengthened
+        : _Mapping(extents_type{_Exts}), _Accessor(), _Ptr(_STD move(_Ptr_)) {}
+
+    constexpr mdspan(data_handle_type _Ptr_, const extents_type& _Exts)
+        noexcept(is_nothrow_constructible_v<mapping_type, const extents_type&>
+                 && is_nothrow_default_constructible_v<accessor_type>) // strengthened
+        requires is_constructible_v<mapping_type, const extents_type&> && is_default_constructible_v<accessor_type>
+        : _Mapping(_Exts), _Accessor(), _Ptr(_STD move(_Ptr_)) {}
+
+    constexpr mdspan(data_handle_type _Ptr_, const mapping_type& _Map_)
+        noexcept(is_nothrow_copy_constructible_v<mapping_type>
+                 && is_nothrow_default_constructible_v<accessor_type>) // strengthened
+        requires is_default_constructible_v<accessor_type>
+        : _Mapping(_Map_), _Accessor(), _Ptr(_STD move(_Ptr_)) {}
+
+    constexpr mdspan(data_handle_type _Ptr_, const mapping_type& _Map_, const accessor_type& _Acc_) noexcept(
+        is_nothrow_copy_constructible_v<mapping_type> && is_nothrow_copy_constructible_v<accessor_type>) // strengthened
+        : _Mapping(_Map_), _Accessor(_Acc_), _Ptr(_STD move(_Ptr_)) {}
+
+    template <class _OtherElementType, class _OtherExtents, class _OtherLayoutPolicy, class _OtherAccessor>
+        requires is_constructible_v<mapping_type, const typename _OtherLayoutPolicy::template mapping<_OtherExtents>&>
+                  && is_constructible_v<accessor_type, const _OtherAccessor&>
+    constexpr explicit(
+        !is_convertible_v<const typename _OtherLayoutPolicy::template mapping<_OtherExtents>&, mapping_type>
+        || !is_convertible_v<const _OtherAccessor&, accessor_type>)
+        mdspan(const mdspan<_OtherElementType, _OtherExtents, _OtherLayoutPolicy, _OtherAccessor>& _Other)
+            noexcept(is_nothrow_constructible_v<data_handle_type, const typename _OtherAccessor::data_handle_type&>
+                     && is_nothrow_constructible_v<mapping_type,
+                         const typename _OtherLayoutPolicy::template mapping<_OtherExtents>&>
+                     && is_nothrow_constructible_v<accessor_type, const _OtherAccessor&>) // strengthened
+        : _Mapping(_Other.mapping()), _Accessor(_Other.accessor()), _Ptr(_Other.data_handle()) {
+        static_assert(is_constructible_v<data_handle_type, const typename _OtherAccessor::data_handle_type&>,
+            "The data_handle_type must be constructible from const typename OtherAccessor::data_handle_type& (N4950 "
+            "[mdspan.mdspan.cons]/20.1).");
+        static_assert(is_constructible_v<extents_type, _OtherExtents>,
+            "The extents_type must be constructible from OtherExtents (N4950 [mdspan.mdspan.cons]/20.2).");
+#if _MSVC_STL_HARDENING_MDSPAN || _ITERATOR_DEBUG_LEVEL != 0
+        for (rank_type _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+            const auto _Static_ext = extents_type::_Static_extents[_Idx];
+            _STL_VERIFY(_STD cmp_equal(_Static_ext, dynamic_extent) || _STD cmp_equal(_Static_ext, _Other.extent(_Idx)),
+                "For each rank index r of extents_type, static_extent(r) == dynamic_extent || static_extent(r) == "
+                "other.extent(r) must be true (N4950 [mdspan.mdspan.cons]/21.1).");
+        }
+#endif // _MSVC_STL_HARDENING_MDSPAN || _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    constexpr mdspan& operator=(const mdspan&) = default;
+    constexpr mdspan& operator=(mdspan&&)      = default;
+
+    template <class... _OtherIndexTypes>
+        requires conjunction_v<is_convertible<_OtherIndexTypes, index_type>...,
+                     is_nothrow_constructible<index_type, _OtherIndexTypes>...>
+              && (sizeof...(_OtherIndexTypes) == rank())
+    _NODISCARD constexpr reference operator[](_OtherIndexTypes... _Indices) const
+        noexcept(noexcept(_Access_impl(static_cast<index_type>(_STD move(_Indices))...))) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        return _Access_impl(_STD _Mdspan_checked_index_cast<index_type>(_STD move(_Indices))...);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL != 0 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return _Access_impl(static_cast<index_type>(_STD move(_Indices))...);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+private:
+    template <class _OtherIndexType, size_t... _Seq>
+    _NODISCARD constexpr reference _Multidimensional_subscript(
+        span<_OtherIndexType, rank()> _Indices, index_sequence<_Seq...>) const
+        noexcept(noexcept(_Access_impl(static_cast<index_type>(_STD as_const(_Indices[_Seq]))...))) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        return _Access_impl(_STD _Mdspan_checked_index_cast<index_type>(_STD as_const(_Indices[_Seq]))...);
+#else // ^^^ _ITERATOR_DEBUG_LEVEL != 0 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return _Access_impl(static_cast<index_type>(_STD as_const(_Indices[_Seq]))...);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+public:
+    template <class _OtherIndexType>
+        requires is_convertible_v<const _OtherIndexType&, index_type>
+              && is_nothrow_constructible_v<index_type, const _OtherIndexType&>
+    _NODISCARD constexpr reference operator[](span<_OtherIndexType, rank()> _Indices) const
+        noexcept(noexcept(_Multidimensional_subscript(_Indices, make_index_sequence<rank()>{}))) /* strengthened */ {
+        return _Multidimensional_subscript(_Indices, make_index_sequence<rank()>{});
+    }
+
+    template <class _OtherIndexType>
+        requires is_convertible_v<const _OtherIndexType&, index_type>
+              && is_nothrow_constructible_v<index_type, const _OtherIndexType&>
+    _NODISCARD constexpr reference operator[](const array<_OtherIndexType, rank()>& _Indices) const noexcept(
+        noexcept(_Multidimensional_subscript(span{_Indices}, make_index_sequence<rank()>{}))) /* strengthened */ {
+        return _Multidimensional_subscript(span{_Indices}, make_index_sequence<rank()>{});
+    }
+
+    _NODISCARD constexpr size_type size() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (rank_dynamic() != 0) {
+            _STL_VERIFY(
+                _Mapping._Map.extents().template _Is_dynamic_multidim_index_space_size_representable<size_type>(),
+                "The size of the multidimensional index space extents() must be representable as a value of type "
+                "size_type (N4950 [mdspan.mdspan.members]/7).");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return static_cast<size_type>(
+            _Fwd_prod_of_extents<extents_type>::_Calculate(_Mapping._Map.extents(), extents_type::_Rank));
+    }
+
+    _NODISCARD constexpr bool empty() const noexcept {
+        if constexpr (extents_type::_Multidim_index_space_size_is_always_zero) {
+            return true;
+        } else {
+            const extents_type& _Exts = _Mapping._Map.extents();
+            for (rank_type _Idx = 0; _Idx < extents_type::_Rank; ++_Idx) {
+                if (_Exts.extent(_Idx) == 0) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    friend constexpr void swap(mdspan& _Left, mdspan& _Right) noexcept {
+        swap(_Left._Ptr, _Right._Ptr); // intentional ADL
+
+        if constexpr (!_Elidable_layout_mapping<layout_type, extents_type>) {
+            swap(_Left._Mapping._Map, _Right._Mapping._Map); // intentional ADL
+        }
+
+        if constexpr (!_Elidable_accessor_policy<accessor_type>) {
+            swap(_Left._Accessor._Acc, _Right._Accessor._Acc); // intentional ADL
+        }
+    }
+
+    _NODISCARD constexpr const extents_type& extents() const noexcept {
+        return _Mapping._Map.extents();
+    }
+
+    _NODISCARD constexpr const data_handle_type& data_handle() const noexcept {
+        return _Ptr;
+    }
+
+    _NODISCARD constexpr const mapping_type& mapping() const noexcept {
+        return _Mapping._Map;
+    }
+
+    _NODISCARD constexpr const accessor_type& accessor() const noexcept {
+        return _Accessor._Acc;
+    }
+
+    _NODISCARD static constexpr bool is_always_unique() noexcept /* strengthened */ {
+        constexpr bool _Result = mapping_type::is_always_unique();
+        return _Result;
+    }
+
+    _NODISCARD static constexpr bool is_always_exhaustive() noexcept /* strengthened */ {
+        constexpr bool _Result = mapping_type::is_always_exhaustive();
+        return _Result;
+    }
+
+    _NODISCARD static constexpr bool is_always_strided() noexcept /* strengthened */ {
+        constexpr bool _Result = mapping_type::is_always_strided();
+        return _Result;
+    }
+
+    _NODISCARD constexpr bool is_unique() const noexcept(noexcept(_Mapping._Map.is_unique())) /* strengthened */ {
+        return _Mapping._Map.is_unique();
+    }
+
+    _NODISCARD constexpr bool is_exhaustive() const
+        noexcept(noexcept(_Mapping._Map.is_exhaustive())) /* strengthened */ {
+        return _Mapping._Map.is_exhaustive();
+    }
+
+    _NODISCARD constexpr bool is_strided() const noexcept(noexcept(_Mapping._Map.is_strided())) /* strengthened */ {
+        return _Mapping._Map.is_strided();
+    }
+
+    _NODISCARD constexpr index_type stride(const rank_type _Idx) const
+        noexcept(noexcept(_Mapping._Map.stride(_Idx))) /* strengthened */ {
+        return _Mapping._Map.stride(_Idx);
+    }
+
+private:
+    template <class... _OtherIndexTypes>
+    _NODISCARD constexpr reference _Access_impl(_OtherIndexTypes... _Indices) const
+        noexcept(noexcept(_Accessor._Acc.access(_Ptr, static_cast<size_t>(_Mapping._Map(_Indices...))))) {
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_OtherIndexTypes, index_type>...>);
+#if _MSVC_STL_HARDENING_MDSPAN || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(
+            _Mapping._Map.extents()._Contains_multidimensional_index(make_index_sequence<rank()>{}, _Indices...),
+            "mdspan subscript out of range; extents_type::index-cast(std::move(indices)) must be a multidimensional "
+            "index in extents() (N5001 [mdspan.mdspan.members]/3).");
+#endif
+
+        return _Accessor._Acc.access(_Ptr, static_cast<size_t>(_Mapping._Map(_Indices...)));
+    }
+
+    _MSVC_NO_UNIQUE_ADDRESS _Mdspan_mapping_holder<extents_type, layout_type> _Mapping;
+    _MSVC_NO_UNIQUE_ADDRESS _Mdspan_accessor_holder<accessor_type> _Accessor;
+    _MSVC_NO_UNIQUE_ADDRESS data_handle_type _Ptr = data_handle_type();
+};
+
+template <class _CArray>
+    requires (is_array_v<_CArray> && rank_v<_CArray> == 1)
+mdspan(_CArray&) -> mdspan<remove_all_extents_t<_CArray>, extents<size_t, extent_v<_CArray, 0>>>;
+
+template <class _Pointer>
+    requires (is_pointer_v<remove_reference_t<_Pointer>>)
+mdspan(_Pointer&&) -> mdspan<remove_pointer_t<remove_reference_t<_Pointer>>, extents<size_t>>;
+
+template <class _ElementType, class... _Integrals>
+    requires conjunction_v<is_convertible<_Integrals, size_t>...> && (sizeof...(_Integrals) > 0)
+explicit mdspan(_ElementType*, _Integrals...) -> mdspan<_ElementType, dextents<size_t, sizeof...(_Integrals)>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Nx>
+mdspan(_ElementType*, span<_OtherIndexType, _Nx>) -> mdspan<_ElementType, dextents<size_t, _Nx>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Nx>
+mdspan(_ElementType*, const array<_OtherIndexType, _Nx>&) -> mdspan<_ElementType, dextents<size_t, _Nx>>;
+
+template <class _ElementType, class _IndexType, size_t... _ExtentsPack>
+mdspan(_ElementType*, const extents<_IndexType, _ExtentsPack...>&)
+    -> mdspan<_ElementType, extents<_IndexType, _ExtentsPack...>>;
+
+template <class _ElementType, class _MappingType>
+mdspan(_ElementType*, const _MappingType&)
+    -> mdspan<_ElementType, typename _MappingType::extents_type, typename _MappingType::layout_type>;
+
+template <class _MappingType, class _AccessorType>
+mdspan(typename _AccessorType::data_handle_type, const _MappingType&, const _AccessorType&)
+    -> mdspan<typename _AccessorType::element_type, typename _MappingType::extents_type,
+        typename _MappingType::layout_type, _AccessorType>;
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX23 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _MDSPAN_
diff --git a/msvc-stl/stl/inc/memory b/msvc-stl/stl/inc/memory
new file mode 100644
index 0000000..02a1772
--- /dev/null
+++ b/msvc-stl/stl/inc/memory
@@ -0,0 +1,4606 @@
+// memory standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _MEMORY_
+#define _MEMORY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <exception>
+#include <iosfwd>
+#include <type_traits>
+#include <typeinfo>
+#include <xmemory>
+
+#if _HAS_CXX20
+#include <atomic>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#undef msvc
+
+_STD_BEGIN
+#if _HAS_CXX17
+#define _REQUIRE_PARALLEL_LVALUE_ITERATOR(_Iter)                                                                     \
+    static_assert(_Is_ranges_fwd_iter_v<_Iter> && is_lvalue_reference_v<_Iter_ref_t<_Iter>>,                         \
+        "Parallel specialized <memory> algorithms require the iterator type to be forward iterator and dereference " \
+        "to lvalues.")
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NoThrowFwdIt uninitialized_copy(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _NoThrowFwdIt _Dest) noexcept
+/* terminates */ {
+    // copy [_First, _Last) to raw [_Dest, ...)
+    // not parallelized at present
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+
+    return _STD uninitialized_copy(_First, _Last, _Dest);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using uninitialized_copy_result = in_out_result<_In, _Out>;
+
+    class _Uninitialized_copy_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, _No_throw_forward_iterator _Out,
+            _No_throw_sentinel_for<_Out> _OSe>
+            requires constructible_from<iter_value_t<_Out>, iter_reference_t<_It>>
+        static uninitialized_copy_result<_It, _Out> operator()(_It _First1, _Se _Last1, _Out _First2, _OSe _Last2) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UResult = _Uninitialized_copy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last1)), _RANGES _Unwrap_iter<_OSe>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_Out>(_STD move(_Last2)));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2)};
+        }
+
+        template <input_range _Rng1, _No_throw_forward_range _Rng2>
+            requires constructible_from<range_value_t<_Rng2>, range_reference_t<_Rng1>>
+        static uninitialized_copy_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2) {
+            auto _First1  = _RANGES begin(_Range1);
+            auto _UResult = _Uninitialized_copy_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in));
+            return {_STD move(_First1), _RANGES _Rewrap_iterator(_Range2, _STD move(_UResult.out))};
+        }
+
+    private:
+        template <class _It, class _Se, class _Out, class _OSe>
+        _NODISCARD static uninitialized_copy_result<_It, _Out> _Uninitialized_copy_unchecked(
+            _It _IFirst, _Se _ILast, _Out _OFirst, _OSe _OLast) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_forward_iterator<_Out>);
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_OSe, _Out>);
+            _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_Out>, iter_reference_t<_It>>);
+
+            constexpr bool _Is_sized1  = sized_sentinel_for<_Se, _It>;
+            constexpr bool _Is_sized2  = sized_sentinel_for<_OSe, _Out>;
+            constexpr bool _Can_memcpy = _Iter_copy_cat<_It, _Out>::_Bitcopy_constructible
+                                      && _Sized_or_unreachable_sentinel_for<_Se, _It>
+                                      && _Sized_or_unreachable_sentinel_for<_OSe, _Out>;
+            if constexpr (_Can_memcpy && (_Is_sized1 || _Is_sized2)) {
+                if constexpr (_Is_sized1 && _Is_sized2) {
+                    return _RANGES _Copy_memcpy_common(_IFirst, _RANGES next(_IFirst, _STD move(_ILast)), _OFirst,
+                        _RANGES next(_OFirst, _STD move(_OLast)));
+                } else if constexpr (_Is_sized1) {
+                    const auto _Dist = _ILast - _IFirst;
+                    _STD _Contiguous_iter_verify(_OFirst, static_cast<iter_difference_t<_Out>>(_Dist));
+                    return _RANGES _Copy_memcpy_distance(_IFirst, _OFirst, _IFirst, _IFirst + _Dist);
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(_Is_sized2);
+                    const auto _Dist = _OLast - _OFirst;
+                    _STD _Contiguous_iter_verify(_IFirst, static_cast<iter_difference_t<_It>>(_Dist));
+                    return _RANGES _Copy_memcpy_distance(_IFirst, _OFirst, _OFirst, _OFirst + _Dist);
+                }
+            } else {
+                if constexpr (_Can_memcpy) {
+                    // We were eligible for the memcpy optimization above, except for both sentinels being unreachable.
+                    // The following classic code is doomed, because no exceptions will end the infinite loop.
+                    // Following our usual pattern, let's emit a debug assertion, then run the loop anyways.
+                    _STL_ASSERT(false, "Tried to std::uninitialized_copy() two ranges with unreachable sentinels");
+                }
+
+                _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+                for (; _IFirst != _ILast && _Backout._Last != _OLast; ++_IFirst) {
+                    _Backout._Emplace_back(*_IFirst);
+                }
+
+                return {_STD move(_IFirst), _Backout._Release()};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_copy_fn uninitialized_copy;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Diff, class _NoThrowFwdIt>
+_NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) {
+    // copy [_First, _First + _Count) to [_Dest, ...)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return _Dest;
+    }
+
+    auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+    auto _UDest  = _STD _Get_unwrapped_n(_Dest, _Count);
+    if constexpr (_Iter_copy_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_constructible) {
+        _UDest = _STD _Copy_memcpy_n(_UFirst, static_cast<size_t>(_Count), _UDest);
+    } else {
+        _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
+
+        for (; _Count > 0; --_Count, (void) ++_UFirst) {
+            _Backout._Emplace_back_deref(_UFirst);
+        }
+
+        _UDest = _Backout._Release();
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _NoThrowFwdIt,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_NoThrowFwdIt uninitialized_copy_n(_ExPo&&, const _FwdIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) noexcept
+/* terminates */ {
+    // copy [_First, _First + _Count) to raw [_Dest, ...)
+    // not parallelized at present
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    return _STD uninitialized_copy_n(_First, _Count, _Dest);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using uninitialized_copy_n_result = in_out_result<_In, _Out>;
+
+    struct _Uninitialized_copy_n_fn {
+        template <input_iterator _It, _No_throw_forward_iterator _Out, _No_throw_sentinel_for<_Out> _OSe>
+            requires constructible_from<iter_value_t<_Out>, iter_reference_t<_It>>
+        static uninitialized_copy_n_result<_It, _Out> operator()(
+            _It _First1, iter_difference_t<_It> _Count, _Out _First2, _OSe _Last2) {
+            if (_Count <= 0) {
+                return {_STD move(_First1), _STD move(_First2)};
+            }
+
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _IFirst = _STD _Get_unwrapped_n(_STD move(_First1), _Count);
+            auto _OFirst = _RANGES _Unwrap_iter<_OSe>(_STD move(_First2));
+            auto _OLast  = _RANGES _Unwrap_sent<_Out>(_STD move(_Last2));
+            if constexpr (_Iter_copy_cat<_It, _Out>::_Bitcopy_constructible
+                          && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) {
+                if constexpr (sized_sentinel_for<_OSe, _Out>) {
+                    auto _UResult = _RANGES _Copy_memcpy_common(
+                        _IFirst, _IFirst + _Count, _OFirst, _RANGES next(_OFirst, _STD move(_OLast)));
+                    _IFirst = _STD move(_UResult.in);
+                    _OFirst = _STD move(_UResult.out);
+                } else {
+                    _STD _Contiguous_iter_verify(_IFirst, _Count);
+                    _STD _Contiguous_iter_verify(_OFirst, static_cast<iter_difference_t<_Out>>(_Count));
+                    auto _UResult = _RANGES _Copy_memcpy_count(_IFirst, _OFirst, static_cast<size_t>(_Count));
+                    _IFirst       = _STD move(_UResult.in);
+                    _OFirst       = _STD move(_UResult.out);
+                }
+            } else {
+                _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+                for (; _Count > 0 && _Backout._Last != _OLast; --_Count, (void) ++_IFirst) {
+                    _Backout._Emplace_back(*_IFirst);
+                }
+
+                _OFirst = _Backout._Release();
+            }
+
+            _STD _Seek_wrapped(_First1, _STD move(_IFirst));
+            _STD _Seek_wrapped(_First2, _STD move(_OFirst));
+            return {_STD move(_First1), _STD move(_First2)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_copy_n_fn uninitialized_copy_n;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _InIt, class _NoThrowFwdIt>
+_NoThrowFwdIt uninitialized_move(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+    // move [_First, _Last) to raw [_Dest, ...)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _UDest  = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Uninitialized_move_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NoThrowFwdIt uninitialized_move(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _NoThrowFwdIt _Dest) noexcept
+/* terminates */ {
+    // move [_First, _Last) to raw [_Dest, ...)
+    // not parallelized at present
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+
+    return _STD uninitialized_move(_First, _Last, _Dest);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Uninitialized_move_fn {
+        template <input_iterator _It, sentinel_for<_It> _Se, _No_throw_forward_iterator _Out,
+            _No_throw_sentinel_for<_Out> _OSe>
+            requires constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>
+        static uninitialized_move_result<_It, _Out> operator()(_It _First1, _Se _Last1, _Out _First2, _OSe _Last2) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UResult = _RANGES _Uninitialized_move_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First1)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last1)), _RANGES _Unwrap_iter<_OSe>(_STD move(_First2)),
+                _RANGES _Unwrap_sent<_Out>(_STD move(_Last2)));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_First2, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2)};
+        }
+
+        template <input_range _Rng1, _No_throw_forward_range _Rng2>
+            requires constructible_from<range_value_t<_Rng2>, range_rvalue_reference_t<_Rng1>>
+        static uninitialized_move_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2) {
+            auto _First1  = _RANGES begin(_Range1);
+            auto _UResult = _RANGES _Uninitialized_move_unchecked(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2));
+
+            _STD _Seek_wrapped(_First1, _STD move(_UResult.in));
+            return {_STD move(_First1), _RANGES _Rewrap_iterator(_Range2, _STD move(_UResult.out))};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_move_fn uninitialized_move;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Diff, class _NoThrowFwdIt>
+pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) {
+    // move [_First, _First + _Count) to [_Dest, ...)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return {_First, _Dest};
+    }
+
+    auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+    auto _UDest  = _STD _Get_unwrapped_n(_Dest, _Count);
+    if constexpr (_Iter_move_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_constructible) {
+        _UDest = _STD _Copy_memcpy_n(_UFirst, static_cast<size_t>(_Count), _UDest);
+        _UFirst += _Count;
+    } else {
+        _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};
+
+        for (; _Count > 0; --_Count, (void) ++_UFirst) {
+            _Backout._Emplace_back_deref_move(_UFirst);
+        }
+
+        _UDest = _Backout._Release();
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    _STD _Seek_wrapped(_First, _UFirst);
+    return {_First, _Dest};
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _NoThrowFwdIt,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+pair<_FwdIt, _NoThrowFwdIt> uninitialized_move_n(
+    _ExPo&&, const _FwdIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) noexcept /* terminates */ {
+    // move [_First, _First + _Count) to raw [_Dest, ...)
+    // not parallelized at present
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    return _STD uninitialized_move_n(_First, _Count, _Dest);
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, class _Tval, _Enable_if_execution_policy_t<_ExPo> = 0>
+void uninitialized_fill(_ExPo&&, const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) noexcept
+/* terminates */ {
+    // copy _Val throughout raw [_First, _Last)
+    // not parallelized at present
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+
+    _STD uninitialized_fill(_First, _Last, _Val);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    _EXPORT_STD template <class _In, class _Out>
+    using uninitialized_move_n_result = in_out_result<_In, _Out>;
+
+    struct _Uninitialized_move_n_fn {
+        template <input_iterator _It, _No_throw_forward_iterator _Out, _No_throw_sentinel_for<_Out> _OSe>
+            requires constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>
+        static uninitialized_move_n_result<_It, _Out> operator()(
+            _It _First1, iter_difference_t<_It> _Count, _Out _First2, _OSe _Last2) {
+            if (_Count <= 0) {
+                return {_STD move(_First1), _STD move(_First2)};
+            }
+
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _IFirst      = _STD _Get_unwrapped_n(_STD move(_First1), _Count);
+            auto _OFirst      = _RANGES _Unwrap_iter<_OSe>(_STD move(_First2));
+            const auto _OLast = _RANGES _Unwrap_sent<_Out>(_STD move(_Last2));
+            if constexpr (_Iter_move_cat<_It, _Out>::_Bitcopy_constructible
+                          && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) {
+                if constexpr (sized_sentinel_for<_OSe, _Out>) {
+                    auto _UResult = _RANGES _Copy_memcpy_common(
+                        _IFirst, _IFirst + _Count, _OFirst, _RANGES next(_OFirst, _STD move(_OLast)));
+                    _IFirst = _STD move(_UResult.in);
+                    _OFirst = _STD move(_UResult.out);
+                } else {
+                    _STD _Contiguous_iter_verify(_IFirst, _Count);
+                    _STD _Contiguous_iter_verify(_OFirst, static_cast<iter_difference_t<_Out>>(_Count));
+                    auto _UResult = _RANGES _Copy_memcpy_count(_IFirst, _OFirst, static_cast<size_t>(_Count));
+                    _IFirst       = _STD move(_UResult.in);
+                    _OFirst       = _STD move(_UResult.out);
+                }
+            } else {
+                _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+                for (; _Count > 0 && _Backout._Last != _OLast; --_Count, (void) ++_IFirst) {
+                    _Backout._Emplace_back(_RANGES iter_move(_IFirst));
+                }
+
+                _OFirst = _Backout._Release();
+            }
+
+            _STD _Seek_wrapped(_First1, _STD move(_IFirst));
+            _STD _Seek_wrapped(_First2, _STD move(_OFirst));
+            return {_STD move(_First1), _STD move(_First2)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_move_n_fn uninitialized_move_n;
+
+    class _Uninitialized_fill_fn {
+    public:
+        template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se, class _Ty>
+            requires constructible_from<iter_value_t<_It>, const _Ty&>
+        static _It operator()(_It _First, _Se _Last, const _Ty& _Val) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Uninitialized_fill_unchecked(
+                _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _Val);
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <_No_throw_forward_range _Rng, class _Ty>
+            requires constructible_from<range_value_t<_Rng>, const _Ty&>
+        static borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, const _Ty& _Val) {
+            return _RANGES _Rewrap_iterator(
+                _Range, _Uninitialized_fill_unchecked(_Ubegin(_Range), _Uend(_Range), _Val));
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty>
+        _NODISCARD static _It _Uninitialized_fill_unchecked(_It _OFirst, _Se _OLast, const _Ty& _Val) {
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_It>, const _Ty&>);
+
+            if constexpr (_Fill_memset_is_safe<_It, _Ty>) {
+                const auto _OFinal = _RANGES next(_OFirst, _STD move(_OLast));
+                _STD _Fill_memset(_OFirst, _Val, static_cast<size_t>(_OFinal - _OFirst));
+                return _OFinal;
+            } else {
+                if constexpr (_Fill_zero_memset_is_safe<_It, _Ty>) {
+                    if (_STD _Is_all_bits_zero(_Val)) {
+                        const auto _OFinal = _RANGES next(_OFirst, _STD move(_OLast));
+                        _STD _Fill_zero_memset(_OFirst, static_cast<size_t>(_OFinal - _OFirst));
+                        return _OFinal;
+                    }
+                }
+
+                _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+                while (_Backout._Last != _OLast) {
+                    _Backout._Emplace_back(_Val);
+                }
+
+                return _Backout._Release();
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_fill_fn uninitialized_fill;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _NoThrowFwdIt, class _Diff, class _Tval>
+_NoThrowFwdIt uninitialized_fill_n(_NoThrowFwdIt _First, const _Diff _Count_raw, const _Tval& _Val) {
+    // copy _Count copies of _Val to raw _First
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return _First;
+    }
+
+    auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+    if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Tval>) {
+        _STD _Fill_memset(_UFirst, _Val, static_cast<size_t>(_Count));
+        _UFirst += _Count;
+    } else {
+        if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Tval>) {
+            if (_STD _Is_all_bits_zero(_Val)) {
+                _STD _Fill_zero_memset(_UFirst, static_cast<size_t>(_Count));
+                _STD _Seek_wrapped(_First, _UFirst + _Count);
+                return _First;
+            }
+        }
+
+        _Uninitialized_backout<decltype(_UFirst)> _Backout{_UFirst};
+
+        for (; _Count > 0; --_Count) {
+            _Backout._Emplace_back(_Val);
+        }
+
+        _UFirst = _Backout._Release();
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, class _Diff, class _Tval,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_NoThrowFwdIt uninitialized_fill_n(
+    _ExPo&&, const _NoThrowFwdIt _First, const _Diff _Count_raw, const _Tval& _Val) noexcept
+/* terminates */ {
+    // copy _Count copies of _Val to raw _First
+    // not parallelized at present
+    _REQUIRE_PARALLEL_LVALUE_ITERATOR(_NoThrowFwdIt);
+
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    return _STD uninitialized_fill_n(_First, _Count, _Val);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Uninitialized_fill_n_fn {
+        template <_No_throw_forward_iterator _It, class _Ty>
+            requires constructible_from<iter_value_t<_It>, const _Ty&>
+        static _It operator()(_It _First, iter_difference_t<_It> _Count, const _Ty& _Val) {
+            if (_Count <= 0) {
+                return _First;
+            }
+
+            auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+            if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
+                _STD _Fill_memset(_UFirst, _Val, static_cast<size_t>(_Count));
+                _STD _Seek_wrapped(_First, _UFirst + _Count);
+            } else {
+                if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
+                    if (_STD _Is_all_bits_zero(_Val)) {
+                        _STD _Fill_zero_memset(_UFirst, static_cast<size_t>(_Count));
+                        _STD _Seek_wrapped(_First, _UFirst + _Count);
+                        return _First;
+                    }
+                }
+
+                _Uninitialized_backout _Backout{_STD move(_UFirst)};
+
+                for (; _Count > 0; --_Count) {
+                    _Backout._Emplace_back(_Val);
+                }
+
+                _STD _Seek_wrapped(_First, _Backout._Release());
+            }
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_fill_n_fn uninitialized_fill_n;
+
+    struct _Construct_at_fn {
+        template <class _Ty, class... _Types>
+            requires (!is_unbounded_array_v<_Ty>) && requires(_Ty* _Ptr, _Types&&... _Args) {
+                ::new (static_cast<void*>(_Ptr)) _Ty(static_cast<_Types&&>(_Args)...); // per LWG-3888
+            }
+        static constexpr _Ty* operator()(_Ty* _Location, _Types&&... _Args) noexcept(
+            noexcept(::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...))) /* strengthened */ {
+#ifdef __EDG__
+            return _STD construct_at(_Location, _STD forward<_Types>(_Args)...);
+#else // ^^^ EDG / Other vvv
+            if constexpr (is_array_v<_Ty>) {
+                static_assert(sizeof...(_Types) == 0, "The array is only allowed to be value-initialized by "
+                                                      "std::ranges::construct_at. (N5032 [specialized.construct]/2)");
+#if defined(__clang__) // TRANSITION, LLVM-117294
+                ::new (static_cast<void*>(_Location)) _Ty();
+                return __builtin_launder(_Location); // per old resolution of LWG-3436
+#else // ^^^ workaround / no workaround vvv
+                _MSVC_CONSTEXPR return ::new (static_cast<void*>(_Location)) _Ty[1]();
+#endif // ^^^ no workaround ^^^
+            } else {
+                _MSVC_CONSTEXPR return ::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...);
+            }
+#endif // ^^^ Other ^^^
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Construct_at_fn construct_at;
+
+    template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se>
+        requires destructible<iter_value_t<_It>>
+    _NODISCARD constexpr _It _Destroy_unchecked(_It _First, _Se _Last) noexcept;
+
+    struct _Destroy_at_fn {
+        template <destructible _Ty>
+        static constexpr void operator()(_Ty* const _Location) noexcept {
+            if constexpr (is_array_v<_Ty>) {
+                (void) _RANGES _Destroy_unchecked(_RANGES begin(*_Location), _RANGES end(*_Location));
+            } else {
+                _Location->~_Ty();
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Destroy_at_fn destroy_at;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _NoThrowFwdIt>
+_CONSTEXPR20 void destroy(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
+    // destroy all elements in [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Destroy_range(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void destroy(_ExPo&& _Exec, _NoThrowFwdIt _First, _NoThrowFwdIt _Last) noexcept; // terminates
+
+#if _HAS_CXX20
+namespace ranges {
+    template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se>
+        requires destructible<iter_value_t<_It>>
+    _NODISCARD constexpr _It _Destroy_unchecked(_It _First, _Se _Last) noexcept {
+        if (_STD is_constant_evaluated()) {
+            for (; _First != _Last; ++_First) {
+                _RANGES destroy_at(_STD addressof(*_First));
+            }
+        } else {
+            if constexpr (is_trivially_destructible_v<iter_value_t<_It>>) {
+                _RANGES advance(_First, _STD move(_Last));
+            } else {
+                for (; _First != _Last; ++_First) {
+                    _RANGES destroy_at(_STD addressof(*_First));
+                }
+            }
+        }
+
+        return _First;
+    }
+
+    struct _Destroy_fn {
+        template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se>
+            requires destructible<iter_value_t<_It>>
+        static constexpr _It operator()(_It _First, _Se _Last) noexcept {
+            _STD _Adl_verify_range(_First, _Last);
+            _STD _Seek_wrapped(_First, _RANGES _Destroy_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                                           _RANGES _Unwrap_sent<_It>(_STD move(_Last))));
+            return _First;
+        }
+
+        template <_No_throw_input_range _Rng>
+            requires destructible<range_value_t<_Rng>>
+        static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) noexcept {
+            auto _First = _RANGES begin(_Range);
+            _STD _Seek_wrapped(
+                _First, _RANGES _Destroy_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range)));
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Destroy_fn destroy;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _NoThrowFwdIt, class _Diff>
+_CONSTEXPR20 _NoThrowFwdIt destroy_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
+    // destroy all elements in [_First, _First + _Count)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return _First;
+    }
+
+    auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        for (; _Count > 0; --_Count, (void) ++_UFirst) {
+            _STD _Destroy_in_place(*_UFirst);
+        }
+    } else
+#endif // _HAS_CXX20
+    {
+        if constexpr (is_trivially_destructible_v<_Iter_value_t<_NoThrowFwdIt>>) {
+            _STD advance(_UFirst, _Count);
+        } else {
+            for (; _Count > 0; --_Count, (void) ++_UFirst) {
+                _STD _Destroy_in_place(*_UFirst);
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NoThrowFwdIt destroy_n(_ExPo&& _Exec, _NoThrowFwdIt _First, _Diff _Count_raw) noexcept; // terminates
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Destroy_n_fn {
+        template <_No_throw_input_iterator _It>
+            requires destructible<iter_value_t<_It>>
+        static constexpr _It operator()(_It _First, iter_difference_t<_It> _Count) noexcept {
+            if (_Count <= 0) {
+                return _First;
+            }
+
+            auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+            if (_STD is_constant_evaluated()) {
+                do {
+                    _RANGES destroy_at(_STD addressof(*_UFirst));
+                    ++_UFirst;
+                    --_Count;
+                } while (_Count > 0);
+            } else {
+                if constexpr (is_trivially_destructible_v<iter_value_t<_It>>) {
+                    _RANGES advance(_UFirst, _Count);
+                } else {
+                    do {
+                        _RANGES destroy_at(_STD addressof(*_UFirst));
+                        ++_UFirst;
+                        --_Count;
+                    } while (_Count > 0);
+                }
+            }
+
+            _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Destroy_n_fn destroy_n;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _NoThrowFwdIt>
+void uninitialized_default_construct(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
+    // default-initialize all elements in [_First, _Last)
+    using _Ty = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
+    _STD _Adl_verify_range(_First, _Last);
+    if constexpr (!is_trivially_default_constructible_v<_Ty>) {
+        _Uninitialized_backout _Backout{_STD _Get_unwrapped(_First)};
+
+        for (const auto _ULast = _STD _Get_unwrapped(_Last); _Backout._Last != _ULast; ++_Backout._Last) {
+            _STD _Default_construct_in_place(*_Backout._Last);
+        }
+
+        _Backout._Release();
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void uninitialized_default_construct(_ExPo&& _Exec, _NoThrowFwdIt _First, _NoThrowFwdIt _Last) noexcept; // terminates
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Uninitialized_default_construct_fn {
+    public:
+        template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se>
+            requires default_initializable<iter_value_t<_It>>
+        static _It operator()(_It _First, _Se _Last) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Uninitialized_default_construct_unchecked(
+                _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <_No_throw_forward_range _Rng>
+            requires default_initializable<range_value_t<_Rng>>
+        static borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) {
+            auto _UResult = _Uninitialized_default_construct_unchecked(_Ubegin(_Range), _Uend(_Range));
+
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Se>
+        _NODISCARD static _It _Uninitialized_default_construct_unchecked(_It _OFirst, const _Se _OLast) {
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(default_initializable<iter_value_t<_It>>);
+
+            using _Ty = remove_reference_t<iter_reference_t<_It>>;
+            if constexpr (is_trivially_default_constructible_v<_Ty>) {
+                _RANGES advance(_OFirst, _OLast);
+                return _OFirst;
+            } else {
+                _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+                for (; _Backout._Last != _OLast; ++_Backout._Last) {
+                    _STD _Default_construct_in_place(*_Backout._Last);
+                }
+
+                return _Backout._Release();
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_default_construct_fn uninitialized_default_construct;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _NoThrowFwdIt, class _Diff>
+_NoThrowFwdIt uninitialized_default_construct_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
+    // default-initialize all elements in [_First, _First + _Count)
+    using _Ty                      = _Iter_value_t<_NoThrowFwdIt>;
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return _First;
+    }
+
+    if constexpr (is_trivially_default_constructible_v<_Ty>) {
+        _STD advance(_First, _Count);
+    } else {
+        _Uninitialized_backout _Backout{_STD _Get_unwrapped_n(_First, _Count)};
+
+        for (; _Count > 0; ++_Backout._Last, (void) --_Count) {
+            _STD _Default_construct_in_place(*_Backout._Last);
+        }
+
+        _STD _Seek_wrapped(_First, _Backout._Release());
+    }
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NoThrowFwdIt uninitialized_default_construct_n(
+    _ExPo&& _Exec, _NoThrowFwdIt _First, _Diff _Count_raw) noexcept; // terminates
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Uninitialized_default_construct_n_fn {
+        template <_No_throw_forward_iterator _It>
+            requires default_initializable<iter_value_t<_It>>
+        static _It operator()(_It _First, iter_difference_t<_It> _Count) {
+            if (_Count <= 0) {
+                return _First;
+            }
+
+            using _Ty = remove_reference_t<iter_reference_t<_It>>;
+            if constexpr (is_trivially_default_constructible_v<_Ty>) {
+                _RANGES advance(_First, _Count);
+            } else {
+                _Uninitialized_backout _Backout{_STD _Get_unwrapped_n(_STD move(_First), _Count)};
+
+                for (; _Count > 0; --_Count, (void) ++_Backout._Last) {
+                    _STD _Default_construct_in_place(*_Backout._Last);
+                }
+
+                _STD _Seek_wrapped(_First, _Backout._Release());
+            }
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_default_construct_n_fn uninitialized_default_construct_n;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _NoThrowFwdIt>
+void uninitialized_value_construct(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
+    // value-initialize all elements in [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    if constexpr (_Use_memset_value_construct_v<_Unwrapped_t<const _NoThrowFwdIt&>>) {
+        _STD _Zero_range(_UFirst, _ULast);
+    } else {
+        _Uninitialized_backout _Backout{_UFirst};
+
+        while (_Backout._Last != _ULast) {
+            _Backout._Emplace_back();
+        }
+
+        _Backout._Release();
+    }
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void uninitialized_value_construct(_ExPo&& _Exec, _NoThrowFwdIt _First, _NoThrowFwdIt _Last) noexcept; // terminates
+
+#if _HAS_CXX20
+namespace ranges {
+    class _Uninitialized_value_construct_fn {
+    public:
+        template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se>
+            requires default_initializable<iter_value_t<_It>>
+        static _It operator()(_It _First, _Se _Last) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _Uninitialized_value_construct_unchecked(
+                _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <_No_throw_forward_range _Rng>
+            requires default_initializable<range_value_t<_Rng>>
+        static borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) {
+            auto _UResult = _Uninitialized_value_construct_unchecked(_Ubegin(_Range), _Uend(_Range));
+
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Se>
+        _NODISCARD static _It _Uninitialized_value_construct_unchecked(_It _OFirst, _Se _OLast) {
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(default_initializable<iter_value_t<_It>>);
+
+            if constexpr (_Use_memset_value_construct_v<_It>) {
+                return _STD _Zero_range(_OFirst, _RANGES next(_OFirst, _STD move(_OLast)));
+            } else {
+                _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+                while (_Backout._Last != _OLast) {
+                    _Backout._Emplace_back();
+                }
+
+                return _Backout._Release();
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_value_construct_fn uninitialized_value_construct;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _NoThrowFwdIt, class _Diff>
+_NoThrowFwdIt uninitialized_value_construct_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
+    // value-initialize all elements in [_First, _First + _Count)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (_Count <= 0) {
+        return _First;
+    }
+
+    _STD _Seek_wrapped(
+        _First, _STD _Uninitialized_value_construct_n_unchecked1(_STD _Get_unwrapped_n(_First, _Count), _Count));
+    return _First;
+}
+
+_EXPORT_STD template <class _ExPo, class _NoThrowFwdIt, class _Diff, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NoThrowFwdIt uninitialized_value_construct_n(
+    _ExPo&& _Exec, _NoThrowFwdIt _First, _Diff _Count_raw) noexcept; // terminates
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Uninitialized_value_construct_n_fn {
+        template <_No_throw_forward_iterator _It>
+            requires default_initializable<iter_value_t<_It>>
+        static _It operator()(_It _First, iter_difference_t<_It> _Count) {
+            if (_Count <= 0) {
+                return _First;
+            }
+
+            auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+            if constexpr (_Use_memset_value_construct_v<_It>) {
+                _STD _Seek_wrapped(_First, _STD _Zero_range(_UFirst, _UFirst + _Count));
+            } else {
+                _Uninitialized_backout _Backout{_STD move(_UFirst)};
+
+                for (; _Count > 0; --_Count) {
+                    _Backout._Emplace_back();
+                }
+
+                _STD _Seek_wrapped(_First, _Backout._Release());
+            }
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Uninitialized_value_construct_n_fn uninitialized_value_construct_n;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+template <class _PtrTy>
+_NODISCARD void* _Voidify_unfancy(_PtrTy _Ptr) noexcept {
+    if constexpr (is_pointer_v<_PtrTy>) {
+        return _Ptr;
+    } else {
+        return _STD addressof(*_Ptr);
+    }
+}
+#endif // _HAS_CXX20
+
+#if _HAS_DEPRECATED_RAW_STORAGE_ITERATOR
+_EXPORT_STD template <class _OutIt, class _Ty>
+class _CXX17_DEPRECATE_RAW_STORAGE_ITERATOR raw_storage_iterator { // wrap stores to raw buffer as output iterator
+public:
+    using iterator_category = output_iterator_tag;
+    using value_type        = void;
+#if _HAS_CXX20
+    using difference_type = ptrdiff_t;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using difference_type = void;
+#endif // ^^^ !_HAS_CXX20 ^^^
+    using pointer   = void;
+    using reference = void;
+
+    explicit raw_storage_iterator(_OutIt _First) : _Next(_First) {}
+
+    _NODISCARD raw_storage_iterator& operator*() { // pretend to return designated value
+        return *this;
+    }
+
+    raw_storage_iterator& operator=(const _Ty& _Val) { // construct value designated by stored iterator
+        _STD _Construct_in_place(const_cast<_Remove_cvref_t<decltype(*_Next)>&>(*_Next), _Val);
+        return *this;
+    }
+
+    raw_storage_iterator& operator=(_Ty&& _Val) { // construct value designated by stored iterator
+        _STD _Construct_in_place(const_cast<_Remove_cvref_t<decltype(*_Next)>&>(*_Next), _STD move(_Val));
+        return *this;
+    }
+
+    raw_storage_iterator& operator++() {
+        ++_Next;
+        return *this;
+    }
+
+    raw_storage_iterator operator++(int) {
+        raw_storage_iterator _Ans = *this;
+        ++_Next;
+        return _Ans;
+    }
+
+    _NODISCARD _OutIt base() const {
+        return _Next;
+    }
+
+private:
+    _OutIt _Next;
+};
+#endif // _HAS_DEPRECATED_RAW_STORAGE_ITERATOR
+
+#if _HAS_AUTO_PTR_ETC
+_EXPORT_STD template <class _Ty>
+class auto_ptr;
+
+_EXPORT_STD template <class _Ty>
+struct auto_ptr_ref { // proxy reference for auto_ptr copying
+    explicit auto_ptr_ref(_Ty* _Right) : _Ref(_Right) {}
+
+    _Ty* _Ref; // generic pointer to auto_ptr ptr
+};
+
+_EXPORT_STD template <class _Ty>
+class auto_ptr { // wrap an object pointer to ensure destruction
+public:
+    using element_type = _Ty;
+
+    explicit auto_ptr(_Ty* _Ptr = nullptr) noexcept : _Myptr(_Ptr) {}
+
+    auto_ptr(auto_ptr& _Right) noexcept : _Myptr(_Right.release()) {}
+
+    auto_ptr(auto_ptr_ref<_Ty> _Right) noexcept {
+        _Ty* _Ptr   = _Right._Ref;
+        _Right._Ref = nullptr; // release old
+        _Myptr      = _Ptr; // reset this
+    }
+
+    template <class _Other>
+    operator auto_ptr<_Other>() noexcept { // convert to compatible auto_ptr
+        return auto_ptr<_Other>(*this);
+    }
+
+    template <class _Other>
+    operator auto_ptr_ref<_Other>() noexcept { // convert to compatible auto_ptr_ref
+        _Other* _Cvtptr = _Myptr; // test implicit conversion
+        auto_ptr_ref<_Other> _Ans(_Cvtptr);
+        _Myptr = nullptr; // pass ownership to auto_ptr_ref
+        return _Ans;
+    }
+
+    template <class _Other>
+    auto_ptr& operator=(auto_ptr<_Other>& _Right) noexcept {
+        reset(_Right.release());
+        return *this;
+    }
+
+    template <class _Other>
+    auto_ptr(auto_ptr<_Other>& _Right) noexcept : _Myptr(_Right.release()) {}
+
+    auto_ptr& operator=(auto_ptr& _Right) noexcept {
+        reset(_Right.release());
+        return *this;
+    }
+
+    auto_ptr& operator=(auto_ptr_ref<_Ty> _Right) noexcept {
+        _Ty* _Ptr   = _Right._Ref;
+        _Right._Ref = 0; // release old
+        reset(_Ptr); // set new
+        return *this;
+    }
+
+    ~auto_ptr() noexcept {
+        delete _Myptr;
+    }
+
+    _NODISCARD _Ty& operator*() const noexcept {
+        return *get();
+    }
+
+    _NODISCARD _Ty* operator->() const noexcept {
+        return get();
+    }
+
+    _NODISCARD _Ty* get() const noexcept {
+        return _Myptr;
+    }
+
+    _Ty* release() noexcept {
+        _Ty* _Tmp = _Myptr;
+        _Myptr    = nullptr;
+        return _Tmp;
+    }
+
+    void reset(_Ty* _Ptr = nullptr) noexcept { // destroy designated object and store new pointer
+        if (_Ptr != _Myptr) {
+            delete _Myptr;
+        }
+
+        _Myptr = _Ptr;
+    }
+
+private:
+    _Ty* _Myptr; // the wrapped object pointer
+};
+
+template <>
+class auto_ptr<void> {
+public:
+    using element_type = void;
+};
+#endif // _HAS_AUTO_PTR_ETC
+
+_EXPORT_STD class _NODISCARD bad_weak_ptr : public exception {
+    // exception type for invalid use of expired weak_ptr object
+public:
+    bad_weak_ptr() noexcept {}
+
+    _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
+        // return pointer to message string
+        return "bad_weak_ptr";
+    }
+};
+
+[[noreturn]] inline void _Throw_bad_weak_ptr() {
+    _THROW(bad_weak_ptr{});
+}
+
+class __declspec(novtable) _Ref_count_base { // common code for reference counting
+private:
+#ifdef _M_CEE_PURE
+    // permanent workaround to avoid mentioning _purecall in msvcurt.lib, ptrustu.lib, or other support libs
+    virtual void _Destroy() noexcept {
+        _STL_REPORT_ERROR("_Ref_count_base base class member functions should not be called");
+    }
+
+    virtual void _Delete_this() noexcept {
+        _STL_REPORT_ERROR("_Ref_count_base base class member functions should not be called");
+    }
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+    virtual void _Destroy() noexcept     = 0; // destroy managed resource
+    virtual void _Delete_this() noexcept = 0; // destroy self
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    _Atomic_counter_t _Uses  = 1;
+    _Atomic_counter_t _Weaks = 1;
+
+protected:
+    constexpr _Ref_count_base() noexcept = default; // non-atomic initializations
+
+public:
+    _Ref_count_base(const _Ref_count_base&)            = delete;
+    _Ref_count_base& operator=(const _Ref_count_base&) = delete;
+
+    virtual ~_Ref_count_base() noexcept {} // TRANSITION, should be non-virtual
+
+    bool _Incref_nz() noexcept { // increment use count if not zero, return true if successful
+        auto& _Volatile_uses = reinterpret_cast<volatile long&>(_Uses);
+#ifdef _M_CEE_PURE
+        long _Count = *_Atomic_address_as<const long>(&_Volatile_uses);
+#else
+        long _Count = __iso_volatile_load32(reinterpret_cast<volatile int*>(&_Volatile_uses));
+#endif
+        while (_Count != 0) {
+            const long _Old_value = _INTRIN_RELAXED(_InterlockedCompareExchange)(&_Volatile_uses, _Count + 1, _Count);
+            if (_Old_value == _Count) {
+                return true;
+            }
+
+            _Count = _Old_value;
+        }
+
+        return false;
+    }
+
+    void _Incref() noexcept { // increment use count
+        _MT_INCR(_Uses);
+    }
+
+    void _Incwref() noexcept { // increment weak reference count
+        _MT_INCR(_Weaks);
+    }
+
+    void _Decref() noexcept { // decrement use count
+        if (_MT_DECR(_Uses) == 0) {
+            _Destroy();
+            _Decwref();
+        }
+    }
+
+    void _Decwref() noexcept { // decrement weak reference count
+        if (_MT_DECR(_Weaks) == 0) {
+            _Delete_this();
+        }
+    }
+
+    long _Use_count() const noexcept {
+        return static_cast<long>(_Uses);
+    }
+
+    virtual void* _Get_deleter(const type_info&) const noexcept {
+        return nullptr;
+    }
+};
+
+template <class _Ty>
+class _Ref_count : public _Ref_count_base { // handle reference counting for pointer without deleter
+public:
+    explicit _Ref_count(_Ty* _Px) : _Ref_count_base(), _Ptr(_Px) {}
+
+private:
+    void _Destroy() noexcept override { // destroy managed resource
+        delete _Ptr;
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        delete this;
+    }
+
+    _Ty* _Ptr;
+};
+
+template <class _Resource, class _Dx>
+class _Ref_count_resource : public _Ref_count_base { // handle reference counting for object with deleter
+public:
+    _Ref_count_resource(_Resource _Px, _Dx _Dt)
+        : _Ref_count_base(), _Mypair(_One_then_variadic_args_t{}, _STD move(_Dt), _Px) {}
+
+    ~_Ref_count_resource() noexcept override = default; // TRANSITION, should be non-virtual
+
+    void* _Get_deleter(const type_info& _Typeid) const noexcept override {
+#if _HAS_STATIC_RTTI
+        if (_Typeid == typeid(_Dx)) {
+            return const_cast<_Dx*>(_STD addressof(_Mypair._Get_first()));
+        }
+#else // ^^^ _HAS_STATIC_RTTI / !_HAS_STATIC_RTTI vvv
+        (void) _Typeid;
+#endif // ^^^ !_HAS_STATIC_RTTI ^^^
+
+        return nullptr;
+    }
+
+private:
+    void _Destroy() noexcept override { // destroy managed resource
+        _Mypair._Get_first()(_Mypair._Myval2);
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        delete this;
+    }
+
+    _Compressed_pair<_Dx, _Resource> _Mypair;
+};
+
+template <class _Resource, class _Dx, class _Alloc>
+class _Ref_count_resource_alloc : public _Ref_count_base {
+    // handle reference counting for object with deleter and allocator
+public:
+    _Ref_count_resource_alloc(_Resource _Px, _Dx _Dt, const _Alloc& _Ax)
+        : _Ref_count_base(),
+          _Mypair(_One_then_variadic_args_t{}, _STD move(_Dt), _One_then_variadic_args_t{}, _Ax, _Px) {}
+
+    ~_Ref_count_resource_alloc() noexcept override = default; // TRANSITION, should be non-virtual
+
+    void* _Get_deleter(const type_info& _Typeid) const noexcept override {
+#if _HAS_STATIC_RTTI
+        if (_Typeid == typeid(_Dx)) {
+            return const_cast<_Dx*>(_STD addressof(_Mypair._Get_first()));
+        }
+#else // ^^^ _HAS_STATIC_RTTI / !_HAS_STATIC_RTTI vvv
+        (void) _Typeid;
+#endif // ^^^ !_HAS_STATIC_RTTI ^^^
+
+        return nullptr;
+    }
+
+private:
+    using _Myalty = _Rebind_alloc_t<_Alloc, _Ref_count_resource_alloc>;
+
+    void _Destroy() noexcept override { // destroy managed resource
+        _Mypair._Get_first()(_Mypair._Myval2._Myval2);
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        _Myalty _Al = _Mypair._Myval2._Get_first();
+        this->~_Ref_count_resource_alloc();
+        _STD _Deallocate_plain(_Al, this);
+    }
+
+    _Compressed_pair<_Dx, _Compressed_pair<_Myalty, _Resource>> _Mypair;
+};
+
+_EXPORT_STD template <class _Ty>
+struct default_delete;
+
+_EXPORT_STD template <class _Ty, class _Dx = default_delete<_Ty>>
+class unique_ptr;
+
+_EXPORT_STD template <class _Ty>
+class shared_ptr;
+
+_EXPORT_STD template <class _Ty>
+class weak_ptr;
+
+template <class _Yty, class = void>
+struct _Can_enable_shared : false_type {}; // detect unambiguous and accessible inheritance from enable_shared_from_this
+
+template <class _Yty>
+struct _Can_enable_shared<_Yty, void_t<typename _Yty::_Esft_type>>
+    : is_convertible<remove_cv_t<_Yty>*, typename _Yty::_Esft_type*>::type {
+    // is_convertible is necessary to verify unambiguous inheritance
+};
+
+struct _Exception_ptr_access;
+
+template <class _Ty>
+class _Ptr_base { // base class for shared_ptr and weak_ptr
+public:
+    using element_type = remove_extent_t<_Ty>;
+
+    _NODISCARD long use_count() const noexcept {
+        return _Rep ? _Rep->_Use_count() : 0;
+    }
+
+    template <class _Ty2>
+    _NODISCARD bool owner_before(const _Ptr_base<_Ty2>& _Right) const noexcept { // compare addresses of manager objects
+        return _Rep < _Right._Rep;
+    }
+
+    _Ptr_base(const _Ptr_base&)            = delete;
+    _Ptr_base& operator=(const _Ptr_base&) = delete;
+
+protected:
+    _NODISCARD element_type* get() const noexcept {
+        return _Ptr;
+    }
+
+    constexpr _Ptr_base() noexcept = default;
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    ~_Ptr_base() noexcept {
+        const uintptr_t _Tombstone_value{_MSVC_STL_UINTPTR_TOMBSTONE_VALUE};
+        _Ptr = reinterpret_cast<element_type*>(_Tombstone_value);
+        _Rep = reinterpret_cast<_Ref_count_base*>(_Tombstone_value);
+    }
+#else // ^^^ _MSVC_STL_DESTRUCTOR_TOMBSTONES / !_MSVC_STL_DESTRUCTOR_TOMBSTONES vvv
+    ~_Ptr_base() = default;
+#endif // ^^^ !_MSVC_STL_DESTRUCTOR_TOMBSTONES ^^^
+
+    template <class _Ty2>
+    void _Move_construct_from(_Ptr_base<_Ty2>&& _Right) noexcept {
+        // implement shared_ptr's (converting) move ctor and weak_ptr's move ctor
+        _Ptr = _Right._Ptr;
+        _Rep = _Right._Rep;
+
+        _Right._Ptr = nullptr;
+        _Right._Rep = nullptr;
+    }
+
+    template <class _Ty2>
+    void _Copy_construct_from(const shared_ptr<_Ty2>& _Other) noexcept {
+        // implement shared_ptr's (converting) copy ctor
+        _Other._Incref();
+
+        _Ptr = _Other._Ptr;
+        _Rep = _Other._Rep;
+    }
+
+    template <class _Ty2>
+    void _Alias_construct_from(const shared_ptr<_Ty2>& _Other, element_type* _Px) noexcept {
+        // implement shared_ptr's aliasing ctor
+        _Other._Incref();
+
+        _Ptr = _Px;
+        _Rep = _Other._Rep;
+    }
+
+    template <class _Ty2>
+    void _Alias_move_construct_from(shared_ptr<_Ty2>&& _Other, element_type* _Px) noexcept {
+        // implement shared_ptr's aliasing move ctor
+        _Ptr = _Px;
+        _Rep = _Other._Rep;
+
+        _Other._Ptr = nullptr;
+        _Other._Rep = nullptr;
+    }
+
+    template <class _Ty0>
+    friend class weak_ptr; // specifically, weak_ptr::lock()
+
+    template <class _Ty2>
+    bool _Construct_from_weak(const weak_ptr<_Ty2>& _Other) noexcept {
+        // implement shared_ptr's ctor from weak_ptr, and weak_ptr::lock()
+        if (_Other._Rep && _Other._Rep->_Incref_nz()) {
+            _Ptr = _Other._Ptr;
+            _Rep = _Other._Rep;
+            return true;
+        }
+
+        return false;
+    }
+
+    void _Incref() const noexcept {
+        if (_Rep) {
+            _Rep->_Incref();
+        }
+    }
+
+    void _Decref() noexcept { // decrement reference count
+        if (_Rep) {
+            _Rep->_Decref();
+        }
+    }
+
+    void _Swap(_Ptr_base& _Right) noexcept { // swap pointers
+        _STD swap(_Ptr, _Right._Ptr);
+        _STD swap(_Rep, _Right._Rep);
+    }
+
+    template <class _Ty2>
+    void _Weakly_construct_from(const _Ptr_base<_Ty2>& _Other) noexcept { // implement weak_ptr's ctors
+        if (_Other._Rep) {
+            _Ptr = _Other._Ptr;
+            _Rep = _Other._Rep;
+            _Rep->_Incwref();
+        } else {
+            _STL_INTERNAL_CHECK(!_Ptr && !_Rep);
+        }
+    }
+
+    template <class _Ty2>
+    void _Weakly_convert_lvalue_avoiding_expired_conversions(const _Ptr_base<_Ty2>& _Other) noexcept {
+        // implement weak_ptr's copy converting ctor
+        if (_Other._Rep) {
+            _Rep = _Other._Rep; // always share ownership
+            _Rep->_Incwref();
+
+            if (_Rep->_Incref_nz()) {
+                _Ptr = _Other._Ptr; // keep resource alive during conversion, handling virtual inheritance
+                _Rep->_Decref();
+            } else {
+                _STL_INTERNAL_CHECK(!_Ptr);
+            }
+        } else {
+            _STL_INTERNAL_CHECK(!_Ptr && !_Rep);
+        }
+    }
+
+    template <class _Ty2>
+    void _Weakly_convert_rvalue_avoiding_expired_conversions(_Ptr_base<_Ty2>&& _Other) noexcept {
+        // implement weak_ptr's move converting ctor
+        _Rep        = _Other._Rep; // always transfer ownership
+        _Other._Rep = nullptr;
+
+        if (_Rep && _Rep->_Incref_nz()) {
+            _Ptr = _Other._Ptr; // keep resource alive during conversion, handling virtual inheritance
+            _Rep->_Decref();
+        } else {
+            _STL_INTERNAL_CHECK(!_Ptr);
+        }
+
+        _Other._Ptr = nullptr;
+    }
+
+    void _Incwref() const noexcept {
+        if (_Rep) {
+            _Rep->_Incwref();
+        }
+    }
+
+    void _Decwref() noexcept { // decrement weak reference count
+        if (_Rep) {
+            _Rep->_Decwref();
+        }
+    }
+
+private:
+    element_type* _Ptr{nullptr};
+    _Ref_count_base* _Rep{nullptr};
+
+    template <class _Ty0>
+    friend class _Ptr_base;
+
+    friend shared_ptr<_Ty>;
+
+    template <class _Ty0>
+    friend struct atomic;
+
+    friend _Exception_ptr_access;
+
+#if _HAS_STATIC_RTTI
+    template <class _Dx, class _Ty0>
+    friend _Dx* get_deleter(const shared_ptr<_Ty0>& _Sx) noexcept;
+#endif // _HAS_STATIC_RTTI
+};
+
+template <class _Yty, class = void>
+struct _Can_scalar_delete : false_type {};
+template <class _Yty>
+struct _Can_scalar_delete<_Yty, void_t<decltype(delete _STD declval<_Yty*>())>> : bool_constant<!is_void_v<_Yty>> {};
+
+template <class _Yty, class = void>
+struct _Can_array_delete : false_type {};
+template <class _Yty>
+struct _Can_array_delete<_Yty, void_t<decltype(delete[] _STD declval<_Yty*>())>> : true_type {};
+
+template <class _Fx, class _Arg, class = void>
+struct _Can_call_function_object : false_type {};
+template <class _Fx, class _Arg>
+struct _Can_call_function_object<_Fx, _Arg, void_t<decltype(_STD declval<_Fx>()(_STD declval<_Arg>()))>> : true_type {};
+
+template <class _Yty, class _Ty, class = void>
+struct _SP_convertible : is_convertible<_Yty*, _Ty*>::type {};
+
+template <class _Yty, class _Uty, class _Void>
+struct _SP_convertible<_Yty, _Uty[], _Void> : false_type {};
+template <class _Yty, class _Uty>
+struct _SP_convertible<_Yty, _Uty[], void_t<_Yty (*)[]>> : is_convertible<_Yty (*)[], _Uty (*)[]>::type {};
+
+template <class _Yty, class _Uty, size_t _Ext, class _Void>
+struct _SP_convertible<_Yty, _Uty[_Ext], _Void> : false_type {};
+template <class _Yty, class _Uty, size_t _Ext>
+struct _SP_convertible<_Yty, _Uty[_Ext], void_t<_Yty (*)[_Ext]>>
+    : is_convertible<_Yty (*)[_Ext], _Uty (*)[_Ext]>::type {};
+
+template <class _Yty, class _Ty>
+struct _SP_pointer_compatible : is_convertible<_Yty*, _Ty*>::type {
+    // N4950 [util.smartptr.shared.general]/6 "a pointer type Y* is said to be compatible
+    // with a pointer type T* when either Y* is convertible to T* ..."
+};
+template <class _Uty, size_t _Ext>
+struct _SP_pointer_compatible<_Uty[_Ext], _Uty[]> : true_type {
+    // N4950 [util.smartptr.shared.general]/6 "... or Y is U[N] and T is cv U[]."
+};
+template <class _Uty, size_t _Ext>
+struct _SP_pointer_compatible<_Uty[_Ext], const _Uty[]> : true_type {
+    // N4950 [util.smartptr.shared.general]/6 "... or Y is U[N] and T is cv U[]."
+};
+template <class _Uty, size_t _Ext>
+struct _SP_pointer_compatible<_Uty[_Ext], volatile _Uty[]> : true_type {
+    // N4950 [util.smartptr.shared.general]/6 "... or Y is U[N] and T is cv U[]."
+};
+template <class _Uty, size_t _Ext>
+struct _SP_pointer_compatible<_Uty[_Ext], const volatile _Uty[]> : true_type {
+    // N4950 [util.smartptr.shared.general]/6 "... or Y is U[N] and T is cv U[]."
+};
+
+template <class _Ux>
+struct _Temporary_owner {
+    _Ux* _Ptr;
+
+    explicit _Temporary_owner(_Ux* const _Ptr_) noexcept : _Ptr(_Ptr_) {}
+    _Temporary_owner(const _Temporary_owner&)            = delete;
+    _Temporary_owner& operator=(const _Temporary_owner&) = delete;
+    ~_Temporary_owner() {
+        delete _Ptr;
+    }
+};
+
+template <class _UxptrOrNullptr, class _Dx>
+struct _Temporary_owner_del {
+    _UxptrOrNullptr _Ptr;
+    _Dx& _Dt;
+    bool _Call_deleter = true;
+
+    explicit _Temporary_owner_del(const _UxptrOrNullptr _Ptr_, _Dx& _Dt_) noexcept : _Ptr(_Ptr_), _Dt(_Dt_) {}
+    _Temporary_owner_del(const _Temporary_owner_del&)            = delete;
+    _Temporary_owner_del& operator=(const _Temporary_owner_del&) = delete;
+    ~_Temporary_owner_del() {
+        if (_Call_deleter) {
+            _Dt(_Ptr);
+        }
+    }
+};
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Not_builtin_array = !is_array_v<_Ty>;
+
+template <class _Ty>
+concept _Bounded_builtin_array = is_bounded_array_v<_Ty>;
+
+template <class _Ty>
+concept _Unbounded_builtin_array = is_unbounded_array_v<_Ty>;
+
+template <class _Ty>
+concept _Not_unbounded_builtin_array = !is_unbounded_array_v<_Ty>;
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty>
+class shared_ptr : public _Ptr_base<_Ty> { // class for reference counted resource management
+private:
+    using _Mybase = _Ptr_base<_Ty>;
+
+public:
+    using typename _Mybase::element_type;
+
+#if _HAS_CXX17
+    using weak_type = weak_ptr<_Ty>;
+#endif // _HAS_CXX17
+
+    constexpr shared_ptr() noexcept = default;
+
+    constexpr shared_ptr(nullptr_t) noexcept {} // construct empty shared_ptr
+
+    template <class _Ux,
+        enable_if_t<conjunction_v<conditional_t<is_array_v<_Ty>, _Can_array_delete<_Ux>, _Can_scalar_delete<_Ux>>,
+                        _SP_convertible<_Ux, _Ty>>,
+            int> = 0>
+    explicit shared_ptr(_Ux* _Px) { // construct shared_ptr object that owns _Px
+        if constexpr (is_array_v<_Ty>) {
+            _Setpd(_Px, default_delete<_Ux[]>{});
+        } else {
+            _Temporary_owner<_Ux> _Owner(_Px);
+            _Set_ptr_rep_and_enable_shared(_Owner._Ptr, new _Ref_count<_Ux>(_Owner._Ptr));
+            _Owner._Ptr = nullptr;
+        }
+    }
+
+    template <class _Ux, class _Dx,
+        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, _Ux*&>,
+                        _SP_convertible<_Ux, _Ty>>,
+            int> = 0>
+    shared_ptr(_Ux* _Px, _Dx _Dt) { // construct with _Px, deleter
+        _Setpd(_Px, _STD move(_Dt));
+    }
+
+    template <class _Ux, class _Dx, class _Alloc,
+        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, _Ux*&>,
+                        _SP_convertible<_Ux, _Ty>>,
+            int> = 0>
+    shared_ptr(_Ux* _Px, _Dx _Dt, _Alloc _Ax) { // construct with _Px, deleter, allocator
+        _Setpda(_Px, _STD move(_Dt), _Ax);
+    }
+
+    template <class _Dx,
+        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, nullptr_t&>>, int> = 0>
+    shared_ptr(nullptr_t, _Dx _Dt) { // construct with nullptr, deleter
+        _Setpd(nullptr, _STD move(_Dt));
+    }
+
+    template <class _Dx, class _Alloc,
+        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, nullptr_t&>>, int> = 0>
+    shared_ptr(nullptr_t, _Dx _Dt, _Alloc _Ax) { // construct with nullptr, deleter, allocator
+        _Setpda(nullptr, _STD move(_Dt), _Ax);
+    }
+
+    template <class _Ty2>
+    shared_ptr(const shared_ptr<_Ty2>& _Right, element_type* _Px) noexcept {
+        // construct shared_ptr object that aliases _Right
+        this->_Alias_construct_from(_Right, _Px);
+    }
+
+    template <class _Ty2>
+    shared_ptr(shared_ptr<_Ty2>&& _Right, element_type* _Px) noexcept {
+        // move construct shared_ptr object that aliases _Right
+        this->_Alias_move_construct_from(_STD move(_Right), _Px);
+    }
+
+    shared_ptr(const shared_ptr& _Other) noexcept { // construct shared_ptr object that owns same resource as _Other
+        this->_Copy_construct_from(_Other);
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    shared_ptr(const shared_ptr<_Ty2>& _Other) noexcept {
+        // construct shared_ptr object that owns same resource as _Other
+        this->_Copy_construct_from(_Other);
+    }
+
+    shared_ptr(shared_ptr&& _Right) noexcept { // construct shared_ptr object that takes resource from _Right
+        this->_Move_construct_from(_STD move(_Right));
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    shared_ptr(shared_ptr<_Ty2>&& _Right) noexcept { // construct shared_ptr object that takes resource from _Right
+        this->_Move_construct_from(_STD move(_Right));
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    explicit shared_ptr(const weak_ptr<_Ty2>& _Other) { // construct shared_ptr object that owns resource *_Other
+        if (!this->_Construct_from_weak(_Other)) {
+            _Throw_bad_weak_ptr();
+        }
+    }
+
+#if _HAS_AUTO_PTR_ETC
+    template <class _Ty2, enable_if_t<is_convertible_v<_Ty2*, _Ty*>, int> = 0>
+    shared_ptr(auto_ptr<_Ty2>&& _Other) { // construct shared_ptr object that owns *_Other.get()
+        _Ty2* _Px = _Other.get();
+        _Set_ptr_rep_and_enable_shared(_Px, new _Ref_count<_Ty2>(_Px));
+        _Other.release();
+    }
+#endif // _HAS_AUTO_PTR_ETC
+
+    template <class _Ux, class _Dx,
+        enable_if_t<conjunction_v<_SP_pointer_compatible<_Ux, _Ty>,
+                        is_convertible<typename unique_ptr<_Ux, _Dx>::pointer, element_type*>>,
+            int> = 0>
+    shared_ptr(unique_ptr<_Ux, _Dx>&& _Other) {
+        using _Fancy_t   = typename unique_ptr<_Ux, _Dx>::pointer;
+        using _Raw_t     = typename unique_ptr<_Ux, _Dx>::element_type*;
+        using _Deleter_t = conditional_t<is_reference_v<_Dx>, decltype(_STD ref(_Other.get_deleter())), _Dx>;
+
+        const _Fancy_t _Fancy = _Other.get();
+
+        if (_Fancy) {
+            const _Raw_t _Raw = _Fancy;
+            const auto _Rx =
+                new _Ref_count_resource<_Fancy_t, _Deleter_t>(_Fancy, _STD forward<_Dx>(_Other.get_deleter()));
+            _Set_ptr_rep_and_enable_shared(_Raw, _Rx);
+            _Other.release();
+        }
+    }
+
+    ~shared_ptr() noexcept { // release resource
+        this->_Decref();
+    }
+
+    shared_ptr& operator=(const shared_ptr& _Right) noexcept {
+        shared_ptr(_Right).swap(*this);
+        return *this;
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    shared_ptr& operator=(const shared_ptr<_Ty2>& _Right) noexcept {
+        shared_ptr(_Right).swap(*this);
+        return *this;
+    }
+
+    shared_ptr& operator=(shared_ptr&& _Right) noexcept { // take resource from _Right
+        shared_ptr(_STD move(_Right)).swap(*this);
+        return *this;
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    shared_ptr& operator=(shared_ptr<_Ty2>&& _Right) noexcept { // take resource from _Right
+        shared_ptr(_STD move(_Right)).swap(*this);
+        return *this;
+    }
+
+#if _HAS_AUTO_PTR_ETC
+    template <class _Ty2, enable_if_t<is_convertible_v<_Ty2*, _Ty*>, int> = 0>
+    shared_ptr& operator=(auto_ptr<_Ty2>&& _Right) {
+        shared_ptr(_STD move(_Right)).swap(*this);
+        return *this;
+    }
+#endif // _HAS_AUTO_PTR_ETC
+
+    template <class _Ux, class _Dx,
+        enable_if_t<conjunction_v<_SP_pointer_compatible<_Ux, _Ty>,
+                        is_convertible<typename unique_ptr<_Ux, _Dx>::pointer, element_type*>>,
+            int> = 0>
+    shared_ptr& operator=(unique_ptr<_Ux, _Dx>&& _Right) { // move from unique_ptr
+        shared_ptr(_STD move(_Right)).swap(*this);
+        return *this;
+    }
+
+    void swap(shared_ptr& _Other) noexcept {
+        this->_Swap(_Other);
+    }
+
+    void reset() noexcept { // release resource and convert to empty shared_ptr object
+        shared_ptr().swap(*this);
+    }
+
+    template <class _Ux,
+        enable_if_t<conjunction_v<conditional_t<is_array_v<_Ty>, _Can_array_delete<_Ux>, _Can_scalar_delete<_Ux>>,
+                        _SP_convertible<_Ux, _Ty>>,
+            int> = 0>
+    void reset(_Ux* _Px) { // release, take ownership of _Px
+        shared_ptr(_Px).swap(*this);
+    }
+
+    template <class _Ux, class _Dx,
+        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, _Ux*&>,
+                        _SP_convertible<_Ux, _Ty>>,
+            int> = 0>
+    void reset(_Ux* _Px, _Dx _Dt) { // release, take ownership of _Px, with deleter _Dt
+        shared_ptr(_Px, _Dt).swap(*this);
+    }
+
+    template <class _Ux, class _Dx, class _Alloc,
+        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, _Ux*&>,
+                        _SP_convertible<_Ux, _Ty>>,
+            int> = 0>
+    void reset(_Ux* _Px, _Dx _Dt, _Alloc _Ax) { // release, take ownership of _Px, with deleter _Dt, allocator _Ax
+        shared_ptr(_Px, _Dt, _Ax).swap(*this);
+    }
+
+    using _Mybase::get;
+
+    template <class _Ty2 = _Ty, enable_if_t<!disjunction_v<is_array<_Ty2>, is_void<_Ty2>>, int> = 0>
+    _NODISCARD _Ty2& operator*() const noexcept {
+        return *get();
+    }
+
+    template <class _Ty2 = _Ty, enable_if_t<!is_array_v<_Ty2>, int> = 0>
+    _NODISCARD _Ty2* operator->() const noexcept {
+        return get();
+    }
+
+    template <class _Ty2 = _Ty, class _Elem = element_type, enable_if_t<is_array_v<_Ty2>, int> = 0>
+    _NODISCARD _Elem& operator[](ptrdiff_t _Idx) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_SHARED_PTR_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (extent_v<_Ty> != 0) {
+            _STL_VERIFY(
+                _Idx >= 0 && static_cast<size_t>(_Idx) < extent_v<_Ty>, "shared_ptr<T[N]> subscript out of range");
+        } else {
+            _STL_VERIFY(_Idx >= 0, "shared_ptr<T[]> subscript out of range");
+        }
+#endif // _MSVC_STL_HARDENING_SHARED_PTR_ARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        return get()[_Idx];
+    }
+
+#if _HAS_DEPRECATED_SHARED_PTR_UNIQUE
+    _CXX17_DEPRECATE_SHARED_PTR_UNIQUE _NODISCARD bool unique() const noexcept {
+        // return true if no other shared_ptr object owns this resource
+        return this->use_count() == 1;
+    }
+#endif // _HAS_DEPRECATED_SHARED_PTR_UNIQUE
+
+    explicit operator bool() const noexcept {
+        return get() != nullptr;
+    }
+
+private:
+    template <class _UxptrOrNullptr, class _Dx>
+    void _Setpd(const _UxptrOrNullptr _Px, _Dx _Dt) { // take ownership of _Px, deleter _Dt
+        _Temporary_owner_del<_UxptrOrNullptr, _Dx> _Owner(_Px, _Dt);
+        _Set_ptr_rep_and_enable_shared(
+            _Owner._Ptr, new _Ref_count_resource<_UxptrOrNullptr, _Dx>(_Owner._Ptr, _STD move(_Dt)));
+        _Owner._Call_deleter = false;
+    }
+
+    template <class _UxptrOrNullptr, class _Dx, class _Alloc>
+    void _Setpda(const _UxptrOrNullptr _Px, _Dx _Dt, _Alloc _Ax) { // take ownership of _Px, deleter _Dt, allocator _Ax
+        using _Alref_alloc = _Rebind_alloc_t<_Alloc, _Ref_count_resource_alloc<_UxptrOrNullptr, _Dx, _Alloc>>;
+
+        _Temporary_owner_del<_UxptrOrNullptr, _Dx> _Owner(_Px, _Dt);
+        _Alref_alloc _Alref(_Ax);
+        _Alloc_construct_ptr<_Alref_alloc> _Constructor(_Alref);
+        _Constructor._Allocate();
+        _STD _Construct_in_place(*_Constructor._Ptr, _Owner._Ptr, _STD move(_Dt), _Ax);
+        _Set_ptr_rep_and_enable_shared(_Owner._Ptr, _STD _Unfancy(_Constructor._Ptr));
+        _Constructor._Ptr    = nullptr;
+        _Owner._Call_deleter = false;
+    }
+
+#if _HAS_CXX20
+    template <_Not_builtin_array _Ty0, class... _Types>
+    friend shared_ptr<_Ty0> make_shared(_Types&&... _Args);
+
+    template <_Not_builtin_array _Ty0, class _Alloc, class... _Types>
+    friend shared_ptr<_Ty0> allocate_shared(const _Alloc& _Al_arg, _Types&&... _Args);
+
+    template <_Bounded_builtin_array _Ty0>
+    friend shared_ptr<_Ty0> make_shared();
+
+    template <_Bounded_builtin_array _Ty0, class _Alloc>
+    friend shared_ptr<_Ty0> allocate_shared(const _Alloc& _Al_arg);
+
+    template <_Bounded_builtin_array _Ty0>
+    friend shared_ptr<_Ty0> make_shared(const remove_extent_t<_Ty0>& _Val);
+
+    template <_Bounded_builtin_array _Ty0, class _Alloc>
+    friend shared_ptr<_Ty0> allocate_shared(const _Alloc& _Al_arg, const remove_extent_t<_Ty0>& _Val);
+
+    template <_Not_unbounded_builtin_array _Ty0>
+    friend shared_ptr<_Ty0> make_shared_for_overwrite();
+
+    template <_Not_unbounded_builtin_array _Ty0, class _Alloc>
+    friend shared_ptr<_Ty0> allocate_shared_for_overwrite(const _Alloc& _Al_arg);
+
+    template <class _Ty0, class... _ArgTypes>
+    friend shared_ptr<_Ty0> _Make_shared_unbounded_array(size_t _Count, const _ArgTypes&... _Args);
+
+    template <bool _IsForOverwrite, class _Ty0, class _Alloc, class... _ArgTypes>
+    friend shared_ptr<_Ty0> _Allocate_shared_unbounded_array(
+        const _Alloc& _Al, size_t _Count, const _ArgTypes&... _Args);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    template <class _Ty0, class... _Types>
+    friend shared_ptr<_Ty0> make_shared(_Types&&... _Args);
+
+    template <class _Ty0, class _Alloc, class... _Types>
+    friend shared_ptr<_Ty0> allocate_shared(const _Alloc& _Al_arg, _Types&&... _Args);
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    template <class _Ux>
+    void _Set_ptr_rep_and_enable_shared(_Ux* const _Px, _Ref_count_base* const _Rx) noexcept { // take ownership of _Px
+        this->_Ptr = _Px;
+        this->_Rep = _Rx;
+        if constexpr (conjunction_v<negation<is_array<_Ty>>, negation<is_volatile<_Ux>>, _Can_enable_shared<_Ux>>) {
+            if (_Px && _Px->_Wptr.expired()) {
+                _Px->_Wptr = shared_ptr<remove_cv_t<_Ux>>(*this, const_cast<remove_cv_t<_Ux>*>(_Px));
+            }
+        }
+    }
+
+    void _Set_ptr_rep_and_enable_shared(nullptr_t, _Ref_count_base* const _Rx) noexcept { // take ownership of nullptr
+        this->_Ptr = nullptr;
+        this->_Rep = _Rx;
+    }
+};
+
+#if _HAS_CXX17
+template <class _Ty>
+shared_ptr(weak_ptr<_Ty>) -> shared_ptr<_Ty>;
+
+template <class _Ty, class _Dx>
+shared_ptr(unique_ptr<_Ty, _Dx>) -> shared_ptr<_Ty>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD bool operator==(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
+    return _Left.get() == _Right.get();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD strong_ordering operator<=>(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
+    return _Left.get() <=> _Right.get();
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty1, class _Ty2>
+_NODISCARD bool operator!=(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
+    return _Left.get() != _Right.get();
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD bool operator<(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
+    return _Left.get() < _Right.get();
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD bool operator>=(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
+    return _Left.get() >= _Right.get();
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD bool operator>(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
+    return _Left.get() > _Right.get();
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD bool operator<=(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
+    return _Left.get() <= _Right.get();
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD bool operator==(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
+    return _Left.get() == nullptr;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+_NODISCARD strong_ordering operator<=>(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
+    return _Left.get() <=> static_cast<shared_ptr<_Ty>::element_type*>(nullptr);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty>
+_NODISCARD bool operator==(nullptr_t, const shared_ptr<_Ty>& _Right) noexcept {
+    return nullptr == _Right.get();
+}
+
+template <class _Ty>
+_NODISCARD bool operator!=(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
+    return _Left.get() != nullptr;
+}
+
+template <class _Ty>
+_NODISCARD bool operator!=(nullptr_t, const shared_ptr<_Ty>& _Right) noexcept {
+    return nullptr != _Right.get();
+}
+
+template <class _Ty>
+_NODISCARD bool operator<(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
+    return _Left.get() < static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr);
+}
+
+template <class _Ty>
+_NODISCARD bool operator<(nullptr_t, const shared_ptr<_Ty>& _Right) noexcept {
+    return static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr) < _Right.get();
+}
+
+template <class _Ty>
+_NODISCARD bool operator>=(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
+    return _Left.get() >= static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr);
+}
+
+template <class _Ty>
+_NODISCARD bool operator>=(nullptr_t, const shared_ptr<_Ty>& _Right) noexcept {
+    return static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr) >= _Right.get();
+}
+
+template <class _Ty>
+_NODISCARD bool operator>(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
+    return _Left.get() > static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr);
+}
+
+template <class _Ty>
+_NODISCARD bool operator>(nullptr_t, const shared_ptr<_Ty>& _Right) noexcept {
+    return static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr) > _Right.get();
+}
+
+template <class _Ty>
+_NODISCARD bool operator<=(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
+    return _Left.get() <= static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr);
+}
+
+template <class _Ty>
+_NODISCARD bool operator<=(nullptr_t, const shared_ptr<_Ty>& _Right) noexcept {
+    return static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr) <= _Right.get();
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Ty>
+basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Out, const shared_ptr<_Ty>& _Px) {
+    // write contained pointer to stream
+    return _Out << _Px.get();
+}
+
+_EXPORT_STD template <class _Ty>
+void swap(shared_ptr<_Ty>& _Left, shared_ptr<_Ty>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD shared_ptr<_Ty1> static_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
+    // static_cast for shared_ptr that properly respects the reference count control block
+    const auto _Ptr = static_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
+    return shared_ptr<_Ty1>(_Other, _Ptr);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD shared_ptr<_Ty1> static_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
+    // static_cast for shared_ptr that properly respects the reference count control block
+    const auto _Ptr = static_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
+    return shared_ptr<_Ty1>(_STD move(_Other), _Ptr);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD shared_ptr<_Ty1> const_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
+    // const_cast for shared_ptr that properly respects the reference count control block
+    const auto _Ptr = const_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
+    return shared_ptr<_Ty1>(_Other, _Ptr);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD shared_ptr<_Ty1> const_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
+    // const_cast for shared_ptr that properly respects the reference count control block
+    const auto _Ptr = const_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
+    return shared_ptr<_Ty1>(_STD move(_Other), _Ptr);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD shared_ptr<_Ty1> reinterpret_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
+    // reinterpret_cast for shared_ptr that properly respects the reference count control block
+    const auto _Ptr = reinterpret_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
+    return shared_ptr<_Ty1>(_Other, _Ptr);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD shared_ptr<_Ty1> reinterpret_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
+    // reinterpret_cast for shared_ptr that properly respects the reference count control block
+    const auto _Ptr = reinterpret_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
+    return shared_ptr<_Ty1>(_STD move(_Other), _Ptr);
+}
+
+#ifdef _CPPRTTI
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD shared_ptr<_Ty1> dynamic_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
+    // dynamic_cast for shared_ptr that properly respects the reference count control block
+    const auto _Ptr = dynamic_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
+
+    if (_Ptr) {
+        return shared_ptr<_Ty1>(_Other, _Ptr);
+    }
+
+    return {};
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD shared_ptr<_Ty1> dynamic_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
+    // dynamic_cast for shared_ptr that properly respects the reference count control block
+    const auto _Ptr = dynamic_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
+
+    if (_Ptr) {
+        return shared_ptr<_Ty1>(_STD move(_Other), _Ptr);
+    }
+
+    return {};
+}
+#else // ^^^ defined(_CPPRTTI) / !defined(_CPPRTTI) vvv
+_EXPORT_STD template <class _Ty1, class _Ty2>
+shared_ptr<_Ty1> dynamic_pointer_cast(const shared_ptr<_Ty2>&) noexcept = delete; // requires /GR option
+_EXPORT_STD template <class _Ty1, class _Ty2>
+shared_ptr<_Ty1> dynamic_pointer_cast(shared_ptr<_Ty2>&&) noexcept = delete; // requires /GR option
+#endif // ^^^ !defined(_CPPRTTI) ^^^
+
+#if _HAS_STATIC_RTTI
+_EXPORT_STD template <class _Dx, class _Ty>
+_NODISCARD _Dx* get_deleter(const shared_ptr<_Ty>& _Sx) noexcept {
+    // return pointer to shared_ptr's deleter object if its type is _Dx
+    if (_Sx._Rep) {
+        return static_cast<_Dx*>(_Sx._Rep->_Get_deleter(typeid(_Dx)));
+    }
+
+    return nullptr;
+}
+#else // ^^^ _HAS_STATIC_RTTI / !_HAS_STATIC_RTTI vvv
+_EXPORT_STD template <class _Dx, class _Ty>
+_Dx* get_deleter(const shared_ptr<_Ty>&) noexcept = delete; // requires static RTTI
+#endif // ^^^ !_HAS_STATIC_RTTI ^^^
+
+#if _HAS_CXX20
+struct _For_overwrite_tag {
+    explicit _For_overwrite_tag() = default;
+};
+#endif // _HAS_CXX20
+
+template <class _Ty>
+class _Ref_count_obj2 : public _Ref_count_base { // handle reference counting for object in control block, no allocator
+public:
+    template <class... _Types>
+    explicit _Ref_count_obj2(_Types&&... _Args) : _Ref_count_base() {
+#if _HAS_CXX20
+        if constexpr (sizeof...(_Types) == 1 && (is_same_v<_For_overwrite_tag, remove_cvref_t<_Types>> && ...)) {
+            _STD _Default_construct_in_place(_Storage._Value);
+            ((void) _Args, ...);
+        } else
+#endif // _HAS_CXX20
+        {
+            _STD _Construct_in_place(_Storage._Value, _STD forward<_Types>(_Args)...);
+        }
+    }
+
+    ~_Ref_count_obj2() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do, _Storage._Value was already destroyed in _Destroy
+
+        // N4950 [class.dtor]/7:
+        // "A defaulted destructor for a class X is defined as deleted if:
+        // X is a union-like class that has a variant member with a non-trivial destructor"
+    }
+
+    union {
+        _Wrap<remove_cv_t<_Ty>> _Storage;
+    };
+
+private:
+    void _Destroy() noexcept override { // destroy managed resource
+        _STD _Destroy_in_place(_Storage._Value);
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        delete this;
+    }
+};
+
+#if _HAS_CXX20
+template <size_t _Align>
+struct _Alignas_storage_unit {
+    alignas(_Align) char _Space[_Align];
+};
+
+enum class _Check_overflow : bool { _Nope, _Yes };
+
+template <class _Refc, _Check_overflow _Check>
+_NODISCARD size_t _Calculate_bytes_for_flexible_array(const size_t _Count) noexcept(_Check == _Check_overflow::_Nope) {
+    constexpr size_t _Align = alignof(_Refc);
+
+    size_t _Bytes = sizeof(_Refc); // contains storage for one element
+
+    if (_Count > 1) {
+        constexpr size_t _Element_size = sizeof(typename _Refc::_Element_type);
+
+        size_t _Extra_bytes;
+
+        if constexpr (_Check == _Check_overflow::_Yes) {
+            _Extra_bytes = _Get_size_of_n<_Element_size>(_Count - 1); // check multiplication overflow
+
+            if (_Extra_bytes > static_cast<size_t>(-1) - _Bytes - (_Align - 1)) { // assume worst case adjustment
+                _Throw_bad_array_new_length(); // addition overflow
+            }
+        } else {
+            _Extra_bytes = _Element_size * (_Count - 1);
+        }
+
+        _Bytes += _Extra_bytes;
+
+        _Bytes = (_Bytes + _Align - 1) & ~(_Align - 1);
+    }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    using _Storage = _Alignas_storage_unit<_Align>;
+    _STL_INTERNAL_CHECK(_Bytes % sizeof(_Storage) == 0);
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+    return _Bytes;
+}
+
+template <class _Refc>
+_NODISCARD _Refc* _Allocate_flexible_array(const size_t _Count) {
+    const size_t _Bytes = _Calculate_bytes_for_flexible_array<_Refc, _Check_overflow::_Yes>(_Count);
+#ifdef __cpp_aligned_new
+    constexpr size_t _Align = alignof(_Refc);
+    if constexpr (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        return static_cast<_Refc*>(::operator new(_Bytes, align_val_t{_Align}));
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+        return static_cast<_Refc*>(::operator new(_Bytes));
+    }
+}
+
+template <class _Refc>
+void _Deallocate_flexible_array(_Refc* const _Ptr) noexcept {
+#ifdef __cpp_aligned_new
+    constexpr size_t _Align = alignof(_Refc);
+    if constexpr (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        ::operator delete(static_cast<void*>(_Ptr), align_val_t{_Align});
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+        ::operator delete(static_cast<void*>(_Ptr));
+    }
+}
+
+template <class _NoThrowIt>
+struct _NODISCARD _Uninitialized_rev_destroying_backout {
+    // struct to undo partially constructed ranges in _Uninitialized_xxx algorithms
+    _NoThrowIt _First;
+    _NoThrowIt _Last;
+
+    explicit _Uninitialized_rev_destroying_backout(_NoThrowIt _Dest) noexcept : _First(_Dest), _Last(_Dest) {}
+
+    _Uninitialized_rev_destroying_backout(const _Uninitialized_rev_destroying_backout&)            = delete;
+    _Uninitialized_rev_destroying_backout& operator=(const _Uninitialized_rev_destroying_backout&) = delete;
+
+    ~_Uninitialized_rev_destroying_backout() {
+        while (_Last != _First) {
+            --_Last;
+            _STD destroy_at(_STD addressof(*_Last));
+        }
+    }
+
+    template <class... _Types>
+    void _Emplace_back(_Types&&... _Vals) { // construct a new element at *_Last and increment
+        _STD _Construct_in_place(*_Last, _STD forward<_Types>(_Vals)...);
+        ++_Last;
+    }
+
+    void _Emplace_back_for_overwrite() {
+        _STD _Default_construct_in_place(*_Last);
+        ++_Last;
+    }
+
+    _NoThrowIt _Release() noexcept { // suppress any exception handling backout and return _Last
+        _First = _Last;
+        return _Last;
+    }
+};
+
+template <class _Ty>
+void _Reverse_destroy_multidimensional_n(_Ty* const _Arr, size_t _Size) noexcept {
+    while (_Size > 0) {
+        --_Size;
+        if constexpr (is_array_v<_Ty>) {
+            _STD _Reverse_destroy_multidimensional_n(_Arr[_Size], extent_v<_Ty>);
+        } else {
+            _STD _Destroy_in_place(_Arr[_Size]);
+        }
+    }
+}
+
+template <class _Ty>
+struct _NODISCARD _Reverse_destroy_multidimensional_n_guard {
+    _Ty* _Target;
+    size_t _Index;
+
+    ~_Reverse_destroy_multidimensional_n_guard() {
+        if (_Target) {
+            _STD _Reverse_destroy_multidimensional_n(_Target, _Index);
+        }
+    }
+};
+
+template <class _Ty, size_t _Size>
+void _Uninitialized_copy_multidimensional(const _Ty (&_In)[_Size], _Ty (&_Out)[_Size]) {
+    using _Item = remove_all_extents_t<_Ty>;
+    if constexpr (conjunction_v<is_trivially_copy_constructible<_Item>, is_trivially_destructible<_Item>>) {
+        _STD _Copy_memcpy_n(_In, _Size, _Out);
+    } else if constexpr (is_array_v<_Ty>) {
+        _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
+        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
+            _STD _Uninitialized_copy_multidimensional(_In[_Idx], _Out[_Idx]);
+        }
+        _Guard._Target = nullptr;
+    } else {
+        _Uninitialized_rev_destroying_backout _Backout{_Out};
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Backout._Emplace_back(_In[_Idx]);
+        }
+        _Backout._Release();
+    }
+}
+
+template <class _Ty>
+void _Uninitialized_value_construct_multidimensional_n(_Ty* const _Out, const size_t _Size) {
+    using _Item = remove_all_extents_t<_Ty>;
+    if constexpr (_Use_memset_value_construct_v<_Item*>) {
+        _STD _Zero_range(_Out, _Out + _Size);
+    } else if constexpr (is_array_v<_Ty>) {
+        _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
+        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
+            _STD _Uninitialized_value_construct_multidimensional_n(_Out[_Idx], extent_v<_Ty>);
+        }
+        _Guard._Target = nullptr;
+    } else {
+        _Uninitialized_rev_destroying_backout _Backout{_Out};
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Backout._Emplace_back();
+        }
+        _Backout._Release();
+    }
+}
+
+template <class _Ty>
+void _Uninitialized_default_construct_multidimensional_n(_Ty* const _Out, const size_t _Size) {
+    if constexpr (!is_trivially_default_constructible_v<_Ty>) {
+        if constexpr (is_array_v<_Ty>) {
+            _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
+            for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
+                _STD _Uninitialized_default_construct_multidimensional_n(_Out[_Idx], extent_v<_Ty>);
+            }
+            _Guard._Target = nullptr;
+        } else {
+            _Uninitialized_rev_destroying_backout _Backout{_Out};
+            for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+                _Backout._Emplace_back_for_overwrite();
+            }
+            _Backout._Release();
+        }
+    }
+}
+
+template <class _Ty>
+void _Uninitialized_fill_multidimensional_n(_Ty* const _Out, const size_t _Size, const _Ty& _Val) {
+    if constexpr (is_array_v<_Ty>) {
+        _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
+        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
+            _STD _Uninitialized_copy_multidimensional(_Val, _Out[_Idx]); // intentionally copy, not fill
+        }
+        _Guard._Target = nullptr;
+    } else if constexpr (_Fill_memset_is_safe<_Ty*, _Ty>) {
+        _STD _Fill_memset(_Out, _Val, _Size);
+    } else {
+        if constexpr (_Fill_zero_memset_is_safe<_Ty*, _Ty>) {
+            if (_STD _Is_all_bits_zero(_Val)) {
+                _STD _Fill_zero_memset(_Out, _Size);
+                return;
+            }
+        }
+        _Uninitialized_rev_destroying_backout _Backout{_Out};
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Backout._Emplace_back(_Val);
+        }
+        _Backout._Release();
+    }
+}
+
+template <class _Ty, bool = is_trivially_destructible_v<remove_extent_t<_Ty>>>
+class _Ref_count_unbounded_array : public _Ref_count_base {
+    // handle reference counting for unbounded array with trivial destruction in control block, no allocator
+public:
+    static_assert(is_unbounded_array_v<_Ty>);
+
+    using _Element_type = remove_extent_t<_Ty>;
+
+    explicit _Ref_count_unbounded_array(const size_t _Count) : _Ref_count_base() {
+        _STD _Uninitialized_value_construct_multidimensional_n(_Get_ptr(), _Count);
+    }
+
+    template <class _Arg>
+    explicit _Ref_count_unbounded_array(const size_t _Count, const _Arg& _Val) : _Ref_count_base() {
+        if constexpr (is_same_v<_For_overwrite_tag, _Arg>) {
+            _STD _Uninitialized_default_construct_multidimensional_n(_Get_ptr(), _Count);
+        } else {
+            _STD _Uninitialized_fill_multidimensional_n(_Get_ptr(), _Count, _Val);
+        }
+    }
+
+    _NODISCARD auto _Get_ptr() noexcept {
+        return _STD addressof(_Storage._Value);
+    }
+
+private:
+    union {
+        _Wrap<remove_cv_t<_Element_type>> _Storage; // flexible array must be last member
+    };
+
+    ~_Ref_count_unbounded_array() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do, _Ty is trivially destructible
+
+        // See N4950 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        // nothing to do, _Ty is trivially destructible
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        this->~_Ref_count_unbounded_array();
+        _STD _Deallocate_flexible_array(this);
+    }
+};
+
+template <class _Ty>
+class _Ref_count_unbounded_array<_Ty, false> : public _Ref_count_base {
+    // handle reference counting for unbounded array with non-trivial destruction in control block, no allocator
+public:
+    static_assert(is_unbounded_array_v<_Ty>);
+
+    using _Element_type = remove_extent_t<_Ty>;
+
+    explicit _Ref_count_unbounded_array(const size_t _Count) : _Ref_count_base(), _Size(_Count) {
+        _STD _Uninitialized_value_construct_multidimensional_n(_Get_ptr(), _Size);
+    }
+
+    template <class _Arg>
+    explicit _Ref_count_unbounded_array(const size_t _Count, const _Arg& _Val) : _Ref_count_base(), _Size(_Count) {
+        if constexpr (is_same_v<_For_overwrite_tag, _Arg>) {
+            _STD _Uninitialized_default_construct_multidimensional_n(_Get_ptr(), _Size);
+        } else {
+            _STD _Uninitialized_fill_multidimensional_n(_Get_ptr(), _Size, _Val);
+        }
+    }
+
+    _NODISCARD auto _Get_ptr() noexcept {
+        return _STD addressof(_Storage._Value);
+    }
+
+private:
+    size_t _Size;
+
+    union {
+        _Wrap<remove_cv_t<_Element_type>> _Storage; // flexible array must be last member
+    };
+
+    ~_Ref_count_unbounded_array() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do, _Storage was already destroyed in _Destroy
+
+        // See N4950 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        _STD _Reverse_destroy_multidimensional_n(_Get_ptr(), _Size);
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        this->~_Ref_count_unbounded_array();
+        _STD _Deallocate_flexible_array(this);
+    }
+};
+
+template <class _Ty>
+class _Ref_count_bounded_array : public _Ref_count_base {
+    // handle reference counting for bounded array in control block, no allocator
+public:
+    static_assert(is_bounded_array_v<_Ty>);
+
+    _Ref_count_bounded_array() : _Ref_count_base(), _Storage() {} // value-initializing _Storage is necessary here
+
+    template <class _Arg>
+    explicit _Ref_count_bounded_array(const _Arg& _Val) : _Ref_count_base() { // don't value-initialize _Storage
+        if constexpr (is_same_v<_For_overwrite_tag, _Arg>) {
+            _STD _Uninitialized_default_construct_multidimensional_n(_Storage._Value, extent_v<_Ty>);
+        } else {
+            _STD _Uninitialized_fill_multidimensional_n(_Storage._Value, extent_v<_Ty>, _Val);
+        }
+    }
+
+    union {
+        _Wrap<remove_cv_t<_Ty>> _Storage;
+    };
+
+private:
+    ~_Ref_count_bounded_array() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do, _Storage was already destroyed in _Destroy
+
+        // See N4950 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        // not _Storage._Value as _Ty is an array type (not a class type or a scalar type),
+        // and thus cannot be used as a pseudo-destructor (N4950 [expr.prim.id.dtor]).
+        _STD _Destroy_in_place(_Storage);
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        delete this;
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Ty, class _Alloc>
+class _Ref_count_obj_alloc3 : public _Ebco_base<_Rebind_alloc_t<_Alloc, _Ty>>, public _Ref_count_base {
+    // handle reference counting for object in control block, allocator
+private:
+    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared should remove_cv_t");
+
+    using _Rebound = _Rebind_alloc_t<_Alloc, _Ty>;
+
+public:
+    template <class... _Types>
+    explicit _Ref_count_obj_alloc3(const _Alloc& _Al_arg, _Types&&... _Args)
+        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base() {
+#if _HAS_CXX20 && defined(_ENABLE_STL_INTERNAL_CHECK)
+        if constexpr (sizeof...(_Types) == 1) {
+            // allocate_shared_for_overwrite should use another type for the control block
+            _STL_INTERNAL_STATIC_ASSERT(!(is_same_v<_For_overwrite_tag, remove_cvref_t<_Types>> && ...));
+        }
+#endif // _HAS_CXX20 && defined(_ENABLE_STL_INTERNAL_CHECK)
+        allocator_traits<_Rebound>::construct(
+            this->_Get_val(), _STD addressof(_Storage._Value), _STD forward<_Types>(_Args)...);
+    }
+
+    union {
+        _Wrap<_Ty> _Storage;
+    };
+
+private:
+    ~_Ref_count_obj_alloc3() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do; _Storage._Value already destroyed by _Destroy()
+
+        // See N4950 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        allocator_traits<_Rebound>::destroy(this->_Get_val(), _STD addressof(_Storage._Value));
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        _Rebind_alloc_t<_Alloc, _Ref_count_obj_alloc3> _Al(this->_Get_val());
+        this->~_Ref_count_obj_alloc3();
+        _STD _Deallocate_plain(_Al, this);
+    }
+};
+
+#if _HAS_CXX20
+template <class _Ty, class _Alloc>
+class _Ref_count_obj_alloc_for_overwrite : public _Ebco_base<_Rebind_alloc_t<_Alloc, _Ty>>, public _Ref_count_base {
+    // handle reference counting for object in control block, allocator
+    // initialize and destroy objects by the default mechanism
+private:
+    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared_for_overwrite should remove_cv_t");
+
+    using _Rebound = _Rebind_alloc_t<_Alloc, _Ty>;
+
+public:
+    template <class... _Types>
+    explicit _Ref_count_obj_alloc_for_overwrite(const _Alloc& _Al_arg)
+        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base() {
+        _STD _Default_construct_in_place(_Storage._Value);
+    }
+
+    union {
+        _Wrap<_Ty> _Storage;
+    };
+
+private:
+    ~_Ref_count_obj_alloc_for_overwrite() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do; _Storage._Value already destroyed by _Destroy()
+
+        // See N4964 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        _STD _Destroy_in_place(_Storage._Value);
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        _Rebind_alloc_t<_Alloc, _Ref_count_obj_alloc_for_overwrite> _Al(this->_Get_val());
+        this->~_Ref_count_obj_alloc_for_overwrite();
+        _STD _Deallocate_plain(_Al, this);
+    }
+};
+
+template <class _Alloc>
+class _NODISCARD _Uninitialized_rev_destroying_backout_al {
+    // class to undo partially constructed ranges in _Uninitialized_xxx_al algorithms
+
+private:
+    using pointer = _Alloc_ptr_t<_Alloc>;
+
+public:
+    _Uninitialized_rev_destroying_backout_al(pointer _Dest, _Alloc& _Al_) noexcept
+        : _First(_Dest), _Last(_Dest), _Al(_Al_) {}
+
+    _Uninitialized_rev_destroying_backout_al(const _Uninitialized_rev_destroying_backout_al&)            = delete;
+    _Uninitialized_rev_destroying_backout_al& operator=(const _Uninitialized_rev_destroying_backout_al&) = delete;
+
+    ~_Uninitialized_rev_destroying_backout_al() {
+        while (_Last != _First) {
+            --_Last;
+            allocator_traits<_Alloc>::destroy(_Al, _Last);
+        }
+    }
+
+    template <class... _Types>
+    void _Emplace_back(_Types&&... _Vals) { // construct a new element at *_Last and increment
+        allocator_traits<_Alloc>::construct(_Al, _STD _Unfancy(_Last), _STD forward<_Types>(_Vals)...);
+        ++_Last;
+    }
+
+    pointer _Release() noexcept { // suppress any exception handling backout and return _Last
+        _First = _Last;
+        return _Last;
+    }
+
+private:
+    pointer _First;
+    pointer _Last;
+    _Alloc& _Al;
+};
+
+template <class _Ty, class _Alloc>
+void _Reverse_destroy_multidimensional_n_al(_Ty* const _Arr, size_t _Size, _Alloc& _Al) noexcept {
+    while (_Size > 0) {
+        --_Size;
+        if constexpr (is_array_v<_Ty>) {
+            _STD _Reverse_destroy_multidimensional_n_al(_Arr[_Size], extent_v<_Ty>, _Al);
+        } else {
+            allocator_traits<_Alloc>::destroy(_Al, _Arr + _Size);
+        }
+    }
+}
+
+template <class _Ty, class _Alloc>
+struct _NODISCARD _Reverse_destroy_multidimensional_n_al_guard {
+    _Ty* _Target;
+    size_t _Index;
+    _Alloc& _Al;
+
+    ~_Reverse_destroy_multidimensional_n_al_guard() {
+        if (_Target) {
+            _STD _Reverse_destroy_multidimensional_n_al(_Target, _Index, _Al);
+        }
+    }
+};
+
+template <class _Ty, size_t _Size, class _Alloc>
+void _Uninitialized_copy_multidimensional_al(const _Ty (&_In)[_Size], _Ty (&_Out)[_Size], _Alloc& _Al) {
+    using _Item = remove_all_extents_t<_Ty>;
+    if constexpr (conjunction_v<is_trivially_copy_constructible<_Item>, is_trivially_destructible<_Item>,
+                      _Uses_default_construct<_Alloc, _Item*, const _Item&>>) {
+        _STD _Copy_memcpy_n(_In, _Size, _Out);
+    } else if constexpr (is_array_v<_Ty>) {
+        _Reverse_destroy_multidimensional_n_al_guard<_Ty, _Alloc> _Guard{_Out, 0, _Al};
+        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
+            _STD _Uninitialized_copy_multidimensional_al(_In[_Idx], _Out[_Idx], _Al);
+        }
+        _Guard._Target = nullptr;
+    } else {
+        _Uninitialized_rev_destroying_backout_al _Backout{_Out, _Al};
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Backout._Emplace_back(_In[_Idx]);
+        }
+        _Backout._Release();
+    }
+}
+
+template <class _Ty, class _Alloc>
+void _Uninitialized_value_construct_multidimensional_n_al(_Ty* const _Out, const size_t _Size, _Alloc& _Al) {
+    using _Item = remove_all_extents_t<_Ty>;
+    if constexpr (_Use_memset_value_construct_v<_Item*> && _Uses_default_construct<_Alloc, _Item*>::value) {
+        _STD _Zero_range(_Out, _Out + _Size);
+    } else if constexpr (is_array_v<_Ty>) {
+        _Reverse_destroy_multidimensional_n_al_guard<_Ty, _Alloc> _Guard{_Out, 0, _Al};
+        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
+            _STD _Uninitialized_value_construct_multidimensional_n_al(_Out[_Idx], extent_v<_Ty>, _Al);
+        }
+        _Guard._Target = nullptr;
+    } else {
+        _Uninitialized_rev_destroying_backout_al _Backout{_Out, _Al};
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Backout._Emplace_back();
+        }
+        _Backout._Release();
+    }
+}
+
+template <class _Ty, class _Alloc>
+void _Uninitialized_fill_multidimensional_n_al(_Ty* const _Out, const size_t _Size, const _Ty& _Val, _Alloc& _Al) {
+    if constexpr (is_array_v<_Ty>) {
+        _Reverse_destroy_multidimensional_n_al_guard<_Ty, _Alloc> _Guard{_Out, 0, _Al};
+        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
+            _STD _Uninitialized_copy_multidimensional_al(_Val, _Out[_Idx], _Al); // intentionally copy, not fill
+        }
+        _Guard._Target = nullptr;
+    } else if constexpr (_Fill_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, const _Ty&>::value) {
+        _STD _Fill_memset(_Out, _Val, _Size);
+    } else {
+        if constexpr (_Fill_zero_memset_is_safe<_Ty*, _Ty>
+                      && _Uses_default_construct<_Alloc, _Ty*, const _Ty&>::value) {
+            if (_STD _Is_all_bits_zero(_Val)) {
+                _STD _Fill_zero_memset(_Out, _Size);
+                return;
+            }
+        }
+        _Uninitialized_rev_destroying_backout_al _Backout{_Out, _Al};
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Backout._Emplace_back(_Val);
+        }
+        _Backout._Release();
+    }
+}
+
+template <class _Ty, class _Alloc>
+class _Ref_count_unbounded_array_alloc : public _Ebco_base<_Rebind_alloc_t<_Alloc, remove_all_extents_t<_Ty>>>,
+                                         public _Ref_count_base {
+    // handle reference counting for unbounded array in control block, allocator
+private:
+    static_assert(is_unbounded_array_v<_Ty>);
+    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared should remove_cv_t");
+
+    using _Item    = remove_all_extents_t<_Ty>;
+    using _Rebound = _Rebind_alloc_t<_Alloc, _Item>;
+
+public:
+    using _Element_type = remove_extent_t<_Ty>;
+
+    explicit _Ref_count_unbounded_array_alloc(const _Alloc& _Al_arg, const size_t _Count)
+        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base(), _Size(_Count) {
+        _STD _Uninitialized_value_construct_multidimensional_n_al(_Get_ptr(), _Size, this->_Get_val());
+    }
+
+    template <class _Arg>
+    explicit _Ref_count_unbounded_array_alloc(const _Alloc& _Al_arg, const size_t _Count, const _Arg& _Val)
+        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base(), _Size(_Count) {
+        // allocate_shared_for_overwrite should use another type for the control block
+        _STL_INTERNAL_STATIC_ASSERT(!is_same_v<_For_overwrite_tag, _Arg>);
+
+        _STD _Uninitialized_fill_multidimensional_n_al(_Get_ptr(), _Size, _Val, this->_Get_val());
+    }
+
+    _NODISCARD auto _Get_ptr() noexcept {
+        return _STD addressof(_Storage._Value);
+    }
+
+private:
+    size_t _Size;
+
+    union {
+        _Wrap<_Element_type> _Storage; // flexible array must be last member
+    };
+
+    ~_Ref_count_unbounded_array_alloc() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do; _Storage._Value already destroyed by _Destroy()
+
+        // See N4950 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        if constexpr (!conjunction_v<is_trivially_destructible<_Item>, _Uses_default_destroy<_Rebound, _Item*>>) {
+            _STD _Reverse_destroy_multidimensional_n_al(_Get_ptr(), _Size, this->_Get_val());
+        }
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        constexpr size_t _Align = alignof(_Ref_count_unbounded_array_alloc);
+        using _Storage          = _Alignas_storage_unit<_Align>;
+        using _Rebound_alloc    = _Rebind_alloc_t<_Alloc, _Storage>;
+
+        _Rebound_alloc _Al(this->_Get_val());
+        const size_t _Bytes =
+            _Calculate_bytes_for_flexible_array<_Ref_count_unbounded_array_alloc, _Check_overflow::_Nope>(_Size);
+        const size_t _Storage_units = _Bytes / sizeof(_Storage);
+
+        this->~_Ref_count_unbounded_array_alloc();
+
+        _Al.deallocate(_STD _Refancy<_Alloc_ptr_t<_Rebound_alloc>>(reinterpret_cast<_Storage*>(this)),
+            static_cast<_Alloc_size_t<_Rebound_alloc>>(_Storage_units));
+    }
+};
+
+template <class _Ty, class _Alloc>
+class _Ref_count_unbounded_array_alloc_for_overwrite
+    : public _Ebco_base<_Rebind_alloc_t<_Alloc, remove_all_extents_t<_Ty>>>,
+      public _Ref_count_base {
+    // handle reference counting for unbounded array in control block, allocator
+    // initialize and destroy objects by the default mechanism
+private:
+    static_assert(is_unbounded_array_v<_Ty>);
+    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared_for_overwrite should remove_cv_t");
+
+    using _Item    = remove_all_extents_t<_Ty>;
+    using _Rebound = _Rebind_alloc_t<_Alloc, _Item>;
+
+public:
+    using _Element_type = remove_extent_t<_Ty>;
+
+    explicit _Ref_count_unbounded_array_alloc_for_overwrite(const _Alloc& _Al_arg, const size_t _Count)
+        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base(), _Size(_Count) {
+        _STD _Uninitialized_default_construct_multidimensional_n(_Get_ptr(), _Size); // the allocator isn't needed
+    }
+
+    _NODISCARD auto _Get_ptr() noexcept {
+        return _STD addressof(_Storage._Value);
+    }
+
+private:
+    size_t _Size;
+
+    union {
+        _Wrap<_Element_type> _Storage; // flexible array must be last member
+    };
+
+    ~_Ref_count_unbounded_array_alloc_for_overwrite() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do; _Storage._Value already destroyed by _Destroy()
+
+        // See N4964 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        _STD _Reverse_destroy_multidimensional_n(_Get_ptr(), _Size);
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        constexpr size_t _Align = alignof(_Ref_count_unbounded_array_alloc_for_overwrite);
+        using _Storage          = _Alignas_storage_unit<_Align>;
+        using _Rebound_alloc    = _Rebind_alloc_t<_Alloc, _Storage>;
+
+        _Rebound_alloc _Al(this->_Get_val());
+        const size_t _Bytes         = _Calculate_bytes_for_flexible_array< //
+            _Ref_count_unbounded_array_alloc_for_overwrite, _Check_overflow::_Nope>(_Size);
+        const size_t _Storage_units = _Bytes / sizeof(_Storage);
+
+        this->~_Ref_count_unbounded_array_alloc_for_overwrite();
+
+        _Al.deallocate(_STD _Refancy<_Alloc_ptr_t<_Rebound_alloc>>(reinterpret_cast<_Storage*>(this)),
+            static_cast<_Alloc_size_t<_Rebound_alloc>>(_Storage_units));
+    }
+};
+
+template <class _Ty, class _Alloc>
+class _Ref_count_bounded_array_alloc : public _Ebco_base<_Rebind_alloc_t<_Alloc, remove_all_extents_t<_Ty>>>,
+                                       public _Ref_count_base {
+    // handle reference counting for bounded array in control block, allocator
+private:
+    static_assert(is_bounded_array_v<_Ty>);
+    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared should remove_cv_t");
+
+    using _Item    = remove_all_extents_t<_Ty>;
+    using _Rebound = _Rebind_alloc_t<_Alloc, _Item>;
+
+public:
+    explicit _Ref_count_bounded_array_alloc(const _Alloc& _Al_arg)
+        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base() { // don't value-initialize _Storage
+        _STD _Uninitialized_value_construct_multidimensional_n_al(_Storage._Value, extent_v<_Ty>, this->_Get_val());
+    }
+
+    template <class _Arg>
+    explicit _Ref_count_bounded_array_alloc(const _Alloc& _Al_arg, const _Arg& _Val)
+        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base() { // don't value-initialize _Storage
+        // allocate_shared_for_overwrite should use another type for the control block
+        _STL_INTERNAL_STATIC_ASSERT(!is_same_v<_For_overwrite_tag, _Arg>);
+
+        _STD _Uninitialized_fill_multidimensional_n_al(_Storage._Value, extent_v<_Ty>, _Val, this->_Get_val());
+    }
+
+    union {
+        _Wrap<_Ty> _Storage;
+    };
+
+private:
+    ~_Ref_count_bounded_array_alloc() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do; _Storage._Value already destroyed by _Destroy()
+
+        // See N4950 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        if constexpr (!conjunction_v<is_trivially_destructible<_Item>, _Uses_default_destroy<_Rebound, _Item*>>) {
+            _STD _Reverse_destroy_multidimensional_n_al(_Storage._Value, extent_v<_Ty>, this->_Get_val());
+        }
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        _Rebind_alloc_t<_Alloc, _Ref_count_bounded_array_alloc> _Al(this->_Get_val());
+        this->~_Ref_count_bounded_array_alloc();
+        _STD _Deallocate_plain(_Al, this);
+    }
+};
+
+template <class _Ty, class _Alloc>
+class _Ref_count_bounded_array_alloc_for_overwrite
+    : public _Ebco_base<_Rebind_alloc_t<_Alloc, remove_all_extents_t<_Ty>>>,
+      public _Ref_count_base {
+    // handle reference counting for bounded array in control block, allocator
+    // initialize and destroy objects by the default mechanism
+private:
+    static_assert(is_bounded_array_v<_Ty>);
+    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared_for_overwrite should remove_cv_t");
+
+    using _Item    = remove_all_extents_t<_Ty>;
+    using _Rebound = _Rebind_alloc_t<_Alloc, _Item>;
+
+public:
+    explicit _Ref_count_bounded_array_alloc_for_overwrite(const _Alloc& _Al_arg)
+        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base() { // don't value-initialize _Storage
+        _STD _Uninitialized_default_construct_multidimensional_n(
+            _Storage._Value, extent_v<_Ty>); // the allocator isn't needed
+    }
+
+    union {
+        _Wrap<_Ty> _Storage;
+    };
+
+private:
+    ~_Ref_count_bounded_array_alloc_for_overwrite() noexcept override { // TRANSITION, should be non-virtual
+        // nothing to do; _Storage._Value already destroyed by _Destroy()
+
+        // See N4964 [class.dtor]/7.
+    }
+
+    void _Destroy() noexcept override { // destroy managed resource
+        // not _Storage._Value as _Ty is an array type (not a class type or a scalar type),
+        // and thus cannot be used as a pseudo-destructor (N4964 [expr.prim.id.dtor]).
+        _STD _Destroy_in_place(_Storage);
+    }
+
+    void _Delete_this() noexcept override { // destroy self
+        _Rebind_alloc_t<_Alloc, _Ref_count_bounded_array_alloc_for_overwrite> _Al(this->_Get_val());
+        this->~_Ref_count_bounded_array_alloc_for_overwrite();
+        _STD _Deallocate_plain(_Al, this);
+    }
+};
+#endif // _HAS_CXX20
+
+#if _HAS_CXX20
+_EXPORT_STD template <_Not_builtin_array _Ty, class... _Types>
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class... _Types>
+#endif // ^^^ !_HAS_CXX20 ^^^
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> make_shared(_Types&&... _Args) { // make a shared_ptr to non-array object
+    const auto _Rx = new _Ref_count_obj2<_Ty>(_STD forward<_Types>(_Args)...);
+    shared_ptr<_Ty> _Ret;
+    _Ret._Set_ptr_rep_and_enable_shared(_STD addressof(_Rx->_Storage._Value), _Rx);
+    return _Ret;
+}
+
+#if _HAS_CXX20
+template <class _Refc>
+struct _NODISCARD _Global_delete_guard {
+    _Refc* _Target;
+
+    ~_Global_delete_guard() {
+        // While this branch is technically unnecessary because N4950 [new.delete.single]/16 requires
+        // `::operator delete(nullptr)` to be a no-op, it's here to help optimizers see that after
+        // `_Guard._Target = nullptr;`, this destructor can be eliminated.
+        if (_Target) {
+            _STD _Deallocate_flexible_array(_Target);
+        }
+    }
+};
+
+template <class _Ty, class... _ArgTypes>
+_NODISCARD shared_ptr<_Ty> _Make_shared_unbounded_array(const size_t _Count, const _ArgTypes&... _Args) {
+    // make a shared_ptr to an unbounded array
+    static_assert(is_unbounded_array_v<_Ty>);
+    using _Refc    = _Ref_count_unbounded_array<_Ty>;
+    const auto _Rx = _Allocate_flexible_array<_Refc>(_Count);
+    _Global_delete_guard<_Refc> _Guard{_Rx};
+    ::new (static_cast<void*>(_Rx)) _Refc(_Count, _Args...);
+    _Guard._Target = nullptr;
+    shared_ptr<_Ty> _Ret;
+    _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Get_ptr(), _Rx);
+    return _Ret;
+}
+
+_EXPORT_STD template <_Unbounded_builtin_array _Ty>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> make_shared(const size_t _Count) {
+    return _STD _Make_shared_unbounded_array<_Ty>(_Count);
+}
+
+_EXPORT_STD template <_Unbounded_builtin_array _Ty>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> make_shared(const size_t _Count, const remove_extent_t<_Ty>& _Val) {
+    return _STD _Make_shared_unbounded_array<_Ty>(_Count, _Val);
+}
+
+_EXPORT_STD template <_Bounded_builtin_array _Ty>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> make_shared() {
+    // make a shared_ptr to a bounded array
+    const auto _Rx = new _Ref_count_bounded_array<_Ty>();
+    shared_ptr<_Ty> _Ret;
+    _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Storage._Value, _Rx);
+    return _Ret;
+}
+
+_EXPORT_STD template <_Bounded_builtin_array _Ty>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> make_shared(const remove_extent_t<_Ty>& _Val) {
+    // make a shared_ptr to a bounded array
+    const auto _Rx = new _Ref_count_bounded_array<_Ty>(_Val);
+    shared_ptr<_Ty> _Ret;
+    _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Storage._Value, _Rx);
+    return _Ret;
+}
+
+_EXPORT_STD template <_Not_unbounded_builtin_array _Ty>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> make_shared_for_overwrite() {
+    shared_ptr<_Ty> _Ret;
+    if constexpr (is_array_v<_Ty>) {
+        // make a shared_ptr to a bounded array
+        const auto _Rx = new _Ref_count_bounded_array<_Ty>(_For_overwrite_tag{});
+        _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Storage._Value, _Rx);
+    } else {
+        // make a shared_ptr to non-array object
+        const auto _Rx = new _Ref_count_obj2<_Ty>(_For_overwrite_tag{});
+        _Ret._Set_ptr_rep_and_enable_shared(_STD addressof(_Rx->_Storage._Value), _Rx);
+    }
+    return _Ret;
+}
+
+_EXPORT_STD template <_Unbounded_builtin_array _Ty>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> make_shared_for_overwrite(const size_t _Count) {
+    return _STD _Make_shared_unbounded_array<_Ty>(_Count, _For_overwrite_tag{});
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX20
+_EXPORT_STD template <_Not_builtin_array _Ty, class _Alloc, class... _Types>
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Alloc, class... _Types>
+#endif // ^^^ !_HAS_CXX20 ^^^
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> allocate_shared(const _Alloc& _Al, _Types&&... _Args) {
+    // make a shared_ptr to non-array object
+    using _Refoa   = _Ref_count_obj_alloc3<remove_cv_t<_Ty>, _Alloc>;
+    using _Alblock = _Rebind_alloc_t<_Alloc, _Refoa>;
+    _Alblock _Rebound(_Al);
+    _Alloc_construct_ptr<_Alblock> _Constructor{_Rebound};
+    _Constructor._Allocate();
+    _STD _Construct_in_place(*_Constructor._Ptr, _Al, _STD forward<_Types>(_Args)...);
+    shared_ptr<_Ty> _Ret;
+    const auto _Ptr = reinterpret_cast<_Ty*>(_STD addressof(_Constructor._Ptr->_Storage._Value));
+    _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _STD _Unfancy(_Constructor._Release()));
+    return _Ret;
+}
+
+#if _HAS_CXX20
+template <class _Alloc>
+struct _Allocate_n_ptr {
+    _Alloc& _Al;
+    _Alloc_ptr_t<_Alloc> _Ptr;
+    size_t _Nx;
+
+    _Allocate_n_ptr(_Alloc& _Al_, const size_t _Nx_)
+        : _Al(_Al_), _Ptr(_Al_.allocate(_Convert_size<_Alloc_size_t<_Alloc>>(_Nx_))), _Nx(_Nx_) {}
+
+    ~_Allocate_n_ptr() {
+        if (_Ptr) {
+            _Al.deallocate(_Ptr, static_cast<_Alloc_size_t<_Alloc>>(_Nx));
+        }
+    }
+
+    _Allocate_n_ptr(const _Allocate_n_ptr&)            = delete;
+    _Allocate_n_ptr& operator=(const _Allocate_n_ptr&) = delete;
+};
+
+template <bool _IsForOverwrite, class _Ty, class _Alloc, class... _ArgTypes>
+_NODISCARD shared_ptr<_Ty> _Allocate_shared_unbounded_array(
+    const _Alloc& _Al, const size_t _Count, const _ArgTypes&... _Args) {
+    // make a shared_ptr to an unbounded array
+    static_assert(is_unbounded_array_v<_Ty>);
+    using _Refc             = conditional_t<_IsForOverwrite, //
+        _Ref_count_unbounded_array_alloc_for_overwrite<remove_cv_t<_Ty>, _Alloc>,
+        _Ref_count_unbounded_array_alloc<remove_cv_t<_Ty>, _Alloc>>;
+    constexpr size_t _Align = alignof(_Refc);
+    using _Storage          = _Alignas_storage_unit<_Align>;
+    _Rebind_alloc_t<_Alloc, _Storage> _Rebound(_Al);
+    const size_t _Bytes         = _Calculate_bytes_for_flexible_array<_Refc, _Check_overflow::_Yes>(_Count);
+    const size_t _Storage_units = _Bytes / sizeof(_Storage);
+    _Allocate_n_ptr _Guard{_Rebound, _Storage_units};
+    const auto _Rx = reinterpret_cast<_Refc*>(_STD _Unfancy(_Guard._Ptr));
+    ::new (static_cast<void*>(_Rx)) _Refc(_Al, _Count, _Args...);
+    _Guard._Ptr = nullptr;
+    shared_ptr<_Ty> _Ret;
+    _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Get_ptr(), _Rx);
+    return _Ret;
+}
+
+_EXPORT_STD template <_Unbounded_builtin_array _Ty, class _Alloc>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> allocate_shared(const _Alloc& _Al, const size_t _Count) {
+    return _STD _Allocate_shared_unbounded_array<false, _Ty>(_Al, _Count);
+}
+
+_EXPORT_STD template <_Unbounded_builtin_array _Ty, class _Alloc>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> allocate_shared(
+    const _Alloc& _Al, const size_t _Count, const remove_extent_t<_Ty>& _Val) {
+    return _STD _Allocate_shared_unbounded_array<false, _Ty>(_Al, _Count, _Val);
+}
+
+_EXPORT_STD template <_Bounded_builtin_array _Ty, class _Alloc>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> allocate_shared(const _Alloc& _Al) {
+    // make a shared_ptr to a bounded array
+    using _Refc    = _Ref_count_bounded_array_alloc<remove_cv_t<_Ty>, _Alloc>;
+    using _Alblock = _Rebind_alloc_t<_Alloc, _Refc>;
+    _Alblock _Rebound(_Al);
+    _Alloc_construct_ptr _Constructor{_Rebound};
+    _Constructor._Allocate();
+    ::new (_STD _Voidify_unfancy(_Constructor._Ptr)) _Refc(_Al);
+    shared_ptr<_Ty> _Ret;
+    const auto _Ptr = static_cast<remove_extent_t<_Ty>*>(_Constructor._Ptr->_Storage._Value);
+    _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _STD _Unfancy(_Constructor._Release()));
+    return _Ret;
+}
+
+_EXPORT_STD template <_Bounded_builtin_array _Ty, class _Alloc>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> allocate_shared(const _Alloc& _Al, const remove_extent_t<_Ty>& _Val) {
+    // make a shared_ptr to a bounded array
+    using _Refc    = _Ref_count_bounded_array_alloc<remove_cv_t<_Ty>, _Alloc>;
+    using _Alblock = _Rebind_alloc_t<_Alloc, _Refc>;
+    _Alblock _Rebound(_Al);
+    _Alloc_construct_ptr _Constructor{_Rebound};
+    _Constructor._Allocate();
+    ::new (_STD _Voidify_unfancy(_Constructor._Ptr)) _Refc(_Al, _Val);
+    shared_ptr<_Ty> _Ret;
+    const auto _Ptr = static_cast<remove_extent_t<_Ty>*>(_Constructor._Ptr->_Storage._Value);
+    _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _STD _Unfancy(_Constructor._Release()));
+    return _Ret;
+}
+
+_EXPORT_STD template <_Not_unbounded_builtin_array _Ty, class _Alloc>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> allocate_shared_for_overwrite(const _Alloc& _Al) {
+    shared_ptr<_Ty> _Ret;
+    if constexpr (is_array_v<_Ty>) {
+        // make a shared_ptr to a bounded array
+        using _Refc    = _Ref_count_bounded_array_alloc_for_overwrite<remove_cv_t<_Ty>, _Alloc>;
+        using _Alblock = _Rebind_alloc_t<_Alloc, _Refc>;
+        _Alblock _Rebound(_Al);
+        _Alloc_construct_ptr _Constructor{_Rebound};
+        _Constructor._Allocate();
+        ::new (_STD _Voidify_unfancy(_Constructor._Ptr)) _Refc(_Al);
+        const auto _Ptr = static_cast<remove_extent_t<_Ty>*>(_Constructor._Ptr->_Storage._Value);
+        _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _STD _Unfancy(_Constructor._Release()));
+    } else {
+        // make a shared_ptr to non-array object
+        using _Refoa   = _Ref_count_obj_alloc_for_overwrite<remove_cv_t<_Ty>, _Alloc>;
+        using _Alblock = _Rebind_alloc_t<_Alloc, _Refoa>;
+        _Alblock _Rebound(_Al);
+        _Alloc_construct_ptr<_Alblock> _Constructor{_Rebound};
+        _Constructor._Allocate();
+        _STD _Construct_in_place(*_Constructor._Ptr, _Al);
+        const auto _Ptr = reinterpret_cast<_Ty*>(_STD addressof(_Constructor._Ptr->_Storage._Value));
+        _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _STD _Unfancy(_Constructor._Release()));
+    }
+
+    return _Ret;
+}
+
+_EXPORT_STD template <_Unbounded_builtin_array _Ty, class _Alloc>
+_NODISCARD_SMART_PTR_ALLOC shared_ptr<_Ty> allocate_shared_for_overwrite(const _Alloc& _Al, const size_t _Count) {
+    return _STD _Allocate_shared_unbounded_array<true, _Ty>(_Al, _Count);
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty>
+class weak_ptr : public _Ptr_base<_Ty> { // class for pointer to reference counted resource
+public:
+#ifndef _M_CEE_PURE
+    // When a constructor is converting from weak_ptr<_Ty2> to weak_ptr<_Ty>, the below type trait intentionally asks
+    // whether it would be possible to static_cast from _Ty* to const _Ty2*; see N4950 [expr.static.cast]/12.
+
+    // Primary template, the value is used when the substitution fails.
+    template <class _Ty2, class = const _Ty2*>
+    static constexpr bool _Must_avoid_expired_conversions_from = true;
+
+    // Template specialization, the value is used when the substitution succeeds.
+    template <class _Ty2>
+    static constexpr bool
+        _Must_avoid_expired_conversions_from<_Ty2, decltype(static_cast<const _Ty2*>(static_cast<_Ty*>(nullptr)))> =
+            false;
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    constexpr weak_ptr() noexcept {}
+
+    weak_ptr(const weak_ptr& _Other) noexcept {
+        this->_Weakly_construct_from(_Other); // same type, no conversion
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    weak_ptr(const shared_ptr<_Ty2>& _Other) noexcept {
+        this->_Weakly_construct_from(_Other); // shared_ptr keeps resource alive during conversion
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    weak_ptr(const weak_ptr<_Ty2>& _Other) noexcept {
+#ifdef _M_CEE_PURE
+        constexpr bool _Avoid_expired_conversions = true; // slow, but always safe; avoids error LNK1179
+#else
+        constexpr bool _Avoid_expired_conversions = _Must_avoid_expired_conversions_from<_Ty2>;
+#endif
+
+        if constexpr (_Avoid_expired_conversions) {
+            this->_Weakly_convert_lvalue_avoiding_expired_conversions(_Other);
+        } else {
+            this->_Weakly_construct_from(_Other);
+        }
+    }
+
+    weak_ptr(weak_ptr&& _Other) noexcept {
+        this->_Move_construct_from(_STD move(_Other));
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    weak_ptr(weak_ptr<_Ty2>&& _Other) noexcept {
+#ifdef _M_CEE_PURE
+        constexpr bool _Avoid_expired_conversions = true; // slow, but always safe; avoids error LNK1179
+#else
+        constexpr bool _Avoid_expired_conversions = _Must_avoid_expired_conversions_from<_Ty2>;
+#endif
+
+        if constexpr (_Avoid_expired_conversions) {
+            this->_Weakly_convert_rvalue_avoiding_expired_conversions(_STD move(_Other));
+        } else {
+            this->_Move_construct_from(_STD move(_Other));
+        }
+    }
+
+    ~weak_ptr() noexcept {
+        this->_Decwref();
+    }
+
+    weak_ptr& operator=(const weak_ptr& _Right) noexcept {
+        weak_ptr(_Right).swap(*this);
+        return *this;
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    weak_ptr& operator=(const weak_ptr<_Ty2>& _Right) noexcept {
+        weak_ptr(_Right).swap(*this);
+        return *this;
+    }
+
+    weak_ptr& operator=(weak_ptr&& _Right) noexcept {
+        weak_ptr(_STD move(_Right)).swap(*this);
+        return *this;
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    weak_ptr& operator=(weak_ptr<_Ty2>&& _Right) noexcept {
+        weak_ptr(_STD move(_Right)).swap(*this);
+        return *this;
+    }
+
+    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
+    weak_ptr& operator=(const shared_ptr<_Ty2>& _Right) noexcept {
+        weak_ptr(_Right).swap(*this);
+        return *this;
+    }
+
+    void reset() noexcept { // release resource, convert to null weak_ptr object
+        weak_ptr{}.swap(*this);
+    }
+
+    void swap(weak_ptr& _Other) noexcept {
+        this->_Swap(_Other);
+    }
+
+    _NODISCARD bool expired() const noexcept {
+        return this->use_count() == 0;
+    }
+
+    _NODISCARD shared_ptr<_Ty> lock() const noexcept { // convert to shared_ptr
+        shared_ptr<_Ty> _Ret;
+        (void) _Ret._Construct_from_weak(*this);
+        return _Ret;
+    }
+};
+
+#if _HAS_CXX17
+template <class _Ty>
+weak_ptr(shared_ptr<_Ty>) -> weak_ptr<_Ty>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty>
+void swap(weak_ptr<_Ty>& _Left, weak_ptr<_Ty>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty>
+class enable_shared_from_this { // provide member functions that create shared_ptr to this
+public:
+    using _Esft_type = enable_shared_from_this;
+
+    _NODISCARD shared_ptr<_Ty> shared_from_this() {
+        return shared_ptr<_Ty>(_Wptr);
+    }
+
+    _NODISCARD shared_ptr<const _Ty> shared_from_this() const {
+        return shared_ptr<const _Ty>(_Wptr);
+    }
+
+    _NODISCARD weak_ptr<_Ty> weak_from_this() noexcept {
+        return _Wptr;
+    }
+
+    _NODISCARD weak_ptr<const _Ty> weak_from_this() const noexcept {
+        return _Wptr;
+    }
+
+protected:
+    constexpr enable_shared_from_this() noexcept : _Wptr() {}
+
+    enable_shared_from_this(const enable_shared_from_this&) noexcept : _Wptr() {
+        // construct (must value-initialize _Wptr)
+    }
+
+    enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept { // assign (must not change _Wptr)
+        return *this;
+    }
+
+    ~enable_shared_from_this() = default;
+
+private:
+    template <class _Yty>
+    friend class shared_ptr;
+
+    mutable weak_ptr<_Ty> _Wptr;
+};
+
+_EXPORT_STD template <class _Ty>
+struct default_delete { // default deleter for unique_ptr
+    constexpr default_delete() noexcept = default;
+
+    template <class _Ty2, enable_if_t<is_convertible_v<_Ty2*, _Ty*>, int> = 0>
+    _CONSTEXPR23 default_delete(const default_delete<_Ty2>&) noexcept {}
+
+    _CONSTEXPR23 void operator()(_Ty* _Ptr) const noexcept /* strengthened */ { // delete a pointer
+        static_assert(0 < sizeof(_Ty), "can't delete an incomplete type");
+        delete _Ptr;
+    }
+};
+
+template <class _Ty>
+struct default_delete<_Ty[]> { // default deleter for unique_ptr to array of unknown size
+    constexpr default_delete() noexcept = default;
+
+    template <class _Uty, enable_if_t<is_convertible_v<_Uty (*)[], _Ty (*)[]>, int> = 0>
+    _CONSTEXPR23 default_delete(const default_delete<_Uty[]>&) noexcept {}
+
+    template <class _Uty, enable_if_t<is_convertible_v<_Uty (*)[], _Ty (*)[]>, int> = 0>
+    _CONSTEXPR23 void operator()(_Uty* _Ptr) const noexcept /* strengthened */ { // delete a pointer
+        static_assert(0 < sizeof(_Uty), "can't delete an incomplete type");
+        delete[] _Ptr;
+    }
+};
+
+template <class _Ty, class _Dx_noref, class = void>
+struct _Get_deleter_pointer_type { // provide fallback
+    using type = _Ty*;
+};
+
+template <class _Ty, class _Dx_noref>
+struct _Get_deleter_pointer_type<_Ty, _Dx_noref, void_t<typename _Dx_noref::pointer>> { // get _Dx_noref::pointer
+    using type = typename _Dx_noref::pointer;
+};
+
+template <class _Dx2>
+using _Unique_ptr_enable_default_t =
+    enable_if_t<conjunction_v<negation<is_pointer<_Dx2>>, is_default_constructible<_Dx2>>, int>;
+
+template <class, class = void>
+constexpr bool _Can_form_pointer = false;
+template <class _Ty>
+constexpr bool _Can_form_pointer<_Ty, void_t<_Ty*>> = true;
+
+template <class, class = void>
+constexpr bool _Can_dereference = false;
+template <class _Ty>
+constexpr bool _Can_dereference<_Ty, void_t<decltype(*_STD declval<_Ty>())>> = true;
+
+_EXPORT_STD template <class _Ty, class _Dx /* = default_delete<_Ty> */>
+class unique_ptr { // non-copyable pointer to an object
+public:
+    static_assert(_Can_form_pointer<_Ty>,
+        "unique_ptr<T, D> requires T* to be a valid type (N5001 [unique.ptr.single.general]/1).");
+
+    using pointer      = typename _Get_deleter_pointer_type<_Ty, remove_reference_t<_Dx>>::type;
+    using element_type = _Ty;
+    using deleter_type = _Dx;
+
+    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
+    constexpr unique_ptr() noexcept : _Mypair(_Zero_then_variadic_args_t{}) {}
+
+    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
+    constexpr unique_ptr(nullptr_t) noexcept : _Mypair(_Zero_then_variadic_args_t{}) {}
+
+    _CONSTEXPR23 unique_ptr& operator=(nullptr_t) noexcept {
+        reset();
+        return *this;
+    }
+
+    // The Standard depicts these constructors that accept pointer as taking type_identity_t<pointer> to inhibit CTAD.
+    // Since pointer is an opaque type alias in our implementation, it inhibits CTAD without extra decoration.
+    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
+    _CONSTEXPR23 explicit unique_ptr(pointer _Ptr) noexcept : _Mypair(_Zero_then_variadic_args_t{}, _Ptr) {}
+
+    template <class _Dx2 = _Dx, enable_if_t<is_constructible_v<_Dx2, const _Dx2&>, int> = 0>
+    _CONSTEXPR23 unique_ptr(pointer _Ptr, const _Dx& _Dt) noexcept : _Mypair(_One_then_variadic_args_t{}, _Dt, _Ptr) {}
+
+    template <class _Dx2                                                                            = _Dx,
+        enable_if_t<conjunction_v<negation<is_reference<_Dx2>>, is_constructible<_Dx2, _Dx2>>, int> = 0>
+    _CONSTEXPR23 unique_ptr(pointer _Ptr, _Dx&& _Dt) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD move(_Dt), _Ptr) {}
+
+    template <class _Dx2                                                                                      = _Dx,
+        enable_if_t<conjunction_v<is_reference<_Dx2>, is_constructible<_Dx2, remove_reference_t<_Dx2>>>, int> = 0>
+    unique_ptr(pointer, remove_reference_t<_Dx>&&) = delete;
+
+    template <class _Dx2 = _Dx, enable_if_t<is_move_constructible_v<_Dx2>, int> = 0>
+    _CONSTEXPR23 unique_ptr(unique_ptr&& _Right) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Dx>(_Right.get_deleter()), _Right.release()) {}
+
+    template <class _Ty2, class _Dx2,
+        enable_if_t<
+            conjunction_v<negation<is_array<_Ty2>>, is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer, pointer>,
+                conditional_t<is_reference_v<_Dx>, is_same<_Dx2, _Dx>, is_convertible<_Dx2, _Dx>>>,
+            int> = 0>
+    _CONSTEXPR23 unique_ptr(unique_ptr<_Ty2, _Dx2>&& _Right) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Dx2>(_Right.get_deleter()), _Right.release()) {}
+
+#if _HAS_AUTO_PTR_ETC
+    template <class _Ty2,
+        enable_if_t<conjunction_v<is_convertible<_Ty2*, pointer>, is_same<_Dx, default_delete<_Ty>>>, int> = 0>
+    unique_ptr(auto_ptr<_Ty2>&& _Right) noexcept : _Mypair(_Zero_then_variadic_args_t{}, _Right.release()) {}
+#endif // _HAS_AUTO_PTR_ETC
+
+    template <class _Ty2, class _Dx2,
+        enable_if_t<conjunction_v<negation<is_array<_Ty2>>, is_assignable<_Dx&, _Dx2>,
+                        is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer, pointer>>,
+            int> = 0>
+    _CONSTEXPR23 unique_ptr& operator=(unique_ptr<_Ty2, _Dx2>&& _Right) noexcept {
+        reset(_Right.release());
+        _Mypair._Get_first() = _STD forward<_Dx2>(_Right._Mypair._Get_first());
+        return *this;
+    }
+
+    template <class _Dx2 = _Dx, enable_if_t<is_move_assignable_v<_Dx2>, int> = 0>
+    _CONSTEXPR23 unique_ptr& operator=(unique_ptr&& _Right) noexcept {
+        reset(_Right.release());
+        _Mypair._Get_first() = _STD forward<_Dx>(_Right._Mypair._Get_first());
+        return *this;
+    }
+
+    _CONSTEXPR23 void swap(unique_ptr& _Right) noexcept {
+        using _STD swap;
+        swap(_Mypair._Myval2, _Right._Mypair._Myval2); // intentional ADL
+        swap(_Mypair._Get_first(), _Right._Mypair._Get_first()); // intentional ADL
+    }
+
+    _CONSTEXPR23 ~unique_ptr() noexcept {
+        if (_Mypair._Myval2) {
+            _Mypair._Get_first()(_Mypair._Myval2);
+        }
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        if constexpr (is_pointer_v<pointer>) {
+            if (!_STD _Is_constant_evaluated()) {
+                const auto _Tombstone{reinterpret_cast<pointer>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+                _Mypair._Myval2 = _Tombstone;
+            }
+        }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    }
+
+    _NODISCARD _CONSTEXPR23 _Dx& get_deleter() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _NODISCARD _CONSTEXPR23 const _Dx& get_deleter() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    template <class _Ptr = pointer, enable_if_t<_Can_dereference<_Ptr>, int> = 0>
+    _NODISCARD _CONSTEXPR23 add_lvalue_reference_t<_Ty> operator*() const noexcept(noexcept(*_STD declval<pointer>())) {
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+        static_assert(
+            !reference_converts_from_temporary_v<add_lvalue_reference_t<_Ty>, decltype(*_STD declval<pointer>())>,
+            "Can't return a temporary object from unique_ptr::operator*(). (N5014 [unique.ptr.single.observers]/1)");
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+        return *_Mypair._Myval2;
+    }
+
+    _NODISCARD _CONSTEXPR23 pointer operator->() const noexcept {
+        return _Mypair._Myval2;
+    }
+
+    _NODISCARD _CONSTEXPR23 pointer get() const noexcept {
+        return _Mypair._Myval2;
+    }
+
+    _CONSTEXPR23 explicit operator bool() const noexcept {
+        return static_cast<bool>(_Mypair._Myval2);
+    }
+
+    _CONSTEXPR23 pointer release() noexcept {
+        return _STD exchange(_Mypair._Myval2, nullptr);
+    }
+
+    _CONSTEXPR23 void reset(pointer _Ptr = nullptr) noexcept {
+        pointer _Old = _STD exchange(_Mypair._Myval2, _Ptr);
+        if (_Old) {
+            _Mypair._Get_first()(_Old);
+        }
+    }
+
+    unique_ptr(const unique_ptr&)            = delete;
+    unique_ptr& operator=(const unique_ptr&) = delete;
+
+private:
+    template <class, class>
+    friend class unique_ptr;
+
+    _Compressed_pair<_Dx, pointer> _Mypair;
+};
+
+template <class _Ty, class _Dx>
+class unique_ptr<_Ty[], _Dx> { // non-copyable pointer to an array object
+public:
+    using pointer      = typename _Get_deleter_pointer_type<_Ty, remove_reference_t<_Dx>>::type;
+    using element_type = _Ty;
+    using deleter_type = _Dx;
+
+    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
+    constexpr unique_ptr() noexcept : _Mypair(_Zero_then_variadic_args_t{}) {}
+
+    template <class _Uty, class _Is_nullptr = is_null_pointer<_Uty>>
+    using _Enable_ctor_reset =
+        enable_if_t<is_same_v<_Uty, pointer> || _Is_nullptr::value
+                        || (is_same_v<pointer, element_type*> && is_pointer_v<_Uty>
+                            && is_convertible_v<remove_pointer_t<_Uty> (*)[], element_type (*)[]>),
+            int>;
+
+    template <class _Uty, class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0, _Enable_ctor_reset<_Uty> = 0>
+    _CONSTEXPR23 explicit unique_ptr(_Uty _Ptr) noexcept : _Mypair(_Zero_then_variadic_args_t{}, _Ptr) {}
+
+    template <class _Uty, class _Dx2 = _Dx, enable_if_t<is_constructible_v<_Dx2, const _Dx2&>, int> = 0,
+        _Enable_ctor_reset<_Uty> = 0>
+    _CONSTEXPR23 unique_ptr(_Uty _Ptr, const _Dx& _Dt) noexcept : _Mypair(_One_then_variadic_args_t{}, _Dt, _Ptr) {}
+
+    template <class _Uty, class _Dx2 = _Dx,
+        enable_if_t<conjunction_v<negation<is_reference<_Dx2>>, is_constructible<_Dx2, _Dx2>>, int> = 0,
+        _Enable_ctor_reset<_Uty>                                                                    = 0>
+    _CONSTEXPR23 unique_ptr(_Uty _Ptr, _Dx&& _Dt) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD move(_Dt), _Ptr) {}
+
+    template <class _Uty, class _Dx2 = _Dx,
+        enable_if_t<conjunction_v<is_reference<_Dx2>, is_constructible<_Dx2, remove_reference_t<_Dx2>>>, int> = 0>
+    unique_ptr(_Uty, remove_reference_t<_Dx>&&) = delete;
+
+    template <class _Dx2 = _Dx, enable_if_t<is_move_constructible_v<_Dx2>, int> = 0>
+    _CONSTEXPR23 unique_ptr(unique_ptr&& _Right) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Dx>(_Right.get_deleter()), _Right.release()) {}
+
+    template <class _Dx2 = _Dx, enable_if_t<is_move_assignable_v<_Dx2>, int> = 0>
+    _CONSTEXPR23 unique_ptr& operator=(unique_ptr&& _Right) noexcept {
+        if (this != _STD addressof(_Right)) {
+            reset(_Right.release());
+            _Mypair._Get_first() = _STD move(_Right._Mypair._Get_first());
+        }
+
+        return *this;
+    }
+
+    template <class _Uty, class _Ex, class _More, class _UP_pointer = typename unique_ptr<_Uty, _Ex>::pointer,
+        class _UP_element_type = typename unique_ptr<_Uty, _Ex>::element_type>
+    using _Enable_conversion = enable_if_t<
+        conjunction_v<is_array<_Uty>, is_same<pointer, element_type*>, is_same<_UP_pointer, _UP_element_type*>,
+            is_convertible<_UP_element_type (*)[], element_type (*)[]>, _More>,
+        int>;
+
+    template <class _Uty, class _Ex,
+        _Enable_conversion<_Uty, _Ex, conditional_t<is_reference_v<_Dx>, is_same<_Ex, _Dx>, is_convertible<_Ex, _Dx>>> =
+            0>
+    _CONSTEXPR23 unique_ptr(unique_ptr<_Uty, _Ex>&& _Right) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Ex>(_Right.get_deleter()), _Right.release()) {}
+
+    template <class _Uty, class _Ex, _Enable_conversion<_Uty, _Ex, is_assignable<_Dx&, _Ex>> = 0>
+    _CONSTEXPR23 unique_ptr& operator=(unique_ptr<_Uty, _Ex>&& _Right) noexcept {
+        reset(_Right.release());
+        _Mypair._Get_first() = _STD forward<_Ex>(_Right._Mypair._Get_first());
+        return *this;
+    }
+
+    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
+    constexpr unique_ptr(nullptr_t) noexcept : _Mypair(_Zero_then_variadic_args_t{}) {}
+
+    _CONSTEXPR23 unique_ptr& operator=(nullptr_t) noexcept {
+        reset();
+        return *this;
+    }
+
+    _CONSTEXPR23 void reset(nullptr_t = nullptr) noexcept {
+        reset(pointer());
+    }
+
+    _CONSTEXPR23 void swap(unique_ptr& _Right) noexcept {
+        using _STD swap;
+        swap(_Mypair._Myval2, _Right._Mypair._Myval2); // intentional ADL
+        swap(_Mypair._Get_first(), _Right._Mypair._Get_first()); // intentional ADL
+    }
+
+    _CONSTEXPR23 ~unique_ptr() noexcept {
+        if (_Mypair._Myval2) {
+            _Mypair._Get_first()(_Mypair._Myval2);
+        }
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        if constexpr (is_pointer_v<pointer>) {
+            if (!_STD _Is_constant_evaluated()) {
+                const auto _Tombstone{reinterpret_cast<pointer>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+                _Mypair._Myval2 = _Tombstone;
+            }
+        }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    }
+
+    _NODISCARD _CONSTEXPR23 _Dx& get_deleter() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _NODISCARD _CONSTEXPR23 const _Dx& get_deleter() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _NODISCARD _CONSTEXPR23 _Ty& operator[](size_t _Idx) const noexcept /* strengthened */ {
+        return _Mypair._Myval2[_Idx];
+    }
+
+    _NODISCARD _CONSTEXPR23 pointer get() const noexcept {
+        return _Mypair._Myval2;
+    }
+
+    _CONSTEXPR23 explicit operator bool() const noexcept {
+        return static_cast<bool>(_Mypair._Myval2);
+    }
+
+    _CONSTEXPR23 pointer release() noexcept {
+        return _STD exchange(_Mypair._Myval2, nullptr);
+    }
+
+    template <class _Uty, _Enable_ctor_reset<_Uty, false_type> = 0>
+    _CONSTEXPR23 void reset(_Uty _Ptr) noexcept {
+        pointer _Old = _STD exchange(_Mypair._Myval2, _Ptr);
+        if (_Old) {
+            _Mypair._Get_first()(_Old);
+        }
+    }
+
+    unique_ptr(const unique_ptr&)            = delete;
+    unique_ptr& operator=(const unique_ptr&) = delete;
+
+private:
+    template <class, class>
+    friend class unique_ptr;
+
+    _Compressed_pair<_Dx, pointer> _Mypair;
+};
+
+_EXPORT_STD template <class _Ty, class... _Types, enable_if_t<!is_array_v<_Ty>, int> = 0>
+_NODISCARD_SMART_PTR_ALLOC _CONSTEXPR23 unique_ptr<_Ty> make_unique(_Types&&... _Args) { // make a unique_ptr
+    return unique_ptr<_Ty>(new _Ty(_STD forward<_Types>(_Args)...));
+}
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_array_v<_Ty> && extent_v<_Ty> == 0, int> = 0>
+_NODISCARD_SMART_PTR_ALLOC _CONSTEXPR23 unique_ptr<_Ty> make_unique(const size_t _Size) { // make a unique_ptr
+    using _Elem = remove_extent_t<_Ty>;
+    return unique_ptr<_Ty>(new _Elem[_Size]());
+}
+
+_EXPORT_STD template <class _Ty, class... _Types, enable_if_t<extent_v<_Ty> != 0, int> = 0>
+void make_unique(_Types&&...) = delete;
+
+#if _HAS_CXX20
+_EXPORT_STD template <_Not_builtin_array _Ty>
+_NODISCARD_SMART_PTR_ALLOC _CONSTEXPR23 unique_ptr<_Ty> make_unique_for_overwrite() {
+    // make a unique_ptr with default initialization
+    return unique_ptr<_Ty>(new _Ty);
+}
+
+_EXPORT_STD template <_Unbounded_builtin_array _Ty>
+_NODISCARD_SMART_PTR_ALLOC _CONSTEXPR23 unique_ptr<_Ty> make_unique_for_overwrite(const size_t _Size) {
+    // make a unique_ptr with default initialization
+    using _Elem = remove_extent_t<_Ty>;
+    return unique_ptr<_Ty>(new _Elem[_Size]);
+}
+
+_EXPORT_STD template <_Bounded_builtin_array _Ty, class... _Types>
+void make_unique_for_overwrite(_Types&&...) = delete;
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty, class _Dx, enable_if_t<_Is_swappable<_Dx>::value, int> = 0>
+_CONSTEXPR23 void swap(unique_ptr<_Ty, _Dx>& _Left, unique_ptr<_Ty, _Dx>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_NODISCARD _CONSTEXPR23 bool operator==(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
+    return _Left.get() == _Right.get();
+}
+
+#if !_HAS_CXX20
+template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_NODISCARD bool operator!=(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_NODISCARD bool operator<(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
+    using _Ptr1   = typename unique_ptr<_Ty1, _Dx1>::pointer;
+    using _Ptr2   = typename unique_ptr<_Ty2, _Dx2>::pointer;
+    using _Common = common_type_t<_Ptr1, _Ptr2>;
+    return less<_Common>{}(_Left.get(), _Right.get());
+}
+
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_NODISCARD bool operator>=(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
+    return !(_Left < _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_NODISCARD bool operator>(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
+    return _Right < _Left;
+}
+
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+_NODISCARD bool operator<=(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
+    return !(_Right < _Left);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
+    requires three_way_comparable_with<typename unique_ptr<_Ty1, _Dx1>::pointer,
+        typename unique_ptr<_Ty2, _Dx2>::pointer>
+_NODISCARD
+    compare_three_way_result_t<typename unique_ptr<_Ty1, _Dx1>::pointer, typename unique_ptr<_Ty2, _Dx2>::pointer>
+    operator<=>(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
+    return _Left.get() <=> _Right.get();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator==(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) noexcept {
+    return !_Left;
+}
+
+#if !_HAS_CXX20
+template <class _Ty, class _Dx>
+_NODISCARD bool operator==(nullptr_t, const unique_ptr<_Ty, _Dx>& _Right) noexcept {
+    return !_Right;
+}
+
+template <class _Ty, class _Dx>
+_NODISCARD bool operator!=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) noexcept {
+    return !(_Left == nullptr);
+}
+
+template <class _Ty, class _Dx>
+_NODISCARD bool operator!=(nullptr_t, const unique_ptr<_Ty, _Dx>& _Right) noexcept {
+    return !(nullptr == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator<(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) {
+    using _Ptr = typename unique_ptr<_Ty, _Dx>::pointer;
+    return less<_Ptr>{}(_Left.get(), nullptr);
+}
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator<(nullptr_t, const unique_ptr<_Ty, _Dx>& _Right) {
+    using _Ptr = typename unique_ptr<_Ty, _Dx>::pointer;
+    return less<_Ptr>{}(nullptr, _Right.get());
+}
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator>=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) {
+    return !(_Left < nullptr);
+}
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator>=(nullptr_t, const unique_ptr<_Ty, _Dx>& _Right) {
+    return !(nullptr < _Right);
+}
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator>(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) {
+    return nullptr < _Left;
+}
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator>(nullptr_t, const unique_ptr<_Ty, _Dx>& _Right) {
+    return _Right < nullptr;
+}
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator<=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) {
+    return !(nullptr < _Left);
+}
+
+_EXPORT_STD template <class _Ty, class _Dx>
+_NODISCARD _CONSTEXPR23 bool operator<=(nullptr_t, const unique_ptr<_Ty, _Dx>& _Right) {
+    return !(_Right < nullptr);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Dx>
+    requires three_way_comparable<typename unique_ptr<_Ty, _Dx>::pointer>
+_NODISCARD _CONSTEXPR23 compare_three_way_result_t<typename unique_ptr<_Ty, _Dx>::pointer> operator<=>(
+    const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) {
+    return _Left.get() <=> static_cast<typename unique_ptr<_Ty, _Dx>::pointer>(nullptr);
+}
+#endif // _HAS_CXX20
+
+template <class _OutTy, class _PxTy, class = void>
+struct _Can_stream_unique_ptr : false_type {};
+template <class _OutTy, class _PxTy>
+struct _Can_stream_unique_ptr<_OutTy, _PxTy, void_t<decltype(_STD declval<_OutTy>() << _STD declval<_PxTy>().get())>>
+    : true_type {};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Yty, class _Dx,
+    enable_if_t<_Can_stream_unique_ptr<basic_ostream<_Elem, _Traits>&, const unique_ptr<_Yty, _Dx>&>::value, int> = 0>
+basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Out, const unique_ptr<_Yty, _Dx>& _Px) {
+    // write contained pointer to stream
+    _Out << _Px.get();
+    return _Out;
+}
+
+#if _HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23
+_EXPORT_STD enum class pointer_safety { relaxed, preferred, strict };
+
+_EXPORT_STD inline void declare_reachable(void*) {}
+
+_EXPORT_STD template <class _Ty>
+_Ty* undeclare_reachable(_Ty* _Ptr) {
+    return _Ptr;
+}
+
+_EXPORT_STD inline void declare_no_pointers(char*, size_t) {}
+
+_EXPORT_STD inline void undeclare_no_pointers(char*, size_t) {}
+
+_EXPORT_STD inline pointer_safety get_pointer_safety() noexcept {
+    return pointer_safety::relaxed;
+}
+#endif // _HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23
+
+_EXPORT_STD template <class _Ty = void>
+struct owner_less; // not defined
+
+template <class _Ty>
+struct owner_less<shared_ptr<_Ty>> {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = shared_ptr<_Ty>;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = shared_ptr<_Ty>;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD bool operator()(const shared_ptr<_Ty>& _Left, const shared_ptr<_Ty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+
+    _NODISCARD bool operator()(const shared_ptr<_Ty>& _Left, const weak_ptr<_Ty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+
+    _NODISCARD bool operator()(const weak_ptr<_Ty>& _Left, const shared_ptr<_Ty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+};
+
+template <class _Ty>
+struct owner_less<weak_ptr<_Ty>> {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = weak_ptr<_Ty>;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = weak_ptr<_Ty>;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD bool operator()(const weak_ptr<_Ty>& _Left, const weak_ptr<_Ty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+
+    _NODISCARD bool operator()(const weak_ptr<_Ty>& _Left, const shared_ptr<_Ty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+
+    _NODISCARD bool operator()(const shared_ptr<_Ty>& _Left, const weak_ptr<_Ty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+};
+
+template <>
+struct owner_less<void> {
+    template <class _Ty, class _Uty>
+    _NODISCARD bool operator()(const shared_ptr<_Ty>& _Left, const shared_ptr<_Uty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+
+    template <class _Ty, class _Uty>
+    _NODISCARD bool operator()(const shared_ptr<_Ty>& _Left, const weak_ptr<_Uty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+
+    template <class _Ty, class _Uty>
+    _NODISCARD bool operator()(const weak_ptr<_Ty>& _Left, const shared_ptr<_Uty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+
+    template <class _Ty, class _Uty>
+    _NODISCARD bool operator()(const weak_ptr<_Ty>& _Left, const weak_ptr<_Uty>& _Right) const noexcept {
+        return _Left.owner_before(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <class _Ty, class _Dx>
+struct hash<unique_ptr<_Ty, _Dx>> : _Conditionally_enabled_hash<unique_ptr<_Ty, _Dx>,
+                                        is_default_constructible_v<hash<typename unique_ptr<_Ty, _Dx>::pointer>>> {
+    static size_t _Do_hash(const unique_ptr<_Ty, _Dx>& _Keyval)
+        noexcept(_Is_nothrow_hashable<typename unique_ptr<_Ty, _Dx>::pointer>::value) {
+        return hash<typename unique_ptr<_Ty, _Dx>::pointer>{}(_Keyval.get());
+    }
+};
+
+template <class _Ty>
+struct hash<shared_ptr<_Ty>> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = shared_ptr<_Ty>;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(const shared_ptr<_Ty>& _Keyval) noexcept {
+        return hash<typename shared_ptr<_Ty>::element_type*>()(_Keyval.get());
+    }
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <size_t _Nx, class _Ty>
+_NODISCARD_ASSUME_ALIGNED constexpr _Ty* assume_aligned(_Ty* const _Ptr) noexcept /* strengthened */ {
+    if (_STD is_constant_evaluated()) {
+        return _Ptr;
+    } else {
+        // this enforces the requirement that _Nx be a power of two
+        return static_cast<_Ty*>(__builtin_assume_aligned(_Ptr, _Nx));
+    }
+}
+#endif // _HAS_CXX20
+
+extern "C" {
+_CRTIMP2_PURE void __cdecl _Lock_shared_ptr_spin_lock() noexcept;
+_CRTIMP2_PURE void __cdecl _Unlock_shared_ptr_spin_lock() noexcept;
+} // extern "C"
+
+struct _Shared_ptr_spin_lock { // class to manage a spin lock for shared_ptr atomic operations
+    _Shared_ptr_spin_lock() noexcept { // lock the spin lock
+        _Lock_shared_ptr_spin_lock();
+    }
+
+    ~_Shared_ptr_spin_lock() noexcept { // unlock the spin lock
+        _Unlock_shared_ptr_spin_lock();
+    }
+};
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT _NODISCARD bool atomic_is_lock_free(const shared_ptr<_Ty>*) {
+    // return true if atomic operations on shared_ptr<_Ty> are lock-free
+    return false;
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT _NODISCARD shared_ptr<_Ty> atomic_load_explicit(
+    const shared_ptr<_Ty>* _Ptr, memory_order) {
+    // load *_Ptr atomically
+    _Shared_ptr_spin_lock _Lock;
+    shared_ptr<_Ty> _Result = *_Ptr;
+    return _Result;
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT _NODISCARD shared_ptr<_Ty> atomic_load(
+    const shared_ptr<_Ty>* _Ptr) { // load *_Ptr atomically
+    return _STD atomic_load_explicit(_Ptr, memory_order_seq_cst);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT void atomic_store_explicit(
+    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other, memory_order) {
+    // store _Other to *_Ptr atomically
+    _Shared_ptr_spin_lock _Lock;
+    _Ptr->swap(_Other);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT void atomic_store(
+    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other) { // store _Other to *_Ptr atomically
+    _STD atomic_store_explicit(_Ptr, _STD move(_Other), memory_order_seq_cst);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT shared_ptr<_Ty> atomic_exchange_explicit(
+    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other, memory_order) {
+    // copy _Other to *_Ptr and return previous value of *_Ptr atomically
+    _Shared_ptr_spin_lock _Lock;
+    _Ptr->swap(_Other);
+    return _Other;
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT shared_ptr<_Ty> atomic_exchange(
+    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other) {
+    // copy _Other to *_Ptr and return previous value of *_Ptr atomically
+    return _STD atomic_exchange_explicit(_Ptr, _STD move(_Other), memory_order_seq_cst);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_weak_explicit(shared_ptr<_Ty>* _Ptr,
+    shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value, memory_order, memory_order) { // atomically compare and exchange
+    shared_ptr<_Ty> _Old_exp; // destroyed outside spin lock
+    _Shared_ptr_spin_lock _Lock;
+    bool _Success = _Ptr->get() == _Exp->get() && !_Ptr->owner_before(*_Exp) && !_Exp->owner_before(*_Ptr);
+    if (_Success) {
+        _Ptr->swap(_Value);
+    } else { // match failed
+        _Exp->swap(_Old_exp);
+        *_Exp = *_Ptr;
+    }
+    return _Success;
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_weak(
+    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value) {
+    // atomically compare and exchange
+    return _STD atomic_compare_exchange_weak_explicit(
+        _Ptr, _Exp, _STD move(_Value), memory_order_seq_cst, memory_order_seq_cst);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_strong_explicit(shared_ptr<_Ty>* _Ptr,
+    shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value, memory_order, memory_order) { // atomically compare and exchange
+    return _STD atomic_compare_exchange_weak_explicit(
+        _Ptr, _Exp, _STD move(_Value), memory_order_seq_cst, memory_order_seq_cst);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT bool atomic_compare_exchange_strong(
+    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value) {
+    // atomically compare and exchange
+    return _STD atomic_compare_exchange_strong_explicit(
+        _Ptr, _Exp, _STD move(_Value), memory_order_seq_cst, memory_order_seq_cst);
+}
+
+#if _HAS_CXX20
+template <class _Ty>
+class alignas(2 * sizeof(void*)) _Atomic_ptr_base {
+    // overalignment is to allow potential future use of cmpxchg16b
+protected:
+    constexpr _Atomic_ptr_base() noexcept = default;
+
+    _Atomic_ptr_base(remove_extent_t<_Ty>* const _Px, _Ref_count_base* const _Ref) noexcept
+        : _Ptr(_Px), _Repptr(_Ref) {}
+
+    void _Wait(remove_extent_t<_Ty>* _Old_ptr, _Ref_count_base* const _Old_rep, memory_order) const noexcept {
+        unsigned long _Remaining_timeout = 16; // milliseconds
+        const unsigned long _Max_timeout = 1048576; // milliseconds, ~17.5 minutes
+        for (;;) {
+            auto _Rep   = _Repptr._Lock_and_load();
+            bool _Equal = _Ptr.load(memory_order_relaxed) == _Old_ptr && _Rep == _Old_rep;
+            _Repptr._Store_and_unlock(_Rep);
+            if (!_Equal) {
+                break;
+            }
+            ::__std_atomic_wait_direct(
+                _STD addressof(_Ptr), _STD addressof(_Old_ptr), sizeof(_Old_ptr), _Remaining_timeout);
+            _Remaining_timeout = (_STD min) (_Max_timeout, _Remaining_timeout * 2);
+        }
+    }
+
+    void notify_one() noexcept {
+        _Ptr.notify_one();
+    }
+
+    void notify_all() noexcept {
+        _Ptr.notify_all();
+    }
+
+    atomic<remove_extent_t<_Ty>*> _Ptr{nullptr};
+    mutable _Locked_pointer<_Ref_count_base> _Repptr;
+};
+
+template <class _Ty>
+struct atomic<shared_ptr<_Ty>> : private _Atomic_ptr_base<_Ty> {
+private:
+    using _Base = _Atomic_ptr_base<_Ty>;
+
+public:
+    using value_type = shared_ptr<_Ty>;
+
+    static constexpr bool is_always_lock_free = false;
+
+    _NODISCARD bool is_lock_free() const noexcept {
+        return false;
+    }
+
+    void store(shared_ptr<_Ty> _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Check_store_memory_order(_Order);
+        const auto _Rep                  = this->_Repptr._Lock_and_load();
+        remove_extent_t<_Ty>* const _Tmp = _Value._Ptr;
+        _Value._Ptr                      = this->_Ptr.load(memory_order_relaxed);
+        this->_Ptr.store(_Tmp, memory_order_relaxed);
+        this->_Repptr._Store_and_unlock(_Value._Rep);
+        _Value._Rep = _Rep;
+    }
+
+    _NODISCARD shared_ptr<_Ty> load(const memory_order _Order = memory_order_seq_cst) const noexcept {
+        _Check_load_memory_order(_Order);
+        shared_ptr<_Ty> _Result;
+        const auto _Rep = this->_Repptr._Lock_and_load();
+        _Result._Ptr    = this->_Ptr.load(memory_order_relaxed);
+        _Result._Rep    = _Rep;
+        _Result._Incref();
+        this->_Repptr._Store_and_unlock(_Rep);
+        return _Result;
+    }
+
+    operator shared_ptr<_Ty>() const noexcept {
+        return load();
+    }
+
+    shared_ptr<_Ty> exchange(shared_ptr<_Ty> _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Check_memory_order(static_cast<unsigned int>(_Order));
+        shared_ptr<_Ty> _Result;
+        _Result._Rep = this->_Repptr._Lock_and_load();
+        _Result._Ptr = this->_Ptr.load(memory_order_relaxed);
+        this->_Ptr.store(_Value._Ptr, memory_order_relaxed);
+        this->_Repptr._Store_and_unlock(_Value._Rep);
+        _Value._Ptr = nullptr; // ownership of _Value ref has been given to this, silence decrement
+        _Value._Rep = nullptr;
+        return _Result;
+    }
+
+    bool compare_exchange_weak(shared_ptr<_Ty>& _Expected, shared_ptr<_Ty> _Desired, const memory_order _Success,
+        const memory_order _Failure) noexcept {
+        return compare_exchange_strong(_Expected, _STD move(_Desired), _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    bool compare_exchange_strong(shared_ptr<_Ty>& _Expected, shared_ptr<_Ty> _Desired, const memory_order _Success,
+        const memory_order _Failure) noexcept {
+        return compare_exchange_strong(_Expected, _STD move(_Desired), _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    bool compare_exchange_weak(shared_ptr<_Ty>& _Expected, shared_ptr<_Ty> _Desired,
+        const memory_order _Order = memory_order_seq_cst) noexcept {
+        return compare_exchange_strong(_Expected, _STD move(_Desired), _Order);
+    }
+
+    bool compare_exchange_strong(shared_ptr<_Ty>& _Expected, shared_ptr<_Ty> _Desired,
+        const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Check_memory_order(static_cast<unsigned int>(_Order));
+        auto _Rep = this->_Repptr._Lock_and_load();
+        if (this->_Ptr.load(memory_order_relaxed) == _Expected._Ptr && _Rep == _Expected._Rep) {
+            remove_extent_t<_Ty>* const _Tmp = _Desired._Ptr;
+            _Desired._Ptr                    = this->_Ptr.load(memory_order_relaxed);
+            this->_Ptr.store(_Tmp, memory_order_relaxed);
+            _STD swap(_Rep, _Desired._Rep);
+            this->_Repptr._Store_and_unlock(_Rep);
+            return true;
+        }
+        _Ref_count_base* _Expected_rep = _Expected._Rep;
+        _Expected._Ptr                 = this->_Ptr.load(memory_order_relaxed);
+        _Expected._Rep                 = _Rep;
+        _Expected._Incref();
+        this->_Repptr._Store_and_unlock(_Rep);
+        if (_Expected_rep) {
+            _Expected_rep->_Decref();
+        }
+        return false;
+    }
+
+    void wait(shared_ptr<_Ty> _Old, memory_order _Order = memory_order_seq_cst) const noexcept {
+        this->_Wait(_Old._Ptr, _Old._Rep, _Order);
+    }
+
+    using _Base::notify_all;
+    using _Base::notify_one;
+
+    constexpr atomic() noexcept = default;
+
+    constexpr atomic(nullptr_t) noexcept : atomic() {}
+
+    atomic(const shared_ptr<_Ty> _Value) noexcept : _Base(_Value._Ptr, _Value._Rep) {
+        _Value._Incref();
+    }
+
+    atomic(const atomic&)         = delete;
+    void operator=(const atomic&) = delete;
+
+    void operator=(shared_ptr<_Ty> _Value) noexcept {
+        store(_STD move(_Value));
+    }
+
+    void operator=(nullptr_t) noexcept {
+        store(nullptr);
+    }
+
+    ~atomic() {
+        const auto _Rep = this->_Repptr._Unsafe_load_relaxed();
+        if (_Rep) {
+            _Rep->_Decref();
+        }
+    }
+};
+
+template <class _Ty>
+struct atomic<weak_ptr<_Ty>> : private _Atomic_ptr_base<_Ty> {
+private:
+    using _Base = _Atomic_ptr_base<_Ty>;
+
+public:
+    using value_type = weak_ptr<_Ty>;
+
+    static constexpr bool is_always_lock_free = false;
+
+    _NODISCARD bool is_lock_free() const noexcept {
+        return false;
+    }
+
+    void store(weak_ptr<_Ty> _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Check_store_memory_order(_Order);
+        const auto _Rep                  = this->_Repptr._Lock_and_load();
+        remove_extent_t<_Ty>* const _Tmp = _Value._Ptr;
+        _Value._Ptr                      = this->_Ptr.load(memory_order_relaxed);
+        this->_Ptr.store(_Tmp, memory_order_relaxed);
+        this->_Repptr._Store_and_unlock(_Value._Rep);
+        _Value._Rep = _Rep;
+    }
+
+    _NODISCARD weak_ptr<_Ty> load(const memory_order _Order = memory_order_seq_cst) const noexcept {
+        _Check_load_memory_order(_Order);
+        weak_ptr<_Ty> _Result;
+        const auto _Rep = this->_Repptr._Lock_and_load();
+        _Result._Ptr    = this->_Ptr.load(memory_order_relaxed);
+        _Result._Rep    = _Rep;
+        _Result._Incwref();
+        this->_Repptr._Store_and_unlock(_Rep);
+        return _Result;
+    }
+
+    operator weak_ptr<_Ty>() const noexcept {
+        return load();
+    }
+
+    weak_ptr<_Ty> exchange(weak_ptr<_Ty> _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Check_memory_order(static_cast<unsigned int>(_Order));
+        weak_ptr<_Ty> _Result;
+        _Result._Rep = this->_Repptr._Lock_and_load();
+        _Result._Ptr = this->_Ptr.load(memory_order_relaxed);
+        this->_Ptr.store(_Value._Ptr, memory_order_relaxed);
+        this->_Repptr._Store_and_unlock(_Value._Rep);
+        _Value._Ptr = nullptr; // ownership of _Value ref has been given to this, silence decrement
+        _Value._Rep = nullptr;
+        return _Result;
+    }
+
+    bool compare_exchange_weak(weak_ptr<_Ty>& _Expected, weak_ptr<_Ty> _Desired, const memory_order _Success,
+        const memory_order _Failure) noexcept {
+        return compare_exchange_strong(_Expected, _STD move(_Desired), _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    bool compare_exchange_strong(weak_ptr<_Ty>& _Expected, weak_ptr<_Ty> _Desired, const memory_order _Success,
+        const memory_order _Failure) noexcept {
+        return compare_exchange_strong(_Expected, _STD move(_Desired), _Combine_cas_memory_orders(_Success, _Failure));
+    }
+
+    bool compare_exchange_weak(
+        weak_ptr<_Ty>& _Expected, weak_ptr<_Ty> _Desired, const memory_order _Order = memory_order_seq_cst) noexcept {
+        return compare_exchange_strong(_Expected, _STD move(_Desired), _Order);
+    }
+
+    bool compare_exchange_strong(
+        weak_ptr<_Ty>& _Expected, weak_ptr<_Ty> _Desired, const memory_order _Order = memory_order_seq_cst) noexcept {
+        _Check_memory_order(static_cast<unsigned int>(_Order));
+        auto _Rep = this->_Repptr._Lock_and_load();
+        if (this->_Ptr.load(memory_order_relaxed) == _Expected._Ptr && _Rep == _Expected._Rep) {
+            remove_extent_t<_Ty>* const _Tmp = _Desired._Ptr;
+            _Desired._Ptr                    = this->_Ptr.load(memory_order_relaxed);
+            this->_Ptr.store(_Tmp, memory_order_relaxed);
+            _STD swap(_Rep, _Desired._Rep);
+            this->_Repptr._Store_and_unlock(_Rep);
+            return true;
+        }
+        const auto _Expected_rep = _Expected._Rep;
+        _Expected._Ptr           = this->_Ptr.load(memory_order_relaxed);
+        _Expected._Rep           = _Rep;
+        _Expected._Incwref();
+        this->_Repptr._Store_and_unlock(_Rep);
+        if (_Expected_rep) {
+            _Expected_rep->_Decwref();
+        }
+        return false;
+    }
+
+    void wait(weak_ptr<_Ty> _Old, memory_order _Order = memory_order_seq_cst) const noexcept {
+        this->_Wait(_Old._Ptr, _Old._Rep, _Order);
+    }
+
+    using _Base::notify_all;
+    using _Base::notify_one;
+
+    constexpr atomic() noexcept = default;
+
+    atomic(const weak_ptr<_Ty> _Value) noexcept : _Base(_Value._Ptr, _Value._Rep) {
+        _Value._Incwref();
+    }
+
+    atomic(const atomic&)         = delete;
+    void operator=(const atomic&) = delete;
+
+    void operator=(weak_ptr<_Ty> _Value) noexcept {
+        store(_STD move(_Value));
+    }
+
+    ~atomic() {
+        const auto _Rep = this->_Repptr._Unsafe_load_relaxed();
+        if (_Rep) {
+            _Rep->_Decwref();
+        }
+    }
+};
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+template <class _Ty>
+struct _Pointer_of_helper {};
+
+template <_Has_member_pointer _Ty>
+struct _Pointer_of_helper<_Ty> {
+    using type = _Ty::pointer;
+};
+
+template <_Has_member_element_type _Ty>
+    requires (!_Has_member_pointer<_Ty>)
+struct _Pointer_of_helper<_Ty> {
+    using type = _Ty::element_type*;
+};
+
+template <class _Ty>
+    requires (
+        !_Has_member_element_type<_Ty> && !_Has_member_pointer<_Ty> && _Has_member_element_type<pointer_traits<_Ty>>)
+struct _Pointer_of_helper<_Ty> {
+    using type = pointer_traits<_Ty>::element_type*;
+};
+
+template <class _Ty>
+using _Pointer_of = _Pointer_of_helper<_Ty>::type;
+
+template <class _Ty, class _Uty>
+struct _Pointer_of_or_helper {
+    using type = _Uty;
+};
+
+template <class _Ty, class _Uty>
+    requires requires { typename _Pointer_of<_Ty>; }
+struct _Pointer_of_or_helper<_Ty, _Uty> {
+    using type = _Pointer_of<_Ty>;
+};
+
+template <class _Ty, class _Uty>
+using _Pointer_of_or = _Pointer_of_or_helper<_Ty, _Uty>::type;
+
+template <class _SmartPtr, class _Sp, class _Pointer, class... _ArgsT>
+concept _Resettable_pointer = requires(_SmartPtr& _Smart_ptr, _Pointer _Ptr, _ArgsT&&... _Args) {
+    _Smart_ptr.reset(static_cast<_Sp>(_Ptr), _STD forward<_ArgsT>(_Args)...);
+};
+
+_EXPORT_STD template <class _SmartPtr, class _Pointer, class... _ArgsT>
+class out_ptr_t {
+    static_assert(!_Is_specialization_v<_SmartPtr, shared_ptr> || sizeof...(_ArgsT) != 0,
+        "out_ptr_t with shared_ptr requires a deleter (N4950 [out.ptr.t]/3)");
+
+public:
+    explicit out_ptr_t(_SmartPtr& _Smart_ptr_, _ArgsT... _Args_)
+        noexcept(is_nothrow_constructible_v<tuple<_ArgsT...>, _ArgsT...>) /* strengthened */
+        : _Smart_ptr(_Smart_ptr_),
+          _Mypair(_One_then_variadic_args_t{}, tuple<_ArgsT...>{_STD forward<_ArgsT>(_Args_)...}) {
+        if constexpr (requires { _Smart_ptr.reset(); }) {
+            _Smart_ptr.reset();
+        } else {
+            static_assert(is_constructible_v<_SmartPtr>, "the adapted pointer type must be default constructible.");
+            _Smart_ptr = _SmartPtr();
+        }
+    }
+
+    out_ptr_t(const out_ptr_t&) = delete;
+
+    ~out_ptr_t() {
+        if (!_Get_ptr()) {
+            return;
+        }
+
+        _STD apply(
+            [this](auto&&... _Args_) {
+                using _Sp = _Pointer_of_or<_SmartPtr, _Pointer>;
+                if constexpr (_Resettable_pointer<_SmartPtr, _Sp, _Pointer, _ArgsT...>) {
+                    _Smart_ptr.reset(static_cast<_Sp>(_Get_ptr()), _STD forward<_ArgsT>(_Args_)...);
+                } else {
+                    static_assert(is_constructible_v<_SmartPtr, _Sp, _ArgsT...>, "(N4950 [out.ptr.t]/9.3)");
+                    _Smart_ptr = _SmartPtr(static_cast<_Sp>(_Get_ptr()), _STD forward<_ArgsT>(_Args_)...);
+                }
+            },
+            _STD move(_Get_args()));
+    }
+
+    operator _Pointer*() const noexcept {
+        return _STD addressof(_Get_ptr());
+    }
+
+    operator void**() const noexcept
+        requires (!is_same_v<_Pointer, void*>)
+    {
+        static_assert(is_pointer_v<_Pointer>, "conversion of out_ptr_t<Smart, Pointer, Args...> to void** requires "
+                                              "Pointer to be a raw pointer (N4950 [out.ptr.t]/13)");
+        return reinterpret_cast<void**>(_STD addressof(_Get_ptr()));
+    }
+
+private:
+    _NODISCARD _Pointer& _Get_ptr() const noexcept {
+        return const_cast<_Pointer&>(_Mypair._Myval2);
+    }
+
+    _NODISCARD tuple<_ArgsT...>& _Get_args() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _SmartPtr& _Smart_ptr;
+    _Compressed_pair<tuple<_ArgsT...>, _Pointer> _Mypair;
+};
+
+_EXPORT_STD template <class _Pointer = void, class _SmartPtr, class... _ArgsT>
+_NODISCARD auto out_ptr(_SmartPtr& _Smart_ptr, _ArgsT&&... _Args) {
+    if constexpr (is_void_v<_Pointer>) {
+        return out_ptr_t<_SmartPtr, _Pointer_of<_SmartPtr>, _ArgsT&&...>(_Smart_ptr, _STD forward<_ArgsT>(_Args)...);
+    } else {
+        return out_ptr_t<_SmartPtr, _Pointer, _ArgsT&&...>(_Smart_ptr, _STD forward<_ArgsT>(_Args)...);
+    }
+}
+
+_EXPORT_STD template <class _SmartPtr, class _Pointer, class... _ArgsT>
+class inout_ptr_t {
+    static_assert(!_Is_specialization_v<_SmartPtr, shared_ptr>,
+        "inout_ptr_t doesn't work with shared_ptr (N4950 [inout.ptr.t]/3)");
+
+private:
+    _NODISCARD static auto _Get_ptr_from_smart(_SmartPtr& _Smart_ptr) noexcept
+        requires is_pointer_v<_SmartPtr>
+    {
+        return _Smart_ptr;
+    }
+
+    _NODISCARD static auto _Get_ptr_from_smart(_SmartPtr& _Smart_ptr) noexcept(noexcept(_Smart_ptr.get())) {
+        return _Smart_ptr.get();
+    }
+
+public:
+    explicit inout_ptr_t(_SmartPtr& _Smart_ptr_, _ArgsT... _Args_)
+        noexcept(is_nothrow_constructible_v<tuple<_ArgsT...>, _ArgsT...>
+                 && noexcept(_Get_ptr_from_smart(_Smart_ptr_))) /* strengthened */
+        : _Smart_ptr(_Smart_ptr_),
+          _Mypair(_One_then_variadic_args_t{}, tuple<_ArgsT...>{_STD forward<_ArgsT>(_Args_)...},
+              _Get_ptr_from_smart(_Smart_ptr_)) {}
+
+    inout_ptr_t(const inout_ptr_t&) = delete;
+
+    ~inout_ptr_t() {
+        if constexpr (!is_pointer_v<_SmartPtr>) {
+            _Smart_ptr.release();
+
+            if (!_Get_ptr()) {
+                return;
+            }
+        }
+
+        _STD apply(
+            [this](auto&&... _Args_) {
+                using _Sp = _Pointer_of_or<_SmartPtr, _Pointer>;
+                if constexpr (is_pointer_v<_SmartPtr>) {
+                    _Smart_ptr = _SmartPtr(static_cast<_Sp>(_Get_ptr()), _STD forward<_ArgsT>(_Args_)...);
+                } else if constexpr (_Resettable_pointer<_SmartPtr, _Sp, _Pointer, _ArgsT...>) {
+                    _Smart_ptr.reset(static_cast<_Sp>(_Get_ptr()), _STD forward<_ArgsT>(_Args_)...);
+                } else {
+                    static_assert(is_constructible_v<_SmartPtr, _Sp, _ArgsT...>, "(N4950 [inout.ptr.t]/11.4)");
+                    _Smart_ptr = _SmartPtr(static_cast<_Sp>(_Get_ptr()), _STD forward<_ArgsT>(_Args_)...);
+                }
+            },
+            _STD move(_Get_args()));
+    }
+
+    operator _Pointer*() const noexcept {
+        return _STD addressof(_Get_ptr());
+    }
+
+    operator void**() const noexcept
+        requires (!is_same_v<_Pointer, void*>)
+    {
+        static_assert(is_pointer_v<_Pointer>, "conversion of inout_ptr_t<Smart, Pointer, Args...> to void** requires "
+                                              "Pointer to be a raw pointer (N4950 [inout.ptr.t]/15)");
+        return reinterpret_cast<void**>(_STD addressof(_Get_ptr()));
+    }
+
+private:
+    _NODISCARD _Pointer& _Get_ptr() const noexcept {
+        return const_cast<_Pointer&>(_Mypair._Myval2);
+    }
+
+    _NODISCARD tuple<_ArgsT...>& _Get_args() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _SmartPtr& _Smart_ptr;
+    _Compressed_pair<tuple<_ArgsT...>, _Pointer> _Mypair;
+};
+
+_EXPORT_STD template <class _Pointer = void, class _SmartPtr, class... _ArgsT>
+_NODISCARD auto inout_ptr(_SmartPtr& _Smart_ptr, _ArgsT&&... _Args) {
+    if constexpr (is_void_v<_Pointer>) {
+        return inout_ptr_t<_SmartPtr, _Pointer_of<_SmartPtr>, _ArgsT&&...>(_Smart_ptr, _STD forward<_ArgsT>(_Args)...);
+    } else {
+        return inout_ptr_t<_SmartPtr, _Pointer, _ArgsT&&...>(_Smart_ptr, _STD forward<_ArgsT>(_Args)...);
+    }
+}
+
+#ifdef __cpp_lib_start_lifetime_as // TRANSITION
+_EXPORT_STD template <class _Ty>
+_Ty* start_lifetime_as(void* const _Ptr) noexcept {
+#ifdef __cpp_lib_is_implicit_lifetime // TRANSITION, toolset update
+    static_assert(is_implicit_lifetime_v<_Ty>, "T must be an implicit-lifetime type. (N5032 [obj.lifetime]/1)");
+#endif // ^^^ no workaround ^^^
+    static_assert(sizeof(_Ty) > 0, "T must be a complete type. (N5032 [obj.lifetime]/1)");
+    return __builtin_start_lifetime_as<_Ty>(_Ptr);
+}
+_EXPORT_STD template <class _Ty>
+const _Ty* start_lifetime_as(const void* const _Ptr) noexcept {
+#ifdef __cpp_lib_is_implicit_lifetime // TRANSITION, toolset update
+    static_assert(is_implicit_lifetime_v<_Ty>, "T must be an implicit-lifetime type. (N5032 [obj.lifetime]/1)");
+#endif // ^^^ no workaround ^^^
+    static_assert(sizeof(_Ty) > 0, "T must be a complete type. (N5032 [obj.lifetime]/1)");
+    return __builtin_start_lifetime_as<_Ty>(_Ptr);
+}
+_EXPORT_STD template <class _Ty>
+volatile _Ty* start_lifetime_as(volatile void* const _Ptr) noexcept {
+#ifdef __cpp_lib_is_implicit_lifetime // TRANSITION, toolset update
+    static_assert(is_implicit_lifetime_v<_Ty>, "T must be an implicit-lifetime type. (N5032 [obj.lifetime]/1)");
+#endif // ^^^ no workaround ^^^
+    static_assert(sizeof(_Ty) > 0, "T must be a complete type. (N5032 [obj.lifetime]/1)");
+    return __builtin_start_lifetime_as<_Ty>(_Ptr);
+}
+_EXPORT_STD template <class _Ty>
+const volatile _Ty* start_lifetime_as(const volatile void* const _Ptr) noexcept {
+#ifdef __cpp_lib_is_implicit_lifetime // TRANSITION, toolset update
+    static_assert(is_implicit_lifetime_v<_Ty>, "T must be an implicit-lifetime type. (N5032 [obj.lifetime]/1)");
+#endif // ^^^ no workaround ^^^
+    static_assert(sizeof(_Ty) > 0, "T must be a complete type. (N5032 [obj.lifetime]/1)");
+    return __builtin_start_lifetime_as<_Ty>(_Ptr);
+}
+
+_EXPORT_STD template <class _Ty>
+_Ty* start_lifetime_as_array(void* const _Ptr, const size_t _Nx) noexcept {
+    static_assert(sizeof(_Ty) > 0, "T must be a complete type. (N5032 [obj.lifetime]/5)");
+    return __builtin_start_lifetime_as_array<_Ty>(_Ptr, _Nx);
+}
+_EXPORT_STD template <class _Ty>
+const _Ty* start_lifetime_as_array(const void* const _Ptr, const size_t _Nx) noexcept {
+    static_assert(sizeof(_Ty) > 0, "T must be a complete type. (N5032 [obj.lifetime]/5)");
+    return __builtin_start_lifetime_as_array<_Ty>(_Ptr, _Nx);
+}
+_EXPORT_STD template <class _Ty>
+volatile _Ty* start_lifetime_as_array(volatile void* const _Ptr, const size_t _Nx) noexcept {
+    static_assert(sizeof(_Ty) > 0, "T must be a complete type. (N5032 [obj.lifetime]/5)");
+    return __builtin_start_lifetime_as_array<_Ty>(_Ptr, _Nx);
+}
+_EXPORT_STD template <class _Ty>
+const volatile _Ty* start_lifetime_as_array(const volatile void* const _Ptr, const size_t _Nx) noexcept {
+    static_assert(sizeof(_Ty) > 0, "T must be a complete type. (N5032 [obj.lifetime]/5)");
+    return __builtin_start_lifetime_as_array<_Ty>(_Ptr, _Nx);
+}
+#endif // ^^^ defined(__cpp_lib_start_lifetime_as) ^^^
+
+#endif // _HAS_CXX23
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _MEMORY_
diff --git a/msvc-stl/stl/inc/memory_resource b/msvc-stl/stl/inc/memory_resource
new file mode 100644
index 0000000..b7ec83b
--- /dev/null
+++ b/msvc-stl/stl/inc/memory_resource
@@ -0,0 +1,753 @@
+// memory_resource standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _MEMORY_RESOURCE_
+#define _MEMORY_RESOURCE_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <memory_resource> are available only with C++17 or later.");
+#else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#include <vector>
+#include <xbit_ops.h>
+#include <xpolymorphic_allocator.h>
+#include <xutility>
+
+#ifndef _M_CEE_PURE
+#include <mutex>
+#endif // !defined(_M_CEE_PURE)
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+namespace pmr {
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Aligned_set_default_resource(memory_resource*) noexcept;
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Unaligned_set_default_resource(memory_resource*) noexcept;
+
+    _EXPORT_STD inline memory_resource* set_default_resource(memory_resource* const _Resource) noexcept {
+#ifdef __cpp_aligned_new
+        return _Aligned_set_default_resource(_Resource);
+#else // ^^^ defined(__cpp_aligned_new) / !defined(__cpp_aligned_new) vvv
+        return _Unaligned_set_default_resource(_Resource);
+#endif // ^^^ !defined(__cpp_aligned_new) ^^^
+    }
+
+    _EXPORT_STD extern "C" _NODISCARD _CRT_SATELLITE_1 memory_resource* __cdecl null_memory_resource() noexcept;
+
+    class _Identity_equal_resource : public memory_resource {
+    protected:
+        bool do_is_equal(const memory_resource& _That) const noexcept override {
+            return this == &_That;
+        }
+    };
+
+    class _Unaligned_new_delete_resource_impl final
+        : public _Identity_equal_resource { // implementation for new_delete_resource with /Zc:alignedNew-
+        void* do_allocate(const size_t _Bytes, const size_t _Align) override {
+            if (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+                _Xbad_alloc();
+            }
+
+            return ::operator new(_Bytes);
+        }
+
+        void do_deallocate(void* const _Ptr, const size_t _Bytes, size_t) noexcept override /* strengthened */ {
+            ::operator delete(_Ptr, _Bytes);
+        }
+    };
+
+    extern "C" _CRT_SATELLITE_1 _Unaligned_new_delete_resource_impl* __cdecl _Unaligned_new_delete_resource() noexcept;
+
+#ifdef __cpp_aligned_new
+    class _Aligned_new_delete_resource_impl final
+        : public _Identity_equal_resource { // implementation for new_delete_resource with aligned new support
+        void* do_allocate(const size_t _Bytes, const size_t _Align) override {
+            if (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+                return ::operator new(_Bytes, align_val_t{_Align});
+            }
+
+            return ::operator new(_Bytes);
+        }
+
+        void do_deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align) noexcept override
+        /* strengthened */ {
+            if (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+                return ::operator delete(_Ptr, _Bytes, align_val_t{_Align});
+            }
+
+            ::operator delete(_Ptr, _Bytes);
+        }
+    };
+
+    extern "C" _CRT_SATELLITE_1 _Aligned_new_delete_resource_impl* __cdecl _Aligned_new_delete_resource() noexcept;
+
+    _EXPORT_STD _NODISCARD inline memory_resource* new_delete_resource() noexcept {
+        return _Aligned_new_delete_resource();
+    }
+
+#else // ^^^ defined(__cpp_aligned_new) / !defined(__cpp_aligned_new) vvv
+
+    _EXPORT_STD _NODISCARD inline memory_resource* new_delete_resource() noexcept {
+        return _Unaligned_new_delete_resource();
+    }
+#endif // ^^^ !defined(__cpp_aligned_new) ^^^
+
+    template <class _Tag = void>
+    struct _Double_link { // base class for intrusive doubly-linked structures
+        _Double_link* _Next;
+        _Double_link* _Prev;
+    };
+
+    template <class _Ty, class _Tag = void>
+    struct _Intrusive_list { // intrusive circular list of _Ty, which must derive from _Double_link<_Tag>
+        using _Link_type = _Double_link<_Tag>;
+
+        _STL_INTERNAL_STATIC_ASSERT(is_base_of_v<_Link_type, _Ty>);
+
+        constexpr _Intrusive_list() noexcept { // TRANSITION, VSO-517878
+            // initialize this list to the empty state
+        }
+
+        _Intrusive_list(const _Intrusive_list&)            = delete;
+        _Intrusive_list& operator=(const _Intrusive_list&) = delete;
+
+        static constexpr _Link_type* _As_link(_Ty* const _Ptr) noexcept {
+            // extract the link from the item denoted by _Ptr
+            return static_cast<_Link_type*>(_Ptr);
+        }
+
+        static constexpr _Ty* _As_item(_Link_type* const _Ptr) noexcept { // get the item whose link is denoted by _Ptr
+            return static_cast<_Ty*>(_Ptr);
+        }
+
+        constexpr void _Push_front(_Ty* const _Item) noexcept { // insert _Item at the head of this list
+            const auto _Ptr    = static_cast<_Link_type*>(_Item);
+            _Ptr->_Next        = _Head._Next;
+            _Head._Next->_Prev = _Ptr;
+            _Ptr->_Prev        = &_Head;
+            _Head._Next        = _Ptr;
+        }
+
+        static constexpr void _Remove(_Ty* const _Item) noexcept { // unlink _Item from this list
+            const auto _Ptr    = static_cast<_Link_type*>(_Item);
+            _Ptr->_Next->_Prev = _Ptr->_Prev;
+            _Ptr->_Prev->_Next = _Ptr->_Next;
+        }
+
+        constexpr void _Clear() noexcept { // make this list empty
+            _Head._Next = &_Head;
+            _Head._Prev = &_Head;
+        }
+
+        _Link_type _Head{&_Head, &_Head};
+    };
+
+    template <class _Tag = void>
+    struct _Single_link { // base class for intrusive singly-linked structures
+        _Single_link* _Next;
+    };
+
+    template <class _Ty, class _Tag = void>
+    struct _Intrusive_stack { // intrusive stack of _Ty, which must derive from _Single_link<_Tag>
+        using _Link_type = _Single_link<_Tag>;
+
+        _STL_INTERNAL_STATIC_ASSERT(is_base_of_v<_Link_type, _Ty>);
+
+        constexpr _Intrusive_stack() noexcept = default;
+        constexpr _Intrusive_stack(_Intrusive_stack&& _That) noexcept : _Head{_That._Head} {
+            _That._Head = nullptr;
+        }
+        constexpr _Intrusive_stack& operator=(_Intrusive_stack&& _That) noexcept {
+            _Head       = _That._Head;
+            _That._Head = nullptr;
+            return *this;
+        }
+
+        static constexpr _Link_type* _As_link(_Ty* const _Ptr) noexcept {
+            return static_cast<_Link_type*>(_Ptr);
+        }
+
+        static constexpr _Ty* _As_item(_Link_type* const _Ptr) noexcept {
+            return static_cast<_Ty*>(_Ptr);
+        }
+
+        constexpr bool _Empty() const noexcept {
+            return _Head == nullptr;
+        }
+
+        constexpr _Ty* _Top() const noexcept {
+            return _As_item(_Head);
+        }
+
+        constexpr void _Push(_Ty* const _Item) noexcept {
+            const auto _Ptr = _As_link(_Item);
+            _Ptr->_Next     = _Head;
+            _Head           = _Ptr;
+        }
+
+        constexpr _Ty* _Pop() noexcept { // pre: _Head != nullptr
+            const auto _Result = _Head;
+            _Head              = _Head->_Next;
+            return _As_item(_Result);
+        }
+
+        constexpr void _Remove(_Ty* const _Item) noexcept {
+            const auto _Ptr = _As_link(_Item);
+            for (_Link_type** _Pnext = &_Head; *_Pnext; _Pnext = &(*_Pnext)->_Next) {
+                if (*_Pnext == _Ptr) {
+                    *_Pnext = _Ptr->_Next;
+                    break;
+                }
+            }
+        }
+
+        _Link_type* _Head = nullptr;
+    };
+
+    _EXPORT_STD struct pool_options {
+        size_t max_blocks_per_chunk        = 0;
+        size_t largest_required_pool_block = 0;
+    };
+
+    inline void _Check_alignment(void* const _Ptr, const size_t _Align) noexcept {
+        _STL_ASSERT((reinterpret_cast<uintptr_t>(_Ptr) & (_Align - 1)) == 0,
+            "Upstream resource did not respect alignment requirement.");
+        (void) _Ptr;
+        (void) _Align;
+    }
+
+    _EXPORT_STD struct unsynchronized_pool_resource : _Identity_equal_resource {
+        unsynchronized_pool_resource() noexcept { // initialize pool with default options and default upstream
+            _Setup_options();
+        }
+        unsynchronized_pool_resource(
+            const pool_options& _Opts, memory_resource* const _Resource) noexcept // strengthened
+            : _Options(_Opts), _Pools{_Resource} { // initialize pool with options _Opts and upstream _Resource
+            _STL_ASSERT(_Resource, "Upstream memory resource must be a valid resource (N4950 [mem.res.pool.ctor]/1)");
+            _Setup_options();
+        }
+        explicit unsynchronized_pool_resource(memory_resource* const _Resource) noexcept // strengthened
+            : _Pools{_Resource} { // initialize pool with default options and upstream _Resource
+            _STL_ASSERT(_Resource, "Upstream memory resource must be a valid resource (N4950 [mem.res.pool.ctor]/1)");
+            _Setup_options();
+        }
+        explicit unsynchronized_pool_resource(const pool_options& _Opts) noexcept // strengthened
+            : _Options(_Opts) { // initialize pool with options _Opts and default upstream
+            _Setup_options();
+        }
+
+        unsynchronized_pool_resource(const unsynchronized_pool_resource&)            = delete;
+        unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&) = delete;
+
+        ~unsynchronized_pool_resource() noexcept override {
+            // destroy this pool resource, releasing all allocations back upstream
+            release();
+        }
+
+        _NODISCARD memory_resource* upstream_resource() const noexcept /* strengthened */ {
+            // retrieve this pool resource's upstream resource
+            return _Pools.get_allocator().resource();
+        }
+
+        _NODISCARD pool_options options() const noexcept /* strengthened */ {
+            // retrieve the adjusted/actual option values
+            return _Options;
+        }
+
+        void release() noexcept /* strengthened */ {
+            // release all allocations back upstream
+            for (auto& _Al : _Pools) {
+                _Al._Clear(*this);
+            }
+            _Pools.clear();
+            _Pools.shrink_to_fit();
+
+            auto _Ptr = _Chunks._Head._Next;
+            _Chunks._Clear();
+            memory_resource* const _Resource = upstream_resource();
+            while (_Ptr != &_Chunks._Head) {
+                const auto _Chunk = _Chunks._As_item(_Ptr);
+                _Ptr              = _Ptr->_Next;
+                _Resource->deallocate(_Chunk->_Base_address(), _Chunk->_Size, _Chunk->_Align);
+            }
+        }
+
+    protected:
+        void* do_allocate(size_t _Bytes, const size_t _Align) override {
+            // allocate a block from the appropriate pool, or directly from upstream if too large
+            if (_Bytes <= _Options.largest_required_pool_block) {
+                auto _Result = _Find_pool(_Bytes, _Align);
+                if (_Result.first == _Pools.end() || _Result.first->_Log_of_size != _Result.second) {
+                    _Result.first = _Pools.emplace(_Result.first, _Result.second);
+                }
+
+                return _Result.first->_Allocate(*this);
+            }
+
+            return _Allocate_oversized(_Bytes, _Align);
+        }
+
+        void do_deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align) override {
+            // deallocate a block from the appropriate pool, or directly from upstream if too large
+            if (_Bytes <= _Options.largest_required_pool_block) {
+                const auto _Result = _Find_pool(_Bytes, _Align);
+                if (_Result.first != _Pools.end() && _Result.first->_Log_of_size == _Result.second) {
+                    _Result.first->_Deallocate(*this, _Ptr);
+                }
+            } else {
+                _Deallocate_oversized(_Ptr, _Bytes, _Align);
+            }
+        }
+
+    private:
+        struct _Oversized_header : _Double_link<> {
+            // tracks an allocation that was obtained directly from the upstream resource
+            size_t _Size;
+            size_t _Align;
+
+            void* _Base_address() const { // headers are stored at the end of the allocated memory block
+                return const_cast<char*>(reinterpret_cast<const char*>(this + 1) - _Size);
+            }
+        };
+
+        static_assert(alignof(_Oversized_header) == alignof(void*));
+        static_assert(sizeof(_Oversized_header) == 4 * sizeof(void*));
+
+        static constexpr bool _Prepare_oversized(size_t& _Bytes, size_t& _Align) noexcept {
+            // adjust size and alignment to allow for an _Oversized_header
+            _Align = (_STD max) (_Align, alignof(_Oversized_header));
+
+            if (_Bytes > SIZE_MAX - sizeof(_Oversized_header) - alignof(_Oversized_header) + 1) {
+                // no room for header + alignment padding
+                return false;
+            }
+
+            // adjust _Bytes to the smallest multiple of alignof(_Oversized_header) that is >=
+            // _Bytes + sizeof(_Oversized_header), which guarantees that the end of the allocated space
+            // is properly aligned for an _Oversized_header.
+            _Bytes = (_Bytes + sizeof(_Oversized_header) + alignof(_Oversized_header) - 1)
+                   & ~(alignof(_Oversized_header) - 1);
+
+            return true;
+        }
+
+        void* _Allocate_oversized(size_t _Bytes, size_t _Align) {
+            // allocate a block directly from the upstream resource
+            if (!_Prepare_oversized(_Bytes, _Align)) { // no room for header + alignment padding
+                _Xbad_alloc();
+            }
+
+            memory_resource* const _Resource = upstream_resource();
+            void* const _Ptr                 = _Resource->allocate(_Bytes, _Align);
+            _Check_alignment(_Ptr, _Align);
+
+            _Oversized_header* const _Hdr = reinterpret_cast<_Oversized_header*>(static_cast<char*>(_Ptr) + _Bytes) - 1;
+
+            _Hdr->_Size  = _Bytes;
+            _Hdr->_Align = _Align;
+            _Chunks._Push_front(_Hdr);
+
+            return _Ptr;
+        }
+
+        void _Deallocate_oversized(void* _Ptr, size_t _Bytes, size_t _Align) noexcept {
+            // deallocate a block directly from the upstream resource
+            [[maybe_unused]] const bool _Has_room_for_padding = _Prepare_oversized(_Bytes, _Align);
+
+            // If there's no room for header + alignment padding, this memory WAS NOT allocated by this pool resource
+            _STL_ASSERT(_Has_room_for_padding, "Cannot deallocate memory not allocated by this memory pool.");
+
+            _Oversized_header* _Hdr = reinterpret_cast<_Oversized_header*>(static_cast<char*>(_Ptr) + _Bytes) - 1;
+
+            _STL_ASSERT(_Hdr->_Size == _Bytes && _Hdr->_Align == _Align,
+                "Cannot deallocate memory not allocated by this memory pool.");
+            _Chunks._Remove(_Hdr);
+            upstream_resource()->deallocate(_Ptr, _Bytes, _Align);
+        }
+
+        struct _Pool { // manager for a collection of chunks comprised of blocks of a single size
+            struct _Chunk : _Single_link<> {
+                // a memory allocation consisting of a number of fixed-size blocks to be parceled out
+                _Intrusive_stack<_Single_link<>> _Free_blocks{}; // list of free blocks
+                size_t _Free_count; // # of unallocated blocks
+                size_t _Capacity; // total # of blocks
+                char* _Base; // address of first block
+                size_t _Next_available = 0; // index of first never-allocated block
+                size_t _Id; // unique identifier; increasing order of allocation
+
+                _Chunk(_Pool& _Al, void* const _Base_, const size_t _Capacity_) noexcept
+                    : _Free_count{_Capacity_}, _Capacity{_Capacity_}, _Base{static_cast<char*>(_Base_)},
+                      _Id{_Al._All_chunks._Empty() ? 0 : _Al._All_chunks._Top()->_Id + 1} {
+                    // initialize a chunk of _Capacity blocks, all initially free
+                }
+
+                _Chunk(const _Chunk&)            = delete;
+                _Chunk& operator=(const _Chunk&) = delete;
+            };
+
+            _Chunk* _Unfull_chunk = nullptr; // largest _Chunk with free blocks
+            _Intrusive_stack<_Chunk> _All_chunks{}; // all chunks (ordered by decreasing _Id)
+            size_t _Next_capacity = _Default_next_capacity; // # of blocks to allocate in next _Chunk
+                                                            // in (1, (PTRDIFF_MAX - sizeof(_Chunk)) >> _Log_of_size]
+            size_t _Block_size; // size of allocated blocks
+            size_t _Log_of_size; // _Block_size == 1 << _Log_of_size
+            _Chunk* _Empty_chunk = nullptr; // only _Chunk with all free blocks
+
+            static constexpr size_t _Default_next_capacity = 4;
+            static_assert(_Default_next_capacity > 1);
+
+            explicit _Pool(const size_t _Log_of_size_) noexcept
+                : _Block_size{size_t{1} << _Log_of_size_}, _Log_of_size{_Log_of_size_} {
+                // initialize a pool that manages blocks of the indicated size
+            }
+
+            _Pool(_Pool&& _That) noexcept
+                : _Unfull_chunk{_STD exchange(_That._Unfull_chunk, nullptr)}, _All_chunks{_STD move(_That._All_chunks)},
+                  _Next_capacity{_STD exchange(_That._Next_capacity, _Default_next_capacity)},
+                  _Block_size{_That._Block_size}, _Log_of_size{_That._Log_of_size},
+                  _Empty_chunk{_STD exchange(_That._Empty_chunk, nullptr)} {}
+
+            _Pool& operator=(_Pool&& _That) noexcept {
+                _Unfull_chunk  = _STD exchange(_That._Unfull_chunk, nullptr);
+                _All_chunks    = _STD move(_That._All_chunks);
+                _Next_capacity = _STD exchange(_That._Next_capacity, _Default_next_capacity);
+                _Block_size    = _That._Block_size;
+                _Log_of_size   = _That._Log_of_size;
+                _Empty_chunk   = _STD exchange(_That._Empty_chunk, nullptr);
+                return *this;
+            }
+
+            void _Clear(unsynchronized_pool_resource& _Pool_resource) noexcept {
+                // release all chunks in the pool back upstream
+                _Intrusive_stack<_Chunk> _Tmp{};
+                _STD swap(_Tmp, _All_chunks);
+                memory_resource* const _Resource = _Pool_resource.upstream_resource();
+                while (!_Tmp._Empty()) {
+                    const auto _Ptr = _Tmp._Pop();
+                    _Resource->deallocate(_Ptr->_Base, _Size_for_capacity(_Ptr->_Capacity), _Block_size);
+                }
+
+                _Unfull_chunk  = nullptr;
+                _Next_capacity = _Default_next_capacity;
+                _Empty_chunk   = nullptr;
+            }
+
+            void* _Allocate(unsynchronized_pool_resource& _Pool_resource) { // allocate a block from this pool
+                for (;; _Unfull_chunk = _All_chunks._As_item(_Unfull_chunk->_Next)) {
+                    if (!_Unfull_chunk) {
+                        _Increase_capacity(_Pool_resource);
+                    } else if (!_Unfull_chunk->_Free_blocks._Empty()) {
+                        if (_Unfull_chunk == _Empty_chunk) { // this chunk is no longer empty
+                            _Empty_chunk = nullptr;
+                        }
+                        --_Unfull_chunk->_Free_count;
+                        return _Unfull_chunk->_Free_blocks._Pop();
+                    }
+
+                    if (_Unfull_chunk->_Next_available < _Unfull_chunk->_Capacity) {
+                        if (_Unfull_chunk == _Empty_chunk) { // this chunk is no longer empty
+                            _Empty_chunk = nullptr;
+                        }
+                        --_Unfull_chunk->_Free_count;
+                        char* const _Block = _Unfull_chunk->_Base + _Unfull_chunk->_Next_available * _Block_size;
+                        ++_Unfull_chunk->_Next_available;
+                        *(reinterpret_cast<_Chunk**>(_Block + _Block_size) - 1) = _Unfull_chunk;
+                        return _Block;
+                    }
+                }
+            }
+
+            void _Deallocate(unsynchronized_pool_resource& _Pool_resource, void* const _Ptr) noexcept {
+                // return a block to this pool
+                _Chunk* _Current = *(reinterpret_cast<_Chunk**>(static_cast<char*>(_Ptr) + _Block_size) - 1);
+
+                _Current->_Free_blocks._Push(::new (_Ptr) _Single_link<>);
+
+                if (_Current->_Free_count++ == 0) {
+                    // prefer to allocate from newer/larger chunks...
+                    if (!_Unfull_chunk || _Unfull_chunk->_Id < _Current->_Id) {
+                        _Unfull_chunk = _Current;
+                    }
+
+                    return;
+                }
+
+                if (_Current->_Free_count < _Current->_Capacity) {
+                    return;
+                }
+
+                if (!_Empty_chunk) {
+                    _Empty_chunk = _Current;
+                    return;
+                }
+
+                // ...and release older/smaller chunks to keep the list lengths short.
+                if (_Empty_chunk->_Id < _Current->_Id) {
+                    _STD swap(_Current, _Empty_chunk);
+                }
+
+                _All_chunks._Remove(_Current);
+                _Pool_resource.upstream_resource()->deallocate(
+                    _Current->_Base, _Size_for_capacity(_Current->_Capacity), _Block_size);
+            }
+
+            size_t _Size_for_capacity(const size_t _Capacity) const noexcept {
+                // return the size of a chunk that holds _Capacity blocks
+                return (_Capacity << _Log_of_size) + sizeof(_Chunk);
+            }
+
+            void _Increase_capacity(unsynchronized_pool_resource& _Pool_resource) {
+                // this pool has no free blocks; get a new chunk from upstream
+                if (_Next_capacity > _Pool_resource._Options.max_blocks_per_chunk) {
+                    // This is a fresh pool, _Next_capacity hasn't yet been bounded by max_blocks_per_chunk:
+                    _Next_capacity = _Pool_resource._Options.max_blocks_per_chunk;
+                }
+                const size_t _Size               = _Size_for_capacity(_Next_capacity);
+                memory_resource* const _Resource = _Pool_resource.upstream_resource();
+                void* const _Ptr                 = _Resource->allocate(_Size, _Block_size);
+                _Check_alignment(_Ptr, _Block_size);
+
+                void* const _Tmp = static_cast<char*>(_Ptr) + _Size - sizeof(_Chunk);
+                _Unfull_chunk    = ::new (_Tmp) _Chunk{*this, _Ptr, _Next_capacity};
+                _Empty_chunk     = _Unfull_chunk;
+                _All_chunks._Push(_Unfull_chunk);
+
+                // scale _Next_capacity by 2, saturating so that _Size_for_capacity(_Next_capacity) cannot overflow
+                _Next_capacity =
+                    (_STD min) (_Next_capacity << 1, (_STD min) ((PTRDIFF_MAX - sizeof(_Chunk)) >> _Log_of_size,
+                                                         _Pool_resource._Options.max_blocks_per_chunk));
+            }
+        };
+
+        void _Setup_options() noexcept { // configure pool options
+            constexpr auto _Max_blocks_per_chunk_limit = static_cast<size_t>(PTRDIFF_MAX);
+            constexpr auto _Largest_required_pool_block_limit =
+                static_cast<size_t>((PTRDIFF_MAX >> 4) + 1); // somewhat arbitrary power of 2
+            static_assert(_Is_pow_2(_Largest_required_pool_block_limit));
+
+            if (_Options.max_blocks_per_chunk - 1 >= _Max_blocks_per_chunk_limit) {
+                _Options.max_blocks_per_chunk = _Max_blocks_per_chunk_limit;
+            }
+
+            if (_Options.largest_required_pool_block - 1 < sizeof(void*)) {
+                _Options.largest_required_pool_block = sizeof(void*);
+            } else if (_Options.largest_required_pool_block - 1 >= _Largest_required_pool_block_limit) {
+                _Options.largest_required_pool_block = _Largest_required_pool_block_limit;
+            } else {
+                _Options.largest_required_pool_block = static_cast<size_t>(1)
+                                                    << _Ceiling_of_log_2(_Options.largest_required_pool_block);
+            }
+        }
+
+        pair<pmr::vector<_Pool>::iterator, unsigned char> _Find_pool(
+            const size_t _Bytes, const size_t _Align) noexcept {
+            // find the pool from which to allocate a block with size _Bytes and alignment _Align
+            const size_t _Size      = (_STD max) (_Bytes + sizeof(void*), _Align);
+            const auto _Log_of_size = static_cast<unsigned char>(_Ceiling_of_log_2(_Size));
+            return {_STD lower_bound(_Pools.begin(), _Pools.end(), _Log_of_size,
+                        [](const _Pool& _Al, const unsigned char _Log) static { return _Al._Log_of_size < _Log; }),
+                _Log_of_size};
+        }
+
+        pool_options _Options{}; // parameters that control the behavior of this pool resource
+        _Intrusive_list<_Oversized_header> _Chunks{}; // list of oversized allocations obtained directly from upstream
+        pmr::vector<_Pool> _Pools{}; // pools in order of increasing block size
+    };
+
+#ifndef _M_CEE_PURE
+    _EXPORT_STD class synchronized_pool_resource : public unsynchronized_pool_resource {
+    public:
+        using unsynchronized_pool_resource::unsynchronized_pool_resource;
+
+        void release() noexcept /* strengthened */ {
+            lock_guard<mutex> _Guard{_Mtx};
+            unsynchronized_pool_resource::release();
+        }
+
+    protected:
+        void* do_allocate(const size_t _Bytes, const size_t _Align) override {
+            lock_guard<mutex> _Guard{_Mtx};
+            return unsynchronized_pool_resource::do_allocate(_Bytes, _Align);
+        }
+
+        void do_deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align) override {
+            lock_guard<mutex> _Guard{_Mtx};
+            unsynchronized_pool_resource::do_deallocate(_Ptr, _Bytes, _Align);
+        }
+
+    private:
+        mutable mutex _Mtx;
+    };
+#endif // !defined(_M_CEE_PURE)
+
+    _EXPORT_STD class monotonic_buffer_resource : public _Identity_equal_resource {
+    public:
+        explicit monotonic_buffer_resource(memory_resource* const _Upstream) noexcept // strengthened
+            : _Resource{_Upstream} {} // initialize this resource with upstream
+
+        monotonic_buffer_resource(const size_t _Initial_size, memory_resource* const _Upstream) noexcept // strengthened
+            : _Next_buffer_size(_Round(_Initial_size)), _Resource{_Upstream} {
+            // initialize this resource with upstream and initial allocation size
+        }
+
+        monotonic_buffer_resource(void* const _Buffer, const size_t _Buffer_size,
+            memory_resource* const _Upstream) noexcept // strengthened
+            : _Current_buffer(_Buffer), _Space_available(_Buffer_size),
+              _Next_buffer_size(_Buffer_size ? _Scale(_Buffer_size) : _Min_allocation), _Resource{_Upstream} {
+            // initialize this resource with upstream and initial buffer
+        }
+
+        monotonic_buffer_resource() = default;
+
+        explicit monotonic_buffer_resource(const size_t _Initial_size) noexcept // strengthened
+            : _Next_buffer_size(_Round(_Initial_size)) {} // initialize this resource with initial allocation size
+
+        monotonic_buffer_resource(void* const _Buffer, const size_t _Buffer_size) noexcept // strengthened
+            : _Current_buffer(_Buffer), _Space_available(_Buffer_size),
+              _Next_buffer_size(_Buffer_size ? _Scale(_Buffer_size) : _Min_allocation) {
+            // initialize this resource with initial buffer
+        }
+
+        ~monotonic_buffer_resource() noexcept override {
+            release();
+        }
+
+        monotonic_buffer_resource(const monotonic_buffer_resource&)            = delete;
+        monotonic_buffer_resource& operator=(const monotonic_buffer_resource&) = delete;
+
+        void release() noexcept /* strengthened */ {
+            if (_Chunks._Empty()) {
+                // nothing to release; potentially continues to use an initial block provided at construction
+                return;
+            }
+
+            _Current_buffer  = nullptr;
+            _Space_available = 0;
+
+            // unscale _Next_buffer_size so the next allocation will be the same size as the most recent allocation
+            // (keep synchronized with monotonic_buffer_resource::_Scale)
+            const size_t _Unscaled = (_Next_buffer_size / 3 * 2 + alignof(_Header) - 1) & _Max_allocation;
+            _Next_buffer_size      = (_STD max) (_Unscaled, _Min_allocation);
+
+            _Intrusive_stack<_Header> _Tmp{};
+            _STD swap(_Tmp, _Chunks);
+            while (!_Tmp._Empty()) {
+                const auto _Ptr = _Tmp._Pop();
+                _Resource->deallocate(_Ptr->_Base_address(), _Ptr->_Size, _Ptr->_Align);
+            }
+        }
+
+        _NODISCARD memory_resource* upstream_resource() const noexcept /* strengthened */ {
+            // retrieve the upstream resource
+            return _Resource;
+        }
+
+    protected:
+        void* do_allocate(const size_t _Bytes, const size_t _Align) override {
+            // allocate from the current buffer or a new larger buffer from upstream
+            if (!_STD align(_Align, _Bytes, _Current_buffer, _Space_available)) {
+                _Increase_capacity(_Bytes, _Align);
+            }
+
+            void* const _Result = _Current_buffer;
+            _Current_buffer     = static_cast<char*>(_Current_buffer) + _Bytes;
+            _Space_available -= _Bytes;
+            return _Result;
+        }
+
+        void do_deallocate(void*, size_t, size_t) override {} // nothing to do
+
+    private:
+        struct _Header : _Single_link<> { // track the size and alignment of an allocation from upstream
+            size_t _Size;
+            size_t _Align;
+
+            _Header(const size_t _Size_, const size_t _Align_) : _Size{_Size_}, _Align{_Align_} {}
+
+            void* _Base_address() const { // header is stored at the end of the allocated memory block
+                return const_cast<char*>(reinterpret_cast<const char*>(this + 1) - _Size);
+            }
+        };
+
+        static constexpr size_t _Min_allocation = 2 * sizeof(_Header);
+        static constexpr size_t _Max_allocation = 0 - alignof(_Header);
+
+        static constexpr size_t _Round(const size_t _Size) noexcept {
+            // return the smallest multiple of alignof(_Header) greater than _Size,
+            // clamped to the range [_Min_allocation, _Max_allocation]
+            if (_Size < _Min_allocation) {
+                return _Min_allocation;
+            }
+
+            if (_Size >= _Max_allocation) {
+                return _Max_allocation;
+            }
+
+            // Since _Max_allocation == -alignof(_Header), _Size < _Max_allocation implies that
+            // (_Size + alignof(_Header) - 1) does not overflow.
+            return (_Size + alignof(_Header) - 1) & _Max_allocation;
+        }
+
+        static constexpr size_t _Scale(const size_t _Size) noexcept {
+            // scale _Size by 1.5, rounding up to a multiple of alignof(_Header), saturating to _Max_allocation
+            // (keep synchronized with monotonic_buffer_resource::release)
+#pragma warning(push)
+#pragma warning(disable : 26450) // TRANSITION, VSO-1828677
+            constexpr auto _Max_size = (_Max_allocation - alignof(_Header) + 1) / 3 * 2;
+#pragma warning(pop)
+            if (_Size >= _Max_size) {
+                return _Max_allocation;
+            }
+
+            return (_Size + (_Size + 1) / 2 + alignof(_Header) - 1) & _Max_allocation;
+        }
+
+        void _Increase_capacity(const size_t _Bytes, const size_t _Align) { // obtain a new buffer from upstream
+            if (_Bytes > _Max_allocation - sizeof(_Header)) {
+                _Xbad_alloc();
+            }
+
+            size_t _New_size = _Next_buffer_size;
+            if (_New_size < _Bytes + sizeof(_Header)) {
+                _New_size = (_Bytes + sizeof(_Header) + alignof(_Header) - 1) & _Max_allocation;
+            }
+
+            const size_t _New_align = (_STD max) (alignof(_Header), _Align);
+
+            void* _New_buffer = _Resource->allocate(_New_size, _New_align);
+            _Check_alignment(_New_buffer, _New_align);
+
+            _Current_buffer  = _New_buffer;
+            _Space_available = _New_size - sizeof(_Header);
+            _New_buffer      = static_cast<char*>(_New_buffer) + _Space_available;
+            _Chunks._Push(::new (_New_buffer) _Header{_New_size, _New_align});
+
+            _Next_buffer_size = _Scale(_New_size);
+        }
+
+        void* _Current_buffer    = nullptr; // current memory block to parcel out to callers
+        size_t _Space_available  = 0; // space remaining in current block
+        size_t _Next_buffer_size = _Min_allocation; // size of next block to allocate from upstream
+        _Intrusive_stack<_Header> _Chunks{}; // list of memory blocks allocated from upstream
+        memory_resource* _Resource = _STD pmr::get_default_resource(); // upstream resource from which to allocate
+    };
+} // namespace pmr
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX17 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _MEMORY_RESOURCE_
diff --git a/msvc-stl/stl/inc/mutex b/msvc-stl/stl/inc/mutex
new file mode 100644
index 0000000..1319f3c
--- /dev/null
+++ b/msvc-stl/stl/inc/mutex
@@ -0,0 +1,800 @@
+// mutex standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _MUTEX_
+#define _MUTEX_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <mutex> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#include <__msvc_chrono.hpp>
+#include <cstdlib>
+#include <system_error>
+#include <thread>
+#include <utility>
+#include <xcall_once.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD class condition_variable;
+_EXPORT_STD class condition_variable_any;
+
+class _Mutex_base { // base class for all mutex types
+public:
+#ifdef _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR
+    _Mutex_base(int _Flags = 0) noexcept {
+        _Mtx_init_in_situ(_Mymtx(), _Flags | _Mtx_try);
+    }
+#else // ^^^ defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) / !defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) vvv
+    constexpr _Mutex_base(int _Flags = 0) noexcept {
+        _Mtx_storage._Critical_section = {};
+        _Mtx_storage._Thread_id        = -1;
+        _Mtx_storage._Type             = _Flags | _Mtx_try;
+        _Mtx_storage._Count            = 0;
+    }
+#endif // ^^^ !defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) ^^^
+
+    _Mutex_base(const _Mutex_base&)            = delete;
+    _Mutex_base& operator=(const _Mutex_base&) = delete;
+
+    void lock() {
+        if (_Mtx_lock(_Mymtx()) != _Thrd_result::_Success) {
+            // undefined behavior, only occurs for plain mutexes (N4950 [thread.mutex.requirements.mutex.general]/6)
+            _STD _Throw_Cpp_error(_RESOURCE_DEADLOCK_WOULD_OCCUR);
+        }
+
+        if (!_Verify_ownership_levels()) {
+            // only occurs for recursive mutexes (N4950 [thread.mutex.recursive]/3)
+            // POSIX specifies EAGAIN in the corresponding situation:
+            // https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutex_lock.html
+            _STD _Throw_Cpp_error(_RESOURCE_UNAVAILABLE_TRY_AGAIN);
+        }
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock() noexcept /* strengthened */ {
+        // false may be from undefined behavior for plain mutexes (N4950 [thread.mutex.requirements.mutex.general]/6)
+        return _Mtx_trylock(_Mymtx()) == _Thrd_result::_Success;
+    }
+
+    void unlock() noexcept /* strengthened */ {
+        _Mtx_unlock(_Mymtx());
+    }
+
+    // native_handle_type and native_handle() have intentionally been removed. See GH-3820.
+
+protected:
+    _NODISCARD_TRY_CHANGE_STATE bool _Verify_ownership_levels() noexcept {
+        if (_Mtx_storage._Count == INT_MAX) {
+            // only occurs for recursive mutexes (N4950 [thread.mutex.recursive]/3)
+            --_Mtx_storage._Count;
+            return false;
+        }
+
+        return true;
+    }
+
+private:
+    friend condition_variable;
+    friend condition_variable_any;
+
+    _Mtx_internal_imp_t _Mtx_storage{};
+
+    _Mtx_t _Mymtx() noexcept {
+        return &_Mtx_storage;
+    }
+};
+
+_EXPORT_STD class mutex : public _Mutex_base { // class for mutual exclusion
+public:
+    mutex() noexcept = default;
+
+    mutex(const mutex&)            = delete;
+    mutex& operator=(const mutex&) = delete;
+};
+
+_EXPORT_STD class recursive_mutex : public _Mutex_base { // class for recursive mutual exclusion
+public:
+    recursive_mutex() noexcept // strengthened
+        : _Mutex_base(_Mtx_recursive) {}
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock() noexcept {
+        return _Mutex_base::try_lock() && _Verify_ownership_levels();
+    }
+
+    recursive_mutex(const recursive_mutex&)            = delete;
+    recursive_mutex& operator=(const recursive_mutex&) = delete;
+};
+
+_EXPORT_STD struct adopt_lock_t { // indicates adopt lock
+    explicit adopt_lock_t() = default;
+};
+
+_EXPORT_STD struct defer_lock_t { // indicates defer lock
+    explicit defer_lock_t() = default;
+};
+
+_EXPORT_STD struct try_to_lock_t { // indicates try to lock
+    explicit try_to_lock_t() = default;
+};
+
+_EXPORT_STD _INLINE_VAR constexpr adopt_lock_t adopt_lock{};
+_EXPORT_STD _INLINE_VAR constexpr defer_lock_t defer_lock{};
+_EXPORT_STD _INLINE_VAR constexpr try_to_lock_t try_to_lock{};
+
+_EXPORT_STD template <class _Mutex>
+class unique_lock { // whizzy class with destructor that unlocks mutex
+public:
+    using mutex_type = _Mutex;
+
+    unique_lock() noexcept = default;
+
+    _NODISCARD_LOCK explicit unique_lock(_Mutex& _Mtx)
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(false) { // construct and lock
+        _Pmtx->lock();
+        _Owns = true;
+    }
+
+    _NODISCARD_LOCK unique_lock(_Mutex& _Mtx, adopt_lock_t) noexcept // strengthened
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(true) {} // construct and assume already locked
+
+    unique_lock(_Mutex& _Mtx, defer_lock_t) noexcept
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(false) {} // construct but don't lock
+
+    _NODISCARD_LOCK unique_lock(_Mutex& _Mtx, try_to_lock_t)
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock()) {} // construct and try to lock
+
+    template <class _Rep, class _Period>
+    _NODISCARD_LOCK unique_lock(_Mutex& _Mtx, const chrono::duration<_Rep, _Period>& _Rel_time)
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock_for(_Rel_time)) {} // construct and lock with timeout
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_LOCK unique_lock(_Mutex& _Mtx, const chrono::time_point<_Clock, _Duration>& _Abs_time)
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Pmtx->try_lock_until(_Abs_time)) {
+        // construct and lock with timeout
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+    }
+
+    _NODISCARD_LOCK unique_lock(unique_lock&& _Other) noexcept : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns) {
+        _Other._Pmtx = nullptr;
+        _Other._Owns = false;
+    }
+
+    unique_lock& operator=(unique_lock&& _Other) noexcept {
+        unique_lock{_STD move(_Other)}.swap(*this);
+        return *this;
+    }
+
+    ~unique_lock() noexcept {
+        if (_Owns) {
+            _Pmtx->unlock();
+        }
+    }
+
+    unique_lock(const unique_lock&)            = delete;
+    unique_lock& operator=(const unique_lock&) = delete;
+
+    void lock() { // lock the mutex
+        _Validate();
+        _Pmtx->lock();
+        _Owns = true;
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock() {
+        _Validate();
+        _Owns = _Pmtx->try_lock();
+        return _Owns;
+    }
+
+    template <class _Rep, class _Period>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
+        _Validate();
+        _Owns = _Pmtx->try_lock_for(_Rel_time);
+        return _Owns;
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        _Validate();
+        _Owns = _Pmtx->try_lock_until(_Abs_time);
+        return _Owns;
+    }
+
+    void unlock() {
+        if (!_Pmtx || !_Owns) {
+            _Throw_system_error(errc::operation_not_permitted);
+        }
+
+        _Pmtx->unlock();
+        _Owns = false;
+    }
+
+    void swap(unique_lock& _Other) noexcept {
+        _STD swap(_Pmtx, _Other._Pmtx);
+        _STD swap(_Owns, _Other._Owns);
+    }
+
+    _Mutex* release() noexcept {
+        _Mutex* _Res = _Pmtx;
+        _Pmtx        = nullptr;
+        _Owns        = false;
+        return _Res;
+    }
+
+    _NODISCARD bool owns_lock() const noexcept {
+        return _Owns;
+    }
+
+    explicit operator bool() const noexcept {
+        return _Owns;
+    }
+
+    _NODISCARD _Mutex* mutex() const noexcept {
+        return _Pmtx;
+    }
+
+private:
+    _Mutex* _Pmtx = nullptr;
+    bool _Owns    = false;
+
+    void _Validate() const { // check if the mutex can be locked
+        if (!_Pmtx) {
+            _Throw_system_error(errc::operation_not_permitted);
+        }
+
+        if (_Owns) {
+            _Throw_system_error(errc::resource_deadlock_would_occur);
+        }
+    }
+};
+
+_EXPORT_STD template <class _Mutex>
+void swap(unique_lock<_Mutex>& _Left, unique_lock<_Mutex>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+template <size_t... _Indices, class... _LockN>
+void _Lock_from_locks(const int _Target, index_sequence<_Indices...>, _LockN&... _LkN) { // lock _LkN[_Target]
+    int _Ignored[] = {((static_cast<int>(_Indices) == _Target ? (void) _LkN.lock() : void()), 0)...};
+    (void) _Ignored;
+}
+
+template <size_t... _Indices, class... _LockN>
+bool _Try_lock_from_locks(
+    const int _Target, index_sequence<_Indices...>, _LockN&... _LkN) { // try to lock _LkN[_Target]
+    bool _Result{};
+    int _Ignored[] = {((static_cast<int>(_Indices) == _Target ? (void) (_Result = _LkN.try_lock()) : void()), 0)...};
+    (void) _Ignored;
+    return _Result;
+}
+
+template <size_t... _Indices, class... _LockN>
+void _Unlock_locks(const int _First, const int _Last, index_sequence<_Indices...>, _LockN&... _LkN) noexcept
+/* terminates */ {
+    // unlock locks in _LkN[_First, _Last)
+    int _Ignored[] = {
+        ((_First <= static_cast<int>(_Indices) && static_cast<int>(_Indices) < _Last ? (void) _LkN.unlock() : void()),
+            0)...};
+    (void) _Ignored;
+}
+
+template <class _Fn>
+struct _NODISCARD _Unlock_call_guard {
+    static_assert(
+        is_trivially_copyable_v<_Fn>, "This scope guard is only used for trivially copyable function objects.");
+
+    explicit _Unlock_call_guard(const _Fn& _Fx) noexcept : _Func(_Fx) {}
+
+    ~_Unlock_call_guard() noexcept {
+        if (_Valid) {
+            _Func();
+        }
+    }
+
+    _Unlock_call_guard(const _Unlock_call_guard&)            = delete;
+    _Unlock_call_guard& operator=(const _Unlock_call_guard&) = delete;
+
+    _Fn _Func;
+    bool _Valid = true;
+};
+
+template <class _Lock>
+struct _NODISCARD _Unlock_one_guard {
+    explicit _Unlock_one_guard(_Lock& _Lk) noexcept : _Lk_ptr(_STD addressof(_Lk)) {}
+
+    ~_Unlock_one_guard() noexcept {
+        if (_Lk_ptr) {
+            _Lk_ptr->unlock();
+        }
+    }
+
+    _Unlock_one_guard(const _Unlock_one_guard&)            = delete;
+    _Unlock_one_guard& operator=(const _Unlock_one_guard&) = delete;
+
+    _Lock* _Lk_ptr;
+};
+
+template <class... _LockN>
+int _Try_lock_range(const int _First, const int _Last, _LockN&... _LkN) {
+    using _Indices = index_sequence_for<_LockN...>;
+    int _Next      = _First;
+
+    auto _Unlocker = [_First, &_Next, &_LkN...]() noexcept { _STD _Unlock_locks(_First, _Next, _Indices{}, _LkN...); };
+    _Unlock_call_guard<decltype(_Unlocker)> _Guard{_Unlocker};
+
+    for (; _Next != _Last; ++_Next) {
+        if (!_STD _Try_lock_from_locks(_Next, _Indices{}, _LkN...)) { // try_lock failed, backout
+            return _Next;
+        }
+    }
+
+    _Guard._Valid = false;
+    return -1;
+}
+
+_EXPORT_STD template <class _Lock0, class _Lock1, class... _LockN>
+_NODISCARD_TRY_CHANGE_STATE int try_lock(_Lock0& _Lk0, _Lock1& _Lk1, _LockN&... _LkN) { // try to lock multiple locks
+    if constexpr (sizeof...(_LockN) == 0) {
+        // try to lock 2 locks, special case for better codegen and reduced metaprogramming for common case
+        if (!_Lk0.try_lock()) {
+            return 0;
+        }
+
+        _Unlock_one_guard<_Lock0> _Guard{_Lk0};
+        if (!_Lk1.try_lock()) {
+            return 1;
+        }
+
+        _Guard._Lk_ptr = nullptr;
+        return -1;
+    } else {
+        // try to lock 3 or more locks
+        return _Try_lock_range(0, sizeof...(_LockN) + 2, _Lk0, _Lk1, _LkN...);
+    }
+}
+
+template <class... _LockN>
+int _Lock_attempt(const int _Hard_lock, _LockN&... _LkN) {
+    // attempt to lock 3 or more locks, starting by locking _LkN[_Hard_lock] and trying to lock the rest
+    using _Indices = index_sequence_for<_LockN...>;
+    _Lock_from_locks(_Hard_lock, _Indices{}, _LkN...);
+    int _Failed        = -1;
+    int _Backout_start = _Hard_lock; // that is, unlock _Hard_lock
+
+    {
+        auto _Unlocker = [&_Backout_start, _Hard_lock, &_LkN...]() noexcept {
+            _STD _Unlock_locks(_Backout_start, _Hard_lock + 1, _Indices{}, _LkN...);
+        };
+        _Unlock_call_guard<decltype(_Unlocker)> _Guard{_Unlocker};
+
+        _Failed = _STD _Try_lock_range(0, _Hard_lock, _LkN...);
+        if (_Failed == -1) {
+            _Backout_start = 0; // that is, unlock [0, _Hard_lock] if the next throws
+            _Failed        = _STD _Try_lock_range(_Hard_lock + 1, sizeof...(_LockN), _LkN...);
+            if (_Failed == -1) { // we got all the locks
+                _Guard._Valid = false;
+                return -1;
+            }
+        }
+        // we didn't get all the locks, backout with the scope guard
+    }
+
+    _STD this_thread::yield();
+    return _Failed;
+}
+
+template <class _Lock0, class _Lock1>
+bool _Lock_attempt_small(_Lock0& _Lk0, _Lock1& _Lk1) {
+    // attempt to lock 2 locks, by first locking _Lk0, and then trying to lock _Lk1 returns whether to try again
+    _Lk0.lock();
+    {
+        _Unlock_one_guard<_Lock0> _Guard{_Lk0};
+        if (_Lk1.try_lock()) {
+            _Guard._Lk_ptr = nullptr;
+            return false;
+        }
+    }
+
+    _STD this_thread::yield();
+    return true;
+}
+
+_EXPORT_STD template <class _Lock0, class _Lock1, class... _LockN>
+void lock(_Lock0& _Lk0, _Lock1& _Lk1, _LockN&... _LkN) { // lock multiple locks, without deadlock
+    if constexpr (sizeof...(_LockN) == 0) {
+        // lock 2 locks, without deadlock, special case for better codegen and reduced metaprogramming for common case
+        while (_Lock_attempt_small(_Lk0, _Lk1) && _Lock_attempt_small(_Lk1, _Lk0)) { // keep trying
+        }
+    } else {
+        // lock 3 or more locks, without deadlock
+        int _Hard_lock = 0;
+        while (_Hard_lock != -1) {
+            _Hard_lock = _Lock_attempt(_Hard_lock, _Lk0, _Lk1, _LkN...);
+        }
+    }
+}
+
+_EXPORT_STD template <class _Mutex>
+class _NODISCARD_LOCK lock_guard { // class with destructor that unlocks a mutex
+public:
+    using mutex_type = _Mutex;
+
+    explicit lock_guard(_Mutex& _Mtx) : _MyMutex(_Mtx) { // construct and lock
+        _MyMutex.lock();
+    }
+
+    lock_guard(_Mutex& _Mtx, adopt_lock_t) noexcept // strengthened
+        : _MyMutex(_Mtx) {} // construct but don't lock
+
+    ~lock_guard() noexcept {
+        _MyMutex.unlock();
+    }
+
+    lock_guard(const lock_guard&)            = delete;
+    lock_guard& operator=(const lock_guard&) = delete;
+
+private:
+    _Mutex& _MyMutex;
+};
+
+#if _HAS_CXX17
+_EXPORT_STD template <class... _Mutexes>
+class _NODISCARD_LOCK scoped_lock { // class with destructor that unlocks mutexes
+public:
+    explicit scoped_lock(_Mutexes&... _Mtxes) : _MyMutexes(_Mtxes...) { // construct and lock
+        _STD lock(_Mtxes...);
+    }
+
+    explicit scoped_lock(adopt_lock_t, _Mutexes&... _Mtxes) noexcept // strengthened
+        : _MyMutexes(_Mtxes...) {} // construct but don't lock
+
+    ~scoped_lock() noexcept {
+        _STD apply([](_Mutexes&... _Mtxes) static { (..., (void) _Mtxes.unlock()); }, _MyMutexes);
+    }
+
+    scoped_lock(const scoped_lock&)            = delete;
+    scoped_lock& operator=(const scoped_lock&) = delete;
+
+private:
+    tuple<_Mutexes&...> _MyMutexes;
+};
+
+template <class _Mutex>
+class _NODISCARD_LOCK scoped_lock<_Mutex> {
+public:
+    using mutex_type = _Mutex;
+
+    explicit scoped_lock(_Mutex& _Mtx) : _MyMutex(_Mtx) { // construct and lock
+        _MyMutex.lock();
+    }
+
+    explicit scoped_lock(adopt_lock_t, _Mutex& _Mtx) noexcept // strengthened
+        : _MyMutex(_Mtx) {} // construct but don't lock
+
+    ~scoped_lock() noexcept {
+        _MyMutex.unlock();
+    }
+
+    scoped_lock(const scoped_lock&)            = delete;
+    scoped_lock& operator=(const scoped_lock&) = delete;
+
+private:
+    _Mutex& _MyMutex;
+};
+
+template <>
+class scoped_lock<> {
+public:
+    explicit scoped_lock() = default;
+    explicit scoped_lock(adopt_lock_t) noexcept /* strengthened */ {}
+
+    scoped_lock(const scoped_lock&)            = delete;
+    scoped_lock& operator=(const scoped_lock&) = delete;
+};
+#endif // _HAS_CXX17
+
+_EXPORT_STD enum class cv_status { // names for wait returns
+    no_timeout,
+    timeout
+};
+
+_EXPORT_STD class condition_variable { // class for waiting for conditions
+public:
+#ifdef _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR
+    condition_variable() noexcept /* strengthened */ {
+        _Cnd_init_in_situ(_Mycnd());
+    }
+#else // ^^^ defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) / !defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) vvv
+    condition_variable() noexcept /* strengthened */ = default;
+#endif // ^^^ !defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) ^^^
+
+    ~condition_variable() noexcept = default;
+
+    condition_variable(const condition_variable&)            = delete;
+    condition_variable& operator=(const condition_variable&) = delete;
+
+    void notify_one() noexcept { // wake up one waiter
+        _Cnd_signal(_Mycnd());
+    }
+
+    void notify_all() noexcept { // wake up all waiters
+        _Cnd_broadcast(_Mycnd());
+    }
+
+    void wait(unique_lock<mutex>& _Lck) noexcept /* strengthened */ { // wait for signal
+        // Nothing to do to comply with LWG-2135 because std::mutex lock/unlock are nothrow
+        _Cnd_wait(_Mycnd(), _Lck.mutex()->_Mymtx());
+    }
+
+    template <class _Predicate>
+    void wait(unique_lock<mutex>& _Lck, _Predicate _Pred) { // wait for signal and test predicate
+        while (!_Pred()) {
+            wait(_Lck);
+        }
+    }
+
+    template <class _Rep, class _Period>
+    cv_status wait_for(unique_lock<mutex>& _Lck, const chrono::duration<_Rep, _Period> _Rel_time) {
+        // wait for duration
+        if (_Rel_time <= chrono::duration<_Rep, _Period>::zero()) {
+            // we don't unlock-and-relock _Lck for this case because it's not observable
+            return cv_status::timeout;
+        }
+        return wait_until(_Lck, _To_absolute_time(_Rel_time));
+    }
+
+    template <class _Rep, class _Period, class _Predicate>
+    bool wait_for(unique_lock<mutex>& _Lck, const chrono::duration<_Rep, _Period> _Rel_time, _Predicate _Pred) {
+        // wait for signal with timeout and check predicate
+        return wait_until(_Lck, _To_absolute_time(_Rel_time), _STD _Pass_fn(_Pred));
+    }
+
+    template <class _Clock, class _Duration>
+    cv_status wait_until(unique_lock<mutex>& _Lck, const chrono::time_point<_Clock, _Duration> _Abs_time) {
+        // wait until time point
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(
+            _Lck.owns_lock(), "wait_until's caller must own the lock argument (N4958 [thread.condition.condvar]/17)");
+        _STL_VERIFY(_Mtx_current_owns(_Lck.mutex()->_Mymtx()),
+            "wait_until's calling thread must hold the lock argument's mutex (N4958 [thread.condition.condvar]/17)");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        for (;;) {
+            const auto _Now = _Clock::now();
+            if (_Abs_time <= _Now) {
+                // we don't unlock-and-relock _Lck for this case because it's not observable
+                return cv_status::timeout;
+            }
+
+            const unsigned long _Rel_ms_count = _Clamped_rel_time_ms_count(_Abs_time - _Now)._Count;
+
+            const _Thrd_result _Res = _Cnd_timedwait_for_unchecked(_Mycnd(), _Lck.mutex()->_Mymtx(), _Rel_ms_count);
+            if (_Res == _Thrd_result::_Success) {
+                return cv_status::no_timeout;
+            }
+        }
+    }
+
+    template <class _Clock, class _Duration, class _Predicate>
+    bool wait_until(unique_lock<mutex>& _Lck, const chrono::time_point<_Clock, _Duration> _Abs_time, _Predicate _Pred) {
+        // wait for signal with timeout and check predicate
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        while (!_Pred()) {
+            if (wait_until(_Lck, _Abs_time) == cv_status::timeout) {
+                return _Pred();
+            }
+        }
+
+        return true;
+    }
+
+    // native_handle_type and native_handle() have intentionally been removed. See GH-3820.
+
+    void _Register(unique_lock<mutex>& _Lck, int* _Ready) noexcept { // register this object for release at thread exit
+        _Cnd_register_at_thread_exit(_Mycnd(), _Lck.release()->_Mymtx(), _Ready);
+    }
+
+    void _Unregister(mutex& _Mtx) noexcept { // unregister this object for release at thread exit
+        _Cnd_unregister_at_thread_exit(_Mtx._Mymtx());
+    }
+
+private:
+    _Cnd_internal_imp_t _Cnd_storage{};
+
+    _Cnd_t _Mycnd() noexcept {
+        return &_Cnd_storage;
+    }
+};
+
+struct _UInt_is_zero {
+    const unsigned int& _UInt;
+
+    _NODISCARD bool operator()() const noexcept {
+        return _UInt == 0;
+    }
+};
+
+_EXPORT_STD class timed_mutex { // class for timed mutual exclusion
+public:
+    timed_mutex() = default;
+
+    timed_mutex(const timed_mutex&)            = delete;
+    timed_mutex& operator=(const timed_mutex&) = delete;
+
+    void lock() { // lock the mutex
+        unique_lock<mutex> _Lock(_My_mutex);
+        while (_My_locked != 0) {
+            _My_cond.wait(_Lock);
+        }
+
+        _My_locked = UINT_MAX;
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock() noexcept /* strengthened */ { // try to lock the mutex
+        lock_guard<mutex> _Lock(_My_mutex);
+        if (_My_locked != 0) {
+            return false;
+        } else {
+            _My_locked = UINT_MAX;
+            return true;
+        }
+    }
+
+    void unlock() { // unlock the mutex
+        {
+            // The lock here is necessary
+            lock_guard<mutex> _Lock(_My_mutex);
+            _My_locked = 0;
+        }
+        _My_cond.notify_one();
+    }
+
+    template <class _Rep, class _Period>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_for(
+        const chrono::duration<_Rep, _Period>& _Rel_time) { // try to lock for duration
+        return try_lock_until(_To_absolute_time(_Rel_time));
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        // try to lock the mutex with timeout
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        unique_lock<mutex> _Lock(_My_mutex);
+        if (!_My_cond.wait_until(_Lock, _Abs_time, _UInt_is_zero{_My_locked})) {
+            return false;
+        }
+
+        _My_locked = UINT_MAX;
+        return true;
+    }
+
+private:
+    mutex _My_mutex;
+    condition_variable _My_cond;
+    unsigned int _My_locked = 0;
+};
+
+_EXPORT_STD class recursive_timed_mutex { // class for recursive timed mutual exclusion
+public:
+    recursive_timed_mutex() = default;
+
+    recursive_timed_mutex(const recursive_timed_mutex&)            = delete;
+    recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
+
+    void lock() { // lock the mutex
+        const thread::id _Tid = this_thread::get_id();
+
+        unique_lock<mutex> _Lock(_My_mutex);
+
+        if (_Tid == _My_owner) {
+            if (_My_locked < UINT_MAX) {
+                ++_My_locked;
+            } else {
+                // POSIX specifies EAGAIN in the corresponding situation:
+                // https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_mutex_lock.html
+                _STD _Throw_system_error(errc::resource_unavailable_try_again);
+            }
+        } else {
+            while (_My_locked != 0) {
+                _My_cond.wait(_Lock);
+            }
+
+            _My_locked = 1;
+            _My_owner  = _Tid;
+        }
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock() noexcept { // try to lock the mutex
+        const thread::id _Tid = this_thread::get_id();
+
+        lock_guard<mutex> _Lock(_My_mutex);
+
+        if (_Tid == _My_owner) {
+            if (_My_locked < UINT_MAX) {
+                ++_My_locked;
+            } else {
+                return false;
+            }
+        } else {
+            if (_My_locked != 0) {
+                return false;
+            } else {
+                _My_locked = 1;
+                _My_owner  = _Tid;
+            }
+        }
+        return true;
+    }
+
+    void unlock() { // unlock the mutex
+        bool _Do_notify = false;
+
+        {
+            lock_guard<mutex> _Lock(_My_mutex);
+            --_My_locked;
+            if (_My_locked == 0) {
+                _Do_notify = true;
+                _My_owner  = thread::id();
+            }
+        }
+
+        if (_Do_notify) {
+            _My_cond.notify_one();
+        }
+    }
+
+    template <class _Rep, class _Period>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_for(
+        const chrono::duration<_Rep, _Period>& _Rel_time) { // try to lock for duration
+        return try_lock_until(_To_absolute_time(_Rel_time));
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        // try to lock the mutex with timeout
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        const thread::id _Tid = this_thread::get_id();
+
+        unique_lock<mutex> _Lock(_My_mutex);
+
+        if (_Tid == _My_owner) {
+            if (_My_locked < UINT_MAX) {
+                ++_My_locked;
+            } else {
+                return false;
+            }
+        } else {
+            if (!_My_cond.wait_until(_Lock, _Abs_time, _UInt_is_zero{_My_locked})) {
+                return false;
+            }
+
+            _My_locked = 1;
+            _My_owner  = _Tid;
+        }
+        return true;
+    }
+
+private:
+    mutex _My_mutex;
+    condition_variable _My_cond;
+    unsigned int _My_locked = 0;
+    thread::id _My_owner;
+};
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _MUTEX_
diff --git a/msvc-stl/stl/inc/new b/msvc-stl/stl/inc/new
new file mode 100644
index 0000000..02401e9
--- /dev/null
+++ b/msvc-stl/stl/inc/new
@@ -0,0 +1,61 @@
+// new standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _NEW_
+#define _NEW_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <exception>
+#include <vcruntime_new.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#if _HAS_CXX20
+_EXPORT_STD struct destroying_delete_t {
+    explicit destroying_delete_t() = default;
+};
+_EXPORT_STD inline constexpr destroying_delete_t destroying_delete{};
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty>
+_NODISCARD_LAUNDER constexpr _Ty* launder(_Ty* _Ptr) noexcept {
+    static_assert(!is_function_v<_Ty> && !is_void_v<_Ty>,
+        "N4950 [ptr.launder]/1: Mandates: !is_function_v<T> && !is_void_v<T> is true.");
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-10456452
+    return __builtin_launder(_Ptr);
+#else // ^^^ no workaround / workaround vvv
+    return ::__builtin_launder(_Ptr);
+#endif // ^^^ workaround ^^^
+}
+
+#if defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM64)
+_EXPORT_STD inline constexpr size_t hardware_constructive_interference_size = 64;
+_EXPORT_STD inline constexpr size_t hardware_destructive_interference_size  = 64;
+#else // ^^^ known architecture / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+
+#endif // _HAS_CXX17
+
+_EXPORT_STD using new_handler = void(__CLRCALL_PURE_OR_CDECL*)();
+
+_EXPORT_STD extern "C++" _CRTIMP2 new_handler __cdecl set_new_handler(_In_opt_ new_handler) noexcept;
+_EXPORT_STD extern "C++" _NODISCARD _CRTIMP2 new_handler __cdecl get_new_handler() noexcept;
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _NEW_
diff --git a/msvc-stl/stl/inc/numbers b/msvc-stl/stl/inc/numbers
new file mode 100644
index 0000000..cfe61dc
--- /dev/null
+++ b/msvc-stl/stl/inc/numbers
@@ -0,0 +1,107 @@
+// numbers standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _NUMBERS_
+#define _NUMBERS_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <numbers> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+#include <concepts>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+namespace numbers {
+    template <class _Ty>
+    struct _Invalid {
+        static_assert(false, "A program that instantiates a primary template of a mathematical constant "
+                             "variable template is ill-formed. (N4950 [math.constants]/3)");
+    };
+
+    // specializations allowed by N5014 [math.constants]/2 for all of these variable templates:
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty e_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty log2e_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty log10e_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty pi_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty inv_pi_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty inv_sqrtpi_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty ln2_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty ln10_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty sqrt2_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty sqrt3_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty inv_sqrt3_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty egamma_v = _Invalid<_Ty>{};
+    _EXPORT_STD template <class _Ty>
+    constexpr _Ty phi_v = _Invalid<_Ty>{};
+
+    template <floating_point _Floating>
+    constexpr _Floating e_v<_Floating> = static_cast<_Floating>(2.718281828459045);
+    template <floating_point _Floating>
+    constexpr _Floating log2e_v<_Floating> = static_cast<_Floating>(1.4426950408889634);
+    template <floating_point _Floating>
+    constexpr _Floating log10e_v<_Floating> = static_cast<_Floating>(0.4342944819032518);
+    template <floating_point _Floating>
+    constexpr _Floating pi_v<_Floating> = static_cast<_Floating>(3.141592653589793);
+    template <floating_point _Floating>
+    constexpr _Floating inv_pi_v<_Floating> = static_cast<_Floating>(0.3183098861837907);
+    template <floating_point _Floating>
+    constexpr _Floating inv_sqrtpi_v<_Floating> = static_cast<_Floating>(0.5641895835477563);
+    template <floating_point _Floating>
+    constexpr _Floating ln2_v<_Floating> = static_cast<_Floating>(0.6931471805599453);
+    template <floating_point _Floating>
+    constexpr _Floating ln10_v<_Floating> = static_cast<_Floating>(2.302585092994046);
+    template <floating_point _Floating>
+    constexpr _Floating sqrt2_v<_Floating> = static_cast<_Floating>(1.4142135623730951);
+    template <floating_point _Floating>
+    constexpr _Floating sqrt3_v<_Floating> = static_cast<_Floating>(1.7320508075688772);
+    template <floating_point _Floating>
+    constexpr _Floating inv_sqrt3_v<_Floating> = static_cast<_Floating>(0.5773502691896257);
+    template <floating_point _Floating>
+    constexpr _Floating egamma_v<_Floating> = static_cast<_Floating>(0.5772156649015329);
+    template <floating_point _Floating>
+    constexpr _Floating phi_v<_Floating> = static_cast<_Floating>(1.618033988749895);
+
+    _EXPORT_STD inline constexpr double e          = e_v<double>;
+    _EXPORT_STD inline constexpr double log2e      = log2e_v<double>;
+    _EXPORT_STD inline constexpr double log10e     = log10e_v<double>;
+    _EXPORT_STD inline constexpr double pi         = pi_v<double>;
+    _EXPORT_STD inline constexpr double inv_pi     = inv_pi_v<double>;
+    _EXPORT_STD inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
+    _EXPORT_STD inline constexpr double ln2        = ln2_v<double>;
+    _EXPORT_STD inline constexpr double ln10       = ln10_v<double>;
+    _EXPORT_STD inline constexpr double sqrt2      = sqrt2_v<double>;
+    _EXPORT_STD inline constexpr double sqrt3      = sqrt3_v<double>;
+    _EXPORT_STD inline constexpr double inv_sqrt3  = inv_sqrt3_v<double>;
+    _EXPORT_STD inline constexpr double egamma     = egamma_v<double>;
+    _EXPORT_STD inline constexpr double phi        = phi_v<double>;
+} // namespace numbers
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _NUMBERS_
diff --git a/msvc-stl/stl/inc/numeric b/msvc-stl/stl/inc/numeric
new file mode 100644
index 0000000..917aefe
--- /dev/null
+++ b/msvc-stl/stl/inc/numeric
@@ -0,0 +1,829 @@
+// numeric standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _NUMERIC_
+#define _NUMERIC_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xutility>
+
+#if _HAS_CXX17
+#include <__msvc_bit_utils.hpp>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+_STD_BEGIN
+_EXPORT_STD template <class _InIt, class _Ty, class _Fn>
+_NODISCARD _CONSTEXPR20 _Ty accumulate(const _InIt _First, const _InIt _Last, _Ty _Val, _Fn _Reduce_op) {
+    // return noncommutative and nonassociative reduction of _Val and all in [_First, _Last), using _Reduce_op
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    for (; _UFirst != _ULast; ++_UFirst) {
+#if _HAS_CXX20
+        _Val = _Reduce_op(_STD move(_Val), *_UFirst);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        _Val = _Reduce_op(_Val, *_UFirst);
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+    return _Val;
+}
+
+_EXPORT_STD template <class _InIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _Ty accumulate(const _InIt _First, const _InIt _Last, _Ty _Val) {
+    // return noncommutative and nonassociative reduction of _Val and all in [_First, _Last)
+    return _STD accumulate(_First, _Last, _Val, plus<>{});
+}
+
+#if _HAS_CXX17
+#if _STD_VECTORIZE_WITH_FLOAT_CONTROL
+template <class _InIt, class _Ty, class _BinOp>
+constexpr bool _Plus_on_arithmetic_ranges_reduction_v =
+    conjunction_v<is_arithmetic<_Ty>, is_arithmetic<remove_pointer_t<_InIt>>, is_same<plus<>, _BinOp>>;
+
+#pragma float_control(precise, off, push)
+template <class _InIt, class _Ty>
+_Ty _Reduce_plus_arithmetic_ranges(_InIt _First, const _InIt _Last, _Ty _Val) {
+    // return reduction, plus arithmetic on contiguous ranges case
+#pragma loop(ivdep)
+    for (; _First != _Last; ++_First) {
+        _Val += *_First;
+    }
+
+    return _Val;
+}
+#pragma float_control(pop)
+#endif // ^^^ _STD_VECTORIZE_WITH_FLOAT_CONTROL ^^^
+
+_EXPORT_STD template <class _InIt, class _Ty, class _BinOp>
+_NODISCARD _CONSTEXPR20 _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op) {
+    // return commutative and associative reduction of _Val and [_First, _Last), using _Reduce_op
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+#if _STD_VECTORIZE_WITH_FLOAT_CONTROL
+    if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_Unwrapped_t<const _InIt&>, _Ty, _BinOp>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _STD _Reduce_plus_arithmetic_ranges(_UFirst, _ULast, _Val);
+        }
+    }
+#endif // ^^^ _STD_VECTORIZE_WITH_FLOAT_CONTROL ^^^
+
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Val = _Reduce_op(_STD move(_Val), *_UFirst); // Requirement missing from N4950
+    }
+
+    return _Val;
+}
+
+_EXPORT_STD template <class _InIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val) {
+    // return commutative and associative reduction of _Val and [_First, _Last)
+    return _STD reduce(_First, _Last, _STD move(_Val), plus{});
+}
+
+_EXPORT_STD template <class _InIt>
+_NODISCARD _CONSTEXPR20 _Iter_value_t<_InIt> reduce(const _InIt _First, const _InIt _Last) {
+    // return commutative and associative reduction of
+    // iterator_traits<_InIt>::value_type{} and [_First, _Last)
+    return _STD reduce(_First, _Last, _Iter_value_t<_InIt>{}, plus{});
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Ty reduce(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Ty reduce(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, _Ty _Val) noexcept /* terminates */ {
+    // return commutative and associative reduction of _Val and [_First, _Last)
+    return _STD reduce(_STD forward<_ExPo>(_Exec), _First, _Last, _STD move(_Val), plus{});
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Iter_value_t<_FwdIt> reduce(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last) noexcept
+/* terminates */ {
+    // return commutative and associative reduction of
+    // iterator_traits<_FwdIt>::value_type{} and [_First, _Last)
+    return _STD reduce(_STD forward<_ExPo>(_Exec), _First, _Last, _Iter_value_t<_FwdIt>{}, plus{});
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
+_NODISCARD _CONSTEXPR20 _Ty inner_product(
+    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) {
+    // return noncommutative and nonassociative transform-reduction of sequences, using
+    // _Reduce_op and _Transform_op
+    _STD _Adl_verify_range(_First1, _Last1);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1));
+    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) {
+#if _HAS_CXX20
+        _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_UFirst1, *_UFirst2)); // Requirement missing from N4950
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        _Val = _Reduce_op(_Val, _Transform_op(*_UFirst1, *_UFirst2)); // Requirement missing from N4950
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+
+    return _Val;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Ty>
+_NODISCARD _CONSTEXPR20 _Ty inner_product(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Ty _Val) {
+    // return noncommutative and nonassociative transform-reduction of sequences
+    return _STD inner_product(_First1, _Last1, _First2, _STD move(_Val), plus<>{}, multiplies<>{});
+}
+
+#if _HAS_CXX17
+#if _STD_VECTORIZE_WITH_FLOAT_CONTROL
+template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
+constexpr bool _Default_ops_transform_reduce_v =
+    conjunction_v<is_arithmetic<_Ty>, is_arithmetic<remove_pointer_t<_InIt1>>, is_arithmetic<remove_pointer_t<_InIt2>>,
+        is_same<plus<>, _BinOp1>, is_same<multiplies<>, _BinOp2>>;
+
+#pragma float_control(precise, off, push)
+template <class _InIt1, class _InIt2, class _Ty>
+_Ty _Transform_reduce_arithmetic_defaults(_InIt1 _First1, const _InIt1 _Last1, _InIt2 _First2, _Ty _Val) {
+    // return transform-reduction, default ops on contiguous arithmetic ranges case
+#pragma loop(ivdep)
+    for (; _First1 != _Last1; ++_First1, (void) ++_First2) {
+        _Val += *_First1 * *_First2;
+    }
+
+    return _Val;
+}
+#pragma float_control(pop)
+#endif // ^^^ _STD_VECTORIZE_WITH_FLOAT_CONTROL ^^^
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
+_NODISCARD _CONSTEXPR20 _Ty transform_reduce(
+    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) {
+    // return commutative and associative transform-reduction of sequences, using
+    // _Reduce_op and _Transform_op
+    _STD _Adl_verify_range(_First1, _Last1);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1));
+#if _STD_VECTORIZE_WITH_FLOAT_CONTROL
+    if constexpr (_Default_ops_transform_reduce_v<_Unwrapped_t<const _InIt1&>, _Unwrapped_t<const _InIt2&>, _Ty,
+                      _BinOp1, _BinOp2>) {
+#if _HAS_CXX20
+        // TRANSITION, DevCom-878972
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _STD _Transform_reduce_arithmetic_defaults(_UFirst1, _ULast1, _UFirst2, _STD move(_Val));
+        }
+    }
+#endif // ^^^ _STD_VECTORIZE_WITH_FLOAT_CONTROL ^^^
+
+    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) {
+        _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_UFirst1, *_UFirst2)); // Requirement missing from N4950
+    }
+    return _Val;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Ty>
+_NODISCARD _CONSTEXPR20 _Ty transform_reduce(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val) {
+    // return commutative and associative transform-reduction of sequences
+    return _STD transform_reduce(_First1, _Last1, _First2, _STD move(_Val), plus{}, multiplies{});
+}
+
+_EXPORT_STD template <class _InIt, class _Ty, class _BinOp, class _UnaryOp>
+_NODISCARD _CONSTEXPR20 _Ty transform_reduce(
+    const _InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
+    // return commutative and associative reduction of transformed sequence, using
+    // _Reduce_op and _Transform_op
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_UFirst)); // Requirement missing from N4950
+    }
+
+    return _Val;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Ty transform_reduce(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val,
+    _BinOp1 _Reduce_op, _BinOp2 _Transform_op) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Ty transform_reduce(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val) noexcept
+/* terminates */ {
+    // return commutative and associative transform-reduction of sequences
+    return _STD transform_reduce(
+        _STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _STD move(_Val), plus{}, multiplies{});
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Ty transform_reduce(_ExPo&& _Exec, _FwdIt _First1, _FwdIt _Last1, _Ty _Val, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _BinOp>
+_CONSTEXPR20 _OutIt partial_sum(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op) {
+    // compute partial noncommutative and nonassociative reductions into _Dest, using _Reduce_op
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+
+    if (_UFirst != _ULast) {
+        _Iter_value_t<_InIt> _Val(*_UFirst);
+        for (;;) {
+            *_UDest = _Val;
+            ++_UDest;
+            ++_UFirst;
+            if (_UFirst == _ULast) {
+                break;
+            }
+#if _HAS_CXX20
+            _Val = _Reduce_op(_STD move(_Val), *_UFirst);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            _Val = _Reduce_op(_Val, *_UFirst);
+#endif // ^^^ !_HAS_CXX20 ^^^
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest) {
+    // compute partial noncommutative and nonassociative reductions into _Dest
+    return _STD partial_sum(_First, _Last, _Dest, plus<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty, class _BinOp>
+_CONSTEXPR20 _OutIt exclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Ty _Val, _BinOp _Reduce_op) {
+    // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of predecessors and _Val
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    if (_UFirst != _ULast) {
+        for (;;) {
+            _Ty _Tmp = _Reduce_op(_Val, *_UFirst); // temp to enable _First == _Dest, also requirement missing
+            *_UDest  = _Val;
+            ++_UDest;
+            ++_UFirst;
+            if (_UFirst == _ULast) {
+                break;
+            }
+
+            _Val = _STD move(_Tmp); // Requirement missing from N4950
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty>
+_CONSTEXPR20 _OutIt exclusive_scan(const _InIt _First, const _InIt _Last, const _OutIt _Dest, _Ty _Val) {
+    // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of predecessors and _Val
+    return _STD exclusive_scan(_First, _Last, _Dest, _STD move(_Val), plus{});
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 exclusive_scan(_ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
+    _BinOp _Reduce_op) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 exclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest, _Ty _Val) noexcept
+/* terminates */ {
+    // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of predecessors and _Val
+    return _STD exclusive_scan(_STD forward<_ExPo>(_Exec), _First, _Last, _Dest, _STD move(_Val), plus{});
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty, class _BinOp>
+_CONSTEXPR20 _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _Ty _Val) {
+    // compute partial noncommutative and associative reductions including _Val into _Dest, using _Reduce_op
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Val    = _Reduce_op(_STD move(_Val), *_UFirst); // Requirement missing from N4950
+        *_UDest = _Val;
+        ++_UDest;
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _BinOp>
+_CONSTEXPR20 _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op) {
+    // compute partial noncommutative and associative reductions into _Dest, using _Reduce_op
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    if (_UFirst != _ULast) {
+        _Iter_value_t<_InIt> _Val(*_UFirst); // Requirement missing from N4950
+        for (;;) {
+            *_UDest = _Val;
+            ++_UDest;
+            ++_UFirst;
+            if (_UFirst == _ULast) {
+                break;
+            }
+
+            _Val = _Reduce_op(_STD move(_Val), *_UFirst); // Requirement missing from N4950
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, const _OutIt _Dest) {
+    // compute partial noncommutative and associative reductions into _Dest
+    return _STD inclusive_scan(_First, _Last, _Dest, plus{});
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 inclusive_scan(
+    _ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty _Val) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 inclusive_scan(
+    _ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 inclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest) noexcept
+/* terminates */ {
+    // compute partial noncommutative and associative reductions into _Dest
+    return _STD inclusive_scan(_STD forward<_ExPo>(_Exec), _First, _Last, _Dest, plus{});
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty, class _BinOp, class _UnaryOp>
+_CONSTEXPR20 _OutIt transform_exclusive_scan(
+    const _InIt _First, const _InIt _Last, _OutIt _Dest, _Ty _Val, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
+    // set each value in [_Dest, _Dest + (_Last - _First)) to the associative reduction of transformed predecessors
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    if (_UFirst != _ULast) {
+        for (;;) {
+            _Ty _Tmp = _Reduce_op(_Val, _Transform_op(*_UFirst)); // temp to enable _First == _Dest
+            *_UDest  = _Val;
+            ++_UDest;
+            ++_UFirst;
+            if (_UFirst == _ULast) {
+                break;
+            }
+
+            _Val = _STD move(_Tmp); // Requirement missing from N4950
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _OutIt, class _Ty, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_OutIt transform_exclusive_scan(_ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _OutIt _Dest, _Ty _Val, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op) noexcept; // terminates
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _Ty, class _BinOp, class _UnaryOp>
+_CONSTEXPR20 _OutIt transform_inclusive_scan(
+    const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _UnaryOp _Transform_op, _Ty _Val) {
+    // compute partial noncommutative and associative transformed reductions including _Val into _Dest
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Val    = _Reduce_op(_STD move(_Val), _Transform_op(*_UFirst)); // Requirement missing from N4950
+        *_UDest = _Val;
+        ++_UDest;
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _BinOp, class _UnaryOp>
+_CONSTEXPR20 _OutIt transform_inclusive_scan(
+    const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
+    // compute partial noncommutative and associative transformed reductions into _Dest
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    if (_UFirst != _ULast) {
+        auto _Val = _Transform_op(*_UFirst); // Requirement missing from N4950, also type to use unclear
+        for (;;) {
+            *_UDest = _Val;
+            ++_UDest;
+            ++_UFirst;
+            if (_UFirst == _ULast) {
+                break;
+            }
+
+            _Val = _Reduce_op(_STD move(_Val), _Transform_op(*_UFirst)); // Requirement missing from N4950
+        }
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 transform_inclusive_scan(_ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op, _Ty _Val) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp,
+    _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 transform_inclusive_scan(_ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
+    _UnaryOp _Transform_op) noexcept; // terminates
+#endif // _HAS_CXX17
+
+template <class _TyDest, class _TySrc, class _BinOp>
+void _Adjacent_difference_no_overlap(
+    _TyDest* const _RESTRICT _Dest, _TySrc* const _RESTRICT _Src, const ptrdiff_t _Count, _BinOp _Func) {
+    _Dest[0] = _Src[0];
+    for (ptrdiff_t _Ix = 1; _Ix != _Count; ++_Ix) {
+#if _HAS_CXX20
+        _TySrc _Tmp = _Src[_Ix - 1];
+        _Dest[_Ix]  = _Func(_Src[_Ix], _STD move(_Tmp));
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        _Dest[_Ix] = _Func(_Src[_Ix], _Src[_Ix - 1]);
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt, class _BinOp>
+_CONSTEXPR20 _OutIt adjacent_difference(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Func) {
+    // compute adjacent differences into _Dest
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    if (_UFirst != _ULast) {
+        if constexpr (_Iterators_are_contiguous<decltype(_UFirst), decltype(_UDest)> && !_Iterator_is_volatile<_InIt>
+                      && is_trivially_copyable_v<_Iter_value_t<_InIt>>) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif
+            {
+                const auto _Dest_dist = static_cast<_Iter_diff_t<decltype(_UDest)>>(_ULast - _UFirst);
+                _STD _Contiguous_iter_verify(_UDest, _Dest_dist);
+
+                // Go with pointers and without loop-carried dependency to enable vectorization
+                const auto _First_ptr = _STD _To_address(_UFirst);
+                const auto _Last_ptr  = _STD _To_address(_ULast);
+                const auto _Dest_ptr  = _STD _To_address(_UDest);
+
+                // Need to perform aliasing analysis.
+                // The vectorizer is generally able to do that on its own, and would guard the vectorized code with
+                // that, but when we eliminate the loop-carried dependency we change the semantics of the unvectorized
+                // code too. So we need to perform this check manually, and after that we can tell the compiler that
+                // there's no aliasing, to avoid it checking for that again.
+                if (reinterpret_cast<uintptr_t>(_Dest_ptr + static_cast<ptrdiff_t>(_Dest_dist))
+                        <= reinterpret_cast<uintptr_t>(_First_ptr)
+                    || reinterpret_cast<uintptr_t>(_Last_ptr) <= reinterpret_cast<uintptr_t>(_Dest_ptr)) {
+                    _STD _Adjacent_difference_no_overlap(
+                        _Dest_ptr, _First_ptr, static_cast<ptrdiff_t>(_Dest_dist), _STD _Pass_fn(_Func));
+                    _STD _Seek_wrapped(_Dest, _UDest + _Dest_dist);
+                    return _Dest;
+                }
+            }
+        }
+
+        _Iter_value_t<_InIt> _Val(*_UFirst);
+        *_UDest = _Val;
+        while (++_UFirst != _ULast) { // compute another difference
+            _Iter_value_t<_InIt> _Tmp(*_UFirst);
+#if _HAS_CXX20
+            *++_UDest = _Func(_Tmp, _STD move(_Val));
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            *++_UDest = _Func(_Tmp, _Val);
+#endif // ^^^ !_HAS_CXX20 ^^^
+            _Val = _STD move(_Tmp);
+        }
+
+        ++_UDest;
+    }
+
+    _STD _Seek_wrapped(_Dest, _UDest);
+    return _Dest;
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt adjacent_difference(const _InIt _First, const _InIt _Last, const _OutIt _Dest) {
+    // compute adjacent differences into _Dest
+    return _STD adjacent_difference(_First, _Last, _Dest, minus<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 adjacent_difference(
+    _ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Diff_op) noexcept; // terminates
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 adjacent_difference(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest) noexcept
+/* terminates */ {
+    // compute adjacent differences into _Dest
+    return _STD adjacent_difference(_STD forward<_ExPo>(_Exec), _First, _Last, _Dest, minus{});
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_CONSTEXPR20 void iota(_FwdIt _First, _FwdIt _Last, _Ty _Val) {
+    // compute increasing sequence into [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+
+    if constexpr (_Iterator_is_contiguous<decltype(_UFirst)> && is_integral_v<_Ty> && sizeof(_Ty) >= 4) {
+        // TRANSITION, DevCom-10593477: help the compiler vectorize
+        const auto _Ptr = _To_address(_UFirst);
+        (void) _STD _To_address(_ULast);
+        const auto _Size = static_cast<size_t>(_ULast - _UFirst);
+
+        if (_STD _In_range<_Ty>(_Size)) {
+            const auto _Size_typed = static_cast<_Ty>(_Size);
+            for (_Ty _Ix = 0; _Ix != _Size_typed; ++_Ix) {
+                _Ptr[_Ix] = _Val + _Ix;
+            }
+
+            return;
+        }
+    }
+
+    for (; _UFirst != _ULast; ++_UFirst, (void) ++_Val) {
+        *_UFirst = _Val;
+    }
+}
+
+#if _HAS_CXX23
+namespace ranges {
+    _EXPORT_STD template <class _Out, class _Ty>
+    using iota_result = out_value_result<_Out, _Ty>;
+
+    class _Iota_fn {
+    public:
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Ty>
+            requires indirectly_writable<_It, const _Ty&>
+        static constexpr iota_result<_It, _Ty> operator()(_It _First, _Se _Last, _Ty _Val) {
+            _STD _Adl_verify_range(_First, _Last);
+            _STD _Seek_wrapped(_First, _Iota_impl(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                                           _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _Val));
+            return {_STD move(_First), _STD move(_Val)};
+        }
+
+        template <weakly_incrementable _Ty, output_range<const _Ty&> _Rng>
+        static constexpr iota_result<borrowed_iterator_t<_Rng>, _Ty> operator()(_Rng&& _Range, _Ty _Val) {
+            auto _First = _RANGES begin(_Range);
+            _STD _Seek_wrapped(
+                _First, _Iota_impl(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range), _Val));
+            return {_STD move(_First), _STD move(_Val)};
+        }
+
+    private:
+        template <class _It, class _Se, class _Ty>
+        _NODISCARD static constexpr _It _Iota_impl(_It _First, const _Se _Last, _Ty& _Val) {
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(weakly_incrementable<_Ty>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_writable<_It, const _Ty&>);
+
+            if constexpr (contiguous_iterator<_It> && sized_sentinel_for<_Se, _It> && is_integral_v<_Ty>
+                          && sizeof(_Ty) >= 4) {
+                // TRANSITION, DevCom-10593477: help the compiler vectorize
+                const auto _Ptr  = _To_address(_First);
+                const auto _Dist = _STD _Contiguous_iter_distance(_First, _Last);
+                const auto _Size = static_cast<size_t>(_Dist);
+
+                if (_STD _In_range<_Ty>(_Size)) {
+                    const auto _Size_typed = static_cast<_Ty>(_Size);
+                    for (_Ty _Ix = 0; _Ix != _Size_typed; ++_Ix) {
+                        const _Ty _Const_val = _Val + _Ix;
+                        _Ptr[_Ix]            = _Const_val;
+                    }
+
+                    _Val += _Size_typed;
+                    return _First + _Dist;
+                }
+            }
+
+            const _Ty& _Const_val = _Val;
+            for (; _First != _Last; ++_First, (void) ++_Val) {
+                *_First = _Const_val;
+            }
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Iota_fn iota;
+} // namespace ranges
+#endif // _HAS_CXX23
+
+#if _HAS_CXX17
+template <class _Integral>
+_NODISCARD constexpr auto _Abs_u(const _Integral _Val) noexcept {
+    // computes absolute value of _Val (converting to an unsigned integer type if necessary to avoid overflow
+    // representing the negation of the minimum value)
+    static_assert(is_integral_v<_Integral>);
+
+    if constexpr (is_signed_v<_Integral>) {
+        using _Unsigned = make_unsigned_t<_Integral>;
+        if (_Val < 0) {
+            // note static_cast to _Unsigned such that _Integral == short returns unsigned short rather than int
+            return static_cast<_Unsigned>(_Unsigned{0} - static_cast<_Unsigned>(_Val));
+        }
+
+        return static_cast<_Unsigned>(_Val);
+    } else {
+        return _Val;
+    }
+}
+
+_EXPORT_STD template <class _Mt, class _Nt>
+_NODISCARD constexpr common_type_t<_Mt, _Nt> gcd(const _Mt _Mx, const _Nt _Nx) noexcept /* strengthened */ {
+    // calculate greatest common divisor
+    static_assert(_Is_nonbool_integral<_Mt> && _Is_nonbool_integral<_Nt>, "GCD requires nonbool integral types");
+
+    using _Common          = common_type_t<_Mt, _Nt>;
+    using _Common_unsigned = make_unsigned_t<_Common>;
+
+    if constexpr (is_signed_v<_Common>) {
+#ifndef _DEBUG
+        if (_STD _Is_constant_evaluated())
+#endif // ^^^ !defined(_DEBUG) ^^^
+        {
+            constexpr auto _Min_common = _STD _Min_limit<_Common>();
+            _STL_VERIFY(_Mx != _Min_common && _Nx != _Min_common,
+                "Preconditions: |m| and |n| are representable as a value of common_type_t<M, N>. "
+                "(N4981 [numeric.ops.gcd]/2, N4981 [numeric.ops.lcm]/2)");
+        }
+    }
+
+    return _Select_countr_zero_impl<_Common_unsigned>([=](auto _Countr_zero_impl) {
+        _Common_unsigned _Mx_magnitude = _Abs_u(_Mx);
+        _Common_unsigned _Nx_magnitude = _Abs_u(_Nx);
+        if (_Mx_magnitude == 0U) {
+            return static_cast<_Common>(_Nx_magnitude);
+        }
+
+        if (_Nx_magnitude == 0U) {
+            return static_cast<_Common>(_Mx_magnitude);
+        }
+
+        const auto _Mx_trailing_zeroes  = static_cast<unsigned long>(_Countr_zero_impl(_Mx_magnitude));
+        auto _Nx_trailing_zeroes        = static_cast<unsigned long>(_Countr_zero_impl(_Nx_magnitude));
+        const auto _Common_factors_of_2 = (_STD min) (_Mx_trailing_zeroes, _Nx_trailing_zeroes);
+        _Mx_magnitude >>= _Mx_trailing_zeroes;
+        for (;;) {
+            _Nx_magnitude >>= _Nx_trailing_zeroes;
+            if (_Mx_magnitude > _Nx_magnitude) {
+                _Common_unsigned _Temp = _Mx_magnitude;
+                _Mx_magnitude          = _Nx_magnitude;
+                _Nx_magnitude          = _Temp;
+            }
+
+            _Nx_magnitude -= _Mx_magnitude;
+            if (_Nx_magnitude == 0U) {
+                return static_cast<_Common>(_Mx_magnitude << _Common_factors_of_2);
+            }
+
+            _Nx_trailing_zeroes = static_cast<unsigned long>(_Countr_zero_impl(_Nx_magnitude));
+        }
+    });
+}
+
+_EXPORT_STD template <class _Mt, class _Nt>
+_NODISCARD constexpr common_type_t<_Mt, _Nt> lcm(const _Mt _Mx, const _Nt _Nx) noexcept /* strengthened */ {
+    // calculate least common multiple
+    static_assert(_Is_nonbool_integral<_Mt> && _Is_nonbool_integral<_Nt>, "LCM requires nonbool integral types");
+    using _Common                        = common_type_t<_Mt, _Nt>;
+    using _Common_unsigned               = make_unsigned_t<_Common>;
+    const _Common_unsigned _Mx_magnitude = _Abs_u(_Mx);
+    const _Common_unsigned _Nx_magnitude = _Abs_u(_Nx);
+    if (_Mx_magnitude == 0 || _Nx_magnitude == 0) {
+        return 0;
+    }
+
+#ifndef _DEBUG
+    if (!_STD _Is_constant_evaluated()) {
+        return static_cast<_Common>((_Mx_magnitude / _STD gcd(_Mx_magnitude, _Nx_magnitude)) * _Nx_magnitude);
+    }
+#endif // ^^^ !defined(_DEBUG) ^^^
+
+    _Common_unsigned _Result = 0;
+    _Common_unsigned _Tmp    = static_cast<_Common_unsigned>(_Mx_magnitude / _STD gcd(_Mx_magnitude, _Nx_magnitude));
+    const bool _Overflow     = _Mul_overflow(_Tmp, _Nx_magnitude, _Result) || !_STD _In_range<_Common>(_Result);
+
+    _STL_VERIFY(!_Overflow, "Preconditions: The least common multiple of |m| and |n| is representable as a value of "
+                            "type common_type_t<M, N>. (N4981 [numeric.ops.lcm]/2)");
+
+    return static_cast<_Common>(_Result);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+    requires is_arithmetic_v<_Ty> && (!is_same_v<remove_cv_t<_Ty>, bool>)
+_NODISCARD constexpr _Ty midpoint(const _Ty _Val1, const _Ty _Val2) noexcept {
+    if constexpr (is_floating_point_v<_Ty>) {
+        if (_STD is_constant_evaluated()) {
+            if (_Is_nan(_Val1)) {
+                return _Val1;
+            }
+
+            if (_Is_nan(_Val2)) {
+                return _Val2;
+            }
+        } else {
+            if (_Is_nan(_Val1) || _Is_nan(_Val2)) {
+                // raise FE_INVALID if at least one of _Val1 and _Val2 is signaling NaN
+                return _Val1 + _Val2;
+            }
+        }
+
+        constexpr _Ty _High_limit = _Floating_type_traits<remove_cv_t<_Ty>>::_Maximum_value / 2;
+        const auto _Val1_a        = _Float_abs(_Val1);
+        const auto _Val2_a        = _Float_abs(_Val2);
+        if (_Val1_a <= _High_limit && _Val2_a <= _High_limit) {
+            // _Val1 and _Val2 are small enough that _Val1 + _Val2 won't overflow
+
+            // For the division to be inexact, the result of the addition must produce a value with the smallest
+            // effective exponent and the low order bit in the mantissa set. For an addition to be inexact in this
+            // condition, the difference between the inputs would have to be smaller than one ULP, but that is
+            // impossible.
+            //
+            // For example, with doubles, the sum/difference of the inputs would have to be finer than 2^-1074, for it
+            // to round (via whatever mode) to the value with a least significant 1 bit and p-1022, but the inputs can't
+            // be finer than 2^-1074 and addition/subtraction can't create smaller steps.
+
+            return (_Val1 + _Val2) / 2;
+        }
+
+        // Here at least one of {_Val1, _Val2} has large magnitude.
+        // Therefore, if one of the values is too small to divide by 2 exactly, the small magnitude is much less than
+        // one ULP of the result, so we can add it directly without the potentially inexact division by 2.
+
+        // In the default rounding mode this less than one ULP difference will always be rounded away, so under
+        // /fp:fast we could avoid these tests if we had some means of detecting it in the caller.
+        constexpr _Ty _Low_limit = _Floating_type_traits<remove_cv_t<_Ty>>::_Minimum_value * 2;
+        if (_Val1_a < _Low_limit) {
+            return _Val1 + _Val2 / 2;
+        }
+
+        if (_Val2_a < _Low_limit) {
+            // division of _Val2 by 2 would be inexact, etc.
+            return _Val1 / 2 + _Val2;
+        }
+
+        return _Val1 / 2 + _Val2 / 2;
+    } else {
+        using _Unsigned    = make_unsigned_t<_Ty>;
+        const auto _Val1_u = static_cast<_Unsigned>(_Val1);
+        const auto _Val2_u = static_cast<_Unsigned>(_Val2);
+        if (_Val1 > _Val2) {
+            return static_cast<_Ty>(_Val1 - static_cast<_Ty>(static_cast<_Unsigned>(_Val1_u - _Val2_u) / 2));
+        } else {
+            return static_cast<_Ty>(_Val1 + static_cast<_Ty>(static_cast<_Unsigned>(_Val2_u - _Val1_u) / 2));
+        }
+    }
+}
+
+_EXPORT_STD template <class _Ty>
+    requires is_object_v<_Ty>
+_NODISCARD constexpr _Ty* midpoint(_Ty* const _Val1, _Ty* const _Val2) noexcept /* strengthened */ {
+    if (_Val1 > _Val2) {
+        return _Val1 - ((_Val1 - _Val2) >> 1); // shift for codegen
+    } else {
+        return _Val1 + ((_Val2 - _Val1) >> 1); // shift for codegen
+    }
+}
+#endif // _HAS_CXX20
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _NUMERIC_
diff --git a/msvc-stl/stl/inc/optional b/msvc-stl/stl/inc/optional
new file mode 100644
index 0000000..8d67b97
--- /dev/null
+++ b/msvc-stl/stl/inc/optional
@@ -0,0 +1,1078 @@
+// optional standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _OPTIONAL_
+#define _OPTIONAL_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <optional> are available only with C++17 or later.");
+#else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+#include <__msvc_sanitizer_annotate_container.hpp>
+#include <exception>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+#include <xsmf_control.h>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_EXPORT_STD struct nullopt_t { // no-value state indicator
+    struct _Tag {};
+    constexpr explicit nullopt_t(_Tag) {}
+#if _HAS_CXX20
+    _NODISCARD friend constexpr auto operator<=>(nullopt_t, nullopt_t) noexcept /* strengthened */ = default;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD friend constexpr bool operator==(nullopt_t, nullopt_t) noexcept /* strengthened */ {
+        return true;
+    }
+    _NODISCARD friend constexpr bool operator!=(nullopt_t, nullopt_t) noexcept /* strengthened */ {
+        return false;
+    }
+    _NODISCARD friend constexpr bool operator<(nullopt_t, nullopt_t) noexcept /* strengthened */ {
+        return false;
+    }
+    _NODISCARD friend constexpr bool operator>(nullopt_t, nullopt_t) noexcept /* strengthened */ {
+        return false;
+    }
+    _NODISCARD friend constexpr bool operator<=(nullopt_t, nullopt_t) noexcept /* strengthened */ {
+        return true;
+    }
+    _NODISCARD friend constexpr bool operator>=(nullopt_t, nullopt_t) noexcept /* strengthened */ {
+        return true;
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+};
+_EXPORT_STD inline constexpr nullopt_t nullopt{nullopt_t::_Tag{}};
+
+_EXPORT_STD class _NODISCARD bad_optional_access : public exception {
+public:
+    _NODISCARD const char* __CLR_OR_THIS_CALL what() const noexcept override {
+        return "Bad optional access";
+    }
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+[[noreturn]] inline void _Throw_bad_optional_access() {
+    _THROW(bad_optional_access{});
+}
+
+struct _Nontrivial_dummy_type {
+    constexpr _Nontrivial_dummy_type() noexcept {
+        // This default constructor is user-provided to avoid zero-initialization when objects are value-initialized.
+    }
+};
+_STL_INTERNAL_STATIC_ASSERT(!is_trivially_default_constructible_v<_Nontrivial_dummy_type>);
+
+#if _HAS_CXX23
+struct _Construct_from_invoke_result_tag {
+    explicit _Construct_from_invoke_result_tag() = default;
+};
+#endif // _HAS_CXX23
+
+template <class _Ty, bool = is_trivially_destructible_v<_Ty>>
+struct _Optional_destruct_base { // either contains a value of _Ty or is empty (trivial destructor)
+    union {
+        _Nontrivial_dummy_type _Dummy;
+        remove_cv_t<_Ty> _Value;
+    };
+    bool _Has_value;
+
+    constexpr _Optional_destruct_base() noexcept : _Dummy{}, _Has_value{false} {} // initialize an empty optional
+
+    template <class... _Types>
+    constexpr explicit _Optional_destruct_base(in_place_t, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, _Types...>)
+        : _Value(_STD forward<_Types>(_Args)...), _Has_value{true} {} // initialize contained value with _Args...
+
+#if _HAS_CXX23
+    template <class _Fn, class _Ux>
+    constexpr _Optional_destruct_base(_Construct_from_invoke_result_tag, _Fn&& _Func, _Ux&& _Arg)
+        noexcept(noexcept(static_cast<_Ty>(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg)))))
+        : _Value(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg))), _Has_value{true} {}
+#endif // _HAS_CXX23
+
+    // For the trivially destructible case, we can't add a destructor for _MSVC_STL_DESTRUCTOR_TOMBSTONES, due to
+    // N5001 [optional.dtor]/2: "Remarks: If is_trivially_destructible_v<T> is true, then this destructor is trivial."
+    // This also prevents ASan annotations from being used.
+
+    _CONSTEXPR20 void reset() noexcept {
+        _Has_value = false;
+    }
+};
+
+template <class _Ty>
+struct _Optional_destruct_base<_Ty, false> { // either contains a value of _Ty or is empty (non-trivial destructor)
+    union {
+        _Nontrivial_dummy_type _Dummy;
+        remove_cv_t<_Ty> _Value;
+    };
+    bool _Has_value;
+
+    _CONSTEXPR20 ~_Optional_destruct_base() noexcept {
+        if (_Has_value) {
+            _Value.~_Ty();
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+            // For the non-trivially destructible case, we can set the optional to be empty.
+            // We don't attempt to scribble over the bytes of the object's storage because that could be expensive
+            // and we don't know whether the object has an invalid representation, much less what it could be.
+            _Has_value = false;
+#endif
+        } else {
+#ifdef _INSERT_OPTIONAL_ANNOTATION
+            // Unpoison our storage when the std::optional is destroyed.
+            // We're giving up control of these bytes, which can be validly reused for something else.
+            if (!_STD _Is_constant_evaluated() && _Asan_optional_should_annotate) {
+                __asan_unpoison_memory_region(_STD addressof(_Value), sizeof(_Ty));
+            }
+#endif // ^^^ defined(_INSERT_OPTIONAL_ANNOTATION) ^^^
+        }
+    }
+
+    constexpr _Optional_destruct_base() noexcept : _Dummy{}, _Has_value{false} { // initialize an empty optional
+#ifdef _INSERT_OPTIONAL_ANNOTATION
+        // Poison our storage when starting empty, until that changes or the std::optional is destroyed.
+        if (!_STD _Is_constant_evaluated() && _Asan_optional_should_annotate) {
+            __asan_poison_memory_region(_STD addressof(_Value), sizeof(_Ty));
+        }
+#endif // ^^^ defined(_INSERT_OPTIONAL_ANNOTATION) ^^^
+    }
+
+    template <class... _Types>
+    constexpr explicit _Optional_destruct_base(in_place_t, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, _Types...>)
+        : _Value(_STD forward<_Types>(_Args)...), _Has_value{true} {} // initialize contained value with _Args...
+
+#if _HAS_CXX23
+    template <class _Fn, class _Ux>
+    constexpr _Optional_destruct_base(_Construct_from_invoke_result_tag, _Fn&& _Func, _Ux&& _Arg)
+        noexcept(noexcept(static_cast<_Ty>(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg)))))
+        : _Value(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg))), _Has_value{true} {}
+#endif // _HAS_CXX23
+
+    _Optional_destruct_base(const _Optional_destruct_base&)            = default;
+    _Optional_destruct_base(_Optional_destruct_base&&)                 = default;
+    _Optional_destruct_base& operator=(const _Optional_destruct_base&) = default;
+    _Optional_destruct_base& operator=(_Optional_destruct_base&&)      = default;
+
+    _CONSTEXPR20 void reset() noexcept {
+        if (_Has_value) {
+            _Value.~_Ty();
+            _Has_value = false;
+
+#ifdef _INSERT_OPTIONAL_ANNOTATION
+            // Poison our storage when becoming empty, until that changes or the std::optional is destroyed.
+            if (!_STD _Is_constant_evaluated() && _Asan_optional_should_annotate) {
+                __asan_poison_memory_region(_STD addressof(_Value), sizeof(_Ty));
+            }
+#endif // ^^^ defined(_INSERT_OPTIONAL_ANNOTATION) ^^^
+        }
+    }
+};
+
+template <class _Ty>
+struct _Optional_construct_base : _Optional_destruct_base<_Ty> {
+    // Provide non-trivial SMF implementations for the _SMF_control machinery
+    using _Optional_destruct_base<_Ty>::_Optional_destruct_base;
+
+    template <class... _Types>
+    _CONSTEXPR20 _Ty& _Construct(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
+        // transition from the empty to the value-containing state
+        _STL_INTERNAL_CHECK(!this->_Has_value);
+
+#ifdef _INSERT_OPTIONAL_ANNOTATION
+        // Only the non-trivially destructible case can use ASan annotations, as the destructor is needed to undo them.
+        if constexpr (!is_trivially_destructible_v<_Ty>) {
+            // Unpoison our storage when becoming non-empty.
+            if (!_STD _Is_constant_evaluated() && _Asan_optional_should_annotate) {
+                __asan_unpoison_memory_region(_STD addressof(this->_Value), sizeof(_Ty));
+            }
+        }
+#endif // ^^^ defined(_INSERT_OPTIONAL_ANNOTATION) ^^^
+
+        _STD _Construct_in_place(this->_Value, _STD forward<_Types>(_Args)...);
+        this->_Has_value = true;
+        return this->_Value;
+    }
+
+    template <class _Ty2>
+    _CONSTEXPR20 void _Assign(_Ty2&& _Right)
+        noexcept(is_nothrow_assignable_v<_Ty&, _Ty2> && is_nothrow_constructible_v<_Ty, _Ty2>) {
+        // assign / initialize the contained value from _Right
+        if (this->_Has_value) {
+            static_cast<_Ty&>(this->_Value) = _STD forward<_Ty2>(_Right);
+        } else {
+            _Construct(_STD forward<_Ty2>(_Right));
+        }
+    }
+
+    template <class _Self>
+    _CONSTEXPR20 void _Construct_from(_Self&& _Right)
+        noexcept(is_nothrow_constructible_v<_Ty, decltype(_STD forward<_Self>(_Right).operator*())>) {
+        // initialize contained value from _Right iff it contains a value
+        if (_Right._Has_value) {
+            _Construct(_STD forward<_Self>(_Right).operator*());
+        }
+    }
+
+    template <class _Self>
+    _CONSTEXPR20 void _Assign_from(_Self&& _Right)
+        noexcept(is_nothrow_constructible_v<_Ty, decltype(_STD forward<_Self>(_Right).operator*())>
+                 && is_nothrow_assignable_v<_Ty&, decltype(_STD forward<_Self>(_Right).operator*())>) {
+        // assign/initialize/destroy contained value from _Right
+        if (_Right._Has_value) {
+            _Assign(_STD forward<_Self>(_Right).operator*());
+        } else {
+            this->reset();
+        }
+    }
+
+    _NODISCARD constexpr _Ty& operator*() & noexcept {
+#if _MSVC_STL_HARDENING_OPTIONAL || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Has_value, "operator*() called on empty optional");
+#endif
+
+        return this->_Value;
+    }
+
+    _NODISCARD constexpr const _Ty& operator*() const& noexcept {
+#if _MSVC_STL_HARDENING_OPTIONAL || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Has_value, "operator*() called on empty optional");
+#endif
+
+        return this->_Value;
+    }
+
+    _NODISCARD constexpr _Ty&& operator*() && noexcept {
+#if _MSVC_STL_HARDENING_OPTIONAL || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Has_value, "operator*() called on empty optional");
+#endif
+
+        return _STD move(this->_Value);
+    }
+
+    _NODISCARD constexpr const _Ty&& operator*() const&& noexcept {
+#if _MSVC_STL_HARDENING_OPTIONAL || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Has_value, "operator*() called on empty optional");
+#endif
+
+        return _STD move(this->_Value);
+    }
+};
+
+_EXPORT_STD template <class _Ty>
+class optional : private _SMF_control<_Optional_construct_base<_Ty>, _Ty> {
+private:
+    using _Mybase = _SMF_control<_Optional_construct_base<_Ty>, _Ty>;
+
+    template <class>
+    friend class optional;
+
+#if _HAS_CXX23
+    template <class _Fn, class _Ux>
+    constexpr optional(_Construct_from_invoke_result_tag _Tag, _Fn&& _Func, _Ux&& _Arg)
+        noexcept(noexcept(static_cast<_Ty>(_STD invoke(_STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg)))))
+        : _Mybase(_Tag, _STD forward<_Fn>(_Func), _STD forward<_Ux>(_Arg)) {}
+#endif // _HAS_CXX23
+
+public:
+    static_assert(!_Is_any_of_v<remove_cv_t<_Ty>, nullopt_t, in_place_t>,
+        "T in optional<T> must be a type other than nullopt_t or in_place_t (N4950 [optional.optional.general]/3).");
+    static_assert(is_object_v<_Ty> && is_destructible_v<_Ty> && !is_array_v<_Ty>,
+        "T in optional<T> must meet the Cpp17Destructible requirements (N4950 [optional.optional.general]/3).");
+
+    using value_type = _Ty;
+
+    constexpr optional() noexcept {}
+    constexpr optional(nullopt_t) noexcept {}
+
+    template <class... _Types, enable_if_t<is_constructible_v<_Ty, _Types...>, int> = 0>
+    constexpr explicit optional(in_place_t, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, _Types...>) // strengthened
+        : _Mybase(in_place, _STD forward<_Types>(_Args)...) {}
+
+    template <class _Elem, class... _Types,
+        enable_if_t<is_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>, int> = 0>
+    constexpr explicit optional(in_place_t, initializer_list<_Elem> _Ilist, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>) // strengthened
+        : _Mybase(in_place, _Ilist, _STD forward<_Types>(_Args)...) {}
+
+    template <class _Ty2>
+    using _AllowDirectConversion = bool_constant<conjunction_v<negation<is_same<_Remove_cvref_t<_Ty2>, optional>>,
+        negation<is_same<_Remove_cvref_t<_Ty2>, in_place_t>>,
+        negation<conjunction<is_same<remove_cv_t<_Ty>, bool>, _Is_specialization<_Remove_cvref_t<_Ty2>, optional>>>,
+        is_constructible<_Ty, _Ty2>>>;
+
+    template <class _Ty2 = remove_cv_t<_Ty>, enable_if_t<_AllowDirectConversion<_Ty2>::value, int> = 0>
+    constexpr explicit(!is_convertible_v<_Ty2, _Ty>) optional(_Ty2&& _Right)
+        noexcept(is_nothrow_constructible_v<_Ty, _Ty2>) // strengthened
+        : _Mybase(in_place, _STD forward<_Ty2>(_Right)) {}
+
+    template <class _Ty2>
+    struct _AllowUnwrapping
+        : bool_constant<disjunction_v<is_same<remove_cv_t<_Ty>, bool>,
+              negation<disjunction<is_same<_Ty, _Ty2>, is_constructible<_Ty, optional<_Ty2>&>,
+                  is_constructible<_Ty, const optional<_Ty2>&>, is_constructible<_Ty, const optional<_Ty2>>,
+                  is_constructible<_Ty, optional<_Ty2>>, is_convertible<optional<_Ty2>&, _Ty>,
+                  is_convertible<const optional<_Ty2>&, _Ty>, is_convertible<const optional<_Ty2>, _Ty>,
+                  is_convertible<optional<_Ty2>, _Ty>>>>> {};
+
+    template <class _Ty2,
+        enable_if_t<conjunction_v<_AllowUnwrapping<_Ty2>, is_constructible<_Ty, const _Ty2&>>, int> = 0>
+    _CONSTEXPR20 explicit(!is_convertible_v<const _Ty2&, _Ty>) optional(const optional<_Ty2>& _Right)
+        noexcept(is_nothrow_constructible_v<_Ty, const _Ty2&>) /* strengthened */ {
+        if (_Right._Has_value) {
+            this->_Construct(_Right.operator*());
+        }
+    }
+
+    template <class _Ty2, enable_if_t<conjunction_v<_AllowUnwrapping<_Ty2>, is_constructible<_Ty, _Ty2>>, int> = 0>
+    _CONSTEXPR20 explicit(!is_convertible_v<_Ty2, _Ty>) optional(optional<_Ty2>&& _Right)
+        noexcept(is_nothrow_constructible_v<_Ty, _Ty2>) /* strengthened */ {
+        if (_Right._Has_value) {
+            this->_Construct(_STD move(_Right.operator*()));
+        }
+    }
+
+    _CONSTEXPR20 optional& operator=(nullopt_t) noexcept {
+        reset();
+        return *this;
+    }
+
+    template <class _Ty2 = remove_cv_t<_Ty>,
+        enable_if_t<conjunction_v<negation<is_same<optional, _Remove_cvref_t<_Ty2>>>,
+                        negation<conjunction<is_scalar<_Ty>, is_same<_Ty, decay_t<_Ty2>>>>, is_constructible<_Ty, _Ty2>,
+                        is_assignable<_Ty&, _Ty2>>,
+            int>         = 0>
+    _CONSTEXPR20 optional& operator=(_Ty2&& _Right)
+        noexcept(is_nothrow_assignable_v<_Ty&, _Ty2> && is_nothrow_constructible_v<_Ty, _Ty2>) /* strengthened */ {
+        this->_Assign(_STD forward<_Ty2>(_Right));
+        return *this;
+    }
+
+    template <class _Ty2>
+    struct _AllowUnwrappingAssignment
+        : bool_constant<!disjunction_v<is_same<_Ty, _Ty2>, is_assignable<_Ty&, optional<_Ty2>&>,
+              is_assignable<_Ty&, const optional<_Ty2>&>, is_assignable<_Ty&, const optional<_Ty2>>,
+              is_assignable<_Ty&, optional<_Ty2>>>> {};
+
+    template <class _Ty2, enable_if_t<conjunction_v<_AllowUnwrappingAssignment<_Ty2>,
+                                          is_constructible<_Ty, const _Ty2&>, is_assignable<_Ty&, const _Ty2&>>,
+                              int> = 0>
+    _CONSTEXPR20 optional& operator=(const optional<_Ty2>& _Right) noexcept(
+        is_nothrow_assignable_v<_Ty&, const _Ty2&> && is_nothrow_constructible_v<_Ty, const _Ty2&>) /* strengthened */ {
+        if (_Right._Has_value) {
+            this->_Assign(_Right.operator*());
+        } else {
+            reset();
+        }
+
+        return *this;
+    }
+
+    template <class _Ty2, enable_if_t<conjunction_v<_AllowUnwrappingAssignment<_Ty2>, is_constructible<_Ty, _Ty2>,
+                                          is_assignable<_Ty&, _Ty2>>,
+                              int> = 0>
+    _CONSTEXPR20 optional& operator=(optional<_Ty2>&& _Right)
+        noexcept(is_nothrow_assignable_v<_Ty&, _Ty2> && is_nothrow_constructible_v<_Ty, _Ty2>) /* strengthened */ {
+        if (_Right._Has_value) {
+            this->_Assign(_STD move(_Right.operator*()));
+        } else {
+            reset();
+        }
+
+        return *this;
+    }
+
+    template <class... _Types, enable_if_t<is_constructible_v<_Ty, _Types...>, int> = 0>
+    _CONSTEXPR20 _Ty& emplace(_Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, _Types...>) /* strengthened */ {
+        reset();
+        return this->_Construct(_STD forward<_Types>(_Args)...);
+    }
+
+    template <class _Elem, class... _Types,
+        enable_if_t<is_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>, int> = 0>
+    _CONSTEXPR20 _Ty& emplace(initializer_list<_Elem> _Ilist, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>) /* strengthened */ {
+        reset();
+        return this->_Construct(_Ilist, _STD forward<_Types>(_Args)...);
+    }
+
+    _CONSTEXPR20 void swap(optional& _Right)
+        noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_swappable_v<_Ty>) {
+        if constexpr (is_move_constructible_v<_Ty>) {
+            static_assert(
+                is_swappable_v<_Ty>, "optional<T>::swap requires T to be swappable (N4993 [optional.swap]/2).");
+        } else {
+            static_assert(false, "optional<T>::swap requires T to be move constructible (N4993 [optional.swap]/1).");
+        }
+        using _STD swap;
+        if constexpr (_Is_trivially_swappable_v<_Ty>) {
+            using _TrivialBaseTy = _Optional_destruct_base<_Ty>;
+            _STD swap(static_cast<_TrivialBaseTy&>(*this), static_cast<_TrivialBaseTy&>(_Right));
+        } else {
+            const bool _Engaged = this->_Has_value;
+            if (_Engaged == _Right._Has_value) {
+                if (_Engaged) {
+                    swap(this->operator*(), _Right.operator*()); // intentional ADL
+                }
+            } else {
+                optional& _Source = _Engaged ? *this : _Right;
+                optional& _Target = _Engaged ? _Right : *this;
+                _Target._Construct(_STD move(_Source.operator*()));
+                _Source.reset();
+            }
+        }
+    }
+
+    _NODISCARD constexpr const _Ty* operator->() const noexcept {
+#if _MSVC_STL_HARDENING_OPTIONAL || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Has_value, "operator->() called on empty optional");
+#endif
+
+        return _STD addressof(this->_Value);
+    }
+    _NODISCARD constexpr _Ty* operator->() noexcept {
+#if _MSVC_STL_HARDENING_OPTIONAL || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Has_value, "operator->() called on empty optional");
+#endif
+
+        return _STD addressof(this->_Value);
+    }
+
+    using _Mybase::operator*;
+
+    constexpr explicit operator bool() const noexcept {
+        return this->_Has_value;
+    }
+    _NODISCARD constexpr bool has_value() const noexcept {
+        return this->_Has_value;
+    }
+
+    _NODISCARD constexpr const _Ty& value() const& {
+        if (!this->_Has_value) {
+            _Throw_bad_optional_access();
+        }
+
+        return this->_Value;
+    }
+    _NODISCARD constexpr _Ty& value() & {
+        if (!this->_Has_value) {
+            _Throw_bad_optional_access();
+        }
+
+        return this->_Value;
+    }
+    _NODISCARD constexpr _Ty&& value() && {
+        if (!this->_Has_value) {
+            _Throw_bad_optional_access();
+        }
+
+        return _STD move(this->_Value);
+    }
+    _NODISCARD constexpr const _Ty&& value() const&& {
+        if (!this->_Has_value) {
+            _Throw_bad_optional_access();
+        }
+
+        return _STD move(this->_Value);
+    }
+
+    template <class _Ty2 = remove_cv_t<_Ty>>
+    _NODISCARD constexpr remove_cv_t<_Ty> value_or(_Ty2&& _Right) const& {
+        static_assert(is_convertible_v<const _Ty&, remove_cv_t<_Ty>>,
+            "The const overload of optional<T>::value_or requires const T& to be convertible to remove_cv_t<T> "
+            "(N4950 [optional.observe]/15 as modified by LWG-3424).");
+        static_assert(is_convertible_v<_Ty2, remove_cv_t<_Ty>>,
+            "optional<T>::value_or(U) requires U to be convertible to remove_cv_t<T> "
+            "(N4950 [optional.observe]/15 as modified by LWG-3424).");
+
+        if (this->_Has_value) {
+            return static_cast<const _Ty&>(this->_Value);
+        }
+
+        return static_cast<remove_cv_t<_Ty>>(_STD forward<_Ty2>(_Right));
+    }
+    template <class _Ty2 = remove_cv_t<_Ty>>
+    _NODISCARD constexpr remove_cv_t<_Ty> value_or(_Ty2&& _Right) && {
+        static_assert(is_convertible_v<_Ty, remove_cv_t<_Ty>>,
+            "The rvalue overload of optional<T>::value_or requires T to be convertible to remove_cv_t<T> "
+            "(N4950 [optional.observe]/17 as modified by LWG-3424).");
+        static_assert(is_convertible_v<_Ty2, remove_cv_t<_Ty>>,
+            "optional<T>::value_or(U) requires U to be convertible to remove_cv_t<T> "
+            "(N4950 [optional.observe]/17 as modified by LWG-3424).");
+
+        if (this->_Has_value) {
+            return static_cast<_Ty&&>(this->_Value);
+        }
+
+        return static_cast<remove_cv_t<_Ty>>(_STD forward<_Ty2>(_Right));
+    }
+
+#if _HAS_CXX23
+    template <class _Fn>
+    constexpr auto and_then(_Fn&& _Func) & {
+        using _Uty = invoke_result_t<_Fn, _Ty&>;
+
+        static_assert(_Is_specialization_v<remove_cvref_t<_Uty>, optional>,
+            "optional<T>::and_then(F) requires the return type of F to be a specialization of optional "
+            "(N4950 [optional.monadic]/2).");
+
+        if (this->_Has_value) {
+            return _STD invoke(_STD forward<_Fn>(_Func), static_cast<_Ty&>(this->_Value));
+        } else {
+            return remove_cvref_t<_Uty>{};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto and_then(_Fn&& _Func) const& {
+        using _Uty = invoke_result_t<_Fn, const _Ty&>;
+
+        static_assert(_Is_specialization_v<remove_cvref_t<_Uty>, optional>,
+            "optional<T>::and_then(F) requires the return type of F to be a specialization of optional "
+            "(N4950 [optional.monadic]/2).");
+
+        if (this->_Has_value) {
+            return _STD invoke(_STD forward<_Fn>(_Func), static_cast<const _Ty&>(this->_Value));
+        } else {
+            return remove_cvref_t<_Uty>{};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto and_then(_Fn&& _Func) && {
+        using _Uty = invoke_result_t<_Fn, _Ty>;
+
+        static_assert(_Is_specialization_v<remove_cvref_t<_Uty>, optional>,
+            "optional<T>::and_then(F) requires the return type of F to be a specialization of optional "
+            "(N4950 [optional.monadic]/5).");
+
+        if (this->_Has_value) {
+            return _STD invoke(_STD forward<_Fn>(_Func), static_cast<_Ty&&>(this->_Value));
+        } else {
+            return remove_cvref_t<_Uty>{};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto and_then(_Fn&& _Func) const&& {
+        using _Uty = invoke_result_t<_Fn, const _Ty>;
+
+        static_assert(_Is_specialization_v<remove_cvref_t<_Uty>, optional>,
+            "optional<T>::and_then(F) requires the return type of F to be a specialization of optional "
+            "(N4950 [optional.monadic]/5).");
+
+        if (this->_Has_value) {
+            return _STD invoke(_STD forward<_Fn>(_Func), static_cast<const _Ty&&>(this->_Value));
+        } else {
+            return remove_cvref_t<_Uty>{};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto transform(_Fn&& _Func) & {
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Ty&>>;
+
+        static_assert(!_Is_any_of_v<_Uty, nullopt_t, in_place_t>,
+            "optional<T>::transform(F) requires the return type of F to be a type other than nullopt_t or in_place_t "
+            "(N4950 [optional.monadic]/8).");
+        static_assert(is_object_v<_Uty> && !is_array_v<_Uty>,
+            "optional<T>::transform(F) requires the return type of F to be a non-array object type "
+            "(N4950 [optional.monadic]/8).");
+
+        if (this->_Has_value) {
+            return optional<_Uty>{
+                _Construct_from_invoke_result_tag{}, _STD forward<_Fn>(_Func), static_cast<_Ty&>(this->_Value)};
+        } else {
+            return optional<_Uty>{};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto transform(_Fn&& _Func) const& {
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Ty&>>;
+
+        static_assert(!_Is_any_of_v<_Uty, nullopt_t, in_place_t>,
+            "optional<T>::transform(F) requires the return type of F to be a type other than nullopt_t or in_place_t "
+            "(N4950 [optional.monadic]/8).");
+        static_assert(is_object_v<_Uty> && !is_array_v<_Uty>,
+            "optional<T>::transform(F) requires the return type of F to be a non-array object type "
+            "(N4950 [optional.monadic]/8).");
+
+        if (this->_Has_value) {
+            return optional<_Uty>{
+                _Construct_from_invoke_result_tag{}, _STD forward<_Fn>(_Func), static_cast<const _Ty&>(this->_Value)};
+        } else {
+            return optional<_Uty>{};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto transform(_Fn&& _Func) && {
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Ty>>;
+
+        static_assert(!_Is_any_of_v<_Uty, nullopt_t, in_place_t>,
+            "optional<T>::transform(F) requires the return type of F to be a type other than nullopt_t or in_place_t "
+            "(N4950 [optional.monadic]/11).");
+        static_assert(is_object_v<_Uty> && !is_array_v<_Uty>,
+            "optional<T>::transform(F) requires the return type of F to be a non-array object type "
+            "(N4950 [optional.monadic]/11).");
+
+        if (this->_Has_value) {
+            return optional<_Uty>{
+                _Construct_from_invoke_result_tag{}, _STD forward<_Fn>(_Func), static_cast<_Ty&&>(this->_Value)};
+        } else {
+            return optional<_Uty>{};
+        }
+    }
+
+    template <class _Fn>
+    constexpr auto transform(_Fn&& _Func) const&& {
+        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Ty>>;
+
+        static_assert(!_Is_any_of_v<_Uty, nullopt_t, in_place_t>,
+            "optional<T>::transform(F) requires the return type of F to be a type other than nullopt_t or in_place_t "
+            "(N4950 [optional.monadic]/11).");
+        static_assert(is_object_v<_Uty> && !is_array_v<_Uty>,
+            "optional<T>::transform(F) requires the return type of F to be a non-array object type "
+            "(N4950 [optional.monadic]/11).");
+
+        if (this->_Has_value) {
+            return optional<_Uty>{
+                _Construct_from_invoke_result_tag{}, _STD forward<_Fn>(_Func), static_cast<const _Ty&&>(this->_Value)};
+        } else {
+            return optional<_Uty>{};
+        }
+    }
+
+    template <invocable<> _Fn>
+        requires copy_constructible<_Ty>
+    constexpr optional or_else(_Fn&& _Func) const& {
+        static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Fn>>, optional>,
+            "optional<T>::or_else(F) requires F to return an optional<T> (N4950 [optional.monadic]/14).");
+
+        if (this->_Has_value) {
+            return *this;
+        } else {
+            return _STD forward<_Fn>(_Func)();
+        }
+    }
+
+    template <invocable<> _Fn>
+        requires move_constructible<_Ty>
+    constexpr optional or_else(_Fn&& _Func) && {
+        static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Fn>>, optional>,
+            "optional<T>::or_else(F) requires F to return an optional<T> (N4950 [optional.monadic]/17).");
+
+        if (this->_Has_value) {
+            return _STD move(*this);
+        } else {
+            return _STD forward<_Fn>(_Func)();
+        }
+    }
+#endif // _HAS_CXX23
+
+    using _Mybase::reset;
+};
+
+template <class _Ty>
+optional(_Ty) -> optional<_Ty>;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool operator==(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() == _Right.operator*()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.operator*() == _Right.operator*() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    const bool _Left_has_value  = _Left.has_value();
+    const bool _Right_has_value = _Right.has_value();
+    if (_Left_has_value && _Right_has_value) {
+        return _Left.operator*() == _Right.operator*();
+    }
+    return _Left_has_value == _Right_has_value;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool operator!=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() != _Right.operator*()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.operator*() != _Right.operator*() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    const bool _Left_has_value  = _Left.has_value();
+    const bool _Right_has_value = _Right.has_value();
+    if (_Left_has_value && _Right_has_value) {
+        return _Left.operator*() != _Right.operator*();
+    }
+    return _Left_has_value != _Right_has_value;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool operator<(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() < _Right.operator*()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.operator*() < _Right.operator*() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    const bool _Left_has_value  = _Left.has_value();
+    const bool _Right_has_value = _Right.has_value();
+    if (_Left_has_value && _Right_has_value) {
+        return _Left.operator*() < _Right.operator*();
+    }
+    return _Left_has_value < _Right_has_value;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool operator>(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() > _Right.operator*()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.operator*() > _Right.operator*() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    const bool _Left_has_value  = _Left.has_value();
+    const bool _Right_has_value = _Right.has_value();
+    if (_Left_has_value && _Right_has_value) {
+        return _Left.operator*() > _Right.operator*();
+    }
+    return _Left_has_value > _Right_has_value;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool operator<=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() <= _Right.operator*()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.operator*() <= _Right.operator*() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    const bool _Left_has_value  = _Left.has_value();
+    const bool _Right_has_value = _Right.has_value();
+    if (_Left_has_value && _Right_has_value) {
+        return _Left.operator*() <= _Right.operator*();
+    }
+    return _Left_has_value <= _Right_has_value;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool operator>=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() >= _Right.operator*()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.operator*() >= _Right.operator*() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    const bool _Left_has_value  = _Left.has_value();
+    const bool _Right_has_value = _Right.has_value();
+    if (_Left_has_value && _Right_has_value) {
+        return _Left.operator*() >= _Right.operator*();
+    }
+    return _Left_has_value >= _Right_has_value;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty1, three_way_comparable_with<_Ty1> _Ty2>
+_NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2> operator<=>(const optional<_Ty1>& _Left,
+    const optional<_Ty2>& _Right) noexcept(noexcept(_Left.operator*() <=> _Right.operator*())) /* strengthened */ {
+    const bool _Left_has_value  = _Left.has_value();
+    const bool _Right_has_value = _Right.has_value();
+    if (_Left_has_value && _Right_has_value) {
+        return _Left.operator*() <=> _Right.operator*();
+    }
+
+    return _Left_has_value <=> _Right_has_value;
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr bool operator==(const optional<_Ty>& _Left, nullopt_t) noexcept {
+    return !_Left.has_value();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr strong_ordering operator<=>(const optional<_Ty>& _Left, nullopt_t) noexcept {
+    return _Left.has_value() <=> false;
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty>
+_NODISCARD constexpr bool operator==(nullopt_t, const optional<_Ty>& _Right) noexcept {
+    return !_Right.has_value();
+}
+
+template <class _Ty>
+_NODISCARD constexpr bool operator!=(const optional<_Ty>& _Left, nullopt_t) noexcept {
+    return _Left.has_value();
+}
+template <class _Ty>
+_NODISCARD constexpr bool operator!=(nullopt_t, const optional<_Ty>& _Right) noexcept {
+    return _Right.has_value();
+}
+
+template <class _Ty>
+_NODISCARD constexpr bool operator<(const optional<_Ty>&, nullopt_t) noexcept {
+    return false;
+}
+template <class _Ty>
+_NODISCARD constexpr bool operator<(nullopt_t, const optional<_Ty>& _Right) noexcept {
+    return _Right.has_value();
+}
+
+template <class _Ty>
+_NODISCARD constexpr bool operator>(const optional<_Ty>& _Left, nullopt_t) noexcept {
+    return _Left.has_value();
+}
+template <class _Ty>
+_NODISCARD constexpr bool operator>(nullopt_t, const optional<_Ty>&) noexcept {
+    return false;
+}
+
+template <class _Ty>
+_NODISCARD constexpr bool operator<=(const optional<_Ty>& _Left, nullopt_t) noexcept {
+    return !_Left.has_value();
+}
+template <class _Ty>
+_NODISCARD constexpr bool operator<=(nullopt_t, const optional<_Ty>&) noexcept {
+    return true;
+}
+
+template <class _Ty>
+_NODISCARD constexpr bool operator>=(const optional<_Ty>&, nullopt_t) noexcept {
+    return true;
+}
+template <class _Ty>
+_NODISCARD constexpr bool operator>=(nullopt_t, const optional<_Ty>& _Right) noexcept {
+    return !_Right.has_value();
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Ty>
+using _Enable_if_bool_convertible = enable_if_t<is_convertible_v<_Ty, bool>, int>;
+
+template <class _Lhs, class _Rhs>
+using _Enable_if_comparable_with_equal =
+    _Enable_if_bool_convertible<decltype(_STD declval<const _Lhs&>() == _STD declval<const _Rhs&>())>;
+
+template <class _Lhs, class _Rhs>
+using _Enable_if_comparable_with_not_equal =
+    _Enable_if_bool_convertible<decltype(_STD declval<const _Lhs&>() != _STD declval<const _Rhs&>())>;
+
+template <class _Lhs, class _Rhs>
+using _Enable_if_comparable_with_less =
+    _Enable_if_bool_convertible<decltype(_STD declval<const _Lhs&>() < _STD declval<const _Rhs&>())>;
+
+template <class _Lhs, class _Rhs>
+using _Enable_if_comparable_with_greater =
+    _Enable_if_bool_convertible<decltype(_STD declval<const _Lhs&>() > _STD declval<const _Rhs&>())>;
+
+template <class _Lhs, class _Rhs>
+using _Enable_if_comparable_with_less_equal =
+    _Enable_if_bool_convertible<decltype(_STD declval<const _Lhs&>() <= _STD declval<const _Rhs&>())>;
+
+template <class _Lhs, class _Rhs>
+using _Enable_if_comparable_with_greater_equal =
+    _Enable_if_bool_convertible<decltype(_STD declval<const _Lhs&>() >= _STD declval<const _Rhs&>())>;
+
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator==(const optional<_Ty1>& _Left, const _Ty2& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() == _Right))) /* strengthened */ {
+    if (_Left) {
+        return _Left.operator*() == _Right;
+    }
+    return false;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator==(const _Ty1& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left == _Right.operator*()))) /* strengthened */ {
+    if (_Right) {
+        return _Left == _Right.operator*();
+    }
+    return false;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_not_equal<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator!=(const optional<_Ty1>& _Left, const _Ty2& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() != _Right))) /* strengthened */ {
+    if (_Left) {
+        return _Left.operator*() != _Right;
+    }
+    return true;
+}
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_not_equal<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator!=(const _Ty1& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left != _Right.operator*()))) /* strengthened */ {
+    if (_Right) {
+        return _Left != _Right.operator*();
+    }
+    return true;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator<(const optional<_Ty1>& _Left, const _Ty2& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() < _Right))) /* strengthened */ {
+    if (_Left) {
+        return _Left.operator*() < _Right;
+    }
+    return true;
+}
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator<(const _Ty1& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left < _Right.operator*()))) /* strengthened */ {
+    if (_Right) {
+        return _Left < _Right.operator*();
+    }
+    return false;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator>(const optional<_Ty1>& _Left, const _Ty2& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() > _Right))) /* strengthened */ {
+    if (_Left) {
+        return _Left.operator*() > _Right;
+    }
+    return false;
+}
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator>(const _Ty1& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left > _Right.operator*()))) /* strengthened */ {
+    if (_Right) {
+        return _Left > _Right.operator*();
+    }
+    return true;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less_equal<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator<=(const optional<_Ty1>& _Left, const _Ty2& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() <= _Right))) /* strengthened */ {
+    if (_Left) {
+        return _Left.operator*() <= _Right;
+    }
+    return true;
+}
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less_equal<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator<=(const _Ty1& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left <= _Right.operator*()))) /* strengthened */ {
+    if (_Right) {
+        return _Left <= _Right.operator*();
+    }
+    return false;
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater_equal<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator>=(const optional<_Ty1>& _Left, const _Ty2& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.operator*() >= _Right))) /* strengthened */ {
+    if (_Left) {
+        return _Left.operator*() >= _Right;
+    }
+    return false;
+}
+_EXPORT_STD template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater_equal<_Ty1, _Ty2> = 0>
+_NODISCARD constexpr bool operator>=(const _Ty1& _Left, const optional<_Ty2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left >= _Right.operator*()))) /* strengthened */ {
+    if (_Right) {
+        return _Left >= _Right.operator*();
+    }
+    return true;
+}
+
+#if _HAS_CXX20
+#ifndef __clang__ // TRANSITION, DevCom-10880933 (EDG) and VSO-2444237 (MSVC)
+template <class _Ty>
+void _Derived_from_optional_impl(const optional<_Ty>&);
+
+template <class _Ty>
+concept _Derived_from_optional = requires(const _Ty& __obj) { _STD _Derived_from_optional_impl(__obj); };
+#else // ^^^ workaround / no workaround vvv
+template <class _Ty>
+concept _Derived_from_optional = requires(const _Ty& __obj) { []<class _Uty>(const optional<_Uty>&) {}(__obj); };
+#endif // ^^^ no workaround ^^^
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+    requires (!_Derived_from_optional<_Ty2>) && three_way_comparable_with<_Ty1, _Ty2>
+_NODISCARD constexpr compare_three_way_result_t<_Ty1, _Ty2> operator<=>(const optional<_Ty1>& _Left, const _Ty2& _Right)
+    noexcept(noexcept(_Left.operator*() <=> _Right)) /* strengthened */ {
+    if (_Left) {
+        return _Left.operator*() <=> _Right;
+    }
+
+    return strong_ordering::less;
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_swappable_v<_Ty>, int> = 0>
+_CONSTEXPR20 void swap(optional<_Ty>& _Left, optional<_Ty>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty, enable_if_t<is_constructible_v<decay_t<_Ty>, _Ty>, int> = 0> // LWG-3627
+_NODISCARD constexpr optional<decay_t<_Ty>> make_optional(_Ty&& _Value)
+    noexcept(noexcept(optional<decay_t<_Ty>>{_STD forward<_Ty>(_Value)})) /* strengthened */ {
+    return optional<decay_t<_Ty>>{_STD forward<_Ty>(_Value)};
+}
+_EXPORT_STD template <class _Ty, class... _Types, enable_if_t<is_constructible_v<_Ty, _Types...>, int> = 0>
+_NODISCARD constexpr optional<_Ty> make_optional(_Types&&... _Args)
+    noexcept(noexcept(optional<_Ty>{in_place, _STD forward<_Types>(_Args)...})) /* strengthened */ {
+    return optional<_Ty>{in_place, _STD forward<_Types>(_Args)...};
+}
+_EXPORT_STD template <class _Ty, class _Elem, class... _Types,
+    enable_if_t<is_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>, int> = 0>
+_NODISCARD constexpr optional<_Ty> make_optional(initializer_list<_Elem> _Ilist, _Types&&... _Args)
+    noexcept(noexcept(optional<_Ty>{in_place, _Ilist, _STD forward<_Types>(_Args)...})) /* strengthened */ {
+    return optional<_Ty>{in_place, _Ilist, _STD forward<_Types>(_Args)...};
+}
+
+template <class _Ty>
+struct hash<optional<_Ty>>
+    : _Conditionally_enabled_hash<optional<_Ty>, is_default_constructible_v<hash<remove_const_t<_Ty>>>> {
+    static size_t _Do_hash(const optional<_Ty>& _Opt) noexcept(_Is_nothrow_hashable<remove_const_t<_Ty>>::value) {
+        constexpr size_t _Unspecified_value = 0;
+        if (_Opt) {
+            return hash<remove_const_t<_Ty>>{}(_Opt.operator*());
+        }
+
+        return _Unspecified_value;
+    }
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX17 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _OPTIONAL_
diff --git a/msvc-stl/stl/inc/ostream b/msvc-stl/stl/inc/ostream
new file mode 100644
index 0000000..16899f4
--- /dev/null
+++ b/msvc-stl/stl/inc/ostream
@@ -0,0 +1,346 @@
+// ostream standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _OSTREAM_
+#define _OSTREAM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_ostream.hpp>
+
+#if _HAS_CXX23
+#include <__msvc_filebuf.hpp>
+#include <__msvc_print.hpp>
+#include <format>
+#endif // ^^^ _HAS_CXX23 ^^^
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#if _HAS_CXX20
+#ifdef _CPPRTTI
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& emit_on_flush(basic_ostream<_Elem, _Traits>& _Ostr) {
+    const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
+    if (_Sync_buf_ptr) {
+        _Sync_buf_ptr->set_emit_on_sync(true);
+    }
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& noemit_on_flush(basic_ostream<_Elem, _Traits>& _Ostr) {
+    const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
+    if (_Sync_buf_ptr) {
+        _Sync_buf_ptr->set_emit_on_sync(false);
+    }
+    return _Ostr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& flush_emit(basic_ostream<_Elem, _Traits>& _Ostr) {
+    _Ostr.flush();
+    const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
+    if (_Sync_buf_ptr) {
+        ios_base::iostate _State = ios_base::goodbit;
+        const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);
+        if (!_Ok) {
+            _State |= ios_base::badbit;
+        } else {
+            _TRY_IO_BEGIN
+            const bool _Emit_failed = !_Sync_buf_ptr->_Do_emit();
+            if (_Emit_failed) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_(ios_base, _Ostr)
+        }
+        _Ostr.setstate(_State);
+    }
+    return _Ostr;
+}
+#else // ^^^ defined(_CPPRTTI) / !defined(_CPPRTTI) vvv
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& emit_on_flush(basic_ostream<_Elem, _Traits>&) = delete; // requires /GR option
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& noemit_on_flush(basic_ostream<_Elem, _Traits>&) = delete; // requires /GR option
+_EXPORT_STD template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& flush_emit(basic_ostream<_Elem, _Traits>&) = delete; // requires /GR option
+#endif // ^^^ !defined(_CPPRTTI) ^^^
+#endif // ^^^ _HAS_CXX20 ^^^
+
+#if _HAS_CXX23
+#ifdef _CPPRTTI
+template <int = 0>
+ios_base::iostate _Print_noformat_nonunicode(ostream& _Ostr, const string_view _Str) {
+    // *LOCKED*
+    //
+    // This function is called from a context in which an ostream::sentry has been
+    // constructed.
+    ios_base::iostate _State = ios_base::goodbit;
+
+    _TRY_IO_BEGIN
+    const auto _Characters_written       = _Ostr.rdbuf()->sputn(_Str.data(), static_cast<streamsize>(_Str.size()));
+    const bool _Was_insertion_successful = static_cast<size_t>(_Characters_written) == _Str.size();
+    if (!_Was_insertion_successful) {
+        _State |= ios_base::badbit;
+    }
+    _CATCH_IO_(ios_base, _Ostr)
+
+    return _State;
+}
+
+template <int = 0>
+ios_base::iostate _Print_newline_only_nonunicode(ostream& _Ostr) {
+    // *LOCKED*
+    //
+    // This function is called from a context in which an ostream::sentry has been
+    // constructed.
+    ios_base::iostate _State = ios_base::goodbit;
+
+    _TRY_IO_BEGIN
+    const bool _Was_insertion_successful = _Ostr.rdbuf()->sputc('\n') == '\n';
+    if (!_Was_insertion_successful) {
+        _State |= ios_base::badbit;
+    }
+    _CATCH_IO_(ios_base, _Ostr)
+
+    return _State;
+}
+
+template <int = 0>
+void _Vprint_nonunicode_impl(
+    const _Add_newline _Add_nl, ostream& _Ostr, const string_view _Fmt_str, const format_args _Fmt_args) {
+    const ostream::sentry _Ok(_Ostr);
+    ios_base::iostate _State = ios_base::goodbit;
+
+    if (!_Ok) {
+        _State |= ios_base::badbit;
+    } else {
+        // This is intentionally kept outside of the try/catch block in _Print_noformat_nonunicode()
+        // (see N4950 [ostream.formatted.print]/3.2).
+        string _Output_str = _STD vformat(_Ostr.getloc(), _Fmt_str, _Fmt_args);
+        if (_Add_nl == _Add_newline::_Yes) {
+            _Output_str.push_back('\n');
+        }
+
+        _State |= _STD _Print_noformat_nonunicode(_Ostr, _Output_str);
+    }
+
+    _Ostr.setstate(_State);
+}
+
+template <class _UnicodeConsoleFn, class _FallbackFn, class _Filebuf_type = filebuf>
+ios_base::iostate _Do_on_maybe_unicode_console(
+    ostream& _Ostr, _UnicodeConsoleFn _Unicode_console_func, _FallbackFn _Fallback_func) {
+    // *LOCKED*
+    //
+    // This function is called from a context in which an ostream::sentry has been
+    // constructed.
+    ios_base::iostate _State = ios_base::goodbit;
+
+    // The std::ostream& overload of vprint_unicode() expects you to determine whether the stream refers
+    // to a unicode console or not based solely on the std::ostream& provided. That class simply doesn't
+    // provide enough information to know this in every case. The best we can do (without breaking ABI)
+    // is check if the underlying std::streambuf object of the std::ostream& actually refers to a std::filebuf
+    // object. This requires the use of a dynamic_cast. (This is also why the std::ostream& overloads of
+    // std::print() et al. are deleted when RTTI is disabled.)
+    streambuf* const _Streambuf = _Ostr.rdbuf();
+    const auto _Filebuf         = dynamic_cast<_Filebuf_type*>(_Streambuf);
+
+    // If we got nullptr, then it probably isn't being used for a unicode console...
+    if (_Filebuf == nullptr) {
+        _State |= _Fallback_func();
+        return _State;
+    }
+
+    FILE* const _File_stream = _Filebuf->_Myfile;
+    const __std_unicode_console_retrieval_result _Unicode_console_retrieval_result{
+        __std_get_unicode_console_handle_from_file_stream(_File_stream)};
+
+    // See the documentation for __std_unicode_console_retrieval_result to understand why we do this.
+    bool _Is_unicode_console;
+
+#pragma warning(push)
+#pragma warning(disable : 4061) // enumerator not explicitly handled by switch label
+    switch (_Unicode_console_retrieval_result._Error) {
+    case __std_win_error::_Success:
+        _Is_unicode_console = true;
+        break;
+
+    case __std_win_error::_File_not_found:
+        _Is_unicode_console = false;
+        break;
+
+    case __std_win_error::_Not_supported:
+        return _State;
+
+    default:
+        return ios_base::failbit;
+    }
+#pragma warning(pop)
+
+    if (_Is_unicode_console) {
+        _TRY_IO_BEGIN
+        const bool _Was_flush_successful = _Ostr.rdbuf()->pubsync() != -1;
+        if (!_Was_flush_successful) {
+            _State |= ios_base::badbit;
+            return _State;
+        }
+
+        const __std_win_error _Unicode_console_print_result =
+            _Unicode_console_func(_Unicode_console_retrieval_result._Console_handle);
+        if (_Unicode_console_print_result != __std_win_error::_Success) {
+            _State |= ios_base::badbit;
+        }
+        _CATCH_IO_(ios_base, _Ostr)
+    } else {
+        _State |= _Fallback_func();
+    }
+
+    return _State;
+}
+
+template <int = 0>
+ios_base::iostate _Print_noformat_unicode(ostream& _Ostr, const string_view _Str) {
+    const auto _Unicode_console = [&](const __std_unicode_console_handle _Console_handle) {
+        return __std_print_to_unicode_console(_Console_handle, _Str.data(), _Str.size());
+    };
+
+    const auto _Fallback = [&] { return _STD _Print_noformat_nonunicode(_Ostr, _Str); };
+
+    return _STD _Do_on_maybe_unicode_console(_Ostr, _Unicode_console, _Fallback);
+}
+
+template <int = 0>
+ios_base::iostate _Print_newline_only_unicode(ostream& _Ostr) {
+    const auto _Unicode_console = [](const __std_unicode_console_handle _Console_handle) static {
+        return __std_print_newline_only_to_unicode_console(_Console_handle);
+    };
+
+    const auto _Fallback = [&] { return _STD _Print_newline_only_nonunicode(_Ostr); };
+
+    return _STD _Do_on_maybe_unicode_console(_Ostr, _Unicode_console, _Fallback);
+}
+
+template <int = 0>
+void _Vprint_unicode_impl(
+    const _Add_newline _Add_nl, ostream& _Ostr, const string_view _Fmt_str, const format_args _Fmt_args) {
+    const ostream::sentry _Ok(_Ostr);
+    ios_base::iostate _State = ios_base::goodbit;
+
+    if (!_Ok) {
+        _State |= ios_base::badbit;
+    } else {
+        // This is intentionally kept outside of the try/catch block in _Print_noformat_unicode()
+        // (see N4950 [ostream.formatted.print]/3.2).
+        string _Output_str = _STD vformat(_Ostr.getloc(), _Fmt_str, _Fmt_args);
+        if (_Add_nl == _Add_newline::_Yes) {
+            _Output_str.push_back('\n');
+        }
+
+        _State |= _STD _Print_noformat_unicode(_Ostr, _Output_str);
+    }
+
+    _Ostr.setstate(_State);
+}
+
+template <int = 0>
+void _Print_noformat(ostream& _Ostr, const string_view _Str) {
+    const ostream::sentry _Ok(_Ostr);
+    ios_base::iostate _State = ios_base::goodbit;
+
+    if (!_Ok) {
+        _State |= ios_base::badbit;
+    } else {
+        if constexpr (_STD _Is_ordinary_literal_encoding_utf8()) {
+            _State |= _STD _Print_noformat_unicode(_Ostr, _Str);
+        } else {
+            _State |= _STD _Print_noformat_nonunicode(_Ostr, _Str);
+        }
+    }
+
+    _Ostr.setstate(_State);
+}
+
+template <class... _Types>
+void _Print_impl(const _Add_newline _Add_nl, ostream& _Ostr, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    constexpr bool _Has_format_args = sizeof...(_Types) > 0;
+
+    // This is intentionally kept outside of the try/catch block in _Print_noformat_*()
+    // (see N4950 [ostream.formatted.print]/3.2).
+
+    if constexpr (_Has_format_args) {
+        if constexpr (_STD _Is_ordinary_literal_encoding_utf8()) {
+            _STD _Vprint_unicode_impl(_Add_nl, _Ostr, _Fmt.get(), _STD make_format_args(_Args...));
+        } else {
+            _STD _Vprint_nonunicode_impl(_Add_nl, _Ostr, _Fmt.get(), _STD make_format_args(_Args...));
+        }
+    } else {
+        const string _Unescaped_str{_Unescape_braces(_Add_nl, _Fmt.get())};
+        _STD _Print_noformat(_Ostr, _Unescaped_str);
+    }
+}
+
+_EXPORT_STD template <class... _Types>
+void print(ostream& _Ostr, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _STD _Print_impl(_Add_newline::_Nope, _Ostr, _Fmt, _STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <class... _Types>
+void println(ostream& _Ostr, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _STD _Print_impl(_Add_newline::_Yes, _Ostr, _Fmt, _STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void println(ostream& _Ostr) {
+    const ostream::sentry _Ok(_Ostr);
+    ios_base::iostate _State = ios_base::goodbit;
+
+    if (!_Ok) {
+        _State |= ios_base::badbit;
+    } else {
+        if constexpr (_STD _Is_ordinary_literal_encoding_utf8()) {
+            _State |= _STD _Print_newline_only_unicode(_Ostr);
+        } else {
+            _State |= _STD _Print_newline_only_nonunicode(_Ostr);
+        }
+    }
+
+    _Ostr.setstate(_State);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void vprint_unicode(ostream& _Ostr, const string_view _Fmt_str, const format_args _Fmt_args) {
+    _STD _Vprint_unicode_impl(_Add_newline::_Nope, _Ostr, _Fmt_str, _Fmt_args);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void vprint_nonunicode(ostream& _Ostr, const string_view _Fmt_str, const format_args _Fmt_args) {
+    _STD _Vprint_nonunicode_impl(_Add_newline::_Nope, _Ostr, _Fmt_str, _Fmt_args);
+}
+#else // ^^^ defined(_CPPRTTI) / !defined(_CPPRTTI) vvv
+_EXPORT_STD template <class... _Types>
+void print(ostream&, format_string<_Types...>, _Types&&...) = delete; // requires /GR option
+
+_EXPORT_STD template <class... _Types>
+void println(ostream&, format_string<_Types...>, _Types&&...) = delete; // requires /GR option
+
+_EXPORT_STD void vprint_unicode(ostream&, string_view, format_args)    = delete; // requires /GR option
+_EXPORT_STD void vprint_nonunicode(ostream&, string_view, format_args) = delete; // requires /GR option
+#endif // ^^^ !defined(_CPPRTTI) ^^^
+#endif // ^^^ _HAS_CXX23 ^^^
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _OSTREAM_
diff --git a/msvc-stl/stl/inc/print b/msvc-stl/stl/inc/print
new file mode 100644
index 0000000..c34d2e8
--- /dev/null
+++ b/msvc-stl/stl/inc/print
@@ -0,0 +1,356 @@
+// print standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _PRINT_
+#define _PRINT_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <print> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+
+#include <__msvc_print.hpp>
+#include <cstdio>
+#include <format>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+struct _NODISCARD _Stream_lock_guard {
+    explicit _Stream_lock_guard(FILE* const _Stream_) : _Stream(_Stream_) {
+        _CSTD _lock_file(_Stream);
+    }
+    ~_Stream_lock_guard() {
+        _CSTD _unlock_file(_Stream);
+    }
+
+    _Stream_lock_guard(const _Stream_lock_guard&)            = delete;
+    _Stream_lock_guard& operator=(const _Stream_lock_guard&) = delete;
+
+    FILE* const _Stream;
+};
+
+class _Print_to_stream_it {
+public:
+    using difference_type = ptrdiff_t;
+
+    explicit _Print_to_stream_it(FILE* const _Stream_) noexcept : _Stream(_Stream_) {}
+
+    // These member functions are never defined:
+    _Print_to_stream_it& operator=(char);
+    _Print_to_stream_it& operator*();
+    _Print_to_stream_it& operator++();
+    _Print_to_stream_it operator++(int);
+
+    FILE* _Get_stream() const noexcept {
+        return _Stream;
+    }
+
+private:
+    FILE* _Stream;
+};
+
+inline void _Print_noformat_nonunicode_nonlocking(FILE* const _Stream, const string_view _Str) {
+    const bool _Was_write_successful = _CSTD _fwrite_nolock(_Str.data(), 1, _Str.size(), _Stream) == _Str.size();
+
+    if (!_Was_write_successful) {
+        _Throw_system_error(static_cast<errc>(errno));
+    }
+}
+
+template <>
+struct _Fmt_iterator_flush<_Print_to_stream_it> {
+    static _Print_to_stream_it _Flush(const char* const _First, const char* const _Last, _Print_to_stream_it _Output) {
+        _STD _Print_noformat_nonunicode_nonlocking(_Output._Get_stream(), {_First, _Last});
+        return _Output;
+    }
+};
+
+class _Print_to_unicode_console_it {
+public:
+    using difference_type = ptrdiff_t;
+
+    explicit _Print_to_unicode_console_it(const __std_unicode_console_handle _Console_handle_) noexcept
+        : _Console_handle(_Console_handle_) {}
+
+    // These member functions are never defined:
+    _Print_to_unicode_console_it& operator=(char);
+    _Print_to_unicode_console_it& operator*();
+    _Print_to_unicode_console_it& operator++();
+    _Print_to_unicode_console_it operator++(int);
+
+    __std_unicode_console_handle _Get_console_handle() const noexcept {
+        return _Console_handle;
+    }
+
+private:
+    __std_unicode_console_handle _Console_handle;
+};
+
+inline void _Print_noformat_unicode_to_console_nonlocking(
+    const __std_unicode_console_handle _Console_handle, const string_view _Str) {
+    const __std_win_error _Console_print_result =
+        __std_print_to_unicode_console(_Console_handle, _Str.data(), _Str.size());
+    if (_Console_print_result != __std_win_error::_Success) {
+        _STD _Throw_system_error_from_std_win_error(_Console_print_result);
+    }
+}
+
+template <>
+struct _Fmt_iterator_flush<_Print_to_unicode_console_it> {
+    static _Print_to_unicode_console_it _Flush(
+        const char* const _First, const char* const _Last, _Print_to_unicode_console_it _Output) {
+        _STD _Print_noformat_unicode_to_console_nonlocking(_Output._Get_console_handle(), {_First, _Last});
+        return _Output;
+    }
+};
+
+inline void _Print_noformat_nonunicode(FILE* const _Stream, const string_view _Str) {
+    const _Stream_lock_guard _Guard{_Stream};
+    _STD _Print_noformat_nonunicode_nonlocking(_Stream, _Str);
+}
+
+// Format non unicode into a temporary string, then print to stream
+inline void _Vprint_nonunicode_buffered_impl(
+    const _Add_newline _Add_nl, FILE* const _Stream, const string_view _Fmt_str, const format_args _Fmt_args) {
+    string _Output_str = _STD vformat(_Fmt_str, _Fmt_args);
+    if (_Add_nl == _Add_newline::_Yes) {
+        _Output_str.push_back('\n');
+    }
+
+    _STD _Print_noformat_nonunicode(_Stream, _Output_str);
+}
+
+// Format non unicode directly into _Stream
+inline void _Vprint_nonunicode_impl(
+    const _Add_newline _Add_nl, FILE* const _Stream, const string_view _Fmt_str, const format_args _Fmt_args) {
+    const _Stream_lock_guard _Guard{_Stream};
+    _STD vformat_to(_Print_to_stream_it{_Stream}, _Fmt_str, _Fmt_args);
+    if (_Add_nl == _Add_newline::_Yes) {
+        _Print_noformat_nonunicode_nonlocking(_Stream, "\n");
+    }
+}
+
+template <class _UnicodeConsoleFn, class _FallbackFn>
+void _Do_on_maybe_unicode_console(
+    FILE* const _Stream, _UnicodeConsoleFn _Unicode_console_func, _FallbackFn _Fallback_func) {
+    const __std_unicode_console_retrieval_result _Unicode_console_retrieval_result{
+        __std_get_unicode_console_handle_from_file_stream(_Stream)};
+
+    // See the documentation for __std_unicode_console_retrieval_result to understand why we do this.
+    bool _Is_unicode_console;
+
+#pragma warning(push)
+#pragma warning(disable : 4061) // enumerator not explicitly handled by switch label
+    switch (_Unicode_console_retrieval_result._Error) {
+    case __std_win_error::_Success:
+        _Is_unicode_console = true;
+        break;
+
+    case __std_win_error::_File_not_found:
+        _Is_unicode_console = false;
+        break;
+
+    case __std_win_error::_Not_supported:
+        return;
+
+    default:
+        _STD _Throw_system_error_from_std_win_error(_Unicode_console_retrieval_result._Error);
+    }
+#pragma warning(pop)
+
+    if (_Is_unicode_console) {
+        _Unicode_console_func(_Unicode_console_retrieval_result._Console_handle);
+    } else {
+        _Fallback_func();
+    }
+}
+
+// If a unicode console, write using native API, else write to stream
+inline void _Vprint_unicode_noformat_impl(FILE* const _Stream, const string_view _Output_str) {
+    const auto _Unicode_console = [&](const __std_unicode_console_handle _Console_handle) {
+        const _Stream_lock_guard _Guard{_Stream};
+
+        const bool _Was_flush_successful = _CSTD _fflush_nolock(_Stream) == 0;
+        if (!_Was_flush_successful) {
+            _Throw_system_error(static_cast<errc>(errno));
+        }
+
+        _STD _Print_noformat_unicode_to_console_nonlocking(_Console_handle, _Output_str);
+    };
+
+    const auto _Fallback = [&] { _STD _Print_noformat_nonunicode(_Stream, _Output_str); };
+
+    _STD _Do_on_maybe_unicode_console(_Stream, _Unicode_console, _Fallback);
+}
+
+inline void _Fputc_newline(FILE* const _Stream) {
+    const bool _Was_write_successful = _CSTD fputc('\n', _Stream) == '\n';
+
+    if (!_Was_write_successful) {
+        _Throw_system_error(static_cast<errc>(errno));
+    }
+}
+
+inline void _Print_newline_only_unicode(FILE* const _Stream) {
+    const auto _Unicode_console = [&](const __std_unicode_console_handle _Console_handle) {
+        const bool _Was_flush_successful = _CSTD fflush(_Stream) == 0;
+        if (!_Was_flush_successful) {
+            _Throw_system_error(static_cast<errc>(errno));
+        }
+
+        const __std_win_error _Console_print_result = __std_print_newline_only_to_unicode_console(_Console_handle);
+        if (_Console_print_result != __std_win_error::_Success) {
+            _STD _Throw_system_error_from_std_win_error(_Console_print_result);
+        }
+    };
+
+    const auto _Fallback = [&] { _STD _Fputc_newline(_Stream); };
+
+    _STD _Do_on_maybe_unicode_console(_Stream, _Unicode_console, _Fallback);
+}
+
+// Format to intermediate string buffer, then print to unicode console/file
+inline void _Vprint_unicode_buffered_impl(
+    const _Add_newline _Add_nl, FILE* const _Stream, const string_view _Fmt_str, const format_args _Fmt_args) {
+    string _Output_str = _STD vformat(_Fmt_str, _Fmt_args);
+    if (_Add_nl == _Add_newline::_Yes) {
+        _Output_str.push_back('\n');
+    }
+    _STD _Vprint_unicode_noformat_impl(_Stream, _Output_str);
+}
+
+inline void _Vprint_unicode_impl(
+    const _Add_newline _Add_nl, FILE* const _Stream, const string_view _Fmt_str, const format_args _Fmt_args) {
+    const auto _Unicode_console = [&](const __std_unicode_console_handle _Console_handle) {
+        const _Stream_lock_guard _Guard{_Stream};
+
+        const bool _Was_flush_successful = _CSTD _fflush_nolock(_Stream) == 0;
+        if (!_Was_flush_successful) {
+            _Throw_system_error(static_cast<errc>(errno));
+        }
+
+        _STD vformat_to(_Print_to_unicode_console_it{_Console_handle}, _Fmt_str, _Fmt_args);
+        if (_Add_nl == _Add_newline::_Yes) {
+            _Print_noformat_unicode_to_console_nonlocking(_Console_handle, "\n");
+        }
+    };
+
+    const auto _Fallback = [&] { _STD _Vprint_nonunicode_impl(_Add_nl, _Stream, _Fmt_str, _Fmt_args); };
+
+    _STD _Do_on_maybe_unicode_console(_Stream, _Unicode_console, _Fallback);
+}
+
+template <class... _Types>
+void _Print_impl(
+    const _Add_newline _Add_nl, FILE* const _Stream, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    constexpr bool _Has_format_args  = sizeof...(_Types) > 0;
+    constexpr bool _Print_nonlocking = (enable_nonlocking_formatter_optimization<remove_cvref_t<_Types>> && ...);
+
+    if constexpr (_Has_format_args) {
+        if constexpr (_STD _Is_ordinary_literal_encoding_utf8()) {
+            if constexpr (_Print_nonlocking) {
+                _STD _Vprint_unicode_impl(_Add_nl, _Stream, _Fmt.get(), _STD make_format_args(_Args...));
+            } else {
+                _STD _Vprint_unicode_buffered_impl(_Add_nl, _Stream, _Fmt.get(), _STD make_format_args(_Args...));
+            }
+        } else {
+            if constexpr (_Print_nonlocking) {
+                _STD _Vprint_nonunicode_impl(_Add_nl, _Stream, _Fmt.get(), _STD make_format_args(_Args...));
+            } else {
+                _STD _Vprint_nonunicode_buffered_impl(_Add_nl, _Stream, _Fmt.get(), _STD make_format_args(_Args...));
+            }
+        }
+    } else {
+        const string _Unescaped_str{_Unescape_braces(_Add_nl, _Fmt.get())};
+
+        if constexpr (_STD _Is_ordinary_literal_encoding_utf8()) {
+            _STD _Vprint_unicode_noformat_impl(_Stream, _Unescaped_str);
+        } else {
+            _STD _Print_noformat_nonunicode(_Stream, _Unescaped_str);
+        }
+    }
+}
+
+_EXPORT_STD template <class... _Types>
+void print(FILE* const _Stream, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _STD _Print_impl(_Add_newline::_Nope, _Stream, _Fmt, _STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <class... _Types>
+void print(const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _STD print(stdout, _Fmt, _STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <class... _Types>
+void println(FILE* const _Stream, const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _STD _Print_impl(_Add_newline::_Yes, _Stream, _Fmt, _STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void println(FILE* _Stream) {
+    if constexpr (_STD _Is_ordinary_literal_encoding_utf8()) {
+        _STD _Print_newline_only_unicode(_Stream);
+    } else {
+        _STD _Fputc_newline(_Stream);
+    }
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void println() {
+    _STD println(stdout);
+}
+
+_EXPORT_STD template <class... _Types>
+void println(const format_string<_Types...> _Fmt, _Types&&... _Args) {
+    _STD println(stdout, _Fmt, _STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void vprint_unicode_buffered(FILE* const _Stream, const string_view _Fmt_str, const format_args _Fmt_args) {
+    _STD _Vprint_unicode_buffered_impl(_Add_newline::_Nope, _Stream, _Fmt_str, _Fmt_args);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void vprint_unicode_buffered(const string_view _Fmt_str, const format_args _Fmt_args) {
+    _STD vprint_unicode_buffered(stdout, _Fmt_str, _Fmt_args);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void vprint_nonunicode_buffered(FILE* const _Stream, const string_view _Fmt_str, const format_args _Fmt_args) {
+    _STD _Vprint_nonunicode_buffered_impl(_Add_newline::_Nope, _Stream, _Fmt_str, _Fmt_args);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void vprint_nonunicode_buffered(const string_view _Fmt_str, const format_args _Fmt_args) {
+    _STD vprint_nonunicode_buffered(stdout, _Fmt_str, _Fmt_args);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void vprint_unicode(FILE* const _Stream, const string_view _Fmt_str, const format_args _Fmt_args) {
+    _STD _Vprint_unicode_impl(_Add_newline::_Nope, _Stream, _Fmt_str, _Fmt_args);
+}
+
+_EXPORT_STD template <int = 0> // improves throughput, see GH-2329
+void vprint_nonunicode(FILE* const _Stream, const string_view _Fmt_str, const format_args _Fmt_args) {
+    _STD _Vprint_nonunicode_impl(_Add_newline::_Nope, _Stream, _Fmt_str, _Fmt_args);
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // ^^^ _HAS_CXX23 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _PRINT_
diff --git a/msvc-stl/stl/inc/queue b/msvc-stl/stl/inc/queue
new file mode 100644
index 0000000..68ebb5d
--- /dev/null
+++ b/msvc-stl/stl/inc/queue
@@ -0,0 +1,523 @@
+// queue standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _QUEUE_
+#define _QUEUE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#ifdef _LEGACY_CODE_ASSUMES_QUEUE_INCLUDES_ALGORITHM
+#include <algorithm>
+#else // ^^^ defined(_LEGACY_CODE_ASSUMES_QUEUE_INCLUDES_ALGORITHM) /
+      // !defined(_LEGACY_CODE_ASSUMES_QUEUE_INCLUDES_ALGORITHM) vvv
+#include <__msvc_heap_algorithms.hpp>
+#endif // ^^^ !defined(_LEGACY_CODE_ASSUMES_QUEUE_INCLUDES_ALGORITHM) ^^^
+
+#include <deque>
+#include <vector>
+
+#if _HAS_CXX23
+#include <__msvc_ranges_to.hpp>
+#include <__msvc_ranges_tuple_formatter.hpp>
+#include <iterator>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD template <class _Ty, class _Container = deque<_Ty>>
+class queue {
+public:
+    using value_type      = typename _Container::value_type;
+    using reference       = typename _Container::reference;
+    using const_reference = typename _Container::const_reference;
+    using size_type       = typename _Container::size_type;
+    using container_type  = _Container;
+
+    static_assert(is_same_v<_Ty, value_type>, "container adaptors require consistent types");
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids container adaptors of non-object types "
+                                    "because of [container.requirements].");
+
+    queue() = default;
+
+    explicit queue(const _Container& _Cont) : c(_Cont) {}
+
+    explicit queue(_Container&& _Cont) noexcept(is_nothrow_move_constructible_v<_Container>) // strengthened
+        : c(_STD move(_Cont)) {}
+
+#if _HAS_CXX23
+    template <_Iterator_for_container _InIt>
+    queue(_InIt _First, _InIt _Last) noexcept(is_nothrow_constructible_v<_Container, _InIt, _InIt>) // strengthened
+        : c(_STD move(_First), _STD move(_Last)) {}
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    queue(from_range_t, _Rng&& _Range) : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range))) {}
+#endif // _HAS_CXX23
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    explicit queue(const _Alloc& _Al) noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>) // strengthened
+        : c(_Al) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    queue(const _Container& _Cont, const _Alloc& _Al) : c(_Cont, _Al) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    queue(_Container&& _Cont, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) // strengthened
+        : c(_STD move(_Cont), _Al) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    queue(const queue& _Right, const _Alloc& _Al) : c(_Right.c, _Al) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    queue(queue&& _Right, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) // strengthened
+        : c(_STD move(_Right.c), _Al) {}
+
+#if _HAS_CXX23
+    template <_Iterator_for_container _InIt, class _Alloc>
+        requires uses_allocator_v<_Container, _Alloc>
+    queue(_InIt _First, _InIt _Last, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, _InIt, _InIt, const _Alloc&>) // strengthened
+        : c(_STD move(_First), _STD move(_Last), _Al) {}
+
+    template <_Container_compatible_range<_Ty> _Rng, class _Alloc>
+    queue(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)) {}
+#endif // _HAS_CXX23
+
+    _NODISCARD_EMPTY_MEMBER_NO_CLEAR bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
+        return c.empty();
+    }
+
+    _NODISCARD size_type size() const noexcept(noexcept(c.size())) /* strengthened */ {
+        return c.size();
+    }
+
+    _NODISCARD reference front() noexcept(noexcept(c.front())) /* strengthened */ {
+        return c.front();
+    }
+
+    _NODISCARD const_reference front() const noexcept(noexcept(c.front())) /* strengthened */ {
+        return c.front();
+    }
+
+    _NODISCARD reference back() noexcept(noexcept(c.back())) /* strengthened */ {
+        return c.back();
+    }
+
+    _NODISCARD const_reference back() const noexcept(noexcept(c.back())) /* strengthened */ {
+        return c.back();
+    }
+
+    void push(const value_type& _Val) {
+        c.push_back(_Val);
+    }
+
+    void push(value_type&& _Val) {
+        c.push_back(_STD move(_Val));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void push_range(_Rng&& _Range) {
+        if constexpr (requires { c.append_range(_STD forward<_Rng>(_Range)); }) {
+            c.append_range(_STD forward<_Rng>(_Range));
+        } else {
+            _RANGES copy(_Range, back_insert_iterator{c});
+        }
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Valty>
+    _ADAPTOR_EMPLACE_RETURN emplace(_Valty&&... _Val) {
+#if _HAS_CXX17
+        return c.emplace_back(_STD forward<_Valty>(_Val)...);
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        c.emplace_back(_STD forward<_Valty>(_Val)...);
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    void pop() noexcept(noexcept(c.pop_front())) /* strengthened */ {
+        c.pop_front();
+    }
+
+    void swap(queue& _Right) noexcept(_Is_nothrow_swappable<_Container>::value) {
+        using _STD swap;
+        swap(c, _Right.c); // intentional ADL
+    }
+
+    _NODISCARD const _Container& _Get_container() const noexcept {
+        return c;
+    }
+
+protected:
+    _Container c{};
+};
+
+#if _HAS_CXX17
+template <class _Container, enable_if_t<!_Is_allocator<_Container>::value, int> = 0>
+queue(_Container) -> queue<typename _Container::value_type, _Container>;
+
+template <class _Container, class _Alloc,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Container>>, uses_allocator<_Container, _Alloc>>, int> = 0>
+queue(_Container, _Alloc) -> queue<typename _Container::value_type, _Container>;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <_Iterator_for_container _InIt, _Allocator_for_container _Alloc = allocator<_Iter_value_t<_InIt>>>
+queue(_InIt, _InIt, _Alloc = _Alloc()) -> queue<_Iter_value_t<_InIt>, deque<_Iter_value_t<_InIt>, _Alloc>>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+queue(from_range_t, _Rng&&, _Alloc = _Alloc())
+    -> queue<_RANGES range_value_t<_Rng>, deque<_RANGES range_value_t<_Rng>, _Alloc>>;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator==(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
+    return _Left._Get_container() == _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator!=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
+    return _Left._Get_container() != _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator<(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
+    return _Left._Get_container() < _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator>(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
+    return _Left._Get_container() > _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator<=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
+    return _Left._Get_container() <= _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator>=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
+    return _Left._Get_container() >= _Right._Get_container();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, three_way_comparable _Container>
+_NODISCARD compare_three_way_result_t<_Container> operator<=>(
+    const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
+    return _Left._Get_container() <=> _Right._Get_container();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
+void swap(queue<_Ty, _Container>& _Left, queue<_Ty, _Container>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+template <class _Ty, class _Container, class _Alloc>
+struct uses_allocator<queue<_Ty, _Container>, _Alloc> : uses_allocator<_Container, _Alloc>::type {};
+
+#if _HAS_CXX23
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+template <_Format_supported_charT _CharT, class _Ty, formattable<_CharT> _Container>
+struct formatter<queue<_Ty, _Container>, _CharT>
+    : _Adaptor_formatter_base<queue<_Ty, _Container>, _CharT, _RANGES ref_view> {};
+
+template <class _Ty, class _Container>
+constexpr bool enable_nonlocking_formatter_optimization<queue<_Ty, _Container>> = false;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>
+class priority_queue {
+public:
+    using value_type      = typename _Container::value_type;
+    using reference       = typename _Container::reference;
+    using const_reference = typename _Container::const_reference;
+    using size_type       = typename _Container::size_type;
+    using container_type  = _Container;
+    using value_compare   = _Pr;
+
+    static_assert(is_same_v<_Ty, value_type>, "container adaptors require consistent types");
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids container adaptors of non-object types "
+                                    "because of [container.requirements].");
+
+    priority_queue() = default;
+
+    explicit priority_queue(const _Pr& _Pred)
+        noexcept(is_nothrow_default_constructible_v<_Container>
+                 && is_nothrow_copy_constructible_v<value_compare>) // strengthened
+        : c(), comp(_Pred) {}
+
+    priority_queue(const _Pr& _Pred, const _Container& _Cont) : c(_Cont), comp(_Pred) {
+        _Make_heap();
+    }
+
+    priority_queue(const _Pr& _Pred, _Container&& _Cont) : c(_STD move(_Cont)), comp(_Pred) {
+        _Make_heap();
+    }
+
+    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
+    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, const _Container& _Cont) : c(_Cont), comp(_Pred) {
+        c.insert(c.end(), _First, _Last);
+        _Make_heap();
+    }
+
+    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
+    priority_queue(_InIt _First, _InIt _Last) : c(_First, _Last), comp() {
+        _Make_heap();
+    }
+
+    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
+    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred) : c(_First, _Last), comp(_Pred) {
+        _Make_heap();
+    }
+
+    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
+    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, _Container&& _Cont) : c(_STD move(_Cont)), comp(_Pred) {
+        c.insert(c.end(), _First, _Last);
+        _Make_heap();
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    priority_queue(from_range_t, _Rng&& _Range, const _Pr& _Pred = _Pr())
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range))), comp(_Pred) {
+        _Make_heap();
+    }
+#endif // _HAS_CXX23
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    explicit priority_queue(const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>
+                 && is_nothrow_default_constructible_v<value_compare>) // strengthened
+        : c(_Al), comp() {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(const _Pr& _Pred, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>
+                 && is_nothrow_copy_constructible_v<value_compare>) // strengthened
+        : c(_Al), comp(_Pred) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(const _Pr& _Pred, const _Container& _Cont, const _Alloc& _Al) : c(_Cont, _Al), comp(_Pred) {
+        _Make_heap();
+    }
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(const _Pr& _Pred, _Container&& _Cont, const _Alloc& _Al) : c(_STD move(_Cont), _Al), comp(_Pred) {
+        _Make_heap();
+    }
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(const priority_queue& _Right, const _Alloc& _Al) : c(_Right.c, _Al), comp(_Right.comp) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(priority_queue&& _Right, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, _Container, const _Alloc&>
+                 && is_nothrow_move_constructible_v<value_compare>) // strengthened
+        : c(_STD move(_Right.c), _Al), comp(_STD move(_Right.comp)) {}
+
+    template <class _InIt, class _Alloc,
+        enable_if_t<_Is_iterator_v<_InIt> && uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(_InIt _First, _InIt _Last, const _Alloc& _Al) : c(_First, _Last, _Al), comp() {
+        _Make_heap();
+    }
+
+    template <class _InIt, class _Alloc,
+        enable_if_t<_Is_iterator_v<_InIt> && uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, const _Alloc& _Al)
+        : c(_First, _Last, _Al), comp(_Pred) {
+        _Make_heap();
+    }
+
+    template <class _InIt, class _Alloc,
+        enable_if_t<_Is_iterator_v<_InIt> && uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, const _Container& _Cont, const _Alloc& _Al)
+        : c(_Cont, _Al), comp(_Pred) {
+        c.insert(c.end(), _First, _Last);
+        _Make_heap();
+    }
+
+    template <class _InIt, class _Alloc,
+        enable_if_t<_Is_iterator_v<_InIt> && uses_allocator_v<_Container, _Alloc>, int> = 0>
+    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, _Container&& _Cont, const _Alloc& _Al)
+        : c(_STD move(_Cont), _Al), comp(_Pred) {
+        c.insert(c.end(), _First, _Last);
+        _Make_heap();
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng, class _Alloc>
+        requires uses_allocator_v<_Container, _Alloc>
+    priority_queue(from_range_t, _Rng&& _Range, const _Pr& _Pred, const _Alloc& _Al)
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)), comp(_Pred) {
+        _Make_heap();
+    }
+
+    template <_Container_compatible_range<_Ty> _Rng, class _Alloc>
+        requires uses_allocator_v<_Container, _Alloc>
+    priority_queue(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)), comp() {
+        _Make_heap();
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD_EMPTY_MEMBER_NO_CLEAR bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
+        return c.empty();
+    }
+
+    _NODISCARD size_type size() const noexcept(noexcept(c.size())) /* strengthened */ {
+        return c.size();
+    }
+
+    _NODISCARD const_reference top() const noexcept(noexcept(c.front())) /* strengthened */ {
+        return c.front();
+    }
+
+    void push(const value_type& _Val) {
+        c.push_back(_Val);
+        _STD push_heap(c.begin(), c.end(), _STD _Pass_fn(comp));
+    }
+
+    void push(value_type&& _Val) {
+        c.push_back(_STD move(_Val));
+        _STD push_heap(c.begin(), c.end(), _STD _Pass_fn(comp));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void push_range(_Rng&& _Range) {
+        const size_type _Old_size = c.size();
+
+        if constexpr (requires { c.append_range(_STD forward<_Rng>(_Range)); }) {
+            c.append_range(_STD forward<_Rng>(_Range));
+        } else {
+            _RANGES copy(_Range, back_insert_iterator{c});
+        }
+
+        const size_type _New_size = c.size();
+        if (_New_size / 2 > _Old_size) { // threshold chosen for performance
+            _Make_heap();
+        } else {
+            const auto _Begin = _STD _Get_unwrapped(c.begin());
+            auto _Heap_end    = _Begin + _Old_size;
+            const auto _End   = _STD _Get_unwrapped(c.end());
+            while (_Heap_end != _End) {
+                _STD push_heap(_Begin, ++_Heap_end, _STD _Pass_fn(comp));
+            }
+        }
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Valty>
+    void emplace(_Valty&&... _Val) {
+        c.emplace_back(_STD forward<_Valty>(_Val)...);
+        _STD push_heap(c.begin(), c.end(), _STD _Pass_fn(comp));
+    }
+
+    void pop() {
+        _STD pop_heap(c.begin(), c.end(), _STD _Pass_fn(comp));
+        c.pop_back();
+    }
+
+    void swap(priority_queue& _Right)
+        noexcept(_Is_nothrow_swappable<_Container>::value && _Is_nothrow_swappable<_Pr>::value) {
+        using _STD swap;
+        swap(c, _Right.c); // intentional ADL
+        swap(comp, _Right.comp); // intentional ADL
+    }
+
+private:
+    void _Make_heap() {
+        _STD make_heap(c.begin(), c.end(), _STD _Pass_fn(comp));
+    }
+
+protected:
+    _Container c{};
+    _Pr comp{};
+};
+
+#if _HAS_CXX17
+template <class _Pr, class _Container,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, negation<_Is_allocator<_Container>>>, int> = 0>
+priority_queue(_Pr, _Container) -> priority_queue<typename _Container::value_type, _Container, _Pr>;
+
+template <class _Iter, class _Pr = less<_Iter_value_t<_Iter>>, class _Container = vector<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, negation<_Is_allocator<_Container>>>,
+        int> = 0>
+priority_queue(_Iter, _Iter, _Pr = _Pr(), _Container = _Container())
+    -> priority_queue<_Iter_value_t<_Iter>, _Container, _Pr>;
+
+template <class _Pr, class _Container, class _Alloc,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, negation<_Is_allocator<_Container>>,
+                    uses_allocator<_Container, _Alloc>>,
+        int> = 0>
+priority_queue(_Pr, _Container, _Alloc) -> priority_queue<typename _Container::value_type, _Container, _Pr>;
+
+template <class _Iter, class _Alloc, class _Container = vector<_Iter_value_t<_Iter>, _Alloc>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>, uses_allocator<_Container, _Alloc>>, int> = 0>
+priority_queue(_Iter, _Iter, _Alloc) -> priority_queue<_Iter_value_t<_Iter>, _Container, less<_Iter_value_t<_Iter>>>;
+
+template <class _Iter, class _Compare, class _Alloc, class _Container = vector<_Iter_value_t<_Iter>, _Alloc>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>, uses_allocator<_Container, _Alloc>>, int> = 0>
+priority_queue(_Iter, _Iter, _Compare, _Alloc) -> priority_queue<_Iter_value_t<_Iter>, _Container, _Compare>;
+
+template <class _Iter, class _Compare, class _Container, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, uses_allocator<_Container, _Alloc>>, int> = 0>
+priority_queue(_Iter, _Iter, _Compare, _Container, _Alloc)
+    -> priority_queue<typename _Container::value_type, _Container, _Compare>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, class _Pr = less<_RANGES range_value_t<_Rng>>,
+    enable_if_t<!_Is_allocator<_Pr>::value, int> = 0>
+priority_queue(from_range_t, _Rng&&, _Pr = _Pr())
+    -> priority_queue<_RANGES range_value_t<_Rng>, vector<_RANGES range_value_t<_Rng>>, _Pr>;
+
+template <_RANGES input_range _Rng, class _Pr, class _Alloc,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+priority_queue(from_range_t, _Rng&&, _Pr, _Alloc)
+    -> priority_queue<_RANGES range_value_t<_Rng>, vector<_RANGES range_value_t<_Rng>, _Alloc>, _Pr>;
+
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+priority_queue(from_range_t, _Rng&&, _Alloc)
+    -> priority_queue<_RANGES range_value_t<_Rng>, vector<_RANGES range_value_t<_Rng>, _Alloc>>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty, class _Container, class _Pr,
+    enable_if_t<_Is_swappable<_Container>::value && _Is_swappable<_Pr>::value, int> = 0>
+void swap(priority_queue<_Ty, _Container, _Pr>& _Left, priority_queue<_Ty, _Container, _Pr>& _Right)
+    noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+template <class _Ty, class _Container, class _Pr, class _Alloc>
+struct uses_allocator<priority_queue<_Ty, _Container, _Pr>, _Alloc> : uses_allocator<_Container, _Alloc>::type {};
+
+#if _HAS_CXX23
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+template <_Format_supported_charT _CharT, class _Ty, formattable<_CharT> _Container, class _Comp>
+struct formatter<priority_queue<_Ty, _Container, _Comp>, _CharT>
+    : _Adaptor_formatter_base<priority_queue<_Ty, _Container, _Comp>, _CharT, _RANGES ref_view> {};
+
+template <class _Ty, class _Container, class _Compare>
+constexpr bool enable_nonlocking_formatter_optimization<priority_queue<_Ty, _Container, _Compare>> = false;
+#endif // _HAS_CXX23
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _QUEUE_
diff --git a/msvc-stl/stl/inc/random b/msvc-stl/stl/inc/random
new file mode 100644
index 0000000..78260d3
--- /dev/null
+++ b/msvc-stl/stl/inc/random
@@ -0,0 +1,4742 @@
+// random standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _RANDOM_
+#define _RANDOM_
+#include <yvals_core.h>
+
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_int128.hpp>
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <ios>
+#include <vector>
+#include <xbit_ops.h>
+#include <xstring>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#define _RNG_PROHIBIT_CHAR(_CheckedType)               \
+    static_assert(!_Is_character<_CheckedType>::value, \
+        "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed")
+
+#define _RNG_REQUIRE_REALTYPE(_RandType, _CheckedType)                    \
+    static_assert(_Is_any_of_v<_CheckedType, float, double, long double>, \
+        "invalid template argument for " #_RandType                       \
+        ": N4950 [rand.req.genl]/1.4 requires one of float, double, or long double")
+
+#define _RNG_REQUIRE_INTTYPE(_RandType, _CheckedType)                                                                  \
+    static_assert(_Is_any_of_v<_CheckedType, short, int, long, long long, unsigned short, unsigned int, unsigned long, \
+                      unsigned long long>,                                                                             \
+        "invalid template argument for " #_RandType                                                                    \
+        ": N4950 [rand.req.genl]/1.5 requires one of short, int, long, long long, unsigned short, unsigned int, "      \
+        "unsigned long, or unsigned long long");                                                                       \
+    _RNG_PROHIBIT_CHAR(_CheckedType)
+
+#define _RNG_REQUIRE_UINTTYPE(_RandType, _CheckedType)                                                             \
+    static_assert(_Is_any_of_v<_CheckedType, unsigned short, unsigned int, unsigned long, unsigned long long>,     \
+        "invalid template argument for " #_RandType ": N4950 [rand.req.genl]/1.6 requires one of unsigned short, " \
+        "unsigned int, unsigned long, or unsigned long long");                                                     \
+    _RNG_PROHIBIT_CHAR(_CheckedType)
+
+template <class _Seed_seq, class _Self, class _Engine = _Self>
+using _Enable_if_seed_seq_t =
+    enable_if_t<!is_convertible_v<remove_cv_t<_Seed_seq>, typename _Self::result_type>
+                    && !is_same_v<remove_cv_t<_Seed_seq>, _Self> && !is_same_v<remove_cv_t<_Seed_seq>, _Engine>,
+        int>;
+
+_INLINE_VAR constexpr long double _Pi_val = 3.14159265358979323846264338327950288L;
+_INLINE_VAR constexpr long double _Exp1   = 2.71828182845904523536028747135266250L;
+_INLINE_VAR constexpr long double _Two32  = 4294967296.0L;
+_INLINE_VAR constexpr long double _Two31  = 2147483648.0L;
+
+_INLINE_VAR constexpr int _Nwords = 4;
+
+template <class _Elem, class _Traits>
+basic_ostream<_Elem, _Traits>& _Write(
+    basic_ostream<_Elem, _Traits>& _Os, long double _Dx) { // write long double to stream
+    int _Ex           = 0;
+    long double _Frac = _CSTD frexpl(_Dx, &_Ex);
+    for (int _Nw = 0; _Nw < _Nwords; ++_Nw) { // break into 31-bit words
+        _Frac *= _Two31;
+        long _Digits = static_cast<long>(_Frac);
+        _Frac -= _Digits;
+        _Os << ' ' << _Digits;
+    }
+    _Os << ' ' << _Ex;
+    return _Os;
+}
+
+template <class _Elem, class _Traits>
+basic_istream<_Elem, _Traits>& _Read(
+    basic_istream<_Elem, _Traits>& _Is, long double& _Dx) { // read long double from stream
+    long double _Frac = 0.0;
+    long _Digits;
+    for (int _Nw = 0; _Nw < _Nwords; ++_Nw) { // accumulate 31-bit words
+        _Is >> _Digits;
+        long double _Temp = _Digits / _Two31;
+        for (int _Idx = 0; _Idx < _Nw; ++_Idx) {
+            _Temp /= _Two31;
+        }
+
+        _Frac += _Temp;
+    }
+    _Is >> _Digits;
+    _Dx = _CSTD ldexpl(_Frac, _Digits);
+    return _Is;
+}
+
+template <class _Elem, class _Traits, class _Ty>
+basic_istream<_Elem, _Traits>& _In(basic_istream<_Elem, _Traits>& _Is, _Ty& _Dx) { // read from stream
+    long double _Vx;
+    _Ty _Max = (numeric_limits<_Ty>::max)();
+    _Read(_Is, _Vx);
+    if (_CSTD fabsl(_Vx) <= _Max) {
+        _Dx = static_cast<_Ty>(_Vx);
+    } else if (_Vx < 0) {
+        _Dx = -_Max;
+    } else {
+        _Dx = _Max;
+    }
+
+    return _Is;
+}
+
+template <class _Elem, class _Traits, class _Ty>
+basic_ostream<_Elem, _Traits>& _Out(basic_ostream<_Elem, _Traits>& _Os, _Ty _Dx) { // write to stream
+    return _Write(_Os, _Dx);
+}
+
+template <class _Elem, class _Traits, class _Ty>
+class _Wrap_istream { // wrap input stream as function object
+public:
+    _Wrap_istream(basic_istream<_Elem, _Traits>& _Is) : _Str(_Is) {}
+
+    _Ty operator()() { // read next value
+        _Ty _Data;
+        _Str >> _Data;
+        if (!_Str) {
+            _Xinvalid_argument("input stream corrupted");
+        }
+
+        return _Data;
+    }
+
+    _Wrap_istream& operator=(const _Wrap_istream&) = delete;
+
+private:
+    basic_istream<_Elem, _Traits>& _Str;
+};
+
+_EXPORT_STD class seed_seq { // standard sequence of seed values
+public:
+    using result_type = unsigned int;
+
+    seed_seq() noexcept {}
+
+    template <class _Ty, enable_if_t<is_integral_v<_Ty>, int> = 0>
+    seed_seq(initializer_list<_Ty> _Ilist) {
+        _Construct(_Ilist.begin(), _Ilist.end());
+    }
+
+    template <class _InIt>
+    seed_seq(_InIt _First, _InIt _Last) {
+        _Construct(_First, _Last);
+    }
+
+    template <class _RanIt>
+    void generate(_RanIt _First, _RanIt _Last) const { // generate randomized interval from seeds
+        using _Valty = _Iter_value_t<_RanIt>;
+        static_assert(_Is_any_of_v<remove_cv_t<_Valty>, unsigned int, unsigned long, unsigned long long>,
+            "N4971 [rand.util.seedseq]/7 requires the value type of the iterator to be an unsigned type that is at "
+            "least 32-bit.");
+
+        _Adl_verify_range(_First, _Last);
+        auto _UFirst   = _Get_unwrapped(_First);
+        const auto _Nx = static_cast<size_t>(_Get_unwrapped(_Last) - _UFirst);
+
+        if (0 < _Nx) { // finite interval, fill it
+            const size_t _Sx = _Myvec.size();
+            const size_t _Tx = 623 <= _Nx ? 11 : 68 <= _Nx ? 7 : 39 <= _Nx ? 5 : 7 <= _Nx ? 3 : (_Nx - 1) / 2;
+            const size_t _Px = (_Nx - _Tx) / 2;
+            const size_t _Qx = _Px + _Tx;
+            const size_t _Mx = _Nx <= _Sx ? _Sx + 1 : _Nx;
+            size_t _Kx;
+
+            _Valty _Mask(_Valty(1) << 31);
+            _Mask <<= 1; // build 32-bit mask safely
+            _Mask -= 1;
+
+            for (_Kx = 0; _Kx < _Nx; ++_Kx) {
+                _UFirst[_Kx] = 0x8b8b8b8b;
+            }
+
+            for (_Kx = 0; _Kx < _Mx; ++_Kx) { // scramble and add any vector contributions
+                result_type _Rx1 =
+                    1664525 * _Xor27(_UFirst[_Kx % _Nx] ^ _UFirst[(_Kx + _Px) % _Nx] ^ _UFirst[(_Kx - 1) % _Nx]);
+
+                size_t _Off;
+                if (_Kx == 0) {
+                    _Off = _Sx;
+                } else if (_Kx <= _Sx) {
+                    _Off = _Kx % _Nx + _Myvec[_Kx - 1];
+                } else {
+                    _Off = _Kx % _Nx;
+                }
+                result_type _Rx2 = static_cast<result_type>((_Rx1 + _Off) & _Mask);
+
+                _UFirst[(_Kx + _Px) % _Nx] = (_UFirst[(_Kx + _Px) % _Nx] + _Rx1) & _Mask;
+                _UFirst[(_Kx + _Qx) % _Nx] = (_UFirst[(_Kx + _Qx) % _Nx] + _Rx2) & _Mask;
+                _UFirst[_Kx % _Nx]         = _Rx2;
+            }
+            for (; _Kx < _Mx + _Nx; ++_Kx) { // rescramble
+                result_type _Rx3 =
+                    1566083941 * _Xor27(_UFirst[_Kx % _Nx] + _UFirst[(_Kx + _Px) % _Nx] + _UFirst[(_Kx - 1) % _Nx]);
+                result_type _Rx4 = static_cast<result_type>((_Rx3 - _Kx % _Nx) & _Mask);
+
+                _UFirst[(_Kx + _Px) % _Nx] = (_UFirst[(_Kx + _Px) % _Nx] ^ _Rx3) & _Mask;
+                _UFirst[(_Kx + _Qx) % _Nx] = (_UFirst[(_Kx + _Qx) % _Nx] ^ _Rx4) & _Mask;
+                _UFirst[_Kx % _Nx]         = _Rx4;
+            }
+        }
+    }
+
+    template <class _OutIt>
+    void param(_OutIt _Dest) const { // copy seeds
+        _STD copy(_Myvec.begin(), _Myvec.end(), _Dest);
+    }
+
+    _NODISCARD size_t size() const noexcept { // get size of seed
+        return _Myvec.size();
+    }
+
+    seed_seq(const seed_seq&)       = delete;
+    void operator=(const seed_seq&) = delete;
+
+private:
+    template <class _InIt>
+    void _Construct(_InIt _First, _InIt _Last) {
+        for (; _First != _Last; ++_First) {
+            _Myvec.push_back(static_cast<unsigned int>(*_First));
+        }
+    }
+
+    result_type _Xor27(result_type _Val) const noexcept { // shift and merge
+        return _Val ^ (_Val >> 27);
+    }
+
+    vector<result_type> _Myvec;
+};
+
+struct _Urbg_gen_can_params {
+    bool _Rx_is_pow2 = false; // $R$ (in N4981 [rand.util.canonical]/1.2) is a power of 2
+    int _Kx          = 0; // $k$ in N4981 [rand.util.canonical]/1.4
+    uint64_t _Xx     = 0; // $x$ in N4981 [rand.util.canonical]/1.5
+    float _Scale     = 0.0f; // $r^{-d}$, always representable as a float
+    int _Smax_bits   = 0; // number of bits in $R^k$
+};
+
+_NODISCARD constexpr _Urbg_gen_can_params _Generate_canonical_params(const size_t _Bits, const uint64_t _Rm1) {
+    const auto _Rx        = _Unsigned128{_Rm1} + 1; // $R$ in N4981 [rand.util.canonical]/1.2
+    const auto _Target    = _Unsigned128{1} << _Bits; // $r^d$
+    _Unsigned128 _Product = 1;
+    _Urbg_gen_can_params _Result;
+    _Result._Rx_is_pow2 = (_Rx & (_Rx - 1)) == 0;
+    _Result._Kx         = 0;
+    while (_Product < _Target) {
+        _Product *= _Rx;
+        ++_Result._Kx;
+    }
+
+    _Result._Xx        = static_cast<uint64_t>(_Product / _Target);
+    _Result._Scale     = 1.0f / static_cast<float>(1ULL << _Bits);
+    _Result._Smax_bits = 0;
+    // $S \in [0, _Product)$
+    --_Product;
+    while (_Product > 0) {
+        ++_Result._Smax_bits;
+        _Product >>= 1;
+    }
+
+    return _Result;
+}
+
+_EXPORT_STD template <class _Real, size_t _Bits, class _Gen>
+_NODISCARD _Real generate_canonical(_Gen& _Gx) { // build a floating-point value from random sequence
+    _RNG_REQUIRE_REALTYPE(generate_canonical, _Real);
+
+    constexpr auto _Digits  = static_cast<size_t>(numeric_limits<_Real>::digits);
+    constexpr auto _Minbits = static_cast<int>(_Digits < _Bits ? _Digits : _Bits);
+
+    if constexpr (_Minbits == 0) {
+        return _Real{0};
+    } else {
+        using _Result_uint_type = conditional_t<_Minbits <= 32, uint32_t, uint64_t>;
+
+        constexpr auto _Gxmin  = (_Gen::min) ();
+        constexpr auto _Gxmax  = (_Gen::max) ();
+        constexpr auto _Params = _Generate_canonical_params(_Minbits, _Gxmax - _Gxmin);
+
+        _STL_INTERNAL_STATIC_ASSERT(_Params._Kx >= 1);
+
+        if constexpr (_Params._Rx_is_pow2) {
+            // Always needs only one attempt. Multiplications can be replaced with shift/add.
+            constexpr int _Discarded_bits = _Params._Smax_bits - _Minbits;
+            _Result_uint_type _Sx         = static_cast<_Result_uint_type>((_Gx() - _Gxmin) >> _Discarded_bits);
+
+            if constexpr (_Params._Kx > 1) {
+                constexpr int _Rx_bits = _Params._Smax_bits / _Params._Kx;
+                int _Shift             = -_Discarded_bits;
+                for (int _Idx = 1; _Idx < _Params._Kx; ++_Idx) {
+                    _Shift += _Rx_bits;
+                    _Sx += static_cast<_Result_uint_type>(_Gx() - _Gxmin) << _Shift;
+                }
+            }
+
+            return static_cast<_Real>(_Sx) * static_cast<_Real>(_Params._Scale);
+        } else {
+            using _Sx_type = conditional_t<_Params._Smax_bits <= 32, uint32_t,
+                conditional_t<_Params._Smax_bits <= 64, uint64_t, _Unsigned128>>;
+
+            constexpr auto _Rx        = _Sx_type{_Gxmax - _Gxmin} + 1u;
+            constexpr _Sx_type _Limit = static_cast<_Sx_type>(_Params._Xx) * (_Sx_type{1} << _Minbits);
+
+            _Sx_type _Sx;
+
+            do {
+                // unroll first two iterations to avoid unnecessary multiplications
+                _Sx = static_cast<_Sx_type>(_Gx() - _Gxmin);
+                if constexpr (_Params._Kx == 2) {
+                    _Sx += static_cast<_Sx_type>(_Gx() - _Gxmin) * _Rx;
+                } else if constexpr (_Params._Kx > 2) {
+                    _Sx += static_cast<_Sx_type>(_Gx() - _Gxmin) * _Rx;
+                    _Sx_type _Factor = _Rx;
+                    for (int _Idx = 2; _Idx < _Params._Kx; ++_Idx) {
+                        _Factor *= _Rx;
+                        _Sx += static_cast<_Sx_type>(_Gx() - _Gxmin) * _Factor;
+                    }
+                }
+            } while (_Sx >= _Limit);
+
+            return static_cast<_Real>(static_cast<_Result_uint_type>(_Sx / _Params._Xx))
+                 * static_cast<_Real>(_Params._Scale);
+        }
+    }
+}
+
+template <class _Real, class _Gen>
+_NODISCARD _Real _Nrand_impl(_Gen& _Gx) { // build a floating-point value from random sequence
+    _RNG_REQUIRE_REALTYPE(_Nrand_impl, _Real);
+
+    constexpr auto _Digits = static_cast<size_t>(numeric_limits<_Real>::digits);
+
+    return _STD generate_canonical<_Real, _Digits>(_Gx);
+}
+
+template <class _Uint, _Uint _Ax, _Uint _Cx, _Uint _Mx>
+_NODISCARD _Uint _Next_linear_congruential_value(_Uint _Prev) noexcept {
+    // Choose intermediate type:
+    // To use type T for the intermediate calculation, we must show
+    //  _Ax * (_Mx - 1) + _Cx <= numeric_limits<T>::max()
+    // Split _Cx:
+    //   _Cx <= numeric_limits<T>::max()
+    //   && _Ax * (_Mx - 1) <= numeric_limits<T>::max() - _Cx
+    // Divide by _Ax:
+    //   _Cx <= numeric_limits<T>::max()
+    //   && (_Mx - 1) <= (numeric_limits<T>::max() - _Cx) / _Ax
+    if constexpr (_Ax == 0) { // degenerate case; avoid divide by 0
+        return static_cast<_Uint>(_Cx); // relies on _Mx == 0 || _Cx <= _Mx, N4950 [rand.eng.lcong]/3
+    } else if constexpr (_Mx == 0) {
+        // N4950 [rand.eng.lcong]/2: "If the template parameter m is 0, the modulus m
+        // used throughout this subclause [rand.eng.lcong] is
+        // numeric_limits<result_type>::max() plus 1." That is: Just do the multiply
+        // and let normal unsigned modulo take care of it
+        return static_cast<_Uint>(static_cast<_Uint>(_Ax * _Prev) + _Cx);
+    } else if constexpr (_Cx == 0 && _Mx == 2147483647) {
+        // for minstd_rand and minstd_rand0 we can improve performance by avoiding constant divisions
+        auto _Mul = static_cast<unsigned long long>(_Prev) * _Ax;
+        _Mul      = (_Mul >> 31) + (_Mul & _Mx);
+        _Mul      = _Mul < _Mx ? _Mul : _Mul - _Mx;
+
+        return static_cast<_Uint>(_Mul);
+    } else if constexpr (_Cx <= UINT_MAX && static_cast<_Uint>(_Mx - 1) <= (UINT_MAX - _Cx) / _Ax) {
+        // unsigned int is sufficient to store intermediate calculation
+        const auto _Mul =
+            static_cast<unsigned int>(_Prev) * static_cast<unsigned int>(_Ax) + static_cast<unsigned int>(_Cx);
+        return static_cast<_Uint>(_Mul % _Mx);
+    } else if constexpr (static_cast<_Uint>(_Mx - 1) <= (ULLONG_MAX - _Cx) / _Ax) {
+        // unsigned long long is sufficient to store intermediate calculation
+        const auto _Mul = static_cast<unsigned long long>(_Prev) * _Ax + _Cx;
+        return static_cast<_Uint>(_Mul % _Mx);
+    } else { // no intermediate integral type fits; fall back to multiprecision
+        const auto _Mul = _Unsigned128{_Prev} * _Ax + _Cx;
+        return static_cast<_Uint>(_Mul % _Mx);
+    }
+}
+
+template <class _Seed_seq>
+_NODISCARD constexpr unsigned int _Seed_seq_to_uint(_Seed_seq& _Seq) {
+    unsigned int _Arr[4]{};
+    _Seq.generate(_Arr, _Arr + 4);
+    return _Arr[3];
+}
+
+template <class _Seed_seq>
+_NODISCARD constexpr unsigned long long _Seed_seq_to_ull(_Seed_seq& _Seq) {
+    unsigned int _Arr[5]{};
+    _Seq.generate(_Arr, _Arr + 5);
+    unsigned long long _Result = _Arr[4];
+    _Result <<= 32;
+    _Result |= _Arr[3];
+    return _Result;
+}
+
+template <class _Uint, _Uint _Cx, _Uint _Mx>
+_NODISCARD constexpr _Uint _Get_linear_congruential_seed(_Uint _Sx) noexcept { // N4950 [rand.eng.lcong]/5
+    if constexpr (_Mx != 0) {
+        _Sx %= _Mx;
+    }
+
+    if constexpr (_Cx == 0) {
+        if (_Sx == 0) {
+            _Sx = _Uint{1};
+        }
+    }
+
+    return _Sx;
+}
+
+template <class _Uint, _Uint _Cx, _Uint _Mx, class _Seed_seq>
+_NODISCARD _Uint _Get_linear_congruential_seed_from_seq(_Seed_seq& _Seq) { // N4950 [rand.eng.lcong]/6
+    _Uint _Sx;
+    if constexpr (_Mx == 0) {
+        if constexpr (sizeof(_Uint) <= sizeof(unsigned int)) {
+            _Sx = static_cast<_Uint>(_Seed_seq_to_uint(_Seq));
+        } else {
+            _Sx = static_cast<_Uint>(_Seed_seq_to_ull(_Seq));
+        }
+    } else if constexpr (_Mx <= UINT_MAX) {
+        _Sx = static_cast<_Uint>(_Seed_seq_to_uint(_Seq) % _Mx);
+    } else {
+        _Sx = static_cast<_Uint>(_Seed_seq_to_ull(_Seq) % _Mx);
+    }
+
+    return _Get_linear_congruential_seed<_Uint, _Cx, _Mx>(_Sx);
+}
+
+_EXPORT_STD template <class _Uint, _Uint _Ax, _Uint _Cx, _Uint _Mx>
+class linear_congruential_engine { // a linear congruential generator random engine
+public:
+    _RNG_REQUIRE_UINTTYPE(linear_congruential_engine, _Uint);
+
+    static_assert(0 == _Mx || (_Ax < _Mx && _Cx < _Mx), "invalid template argument for linear_congruential_engine");
+
+    using result_type                       = _Uint;
+    static constexpr result_type multiplier = _Ax;
+    static constexpr result_type increment  = _Cx;
+    static constexpr result_type modulus    = _Mx;
+
+    _NODISCARD static constexpr result_type(min)() noexcept /* strengthened */ {
+        // return minimum possible generated value
+        return _Cx == 0;
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 4309) // truncation of constant value
+    _NODISCARD static constexpr result_type(max)() noexcept /* strengthened */ {
+        // return maximum possible generated value
+        return static_cast<result_type>(_Mx - 1u); // note 0 wraps around to max
+    }
+#pragma warning(pop)
+
+    static constexpr result_type default_seed = 1u;
+
+    linear_congruential_engine() noexcept // strengthened
+        : _Prev(_Get_linear_congruential_seed<result_type, _Cx, _Mx>(default_seed)) {}
+
+    explicit linear_congruential_engine(result_type _Sx) noexcept // strengthened
+        : _Prev(_Get_linear_congruential_seed<result_type, _Cx, _Mx>(_Sx)) {}
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, linear_congruential_engine> = 0>
+    explicit linear_congruential_engine(_Seed_seq& _Seq)
+        : _Prev(_Get_linear_congruential_seed_from_seq<result_type, _Cx, _Mx>(_Seq)) {}
+
+    void seed(result_type _Sx = default_seed) noexcept /* strengthened */ {
+        // reset sequence from numeric value
+        _Prev = _Get_linear_congruential_seed<result_type, _Cx, _Mx>(_Sx);
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, linear_congruential_engine> = 0>
+    void seed(_Seed_seq& _Seq) { // reset sequence from seed sequence
+        _Prev = _Get_linear_congruential_seed_from_seq<result_type, _Cx, _Mx>(_Seq);
+    }
+
+    _NODISCARD _Uint operator()() noexcept {
+        _Prev = _Next_linear_congruential_value<result_type, _Ax, _Cx, _Mx>(_Prev);
+        return _Prev;
+    }
+
+    void discard(unsigned long long _Nskip) noexcept /* strengthened */ {
+        // discard _Nskip elements
+        if constexpr (_Cx == 0 && _Mx == 2147483647) {
+            // for minstd_rand and minstd_rand0 we can improve performance by
+            // performing fast exponentiation and avoiding constant divisions
+            auto _Temp = static_cast<unsigned long long>(_Prev);
+            auto _Mul  = static_cast<unsigned long long>(_Ax);
+
+            for (;;) {
+                if (_Nskip & 1) {
+                    _Temp = _Temp * _Mul;
+                    _Temp = (_Temp >> 31) + (_Temp & _Mx);
+                    _Temp = _Temp < _Mx ? _Temp : _Temp - _Mx;
+                }
+
+                if (_Nskip >>= 1) {
+                    _Mul = _Mul * _Mul;
+                    _Mul = (_Mul >> 31) + (_Mul & _Mx);
+                    _Mul = _Mul < _Mx ? _Mul : _Mul - _Mx;
+                } else {
+                    break;
+                }
+            }
+
+            _Prev = static_cast<_Uint>(_Temp);
+        } else {
+            auto _Temp = _Prev;
+
+            for (; 0 < _Nskip; --_Nskip) {
+                _Temp = _Next_linear_congruential_value<_Uint, _Ax, _Cx, _Mx>(_Temp);
+            }
+
+            _Prev = _Temp;
+        }
+    }
+
+    _NODISCARD friend bool operator==(
+        const linear_congruential_engine& _Lhs, const linear_congruential_engine& _Rhs) noexcept /* strengthened */ {
+        return _Lhs._Prev == _Rhs._Prev;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const linear_congruential_engine& _Lhs, const linear_congruential_engine& _Rhs) noexcept /* strengthened */ {
+        return _Lhs._Prev != _Rhs._Prev;
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(
+        basic_istream<_Elem, _Traits>& _Istr, linear_congruential_engine& _Eng) {
+        return _Istr >> _Eng._Prev;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(
+        basic_ostream<_Elem, _Traits>& _Ostr, const linear_congruential_engine& _Eng) {
+        return _Ostr << _Eng._Prev;
+    }
+
+private:
+    result_type _Prev;
+};
+
+template <class _Ty, size_t _Nw>
+struct _Circ_buf { // holds historical values for generators
+    _Ty _At(size_t _Ix) const noexcept {
+        return _Ax[_Base(_Ix)];
+    }
+
+    bool _Equals(const _Circ_buf& _Right) const noexcept {
+        const _Ty* _Last1 = _Ax + _Idx;
+        const _Ty* _Last2 = _Right._Ax + _Right._Idx;
+        const _Ty* _First;
+        const _Ty* _Last;
+        const _Ty* _Other;
+        bool _Use2 = _Base() < _Right._Base();
+
+        if (_Use2) { // _Right's range is higher up in the array
+                     // than ours, so scan it first
+            _First = _Right._Ax + _Right._Base();
+            _Last  = _Last2;
+            _Other = _Ax + _Base();
+        } else { // our range is higher up in the array
+                 // than _Right's, so scan ours first
+            _First = _Ax + _Base();
+            _Last  = _Last1;
+            _Other = _Right._Ax + _Right._Base();
+        }
+
+        ptrdiff_t _Nx0 = _Nw;
+        while (0 < _Nx0) { // scan
+                           // note: may need up to three passes; each scan starts at the
+                           // current highest array position and ends at the end of the
+                           // array or the _Idx value, whichever comes first; the
+                           // equality test succeeds only by reaching the _Idx value.
+            const _Ty* _Limit = _First < _Last ? _Last : _Use2 ? _Right._Ax + 2 * _Nw : _Ax + 2 * _Nw;
+            _Nx0 -= _Limit - _First;
+            while (_First != _Limit) {
+                if (*_First++ != *_Other++) {
+                    return false;
+                }
+            }
+
+            _First = _Other;
+            _Last  = _Use2 ? _Last1 : _Last2;
+            _Other = _Use2 ? _Right._Ax : _Ax;
+            _Use2  = !_Use2;
+        }
+        return true;
+    }
+
+    size_t _Base(size_t _Ix = 0) const noexcept {
+        _Ix += _Idx;
+
+        if (_Ix < _Nw) {
+            return _Ix + _Nw;
+        } else {
+            return _Ix - _Nw;
+        }
+    }
+
+    unsigned int _Idx;
+    _Ty _Ax[2 * _Nw];
+};
+
+_EXPORT_STD template <class _Ty, size_t _Wx, size_t _Sx, size_t _Rx>
+class subtract_with_carry_engine : private _Circ_buf<_Ty, _Rx> {
+private:
+    static constexpr _Ty _Mx = static_cast<_Ty>((_Ty{1} << (_Wx - 1)) << 1);
+
+    using _Cy_t  = int;
+    using _UCy_t = unsigned int;
+
+public:
+    _RNG_REQUIRE_UINTTYPE(subtract_with_carry_engine, _Ty);
+
+    static_assert(0U < _Sx && _Sx < _Rx && 0 < _Wx && _Wx <= numeric_limits<_Ty>::digits,
+        "invalid template argument for subtract_with_carry_engine");
+
+    static constexpr size_t word_size = _Wx;
+    static constexpr size_t short_lag = _Sx;
+    static constexpr size_t long_lag  = _Rx;
+
+    using result_type = _Ty;
+
+    static constexpr uint_least32_t default_seed = 19780503u;
+
+    subtract_with_carry_engine() {
+        seed(0u);
+    }
+
+    explicit subtract_with_carry_engine(_Ty _Xx0) {
+        seed(_Xx0);
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, subtract_with_carry_engine> = 0>
+    explicit subtract_with_carry_engine(_Seed_seq& _Seq) {
+        seed(_Seq);
+    }
+
+    void seed(_Ty _Value = 0u) { // set initial values from specified seed value
+        linear_congruential_engine<uint_least32_t, 40014U, 0U, 2147483563U> _Lc{
+            _Value == 0U ? default_seed : static_cast<uint_least32_t>(_Value % 2147483563U)};
+
+        constexpr int _Kx = _Get_wc();
+
+        for (size_t _Ix = 0; _Ix < _Rx; ++_Ix) { // pack _Kx words
+            this->_Ax[_Ix] = _Lc();
+            for (int _Jx = 1; _Jx < _Kx; ++_Jx) {
+                this->_Ax[_Ix] |= static_cast<_Ty>(_Lc()) << (32 * _Jx);
+            }
+        }
+
+        _Carry     = _Reduce();
+        this->_Idx = _Rx;
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, subtract_with_carry_engine> = 0>
+    void seed(_Seed_seq& _Seq) { // reset sequence from seed sequence
+        constexpr int _Kx = (8 * sizeof(_Ty) + 31) / 32;
+        unsigned long _Arr[_Kx * _Rx];
+        _Seq.generate(_STD begin(_Arr), _STD end(_Arr));
+
+        size_t _Idx0 = 0;
+        for (size_t _Ix = 0; _Ix < _Rx; ++_Ix, _Idx0 += _Kx) { // pack _Kx words
+            this->_Ax[_Ix] = _Arr[_Idx0];
+            for (int _Jx = 1; _Jx < _Kx; ++_Jx) {
+                this->_Ax[_Ix] |= static_cast<_Ty>(_Arr[_Idx0 + _Jx]) << (32 * _Jx);
+            }
+
+            if constexpr (_Mx != 0) {
+                this->_Ax[_Ix] %= _Mx;
+            }
+        }
+
+        _Carry     = _Reduce();
+        this->_Idx = _Rx;
+    }
+
+    _NODISCARD static constexpr _Ty(min)() noexcept /* strengthened */ {
+        return 0;
+    }
+
+    _NODISCARD static constexpr _Ty(max)() noexcept /* strengthened */ {
+        return _Mx - 1;
+    }
+
+    _NODISCARD friend bool operator==(
+        const subtract_with_carry_engine& _Left, const subtract_with_carry_engine& _Right) noexcept /* strengthened */ {
+        return _Left._Equals(_Right) && _Left._Carry == _Right._Carry;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const subtract_with_carry_engine& _Left, const subtract_with_carry_engine& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _NODISCARD result_type operator()() noexcept /* strengthened */ {
+        const auto _Ix = 2 * _Rx <= this->_Idx ? 0 : this->_Idx;
+        if (_Ix < _Sx) {
+            _Setx(_Ix, this->_Ax[_Ix + 2 * _Rx - _Sx], this->_Ax[_Ix + _Rx]);
+        } else if (_Ix < _Rx) {
+            _Setx(_Ix, this->_Ax[_Ix - _Sx], this->_Ax[_Ix + _Rx]);
+        } else {
+            _Setx(_Ix, this->_Ax[_Ix - _Sx], this->_Ax[_Ix - _Rx]);
+        }
+
+        this->_Idx = _Ix + 1;
+        return this->_Ax[_Ix];
+    }
+
+    void discard(unsigned long long _Nskip) {
+        for (; 0 < _Nskip; --_Nskip) {
+            (void) (*this)();
+        }
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(
+        basic_ostream<_Elem, _Traits>& _Ostr, const subtract_with_carry_engine& _Eng) {
+        const auto _Save_flags = _Ostr.flags(ios_base::dec | ios_base::left);
+        const auto _Save_fill  = _Ostr.fill(' ');
+
+        for (size_t _Ix = 0; _Ix < _Rx; ++_Ix) {
+            _Ostr << _Eng._At(_Ix) << ' ';
+        }
+
+        _Ostr << _Eng._Carry;
+
+        _Ostr.flags(_Save_flags);
+        _Ostr.fill(_Save_fill);
+        return _Ostr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(
+        basic_istream<_Elem, _Traits>& _Istr, subtract_with_carry_engine& _Eng) {
+        constexpr auto _Nx = long_lag;
+        result_type _Buffer[_Nx];
+        _Cy_t _Carry_buf;
+        const auto _Save_flags = _Istr.flags(ios_base::dec | ios_base::skipws);
+        for (auto& _Val : _Buffer) {
+            _Istr >> _Val;
+        }
+
+        _Istr >> _Carry_buf;
+        if (_Istr) {
+            for (size_t _Ix = 0; _Ix < _Nx; ++_Ix) {
+                _Eng._Ax[_Ix] = _Buffer[_Ix];
+            }
+
+            _Eng._Carry = _Carry_buf;
+            _Eng._Idx   = _Nx;
+        } else {
+            _Istr.setstate(ios_base::failbit);
+        }
+
+        _Istr.flags(_Save_flags);
+        return _Istr;
+    }
+
+private:
+    void _Setx(size_t _Ix, _Ty _Xis, _Ty _Xir) noexcept { // update _Ax[_Ix] and _Carry
+        bool _Underflowed = false;
+        _Ty _Newx         = _Xis;
+        if (_Newx < _Xir) {
+            _Underflowed = true;
+        }
+
+        _Newx -= _Xir;
+        if (_Newx < static_cast<_UCy_t>(_Carry)) {
+            _Underflowed = true;
+        }
+
+        _Newx -= _Carry;
+        if (_Underflowed) { // underflowed, so add _Mx
+            _Newx += _Mx;
+            _Carry = 1;
+        } else {
+            _Carry = 0;
+        }
+
+        this->_Ax[_Ix] = _Newx;
+    }
+
+    static constexpr int _Get_wc() noexcept { // compute number of 32-bit words per element
+        if constexpr (_Mx == 0) {
+            return (8 * sizeof(_Ty) + 31) / 32;
+        } else if constexpr (_Mx > (1ULL << 32)) {
+            return 2;
+        } else {
+            return 1;
+        }
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 4724) // potential mod by 0
+    _Cy_t _Reduce() noexcept { // reduce values to allowed range
+        if constexpr (_Mx != 0) {
+            for (size_t _Ix = 0; _Ix < _Rx; ++_Ix) {
+                this->_Ax[_Ix] %= _Mx;
+            }
+        }
+
+        return this->_Ax[_Rx - 1] == 0;
+    }
+#pragma warning(pop)
+
+    _Cy_t _Carry;
+};
+
+_EXPORT_STD template <class _Ty, size_t _Wx, size_t _Nx, size_t _Mx, size_t _Rx, _Ty _Px, size_t _Ux, _Ty _Dx,
+    size_t _Sx, _Ty _Bx, size_t _Tx, _Ty _Cx, size_t _Lx, _Ty _Fx>
+class mersenne_twister_engine : private _Circ_buf<_Ty, _Nx> {
+private:
+    static constexpr unsigned long long _Max = (((1ULL << (_Wx - 1)) - 1) << 1) + 1;
+
+public:
+    _RNG_REQUIRE_UINTTYPE(mersenne_twister_engine, _Ty);
+
+    static_assert(0 < _Mx && _Mx <= _Nx && 2U < _Wx && _Rx <= _Wx && _Ux <= _Wx && _Sx <= _Wx && _Tx <= _Wx
+                      && _Lx <= _Wx && _Wx <= numeric_limits<_Ty>::digits && _Px <= _Max && _Bx <= _Max && _Cx <= _Max
+                      && _Dx <= _Max && _Fx <= _Max,
+        "invalid template argument for mersenne_twister_engine");
+
+    using result_type = _Ty;
+
+    static constexpr size_t word_size              = _Wx;
+    static constexpr size_t state_size             = _Nx;
+    static constexpr size_t shift_size             = _Mx;
+    static constexpr size_t mask_bits              = _Rx;
+    static constexpr _Ty xor_mask                  = _Px;
+    static constexpr size_t tempering_u            = _Ux;
+    static constexpr _Ty tempering_d               = _Dx;
+    static constexpr size_t tempering_s            = _Sx;
+    static constexpr _Ty tempering_b               = _Bx;
+    static constexpr size_t tempering_t            = _Tx;
+    static constexpr _Ty tempering_c               = _Cx;
+    static constexpr size_t tempering_l            = _Lx;
+    static constexpr _Ty initialization_multiplier = _Fx;
+
+    static constexpr result_type default_seed = 5489U;
+
+    mersenne_twister_engine() {
+        seed(default_seed);
+    }
+
+    explicit mersenne_twister_engine(result_type _Xx0) {
+        seed(_Xx0);
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, mersenne_twister_engine> = 0>
+    explicit mersenne_twister_engine(_Seed_seq& _Seq) {
+        seed(_Seq);
+    }
+
+    void seed(result_type _Xx0 = default_seed) { // set initial values from specified value
+        _Ty _Prev    = _Xx0 & _WMSK;
+        this->_Ax[0] = _Prev;
+        for (size_t _Ix = 1; _Ix < _Nx; ++_Ix) {
+            _Prev          = (_Ix + _Fx * (_Prev ^ (_Prev >> (_Wx - 2)))) & _WMSK;
+            this->_Ax[_Ix] = _Prev;
+        }
+
+        this->_Idx = _Nx;
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, mersenne_twister_engine> = 0>
+    void seed(_Seed_seq& _Seq) { // reset sequence from seed sequence
+        constexpr int _Kx = (_Wx + 31) / 32;
+        unsigned long _Arr[_Kx * _Nx];
+        _Seq.generate(_STD begin(_Arr), _STD end(_Arr));
+
+        int _Idx0 = 0;
+        _Ty _Sum  = 0;
+        for (size_t _Ix = 0; _Ix < _Nx; ++_Ix, _Idx0 += _Kx) { // pack _Kx words
+            this->_Ax[_Ix] = static_cast<_Ty>(_Arr[_Idx0]);
+            for (int _Jx = 1; _Jx < _Kx; ++_Jx) {
+                this->_Ax[_Ix] |= static_cast<_Ty>(_Arr[_Idx0 + _Jx]) << (32 * _Jx);
+            }
+
+            this->_Ax[_Ix] &= _WMSK;
+
+            if (_Ix == 0) {
+                _Sum = this->_Ax[_Ix] >> _Rx;
+            } else {
+                _Sum |= this->_Ax[_Ix];
+            }
+        }
+
+        if (_Sum == 0) {
+            this->_Ax[0] = _Ty{1} << (_Wx - 1);
+        }
+
+        this->_Idx = _Nx;
+    }
+
+    _NODISCARD static constexpr result_type(min)() noexcept /* strengthened */ {
+        return 0;
+    }
+
+    _NODISCARD static constexpr result_type(max)() noexcept /* strengthened */ {
+        return _WMSK;
+    }
+
+    _NODISCARD friend bool operator==(
+        const mersenne_twister_engine& _Left, const mersenne_twister_engine& _Right) noexcept /* strengthened */ {
+        return _Left._Equals(_Right);
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const mersenne_twister_engine& _Left, const mersenne_twister_engine& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _S_Traits>
+    friend basic_istream<_Elem, _S_Traits>& operator>>(
+        basic_istream<_Elem, _S_Traits>& _Istr, mersenne_twister_engine& _Eng) {
+        _Wrap_istream<_Elem, _S_Traits, _Ty> _Gen(_Istr);
+
+        for (size_t _Ix = 0; _Ix < _Nx; ++_Ix) {
+            _Eng._Ax[_Ix] = _Gen() & _WMSK;
+        }
+
+        _Eng._Idx = _Nx;
+
+        return _Istr;
+    }
+
+    template <class _Elem, class _S_Traits>
+    friend basic_ostream<_Elem, _S_Traits>& operator<<(
+        basic_ostream<_Elem, _S_Traits>& _Ostr, const mersenne_twister_engine& _Eng) {
+        _Ostr << _Eng._At(0);
+
+        for (size_t _Ix = 1; _Ix < _Nx; ++_Ix) {
+            _Ostr << ' ' << _Eng._At(_Ix);
+        }
+
+        return _Ostr;
+    }
+
+    _NODISCARD result_type operator()() {
+        if (this->_Idx == _Nx) {
+            _Refill_upper();
+        } else if (2 * _Nx <= this->_Idx) {
+            _Refill_lower();
+        }
+
+        _Ty _Res = this->_Ax[this->_Idx++] & _WMSK;
+        _Res ^= (_Res >> _Ux) & _Dx;
+        _Res ^= (_Res << _Sx) & _Bx;
+        _Res ^= (_Res << _Tx) & _Cx;
+        _Res ^= (_Res & _WMSK) >> _Lx;
+        return _Res;
+    }
+
+    void discard(unsigned long long _Nskip) {
+        for (; 0 < _Nskip; --_Nskip) {
+            (void) (*this)();
+        }
+    }
+
+private:
+    _Post_satisfies_(this->_Idx == 0) void _Refill_lower() {
+        // compute values for the lower half of the history array
+        constexpr size_t _Wrap_bound_one = _Nx - _One_mod_n;
+        constexpr size_t _Wrap_bound_m   = _Nx - _M_mod_n;
+
+        if constexpr (_M_mod_n == 0) {
+            for (size_t _Ix = 0; _Ix < _Wrap_bound_one; ++_Ix) { // fill in values
+                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix + _Nx + _One_mod_n] & _LMSK);
+                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix + _Nx + _M_mod_n];
+            }
+
+            if constexpr (_One_mod_n == 1) { // fill in _Ax[_Nx - 1]
+                constexpr size_t _Ix = _Wrap_bound_one;
+
+                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix - _Nx + _One_mod_n] & _LMSK);
+                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix + _Nx + _M_mod_n];
+            }
+        } else {
+            for (size_t _Ix = 0; _Ix < _Wrap_bound_m; ++_Ix) { // fill in lower region
+                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix + _Nx + _One_mod_n] & _LMSK);
+                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix + _Nx + _M_mod_n];
+            }
+
+            for (size_t _Ix = _Wrap_bound_m; _Ix < _Wrap_bound_one; ++_Ix) {
+                // fill in upper region (avoids modulus operation)
+                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix + _Nx + _One_mod_n] & _LMSK);
+                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix - _Nx + _M_mod_n];
+            }
+
+            if constexpr (_One_mod_n == 1) { // fill in _Ax[_Nx - 1]
+                constexpr size_t _Ix = _Wrap_bound_one;
+
+                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix - _Nx + _One_mod_n] & _LMSK);
+                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix - _Nx + _M_mod_n];
+            }
+        }
+
+        this->_Idx = 0;
+    }
+
+    void _Refill_upper() { // compute values for the upper half of the history array
+        for (size_t _Ix = _Nx; _Ix < 2 * _Nx; ++_Ix) { // fill in values
+            const _Ty _Tmp = (this->_Ax[_Ix - _Nx] & _HMSK) | (this->_Ax[_Ix - _Nx + _One_mod_n] & _LMSK);
+            this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix - _Nx + _M_mod_n];
+        }
+    }
+
+    _Ty _Dxval{_Dx}; // TRANSITION, ABI: _Dxval must be initialized to _Dx but is unused by the current implementation
+
+    static constexpr _Ty _WMSK = ~((~_Ty{0} << (_Wx - 1)) << 1);
+    static constexpr _Ty _HMSK = (_WMSK << _Rx) & _WMSK;
+    static constexpr _Ty _LMSK = ~_HMSK & _WMSK;
+
+    static constexpr int _One_mod_n = 1 % _Nx; // either 0 or 1
+    static constexpr int _M_mod_n   = _Mx % _Nx;
+};
+
+_EXPORT_STD template <class _Engine, size_t _Px, size_t _Rx>
+class discard_block_engine {
+private:
+    using _Block_type = conditional_t<_Px <= INT_MAX, int, size_t>; // TRANSITION, ABI: Should always be size_t
+
+public:
+    static_assert(0 < _Rx && _Rx <= _Px, "invalid template argument for discard_block_engine");
+
+    using result_type = typename _Engine::result_type;
+
+    static constexpr size_t block_size = _Px;
+    static constexpr size_t used_block = _Rx;
+
+    discard_block_engine() : _Eng(), _Nx(0) {}
+
+    explicit discard_block_engine(const _Engine& _Ex) : _Eng(_Ex), _Nx(0) {}
+
+    explicit discard_block_engine(_Engine&& _Ex) : _Eng(_STD move(_Ex)), _Nx(0) {}
+
+    explicit discard_block_engine(result_type _Xx0) : _Eng(_Xx0), _Nx(0) {}
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, discard_block_engine, _Engine> = 0>
+    explicit discard_block_engine(_Seed_seq& _Seq) : _Eng(_Seq), _Nx(0) {}
+
+    void seed() {
+        _Eng.seed();
+        _Nx = 0;
+    }
+
+    void seed(result_type _Xx0) {
+        _Eng.seed(_Xx0);
+        _Nx = 0;
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, discard_block_engine> = 0>
+    void seed(_Seed_seq& _Seq) {
+        _Eng.seed(_Seq);
+        _Nx = 0;
+    }
+
+    _NODISCARD const _Engine& base() const noexcept {
+        return _Eng;
+    }
+
+    _NODISCARD result_type operator()() {
+        if (static_cast<_Block_type>(_Rx) <= _Nx) { // discard values
+            while (_Nx++ < static_cast<_Block_type>(_Px)) {
+                (void) _Eng();
+            }
+
+            _Nx = 0;
+        }
+        ++_Nx;
+        return _Eng();
+    }
+
+    void discard(unsigned long long _Nskip) {
+        for (; 0 < _Nskip; --_Nskip) {
+            (void) (*this)();
+        }
+    }
+
+    _NODISCARD static constexpr result_type(min)() noexcept /* strengthened */ {
+        return (_Engine::min) ();
+    }
+
+    _NODISCARD static constexpr result_type(max)() noexcept /* strengthened */ {
+        return (_Engine::max) ();
+    }
+
+    _NODISCARD friend bool operator==(const discard_block_engine& _Left, const discard_block_engine& _Right) {
+        return _Left._Eng == _Right._Eng && _Left._Nx == _Right._Nx;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const discard_block_engine& _Left, const discard_block_engine& _Right) {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, discard_block_engine& _Eng) {
+        return _Istr >> _Eng._Eng >> _Eng._Nx;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(
+        basic_ostream<_Elem, _Traits>& _Ostr, const discard_block_engine& _Eng) {
+        return _Ostr << _Eng._Eng << ' ' << _Eng._Nx;
+    }
+
+private:
+    _Engine _Eng;
+    _Block_type _Nx;
+};
+
+_EXPORT_STD template <class _Engine, size_t _Wx, class _UIntType>
+class independent_bits_engine { // independent_bits_engine compound engine
+public:
+    _RNG_REQUIRE_UINTTYPE(independent_bits_engine, _UIntType);
+
+    static_assert(
+        0 < _Wx && _Wx <= numeric_limits<_UIntType>::digits, "invalid template argument for independent_bits_engine");
+
+    using result_type = _UIntType;
+    using _Eres       = typename _Engine::result_type;
+
+    independent_bits_engine() {
+        _Init();
+    }
+
+    explicit independent_bits_engine(const _Engine& _Ex) : _Eng(_Ex) {
+        _Init();
+    }
+
+    explicit independent_bits_engine(_Engine&& _Ex) : _Eng(_STD move(_Ex)) {
+        _Init();
+    }
+
+    explicit independent_bits_engine(result_type _Xx0) : _Eng(static_cast<_Eres>(_Xx0)) {
+        _Init();
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, independent_bits_engine, _Engine> = 0>
+    explicit independent_bits_engine(_Seed_seq& _Seq) : _Eng(_Seq) {
+        _Init();
+    }
+
+    void seed() { // seed engine from default value
+        _Eng.seed();
+    }
+
+    void seed(result_type _Xx0) { // seed engine from specified value
+        _Eng.seed(static_cast<_Eres>(_Xx0));
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, independent_bits_engine> = 0>
+    void seed(_Seed_seq& _Seq) { // seed engine from seed sequence
+        _Eng.seed(_Seq);
+    }
+
+    _NODISCARD const _Engine& base() const noexcept {
+        return _Eng;
+    }
+
+    _NODISCARD static constexpr result_type(min)() noexcept /* strengthened */ {
+        return 0;
+    }
+
+    _NODISCARD static constexpr result_type(max)() noexcept /* strengthened */ {
+        return ((result_type{1} << (_Wx - 1)) << 1) - 1;
+    }
+
+    _NODISCARD result_type operator()() {
+        result_type _Mask = ((result_type{1} << (_Wx0 - 1)) << 1) - 1;
+        _Eres _Val;
+
+        do { // get a small enough value
+            _Val = _Eng() - (_Engine::min) ();
+        } while (_Val > _Yx0);
+        result_type _Res = static_cast<result_type>(_Val) & _Mask;
+
+        size_t _Idx = 1;
+        for (; _Idx < _Nx0; ++_Idx) { // pack _Wx0-bit values
+            do {
+                _Val = _Eng() - (_Engine::min) ();
+            } while (_Val > _Yx0);
+            _Res = (_Res << _Wx0) | (static_cast<result_type>(_Val) & _Mask);
+        }
+
+        _Mask = (_Mask << 1) | 1;
+        for (; _Idx < _Nx; ++_Idx) { // pack _Wx0+1-bit values
+            do {
+                _Val = _Eng() - (_Engine::min) ();
+            } while (_Val > _Yx1);
+            _Res = (_Res << (_Wx0 + 1)) | (static_cast<result_type>(_Val) & _Mask);
+        }
+        return _Res;
+    }
+
+    void discard(unsigned long long _Nskip) { // discard _Nskip elements
+        for (; 0 < _Nskip; --_Nskip) {
+            (void) (*this)();
+        }
+    }
+
+    _NODISCARD friend bool operator==(const independent_bits_engine& _Left, const independent_bits_engine& _Right) {
+        return _Left.base() == _Right.base();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const independent_bits_engine& _Left, const independent_bits_engine& _Right) {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        independent_bits_engine& _Eng) { // read state from _Istr
+        return _Istr >> _Eng._Eng;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const independent_bits_engine& _Eng) { // write state to _Ostr
+        return _Ostr << _Eng._Eng;
+    }
+
+private:
+    void _Init() { // compute values for operator()
+        size_t _Mx = 0;
+        _Eres _Rx  = (_Engine::max) () - (_Engine::min) () + 1;
+
+        _Eres _Tmp = _Rx;
+        if (_Tmp == 0) { // all bits used, make _Rx finite
+            _Mx = 1;
+            --_Tmp;
+        }
+        for (; 1 < _Tmp; _Tmp >>= 1) {
+            ++_Mx; // compute _Mx = floor(log2(_Rx))
+        }
+
+        for (size_t _Nfix = 0;; ++_Nfix) { // compute consistent set of parameters
+            _Nx  = (_Wx + _Mx - 1) / _Mx + _Nfix; // trial _Nx
+            _Wx0 = _Wx / _Nx;
+            _Nx0 = _Nx - _Wx % _Nx;
+            if (_Wx0 < sizeof(_Eres) * CHAR_BIT) {
+                _Yx0 = (_Rx >> _Wx0) << _Wx0;
+                _Yx1 = (((_Rx >> _Wx0) >> 1) << _Wx0) << 1;
+            } else {
+                _Yx0 = 0;
+                _Yx1 = 0;
+            }
+
+            if (_Nfix == 1 || _Rx - _Yx0 <= _Yx0 / _Nx) {
+                break; // also works if _Rx == 0 (_Mx == all bits)
+            }
+        }
+        --_Yx0;
+        --_Yx1;
+    }
+
+    _Engine _Eng; // the stored engine
+    size_t _Nx0; // number of smaller packing words
+    size_t _Nx; // total number of packing words
+    size_t _Wx0; // bits per smaller packing word
+    _Eres _Yx0; // max value for smaller packing word
+    _Eres _Yx1; // max value for larger packing word
+};
+
+_EXPORT_STD template <class _Engine, size_t _Kx>
+class shuffle_order_engine { // shuffle_order_engine compound engine
+public:
+    static_assert(0 < _Kx, "invalid template argument for shuffle_order_engine");
+
+    using result_type = typename _Engine::result_type;
+
+    static constexpr size_t table_size = _Kx;
+
+    shuffle_order_engine() {
+        _Init();
+    }
+
+    explicit shuffle_order_engine(const _Engine& _Ex) : _Eng(_Ex) {
+        _Init();
+    }
+
+    explicit shuffle_order_engine(_Engine&& _Ex) : _Eng(_STD move(_Ex)) {
+        _Init();
+    }
+
+    explicit shuffle_order_engine(result_type _Xx0) : _Eng(_Xx0) {
+        _Init();
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, shuffle_order_engine, _Engine> = 0>
+    explicit shuffle_order_engine(_Seed_seq& _Seq) : _Eng(_Seq) {
+        _Init();
+    }
+
+    void seed() { // seed engine from default value
+        _Eng.seed();
+        _Init();
+    }
+
+    void seed(result_type _Xx0) { // seed engine from specified value
+        _Eng.seed(_Xx0);
+        _Init();
+    }
+
+    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, shuffle_order_engine> = 0>
+    void seed(_Seed_seq& _Seq) { // seed engine from seed sequence
+        _Eng.seed(_Seq);
+        _Init();
+    }
+
+    _NODISCARD const _Engine& base() const noexcept {
+        return _Eng;
+    }
+
+    _NODISCARD static constexpr result_type(min)() noexcept /* strengthened */ {
+        return (_Engine::min) ();
+    }
+
+    _NODISCARD static constexpr result_type(max)() noexcept /* strengthened */ {
+        return (_Engine::max) ();
+    }
+
+    _NODISCARD result_type operator()() {
+        size_t _Idx = static_cast<size_t>(static_cast<double>(_Yx - (_Eng.min)()) * _Scale);
+
+        _Yx        = _Arr[_Idx];
+        _Arr[_Idx] = _Eng();
+        return _Yx;
+    }
+
+    void discard(unsigned long long _Nskip) { // discard _Nskip elements
+        for (; 0 < _Nskip; --_Nskip) {
+            (void) (*this)();
+        }
+    }
+
+    _NODISCARD friend bool operator==(const shuffle_order_engine& _Left, const shuffle_order_engine& _Right) {
+        return _Left.base() == _Right.base();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const shuffle_order_engine& _Left, const shuffle_order_engine& _Right) {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(
+        basic_istream<_Elem, _Traits>& _Istr, shuffle_order_engine& _Eng) { // read state from _Istr
+        _Istr >> _Eng._Eng;
+
+        for (auto& _Val : _Eng._Arr) {
+            _Istr >> _Val;
+        }
+
+        return _Istr >> _Eng._Yx;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(
+        basic_ostream<_Elem, _Traits>& _Ostr, const shuffle_order_engine& _Eng) { // write state to _Ostr
+        _Ostr << _Eng._Eng;
+
+        for (const auto& _Val : _Eng._Arr) {
+            _Ostr << ' ' << _Val;
+        }
+
+        return _Ostr << ' ' << _Eng._Yx;
+    }
+
+private:
+    void _Init() { // compute values for operator()
+        for (auto& _Val : _Arr) {
+            _Val = _Eng();
+        }
+
+        _Yx = _Eng();
+        _Scale =
+            static_cast<double>(_Kx) / (static_cast<double>((_Eng.max)()) - static_cast<double>((_Eng.min)()) + 1.0);
+    }
+
+    _Engine _Eng; // the stored engine
+    result_type _Arr[_Kx];
+    result_type _Yx;
+    double _Scale;
+};
+
+_EXPORT_STD template <class _Ty = int>
+class uniform_int_distribution { // uniform integer distribution
+public:
+    _RNG_REQUIRE_INTTYPE(uniform_int_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = uniform_int_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(0, (numeric_limits<_Ty>::max)());
+        }
+
+        explicit param_type(result_type _Min0, result_type _Max0 = (numeric_limits<_Ty>::max)()) noexcept
+        /* strengthened */ {
+            _Init(_Min0, _Max0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Min == _Right._Min && _Left._Max == _Right._Max;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD result_type a() const noexcept /* strengthened */ {
+            return _Min;
+        }
+
+        _NODISCARD result_type b() const noexcept /* strengthened */ {
+            return _Max;
+        }
+
+        void _Init(_Ty _Min0, _Ty _Max0) noexcept { // set internal state
+            _STL_ASSERT(_Min0 <= _Max0, "invalid min and max arguments for uniform_int_distribution");
+            _Min = _Min0;
+            _Max = _Max0;
+        }
+
+        result_type _Min;
+        result_type _Max;
+    };
+
+    uniform_int_distribution() noexcept // strengthened
+        : _Par(0, (numeric_limits<_Ty>::max)()) {}
+
+    explicit uniform_int_distribution(_Ty _Min0, _Ty _Max0 = (numeric_limits<_Ty>::max)()) noexcept // strengthened
+        : _Par(_Min0, _Max0) {}
+
+    explicit uniform_int_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD result_type a() const noexcept /* strengthened */ {
+        return _Par.a();
+    }
+
+    _NODISCARD result_type b() const noexcept /* strengthened */ {
+        return _Par.b();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ {
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ {
+        return _Par._Min;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ {
+        return _Par._Max;
+    }
+
+    void reset() noexcept /* strengthened */ {}
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par._Min, _Par._Max);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0._Min, _Par0._Max);
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(
+        basic_istream<_Elem, _Traits>& _Istr, uniform_int_distribution& _Dist) {
+        uniform_int_distribution::result_type _Min0;
+        uniform_int_distribution::result_type _Max0;
+        _Istr >> _Min0 >> _Max0;
+        _Dist._Par._Init(_Min0, _Max0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(
+        basic_ostream<_Elem, _Traits>& _Ostr, const uniform_int_distribution& _Dist) {
+        return _Ostr << _Dist._Par._Min << ' ' << _Dist._Par._Max;
+    }
+
+    _NODISCARD friend bool operator==(
+        const uniform_int_distribution& _Left, const uniform_int_distribution& _Right) noexcept /* strengthened */ {
+        return _Left._Par == _Right._Par;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const uniform_int_distribution& _Left, const uniform_int_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+private:
+    using _Uty = make_unsigned_t<_Ty>;
+
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, _Ty _Min, _Ty _Max) const { // compute next value in range [_Min, _Max]
+        _Rng_from_urng_v2<_Uty, _Engine> _Generator(_Eng);
+
+        const _Uty _Umin = _Adjust(static_cast<_Uty>(_Min));
+        const _Uty _Umax = _Adjust(static_cast<_Uty>(_Max));
+
+        _Uty _Uret;
+
+        if (_Umax - _Umin == static_cast<_Uty>(-1)) {
+            _Uret = static_cast<_Uty>(_Generator._Get_all_bits());
+        } else {
+            _Uret = static_cast<_Uty>(_Generator(static_cast<_Uty>(_Umax - _Umin + 1)));
+        }
+
+        return static_cast<_Ty>(_Adjust(static_cast<_Uty>(_Uret + _Umin)));
+    }
+
+    static _Uty _Adjust(_Uty _Uval) noexcept { // convert signed ranges to unsigned ranges and vice versa
+        if constexpr (is_signed_v<_Ty>) {
+            constexpr _Uty _Adjuster = (static_cast<_Uty>(-1) >> 1) + 1; // 2^(N-1)
+            return static_cast<_Uty>(_Uval ^ _Adjuster);
+        } else { // _Ty is already unsigned, do nothing
+            return _Uval;
+        }
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD class bernoulli_distribution { // class for bernoulli distribution
+public:
+    using result_type = bool;
+
+    struct param_type { // parameter package
+        using distribution_type = bernoulli_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(0.5);
+        }
+
+        explicit param_type(double _Px0) noexcept /* strengthened */ {
+            _Init(_Px0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Px == _Right._Px;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD double p() const noexcept /* strengthened */ {
+            return _Px;
+        }
+
+        void _Init(double _Px0) noexcept { // set internal state
+            _STL_ASSERT(0.0 <= _Px0 && _Px0 <= 1.0, "invalid probability argument for bernoulli_distribution");
+
+            _Px = _Px0;
+        }
+
+        double _Px;
+    };
+
+    bernoulli_distribution() noexcept // strengthened
+        : _Par(0.5) {}
+
+    explicit bernoulli_distribution(double _Px0) noexcept // strengthened
+        : _Par(_Px0) {}
+
+    explicit bernoulli_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD double p() const noexcept /* strengthened */ {
+        return _Par.p();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return false;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return true;
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const bernoulli_distribution& _Left, const bernoulli_distribution& _Right) noexcept /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const bernoulli_distribution& _Left, const bernoulli_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        bernoulli_distribution& _Dist) { // read state from _Istr
+        double _Px0;
+        _In(_Istr, _Px0);
+        _Dist._Par._Init(_Px0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const bernoulli_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Px);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        return _Nrand_impl<double>(_Eng) < _Par0._Px;
+    }
+
+    param_type _Par;
+};
+
+// Returns smallest _Flt such that static_cast<_Ty>(_Result) > _Val.
+// First truncate to largest _Flt <= _Val, then add ceil(ulp).
+
+template <class _Flt, class _Ty>
+_NODISCARD _Flt _Float_upper_bound(_Ty _Val) noexcept {
+    static_assert(is_unsigned_v<_Ty> && is_integral_v<_Ty> && is_floating_point_v<_Flt>,
+        "invalid template argument for _Float_upper_bound");
+    constexpr auto _Ty_digits  = numeric_limits<_Ty>::digits;
+    constexpr auto _Flt_digits = numeric_limits<_Flt>::digits;
+    using _Ty_32or64           = conditional_t<_Ty_digits <= 32, uint32_t, uint64_t>;
+
+    if constexpr (_Ty_digits <= _Flt_digits) {
+        return static_cast<_Flt>(_Val) + _Flt{1};
+    } else {
+#pragma warning(push)
+#pragma warning(disable : 4146 4293) // unary minus of unsigned, negative shift
+        constexpr auto _Mask = static_cast<_Ty>(-1) << (_Ty_digits - _Flt_digits);
+#ifdef _M_CEE_PURE
+        constexpr auto _Ty_32or64_digits = numeric_limits<_Ty_32or64>::digits;
+        const auto _Log_plus1            = _Ty_32or64_digits - _Countl_zero(static_cast<_Ty_32or64>(_Val | _Ty{1}));
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+        const auto _Log_plus1 = _Bit_scan_reverse(static_cast<_Ty_32or64>(_Val | _Ty{1}));
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+        const auto _Shifted_mask = _Mask >> (_Ty_digits - _Log_plus1);
+        const auto _Ceil_ulp     = _Shifted_mask & -_Shifted_mask;
+        _Val &= _Shifted_mask;
+        if (_Val == _Mask) {
+            // integer add would overflow
+            constexpr auto _Big_ulp = static_cast<_Flt>(_Mask & -_Mask);
+            return static_cast<_Flt>(_Val) + _Big_ulp;
+        } else {
+            return static_cast<_Flt>(_Val + _Ceil_ulp);
+        }
+#pragma warning(pop)
+    }
+}
+
+_EXPORT_STD template <class _Ty = int>
+class geometric_distribution { // geometric distribution
+public:
+    using _Ty1 = double;
+
+    using result_type = _Ty;
+
+    _RNG_REQUIRE_INTTYPE(geometric_distribution, _Ty);
+
+    struct param_type { // parameter package
+        using distribution_type = geometric_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty1(0.5));
+        }
+
+        explicit param_type(_Ty1 _Px0) noexcept /* strengthened */ {
+            _Init(_Px0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Px == _Right._Px;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty1 p() const noexcept /* strengthened */ {
+            return _Px;
+        }
+
+        void _Init(_Ty1 _Px0) noexcept { // initialize
+            _STL_ASSERT(0.0 < _Px0 && _Px0 < 1.0, "invalid probability argument for geometric_distribution");
+            _Px      = _Px0;
+            _Log_1_p = _CSTD log(1 - _Px);
+        }
+
+        _Ty1 _Px;
+        _Ty1 _Log_1_p;
+    };
+
+    geometric_distribution() noexcept // strengthened
+        : _Par(_Ty1(0.5)) {}
+
+    explicit geometric_distribution(_Ty1 _Px0) noexcept // strengthened
+        : _Par(_Px0) {}
+
+    explicit geometric_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty1 p() const noexcept /* strengthened */ {
+        return _Par.p();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return 0;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return (numeric_limits<result_type>::max)();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const geometric_distribution& _Left, const geometric_distribution& _Right) noexcept /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const geometric_distribution& _Left, const geometric_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        geometric_distribution& _Dist) { // read state from _Istr
+        geometric_distribution::_Ty1 _Px0;
+        _In(_Istr, _Px0);
+        _Dist._Par._Init(_Px0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const geometric_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Px);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        using _Uty = make_unsigned_t<_Ty>;
+        constexpr auto _Ty_max{(numeric_limits<_Ty>::max)()};
+        const auto _Ty1_max{_Float_upper_bound<_Ty1>(static_cast<_Uty>(_Ty_max))};
+
+        _Ty1 _Val;
+        do {
+            _Val = _CSTD log(_Nrand_impl<_Ty1>(_Eng)) / _Par0._Log_1_p;
+        } while (_Val >= _Ty1_max);
+        return static_cast<_Ty>(_Val);
+    }
+
+    param_type _Par;
+};
+
+template <class _Ty = int>
+class _Small_poisson_distribution { // poisson distribution with small mean
+public:
+    using _Ty1 = double;
+
+    template <class _Engine>
+    _NODISCARD _Ty operator()(_Engine& _Eng) const {
+        _Ty1 _Val = 1.0;
+        for (_Ty _Res = 0;; ++_Res) { // count repetitions
+            _Val *= _Nrand_impl<_Ty1>(_Eng);
+            if (_Val <= _Gx0) {
+                return _Res;
+            }
+        }
+    }
+
+    void _Init(const _Ty1& _Mean0) noexcept { // set internal state
+        _Gx0 = _CSTD exp(-_Mean0);
+    }
+
+private:
+    _Ty1 _Gx0 = 0.0;
+};
+
+_EXPORT_STD template <class _Ty = int>
+class poisson_distribution { // poisson distribution
+public:
+    using _Ty1 = double;
+
+    using result_type = _Ty;
+
+    _RNG_REQUIRE_INTTYPE(poisson_distribution, _Ty);
+
+    struct param_type { // parameter package
+        using distribution_type = poisson_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty1(1));
+        }
+
+        explicit param_type(_Ty1 _Mean0) noexcept /* strengthened */ {
+            _Init(_Mean0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Mean == _Right._Mean;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty1 mean() const noexcept /* strengthened */ {
+            return _Mean;
+        }
+
+        static constexpr double _Small_threshold = 12.0;
+
+        void _Init(_Ty1 _Mean0) noexcept { // set internal state
+            _STL_ASSERT(0.0 < _Mean0, "invalid mean argument for poisson_distribution");
+            _Mean = _Mean0;
+            if (_Mean0 < _Small_threshold) {
+                _Small._Init(_Mean0);
+                return;
+            }
+            _Sqrt = _CSTD sqrt(2.0 * _Mean0);
+            _Logm = _CSTD log(_Mean0);
+            _Gx1  = _Mean0 * _Logm - _STD lgamma(_Mean0 + 1.0);
+        }
+
+        _Ty1 _Mean = 0.0;
+        _Ty1 _Sqrt = 0.0;
+        _Ty1 _Logm = 0.0;
+        _Ty1 _Gx1  = 0.0;
+
+        _Small_poisson_distribution<_Ty> _Small;
+    };
+
+    poisson_distribution() noexcept // strengthened
+        : _Par(_Ty1(1)) {}
+
+    explicit poisson_distribution(_Ty1 _Mean0) noexcept // strengthened
+        : _Par(_Mean0) {}
+
+    explicit poisson_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty1 mean() const noexcept /* strengthened */ {
+        return _Par.mean();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return 0;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return (numeric_limits<result_type>::max)();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(const poisson_distribution& _Left, const poisson_distribution& _Right) noexcept
+    /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const poisson_distribution& _Left, const poisson_distribution& _Right) noexcept
+    /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        poisson_distribution& _Dist) { // read state from _Istr
+        poisson_distribution::_Ty1 _Mean0;
+        _In(_Istr, _Mean0);
+        _Dist._Par._Init(_Mean0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const poisson_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Mean);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        if (_Par0._Mean < param_type::_Small_threshold) {
+            return _Par0._Small(_Eng);
+        }
+
+        for (;;) { // generate and reject
+            using _Uty = make_unsigned_t<_Ty>;
+            constexpr auto _Ty_max{(numeric_limits<_Ty>::max)()};
+            const auto _Ty1_max{_Float_upper_bound<_Ty1>(static_cast<_Uty>(_Ty_max))};
+
+            _Ty _Res;
+            _Ty1 _Yx;
+            for (;;) { // generate a tentative value
+                _Yx = static_cast<_Ty1>(_CSTD tan(_Pi_val * _Nrand_impl<_Ty1>(_Eng)));
+                const _Ty1 _Mx{_Par0._Sqrt * _Yx + _Par0._Mean};
+                if (0.0 <= _Mx && _Mx < _Ty1_max) {
+                    _Res = static_cast<_Ty>(_Mx);
+                    break;
+                }
+            }
+
+            if (_Nrand_impl<_Ty1>(_Eng)
+                <= 0.9 * (1.0 + _Yx * _Yx) * _CSTD exp(_Res * _Par0._Logm - _STD lgamma(_Res + 1.0) - _Par0._Gx1)) {
+                return _Res;
+            }
+        }
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = int>
+class binomial_distribution { // binomial distribution
+public:
+    using _Ty1 = double;
+
+    using result_type = _Ty;
+
+    _RNG_REQUIRE_INTTYPE(binomial_distribution, _Ty);
+
+    struct param_type { // parameter package
+        using distribution_type = binomial_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(1, _Ty1(0.5));
+        }
+
+        explicit param_type(_Ty _Tx0, _Ty1 _Px0 = _Ty1(0.5)) noexcept /* strengthened */ {
+            _Init(_Tx0, _Px0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Tx == _Right._Tx && _Left._Px == _Right._Px;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty t() const noexcept /* strengthened */ {
+            return _Tx;
+        }
+
+        _NODISCARD _Ty1 p() const noexcept /* strengthened */ {
+            return _Px;
+        }
+
+        void _Init(_Ty _Tx0, _Ty1 _Px0) noexcept { // initialize
+            _STL_ASSERT(0.0 <= _Tx0, "invalid max argument for binomial_distribution");
+            _STL_ASSERT(0.0 <= _Px0 && _Px0 <= 1.0, "invalid probability argument for binomial_distribution");
+            _Tx    = _Tx0;
+            _Px    = _Px0;
+            _Pp    = _Px < 0.5 ? _Px : (1.0 - _Px);
+            _Mean  = _Tx * _Pp;
+            _Gx1   = _STD lgamma(_Tx + 1.0);
+            _Sqrt  = _CSTD sqrt(2 * _Mean * (1 - _Pp));
+            _Logp  = _CSTD log(_Pp);
+            _Logp1 = _CSTD log(1.0 - _Pp);
+            _Small._Init(_Mean);
+        }
+
+        _Ty _Tx;
+        _Ty1 _Px;
+        _Ty1 _Pp;
+        _Ty1 _Mean;
+        _Ty1 _Gx1;
+        _Ty1 _Sqrt;
+        _Ty1 _Logp;
+        _Ty1 _Logp1;
+
+        _Small_poisson_distribution<_Ty> _Small; // TRANSITION, ABI: unused
+    };
+
+    binomial_distribution() noexcept // strengthened
+        : _Par(1, _Ty1(0.5)) {}
+
+    explicit binomial_distribution(_Ty _Tx0, _Ty1 _Px0 = _Ty1(0.5)) noexcept // strengthened
+        : _Par(_Tx0, _Px0) {}
+
+    explicit binomial_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty t() const noexcept /* strengthened */ {
+        return _Par.t();
+    }
+
+    _NODISCARD _Ty1 p() const noexcept /* strengthened */ {
+        return _Par.p();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return 0;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return _Par.t();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(const binomial_distribution& _Left, const binomial_distribution& _Right) noexcept
+    /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const binomial_distribution& _Left, const binomial_distribution& _Right) noexcept
+    /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        binomial_distribution& _Dist) { // read state from _Istr
+        binomial_distribution::result_type _Tx0;
+        binomial_distribution::_Ty1 _Px0;
+        _In(_Istr, _Px0);
+        _In(_Istr, _Tx0);
+        _Dist._Par._Init(_Tx0, _Px0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const binomial_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Px);
+        _Out(_Ostr, _Dist._Par._Tx);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        // Press et al., Numerical Recipes in C, 2nd ed., pp 295-296.
+        _Ty _Res;
+        if (_Par0._Tx < 25) { // generate directly
+            _Res = 0;
+            for (_Ty _Ix = 0; _Ix < _Par0._Tx; ++_Ix) {
+                if (_Nrand_impl<_Ty1>(_Eng) < _Par0._Px) {
+                    ++_Res;
+                }
+            }
+
+            return _Res;
+        } else if (_Par0._Mean < 1.0) {
+            // Events are rare, use waiting time method (Luc Devroye, Non-Uniform Random Variate Generation, p. 525).
+            const _Ty1 _Rand = _Nrand_impl<_Ty1>(_Eng);
+
+            // The exit condition is log(1 - _Rand)/t < log(1-p), which is equivalent to _Rand > 1 - (1-p)^t. If
+            // we have a cheap upper bound for 1-(1-p)^t, we can exit early without having to call log. We use two
+            // such bounds, one that is tight for mean ~0 and another for mean ~1. In the first case, Bernoulli's
+            // inequality gives -1+p*t >= -(1-p)^t, so 1 - (1-p)^t <= p*t = mean. For the other bound, 1-(1-p)^t =
+            // 1-(1-p)(1-mean/t)^(t-1) <= 1-(1-p)(1-1/t)^(t-1) <= 1-(1-p)/e.
+            const _Ty1 _Ub =
+                (_STD min) (_Par0._Mean, _Ty1{3.678794411714423216e-1} * _Par0._Pp + _Ty1{6.32120558828557678e-1});
+            if (_Rand > _Ub) {
+                _Res = _Ty{0};
+            } else {
+                _Ty _Denom = _Par0._Tx;
+                _Ty1 _Sum  = _CSTD log(_Ty1{1.0} - _Rand) / _Denom;
+                while (_Sum >= _Par0._Logp1 && --_Denom != 0) {
+                    _Sum += _CSTD log(_Ty1{1.0} - _Nrand_impl<_Ty1>(_Eng)) / _Denom;
+                }
+                _Res = static_cast<_Ty>(_Par0._Tx - _Denom);
+            }
+        } else { // no shortcuts
+            using _Uty = make_unsigned_t<_Ty>;
+            const auto _Ty1_Tx{_Float_upper_bound<_Ty1>(static_cast<_Uty>(_Par0._Tx))};
+
+            for (;;) { // generate and reject
+                _Ty1 _Yx;
+                for (;;) { // generate a tentative value
+                    _Yx = static_cast<_Ty1>(_CSTD tan(_Pi_val * _Nrand_impl<_Ty1>(_Eng)));
+                    const _Ty1 _Mx{_Par0._Sqrt * _Yx + _Par0._Mean};
+                    if (0.0 <= _Mx && _Mx < _Ty1_Tx) {
+                        _Res = static_cast<_Ty>(_Mx);
+                        break;
+                    }
+                }
+                if (_Nrand_impl<_Ty1>(_Eng)
+                    <= 1.2 * _Par0._Sqrt * (1.0 + _Yx * _Yx)
+                           * _CSTD exp(_Par0._Gx1 - _STD lgamma(_Res + 1.0) - _STD lgamma(_Par0._Tx - _Res + 1.0)
+                                       + _Res * _Par0._Logp + (_Par0._Tx - _Res) * _Par0._Logp1)) {
+                    break;
+                }
+            }
+        }
+        return _Par0._Px == _Par0._Pp ? _Res : static_cast<_Ty>(_Par0._Tx - _Res);
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class uniform_real_distribution { // uniform real distribution
+public:
+    _RNG_REQUIRE_REALTYPE(uniform_real_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = uniform_real_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{0}, _Ty{1});
+        }
+
+        explicit param_type(_Ty _Min0, _Ty _Max0 = _Ty{1}) noexcept /* strengthened */ {
+            _Init(_Min0, _Max0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Min == _Right._Min && _Left._Max == _Right._Max;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD result_type a() const noexcept /* strengthened */ {
+            return _Min;
+        }
+
+        _NODISCARD result_type b() const noexcept /* strengthened */ {
+            return _Max;
+        }
+
+        void _Init(_Ty _Min0, _Ty _Max0) noexcept { // set internal state
+            _STL_ASSERT(_Min0 <= _Max0 && (0 <= _Min0 || _Max0 <= _Min0 + (numeric_limits<_Ty>::max)()),
+                "invalid min and max arguments for uniform_real_distribution");
+            _Min = _Min0;
+            _Max = _Max0;
+        }
+
+        result_type _Min;
+        result_type _Max;
+    };
+
+    uniform_real_distribution() noexcept // strengthened
+        : _Par(_Ty{0}, _Ty{1}) {}
+
+    explicit uniform_real_distribution(_Ty _Min0, _Ty _Max0 = _Ty{1}) noexcept // strengthened
+        : _Par(_Min0, _Max0) {}
+
+    explicit uniform_real_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD result_type a() const noexcept /* strengthened */ {
+        return _Par.a();
+    }
+
+    _NODISCARD result_type b() const noexcept /* strengthened */ {
+        return _Par.b();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ {
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ {
+        return _Par._Min;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ {
+        return _Par._Max;
+    }
+
+    void reset() noexcept /* strengthened */ {}
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(
+        basic_istream<_Elem, _Traits>& _Istr, uniform_real_distribution& _Dist) {
+        return _Dist._Read(_Istr);
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(
+        basic_ostream<_Elem, _Traits>& _Ostr, const uniform_real_distribution& _Dist) {
+        return _Dist._Write(_Ostr);
+    }
+
+    _NODISCARD friend bool operator==(
+        const uniform_real_distribution& _Left, const uniform_real_distribution& _Right) noexcept /* strengthened */ {
+        return _Left._Par == _Right._Par;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const uniform_real_distribution& _Left, const uniform_real_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+private:
+    template <class _Elem, class _Traits>
+    basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr
+        _Ty _Min0;
+        _Ty _Max0;
+        _In(_Istr, _Min0);
+        _In(_Istr, _Max0);
+        _Par._Init(_Min0, _Max0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr
+        _Out(_Ostr, _Par._Min);
+        _Out(_Ostr, _Par._Max);
+        return _Ostr;
+    }
+
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        return _Nrand_impl<_Ty>(_Eng) * (_Par0._Max - _Par0._Min) + _Par0._Min;
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class exponential_distribution { // exponential distribution
+public:
+    _RNG_REQUIRE_REALTYPE(exponential_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = exponential_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{1});
+        }
+
+        explicit param_type(_Ty _Lambda0) noexcept /* strengthened */ {
+            _Init(_Lambda0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Lambda == _Right._Lambda;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty lambda() const noexcept /* strengthened */ {
+            return _Lambda;
+        }
+
+        void _Init(_Ty _Lambda0) noexcept { // set internal state
+            _STL_ASSERT(0.0 < _Lambda0, "invalid lambda argument for exponential_distribution");
+            _Lambda = _Lambda0;
+        }
+
+        _Ty _Lambda;
+    };
+
+    exponential_distribution() noexcept // strengthened
+        : _Par(_Ty{1}) {}
+
+    explicit exponential_distribution(_Ty _Lambda0) noexcept // strengthened
+        : _Par(_Lambda0) {}
+
+    explicit exponential_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty lambda() const noexcept /* strengthened */ {
+        return _Par.lambda();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return 0;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const exponential_distribution& _Left, const exponential_distribution& _Right) noexcept /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const exponential_distribution& _Left, const exponential_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        exponential_distribution& _Dist) { // read state from _Istr
+        exponential_distribution::result_type _Lambda0;
+        _In(_Istr, _Lambda0);
+        _Dist._Par._Init(_Lambda0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const exponential_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Lambda);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        return -_CSTD log(_Ty{1} - _Nrand_impl<_Ty>(_Eng)) / _Par0._Lambda;
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class normal_distribution { // normal distribution
+public:
+    _RNG_REQUIRE_REALTYPE(normal_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = normal_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(0.0, 1.0);
+        }
+
+        explicit param_type(_Ty _Mean0, _Ty _Sigma0 = 1.0) noexcept /* strengthened */ {
+            _Init(_Mean0, _Sigma0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Mean == _Right._Mean && _Left._Sigma == _Right._Sigma;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty mean() const noexcept /* strengthened */ {
+            return _Mean;
+        }
+
+        _NODISCARD _Ty sigma() const noexcept /* strengthened */ {
+            return _Sigma;
+        }
+
+        _NODISCARD _Ty stddev() const noexcept /* strengthened */ {
+            return _Sigma;
+        }
+
+        void _Init(_Ty _Mean0, _Ty _Sigma0) noexcept { // set internal state
+            _STL_ASSERT(0.0 < _Sigma0, "invalid sigma argument for normal_distribution");
+            _Mean  = _Mean0;
+            _Sigma = _Sigma0;
+        }
+
+        _Ty _Mean;
+        _Ty _Sigma;
+    };
+
+    normal_distribution() noexcept // strengthened
+        : _Par(0.0, 1.0), _Valid(false), _Xx2(0) {}
+
+    explicit normal_distribution(_Ty _Mean0, _Ty _Sigma0 = 1.0) noexcept // strengthened
+        : _Par(_Mean0, _Sigma0), _Valid(false), _Xx2(0) {}
+
+    explicit normal_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0), _Valid(false), _Xx2(0) {}
+
+    _NODISCARD _Ty mean() const noexcept /* strengthened */ {
+        return _Par.mean();
+    }
+
+    _NODISCARD _Ty sigma() const noexcept /* strengthened */ {
+        return _Par.sigma();
+    }
+
+    _NODISCARD _Ty stddev() const noexcept /* strengthened */ {
+        return _Par.sigma();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+        reset();
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return -numeric_limits<result_type>::infinity();
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ { // clear internal state
+        _Valid = false;
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(const normal_distribution& _Left, const normal_distribution& _Right) noexcept
+    /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const normal_distribution& _Left, const normal_distribution& _Right) noexcept
+    /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        normal_distribution& _Dist) { // read state from _Istr
+        normal_distribution::result_type _Mean0;
+        normal_distribution::result_type _Sigma0;
+        _In(_Istr, _Mean0);
+        _In(_Istr, _Sigma0);
+        _Dist._Par._Init(_Mean0, _Sigma0);
+
+        _Istr >> _Dist._Valid;
+        _In(_Istr, _Dist._Xx2);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const normal_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Mean);
+        _Out(_Ostr, _Dist._Par._Sigma);
+
+        _Ostr << ' ' << _Dist._Valid;
+        _Out(_Ostr, _Dist._Xx2);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) {
+        // compute next value
+        // Knuth, vol. 2, p. 122, alg. P
+        _Ty _Res;
+        if (_Valid) {
+            _Res   = _Xx2;
+            _Valid = false;
+        } else { // generate two values, store one, return one
+            _Ty _Vx1;
+            _Ty _Vx2;
+            _Ty _Sx;
+            for (;;) { // reject bad values to avoid generating NaN/Inf on the next calculations
+                _Vx1 = 2 * _Nrand_impl<_Ty>(_Eng) - 1;
+                _Vx2 = 2 * _Nrand_impl<_Ty>(_Eng) - 1;
+                _Sx  = _Vx1 * _Vx1 + _Vx2 * _Vx2;
+                if (_Sx < _Ty{1} && _Vx1 != _Ty{0} && _Vx2 != _Ty{0}) {
+                    // good values!
+                    break;
+                }
+            }
+
+            _Ty _LogSx;
+            if (_Sx > _Ty{1e-4}) {
+                _LogSx = _STD log(_Sx);
+            } else {
+                // Bad _Sx value! Very small values will overflow log(_Sx) / _Sx.
+                // Generate a new value based on scaling method.
+                const _Ty _Ln2{_Ty{0.69314718055994530941723212145818}};
+                const _Ty _Maxabs{(_STD max) (_STD abs(_Vx1), _STD abs(_Vx2))};
+                const int _ExpMax{_STD ilogb(_Maxabs)};
+                _Vx1   = _STD scalbn(_Vx1, -_ExpMax);
+                _Vx2   = _STD scalbn(_Vx2, -_ExpMax);
+                _Sx    = _Vx1 * _Vx1 + _Vx2 * _Vx2;
+                _LogSx = _STD log(_Sx) + static_cast<_Ty>(_ExpMax) * (_Ln2 * 2);
+            }
+
+            const _Ty _Fx{_STD sqrt(_Ty{-2} * _LogSx / _Sx)};
+            _Xx2   = _Fx * _Vx2; // save second value for next call
+            _Valid = true;
+            _Res   = _Fx * _Vx1;
+        }
+        return _Res * _Par0._Sigma + _Par0._Mean;
+    }
+
+    param_type _Par;
+    bool _Valid;
+    _Ty _Xx2;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class gamma_distribution { // gamma distribution
+public:
+    _RNG_REQUIRE_REALTYPE(gamma_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = gamma_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{1}, _Ty{1});
+        }
+
+        explicit param_type(_Ty _Alpha0, _Ty _Beta0 = _Ty{1}) noexcept /* strengthened */ {
+            _Init(_Alpha0, _Beta0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Alpha == _Right._Alpha && _Left._Beta == _Right._Beta;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty alpha() const noexcept /* strengthened */ {
+            return _Alpha;
+        }
+
+        _NODISCARD _Ty beta() const noexcept /* strengthened */ {
+            return _Beta;
+        }
+
+        void _Init(_Ty _Alpha0, _Ty _Beta0) noexcept { // initialize
+            _STL_ASSERT(0.0 < _Alpha0, "invalid alpha argument for gamma_distribution");
+            _STL_ASSERT(0.0 < _Beta0, "invalid beta argument for gamma_distribution");
+            _Alpha = _Alpha0;
+            _Beta  = _Beta0;
+            _Px    = static_cast<_Ty>(_Exp1 / (_Alpha + _Exp1));
+            _Sqrt  = _CSTD sqrt(2 * _Alpha - 1);
+        }
+
+        _Ty _Alpha;
+        _Ty _Beta;
+        _Ty _Px;
+        _Ty _Sqrt;
+        exponential_distribution<_Ty> _Exp;
+    };
+
+    gamma_distribution() noexcept // strengthened
+        : _Par(_Ty{1}, _Ty{1}) {}
+
+    explicit gamma_distribution(_Ty _Alpha0, _Ty _Beta0 = _Ty{1}) noexcept // strengthened
+        : _Par(_Alpha0, _Beta0) {}
+
+    explicit gamma_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty alpha() const noexcept /* strengthened */ {
+        return _Par.alpha();
+    }
+
+    _NODISCARD _Ty beta() const noexcept /* strengthened */ {
+        return _Par.beta();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return result_type{0.0};
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(const gamma_distribution& _Left, const gamma_distribution& _Right) noexcept
+    /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const gamma_distribution& _Left, const gamma_distribution& _Right) noexcept
+    /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        gamma_distribution& _Dist) { // read state from _Istr
+        gamma_distribution::result_type _Alpha0;
+        gamma_distribution::result_type _Beta0;
+        _In(_Istr, _Alpha0);
+        _In(_Istr, _Beta0);
+        _Dist._Par._Init(_Alpha0, _Beta0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const gamma_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Alpha);
+        _Out(_Ostr, _Dist._Par._Beta);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, param_type _Par0) const {
+        _Ty _Ux;
+        _Ty _Vx;
+        _Ty _Xx;
+        _Ty _Yx;
+        _Ty _Qx;
+        int _Count;
+        if (_Par0._Alpha < 1) { // small values of alpha
+                                // from Knuth
+            for (;;) { // generate and reject
+                _Ux = _Nrand_impl<_Ty>(_Eng);
+                do {
+                    _Vx = _Nrand_impl<_Ty>(_Eng);
+                } while (_Vx == 0);
+
+                if (_Ux < _Par0._Px) { // small _Ux
+                    _Xx = _CSTD pow(_Vx, _Ty{1} / _Par0._Alpha);
+                    _Qx = _CSTD exp(-_Xx);
+                } else { // large _Ux
+                    _Xx = 1 - _CSTD log(_Vx);
+                    _Qx = _CSTD pow(_Xx, _Par0._Alpha - 1);
+                }
+
+                if (_Nrand_impl<_Ty>(_Eng) < _Qx) {
+                    return _Par0._Beta * _Xx;
+                }
+            }
+        }
+
+        if (_Par0._Alpha == 1) {
+            return _Par0._Beta * _Par0._Exp(_Eng);
+        }
+
+        if (_Par0._Alpha < 20.0 && (_Count = static_cast<int>(_Par0._Alpha)) == _Par0._Alpha) {
+            // _Alpha is small integer, compute directly
+            _Yx = _Nrand_impl<_Ty>(_Eng);
+            while (--_Count) { // adjust result
+                do {
+                    _Ux = _Nrand_impl<_Ty>(_Eng);
+                } while (_Ux == 0);
+
+                _Yx *= _Ux;
+            }
+            return _Par0._Beta * -_CSTD log(_Yx);
+        }
+
+        // no shortcuts
+        for (;;) { // generate and reject
+            _Yx = static_cast<_Ty>(_CSTD tan(_Pi_val * _Nrand_impl<_Ty>(_Eng)));
+            _Xx = _Par0._Sqrt * _Yx + _Par0._Alpha - 1;
+            if (0 < _Xx
+                && _Nrand_impl<_Ty>(_Eng) <= (1 + _Yx * _Yx)
+                                                 * _CSTD exp((_Par0._Alpha - 1) * _CSTD log(_Xx / (_Par0._Alpha - 1))
+                                                             - _Par0._Sqrt * _Yx)) {
+                return _Par0._Beta * _Xx;
+            }
+        }
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class weibull_distribution { // weibull distribution
+public:
+    _RNG_REQUIRE_REALTYPE(weibull_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = weibull_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{1}, _Ty{1});
+        }
+
+        explicit param_type(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) noexcept /* strengthened */ {
+            _Init(_Ax0, _Bx0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty a() const noexcept /* strengthened */ {
+            return _Ax;
+        }
+
+        _NODISCARD _Ty b() const noexcept /* strengthened */ {
+            return _Bx;
+        }
+
+        void _Init(_Ty _Ax0, _Ty _Bx0) noexcept { // initialize
+            _STL_ASSERT(0.0 < _Ax0, "invalid a argument for weibull_distribution");
+            _STL_ASSERT(0.0 < _Bx0, "invalid b argument for weibull_distribution");
+            _Ax = _Ax0;
+            _Bx = _Bx0;
+        }
+
+        _Ty _Ax;
+        _Ty _Bx;
+    };
+
+    weibull_distribution() noexcept // strengthened
+        : _Par(_Ty{1}, _Ty{1}) {}
+
+    explicit weibull_distribution(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) noexcept // strengthened
+        : _Par(_Ax0, _Bx0) {}
+
+    explicit weibull_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty a() const noexcept /* strengthened */ {
+        return _Par.a();
+    }
+
+    _NODISCARD _Ty b() const noexcept /* strengthened */ {
+        return _Par.b();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return 0;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(const weibull_distribution& _Left, const weibull_distribution& _Right) noexcept
+    /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const weibull_distribution& _Left, const weibull_distribution& _Right) noexcept
+    /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        weibull_distribution& _Dist) { // read state from _Istr
+        weibull_distribution::result_type _Ax0;
+        weibull_distribution::result_type _Bx0;
+        _In(_Istr, _Ax0);
+        _In(_Istr, _Bx0);
+        _Dist._Par._Init(_Ax0, _Bx0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const weibull_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Ax);
+        _Out(_Ostr, _Dist._Par._Bx);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { // generate pseudo-random value
+        _Ty _Px = (_Ty{1} - _Nrand_impl<_Ty>(_Eng));
+        return _Par0._Bx * _CSTD pow(-_CSTD log(_Px), _Ty{1} / _Par0._Ax);
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class extreme_value_distribution { // extreme value distribution
+public:
+    _RNG_REQUIRE_REALTYPE(extreme_value_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = extreme_value_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{0}, _Ty{1});
+        }
+
+        explicit param_type(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) noexcept /* strengthened */ {
+            _Init(_Ax0, _Bx0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty a() const noexcept /* strengthened */ {
+            return _Ax;
+        }
+
+        _NODISCARD _Ty b() const noexcept /* strengthened */ {
+            return _Bx;
+        }
+
+        void _Init(_Ty _Ax0, _Ty _Bx0) noexcept { // initialize
+            _STL_ASSERT(0.0 < _Bx0, "invalid b argument for extreme_value_distribution");
+            _Ax = _Ax0;
+            _Bx = _Bx0;
+        }
+
+        _Ty _Ax;
+        _Ty _Bx;
+    };
+
+    extreme_value_distribution() noexcept // strengthened
+        : _Par(_Ty{0}, _Ty{1}) {}
+
+    explicit extreme_value_distribution(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) noexcept // strengthened
+        : _Par(_Ax0, _Bx0) {}
+
+    explicit extreme_value_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty a() const noexcept /* strengthened */ {
+        return _Par.a();
+    }
+
+    _NODISCARD _Ty b() const noexcept /* strengthened */ {
+        return _Par.b();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return -numeric_limits<result_type>::infinity();
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const extreme_value_distribution& _Left, const extreme_value_distribution& _Right) noexcept /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const extreme_value_distribution& _Left, const extreme_value_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        extreme_value_distribution& _Dist) { // read state from _Istr
+        extreme_value_distribution::result_type _Ax0;
+        extreme_value_distribution::result_type _Bx0;
+        _In(_Istr, _Ax0);
+        _In(_Istr, _Bx0);
+        _Dist._Par._Init(_Ax0, _Bx0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const extreme_value_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Ax);
+        _Out(_Ostr, _Dist._Par._Bx);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { // generate pseudo-random value
+        _Ty _Px = _Nrand_impl<_Ty>(_Eng);
+        return _Par0._Ax - _Par0._Bx * _CSTD log(-_CSTD log(_Px));
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class lognormal_distribution { // lognormal_distribution
+public:
+    _RNG_REQUIRE_REALTYPE(lognormal_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = lognormal_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{0}, _Ty{1});
+        }
+
+        explicit param_type(_Ty _Mx0, _Ty _Sx0 = _Ty{1}) noexcept /* strengthened */ {
+            _Init(_Mx0, _Sx0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Mx == _Right._Mx && _Left._Sx == _Right._Sx;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty m() const noexcept /* strengthened */ {
+            return _Mx;
+        }
+
+        _NODISCARD _Ty s() const noexcept /* strengthened */ {
+            return _Sx;
+        }
+
+        void _Init(_Ty _Mx0, _Ty _Sx0) noexcept { // initialize
+            _STL_ASSERT(0.0 < _Sx0, "invalid s argument for lognormal_distribution");
+            _Mx = _Mx0;
+            _Sx = _Sx0;
+        }
+
+        _Ty _Mx;
+        _Ty _Sx;
+    };
+
+    lognormal_distribution() noexcept // strengthened
+        : _Par(_Ty{0}, _Ty{1}) {}
+
+    explicit lognormal_distribution(_Ty _Mx0, _Ty _Sx0 = _Ty{1}) noexcept // strengthened
+        : _Par(_Mx0, _Sx0) {}
+
+    explicit lognormal_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty m() const noexcept /* strengthened */ {
+        return _Par.m();
+    }
+
+    _NODISCARD _Ty s() const noexcept /* strengthened */ {
+        return _Par.s();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return result_type{0.0};
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const lognormal_distribution& _Left, const lognormal_distribution& _Right) noexcept /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const lognormal_distribution& _Left, const lognormal_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        lognormal_distribution& _Dist) { // read state from _Istr
+        lognormal_distribution::result_type _Mx0;
+        lognormal_distribution::result_type _Sx0;
+        _In(_Istr, _Mx0);
+        _In(_Istr, _Sx0);
+        _Dist._Par._Init(_Mx0, _Sx0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const lognormal_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Mx);
+        _Out(_Ostr, _Dist._Par._Sx);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, param_type _Par0) const { // generate pseudo-random value
+        normal_distribution<_Ty> _Dist(_Par0._Mx, _Par0._Sx);
+        return _CSTD exp(_Dist(_Eng));
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class chi_squared_distribution { // chi squared distribution
+public:
+    _RNG_REQUIRE_REALTYPE(chi_squared_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = chi_squared_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{1});
+        }
+
+        explicit param_type(_Ty _Nx0) noexcept /* strengthened */ {
+            _Init(_Nx0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Nx == _Right._Nx;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty n() const noexcept /* strengthened */ {
+            return _Nx;
+        }
+
+        void _Init(_Ty _Nx0) noexcept { // initialize
+            _STL_ASSERT(0 < _Nx0, "invalid n argument for chi_squared_distribution");
+            _Nx = _Nx0;
+        }
+
+        _Ty _Nx;
+    };
+
+    chi_squared_distribution() noexcept // strengthened
+        : _Par(_Ty{1}) {}
+
+    explicit chi_squared_distribution(_Ty _Nx0) noexcept // strengthened
+        : _Par(_Nx0) {}
+
+    explicit chi_squared_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty n() const noexcept /* strengthened */ {
+        return _Par.n();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return result_type{0.0};
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const chi_squared_distribution& _Left, const chi_squared_distribution& _Right) noexcept /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const chi_squared_distribution& _Left, const chi_squared_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        chi_squared_distribution& _Dist) { // read state from _Istr
+        chi_squared_distribution::result_type _Nx0;
+        _Istr >> _Nx0;
+        _Dist._Par._Init(_Nx0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const chi_squared_distribution& _Dist) { // write state to _Ostr
+        return _Ostr << ' ' << _Dist._Par._Nx;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        gamma_distribution<_Ty> _Dist(static_cast<_Ty>(_Par0._Nx) * static_cast<_Ty>(0.5), _Ty{2});
+        return _Dist(_Eng);
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class cauchy_distribution { // Cauchy distribution
+public:
+    _RNG_REQUIRE_REALTYPE(cauchy_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = cauchy_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{0}, _Ty{1});
+        }
+
+        explicit param_type(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) noexcept /* strengthened */ {
+            _Init(_Ax0, _Bx0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty a() const noexcept /* strengthened */ {
+            return _Ax;
+        }
+
+        _NODISCARD _Ty b() const noexcept /* strengthened */ {
+            return _Bx;
+        }
+
+        void _Init(_Ty _Ax0, _Ty _Bx0) noexcept { // initialize
+            _STL_ASSERT(0.0 < _Bx0, "invalid b argument for cauchy_distribution");
+            _Ax = _Ax0;
+            _Bx = _Bx0;
+        }
+
+        _Ty _Ax;
+        _Ty _Bx;
+    };
+
+    cauchy_distribution() noexcept // strengthened
+        : _Par(_Ty{0}, _Ty{1}) {}
+
+    explicit cauchy_distribution(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) noexcept // strengthened
+        : _Par(_Ax0, _Bx0) {}
+
+    explicit cauchy_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty a() const noexcept /* strengthened */ {
+        return _Par.a();
+    }
+
+    _NODISCARD _Ty b() const noexcept /* strengthened */ {
+        return _Par.b();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return -numeric_limits<result_type>::infinity();
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(const cauchy_distribution& _Left, const cauchy_distribution& _Right) noexcept
+    /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const cauchy_distribution& _Left, const cauchy_distribution& _Right) noexcept
+    /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        cauchy_distribution& _Dist) { // read state from _Istr
+        cauchy_distribution::result_type _Ax0;
+        cauchy_distribution::result_type _Bx0;
+        _In(_Istr, _Ax0);
+        _In(_Istr, _Bx0);
+        _Dist._Par._Init(_Ax0, _Bx0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const cauchy_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Ax);
+        _Out(_Ostr, _Dist._Par._Bx);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { // generate pseudo-random value
+        _Ty Px = _Nrand_impl<_Ty>(_Eng);
+        return static_cast<_Ty>(_Par0._Ax + _Par0._Bx * _CSTD tan(_Pi_val * (Px - static_cast<_Ty>(0.5))));
+    }
+
+    param_type _Par;
+};
+
+template <class _Ty = double>
+class _Beta_distribution { // beta distribution
+public:
+    using result_type = _Ty;
+
+    explicit _Beta_distribution(const _Ty& _Ax0 = _Ty{1}, const _Ty& _Bx0 = _Ty{1}) noexcept {
+        _Init(_Ax0, _Bx0);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) const {
+        if (_Ax < _Ty{1} && _Bx < _Ty{1}) { // look for a good value
+            _Ty _Wx;
+            _Ty _Px1;
+            _Ty _Px2;
+            for (;;) { // reject large values
+                _Px1 = _Nrand_impl<_Ty>(_Eng);
+                _Px2 = _Nrand_impl<_Ty>(_Eng);
+                _Px1 = _CSTD pow(_Px1, _Ty{1} / _Ax);
+                _Px2 = _CSTD pow(_Px2, _Ty{1} / _Bx);
+                _Wx  = _Px1 + _Px2;
+                if (_Wx <= _Ty{1} && _Wx != _Ty{0}) {
+                    break;
+                }
+            }
+            return _Px1 / _Wx;
+        } else { // use gamma distributions instead
+            _Ty _Px1;
+            _Ty _Px2;
+            _Ty _PSum;
+            gamma_distribution<_Ty> _Dist1(_Ax, 1);
+            gamma_distribution<_Ty> _Dist2(_Bx, 1);
+
+            for (;;) { // reject pairs whose sum is zero
+                _Px1  = _Dist1(_Eng);
+                _Px2  = _Dist2(_Eng);
+                _PSum = _Px1 + _Px2;
+
+                if (_PSum != _Ty{0}) {
+                    break;
+                }
+            }
+
+            return _Px1 / _PSum;
+        }
+    }
+
+private:
+    void _Init(_Ty _Ax0, _Ty _Bx0) noexcept { // initialize
+        _STL_ASSERT(0.0 < _Ax0, "invalid a argument for _Beta_distribution");
+        _STL_ASSERT(0.0 < _Bx0, "invalid b argument for _Beta_distribution");
+        _Ax = _Ax0;
+        _Bx = _Bx0;
+    }
+
+    _Ty _Ax;
+    _Ty _Bx;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class fisher_f_distribution { // fisher_f distribution
+public:
+    _RNG_REQUIRE_REALTYPE(fisher_f_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = fisher_f_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{1}, _Ty{1});
+        }
+
+        explicit param_type(_Ty _Mx0, _Ty _Nx0 = _Ty{1}) noexcept /* strengthened */ {
+            _Init(_Mx0, _Nx0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Mx == _Right._Mx && _Left._Nx == _Right._Nx;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty m() const noexcept /* strengthened */ {
+            return _Mx;
+        }
+
+        _NODISCARD _Ty n() const noexcept /* strengthened */ {
+            return _Nx;
+        }
+
+        void _Init(_Ty _Mx0, _Ty _Nx0) noexcept { // initialize
+            _STL_ASSERT(0 < _Mx0, "invalid m argument for fisher_f_distribution");
+            _STL_ASSERT(0 < _Nx0, "invalid n argument for fisher_f_distribution");
+            _Mx = _Mx0;
+            _Nx = _Nx0;
+        }
+
+        _Ty _Mx;
+        _Ty _Nx;
+    };
+
+    fisher_f_distribution() noexcept // strengthened
+        : _Par(_Ty{1}, _Ty{1}) {}
+
+    explicit fisher_f_distribution(_Ty _Mx0, _Ty _Nx0 = _Ty{1}) noexcept // strengthened
+        : _Par(_Mx0, _Nx0) {}
+
+    explicit fisher_f_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty m() const noexcept /* strengthened */ {
+        return _Par.m();
+    }
+
+    _NODISCARD _Ty n() const noexcept /* strengthened */ {
+        return _Par.n();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return result_type(0);
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(const fisher_f_distribution& _Left, const fisher_f_distribution& _Right) noexcept
+    /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const fisher_f_distribution& _Left, const fisher_f_distribution& _Right) noexcept
+    /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        fisher_f_distribution& _Dist) { // read state from _Istr
+        fisher_f_distribution::result_type _Mx0;
+        fisher_f_distribution::result_type _Nx0;
+        _Istr >> _Mx0 >> _Nx0;
+        _Dist._Par._Init(_Mx0, _Nx0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const fisher_f_distribution& _Dist) { // write state to _Ostr
+        _Ostr << ' ' << _Dist._Par._Mx << ' ' << _Dist._Par._Nx;
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        _Ty _Px;
+        _Ty _Vx1;
+        _Ty _Vx2;
+        const _Ty _Vx3{1};
+        _Vx1 = static_cast<_Ty>(_Par0._Mx) * static_cast<_Ty>(0.5);
+        _Vx2 = static_cast<_Ty>(_Par0._Nx) * static_cast<_Ty>(0.5);
+        _Beta_distribution<_Ty> _Dist(_Vx1, _Vx2);
+        for (;;) { // reject bad values
+            _Px = _Dist(_Eng);
+            if (_Px != _Vx3) {
+                break;
+            }
+        }
+
+        return (_Vx2 / _Vx1) * (_Px / (_Vx3 - _Px));
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class student_t_distribution { // student_t distribution
+public:
+    _RNG_REQUIRE_REALTYPE(student_t_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = student_t_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(_Ty{1});
+        }
+
+        explicit param_type(_Ty _Nx0) noexcept /* strengthened */ {
+            _Init(_Nx0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Nx == _Right._Nx;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty n() const noexcept /* strengthened */ {
+            return _Nx;
+        }
+
+        void _Init(_Ty _Nx0) noexcept { // initialize
+            _STL_ASSERT(0 < _Nx0, "invalid n argument for student_t_distribution");
+            _Nx = _Nx0;
+        }
+
+        _Ty _Nx;
+    };
+
+    student_t_distribution() noexcept // strengthened
+        : _Par(_Ty{1}) {}
+
+    explicit student_t_distribution(_Ty _Nx0) noexcept // strengthened
+        : _Par(_Nx0) {}
+
+    explicit student_t_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty n() const noexcept /* strengthened */ {
+        return _Par.n();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return -numeric_limits<result_type>::infinity();
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return numeric_limits<result_type>::infinity();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const student_t_distribution& _Left, const student_t_distribution& _Right) noexcept /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const student_t_distribution& _Left, const student_t_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        student_t_distribution& _Dist) { // read state from _Istr
+        student_t_distribution::result_type _Nx0;
+        _Istr >> _Nx0;
+        _Dist._Par._Init(_Nx0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const student_t_distribution& _Dist) { // write state to _Ostr
+        return _Ostr << ' ' << _Dist._Par._Nx;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        _Ty _Vx1;
+        _Ty _Vx2;
+        _Ty _Rx0;
+        _Ty _Rs;
+        uniform_real_distribution<_Ty> _Dist(-1, 1);
+        for (;;) { // get a point inside unit circle
+            _Vx1 = _Dist(_Eng);
+            _Vx2 = _Dist(_Eng);
+            _Rs  = _Vx1 * _Vx1 + _Vx2 * _Vx2;
+
+            // very small _Rs will overflow on pow(_Rx0, -_Ty{4} / _Par0._Nx)
+            if (_Rs < _Ty{1} && _Rs > _Ty{1e-12}) {
+                break;
+            }
+        }
+        _Rx0 = _STD sqrt(_Rs);
+        return _Vx1 * _STD sqrt(_Par0._Nx * (_STD pow(_Rx0, -_Ty{4} / _Par0._Nx) - _Ty{1}) / _Rs);
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = int>
+class negative_binomial_distribution { // negative binomial distribution
+public:
+    _RNG_REQUIRE_INTTYPE(negative_binomial_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = negative_binomial_distribution;
+
+        param_type() noexcept /* strengthened */ {
+            _Init(1, 0.5);
+        }
+
+        explicit param_type(_Ty _Kx0, double _Px0 = 0.5) noexcept /* strengthened */ {
+            _Init(_Kx0, _Px0);
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return _Left._Kx == _Right._Kx && _Left._Px == _Right._Px;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) noexcept
+        /* strengthened */ {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Ty k() const noexcept /* strengthened */ {
+            return _Kx;
+        }
+
+        _NODISCARD double p() const noexcept /* strengthened */ {
+            return _Px;
+        }
+
+        void _Init(_Ty _Kx0, double _Px0) noexcept { // initialize
+            _STL_ASSERT(0.0 < _Kx0, "invalid max argument for negative_binomial_distribution");
+            _STL_ASSERT(0.0 < _Px0 && _Px0 <= 1.0, "invalid probability argument for negative_binomial_distribution");
+            _Kx = _Kx0;
+            _Px = _Px0;
+        }
+
+        _Ty _Kx;
+        double _Px;
+    };
+
+    negative_binomial_distribution() noexcept // strengthened
+        : _Par(1, 0.5) {}
+
+    explicit negative_binomial_distribution(_Ty _Kx0, double _Px0 = 0.5) noexcept // strengthened
+        : _Par(_Kx0, _Px0) {}
+
+    explicit negative_binomial_distribution(const param_type& _Par0) noexcept // strengthened
+        : _Par(_Par0) {}
+
+    _NODISCARD _Ty k() const noexcept /* strengthened */ {
+        return _Par.k();
+    }
+
+    _NODISCARD double p() const noexcept /* strengthened */ {
+        return _Par.p();
+    }
+
+    _NODISCARD param_type param() const noexcept /* strengthened */ {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) noexcept /* strengthened */ { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ { // get smallest possible result
+        return 0;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ { // get largest possible result
+        return (numeric_limits<result_type>::max)();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(const negative_binomial_distribution& _Left,
+        const negative_binomial_distribution& _Right) noexcept /* strengthened */ {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const negative_binomial_distribution& _Left,
+        const negative_binomial_distribution& _Right) noexcept /* strengthened */ {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        negative_binomial_distribution& _Dist) { // read state from _Istr
+        negative_binomial_distribution::result_type _Kx0;
+        double _Px0;
+        _In(_Istr, _Px0);
+        _In(_Istr, _Kx0);
+        _Dist._Par._Init(_Kx0, _Px0);
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const negative_binomial_distribution& _Dist) { // write state to _Ostr
+        _Out(_Ostr, _Dist._Par._Px);
+        _Out(_Ostr, _Dist._Par._Kx);
+        return _Ostr;
+    }
+
+private:
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
+        double _Vx1;
+        gamma_distribution<double> _Dist1(
+            static_cast<double>(_Par0._Kx), static_cast<double>((_Ty{1} - _Par0._Px) / _Par0._Px));
+        _Vx1 = _Dist1(_Eng);
+        poisson_distribution<_Ty> _Dist2(_Vx1);
+
+        return _Dist2(_Eng);
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = int>
+class discrete_distribution { // discrete integer distribution
+public:
+    _RNG_REQUIRE_INTTYPE(discrete_distribution, _Ty);
+
+    using _Myvec      = vector<double>;
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = discrete_distribution;
+
+        param_type(_Uninitialized) noexcept {} // do-nothing constructor for derived classes
+
+        param_type() {
+            _Init();
+        }
+
+        template <class _InIt>
+        param_type(_InIt _First, _InIt _Last) : _Pvec(_First, _Last) {
+            _Init();
+        }
+
+        param_type(initializer_list<double> _Ilist) : _Pvec(_Ilist) {
+            _Init();
+        }
+
+        template <class _Fn>
+        param_type(size_t _Count, double _Low, double _High, _Fn _Func) {
+            double _Range = _High - _Low;
+            _STL_ASSERT(0.0 < _Range, "invalid range for discrete_distribution");
+            if (_Count <= 0) {
+                _Count = 1;
+            }
+
+            _Range /= static_cast<double>(_Count);
+            _Low += 0.5 * _Range; // evaluate in center of each interval
+            for (size_t _Idx = 0; _Idx < _Count; ++_Idx) {
+                _Pvec.push_back(_Func(_Low + _Idx * _Range));
+            }
+
+            _Init();
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) {
+            return _Left._Pvec == _Right._Pvec;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD _Myvec probabilities() const {
+            return _Pvec;
+        }
+
+        void _Init(const bool _Renorm = true) { // initialize
+            const size_t _Size = _Pvec.size();
+
+            if (_Renorm) {
+                if (_Pvec.empty()) {
+                    _Pvec.push_back(1.0); // make empty vector degenerate
+                } else { // normalize probabilities
+                    double _Sum = 0;
+
+                    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) { // sum all probabilities
+                        _STL_ASSERT(0.0 <= _Pvec[_Idx], "invalid probability for discrete_distribution");
+                        _Sum += _Pvec[_Idx];
+                    }
+
+                    _STL_ASSERT(0.0 < _Sum, "invalid probability vector for discrete_distribution");
+                    if (_Sum != 1.0) {
+                        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+                            _Pvec[_Idx] /= _Sum;
+                        }
+                    }
+                }
+            }
+
+            _Pcdf.assign(1, _Pvec[0]);
+            for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+                _Pcdf.push_back(_Pvec[_Idx] + _Pcdf[_Idx - 1]);
+            }
+        }
+
+        template <class _Elem, class _Traits>
+        basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr
+            size_t _Nvals;
+            _Istr >> _Nvals;
+            _Pvec.clear();
+            for (; 0 < _Nvals; --_Nvals) { // get a value and add to vector
+                double _Val;
+                _In(_Istr, _Val);
+                _Pvec.push_back(_Val);
+            }
+            _Init(false); // don't renormalize, just compute CDF
+            return _Istr;
+        }
+
+        template <class _Elem, class _Traits>
+        basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr
+            _Ostr << ' ' << _Pvec.size();
+
+            for (const auto& _Val : _Pvec) {
+                _Out(_Ostr, _Val);
+            }
+
+            return _Ostr;
+        }
+
+        _Myvec _Pvec;
+        _Myvec _Pcdf;
+    };
+
+    discrete_distribution() {}
+
+    template <class _InIt>
+    discrete_distribution(_InIt _First, _InIt _Last) : _Par(_First, _Last) {}
+
+    discrete_distribution(initializer_list<double> _Ilist) : _Par(_Ilist) {}
+
+    template <class _Fn>
+    discrete_distribution(size_t _Count, double _Low, double _High, _Fn _Func) : _Par(_Count, _Low, _High, _Func) {}
+
+    explicit discrete_distribution(const param_type& _Par0) : _Par(_Par0) {}
+
+    _NODISCARD _Myvec probabilities() const {
+        return _Par.probabilities();
+    }
+
+    _NODISCARD param_type param() const {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ {
+        return 0;
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ {
+        return static_cast<result_type>(_Par._Pvec.size() - 1);
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    // reused by piecewise_constant_distribution and piecewise_linear_distribution
+    template <class _Engine>
+    _NODISCARD static result_type _Invoke_param_pcdf(_Engine& _Eng, const _Myvec& _Pcdf) {
+        const double _Px     = _STD _Nrand_impl<double>(_Eng);
+        const auto _First    = _Pcdf.begin();
+        const auto _Position = _STD lower_bound(_First, _STD _Prev_iter(_Pcdf.end()), _Px);
+        return static_cast<result_type>(_Position - _First);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Invoke_param_pcdf(_Eng, _Par._Pcdf);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Invoke_param_pcdf(_Eng, _Par0._Pcdf);
+    }
+
+    _NODISCARD friend bool operator==(const discrete_distribution& _Left, const discrete_distribution& _Right) {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const discrete_distribution& _Left, const discrete_distribution& _Right) {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        discrete_distribution& _Dist) { // read state from _Istr
+        return _Dist._Par._Read(_Istr);
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const discrete_distribution& _Dist) { // write state to _Ostr
+        return _Dist._Par._Write(_Ostr);
+    }
+
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class piecewise_constant_distribution { // piecewise constant floating-point distribution
+public:
+    _RNG_REQUIRE_REALTYPE(piecewise_constant_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = piecewise_constant_distribution;
+
+        param_type() : _Bvec{0, 1} {}
+
+        template <class _InIt1, class _InIt2>
+        param_type(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2) : _Base_params(_Noinit), _Bvec(_First1, _Last1) {
+            if (2 <= _Bvec.size()) {
+                for (size_t _Idx = 0; _Idx < _Bvec.size() - 1; ++_Idx) {
+                    _Base_params._Pvec.push_back(static_cast<double>(*_First2++));
+                }
+            } else { // default construct
+                _Bvec = {0, 1};
+            }
+
+            _Init();
+        }
+
+        template <class _Fn>
+        param_type(initializer_list<_Ty> _Ilist, _Fn _Func) : _Base_params(_Noinit) {
+            if (2 <= _Ilist.size()) {
+                _Bvec.assign(_Ilist);
+
+                for (size_t _Idx = 0; _Idx < _Bvec.size() - 1; ++_Idx) {
+                    _Base_params._Pvec.push_back(_Func(_Ty{0.5} * (_Bvec[_Idx] + _Bvec[_Idx + 1])));
+                }
+            } else { // default construct
+                _Bvec = {0, 1};
+            }
+
+            _Init();
+        }
+
+        template <class _Fn>
+        param_type(size_t _Count, _Ty _Low, _Ty _High, _Fn _Func) : _Base_params(_Count, _Low, _High, _Func) {
+            _Ty _Range = _High - _Low;
+            if (_Count <= 0) {
+                _Count = 1;
+            }
+
+            _Range /= static_cast<_Ty>(_Count);
+            for (size_t _Idx = 0; _Idx <= _Count; ++_Idx) {
+                _Bvec.push_back(_Low + _Idx * _Range);
+            }
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) {
+            return _Left._Base_params == _Right._Base_params && _Left._Bvec == _Right._Bvec;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD vector<_Ty> intervals() const {
+            return _Bvec;
+        }
+
+#pragma warning(push)
+#pragma warning(disable : 4244) // '%s': conversion from '%s' to '%s', possible loss of data
+        _NODISCARD vector<_Ty> densities() const {
+            vector<_Ty> _Ans(_Base_params._Pvec.begin(), _Base_params._Pvec.end());
+
+            for (size_t _Idx = 0; _Idx < _Ans.size(); ++_Idx) {
+                _Ans[_Idx] /= _Bvec[_Idx + 1] - _Bvec[_Idx];
+            }
+
+            return _Ans;
+        }
+#pragma warning(pop)
+
+        void _Init() { // initialize
+            _Base_params._Init();
+        }
+
+        discrete_distribution<size_t>::param_type _Base_params;
+        vector<_Ty> _Bvec;
+    };
+
+    piecewise_constant_distribution() {}
+
+    template <class _InIt1, class _InIt2>
+    piecewise_constant_distribution(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2) : _Par(_First1, _Last1, _First2) {}
+
+    template <class _Fn>
+    piecewise_constant_distribution(initializer_list<_Ty> _Ilist, _Fn _Func) : _Par(_Ilist, _Func) {}
+
+    template <class _Fn>
+    piecewise_constant_distribution(size_t _Count, _Ty _Low, _Ty _High, _Fn _Func) : _Par(_Count, _Low, _High, _Func) {}
+
+    explicit piecewise_constant_distribution(const param_type& _Par0) : _Par(_Par0) {}
+
+    _NODISCARD vector<_Ty> intervals() const {
+        return _Par.intervals();
+    }
+
+    _NODISCARD vector<_Ty> densities() const {
+        return _Par.densities();
+    }
+
+    _NODISCARD param_type param() const {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const {
+        return _Par._Bvec.front();
+    }
+
+    _NODISCARD result_type(max)() const {
+        return _Par._Bvec.back();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const piecewise_constant_distribution& _Left, const piecewise_constant_distribution& _Right) {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const piecewise_constant_distribution& _Left, const piecewise_constant_distribution& _Right) {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        piecewise_constant_distribution& _Dist) { // read state from _Istr
+        _Dist._Par._Base_params._Read(_Istr);
+
+        _Dist._Par._Bvec.clear();
+        for (size_t _Idx = _Dist._Par._Base_params._Pvec.size() + 1; 0 < _Idx; --_Idx) {
+            // get a value and add to intervals vector
+            double _Val;
+            _In(_Istr, _Val);
+            _Dist._Par._Bvec.push_back(_Val);
+        }
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const piecewise_constant_distribution& _Dist) { // write state to _Ostr
+        _Dist._Par._Base_params._Write(_Ostr);
+
+        for (const auto& _Val : _Dist._Par._Bvec) {
+            _Out(_Ostr, _Val);
+        }
+
+        return _Ostr;
+    }
+
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) {
+        size_t _Px = discrete_distribution<size_t>::_Invoke_param_pcdf(_Eng, _Par0._Base_params._Pcdf);
+        uniform_real_distribution<_Ty> _Dist(_Par0._Bvec[_Px], _Par0._Bvec[_Px + 1]);
+        return _Dist(_Eng);
+    }
+
+    discrete_distribution<size_t> _Unused; // TRANSITION, ABI: this was a base class subobject
+    param_type _Par;
+};
+
+_EXPORT_STD template <class _Ty = double>
+class piecewise_linear_distribution { // piecewise linear floating-point distribution
+public:
+    _RNG_REQUIRE_REALTYPE(piecewise_linear_distribution, _Ty);
+
+    using result_type = _Ty;
+
+    struct param_type { // parameter package
+        using distribution_type = piecewise_linear_distribution;
+
+        param_type() {
+            _Init_base();
+            _Pvec.push_back(1.0);
+            _Bvec = {0, 1};
+        }
+
+        template <class _InIt1, class _InIt2>
+        param_type(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2) : _Bvec(_First1, _Last1) {
+            if (2 <= _Bvec.size()) {
+                for (size_t _Idx = 0; _Idx < _Bvec.size(); ++_Idx) {
+                    _Pvec.push_back(static_cast<double>(*_First2++));
+                }
+            } else { // default construct
+                _Bvec = {0, 1};
+            }
+
+            _Init();
+        }
+
+        template <class _Fn>
+        param_type(initializer_list<_Ty> _Ilist, _Fn _Func) {
+            if (2 <= _Ilist.size()) {
+                _Bvec.assign(_Ilist);
+
+                for (const auto& _Bval : _Bvec) {
+                    _Pvec.push_back(_Func(_Bval));
+                }
+            } else { // default construct
+                _Bvec = {0, 1};
+            }
+
+            _Init();
+        }
+
+        template <class _Fn>
+        param_type(size_t _Count, _Ty _Low, _Ty _High, _Fn _Func) {
+            _Ty _Range = _High - _Low;
+            _STL_ASSERT(_Ty{0} < _Range, "invalid range for piecewise_linear_distribution");
+            if (_Count < 1) {
+                _Count = 1;
+            }
+
+            _Range /= static_cast<double>(_Count);
+            for (size_t _Idx = 0; _Idx <= _Count; ++_Idx) { // compute _Bvec and _Pvec
+                _Ty _Bval = _Low + _Idx * _Range;
+                _Bvec.push_back(_Bval);
+                _Pvec.push_back(_Func(_Bval));
+            }
+            _Init();
+        }
+
+        _NODISCARD friend bool operator==(const param_type& _Left, const param_type& _Right) {
+            return _Left._Pvec == _Right._Pvec && _Left._Bvec == _Right._Bvec;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(const param_type& _Left, const param_type& _Right) {
+            return !(_Left == _Right);
+        }
+#endif // !_HAS_CXX20
+
+        _NODISCARD vector<_Ty> intervals() const {
+            return _Bvec;
+        }
+
+#pragma warning(push)
+#pragma warning(disable : 4244) // '%s': conversion from '%s' to '%s', possible loss of data
+        _NODISCARD vector<_Ty> densities() const {
+            vector<_Ty> _Ans(_Pvec.begin(), _Pvec.end());
+            return _Ans;
+        }
+#pragma warning(pop)
+
+        _NODISCARD double _Piece_probability(const size_t _Idx) const {
+            return 0.5 * (_Pvec[_Idx] + _Pvec[_Idx + 1]) * static_cast<double>(_Bvec[_Idx + 1] - _Bvec[_Idx]);
+        }
+
+        void _Init_base(const bool _Renorm = true) { // initialize like discrete_distribution::param_type
+            const size_t _Size = _Pvec.size();
+
+            if (_Renorm) {
+                if (_Pvec.empty()) {
+                    _Pvec.push_back(1.0); // make empty vector degenerate
+                } else { // normalize probabilities
+                    double _Sum = 0;
+
+                    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) { // sum all probabilities
+                        _STL_ASSERT(0.0 <= _Pvec[_Idx], "invalid probability for piecewise_linear_distribution");
+                        _Sum += _Pvec[_Idx];
+                    }
+
+                    _STL_ASSERT(0.0 < _Sum, "invalid probability vector for piecewise_linear_distribution");
+                    if (_Sum != 1.0) {
+                        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+                            _Pvec[_Idx] /= _Sum;
+                        }
+                    }
+                }
+            }
+
+            _Pcdf.assign(1, _Pvec[0]);
+            for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+                _Pcdf.push_back(_Pvec[_Idx] + _Pcdf[_Idx - 1]);
+            }
+        }
+
+        void _Init(const bool _Renorm = true) { // initialize
+            const size_t _Size = _Pvec.size();
+
+            if (_Renorm) {
+                if (_Pvec.empty()) { // make empty vector degenerate
+                    _Pvec = {1.0, 1.0};
+                } else { // normalize probabilities
+                    double _Sum = 0;
+
+                    _STL_ASSERT(0.0 <= _Pvec[0], "invalid probability for piecewise_linear_distribution");
+                    for (size_t _Idx = 1; _Idx < _Size; ++_Idx) { // sum all probabilities
+                        _STL_ASSERT(0.0 <= _Pvec[_Idx], "invalid probability for piecewise_linear_distribution");
+                        _Sum += _Piece_probability(_Idx - 1);
+                    }
+
+                    _STL_ASSERT(0.0 < _Sum, "invalid probability vector for piecewise_linear_distribution");
+                    if (_Sum != 1.0) {
+                        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+                            _Pvec[_Idx] /= _Sum;
+                        }
+                    }
+                }
+            }
+
+            _Pcdf.assign(1, _Piece_probability(0));
+            for (size_t _Idx = 2; _Idx < _Size; ++_Idx) {
+                _Pcdf.push_back(_Piece_probability(_Idx - 1) + _Pcdf[_Idx - 2]);
+            }
+        }
+
+        template <class _Elem, class _Traits>
+        basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { // read state from _Istr
+            size_t _Nvals;
+            _Istr >> _Nvals;
+            _Pvec.clear();
+            for (; 0 < _Nvals; --_Nvals) { // get a value and add to vector
+                double _Val;
+                _In(_Istr, _Val);
+                _Pvec.push_back(_Val);
+            }
+            _Init_base(false); // don't renormalize, just compute CDF
+            return _Istr;
+        }
+
+        template <class _Elem, class _Traits>
+        basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { // write state to _Ostr
+            _Ostr << ' ' << _Pvec.size();
+
+            for (const auto& _Val : _Pvec) {
+                _Out(_Ostr, _Val);
+            }
+
+            return _Ostr;
+        }
+
+        vector<double> _Pvec;
+        vector<double> _Pcdf;
+        vector<_Ty> _Bvec;
+    };
+
+    piecewise_linear_distribution() {}
+
+    template <class _InIt1, class _InIt2>
+    piecewise_linear_distribution(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2) : _Par(_First1, _Last1, _First2) {}
+
+    template <class _Fn>
+    piecewise_linear_distribution(initializer_list<_Ty> _Ilist, _Fn _Func) : _Par(_Ilist, _Func) {}
+
+    template <class _Fn>
+    piecewise_linear_distribution(size_t _Count, _Ty _Low, _Ty _High, _Fn _Func) : _Par(_Count, _Low, _High, _Func) {}
+
+    explicit piecewise_linear_distribution(const param_type& _Par0) : _Par(_Par0) {}
+
+    _NODISCARD vector<_Ty> intervals() const {
+        return _Par.intervals();
+    }
+
+    _NODISCARD vector<_Ty> densities() const {
+        return _Par.densities();
+    }
+
+    _NODISCARD param_type param() const {
+        return _Par;
+    }
+
+    void param(const param_type& _Par0) { // set parameter package
+        _Par = _Par0;
+    }
+
+    _NODISCARD result_type(min)() const noexcept /* strengthened */ {
+        return _Par._Bvec.front();
+    }
+
+    _NODISCARD result_type(max)() const noexcept /* strengthened */ {
+        return _Par._Bvec.back();
+    }
+
+    void reset() noexcept /* strengthened */ {} // clear internal state
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng) {
+        return _Eval(_Eng, _Par);
+    }
+
+    template <class _Engine>
+    _NODISCARD result_type operator()(_Engine& _Eng, const param_type& _Par0) {
+        return _Eval(_Eng, _Par0);
+    }
+
+    _NODISCARD friend bool operator==(
+        const piecewise_linear_distribution& _Left, const piecewise_linear_distribution& _Right) {
+        return _Left.param() == _Right.param();
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(
+        const piecewise_linear_distribution& _Left, const piecewise_linear_distribution& _Right) {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    template <class _Elem, class _Traits>
+    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
+        piecewise_linear_distribution& _Dist) { // read state from _Istr
+        _Dist._Par._Read(_Istr);
+
+        _Dist._Par._Bvec.clear();
+        for (size_t _Idx = _Dist._Par._Pvec.size(); 0 < _Idx; --_Idx) {
+            // get a value and add to intervals vector
+            double _Val;
+            _In(_Istr, _Val);
+            _Dist._Par._Bvec.push_back(_Val);
+        }
+        _Dist._Par._Init(false); // don't renormalize, just compute CDF
+        return _Istr;
+    }
+
+    template <class _Elem, class _Traits>
+    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
+        const piecewise_linear_distribution& _Dist) { // write state to _Ostr
+        _Dist._Par._Write(_Ostr);
+
+        for (const auto& _Val : _Dist._Par._Bvec) {
+            _Out(_Ostr, _Val);
+        }
+
+        return _Ostr;
+    }
+
+    template <class _Engine>
+    result_type _Eval(_Engine& _Eng, const param_type& _Par0) {
+        size_t _Px  = discrete_distribution<size_t>::_Invoke_param_pcdf(_Eng, _Par0._Pcdf);
+        double _Px0 = _Par0._Pvec[_Px];
+        double _Px1 = _Par0._Pvec[_Px + 1];
+        uniform_real_distribution<_Ty> _Dist;
+        result_type _Xx0 = _Dist(_Eng);
+
+        if (_Px0 != _Px1) {
+            _Xx0 = static_cast<result_type>(
+                (_STD sqrt(_Px0 * _Px0 * (1.0 - _Xx0) + _Px1 * _Px1 * _Xx0) - _Px0) / (_Px1 - _Px0));
+        }
+
+        return _Par0._Bvec[_Px] + _Xx0 * (_Par0._Bvec[_Px + 1] - _Par0._Bvec[_Px]);
+    }
+
+    discrete_distribution<size_t> _Unused; // TRANSITION, ABI: this was a base class subobject
+    param_type _Par;
+};
+
+_EXPORT_STD using minstd_rand0 = linear_congruential_engine<unsigned int, 16807, 0, 2147483647>;
+_EXPORT_STD using minstd_rand  = linear_congruential_engine<unsigned int, 48271, 0, 2147483647>;
+
+_EXPORT_STD using mt19937 = mersenne_twister_engine<unsigned int, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7,
+    0x9d2c5680, 15, 0xefc60000, 18, 1812433253>;
+
+_EXPORT_STD using mt19937_64 = mersenne_twister_engine<unsigned long long, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29,
+    0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL>;
+
+_EXPORT_STD using ranlux24_base = subtract_with_carry_engine<unsigned int, 24, 10, 24>;
+_EXPORT_STD using ranlux48_base = subtract_with_carry_engine<unsigned long long, 48, 5, 12>;
+_EXPORT_STD using ranlux24      = discard_block_engine<ranlux24_base, 223, 23>;
+_EXPORT_STD using ranlux48      = discard_block_engine<ranlux48_base, 389, 11>;
+_EXPORT_STD using knuth_b       = shuffle_order_engine<minstd_rand0, 256>;
+
+_EXPORT_STD using default_random_engine = mt19937;
+
+extern "C++" _CRTIMP2_PURE unsigned int __CLRCALL_PURE_OR_CDECL _Random_device();
+
+_EXPORT_STD class random_device { // class to generate random numbers (from hardware where available)
+public:
+    using result_type = unsigned int;
+
+    random_device() = default;
+
+    explicit random_device(const string&) noexcept /* strengthened */ {}
+
+    _NODISCARD static constexpr result_type(min)() noexcept /* strengthened */ {
+        return 0;
+    }
+
+    _NODISCARD static constexpr result_type(max)() noexcept /* strengthened */ {
+        return static_cast<result_type>(-1);
+    }
+
+    _NODISCARD double entropy() const noexcept {
+        return 32.0;
+    }
+
+    _NODISCARD result_type operator()() {
+        return _Random_device();
+    }
+
+    random_device(const random_device&)            = delete;
+    random_device& operator=(const random_device&) = delete;
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _RANDOM_
diff --git a/msvc-stl/stl/inc/ranges b/msvc-stl/stl/inc/ranges
new file mode 100644
index 0000000..07b5d1e
--- /dev/null
+++ b/msvc-stl/stl/inc/ranges
@@ -0,0 +1,9269 @@
+// ranges standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _RANGES_
+#define _RANGES_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <ranges> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+#include <__msvc_int128.hpp>
+#include <__msvc_ranges_to.hpp>
+#include <iosfwd>
+#include <iterator>
+#include <limits>
+#include <span>
+#include <string_view>
+#include <tuple>
+
+#if _HAS_CXX23
+#include <array>
+#include <bit>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+namespace ranges {
+    // MUCH machinery defined in <xutility>, some in <__msvc_ranges_to.hpp>
+
+    template <auto> // _Require_constant<E> is a valid template-id iff E is a constant expression of structural type
+    struct _Require_constant;
+
+#if _HAS_CXX23
+    _EXPORT_STD template <range _Rng>
+    using const_iterator_t = decltype(_RANGES cbegin(_STD declval<_Rng&>()));
+
+    _EXPORT_STD template <range _Rng>
+    using const_sentinel_t = decltype(_RANGES cend(_STD declval<_Rng&>()));
+
+    _EXPORT_STD template <range _Rng>
+    using range_const_reference_t = iter_const_reference_t<iterator_t<_Rng>>;
+
+    template <range _Ty>
+    constexpr auto _Compile_time_max_size = (numeric_limits<_Make_unsigned_like_t<range_difference_t<_Ty>>>::max)();
+
+    template <sized_range _Ty>
+    constexpr auto _Compile_time_max_size<_Ty> = (numeric_limits<range_size_t<_Ty>>::max)();
+
+#ifdef __EDG__ // TRANSITION, VSO-1898880
+    template <class _Ty>
+    concept _Constant_sized_range = sized_range<_Ty> && requires { typename _Require_constant<_Ty::size()>; };
+
+    template <_Constant_sized_range _Ty>
+    constexpr auto _Compile_time_max_size<_Ty> = _Ty::size();
+#else // ^^^ workaround / no workaround vvv
+    template <sized_range _Ty>
+        requires requires { typename _Require_constant<_Ty::size()>; }
+    constexpr auto _Compile_time_max_size<_Ty> = _Ty::size();
+#endif // ^^^ no workaround ^^^
+
+    template <class _Ty, size_t _Size>
+    constexpr auto _Compile_time_max_size<_Ty[_Size]> = _Size;
+
+    template <class _Ty, size_t _Size>
+    constexpr auto _Compile_time_max_size<array<_Ty, _Size>> = _Size;
+
+    template <class _Ty, size_t _Size>
+    constexpr auto _Compile_time_max_size<const array<_Ty, _Size>> = _Size;
+
+    template <class _Ty, size_t _Extent>
+        requires (_Extent != dynamic_extent)
+    constexpr auto _Compile_time_max_size<span<_Ty, _Extent>> = _Extent;
+
+    template <class _Ty, size_t _Extent>
+        requires (_Extent != dynamic_extent)
+    constexpr auto _Compile_time_max_size<const span<_Ty, _Extent>> = _Extent;
+#endif // _HAS_CXX23
+
+    template <class _Rng>
+    concept _Simple_view = view<_Rng> && range<const _Rng> && same_as<iterator_t<_Rng>, iterator_t<const _Rng>>
+                        && same_as<sentinel_t<_Rng>, sentinel_t<const _Rng>>;
+
+    template <class _It>
+    concept _Has_arrow = input_iterator<_It> && (is_pointer_v<_It> || _Has_member_arrow<const _It&>);
+
+    template <bool _IsWrapped, class _Ty>
+    using _Maybe_wrapped = conditional_t<_IsWrapped, _Ty, _Unwrapped_t<_Ty>>;
+
+    template <range _Rng, class _Derived>
+    class _Cached_position : public view_interface<_Derived> {
+        static_assert(false, "A range must be at least forward for position caching to be worthwhile.");
+    };
+
+    template <forward_range _Rng, class _Derived>
+    class _Cached_position<_Rng, _Derived> : public view_interface<_Derived> {
+    private:
+        using _It = iterator_t<_Rng>;
+
+        /* [[no_unique_address]] */ _It _Pos{};
+        bool _Cached = false;
+
+    protected:
+        _Cached_position()  = default;
+        ~_Cached_position() = default;
+
+        // a copied iterator doesn't point into a copied range, so cache values must not propagate via copy
+        constexpr _Cached_position(const _Cached_position&) noexcept(is_nothrow_default_constructible_v<_It>) {}
+        constexpr _Cached_position& operator=(const _Cached_position&) noexcept(noexcept(_Pos = _It{})) {
+            _Pos    = _It{};
+            _Cached = false;
+            return *this;
+        }
+
+        // a moved iterator doesn't point into a moved range, so cache values must not propagate via move;
+        // similarly, a cache value might not be valid for a moved-from view so clear move sources
+        constexpr _Cached_position(_Cached_position&& _Other) noexcept(noexcept(_Pos = _It{})) {
+            _Other._Pos    = _It{};
+            _Other._Cached = false;
+        }
+        constexpr _Cached_position& operator=(_Cached_position&& _Other) noexcept(noexcept(_Pos = _It{})) {
+            _Pos           = _It{};
+            _Cached        = false;
+            _Other._Pos    = _It{};
+            _Other._Cached = false;
+            return *this;
+        }
+
+        _NODISCARD constexpr bool _Has_cache() const noexcept { // Is there a cached position?
+            return _Cached;
+        }
+
+        _NODISCARD constexpr _It _Get_cache(_Rng&) const noexcept(is_nothrow_copy_constructible_v<_It>) {
+            _STL_INTERNAL_CHECK(_Cached);
+            return _Pos;
+        }
+
+        constexpr void _Set_cache(_Rng&, _It _Iter) noexcept(is_nothrow_move_assignable_v<_It>) {
+            _Pos    = _STD move(_Iter);
+            _Cached = true;
+        }
+    };
+
+    template <random_access_range _Rng, class _Derived>
+    class _Cached_position<_Rng, _Derived> : public view_interface<_Derived> {
+    private:
+        using _It = iterator_t<_Rng>;
+
+        range_difference_t<_Rng> _Off = -1;
+
+    protected:
+        _Cached_position()  = default;
+        ~_Cached_position() = default;
+
+        // Offsets are oblivious to copying, so cache values _do_ propagate via copying.
+        _Cached_position(const _Cached_position&)            = default;
+        _Cached_position& operator=(const _Cached_position&) = default;
+
+        // Offsets are potentially invalidated by move, so source caches are invalidated after move
+        constexpr _Cached_position(_Cached_position&& _Other) noexcept
+            : _Off(_STD exchange(_Other._Off, range_difference_t<_Rng>{-1})) {}
+        constexpr _Cached_position& operator=(_Cached_position&& _Other) noexcept {
+            _Off = _STD exchange(_Other._Off, range_difference_t<_Rng>{-1});
+            return *this;
+        }
+
+        _NODISCARD constexpr bool _Has_cache() const noexcept { // Is there a cached position?
+            return _Off >= range_difference_t<_Rng>{0};
+        }
+
+        _NODISCARD constexpr _It _Get_cache(_Rng& _Range) const noexcept(noexcept(_RANGES begin(_Range) + _Off)) {
+            _STL_INTERNAL_CHECK(_Has_cache());
+            return _RANGES begin(_Range) + _Off;
+        }
+
+        constexpr void _Set_cache(_Rng& _Range, const _It& _Iter)
+            noexcept(noexcept(_Off = _Iter - _RANGES begin(_Range))) {
+            _Off = _Iter - _RANGES begin(_Range);
+        }
+    };
+
+    template <bool _Enable, class _Rng, class _Derived>
+    using _Cached_position_t = conditional_t<_Enable, _Cached_position<_Rng, _Derived>, view_interface<_Derived>>;
+
+    template <movable _Ty>
+    class _Defaultabox { // a simplified optional that augments movable types with default-constructibility
+    public:
+        constexpr _Defaultabox() noexcept {}
+
+        constexpr ~_Defaultabox() {
+            if (_Engaged) {
+                _Val.~_Ty();
+            }
+        }
+
+        ~_Defaultabox()
+            requires is_trivially_destructible_v<_Ty>
+        = default;
+
+        _Defaultabox(const _Defaultabox&)
+            requires copy_constructible<_Ty> && is_trivially_copy_constructible_v<_Ty>
+        = default;
+
+        constexpr _Defaultabox(const _Defaultabox& _That) noexcept(is_nothrow_copy_constructible_v<_Ty>)
+            requires copy_constructible<_Ty>
+            : _Engaged{_That._Engaged} {
+            if (_That._Engaged) {
+                _STD _Construct_in_place(_Val, static_cast<const _Ty&>(_That._Val));
+            }
+        }
+
+        _Defaultabox(_Defaultabox&&)
+            requires is_trivially_move_constructible_v<_Ty>
+        = default;
+
+        constexpr _Defaultabox(_Defaultabox&& _That) noexcept(is_nothrow_move_constructible_v<_Ty>)
+            : _Engaged{_That._Engaged} {
+            if (_That._Engaged) {
+                _STD _Construct_in_place(_Val, static_cast<_Ty&&>(_That._Val));
+            }
+        }
+
+        template <_Different_from<_Ty> _Uty>
+            requires convertible_to<const _Uty&, _Ty>
+        constexpr _Defaultabox(const _Defaultabox<_Uty>& _That) noexcept(is_nothrow_constructible_v<_Ty, const _Uty&>)
+            : _Engaged{_That} {
+            if (_That) {
+                _STD _Construct_in_place(_Val, *_That);
+            }
+        }
+
+        template <_Different_from<_Ty> _Uty>
+            requires convertible_to<_Uty, _Ty>
+        constexpr _Defaultabox(_Defaultabox<_Uty>&& _That) noexcept(is_nothrow_constructible_v<_Ty, _Uty>)
+            : _Engaged{_That} {
+            if (_That) {
+                _STD _Construct_in_place(_Val, _STD move(*_That));
+            }
+        }
+
+        _Defaultabox& operator=(const _Defaultabox&) noexcept
+            requires copyable<_Ty> && is_trivially_copy_assignable_v<_Ty>
+        = default;
+
+        constexpr _Defaultabox& operator=(const _Defaultabox& _That)
+            noexcept(is_nothrow_copy_constructible_v<_Ty> && is_nothrow_copy_assignable_v<_Ty>)
+            requires copyable<_Ty>
+        {
+            if (_Engaged) {
+                if (_That._Engaged) {
+                    static_cast<_Ty&>(_Val) = static_cast<const _Ty&>(_That._Val);
+                } else {
+                    _Val.~_Ty();
+                    _Engaged = false;
+                }
+            } else {
+                if (_That._Engaged) {
+                    _STD _Construct_in_place(_Val, static_cast<const _Ty&>(_That._Val));
+                    _Engaged = true;
+                } else {
+                    // nothing to do
+                }
+            }
+
+            return *this;
+        }
+
+        _Defaultabox& operator=(_Defaultabox&&) noexcept
+            requires is_trivially_move_assignable_v<_Ty>
+        = default;
+
+        constexpr _Defaultabox& operator=(_Defaultabox&& _That)
+            noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>) {
+            if (_Engaged) {
+                if (_That._Engaged) {
+                    static_cast<_Ty&>(_Val) = static_cast<_Ty&&>(_That._Val);
+                } else {
+                    _Val.~_Ty();
+                    _Engaged = false;
+                }
+            } else {
+                if (_That._Engaged) {
+                    _STD _Construct_in_place(_Val, static_cast<_Ty&&>(_That._Val));
+                    _Engaged = true;
+                } else {
+                    // nothing to do
+                }
+            }
+
+            return *this;
+        }
+
+        constexpr _Defaultabox& operator=(_Ty&& _That)
+            noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>) {
+            if (_Engaged) {
+                static_cast<_Ty&>(_Val) = _STD move(_That);
+            } else {
+                _STD _Construct_in_place(_Val, _STD move(_That));
+                _Engaged = true;
+            }
+
+            return *this;
+        }
+
+        constexpr _Defaultabox& operator=(const _Ty& _That)
+            noexcept(is_nothrow_copy_constructible_v<_Ty> && is_nothrow_copy_assignable_v<_Ty>)
+            requires copyable<_Ty>
+        {
+            if (_Engaged) {
+                static_cast<_Ty&>(_Val) = _That;
+            } else {
+                _STD _Construct_in_place(_Val, _That);
+                _Engaged = true;
+            }
+
+            return *this;
+        }
+
+        constexpr explicit operator bool() const noexcept {
+            return _Engaged;
+        }
+
+        _NODISCARD constexpr _Ty& operator*() noexcept {
+            _STL_INTERNAL_CHECK(_Engaged);
+            return _Val;
+        }
+        _NODISCARD constexpr const _Ty& operator*() const noexcept {
+            _STL_INTERNAL_CHECK(_Engaged);
+            return _Val;
+        }
+
+        constexpr void _Reset() noexcept {
+            if (_Engaged) {
+                _Val.~_Ty();
+                _Engaged = false;
+            }
+        }
+
+        _NODISCARD constexpr bool operator==(const _Defaultabox& _That) const
+            noexcept(noexcept(static_cast<const _Ty&>(_Val) == static_cast<const _Ty&>(_That._Val))) {
+            _STL_INTERNAL_STATIC_ASSERT(equality_comparable<_Ty>);
+            return _Engaged == _That._Engaged
+                && (!_Engaged || static_cast<const _Ty&>(_Val) == static_cast<const _Ty&>(_That._Val));
+        }
+
+    private:
+        union {
+            remove_cv_t<_Ty> _Val;
+        };
+        bool _Engaged = false;
+    };
+
+    template <movable _Ty>
+        requires default_initializable<_Ty>
+    class _Defaultabox<_Ty> { // provide the same API more efficiently for default-constructible types
+    public:
+        _Defaultabox() = default;
+
+        template <_Different_from<_Ty> _Uty>
+            requires convertible_to<const _Uty&, _Ty>
+        constexpr _Defaultabox(const _Defaultabox<_Uty>& _That)
+            noexcept(is_nothrow_default_constructible_v<_Ty> && noexcept(_Value = static_cast<_Ty>(*_That))) {
+            if (_That) {
+                _Value = static_cast<_Ty>(*_That);
+            }
+        }
+
+        template <_Different_from<_Ty> _Uty>
+            requires convertible_to<_Uty, _Ty>
+        constexpr _Defaultabox(_Defaultabox<_Uty>&& _That) noexcept(
+            is_nothrow_default_constructible_v<_Ty> && noexcept(_Value = static_cast<_Ty>(_STD move(*_That)))) {
+            if (_That) {
+                _Value = static_cast<_Ty>(_STD move(*_That));
+            }
+        }
+
+        constexpr _Defaultabox& operator=(const _Ty& _Right) noexcept(is_nothrow_copy_assignable_v<_Ty>)
+            requires copyable<_Ty>
+        {
+            _Value = _Right;
+            return *this;
+        }
+        constexpr _Defaultabox& operator=(_Ty&& _Right) noexcept(is_nothrow_move_assignable_v<_Ty>) {
+            _Value = _STD move(_Right);
+            return *this;
+        }
+
+        constexpr explicit operator bool() const noexcept {
+            return true;
+        }
+
+        _NODISCARD constexpr _Ty& operator*() noexcept {
+            return _Value;
+        }
+        _NODISCARD constexpr const _Ty& operator*() const noexcept {
+            return _Value;
+        }
+
+        constexpr void _Reset() noexcept(noexcept(_Value = _Ty{})) {
+            _Value = _Ty{};
+        }
+
+        _NODISCARD bool operator==(const _Defaultabox&) const = default;
+
+    private:
+        /* [[no_unique_address]] */ _Ty _Value{};
+    };
+
+    template <_Destructible_object _Ty, bool _Needs_operator_bool = true>
+    class _Non_propagating_cache { // a simplified optional that resets on copy / move
+    public:
+        constexpr _Non_propagating_cache() noexcept {}
+
+        constexpr ~_Non_propagating_cache() {
+            if (_Engaged) {
+                _Val.~_Ty();
+            }
+        }
+
+        ~_Non_propagating_cache()
+            requires is_trivially_destructible_v<_Ty>
+        = default;
+
+        constexpr _Non_propagating_cache(const _Non_propagating_cache&) noexcept {}
+
+        constexpr _Non_propagating_cache(_Non_propagating_cache&& _Other) noexcept {
+            if (_Other._Engaged) {
+                _Other._Val.~_Ty();
+                _Other._Engaged = false;
+            }
+        }
+
+        constexpr _Non_propagating_cache& operator=(const _Non_propagating_cache& _Other) noexcept {
+            if (_STD addressof(_Other) == this) {
+                return *this;
+            }
+
+            if (_Engaged) {
+                _Val.~_Ty();
+                _Engaged = false;
+            }
+
+            return *this;
+        }
+
+        constexpr _Non_propagating_cache& operator=(_Non_propagating_cache&& _Other) noexcept {
+            if (_Engaged) {
+                _Val.~_Ty();
+                _Engaged = false;
+            }
+
+            if (_Other._Engaged) {
+                _Other._Val.~_Ty();
+                _Other._Engaged = false;
+            }
+
+            return *this;
+        }
+
+        _NODISCARD constexpr explicit operator bool() const noexcept
+            requires _Needs_operator_bool
+        {
+            return _Engaged;
+        }
+
+        _NODISCARD constexpr _Ty& operator*() noexcept {
+            _STL_INTERNAL_CHECK(_Engaged);
+            return _Val;
+        }
+        _NODISCARD constexpr const _Ty& operator*() const noexcept {
+            _STL_INTERNAL_CHECK(_Engaged);
+            return _Val;
+        }
+
+        template <class... _Types>
+        constexpr _Ty& _Emplace(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
+            if (_Engaged) {
+                _Val.~_Ty();
+                _Engaged = false;
+            }
+
+            _STD _Construct_in_place(_Val, _STD forward<_Types>(_Args)...);
+            _Engaged = true;
+
+            return _Val;
+        }
+
+    private:
+        union {
+            remove_cv_t<_Ty> _Val;
+        };
+        bool _Engaged = false;
+    };
+
+    template <_Destructible_object _Ty>
+        requires is_trivially_destructible_v<_Ty>
+    class _Non_propagating_cache<_Ty, false> { // a specialization for trivially destructible types where checking if
+                                               // the cache contains a value is not needed
+    public:
+        constexpr _Non_propagating_cache() noexcept {}
+
+        ~_Non_propagating_cache() = default;
+
+        constexpr _Non_propagating_cache(const _Non_propagating_cache&) noexcept {}
+
+        constexpr _Non_propagating_cache(_Non_propagating_cache&&) noexcept {}
+
+        constexpr _Non_propagating_cache& operator=(const _Non_propagating_cache&) noexcept {
+            return *this;
+        }
+
+        constexpr _Non_propagating_cache& operator=(_Non_propagating_cache&&) noexcept {
+            return *this;
+        }
+
+        _NODISCARD constexpr _Ty& operator*() noexcept {
+            return _Val;
+        }
+        _NODISCARD constexpr const _Ty& operator*() const noexcept {
+            return _Val;
+        }
+
+        template <class... _Types>
+        constexpr _Ty& _Emplace(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
+            _STD _Construct_in_place(_Val, _STD forward<_Types>(_Args)...);
+            return _Val;
+        }
+
+    private:
+        union {
+            remove_cv_t<_Ty> _Val;
+        };
+    };
+
+#if _HAS_CXX23
+    _EXPORT_STD template <class _Derived>
+        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
+    class _NO_SPECIALIZATIONS_CITING("N5014 [range.adaptor.object]/5") range_adaptor_closure
+        : public _Pipe::_Base<_Derived> {};
+#endif // _HAS_CXX23
+
+    _EXPORT_STD template <class _Ty>
+        requires is_object_v<_Ty>
+    class empty_view : public view_interface<empty_view<_Ty>> {
+    public:
+        _NODISCARD static constexpr _Ty* begin() noexcept {
+            return nullptr;
+        }
+
+        _NODISCARD static constexpr _Ty* end() noexcept {
+            return nullptr;
+        }
+
+        _NODISCARD static constexpr _Ty* data() noexcept {
+            return nullptr;
+        }
+
+        _NODISCARD static constexpr size_t size() noexcept {
+            return 0;
+        }
+
+        _NODISCARD static constexpr bool empty() noexcept {
+            return true;
+        }
+    };
+
+    template <class _Ty>
+    constexpr bool enable_borrowed_range<empty_view<_Ty>> = true;
+
+    namespace views {
+        _EXPORT_STD template <class _Ty>
+        constexpr empty_view<_Ty> empty;
+    } // namespace views
+
+    _EXPORT_STD template <_Valid_movable_box_object _Ty>
+    class single_view : public view_interface<single_view<_Ty>> {
+    public:
+        single_view()
+            requires default_initializable<_Ty>
+        = default;
+
+        constexpr explicit single_view(const _Ty& _Val_) noexcept(is_nothrow_copy_constructible_v<_Ty>) // strengthened
+            requires copy_constructible<_Ty>
+            : _Val{in_place, _Val_} {}
+        constexpr explicit single_view(_Ty&& _Val_) noexcept(is_nothrow_move_constructible_v<_Ty>) // strengthened
+            : _Val{in_place, _STD move(_Val_)} {}
+
+        template <class... _Types>
+            requires constructible_from<_Ty, _Types...>
+        constexpr explicit single_view(in_place_t, _Types&&... _Args)
+            noexcept(is_nothrow_constructible_v<_Ty, _Types...>) // strengthened
+            : _Val{in_place, _STD forward<_Types>(_Args)...} {}
+
+        _NODISCARD constexpr _Ty* begin() noexcept {
+            return data();
+        }
+        _NODISCARD constexpr const _Ty* begin() const noexcept {
+            return data();
+        }
+
+        _NODISCARD constexpr _Ty* end() noexcept {
+            return data() + 1;
+        }
+        _NODISCARD constexpr const _Ty* end() const noexcept {
+            return data() + 1;
+        }
+
+        _NODISCARD static constexpr bool empty() noexcept {
+            return false;
+        }
+
+        _NODISCARD static constexpr size_t size() noexcept {
+            return 1;
+        }
+
+        _NODISCARD constexpr _Ty* data() noexcept {
+            return _STD addressof(*_Val);
+        }
+        _NODISCARD constexpr const _Ty* data() const noexcept {
+            return _STD addressof(*_Val);
+        }
+
+    private:
+        /* [[no_unique_address]] */ _Movable_box<_Ty> _Val{};
+    };
+
+    template <class _Ty>
+    single_view(_Ty) -> single_view<_Ty>;
+
+    namespace views {
+        struct _Single_fn {
+            template <class _Ty>
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+                noexcept(noexcept(single_view<decay_t<_Ty>>(_STD forward<_Ty>(_Val))))
+                requires requires {
+                    typename single_view<decay_t<_Ty>>;
+                    single_view<decay_t<_Ty>>(static_cast<_Ty&&>(_Val));
+                }
+            {
+                return single_view<decay_t<_Ty>>(_STD forward<_Ty>(_Val));
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Single_fn single;
+    } // namespace views
+
+    template <class _Ty>
+    using _Iota_diff_t = conditional_t<is_integral_v<_Ty>,
+        conditional_t<sizeof(_Ty) < sizeof(int), int,
+            conditional_t<sizeof(_Ty) < sizeof(long long), long long, _Signed128>>,
+        iter_difference_t<_Ty>>;
+
+    template <class _Ty>
+    concept _Decrementable = incrementable<_Ty> && requires(_Ty __t) {
+        { --__t } -> same_as<_Ty&>;
+        { __t-- } -> same_as<_Ty>;
+    };
+
+    template <class _Ty>
+    concept _Advanceable =
+        _Decrementable<_Ty> && totally_ordered<_Ty> && requires(_Ty __i, const _Ty __j, const _Iota_diff_t<_Ty> __n) {
+            { __i += __n } -> same_as<_Ty&>;
+            { __i -= __n } -> same_as<_Ty&>;
+            _Ty(__j + __n);
+            _Ty(__n + __j);
+            _Ty(__j - __n);
+            { __j - __j } -> convertible_to<_Iota_diff_t<_Ty>>;
+        };
+
+    template <class _Wi>
+    struct _Ioterator_category_base {};
+
+    template <incrementable _Wi>
+        requires integral<_Iota_diff_t<_Wi>>
+    struct _Ioterator_category_base<_Wi> {
+        using iterator_category = input_iterator_tag;
+    };
+
+    template <weakly_incrementable _Wi>
+        requires copyable<_Wi>
+    struct _Ioterator : _Ioterator_category_base<_Wi> {
+        /* [[no_unique_address]] */ _Wi _Current{};
+
+        using iterator_concept = conditional_t<_Advanceable<_Wi>, random_access_iterator_tag,
+            conditional_t<_Decrementable<_Wi>, bidirectional_iterator_tag,
+                conditional_t<incrementable<_Wi>, forward_iterator_tag, input_iterator_tag>>>;
+        using value_type       = _Wi;
+        using difference_type  = _Iota_diff_t<_Wi>;
+
+        _Ioterator()
+            requires default_initializable<_Wi>
+        = default;
+
+        constexpr explicit _Ioterator(_Wi _Val) noexcept(is_nothrow_move_constructible_v<_Wi>) /* strengthened */
+            : _Current(_STD move(_Val)) {}
+
+        _NODISCARD constexpr _Wi operator*() const noexcept(is_nothrow_copy_constructible_v<_Wi>) {
+            return _Current;
+        }
+
+        constexpr _Ioterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+            ++_Current;
+            return *this;
+        }
+
+        constexpr auto operator++(int) noexcept(
+            noexcept(++_Current) && (!incrementable<_Wi> || is_nothrow_copy_constructible_v<_Wi>) ) /* strengthened */ {
+            if constexpr (incrementable<_Wi>) {
+                auto _Tmp = *this;
+                ++_Current;
+                return _Tmp;
+            } else {
+                ++_Current;
+            }
+        }
+
+        constexpr _Ioterator& operator--() noexcept(noexcept(--_Current)) /* strengthened */
+            requires _Decrementable<_Wi>
+        {
+            --_Current;
+            return *this;
+        }
+
+        constexpr _Ioterator operator--(int)
+            noexcept(is_nothrow_copy_constructible_v<_Wi> && noexcept(--_Current)) /* strengthened */
+            requires _Decrementable<_Wi>
+        {
+            auto _Tmp = *this;
+            --_Current;
+            return _Tmp;
+        }
+
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-1347136
+    private:
+        template <class _Left, class _Right>
+        static constexpr bool _Nothrow_plus_equal = noexcept(_STD declval<_Left&>() += _STD declval<const _Right&>());
+        template <_Integer_like _Left, class _Right>
+        static constexpr bool _Nothrow_plus_equal<_Left, _Right> = true;
+
+        template <class _Left, class _Right>
+        static constexpr bool _Nothrow_minus_equal = noexcept(_STD declval<_Left&>() -= _STD declval<const _Right&>());
+        template <_Integer_like _Left, class _Right>
+        static constexpr bool _Nothrow_minus_equal<_Left, _Right> = true;
+
+    public:
+#endif // ^^^ workaround ^^^
+
+        constexpr _Ioterator& operator+=(const difference_type _Off)
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-1347136
+            noexcept(noexcept(_Current += _Off)) /* strengthened */
+#else // ^^^ no workaround / workaround vvv
+            noexcept(_Nothrow_plus_equal<_Wi, difference_type>) /* strengthened */
+#endif // ^^^ workaround ^^^
+            requires _Advanceable<_Wi>
+        {
+            if constexpr (_Integer_like<_Wi>) {
+                if constexpr (_Signed_integer_like<_Wi>) {
+                    _Current = static_cast<_Wi>(_Current + _Off);
+                } else {
+                    if (_Off >= difference_type{0}) {
+                        _Current += static_cast<_Wi>(_Off);
+                    } else {
+                        _Current -= static_cast<_Wi>(-_Off);
+                    }
+                }
+            } else {
+                _Current += _Off;
+            }
+            return *this;
+        }
+
+        constexpr _Ioterator& operator-=(const difference_type _Off)
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-1347136
+            noexcept(noexcept(_Current -= _Off)) /* strengthened */
+#else // ^^^ no workaround / workaround vvv
+            noexcept(_Nothrow_minus_equal<_Wi, difference_type>) /* strengthened */
+#endif // ^^^ workaround ^^^
+            requires _Advanceable<_Wi>
+        {
+            if constexpr (_Integer_like<_Wi>) {
+                if constexpr (_Signed_integer_like<_Wi>) {
+                    _Current = static_cast<_Wi>(_Current - _Off);
+                } else {
+                    if (_Off >= difference_type{0}) {
+                        _Current -= static_cast<_Wi>(_Off);
+                    } else {
+                        _Current += static_cast<_Wi>(-_Off);
+                    }
+                }
+            } else {
+                _Current -= _Off;
+            }
+            return *this;
+        }
+
+        _NODISCARD constexpr _Wi operator[](const difference_type _Idx) const
+            noexcept(noexcept(static_cast<_Wi>(_Current + _Idx))) /* strengthened */
+            requires _Advanceable<_Wi>
+        {
+            if constexpr (_Integer_like<_Wi>) {
+                return static_cast<_Wi>(_Current + static_cast<_Wi>(_Idx));
+            } else {
+                return static_cast<_Wi>(_Current + _Idx);
+            }
+        }
+
+        _NODISCARD friend constexpr bool operator==(const _Ioterator& _Left, const _Ioterator& _Right)
+            noexcept(noexcept(_Left._Current == _Right._Current))
+            requires equality_comparable<_Wi>
+        {
+            return _Left._Current == _Right._Current;
+        }
+
+        _NODISCARD friend constexpr bool operator<(const _Ioterator& _Left, const _Ioterator& _Right)
+            noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+            requires totally_ordered<_Wi>
+        {
+            return _Left._Current < _Right._Current;
+        }
+        _NODISCARD friend constexpr bool operator>(const _Ioterator& _Left, const _Ioterator& _Right)
+            noexcept(noexcept(_Right._Current < _Left._Current)) /* strengthened */
+            requires totally_ordered<_Wi>
+        {
+            return _Right._Current < _Left._Current;
+        }
+        _NODISCARD friend constexpr bool operator<=(const _Ioterator& _Left, const _Ioterator& _Right)
+            noexcept(noexcept(!(_Right._Current < _Left._Current))) /* strengthened */
+            requires totally_ordered<_Wi>
+        {
+            return !(_Right._Current < _Left._Current);
+        }
+        _NODISCARD friend constexpr bool operator>=(const _Ioterator& _Left, const _Ioterator& _Right)
+            noexcept(noexcept(!(_Left._Current < _Right._Current))) /* strengthened */
+            requires totally_ordered<_Wi>
+        {
+            return !(_Left._Current < _Right._Current);
+        }
+
+        _NODISCARD friend constexpr auto operator<=>(const _Ioterator& _Left, const _Ioterator& _Right)
+            noexcept(noexcept(_Left._Current <=> _Right._Current))
+            requires totally_ordered<_Wi> && three_way_comparable<_Wi>
+        {
+            return _Left._Current <=> _Right._Current;
+        }
+
+        _NODISCARD friend constexpr _Ioterator operator+(_Ioterator _It, const difference_type _Off)
+            noexcept(is_nothrow_move_constructible_v<_Ioterator> && noexcept(_It += _Off)) /* strengthened */
+            requires _Advanceable<_Wi>
+        {
+            _It += _Off;
+            return _It;
+        }
+        _NODISCARD friend constexpr _Ioterator operator+(const difference_type _Off, _Ioterator _It) noexcept(
+            is_nothrow_move_constructible_v<_Wi> && noexcept(static_cast<_Wi>(_It._Current + _Off))) /* strengthened */
+            requires _Advanceable<_Wi>
+        {
+            return _Ioterator{static_cast<_Wi>(_It._Current + _Off)};
+        }
+
+        _NODISCARD friend constexpr _Ioterator operator-(_Ioterator _It, const difference_type _Off)
+            noexcept(is_nothrow_move_constructible_v<_Ioterator> && noexcept(_It -= _Off)) /* strengthened */
+            requires _Advanceable<_Wi>
+        {
+            _It -= _Off;
+            return _It;
+        }
+
+        _NODISCARD friend constexpr difference_type operator-(const _Ioterator& _Left, const _Ioterator& _Right)
+            noexcept(noexcept(_Left._Current - _Right._Current)) /* strengthened */
+            requires _Advanceable<_Wi>
+        {
+            if constexpr (_Integer_like<_Wi>) {
+                if constexpr (_Signed_integer_like<_Wi>) {
+                    return static_cast<difference_type>(
+                        static_cast<difference_type>(_Left._Current) - static_cast<difference_type>(_Right._Current));
+                } else if (_Right._Current > _Left._Current) {
+                    return static_cast<difference_type>(
+                        -static_cast<difference_type>(_Right._Current - _Left._Current));
+                } else {
+                    return static_cast<difference_type>(_Left._Current - _Right._Current);
+                }
+            } else {
+                return static_cast<difference_type>(_Left._Current - _Right._Current);
+            }
+        }
+    };
+
+    template <weakly_incrementable _Wi, semiregular _Bo>
+        requires _Weakly_equality_comparable_with<_Wi, _Bo> && copyable<_Wi>
+    struct _Iotinel {
+    private:
+        using _It = _Ioterator<_Wi>;
+
+        _NODISCARD constexpr bool _Equal(const _It& _That) const noexcept(noexcept(_That._Current == _Last)) {
+            return _That._Current == _Last;
+        }
+
+        _NODISCARD constexpr iter_difference_t<_Wi> _Delta(const _It& _That) const
+            noexcept(noexcept(_Last - _That._Current)) {
+            _STL_INTERNAL_STATIC_ASSERT(sized_sentinel_for<_Bo, _Wi>);
+            return _Last - _That._Current;
+        }
+
+    public:
+        /* [[no_unique_address]] */ _Bo _Last{};
+
+        _NODISCARD friend constexpr bool operator==(const _It& _Left, const _Iotinel& _Right)
+            noexcept(noexcept(_Right._Equal(_Left))) /* strengthened */ {
+            return _Right._Equal(_Left);
+        }
+
+        _NODISCARD friend constexpr iter_difference_t<_Wi> operator-(const _It& _Left, const _Iotinel& _Right)
+            noexcept(noexcept(_Right._Delta(_Left))) /* strengthened */
+            requires sized_sentinel_for<_Bo, _Wi>
+        {
+            return -_Right._Delta(_Left);
+        }
+
+        _NODISCARD friend constexpr iter_difference_t<_Wi> operator-(const _Iotinel& _Left, const _It& _Right)
+            noexcept(noexcept(_Left._Delta(_Right))) /* strengthened */
+            requires sized_sentinel_for<_Bo, _Wi>
+        {
+            return _Left._Delta(_Right);
+        }
+    };
+
+    _EXPORT_STD template <weakly_incrementable _Wi, semiregular _Bo = unreachable_sentinel_t>
+        requires _Weakly_equality_comparable_with<_Wi, _Bo> && copyable<_Wi>
+    class iota_view : public view_interface<iota_view<_Wi, _Bo>> {
+    private:
+        /* [[no_unique_address]] */ _Wi _Value{};
+        /* [[no_unique_address]] */ _Bo _Bound{};
+
+        using _It = _Ioterator<_Wi>;
+        using _Se = conditional_t<same_as<_Wi, _Bo>, _It,
+            conditional_t<same_as<_Bo, unreachable_sentinel_t>, _Bo, _Iotinel<_Wi, _Bo>>>;
+
+        _NODISCARD static constexpr _Bo& _Bound_from(_Se& _Last) noexcept {
+            if constexpr (same_as<_Wi, _Bo>) {
+                return _Last._Current;
+            } else if constexpr (same_as<_Bo, unreachable_sentinel_t>) {
+                return _Last;
+            } else {
+                return _Last._Last;
+            }
+        }
+
+    public:
+        iota_view()
+            requires default_initializable<_Wi>
+        = default;
+
+        constexpr explicit iota_view(_Wi _Value_)
+            noexcept(is_nothrow_move_constructible_v<_Wi> && is_nothrow_default_constructible_v<_Bo>) // strengthened
+            : _Value(_STD move(_Value_)) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (totally_ordered_with<_Wi, _Bo>) {
+                _STL_VERIFY(_Value_ <= _Bound, "Per N4981 [range.iota.view]/6, the first argument must not exceed the "
+                                               "value-initialized bound when their types are totally ordered.");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        }
+
+        constexpr explicit iota_view(type_identity_t<_Wi> _Value_, type_identity_t<_Bo> _Bound_)
+            noexcept(is_nothrow_move_constructible_v<_Wi> && is_nothrow_move_constructible_v<_Bo>) // strengthened
+            : _Value(_STD move(_Value_)), _Bound(_STD move(_Bound_)) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (totally_ordered_with<_Wi, _Bo>) {
+                _STL_VERIFY(_Value_ <= _Bound_, "Per N4981 [range.iota.view]/8, the first argument must not exceed the "
+                                                "second when their types are totally ordered.");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        }
+
+        constexpr explicit iota_view(_It _First, _Se _Last)
+            noexcept(is_nothrow_move_constructible_v<_Wi> && is_nothrow_move_constructible_v<_Bo>) // strengthened
+            : _Value(_STD move(_First._Current)), _Bound(_STD move(_Bound_from(_Last))) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (totally_ordered_with<_Wi, _Bo>) {
+                _STL_VERIFY(_Value <= _Bound, "Per N4981 [range.iota.view]/8 and /10, the iterator must not exceed the "
+                                              "sentinel when their types are totally ordered.");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        }
+
+        _NODISCARD constexpr _It begin() const noexcept(is_nothrow_copy_constructible_v<_Wi>) /* strengthened */ {
+            return _It{_Value};
+        }
+
+        _NODISCARD constexpr _Se end() const noexcept(is_nothrow_copy_constructible_v<_Bo>) /* strengthened */ {
+            if constexpr (same_as<_Wi, _Bo>) {
+                return _It{_Bound};
+            } else if constexpr (same_as<_Bo, unreachable_sentinel_t>) {
+                return unreachable_sentinel;
+            } else {
+                return _Se{_Bound};
+            }
+        }
+
+        _NODISCARD constexpr bool empty() const noexcept(noexcept(_Value == _Bound)) /* strengthened */ {
+            return _Value == _Bound;
+        }
+
+#pragma warning(push)
+#pragma warning(disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_Bound - _Value)) /* strengthened */
+            requires (same_as<_Wi, _Bo> && _Advanceable<_Wi>)
+                  || (_Integer_like<_Wi> && _Integer_like<_Bo>) || sized_sentinel_for<_Bo, _Wi>
+        {
+            if constexpr (_Integer_like<_Wi> && _Integer_like<_Bo>) {
+                return (_Value < 0) ? ((_Bound < 0) ? (_To_unsigned_like(-_Value) - _To_unsigned_like(-_Bound))
+                                                    : (_To_unsigned_like(_Bound) + _To_unsigned_like(-_Value)))
+                                    : (_To_unsigned_like(_Bound) - _To_unsigned_like(_Value));
+            } else {
+                return _To_unsigned_like(_Bound - _Value);
+            }
+        }
+#pragma warning(pop)
+    };
+
+    template <class _Wi, class _Bo>
+        requires (
+            !_Integer_like<_Wi> || !_Integer_like<_Bo> || (_Signed_integer_like<_Wi> == _Signed_integer_like<_Bo>) )
+    iota_view(_Wi, _Bo) -> iota_view<_Wi, _Bo>;
+
+    template <class _Wi, class _Bo>
+    constexpr bool enable_borrowed_range<iota_view<_Wi, _Bo>> = true;
+
+    namespace views {
+        struct _Iota_fn {
+            template <class _Ty>
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+                noexcept(noexcept(iota_view<decay_t<_Ty>>(static_cast<_Ty&&>(_Val))))
+                requires requires { iota_view<decay_t<_Ty>>(static_cast<_Ty&&>(_Val)); }
+            {
+                return iota_view<decay_t<_Ty>>(static_cast<_Ty&&>(_Val));
+            }
+
+            template <class _Ty1, class _Ty2>
+            _NODISCARD static constexpr auto operator()(_Ty1&& _Start, _Ty2&& _Bound)
+                noexcept(noexcept(iota_view(static_cast<_Ty1&&>(_Start), static_cast<_Ty2&&>(_Bound))))
+                requires requires { iota_view(static_cast<_Ty1&&>(_Start), static_cast<_Ty2&&>(_Bound)); }
+            {
+                return iota_view(static_cast<_Ty1&&>(_Start), static_cast<_Ty2&&>(_Bound));
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Iota_fn iota;
+
+        class _Take_fn;
+        class _Drop_fn;
+    } // namespace views
+
+#if _HAS_CXX23
+    template <class _Ty, class _Tuple, size_t... _Indices>
+    constexpr _Movable_box<_Ty> _Make_box_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>)
+        noexcept(is_nothrow_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl)))...>) {
+        return _Movable_box<_Ty>(in_place, _STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
+    }
+
+    template <class _Ty, class _Tuple>
+    constexpr _Movable_box<_Ty> _Make_box_from_tuple(_Tuple&& _Tpl)
+        noexcept(noexcept(_RANGES _Make_box_from_tuple_impl<_Ty>(
+            _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) {
+        return _RANGES _Make_box_from_tuple_impl<_Ty>(
+            _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
+    }
+
+    template <class _Ty>
+    concept _Integer_like_with_usable_difference_type =
+        _Signed_integer_like<_Ty> || (_Integer_like<_Ty> && weakly_incrementable<_Ty>);
+
+    template <class _Ty>
+    struct _Repeat_view_difference_type {
+        using type = _Iota_diff_t<_Ty>;
+    };
+
+    template <_Signed_integer_like _Ty>
+    struct _Repeat_view_difference_type<_Ty> {
+        using type = _Ty;
+    };
+
+    _EXPORT_STD template <move_constructible _Ty, semiregular _Bo = unreachable_sentinel_t>
+        requires (is_object_v<_Ty> && same_as<_Ty, remove_cv_t<_Ty>>
+                  && (_Integer_like_with_usable_difference_type<_Bo> || same_as<_Bo, unreachable_sentinel_t>) )
+    class repeat_view : public view_interface<repeat_view<_Ty, _Bo>> {
+    private:
+        friend views::_Take_fn;
+        friend views::_Drop_fn;
+
+        class _Iterator {
+        private:
+            friend repeat_view;
+            using _Index_type = conditional_t<same_as<_Bo, unreachable_sentinel_t>, ptrdiff_t, _Bo>;
+
+            const _Ty* _Value{};
+            _Index_type _Current{};
+
+            constexpr explicit _Iterator(const _Ty* _Val, _Index_type _Bo_ = _Index_type{}) noexcept // strengthened
+                : _Value(_Val), _Current(_Bo_) {
+                if constexpr (_Signed_integer_like<_Bo>) {
+                    _STL_INTERNAL_CHECK(_Current >= 0);
+                }
+            }
+
+        public:
+            using iterator_concept  = random_access_iterator_tag;
+            using iterator_category = random_access_iterator_tag;
+            using value_type        = _Ty;
+            using difference_type   = _Repeat_view_difference_type<_Index_type>::type;
+
+            _Iterator() = default;
+
+            _NODISCARD constexpr const _Ty& operator*() const noexcept {
+                return *_Value;
+            }
+
+            constexpr _Iterator& operator++() noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Current < (numeric_limits<_Index_type>::max)(),
+                    "cannot increment repeat_view iterator past end (integer overflow)");
+#endif
+                ++_Current;
+                return *this;
+            }
+            constexpr _Iterator operator++(int) noexcept /* strengthened */ {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--() noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                if constexpr (is_same_v<_Bo, unreachable_sentinel_t>) {
+                    _STL_VERIFY(_Current > (numeric_limits<_Index_type>::min)(),
+                        "cannot decrement repeat_view iterator before begin (integer overflow)");
+                } else {
+                    _STL_VERIFY(_Current > 0, "cannot decrement below 0");
+                }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                --_Current;
+                return *this;
+            }
+            constexpr _Iterator operator--(int) noexcept /* strengthened */ {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator+=(difference_type _Off) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                if (_Off > 0) {
+                    if constexpr (sizeof(difference_type) > sizeof(_Index_type)) {
+                        _STL_VERIFY(static_cast<_Index_type>(_Off) == _Off,
+                            "cannot advance repeat_view iterator past end (integer overflow)");
+                    }
+
+                    _STL_VERIFY(_Current <= (numeric_limits<_Index_type>::max)() - static_cast<_Index_type>(_Off),
+                        "cannot advance repeat_view iterator past end (integer overflow)");
+                } else {
+                    if constexpr (sizeof(difference_type) > sizeof(_Index_type)) {
+                        _STL_VERIFY(static_cast<_Index_type>(_Off) == _Off,
+                            "cannot advance repeat_view iterator before begin (integer overflow)");
+                    }
+
+                    _STL_VERIFY(_Current >= (numeric_limits<_Index_type>::min)() - static_cast<_Index_type>(_Off),
+                        "cannot advance repeat_view iterator before begin (integer overflow)");
+                }
+
+                if constexpr (!is_same_v<_Bo, unreachable_sentinel_t>) {
+                    _STL_VERIFY(_Current + _Off >= 0, "cannot subtract below 0");
+                }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Current += static_cast<_Index_type>(_Off);
+                return *this;
+            }
+            constexpr _Iterator& operator-=(difference_type _Off) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                if (_Off < 0) {
+                    if constexpr (sizeof(difference_type) > sizeof(_Index_type)) {
+                        _STL_VERIFY(static_cast<_Index_type>(_Off) == _Off,
+                            "cannot advance repeat_view iterator past end (integer overflow)");
+                    }
+
+                    _STL_VERIFY(_Current <= (numeric_limits<_Index_type>::max)() + static_cast<_Index_type>(_Off),
+                        "cannot advance repeat_view iterator past end (integer overflow)");
+                } else {
+                    if constexpr (sizeof(difference_type) > sizeof(_Index_type)) {
+                        _STL_VERIFY(static_cast<_Index_type>(_Off) == _Off,
+                            "cannot advance repeat_view iterator before begin (integer overflow)");
+                    }
+
+                    _STL_VERIFY(_Current >= (numeric_limits<_Index_type>::min)() + static_cast<_Index_type>(_Off),
+                        "cannot advance repeat_view iterator before begin (integer overflow)");
+                }
+
+                if constexpr (!is_same_v<_Bo, unreachable_sentinel_t>) {
+                    _STL_VERIFY(_Current - _Off >= 0, "cannot subtract below 0");
+                }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Current -= static_cast<_Index_type>(_Off);
+                return *this;
+            }
+            _NODISCARD constexpr const _Ty& operator[](difference_type _Idx) const noexcept {
+                return *(*this + _Idx);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right) noexcept
+            /* strengthened */ {
+                return _Left._Current == _Right._Current;
+            }
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right) noexcept
+            /* strengthened */ {
+                return _Left._Current <=> _Right._Current;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(_Iterator _Iter, difference_type _Off) noexcept
+            /* strengthened */ {
+                _Iter += _Off;
+                return _Iter;
+            }
+            _NODISCARD friend constexpr _Iterator operator+(difference_type _Off, _Iterator _Iter) noexcept
+            /* strengthened */ {
+                _Iter += _Off;
+                return _Iter;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(_Iterator _Iter, difference_type _Off) noexcept
+            /* strengthened */ {
+                _Iter -= _Off;
+                return _Iter;
+            }
+            _NODISCARD friend constexpr difference_type operator-(
+                const _Iterator& _Left, const _Iterator& _Right) noexcept /* strengthened */ {
+                return static_cast<difference_type>(
+                    static_cast<difference_type>(_Left._Current) - static_cast<difference_type>(_Right._Current));
+            }
+        };
+
+        /* [[no_unique_address]] */ _Movable_box<_Ty> _Value{};
+        /* [[no_unique_address]] */ _Bo _Bound{};
+
+    public:
+        repeat_view()
+            requires default_initializable<_Ty>
+        = default;
+
+        _NODISCARD constexpr explicit repeat_view(const _Ty& _Value_, _Bo _Bound_ = _Bo{})
+            noexcept(is_nothrow_copy_constructible_v<_Ty>) // strengthened
+            requires copy_constructible<_Ty>
+            : _Value(in_place, _Value_), _Bound(_STD move(_Bound_)) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (_Signed_integer_like<_Bo>) {
+                _STL_VERIFY(_Bound >= 0, "Bound must be >= 0");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        }
+        _NODISCARD constexpr explicit repeat_view(_Ty&& _Value_, _Bo _Bound_ = _Bo{})
+            noexcept(is_nothrow_move_constructible_v<_Ty>) // strengthened
+            : _Value(in_place, _STD move(_Value_)), _Bound(_STD move(_Bound_)) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (_Signed_integer_like<_Bo>) {
+                _STL_VERIFY(_Bound >= 0, "Bound must be >= 0");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        }
+        template <class... _TArgs, class... _BArgs>
+            requires constructible_from<_Ty, _TArgs...> && constructible_from<_Bo, _BArgs...>
+        _NODISCARD constexpr explicit repeat_view(
+            piecewise_construct_t, tuple<_TArgs...> _Val_args, tuple<_BArgs...> _Bound_args = tuple<>{})
+            noexcept(noexcept(_RANGES _Make_box_from_tuple<_Ty>(_STD move(_Val_args)))
+                     && noexcept(_STD make_from_tuple<_Bo>(_STD move(_Bound_args)))) // strengthened
+            : _Value(_RANGES _Make_box_from_tuple<_Ty>(_STD move(_Val_args))),
+              _Bound(_STD make_from_tuple<_Bo>(_STD move(_Bound_args))) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (_Signed_integer_like<_Bo>) {
+                _STL_VERIFY(_Bound >= 0, "Bound must be >= 0");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        }
+
+        _NODISCARD constexpr _Iterator begin() const noexcept /* strengthened */ {
+            return _Iterator{_STD addressof(*_Value)};
+        }
+        _NODISCARD constexpr auto end() const noexcept /* strengthened */ {
+            if constexpr (same_as<_Bo, unreachable_sentinel_t>) {
+                return unreachable_sentinel;
+            } else {
+                return _Iterator{_STD addressof(*_Value), _Bound};
+            }
+        }
+
+        _NODISCARD constexpr auto size() const noexcept // strengthened
+            requires (!same_as<_Bo, unreachable_sentinel_t>)
+        {
+            return _STD _To_unsigned_like(_Bound);
+        }
+    };
+
+    template <class _Ty, class _Bo = unreachable_sentinel_t>
+    repeat_view(_Ty, _Bo = _Bo()) -> repeat_view<_Ty, _Bo>;
+
+    namespace views {
+        struct _Repeat_fn {
+            template <class _Ty>
+            _NODISCARD static constexpr auto operator()(_Ty&& _Value)
+                noexcept(noexcept(repeat_view<decay_t<_Ty>>(_STD forward<_Ty>(_Value))))
+                requires requires { repeat_view<decay_t<_Ty>>(_STD forward<_Ty>(_Value)); }
+            {
+                return repeat_view<decay_t<_Ty>>(_STD forward<_Ty>(_Value));
+            }
+
+            template <class _Ty1, class _Ty2>
+            _NODISCARD static constexpr auto operator()(_Ty1&& _Value, _Ty2&& _Count)
+                noexcept(noexcept(repeat_view(_STD forward<_Ty1>(_Value), _STD forward<_Ty2>(_Count))))
+                requires requires { repeat_view(_STD forward<_Ty1>(_Value), _STD forward<_Ty2>(_Count)); }
+            {
+                return repeat_view(_STD forward<_Ty1>(_Value), _STD forward<_Ty2>(_Count));
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Repeat_fn repeat;
+    } // namespace views
+#endif // _HAS_CXX23
+
+    template <class _Ty, class _Elem, class _Traits>
+    concept _Stream_extractable = requires(basic_istream<_Elem, _Traits>& __is, _Ty& __t) { __is >> __t; };
+
+    _EXPORT_STD template <movable _Ty, class _Elem, class _Traits = char_traits<_Elem>>
+        requires default_initializable<_Ty> && _Stream_extractable<_Ty, _Elem, _Traits>
+    class basic_istream_view : public view_interface<basic_istream_view<_Ty, _Elem, _Traits>> {
+    private:
+        class _Iterator {
+        private:
+            basic_istream_view* _Parent;
+
+        public:
+            using iterator_concept = input_iterator_tag;
+            using difference_type  = ptrdiff_t;
+            using value_type       = _Ty;
+
+            constexpr explicit _Iterator(basic_istream_view& _Parent_) noexcept : _Parent{_STD addressof(_Parent_)} {}
+
+            _Iterator(const _Iterator&) = delete;
+            _Iterator(_Iterator&&)      = default;
+
+            _Iterator& operator=(const _Iterator&) = delete;
+            _Iterator& operator=(_Iterator&&)      = default;
+
+            _Iterator& operator++() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                // Per LWG-3489
+                _STL_VERIFY(
+                    !_Parent->_Stream_at_end(), "cannot increment basic_istream_view iterator at end of stream");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                *_Parent->_Stream >> _Parent->_Val;
+                return *this;
+            }
+
+            void operator++(int) {
+                ++*this;
+            }
+
+            _NODISCARD _Ty& operator*() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                // Per LWG-3489
+                _STL_VERIFY(
+                    !_Parent->_Stream_at_end(), "cannot dereference basic_istream_view iterator at end of stream");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _Parent->_Val;
+            }
+
+            _NODISCARD friend bool operator==(const _Iterator& _Left, default_sentinel_t) noexcept /* strengthened */ {
+                return _Left._Parent->_Stream_at_end();
+            }
+        };
+
+        basic_istream<_Elem, _Traits>* _Stream;
+        _Ty _Val = _Ty{};
+
+    public:
+        constexpr explicit basic_istream_view(basic_istream<_Elem, _Traits>& _Stream_)
+            noexcept(is_nothrow_default_constructible_v<_Ty>) // strengthened
+            : _Stream{_STD addressof(_Stream_)} {}
+
+        _NODISCARD constexpr auto begin() {
+            *_Stream >> _Val;
+            return _Iterator{*this};
+        }
+
+        _NODISCARD constexpr default_sentinel_t end() const noexcept {
+            return default_sentinel;
+        }
+
+        _NODISCARD constexpr bool _Stream_at_end() const noexcept {
+            return !*_Stream;
+        }
+    };
+
+    _EXPORT_STD template <class _Ty>
+    using istream_view = basic_istream_view<_Ty, char>;
+    _EXPORT_STD template <class _Ty>
+    using wistream_view = basic_istream_view<_Ty, wchar_t>;
+
+    namespace views {
+        template <class _Elem, class _Stream, class _CharT, class _Traits>
+        concept _Istreamable_impl = derived_from<_Stream, basic_istream<_CharT, _Traits>>
+                                 && constructible_from<basic_istream_view<_Elem, _CharT, _Traits>, _Stream&>;
+        template <class _Elem, class _Stream>
+        concept _Istreamable = requires {
+            typename _Stream::char_type;
+            typename _Stream::traits_type;
+            requires _Istreamable_impl<_Elem, _Stream, typename _Stream::char_type, typename _Stream::traits_type>;
+        };
+
+        template <class _Ty>
+        struct _Istream_fn {
+            template <class _StreamTy>
+                requires _Istreamable<_Ty, _StreamTy>
+            _NODISCARD static constexpr auto operator()(_StreamTy& _Stream)
+                noexcept(is_nothrow_default_constructible_v<_Ty>) /* strengthened */ {
+                return basic_istream_view<_Ty, typename _StreamTy::char_type, typename _StreamTy::traits_type>(_Stream);
+            }
+        };
+
+        _EXPORT_STD template <class _Ty>
+        constexpr _Istream_fn<_Ty> istream;
+    } // namespace views
+
+#if _HAS_CXX23
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<ref_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const ref_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<owning_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const owning_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+
+    _EXPORT_STD template <input_range _Vw>
+        requires view<_Vw>
+    class as_rvalue_view : public view_interface<as_rvalue_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+
+        template <range _Rng>
+        static constexpr bool _Is_end_nothrow_v = noexcept(move_sentinel{_RANGES end(_STD declval<_Rng&>())});
+
+        template <common_range _Rng>
+        static constexpr bool _Is_end_nothrow_v<_Rng> = noexcept(move_iterator{_RANGES end(_STD declval<_Rng&>())});
+
+    public:
+        as_rvalue_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit as_rvalue_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) // strengthened
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() noexcept(noexcept(move_iterator{_RANGES begin(_Range)})) // strengthened
+            requires (!_Simple_view<_Vw>)
+        {
+            return move_iterator{_RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(noexcept(move_iterator{_RANGES begin(_Range)})) // strengthened
+            requires range<const _Vw>
+        {
+            return move_iterator{_RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto end() noexcept(_Is_end_nothrow_v<_Vw>) // strengthened
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (common_range<_Vw>) {
+                return move_iterator{_RANGES end(_Range)};
+            } else {
+                return move_sentinel{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const noexcept(_Is_end_nothrow_v<const _Vw>) // strengthened
+            requires range<const _Vw>
+        {
+            if constexpr (common_range<const _Vw>) {
+                return move_iterator{_RANGES end(_Range)};
+            } else {
+                return move_sentinel{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Range))) // strengthened
+            requires sized_range<_Vw>
+        {
+            return _RANGES size(_Range);
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Range))) // strengthened
+            requires sized_range<const _Vw>
+        {
+            return _RANGES size(_Range);
+        }
+    };
+
+    template <class _Rng>
+    as_rvalue_view(_Rng&&) -> as_rvalue_view<views::all_t<_Rng>>;
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<as_rvalue_view<_Rng>> = enable_borrowed_range<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<as_rvalue_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const as_rvalue_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+
+    namespace views {
+        // direct-non-list-initialization is specified in the Standard (N4981 [range.as.rvalue.overview]/2.2)
+        // and needed for EDG, DevCom-10698021
+        template <class _Rng>
+        concept _Can_as_rvalue = requires(_Rng&& __r) { as_rvalue_view(static_cast<_Rng&&>(__r)); };
+
+        class _As_rvalue_fn : public _Pipe::_Base<_As_rvalue_fn> {
+        private:
+            enum class _St { _None, _All, _As_rvalue };
+
+            template <class _Rng>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                if constexpr (input_range<_Rng> && same_as<range_rvalue_reference_t<_Rng>, range_reference_t<_Rng>>) {
+                    return {_St::_All, noexcept(views::all(_STD declval<_Rng>()))};
+                } else if constexpr (_Can_as_rvalue<_Rng>) {
+                    return {_St::_As_rvalue, noexcept(as_rvalue_view(_STD declval<_Rng>()))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Rng>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();
+
+        public:
+            template <viewable_range _Rng>
+                requires (_Choice<_Rng>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
+                constexpr _St _Strat = _Choice<_Rng>._Strategy;
+                if constexpr (_Strat == _St::_All) {
+                    return views::all(_STD forward<_Rng>(_Range));
+                } else if constexpr (_Strat == _St::_As_rvalue) {
+                    return as_rvalue_view(_STD forward<_Rng>(_Range));
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+
+        _EXPORT_STD inline constexpr _As_rvalue_fn as_rvalue;
+    } // namespace views
+#endif // _HAS_CXX23
+
+    _EXPORT_STD template <input_range _Vw, indirect_unary_predicate<iterator_t<_Vw>> _Pr>
+        requires view<_Vw> && is_object_v<_Pr>
+    class filter_view : public _Cached_position_t<forward_range<_Vw>, _Vw, filter_view<_Vw, _Pr>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        /* [[no_unique_address]] */ _Movable_box<_Pr> _Pred{};
+
+        template <class _View>
+        struct _Category_base {};
+
+        template <forward_range _View>
+        struct _Category_base<_View> {
+            using iterator_category =
+                conditional_t<derived_from<_Iter_cat_t<iterator_t<_View>>, bidirectional_iterator_tag>,
+                    bidirectional_iterator_tag,
+                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_View>>, forward_iterator_tag>,
+                        forward_iterator_tag, _Iter_cat_t<iterator_t<_View>>>>;
+        };
+
+        class _Iterator : public _Category_base<_Vw> {
+        private:
+            /* [[no_unique_address]] */ iterator_t<_Vw> _Current{};
+            filter_view* _Parent{};
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            constexpr void _Check_dereference() const noexcept {
+                _STL_VERIFY(_Parent != nullptr, "cannot dereference value-initialized filter_view iterator");
+                _STL_VERIFY(_Current != _RANGES end(_Parent->_Range), "cannot dereference end filter_view iterator");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        public:
+            using iterator_concept = conditional_t<bidirectional_range<_Vw>, bidirectional_iterator_tag,
+                conditional_t<forward_range<_Vw>, forward_iterator_tag, input_iterator_tag>>;
+            using value_type       = range_value_t<_Vw>;
+            using difference_type  = range_difference_t<_Vw>;
+
+            _Iterator()
+                requires default_initializable<iterator_t<_Vw>>
+            = default;
+
+            constexpr _Iterator(filter_view& _Parent_, iterator_t<_Vw> _Current_)
+                noexcept(is_nothrow_move_constructible_v<iterator_t<_Vw>>) // strengthened
+                : _Current(_STD move(_Current_)), _Parent{_STD addressof(_Parent_)} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STD _Adl_verify_range(_Current, _RANGES end(_Parent_._Range));
+                if constexpr (forward_range<_Vw>) {
+                    _STD _Adl_verify_range(_RANGES begin(_Parent_._Range), _Current);
+                }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+            }
+
+            _NODISCARD constexpr const iterator_t<_Vw>& base() const& noexcept {
+                return _Current;
+            }
+            _NODISCARD constexpr iterator_t<_Vw> base() && noexcept(
+                is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */ {
+                return _STD move(_Current);
+            }
+
+            _NODISCARD constexpr range_reference_t<_Vw> operator*() const
+                noexcept(noexcept(*_Current)) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Check_dereference();
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return *_Current;
+            }
+
+            _NODISCARD constexpr iterator_t<_Vw> operator->() const
+                noexcept(is_nothrow_copy_constructible_v<iterator_t<_Vw>>) /* strengthened */
+                requires _Has_arrow<iterator_t<_Vw>> && copyable<iterator_t<_Vw>>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Check_dereference();
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _Current;
+            }
+
+            constexpr _Iterator& operator++() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Parent != nullptr, "cannot increment value-initialized filter_view iterator");
+                _STL_VERIFY(_Current != _RANGES end(_Parent->_Range), "cannot increment filter_view iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Current =
+                    _RANGES find_if(_STD move(++_Current), _RANGES end(_Parent->_Range), _STD ref(*_Parent->_Pred));
+                return *this;
+            }
+
+            constexpr decltype(auto) operator++(int) {
+                if constexpr (forward_range<_Vw>) {
+                    auto _Tmp = *this;
+                    ++*this;
+                    return _Tmp;
+                } else {
+                    ++*this;
+                }
+            }
+
+            constexpr _Iterator& operator--()
+                requires bidirectional_range<_Vw>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Parent != nullptr, "cannot decrement value-initialized filter_view iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                do {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                    _STL_VERIFY(_Current != _RANGES begin(_Parent->_Range),
+                        "cannot decrement filter_view iterator before begin");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                    --_Current;
+                } while (!_STD invoke(*_Parent->_Pred, *_Current));
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                requires bidirectional_range<_Vw>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                requires equality_comparable<iterator_t<_Vw>>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(
+                    _Left._Parent == _Right._Parent, "cannot compare incompatible filter_view iterators for equality");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _Left._Current == _Right._Current;
+            }
+
+            _NODISCARD friend constexpr range_rvalue_reference_t<_Vw> iter_move(const _Iterator& _It)
+                noexcept(noexcept(_RANGES iter_move(_It._Current))) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _It._Check_dereference();
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _RANGES iter_move(_It._Current);
+            }
+
+            friend constexpr void iter_swap(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_RANGES iter_swap(_Left._Current, _Right._Current)))
+                requires indirectly_swappable<iterator_t<_Vw>>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Left._Check_dereference();
+                _Right._Check_dereference();
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _RANGES iter_swap(_Left._Current, _Right._Current);
+            }
+
+            _NODISCARD constexpr bool _Equal(const sentinel_t<_Vw>& _Last) const
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current == _Last))) {
+                return _Current == _Last;
+            }
+        };
+
+        class _Sentinel {
+        private:
+            /* [[no_unique_address]] */ sentinel_t<_Vw> _Last{};
+
+        public:
+            _Sentinel() = default;
+            constexpr explicit _Sentinel(filter_view& _Parent)
+                noexcept(noexcept(_RANGES end(_Parent._Range))
+                         && is_nothrow_move_constructible_v<sentinel_t<_Vw>>) // strengthened
+                : _Last(_RANGES end(_Parent._Range)) {}
+
+            _NODISCARD constexpr sentinel_t<_Vw> base() const
+                noexcept(is_nothrow_copy_constructible_v<sentinel_t<_Vw>>) /* strengthened */ {
+                return _Last;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _It, const _Sentinel& _Se)
+                noexcept(noexcept(_It._Equal(_Se._Last))) /* strengthened */ {
+                return _It._Equal(_Se._Last);
+            }
+        };
+
+    public:
+        filter_view()
+            requires default_initializable<_Vw> && default_initializable<_Pr>
+        = default;
+
+        constexpr explicit filter_view(_Vw _Range_, _Pr _Pred_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Pr>) // strengthened
+            : _Range(_STD move(_Range_)), _Pred{in_place, _STD move(_Pred_)} {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr const _Pr& pred() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "filter_view has no predicate");
+#endif
+            return *_Pred;
+        }
+
+        _NODISCARD constexpr _Iterator begin() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(
+                _Pred, "N4950 [range.filter.view]/3 forbids calling begin on a filter_view that holds no predicate");
+#endif
+            if constexpr (forward_range<_Vw>) {
+                if (this->_Has_cache()) {
+                    return _Iterator{*this, this->_Get_cache(_Range)};
+                }
+            }
+
+            auto _First = _RANGES find_if(_Range, _STD ref(*_Pred));
+            if constexpr (forward_range<_Vw>) {
+                this->_Set_cache(_Range, _First);
+            }
+
+            return _Iterator{*this, _STD move(_First)};
+        }
+
+        _NODISCARD constexpr auto end() {
+            if constexpr (common_range<_Vw>) {
+                return _Iterator{*this, _RANGES end(_Range)};
+            } else {
+                return _Sentinel{*this};
+            }
+        }
+    };
+
+    template <class _Rng, class _Pr>
+    filter_view(_Rng&&, _Pr) -> filter_view<views::all_t<_Rng>, _Pr>;
+
+#if _HAS_CXX23
+    template <class _Rng, class _Pr>
+    constexpr auto _Compile_time_max_size<filter_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        struct _Filter_fn {
+            template <viewable_range _Rng, class _Pr>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Pr&& _Pred)
+                noexcept(noexcept(filter_view(_STD forward<_Rng>(_Range), _STD forward<_Pr>(_Pred))))
+                requires requires { filter_view(static_cast<_Rng&&>(_Range), _STD forward<_Pr>(_Pred)); }
+            {
+                return filter_view(_STD forward<_Rng>(_Range), _STD forward<_Pr>(_Pred));
+            }
+
+            template <class _Pr>
+                requires constructible_from<decay_t<_Pr>, _Pr>
+            _NODISCARD static constexpr auto operator()(_Pr&& _Pred)
+                noexcept(is_nothrow_constructible_v<decay_t<_Pr>, _Pr>) {
+                return _Range_closure<_Filter_fn, decay_t<_Pr>>{_STD forward<_Pr>(_Pred)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Filter_fn filter;
+    } // namespace views
+
+#if _HAS_CXX23
+    template <class _Rng, class _Fn>
+    constexpr auto _Compile_time_max_size<transform_view<_Rng, _Fn>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng, class _Fn>
+    constexpr auto _Compile_time_max_size<const transform_view<_Rng, _Fn>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
+    _EXPORT_STD template <view _Vw>
+    class take_view : public view_interface<take_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        range_difference_t<_Vw> _Count = 0;
+
+        template <bool _Const, bool _Wrapped = true>
+        class _Sentinel {
+        private:
+            friend take_view;
+
+            using _Base_t        = _Maybe_const<_Const, _Vw>;
+            using _Base_sentinel = _Maybe_wrapped<_Wrapped, sentinel_t<_Base_t>>;
+            template <bool _OtherConst>
+            using _Base_iterator = _Maybe_wrapped<_Wrapped, iterator_t<_Maybe_const<_OtherConst, _Vw>>>;
+            template <bool _OtherConst>
+            using _Counted_iter = counted_iterator<_Base_iterator<_OtherConst>>;
+
+            _Base_sentinel _Last{};
+
+        public:
+            _Sentinel() = default;
+
+            constexpr explicit _Sentinel(_Base_sentinel _Last_)
+                noexcept(is_nothrow_move_constructible_v<_Base_sentinel>) // strengthened
+                : _Last(_STD move(_Last_)) {}
+
+            constexpr _Sentinel(_Sentinel<!_Const, _Wrapped> _That) noexcept(
+                is_nothrow_constructible_v<_Base_sentinel, _Maybe_wrapped<_Wrapped, sentinel_t<_Vw>>>) // strengthened
+                requires _Const && convertible_to<_Maybe_wrapped<_Wrapped, sentinel_t<_Vw>>, _Base_sentinel>
+                : _Last(_STD move(_That._Last)) {}
+
+            _NODISCARD constexpr _Base_sentinel base() const
+                noexcept(is_nothrow_copy_constructible_v<_Base_sentinel>) /* strengthened */ {
+                return _Last;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Counted_iter<_Const>& _Left, const _Sentinel& _Right) {
+                return _Left.count() == 0 || _Left.base() == _Right._Last;
+            }
+
+            template <bool _OtherConst = !_Const>
+                requires sentinel_for<_Base_sentinel, _Base_iterator<_OtherConst>>
+            _NODISCARD friend constexpr bool operator==(
+                const _Counted_iter<_OtherConst>& _Left, const _Sentinel& _Right) {
+                return _Left.count() == 0 || _Left.base() == _Right._Last;
+            }
+
+            using _Prevent_inheriting_unwrap = _Sentinel;
+
+            _NODISCARD constexpr auto _Unwrapped() const& noexcept(
+                noexcept(_Sentinel<_Const, false>{_Last._Unwrapped()}))
+                requires _Wrapped && _Unwrappable_sentinel_for<sentinel_t<_Base_t>, const iterator_t<_Base_t>&>
+            {
+                return _Sentinel<_Const, false>{_Last._Unwrapped()};
+            }
+            _NODISCARD constexpr auto _Unwrapped() && noexcept(
+                noexcept(_Sentinel<_Const, false>{_STD move(_Last)._Unwrapped()}))
+                requires _Wrapped && _Unwrappable_sentinel_for<sentinel_t<_Base_t>, iterator_t<_Base_t>>
+            {
+                return _Sentinel<_Const, false>{_STD move(_Last)._Unwrapped()};
+            }
+
+            static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<iterator_t<_Base_t>>;
+
+            constexpr void _Seek_to(const _Sentinel<_Const, false>& _That)
+                requires _Wrapped
+            {
+                _Seek_wrapped(_Last, _That._Last);
+            }
+            constexpr void _Seek_to(_Sentinel<_Const, false>&& _That)
+                requires _Wrapped
+            {
+                _Seek_wrapped(_Last, _STD move(_That._Last));
+            }
+        };
+
+    public:
+        take_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit take_view(_Vw _Range_, const range_difference_t<_Vw> _Count_)
+            noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)), _Count{_Count_} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Count_ >= 0, "Number of elements to take must be non-negative (N4971 [range.take.view]/1)");
+#endif
+        }
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin()
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (sized_range<_Vw>) {
+                if constexpr (random_access_range<_Vw>) {
+                    return _RANGES begin(_Range);
+                } else {
+                    const auto _Size = static_cast<range_difference_t<_Vw>>(size());
+                    return counted_iterator(_RANGES begin(_Range), _Size);
+                }
+            } else if constexpr (sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>) {
+                auto _Iter       = _RANGES begin(_Range);
+                const auto _Size = (_STD min) (_Count, _RANGES end(_Range) - _Iter);
+                return counted_iterator(_STD move(_Iter), _Size);
+            } else {
+                return counted_iterator(_RANGES begin(_Range), _Count);
+            }
+        }
+
+        _NODISCARD constexpr auto begin() const
+            requires range<const _Vw>
+        {
+            if constexpr (sized_range<const _Vw>) {
+                if constexpr (random_access_range<const _Vw>) {
+                    return _RANGES begin(_Range);
+                } else {
+                    const auto _Size = static_cast<range_difference_t<_Vw>>(size());
+                    return counted_iterator(_RANGES begin(_Range), _Size);
+                }
+            } else if constexpr (sized_sentinel_for<sentinel_t<const _Vw>, iterator_t<const _Vw>>) {
+                auto _Iter       = _RANGES begin(_Range);
+                const auto _Size = (_STD min) (_Count, _RANGES end(_Range) - _Iter);
+                return counted_iterator(_STD move(_Iter), _Size);
+            } else {
+                return counted_iterator(_RANGES begin(_Range), _Count);
+            }
+        }
+
+        _NODISCARD constexpr auto end()
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (sized_range<_Vw>) {
+                if constexpr (random_access_range<_Vw>) {
+                    return _RANGES begin(_Range) + static_cast<range_difference_t<_Vw>>(size());
+                } else {
+                    return default_sentinel;
+                }
+            } else if constexpr (sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>) {
+                return default_sentinel;
+            } else {
+                return _Sentinel<false>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            requires range<const _Vw>
+        {
+            if constexpr (sized_range<const _Vw>) {
+                if constexpr (random_access_range<const _Vw>) {
+                    return _RANGES begin(_Range) + static_cast<range_difference_t<_Vw>>(size());
+                } else {
+                    return default_sentinel;
+                }
+            } else if constexpr (sized_sentinel_for<sentinel_t<const _Vw>, iterator_t<const _Vw>>) {
+                return default_sentinel;
+            } else {
+                return _Sentinel<true>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto size()
+            requires sized_range<_Vw>
+        {
+            const auto _Length = _RANGES size(_Range);
+            return (_STD min) (_Length, static_cast<decltype(_Length)>(_Count));
+        }
+
+        _NODISCARD constexpr auto size() const
+            requires sized_range<const _Vw>
+        {
+            const auto _Length = _RANGES size(_Range);
+            return (_STD min) (_Length, static_cast<decltype(_Length)>(_Count));
+        }
+    };
+
+    template <class _Rng>
+    take_view(_Rng&&, range_difference_t<_Rng>) -> take_view<views::all_t<_Rng>>;
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<take_view<_Rng>> = enable_borrowed_range<_Rng>;
+
+#if _HAS_CXX23
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<take_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const take_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        template <class _Rng>
+        concept _Random_sized_range = random_access_range<_Rng> && sized_range<_Rng>;
+
+        class _Take_fn {
+        private:
+            enum class _St {
+                _Empty,
+                _Reconstruct_span,
+                _Reconstruct_string_view,
+                _Reconstruct_iota_view,
+                _Reconstruct_repeat_view,
+                _Reconstruct_subrange,
+                _Take_view
+            };
+
+            template <class _Rng>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                using _Ty = remove_cvref_t<_Rng>;
+
+                if constexpr (_Is_specialization_v<_Ty, empty_view>) {
+                    return {_St::_Empty, true};
+                } else if constexpr (_Is_span_v<_Ty>) {
+                    return {_St::_Reconstruct_span, true};
+                } else if constexpr (_Is_specialization_v<_Ty, basic_string_view>) {
+                    return {_St::_Reconstruct_string_view, true};
+                } else if constexpr (_Random_sized_range<_Ty> && _Is_specialization_v<_Ty, iota_view>) {
+                    return {_St::_Reconstruct_iota_view,
+                        noexcept(_RANGES begin(_STD declval<_Rng&>()) + _RANGES distance(_STD declval<_Rng&>()))};
+#if _HAS_CXX23
+                } else if constexpr (_Is_specialization_v<_Ty, repeat_view>) {
+                    using _Range_val_t = range_value_t<_Ty>;
+                    return {_St::_Reconstruct_repeat_view,
+                        is_nothrow_constructible_v<_Range_val_t, _Forward_like_t<_Rng, _Range_val_t>>};
+#endif // _HAS_CXX23
+                } else if constexpr (_Random_sized_range<_Ty> && _Is_subrange_v<_Ty>) {
+                    return {_St::_Reconstruct_subrange,
+                        noexcept(subrange(_RANGES begin(_STD declval<_Rng&>()),
+                            _RANGES begin(_STD declval<_Rng&>()) + _RANGES distance(_STD declval<_Rng&>())))};
+                } else {
+                    return {_St::_Take_view, noexcept(take_view(_STD declval<_Rng>(), range_difference_t<_Rng>{0}))};
+                }
+            }
+
+            template <class _Rng>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();
+
+        public:
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, range_difference_t<_Rng> _Count)
+                noexcept(_Choice<_Rng>._No_throw) {
+                constexpr _St _Strat = _Choice<_Rng>._Strategy;
+
+                if constexpr (_Strat == _St::_Empty) {
+                    // it's an empty_view: return another empty view
+                    return remove_cvref_t<_Rng>{};
+                } else if constexpr (_Strat == _St::_Take_view) {
+                    return take_view(_STD forward<_Rng>(_Range), _Count);
+#if _HAS_CXX23
+                } else if constexpr (!sized_range<_Rng> && _Strat == _St::_Reconstruct_repeat_view) {
+                    return repeat_view(_STD forward_like<_Rng>(*_Range._Value), _Count);
+#endif // _HAS_CXX23
+                } else {
+                    // it's a "reconstructible range"; return the same kind of range with a restricted extent
+                    _Count            = (_STD min) (_RANGES distance(_Range), _Count);
+                    const auto _First = _RANGES begin(_Range);
+
+                    if constexpr (_Strat == _St::_Reconstruct_span) {
+                        return span(_First, _First + _Count);
+                    } else if constexpr (_Strat == _St::_Reconstruct_string_view) {
+                        return remove_cvref_t<_Rng>(_First, _First + _Count);
+                    } else if constexpr (_Strat == _St::_Reconstruct_iota_view) {
+                        using _Vt = range_value_t<_Rng>;
+                        return iota_view<_Vt, _Vt>(_First, _First + _Count);
+#if _HAS_CXX23
+                    } else if constexpr (_Strat == _St::_Reconstruct_repeat_view) {
+                        return repeat_view(_STD forward_like<_Rng>(*_Range._Value), _Count);
+#endif // _HAS_CXX23
+                    } else if constexpr (_Strat == _St::_Reconstruct_subrange) {
+                        return subrange(_First, _First + _Count);
+                    } else {
+                        static_assert(false); // unexpected strategy
+                    }
+                }
+            }
+
+            template <class _Ty>
+                requires constructible_from<decay_t<_Ty>, _Ty>
+            _NODISCARD static constexpr auto operator()(_Ty&& _Length)
+                noexcept(is_nothrow_constructible_v<decay_t<_Ty>, _Ty>) {
+                return _Range_closure<_Take_fn, decay_t<_Ty>>{_STD forward<_Ty>(_Length)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Take_fn take;
+    } // namespace views
+
+    _EXPORT_STD template <view _Vw, class _Pr>
+        requires input_range<_Vw> && is_object_v<_Pr> && indirect_unary_predicate<const _Pr, iterator_t<_Vw>>
+    class take_while_view : public view_interface<take_while_view<_Vw, _Pr>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        /* [[no_unique_address]] */ _Movable_box<_Pr> _Pred{};
+
+        template <bool _Const, bool _Wrapped = true>
+        class _Sentinel {
+        private:
+            friend take_while_view;
+
+            using _Base_t        = _Maybe_const<_Const, _Vw>;
+            using _Base_iterator = _Maybe_wrapped<_Wrapped, iterator_t<_Base_t>>;
+            using _Base_sentinel = _Maybe_wrapped<_Wrapped, sentinel_t<_Base_t>>;
+
+            template <bool _OtherConst>
+            using _Maybe_const_iter = _Maybe_wrapped<_Wrapped, iterator_t<_Maybe_const<_OtherConst, _Vw>>>;
+
+            /* [[no_unique_address]] */ _Base_sentinel _Last{};
+            const _Pr* _Pred = nullptr;
+
+        public:
+            _Sentinel() = default;
+
+            constexpr explicit _Sentinel(_Base_sentinel _Last_, const _Pr* const _Pred_)
+                noexcept(is_nothrow_move_constructible_v<_Base_sentinel>) // strengthened
+                : _Last(_STD move(_Last_)), _Pred(_Pred_) {}
+
+            constexpr _Sentinel(_Sentinel<!_Const, _Wrapped> _That) noexcept(
+                is_nothrow_constructible_v<_Base_sentinel, _Maybe_wrapped<_Wrapped, sentinel_t<_Vw>>>) // strengthened
+                requires _Const && convertible_to<_Maybe_wrapped<_Wrapped, sentinel_t<_Vw>>, _Base_sentinel>
+                : _Last(_STD move(_That._Last)), _Pred(_That._Pred) {}
+
+            _NODISCARD constexpr _Base_sentinel base() const
+                noexcept(is_nothrow_copy_constructible_v<_Base_sentinel>) /* strengthened */ {
+                return _Last;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Base_iterator& _Left, const _Sentinel& _Right) {
+                return _Right._Last == _Left || !_STD invoke(*_Right._Pred, *_Left);
+            }
+
+            template <bool _OtherConst = !_Const>
+                requires sentinel_for<_Base_sentinel, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD friend constexpr bool operator==(
+                const _Maybe_const_iter<_OtherConst>& _Left, const _Sentinel& _Right) {
+                return _Right._Last == _Left || !_STD invoke(*_Right._Pred, *_Left);
+            }
+
+            using _Prevent_inheriting_unwrap = _Sentinel;
+
+            _NODISCARD constexpr auto _Unwrapped() const& noexcept(
+                noexcept(_Sentinel<_Const, false>{_Last._Unwrapped(), _Pred}))
+                requires _Wrapped && _Unwrappable_sentinel_for<sentinel_t<_Base_t>, const iterator_t<_Base_t>&>
+            {
+                return _Sentinel<_Const, false>{_Last._Unwrapped(), _Pred};
+            }
+            _NODISCARD constexpr auto _Unwrapped() && noexcept(
+                noexcept(_Sentinel<_Const, false>{_STD move(_Last)._Unwrapped(), _Pred}))
+                requires _Wrapped && _Unwrappable_sentinel_for<sentinel_t<_Base_t>, iterator_t<_Base_t>>
+            {
+                return _Sentinel<_Const, false>{_STD move(_Last)._Unwrapped(), _Pred};
+            }
+
+            static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<iterator_t<_Base_t>>;
+
+            constexpr void _Seek_to(const _Sentinel<_Const, false>& _That)
+                requires _Wrapped
+            {
+                _Seek_wrapped(_Last, _That._Last);
+            }
+            constexpr void _Seek_to(_Sentinel<_Const, false>&& _That)
+                requires _Wrapped
+            {
+                _Seek_wrapped(_Last, _STD move(_That._Last));
+            }
+        };
+
+    public:
+        take_while_view()
+            requires default_initializable<_Vw> && default_initializable<_Pr>
+        = default;
+
+        constexpr explicit take_while_view(_Vw _Range_, _Pr _Pred_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Pr>) // strengthened
+            : _Range(_STD move(_Range_)), _Pred{in_place, _STD move(_Pred_)} {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr const _Pr& pred() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "take_while_view has no predicate");
+#endif
+            return *_Pred;
+        }
+
+        _NODISCARD constexpr auto begin() noexcept(noexcept(_RANGES begin(_Range))) /* strengthened */
+            requires (!_Simple_view<_Vw>)
+        {
+            return _RANGES begin(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(noexcept(_RANGES begin(_Range))) /* strengthened */
+            requires range<const _Vw> && indirect_unary_predicate<const _Pr, iterator_t<const _Vw>>
+        {
+            return _RANGES begin(_Range);
+        }
+
+        _NODISCARD constexpr auto end() noexcept(
+            noexcept(_RANGES end(_Range)) && is_nothrow_move_constructible_v<_Sentinel<false>>) /* strengthened */
+            requires (!_Simple_view<_Vw>)
+        {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "cannot call end on a take_while_view with no predicate");
+#endif
+            return _Sentinel<false>{_RANGES end(_Range), _STD addressof(*_Pred)};
+        }
+
+        _NODISCARD constexpr auto end() const noexcept(
+            noexcept(_RANGES end(_Range)) && is_nothrow_move_constructible_v<_Sentinel<true>>) /* strengthened */
+            requires range<const _Vw> && indirect_unary_predicate<const _Pr, iterator_t<const _Vw>>
+        {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "cannot call end on a take_while_view with no predicate");
+#endif
+            return _Sentinel<true>{_RANGES end(_Range), _STD addressof(*_Pred)};
+        }
+    };
+
+    template <class _Rng, class _Pr>
+    take_while_view(_Rng&&, _Pr) -> take_while_view<views::all_t<_Rng>, _Pr>;
+
+#if _HAS_CXX23
+    template <class _Rng, class _Pr>
+    constexpr auto _Compile_time_max_size<take_while_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng, class _Pr>
+    constexpr auto _Compile_time_max_size<const take_while_view<_Rng, _Pr>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        struct _Take_while_fn {
+            template <viewable_range _Rng, class _Pr>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Pr _Pred)
+                noexcept(noexcept(take_while_view(_STD forward<_Rng>(_Range), _STD move(_Pred))))
+                requires requires { take_while_view(static_cast<_Rng&&>(_Range), _STD move(_Pred)); }
+            {
+                return take_while_view(_STD forward<_Rng>(_Range), _STD move(_Pred));
+            }
+
+            template <class _Pr>
+                requires constructible_from<decay_t<_Pr>, _Pr>
+            _NODISCARD static constexpr auto operator()(_Pr&& _Pred)
+                noexcept(is_nothrow_constructible_v<decay_t<_Pr>, _Pr>) {
+                return _Range_closure<_Take_while_fn, decay_t<_Pr>>{_STD forward<_Pr>(_Pred)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Take_while_fn take_while;
+    } // namespace views
+
+    _EXPORT_STD template <view _Vw>
+    class drop_view : public _Cached_position_t<forward_range<_Vw> && !(random_access_range<_Vw> && sized_range<_Vw>),
+                          _Vw, drop_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        range_difference_t<_Vw> _Count = 0;
+
+        _NODISCARD constexpr auto _Find_first() {
+            if constexpr (sized_range<_Vw>) {
+                _STL_INTERNAL_STATIC_ASSERT(!random_access_range<_Vw>);
+                auto _Offset = _RANGES distance(_Range);
+                if constexpr (bidirectional_range<_Vw> && common_range<_Vw>) {
+                    if (_Count >= _Offset / 2) {
+                        auto _Result = _RANGES end(_Range);
+                        while (_Offset > _Count) {
+                            --_Offset;
+                            --_Result;
+                        }
+
+                        return _Result;
+                    }
+                }
+
+                if (_Offset > _Count) {
+                    _Offset = _Count;
+                }
+
+                return _RANGES next(_RANGES begin(_Range), _Offset);
+            } else {
+                return _RANGES next(_RANGES begin(_Range), _Count, _RANGES end(_Range));
+            }
+        }
+
+    public:
+        drop_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit drop_view(_Vw _Range_, const range_difference_t<_Vw> _Count_)
+            noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)), _Count{_Count_} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Count_ >= 0, "Number of elements to drop must be non-negative (N4971 [range.drop.view]/1)");
+#endif
+        }
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin()
+            requires (!(_Simple_view<_Vw> && random_access_range<const _Vw> && sized_range<const _Vw>) )
+        {
+            if constexpr (sized_range<_Vw> && random_access_range<_Vw>) {
+                const auto _Offset = (_STD min) (_RANGES distance(_Range), _Count);
+                return _RANGES begin(_Range) + _Offset;
+            } else {
+                if constexpr (forward_range<_Vw>) {
+                    if (this->_Has_cache()) {
+                        return this->_Get_cache(_Range);
+                    }
+                }
+
+                same_as<iterator_t<_Vw>> auto _Result = _Find_first();
+                if constexpr (forward_range<_Vw>) {
+                    this->_Set_cache(_Range, _Result);
+                }
+                return _Result;
+            }
+        }
+
+        _NODISCARD constexpr auto begin() const
+            requires random_access_range<const _Vw> && sized_range<const _Vw>
+        {
+            const auto _Offset = (_STD min) (_RANGES distance(_Range), _Count);
+            return _RANGES begin(_Range) + _Offset;
+        }
+
+        _NODISCARD constexpr auto end()
+            requires (!_Simple_view<_Vw>)
+        {
+            return _RANGES end(_Range);
+        }
+
+        _NODISCARD constexpr auto end() const
+            requires range<const _Vw>
+        {
+            return _RANGES end(_Range);
+        }
+
+        _NODISCARD constexpr auto size()
+            requires sized_range<_Vw>
+        {
+            const auto _Size          = _RANGES size(_Range);
+            const auto _Count_as_size = static_cast<range_size_t<_Vw>>(_Count);
+            if (_Size < _Count_as_size) {
+                return range_size_t<_Vw>{0};
+            } else {
+                return static_cast<range_size_t<_Vw>>(_Size - _Count_as_size);
+            }
+        }
+
+        _NODISCARD constexpr auto size() const
+            requires sized_range<const _Vw>
+        {
+            const auto _Size          = _RANGES size(_Range);
+            const auto _Count_as_size = static_cast<range_size_t<_Vw>>(_Count);
+            if (_Size < _Count_as_size) {
+                return range_size_t<_Vw>{0};
+            } else {
+                return static_cast<range_size_t<_Vw>>(_Size - _Count_as_size);
+            }
+        }
+    };
+
+    template <class _Rng>
+    drop_view(_Rng&&, range_difference_t<_Rng>) -> drop_view<views::all_t<_Rng>>;
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<drop_view<_Rng>> = enable_borrowed_range<_Rng>;
+
+#if _HAS_CXX23
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<drop_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const drop_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        class _Drop_fn {
+        private:
+            enum class _St {
+                _Empty,
+                _Reconstruct_span,
+                _Reconstruct_subrange,
+                _Reconstruct_repeat,
+                _Reconstruct_other,
+                _Drop_view
+            };
+
+            template <class _Rng>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                using _Ty = remove_cvref_t<_Rng>;
+
+                if constexpr (_Is_specialization_v<_Ty, empty_view>) {
+                    return {_St::_Empty, true};
+                } else if constexpr (_Is_span_v<_Ty>) {
+                    return {_St::_Reconstruct_span, true};
+                } else if constexpr (_Is_specialization_v<_Ty, basic_string_view>) {
+                    return {_St::_Reconstruct_other, true};
+#if _HAS_CXX23
+                } else if constexpr (_Is_specialization_v<_Ty, repeat_view>) {
+                    using _Range_val_t = range_value_t<_Ty>;
+                    return {_St::_Reconstruct_repeat,
+                        is_nothrow_constructible_v<_Range_val_t, _Forward_like_t<_Rng, _Range_val_t>>};
+#endif // _HAS_CXX23
+                } else if constexpr (_Random_sized_range<_Ty> && _Is_subrange_v<_Ty>) {
+                    if constexpr (sized_sentinel_for<sentinel_t<_Ty>, iterator_t<_Ty>>) {
+                        return {_St::_Reconstruct_subrange,
+                            noexcept(_Ty(_RANGES begin(_STD declval<_Rng&>()) + _RANGES distance(_STD declval<_Rng&>()),
+                                _RANGES end(_STD declval<_Rng&>())))};
+                    } else {
+                        return {_St::_Reconstruct_subrange,
+                            noexcept(_Ty(_RANGES begin(_STD declval<_Rng&>()) + _RANGES distance(_STD declval<_Rng&>()),
+                                _RANGES end(_STD declval<_Rng&>()), range_difference_t<_Rng>{0}))};
+                    }
+                } else if constexpr (_Random_sized_range<_Ty> && _Is_specialization_v<_Ty, iota_view>) {
+                    return {_St::_Reconstruct_other,
+                        noexcept(_Ty(_RANGES begin(_STD declval<_Rng&>()) + _RANGES distance(_STD declval<_Rng&>()),
+                            _RANGES end(_STD declval<_Rng&>())))};
+                } else {
+                    return {_St::_Drop_view, noexcept(drop_view(_STD declval<_Rng>(), range_difference_t<_Rng>{0}))};
+                }
+            }
+
+            template <class _Rng>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();
+
+        public:
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, range_difference_t<_Rng> _Count)
+                noexcept(_Choice<_Rng>._No_throw) {
+                constexpr _St _Strat = _Choice<_Rng>._Strategy;
+
+                if constexpr (_Strat == _St::_Empty) {
+                    // it's an empty_view: return another empty view
+                    return remove_cvref_t<_Rng>{};
+                } else if constexpr (_Strat == _St::_Drop_view) {
+                    return drop_view(_STD forward<_Rng>(_Range), _Count);
+#if _HAS_CXX23
+                } else if constexpr (_Strat == _St::_Reconstruct_repeat) {
+                    if constexpr (sized_range<_Rng>) {
+                        const auto _Size = _RANGES distance(_Range);
+                        _Count           = _Size - (_STD min) (_Size, _Count);
+                        return repeat_view(_STD forward_like<_Rng>(*_Range._Value), _Count);
+                    } else {
+                        return _Range;
+                    }
+#endif // _HAS_CXX23
+                } else {
+                    // it's a "reconstructible range"; return the same kind of range with a restricted extent
+                    _Count = (_STD min) (_RANGES distance(_Range), _Count);
+
+                    if constexpr (_Strat == _St::_Reconstruct_span) {
+                        return span(_Ubegin(_Range) + _Count, _Uend(_Range));
+                    } else if constexpr (_Strat == _St::_Reconstruct_subrange) {
+                        if constexpr (sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>) {
+                            return remove_cvref_t<_Rng>(_RANGES begin(_Range) + _Count, _RANGES end(_Range));
+                        } else {
+                            return remove_cvref_t<_Rng>(
+                                _RANGES begin(_Range) + _Count, _RANGES end(_Range), _RANGES size(_Range) - _Count);
+                        }
+                    } else if constexpr (_Strat == _St::_Reconstruct_other) {
+                        return remove_cvref_t<_Rng>(_RANGES begin(_Range) + _Count, _RANGES end(_Range));
+                    } else {
+                        static_assert(false); // unexpected strategy
+                    }
+                }
+            }
+
+            template <class _Ty>
+                requires constructible_from<decay_t<_Ty>, _Ty>
+            _NODISCARD static constexpr auto operator()(_Ty&& _Length)
+                noexcept(is_nothrow_constructible_v<decay_t<_Ty>, _Ty>) {
+                return _Range_closure<_Drop_fn, decay_t<_Ty>>{_STD forward<_Ty>(_Length)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Drop_fn drop;
+    } // namespace views
+
+    _EXPORT_STD template <view _Vw, class _Pr>
+        requires input_range<_Vw> && is_object_v<_Pr> && indirect_unary_predicate<const _Pr, iterator_t<_Vw>>
+    class drop_while_view : public _Cached_position_t<forward_range<_Vw>, _Vw, drop_while_view<_Vw, _Pr>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        /* [[no_unique_address]] */ _Movable_box<_Pr> _Pred{};
+
+    public:
+        drop_while_view()
+            requires default_initializable<_Vw> && default_initializable<_Pr>
+        = default;
+
+        constexpr explicit drop_while_view(_Vw _Range_, _Pr _Pred_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Pr>) // strengthened
+            : _Range(_STD move(_Range_)), _Pred{in_place, _STD move(_Pred_)} {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr const _Pr& pred() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "drop_while_view has no predicate");
+#endif
+            return *_Pred;
+        }
+
+        _NODISCARD constexpr auto begin() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(
+                _Pred, "N4950 [range.drop.while.view]/3 forbids calling begin on a drop_while_view with no predicate");
+#endif
+            if constexpr (forward_range<_Vw>) {
+                if (this->_Has_cache()) {
+                    return this->_Get_cache(_Range);
+                }
+            }
+
+            auto _First = _RANGES find_if_not(_Range, _STD cref(*_Pred));
+            if constexpr (forward_range<_Vw>) {
+                this->_Set_cache(_Range, _First);
+            }
+
+            return _First;
+        }
+
+        _NODISCARD constexpr auto end() noexcept(noexcept(_RANGES end(_Range))) /* strengthened */ {
+            return _RANGES end(_Range);
+        }
+    };
+
+    template <class _Rng, class _Pr>
+    drop_while_view(_Rng&&, _Pr) -> drop_while_view<views::all_t<_Rng>, _Pr>;
+
+    template <class _Rng, class _Pr>
+    constexpr bool enable_borrowed_range<drop_while_view<_Rng, _Pr>> = enable_borrowed_range<_Rng>;
+
+#if _HAS_CXX23
+    template <class _Rng, class _Pr>
+    constexpr auto _Compile_time_max_size<drop_while_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        struct _Drop_while_fn {
+            template <viewable_range _Rng, class _Pr>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Pr _Pred)
+                noexcept(noexcept(drop_while_view(_STD forward<_Rng>(_Range), _STD move(_Pred))))
+                requires requires { drop_while_view(static_cast<_Rng&&>(_Range), _STD move(_Pred)); }
+            {
+                return drop_while_view(_STD forward<_Rng>(_Range), _STD move(_Pred));
+            }
+
+            template <class _Pr>
+                requires constructible_from<decay_t<_Pr>, _Pr>
+            _NODISCARD static constexpr auto operator()(_Pr&& _Pred)
+                noexcept(is_nothrow_constructible_v<decay_t<_Pr>, _Pr>) {
+                return _Range_closure<_Drop_while_fn, decay_t<_Pr>>{_STD forward<_Pr>(_Pred)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Drop_while_fn drop_while;
+    } // namespace views
+
+    template <class _Ty>
+    _NODISCARD constexpr _Ty& _As_lvalue(_Ty&& _Val) noexcept {
+        return static_cast<_Ty&>(_Val);
+    }
+
+    struct _Construct_tag {
+        explicit _Construct_tag() = default;
+    };
+
+    _EXPORT_STD template <input_range _Vw>
+        requires view<_Vw> && input_range<range_reference_t<_Vw>>
+    class join_view;
+
+    template <class _Vw>
+    class _Join_view_base : public view_interface<join_view<_Vw>> {
+    private:
+        struct _Cache_wrapper {
+            template <input_iterator _Iter>
+            constexpr _Cache_wrapper(_Construct_tag, const _Iter& _It)
+                noexcept(noexcept(static_cast<decltype(_Val)>(*_It)))
+                : _Val(*_It) {}
+
+            remove_cv_t<range_reference_t<_Vw>> _Val;
+        };
+
+    protected:
+        /* [[no_unique_address]] */ _Non_propagating_cache<_Cache_wrapper, false> _Inner{};
+    };
+
+    template <class _Vw>
+        requires is_reference_v<range_reference_t<_Vw>>
+    class _Join_view_base<_Vw> : public view_interface<join_view<_Vw>> {};
+
+    template <class _Vw>
+    class _Join_view_outer_iter_base : public _Join_view_base<_Vw> {
+    protected:
+        _Non_propagating_cache<iterator_t<_Vw>> _Outer;
+    };
+
+    template <forward_range _Vw>
+    class _Join_view_outer_iter_base<_Vw> : public _Join_view_base<_Vw> {};
+
+    _EXPORT_STD template <input_range _Vw>
+        requires view<_Vw> && input_range<range_reference_t<_Vw>>
+    class join_view : public _Join_view_outer_iter_base<_Vw> {
+    private:
+        template <bool _Const>
+        using _InnerRng = range_reference_t<_Maybe_const<_Const, _Vw>>;
+        /* [[no_unique_address]] */ _Vw _Range{};
+
+        template <class _Outer, class _Inner, bool _Deref_is_glvalue>
+        struct _Category_base {};
+
+        template <forward_range _Outer, forward_range _Inner>
+        struct _Category_base<_Outer, _Inner, true> {
+            using iterator_category =
+                conditional_t<common_range<_Inner>
+                                  && derived_from<_Iter_cat_t<iterator_t<_Outer>>, bidirectional_iterator_tag>
+                                  && derived_from<_Iter_cat_t<iterator_t<_Inner>>, bidirectional_iterator_tag>,
+                    bidirectional_iterator_tag,
+                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_Outer>>, forward_iterator_tag>
+                                      && derived_from<_Iter_cat_t<iterator_t<_Inner>>, forward_iterator_tag>,
+                        forward_iterator_tag, input_iterator_tag>>;
+        };
+
+        template <bool _Const>
+        class _Iterator_base
+            : public _Category_base<_Maybe_const<_Const, _Vw>, _InnerRng<_Const>, is_reference_v<_InnerRng<_Const>>> {};
+
+        template <bool _Const>
+            requires forward_range<_Maybe_const<_Const, _Vw>>
+        class _Iterator_base<_Const>
+            : public _Category_base<_Maybe_const<_Const, _Vw>, _InnerRng<_Const>, is_reference_v<_InnerRng<_Const>>> {
+        protected:
+            using _OuterIter = iterator_t<_Maybe_const<_Const, _Vw>>;
+
+            _Iterator_base() = default;
+            constexpr explicit _Iterator_base(_OuterIter&& _Outer_) : _Outer(_STD move(_Outer_)) {}
+
+            /* [[no_unique_address]] */ _OuterIter _Outer{};
+        };
+
+        template <bool _Const>
+        class _Iterator : public _Iterator_base<_Const> {
+        private:
+            friend join_view;
+
+            using _Mybase    = _Iterator_base<_Const>;
+            using _Parent_t  = _Maybe_const<_Const, join_view>;
+            using _Base      = _Maybe_const<_Const, _Vw>;
+            using _OuterIter = iterator_t<_Base>;
+            using _InnerIter = iterator_t<_InnerRng<_Const>>;
+
+            // True if and only if the expression *i, where i is an iterator from the outer range, is a glvalue:
+            static constexpr bool _Deref_is_glvalue = is_reference_v<_InnerRng<_Const>>;
+
+            /* [[no_unique_address]] */ _Defaultabox<_InnerIter> _Inner{}; // Non-standard extension: when _Inner_iter
+                                                                           // is default-constructible, we don't wrap in
+                                                                           // an optional-like.
+            _Parent_t* _Parent{};
+
+            constexpr _Iterator(_Parent_t& _Parent_, _OuterIter _Outer_)
+                requires forward_range<_Base>
+                : _Mybase{_STD move(_Outer_)}, _Parent{_STD addressof(_Parent_)} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STD _Adl_verify_range(this->_Outer, _RANGES end(_Parent_._Range));
+                _STD _Adl_verify_range(_RANGES begin(_Parent_._Range), this->_Outer);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Satisfy();
+            }
+
+            constexpr explicit _Iterator(_Parent_t& _Parent)
+                requires (!forward_range<_Base>)
+                : _Parent{_STD addressof(_Parent)} {
+                _Satisfy();
+            }
+
+            _NODISCARD constexpr _OuterIter& _Get_outer() noexcept {
+                if constexpr (forward_range<_Base>) {
+                    return this->_Outer;
+                } else {
+                    return *_Parent->_Outer;
+                }
+            }
+
+            _NODISCARD constexpr const _OuterIter& _Get_outer() const noexcept {
+                if constexpr (forward_range<_Base>) {
+                    return this->_Outer;
+                } else {
+                    return *_Parent->_Outer;
+                }
+            }
+
+            constexpr auto&& _Update_inner() {
+                if constexpr (_Deref_is_glvalue) {
+                    return *_Get_outer();
+                } else {
+                    return _Parent->_Inner._Emplace(_Construct_tag{}, _Get_outer())._Val;
+                }
+            }
+
+            constexpr void _Satisfy() {
+                auto& _Outer     = _Get_outer();
+                const auto _Last = _RANGES end(_Parent->_Range);
+                for (; _Outer != _Last; ++_Outer) {
+                    auto&& _Tmp = _Update_inner();
+                    _Inner      = _RANGES begin(_Tmp);
+                    if (*_Inner != _RANGES end(_Tmp)) {
+                        return;
+                    }
+                }
+                if constexpr (_Deref_is_glvalue) {
+                    _Inner._Reset();
+                }
+            }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            constexpr void _Check_dereference() const noexcept {
+                _STL_VERIFY(_Parent != nullptr, "cannot dereference value-initialized join_view iterator");
+                _STL_VERIFY(_Get_outer() != _RANGES end(_Parent->_Range), "cannot dereference join_view end iterator");
+                sentinel_t<_InnerRng<_Const>> _Last;
+                if constexpr (_Deref_is_glvalue) {
+                    _Last = _RANGES end(_RANGES _As_lvalue(*_Get_outer()));
+                } else {
+                    _Last = _RANGES end((*_Parent->_Inner)._Val);
+                }
+                _STL_VERIFY(_Inner && *_Inner != _Last, "cannot dereference join_view end iterator");
+            }
+
+            constexpr void _Same_range(const _Iterator& _Right) const noexcept {
+                _STL_VERIFY(_Parent == _Right._Parent, "cannot compare incompatible join_view iterators");
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        public:
+            using iterator_concept =
+                conditional_t<_Deref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<_InnerRng<_Const>>
+                                  && common_range<_InnerRng<_Const>>,
+                    bidirectional_iterator_tag,
+                    conditional_t<_Deref_is_glvalue && forward_range<_Base> && forward_range<_InnerRng<_Const>>,
+                        forward_iterator_tag, input_iterator_tag>>;
+            using value_type      = range_value_t<_InnerRng<_Const>>;
+            using difference_type = common_type_t<range_difference_t<_Base>, range_difference_t<_InnerRng<_Const>>>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _It)
+                requires _Const && convertible_to<iterator_t<_Vw>, _OuterIter>
+                          && convertible_to<iterator_t<_InnerRng<false>>, _InnerIter>
+                : _Mybase(_STD move(_It._Outer)), _Inner(_STD move(_It._Inner)), _Parent(_It._Parent) {}
+
+            _NODISCARD constexpr decltype(auto) operator*() const noexcept(noexcept(**_Inner)) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Check_dereference();
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return **_Inner;
+            }
+
+            _NODISCARD constexpr _InnerIter operator->() const
+                noexcept(is_nothrow_copy_constructible_v<_InnerIter>) // strengthened
+                requires _Has_arrow<_InnerIter> && copyable<_InnerIter>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Check_dereference();
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return *_Inner;
+            }
+
+            constexpr _Iterator& operator++() {
+                auto& _Outer = _Get_outer();
+                if constexpr (_Deref_is_glvalue) {
+                    if (++*_Inner == _RANGES end(_RANGES _As_lvalue(*_Outer))) {
+                        ++_Outer;
+                        _Satisfy();
+                    }
+                } else {
+                    if (++*_Inner == _RANGES end((*_Parent->_Inner)._Val)) {
+                        ++_Outer;
+                        _Satisfy();
+                    }
+                }
+                return *this;
+            }
+
+            constexpr decltype(auto) operator++(int) {
+                if constexpr (_Deref_is_glvalue && forward_range<_Base> && forward_range<_InnerRng<_Const>>) {
+                    auto _Tmp = *this;
+                    ++*this;
+                    return _Tmp;
+                } else {
+                    ++*this;
+                }
+            }
+
+            constexpr _Iterator& operator--()
+                requires _Deref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<_InnerRng<_Const>>
+                      && common_range<_InnerRng<_Const>>
+            {
+                auto& _Outer = _Get_outer();
+                if (_Outer == _RANGES end(_Parent->_Range)) {
+                    --_Outer;
+                    _Inner = _RANGES end(_RANGES _As_lvalue(*_Outer));
+                }
+                while (*_Inner == _RANGES begin(_RANGES _As_lvalue(*_Outer))) {
+                    --_Outer;
+                    *_Inner = _RANGES end(_RANGES _As_lvalue(*_Outer));
+                }
+                --*_Inner;
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                requires _Deref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<_InnerRng<_Const>>
+                      && common_range<_InnerRng<_Const>>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Outer == _Right._Outer && _Left._Inner == _Right._Inner)) /* strengthened */
+                requires _Deref_is_glvalue && forward_range<_Base> && equality_comparable<_InnerIter>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Left._Same_range(_Right);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _Left._Outer == _Right._Outer && _Left._Inner == _Right._Inner;
+            }
+
+            _NODISCARD friend constexpr decltype(auto) iter_move(const _Iterator& _It)
+                noexcept(noexcept(_RANGES iter_move(*_It._Inner))) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _It._Check_dereference();
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _RANGES iter_move(*_It._Inner);
+            }
+
+            friend constexpr void iter_swap(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_RANGES iter_swap(*_Left._Inner, *_Right._Inner)))
+                requires indirectly_swappable<_InnerIter>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Left._Check_dereference();
+                _Right._Check_dereference();
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _RANGES iter_swap(*_Left._Inner, *_Right._Inner);
+            }
+        };
+
+        template <bool _Const>
+        class _Sentinel {
+        private:
+            friend join_view;
+
+            using _Parent_t = _Maybe_const<_Const, join_view>;
+            using _Base     = _Maybe_const<_Const, _Vw>;
+
+            template <bool _OtherConst>
+            using _Maybe_const_iter = iterator_t<_Maybe_const<_OtherConst, _Vw>>;
+
+            /* [[no_unique_address]] */ sentinel_t<_Base> _Last{};
+
+            template <bool _OtherConst>
+                requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD constexpr bool _Equal(const _Iterator<_OtherConst>& _It) const
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_It._Get_outer() == _Last))) {
+                return _It._Get_outer() == _Last;
+            }
+
+        public:
+            _Sentinel() = default;
+            constexpr explicit _Sentinel(_Parent_t& _Parent)
+                noexcept(noexcept(_RANGES end(_Parent._Range))
+                         && is_nothrow_move_constructible_v<sentinel_t<_Base>>) // strengthened
+                : _Last(_RANGES end(_Parent._Range)) {}
+
+            constexpr _Sentinel(_Sentinel<!_Const> _Se)
+                noexcept(is_nothrow_constructible_v<sentinel_t<_Base>, sentinel_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<sentinel_t<_Vw>, sentinel_t<_Base>>
+                : _Last(_STD move(_Se._Last)) {}
+
+            template <bool _OtherConst>
+                requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_OtherConst>& _Left, const _Sentinel& _Right)
+                noexcept(noexcept(_Right._Equal(_Left))) /* strengthened */ {
+                return _Right._Equal(_Left);
+            }
+        };
+
+    public:
+        join_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit join_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() {
+            if constexpr (forward_range<_Vw>) {
+                constexpr bool _Use_const = _Simple_view<_Vw> && is_reference_v<_InnerRng<false>>;
+                return _Iterator<_Use_const>{*this, _RANGES begin(_Range)};
+            } else {
+                this->_Outer._Emplace(_RANGES begin(_Range));
+                return _Iterator<false>{*this};
+            }
+        }
+
+        _NODISCARD constexpr _Iterator<true> begin() const
+            requires forward_range<const _Vw> && is_reference_v<_InnerRng<true>> && input_range<_InnerRng<true>>
+        {
+            return _Iterator<true>{*this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto end() {
+            if constexpr (forward_range<_Vw> && is_reference_v<_InnerRng<false>> && forward_range<_InnerRng<false>>
+                          && common_range<_Vw> && common_range<_InnerRng<false>>) {
+                return _Iterator<_Simple_view<_Vw>>{*this, _RANGES end(_Range)};
+            } else {
+                return _Sentinel<_Simple_view<_Vw>>{*this};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            requires forward_range<const _Vw> && is_reference_v<_InnerRng<true>> && input_range<_InnerRng<true>>
+        {
+            if constexpr (forward_range<_InnerRng<true>> && common_range<const _Vw> && common_range<_InnerRng<true>>) {
+                return _Iterator<true>{*this, _RANGES end(_Range)};
+            } else {
+                return _Sentinel<true>{*this};
+            }
+        }
+    };
+
+    template <class _Rng>
+    explicit join_view(_Rng&&) -> join_view<views::all_t<_Rng>>;
+
+#if _HAS_CXX23
+    template <class _Rng>
+    _NODISCARD consteval auto _Join_view_compile_time_max_size() {
+        using _Inner = remove_reference_t<range_reference_t<_Rng>>;
+        using _Size_type =
+            common_type_t<decltype(_Compile_time_max_size<_Rng>), decltype(_Compile_time_max_size<_Inner>)>;
+        _Size_type _Result{};
+        const bool _Overflow = _Mul_overflow(static_cast<_Size_type>(_Compile_time_max_size<_Rng>),
+            static_cast<_Size_type>(_Compile_time_max_size<_Inner>), _Result);
+        if (_Overflow) {
+            return (numeric_limits<_Size_type>::max)();
+        } else {
+            return _Result;
+        }
+    }
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<join_view<_Rng>> = _Join_view_compile_time_max_size<_Rng>();
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const join_view<_Rng>> = _Join_view_compile_time_max_size<const _Rng>();
+#endif // _HAS_CXX23
+
+    namespace views {
+        struct _Join_fn : public _Pipe::_Base<_Join_fn> {
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range)
+                noexcept(noexcept(join_view<views::all_t<_Rng>>{_STD forward<_Rng>(_Range)}))
+                requires requires { join_view<views::all_t<_Rng>>{static_cast<_Rng&&>(_Range)}; }
+            {
+                return join_view<views::all_t<_Rng>>{_STD forward<_Rng>(_Range)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Join_fn join;
+    } // namespace views
+
+#if _HAS_CXX23
+    template <class... _Rngs>
+    using _Concat_reference_t = common_reference_t<range_reference_t<_Rngs>...>;
+
+    template <class... _Rngs>
+    using _Concat_value_t = common_type_t<range_value_t<_Rngs>...>;
+
+    template <class... _Rngs>
+    using _Concat_rvalue_reference_t = common_reference_t<range_rvalue_reference_t<_Rngs>...>;
+
+    template <class _Ref, class _RRef, class _It>
+    concept _Concat_indirectly_readable_impl = requires(const _It __i) {
+        { *__i } -> convertible_to<_Ref>;
+        { _RANGES iter_move(__i) } -> convertible_to<_RRef>;
+    };
+
+    template <class... _Rngs>
+    concept _Concat_indirectly_readable =
+        common_reference_with<_Concat_reference_t<_Rngs...>&&, _Concat_value_t<_Rngs...>&>
+        && common_reference_with<_Concat_reference_t<_Rngs...>&&, _Concat_rvalue_reference_t<_Rngs...>&&>
+        && common_reference_with<_Concat_rvalue_reference_t<_Rngs...>&&, const _Concat_value_t<_Rngs...>&>
+        && (_Concat_indirectly_readable_impl<_Concat_reference_t<_Rngs...>, _Concat_rvalue_reference_t<_Rngs...>,
+                iterator_t<_Rngs>>
+            && ...);
+
+    template <class... _Rngs>
+    concept _Concatable = requires {
+        typename _Concat_reference_t<_Rngs...>;
+        typename _Concat_value_t<_Rngs...>;
+        typename _Concat_rvalue_reference_t<_Rngs...>;
+    } && _Concat_indirectly_readable<_Rngs...>;
+
+    _EXPORT_STD template <input_range _Vw, forward_range _Pat>
+        requires view<_Vw> && input_range<range_reference_t<_Vw>> && view<_Pat>
+              && _Concatable<range_reference_t<_Vw>, _Pat>
+    class join_with_view;
+
+    template <class _Vw, class _Pat>
+    class _Join_with_view_base : public view_interface<join_with_view<_Vw, _Pat>> {
+    private:
+        struct _Cache_wrapper {
+            template <input_iterator _Iter>
+            constexpr _Cache_wrapper(_Construct_tag, const _Iter& _It)
+                noexcept(noexcept(static_cast<decltype(_Val)>(*_It)))
+                : _Val(*_It) {}
+
+            remove_cv_t<range_reference_t<_Vw>> _Val;
+        };
+
+    protected:
+        /* [[no_unique_address]] */ _Non_propagating_cache<_Cache_wrapper, false> _Inner{};
+    };
+
+    template <class _Vw, class _Pat>
+        requires is_reference_v<range_reference_t<_Vw>>
+    class _Join_with_view_base<_Vw, _Pat> : public view_interface<join_with_view<_Vw, _Pat>> {};
+
+    template <class _Vw, class _Pat>
+    class _Join_with_view_outer_iter_base : public _Join_with_view_base<_Vw, _Pat> {
+    protected:
+        _Non_propagating_cache<iterator_t<_Vw>> _Outer_it;
+    };
+
+    template <forward_range _Vw, class _Pat>
+    class _Join_with_view_outer_iter_base<_Vw, _Pat> : public _Join_with_view_base<_Vw, _Pat> {};
+
+    _EXPORT_STD template <input_range _Vw, forward_range _Pat>
+        requires view<_Vw> && input_range<range_reference_t<_Vw>> && view<_Pat>
+              && _Concatable<range_reference_t<_Vw>, _Pat>
+    class join_with_view : public _Join_with_view_outer_iter_base<_Vw, _Pat> {
+    private:
+        template <bool _Const>
+        using _InnerRng = range_reference_t<_Maybe_const<_Const, _Vw>>;
+
+        /* [[no_unique_address]] */ _Vw _Range{};
+        /* [[no_unique_address]] */ _Pat _Pattern{};
+
+        template <bool _Const>
+        struct _Category_base {};
+
+        template <bool _Const>
+            requires forward_range<_Maybe_const<_Const, _Vw>> && forward_range<_InnerRng<_Const>>
+                  && is_reference_v<_InnerRng<_Const>>
+        struct _Category_base<_Const> {
+            using _Outer       = _Maybe_const<_Const, _Vw>;
+            using _Inner       = _InnerRng<_Const>;
+            using _PatternBase = _Maybe_const<_Const, _Pat>;
+
+            using iterator_category = conditional_t<
+                !is_reference_v<common_reference_t<range_reference_t<_Inner>, range_reference_t<_PatternBase>>>,
+                input_iterator_tag,
+                conditional_t<common_range<_Inner> && common_range<_PatternBase>
+                                  && derived_from<_Iter_cat_t<iterator_t<_Outer>>, bidirectional_iterator_tag>
+                                  && derived_from<_Iter_cat_t<iterator_t<_Inner>>, bidirectional_iterator_tag>
+                                  && derived_from<_Iter_cat_t<iterator_t<_PatternBase>>, bidirectional_iterator_tag>,
+                    bidirectional_iterator_tag,
+                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_Outer>>, forward_iterator_tag>
+                                      && derived_from<_Iter_cat_t<iterator_t<_Inner>>, forward_iterator_tag>
+                                      && derived_from<_Iter_cat_t<iterator_t<_PatternBase>>, forward_iterator_tag>,
+                        forward_iterator_tag, input_iterator_tag>>>;
+        };
+
+        template <bool _Const>
+        class _Iterator_base : public _Category_base<_Const> {};
+
+        template <bool _Const>
+            requires forward_range<_Maybe_const<_Const, _Vw>>
+        class _Iterator_base<_Const> : public _Category_base<_Const> {
+        protected:
+            using _OuterIter = iterator_t<_Maybe_const<_Const, _Vw>>;
+
+            _Iterator_base() = default;
+            constexpr explicit _Iterator_base(_OuterIter&& _Outer_it_) : _Outer_it(_STD move(_Outer_it_)) {}
+
+            /* [[no_unique_address]] */ _OuterIter _Outer_it{};
+        };
+
+        template <bool _Const>
+        class _Iterator : public _Iterator_base<_Const> {
+        private:
+            friend join_with_view;
+
+            using _Mybase      = _Iterator_base<_Const>;
+            using _Parent_t    = _Maybe_const<_Const, join_with_view>;
+            using _Base        = _Maybe_const<_Const, _Vw>;
+            using _PatternBase = _Maybe_const<_Const, _Pat>;
+
+            using _OuterIter   = iterator_t<_Base>;
+            using _InnerIter   = iterator_t<_InnerRng<_Const>>;
+            using _PatternIter = iterator_t<_PatternBase>;
+
+            // True if and only if the expression *i, where i is an iterator from the outer range, is a glvalue:
+            static constexpr bool _Deref_is_glvalue = is_reference_v<_InnerRng<_Const>>;
+
+            _Parent_t* _Parent{};
+            _Variantish<_PatternIter, _InnerIter> _Inner_it{};
+
+            constexpr _Iterator(_Parent_t& _Parent_, _OuterIter _Outer_)
+                requires forward_range<_Base>
+                : _Mybase(_STD move(_Outer_)), _Parent(_STD addressof(_Parent_)) {
+                if (this->_Outer_it != _RANGES end(_Parent->_Range)) {
+                    _Inner_it._Emplace_second(_RANGES begin(_Update_inner()));
+                    _Satisfy();
+                }
+            }
+
+            constexpr explicit _Iterator(_Parent_t& _Parent_)
+                requires (!forward_range<_Base>)
+                : _Parent{_STD addressof(_Parent_)} {
+                if (*_Parent->_Outer_it != _RANGES end(_Parent->_Range)) {
+                    _Inner_it._Emplace_second(_RANGES begin(_Update_inner()));
+                    _Satisfy();
+                }
+            }
+
+            _NODISCARD constexpr _OuterIter& _Get_outer() noexcept {
+                if constexpr (forward_range<_Base>) {
+                    return this->_Outer_it;
+                } else {
+                    return *_Parent->_Outer_it;
+                }
+            }
+
+            _NODISCARD constexpr const _OuterIter& _Get_outer() const noexcept {
+                if constexpr (forward_range<_Base>) {
+                    return this->_Outer_it;
+                } else {
+                    return *_Parent->_Outer_it;
+                }
+            }
+
+            _NODISCARD constexpr auto& _Update_inner() {
+                if constexpr (_Deref_is_glvalue) {
+                    return _RANGES _As_lvalue(*_Get_outer());
+                } else {
+                    return _Parent->_Inner._Emplace(_Construct_tag{}, _Get_outer())._Val;
+                }
+            }
+
+            _NODISCARD constexpr auto& _Get_inner() noexcept {
+                if constexpr (_Deref_is_glvalue) {
+                    return _RANGES _As_lvalue(*_Get_outer());
+                } else {
+                    return (*_Parent->_Inner)._Val;
+                }
+            }
+
+            template <class _Ret = void>
+            constexpr _Ret _Visit_inner_it(auto&& _Func) const {
+                if (_Inner_it._Contains == _Variantish_state::_Holds_first) {
+                    return _Func(_Inner_it._Get_first());
+                } else if (_Inner_it._Contains == _Variantish_state::_Holds_second) {
+                    return _Func(_Inner_it._Get_second());
+                } else {
+                    _STD _Throw_bad_variant_access();
+                }
+            }
+
+            constexpr void _Satisfy() {
+                for (;;) {
+                    if (_Inner_it._Contains == _Variantish_state::_Holds_first) {
+                        if (_Inner_it._Get_first() != _RANGES end(_Parent->_Pattern)) {
+                            break;
+                        }
+
+                        _Inner_it._Emplace_second(_RANGES begin(_Update_inner()));
+                    } else {
+                        _STL_INTERNAL_CHECK(_Inner_it._Contains == _Variantish_state::_Holds_second);
+
+                        if (_Inner_it._Get_second() != _RANGES end(_Get_inner())) {
+                            break;
+                        }
+
+                        auto& _Outer_it = _Get_outer();
+                        ++_Outer_it;
+                        if (_Outer_it == _RANGES end(_Parent->_Range)) {
+                            if constexpr (_Deref_is_glvalue) {
+                                _Inner_it._Emplace_first();
+                            }
+                            break;
+                        }
+
+                        _Inner_it._Emplace_first(_RANGES begin(_Parent->_Pattern));
+                    }
+                }
+            }
+
+        public:
+            using iterator_concept =
+                conditional_t<_Deref_is_glvalue && bidirectional_range<_Base> && _Bidi_common_range<_InnerRng<_Const>>
+                                  && _Bidi_common_range<_PatternBase>,
+                    bidirectional_iterator_tag,
+                    conditional_t<_Deref_is_glvalue && forward_range<_Base> && forward_range<_InnerRng<_Const>>,
+                        forward_iterator_tag, input_iterator_tag>>;
+            using value_type      = common_type_t<iter_value_t<_InnerIter>, iter_value_t<_PatternIter>>;
+            using difference_type = _Common_diff_t<_OuterIter, _InnerIter, _PatternIter>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _It)
+                requires _Const && convertible_to<iterator_t<_Vw>, _OuterIter>
+                          && convertible_to<iterator_t<_InnerRng<false>>, _InnerIter>
+                          && convertible_to<iterator_t<_Pat>, _PatternIter>
+                : _Mybase(_STD move(_It._Outer_it)), _Parent(_It._Parent) {
+                switch (_It._Inner_it._Contains) {
+                case _Variantish_state::_Holds_first:
+                    _Inner_it._Emplace_first(_STD move(_It._Inner_it._Get_first()));
+                    break;
+                case _Variantish_state::_Holds_second:
+                    _Inner_it._Emplace_second(_STD move(_It._Inner_it._Get_second()));
+                    break;
+                case _Variantish_state::_Nothing:
+                    _STD _Throw_bad_variant_access();
+                }
+            }
+
+            _NODISCARD constexpr decltype(auto) operator*() const {
+                using _Ref = common_reference_t<iter_reference_t<_InnerIter>, iter_reference_t<_PatternIter>>;
+                return _Visit_inner_it<_Ref>([](auto&& _It) static -> _Ref { return *_It; });
+            }
+
+            constexpr _Iterator& operator++() {
+                switch (_Inner_it._Contains) {
+                case _Variantish_state::_Holds_first:
+                    ++_Inner_it._Get_first();
+                    break;
+                case _Variantish_state::_Holds_second:
+                    ++_Inner_it._Get_second();
+                    break;
+                case _Variantish_state::_Nothing:
+                    _STD _Throw_bad_variant_access();
+                }
+                _Satisfy();
+                return *this;
+            }
+
+            constexpr void operator++(int) {
+                ++*this;
+            }
+
+            constexpr _Iterator operator++(int)
+                requires _Deref_is_glvalue && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
+            {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--()
+                requires _Deref_is_glvalue && bidirectional_range<_Base> && _Bidi_common_range<_InnerRng<_Const>>
+                      && _Bidi_common_range<_PatternBase>
+            {
+                auto& _Outer_it = _Get_outer();
+                if (_Outer_it == _RANGES end(_Parent->_Range)) {
+                    --_Outer_it;
+                    _Inner_it._Emplace_second(_RANGES end(_Get_inner()));
+                }
+
+                for (;;) {
+                    if (_Inner_it._Contains == _Variantish_state::_Holds_first) {
+                        auto& _It = _Inner_it._Get_first();
+                        if (_It == _RANGES begin(_Parent->_Pattern)) {
+                            --_Outer_it;
+                            _Inner_it._Emplace_second(_RANGES end(_Get_inner()));
+                        } else {
+                            break;
+                        }
+                    } else if (_Inner_it._Contains == _Variantish_state::_Holds_second) {
+                        auto& _It = _Inner_it._Get_second();
+                        if (_It == _RANGES begin(_Get_inner())) {
+                            _Inner_it._Emplace_first(_RANGES end(_Parent->_Pattern));
+                        } else {
+                            break;
+                        }
+                    } else {
+                        _STD _Throw_bad_variant_access();
+                    }
+                }
+
+                switch (_Inner_it._Contains) {
+                case _Variantish_state::_Holds_first:
+                    --_Inner_it._Get_first();
+                    break;
+                case _Variantish_state::_Holds_second:
+                    --_Inner_it._Get_second();
+                    break;
+                case _Variantish_state::_Nothing:
+                    _STD _Throw_bad_variant_access();
+                }
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                requires _Deref_is_glvalue && bidirectional_range<_Base> && _Bidi_common_range<_InnerRng<_Const>>
+                      && _Bidi_common_range<_PatternBase>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                requires _Deref_is_glvalue && forward_range<_Base> && equality_comparable<_InnerIter>
+            {
+                if (_Left._Outer_it != _Right._Outer_it) {
+                    return false;
+                }
+
+                if (_Left._Inner_it._Contains != _Right._Inner_it._Contains) {
+                    return false;
+                }
+
+                switch (_Left._Inner_it._Contains) {
+                case _Variantish_state::_Holds_first:
+                    return _Left._Inner_it._Get_first() == _Right._Inner_it._Get_first();
+                case _Variantish_state::_Holds_second:
+                    return _Left._Inner_it._Get_second() == _Right._Inner_it._Get_second();
+                case _Variantish_state::_Nothing:
+                    return true;
+                }
+
+                _STL_UNREACHABLE;
+            }
+
+            _NODISCARD friend constexpr decltype(auto) iter_move(const _Iterator& _It) {
+                using _Rvalue_ref =
+                    common_reference_t<iter_rvalue_reference_t<_InnerIter>, iter_rvalue_reference_t<_PatternIter>>;
+                return _It._Visit_inner_it<_Rvalue_ref>(_RANGES iter_move);
+            }
+
+            friend constexpr void iter_swap(const _Iterator& _Left, const _Iterator& _Right)
+                requires indirectly_swappable<_InnerIter, _PatternIter>
+            {
+                switch (_Left._Inner_it._Contains) {
+                case _Variantish_state::_Holds_first:
+                    switch (_Right._Inner_it._Contains) {
+                    case _Variantish_state::_Holds_first:
+                        return _RANGES iter_swap(_Left._Inner_it._Get_first(), _Right._Inner_it._Get_first());
+                    case _Variantish_state::_Holds_second:
+                        return _RANGES iter_swap(_Left._Inner_it._Get_first(), _Right._Inner_it._Get_second());
+                    case _Variantish_state::_Nothing:
+                        break;
+                    }
+                    break;
+                case _Variantish_state::_Holds_second:
+                    switch (_Right._Inner_it._Contains) {
+                    case _Variantish_state::_Holds_first:
+                        return _RANGES iter_swap(_Left._Inner_it._Get_second(), _Right._Inner_it._Get_first());
+                    case _Variantish_state::_Holds_second:
+                        return _RANGES iter_swap(_Left._Inner_it._Get_second(), _Right._Inner_it._Get_second());
+                    case _Variantish_state::_Nothing:
+                        break;
+                    }
+                    break;
+                case _Variantish_state::_Nothing:
+                    break;
+                }
+
+                _STD _Throw_bad_variant_access();
+            }
+        };
+
+        template <bool _Const>
+        class _Sentinel {
+        private:
+            friend join_with_view;
+
+            using _Parent_t = _Maybe_const<_Const, join_with_view>;
+            using _Base     = _Maybe_const<_Const, _Vw>;
+
+            _MSVC_NO_UNIQUE_ADDRESS sentinel_t<_Base> _Last{};
+
+            constexpr explicit _Sentinel(_Parent_t& _Parent)
+                noexcept(noexcept(_RANGES end(_Parent._Range))
+                         && is_nothrow_move_constructible_v<sentinel_t<_Base>>) // strengthened
+                : _Last(_RANGES end(_Parent._Range)) {}
+
+            template <bool _OtherConst>
+            _NODISCARD constexpr bool _Equal(const _Iterator<_OtherConst>& _It) const
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_It._Get_outer() == _Last))) {
+                _STL_INTERNAL_STATIC_ASSERT(
+                    sentinel_for<sentinel_t<_Base>, iterator_t<_Maybe_const<_OtherConst, _Vw>>>);
+                return _It._Get_outer() == _Last;
+            }
+
+        public:
+            _Sentinel() = default;
+
+            constexpr _Sentinel(_Sentinel<!_Const> _Se)
+                noexcept(is_nothrow_constructible_v<sentinel_t<_Base>, sentinel_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<sentinel_t<_Vw>, sentinel_t<_Base>>
+                : _Last(_STD move(_Se._Last)) {}
+
+            template <bool _OtherConst>
+                requires sentinel_for<sentinel_t<_Base>, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_OtherConst>& _Left, const _Sentinel& _Right)
+                noexcept(noexcept(_Right._Equal(_Left))) /* strengthened */ {
+                return _Right._Equal(_Left);
+            }
+        };
+
+    public:
+        join_with_view()
+            requires default_initializable<_Vw> && default_initializable<_Pat>
+        = default;
+
+        constexpr explicit join_with_view(_Vw _Range_, _Pat _Pattern_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Pat>) // strengthened
+            : _Range{_STD move(_Range_)}, _Pattern{_STD move(_Pattern_)} {}
+
+        template <input_range _Rng>
+            requires constructible_from<_Vw, views::all_t<_Rng>>
+                      && constructible_from<_Pat, single_view<range_value_t<_InnerRng<false>>>>
+        constexpr explicit join_with_view(_Rng&& _Range_, range_value_t<_InnerRng<false>> _Elem)
+            noexcept(noexcept(_Vw(views::all(_STD forward<_Rng>(_Range_))))
+                     && noexcept(_Pat(views::single(_STD move(_Elem))))) // strengthened
+            : _Range(views::all(_STD forward<_Rng>(_Range_))), _Pattern(views::single(_STD move(_Elem))) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() {
+            if constexpr (forward_range<_Vw>) {
+                constexpr bool _Use_const = _Simple_view<_Vw> && is_reference_v<_InnerRng<false>> && _Simple_view<_Pat>;
+                return _Iterator<_Use_const>{*this, _RANGES begin(_Range)};
+            } else {
+                this->_Outer_it._Emplace(_RANGES begin(_Range));
+                return _Iterator<false>{*this};
+            }
+        }
+
+        _NODISCARD constexpr auto begin() const
+            requires forward_range<const _Vw> && forward_range<const _Pat> && is_reference_v<_InnerRng<true>>
+                  && input_range<_InnerRng<true>> && _Concatable<range_reference_t<const _Vw>, const _Pat>
+        {
+            return _Iterator<true>{*this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto end() {
+            constexpr bool _Both_simple = _Simple_view<_Vw> && _Simple_view<_Pat>;
+            if constexpr (forward_range<_Vw> && is_reference_v<_InnerRng<false>> && forward_range<_InnerRng<false>>
+                          && common_range<_Vw> && common_range<_InnerRng<false>>) {
+                return _Iterator<_Both_simple>{*this, _RANGES end(_Range)};
+            } else {
+                return _Sentinel<_Both_simple>{*this};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            requires forward_range<const _Vw> && forward_range<const _Pat> && is_reference_v<_InnerRng<true>>
+                  && input_range<_InnerRng<true>> && _Concatable<range_reference_t<const _Vw>, const _Pat>
+        {
+            if constexpr (forward_range<_InnerRng<true>> && common_range<_Vw> && common_range<_InnerRng<true>>) {
+                return _Iterator<true>{*this, _RANGES end(_Range)};
+            } else {
+                return _Sentinel<true>{*this};
+            }
+        }
+    };
+
+    template <class _Rng, class _Pat>
+    join_with_view(_Rng&&, _Pat&&) -> join_with_view<views::all_t<_Rng>, views::all_t<_Pat>>;
+
+    template <input_range _Rng>
+    join_with_view(_Rng&&, range_value_t<range_reference_t<_Rng>>)
+        -> join_with_view<views::all_t<_Rng>, single_view<range_value_t<range_reference_t<_Rng>>>>;
+
+    template <class _Rng, class _Pat>
+    _NODISCARD consteval auto _Join_with_view_compile_time_max_size() {
+        using _Inner     = remove_reference_t<range_reference_t<_Rng>>;
+        using _Size_type = common_type_t<decltype(_Compile_time_max_size<_Rng>),
+            decltype(_Compile_time_max_size<_Inner>), decltype(_Compile_time_max_size<_Pat>)>;
+        _Size_type _Joined_max_size{};
+        _Size_type _Pattern_max_size{};
+        _Size_type _Result{};
+        const bool _Overflow =
+            _Mul_overflow(static_cast<_Size_type>(_Compile_time_max_size<_Rng>),
+                static_cast<_Size_type>(_Compile_time_max_size<_Inner>), _Joined_max_size)
+            || _Mul_overflow((_STD max) (static_cast<_Size_type>(_Compile_time_max_size<_Rng>), _Size_type{1}) - 1,
+                static_cast<_Size_type>(_Compile_time_max_size<_Pat>), _Pattern_max_size)
+            || _Add_overflow(_Joined_max_size, _Pattern_max_size, _Result);
+        if (_Overflow) {
+            return (numeric_limits<_Size_type>::max)();
+        } else {
+            return _Result;
+        }
+    }
+
+    template <class _Rng, class _Pat>
+    constexpr auto _Compile_time_max_size<join_with_view<_Rng, _Pat>> =
+        _Join_with_view_compile_time_max_size<_Rng, _Pat>();
+
+    template <class _Rng, class _Pat>
+    constexpr auto _Compile_time_max_size<const join_with_view<_Rng, _Pat>> =
+        _Join_with_view_compile_time_max_size<const _Rng, const _Pat>();
+
+    namespace views {
+        struct _Join_with_fn {
+            template <viewable_range _Rng, class _Pat>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Pat&& _Pattern)
+                noexcept(noexcept(join_with_view(_STD forward<_Rng>(_Range), _STD forward<_Pat>(_Pattern))))
+                requires requires { join_with_view(_STD forward<_Rng>(_Range), _STD forward<_Pat>(_Pattern)); }
+            {
+                return join_with_view(_STD forward<_Rng>(_Range), _STD forward<_Pat>(_Pattern));
+            }
+
+            template <class _Delim>
+                requires constructible_from<decay_t<_Delim>, _Delim>
+            _NODISCARD static constexpr auto operator()(_Delim&& _Delimiter)
+                noexcept(is_nothrow_constructible_v<decay_t<_Delim>, _Delim>) {
+                return _Range_closure<_Join_with_fn, decay_t<_Delim>>{_STD forward<_Delim>(_Delimiter)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Join_with_fn join_with;
+    } // namespace views
+#endif // _HAS_CXX23
+
+    template <class _Ty>
+    concept _Tiny_range = sized_range<_Ty> && requires { typename _Require_constant<remove_reference_t<_Ty>::size()>; }
+                       && (remove_reference_t<_Ty>::size() <= 1);
+
+    _EXPORT_STD template <input_range _Vw, forward_range _Pat>
+        requires (view<_Vw> && view<_Pat> && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, _RANGES equal_to>
+                  && (forward_range<_Vw> || _Tiny_range<_Pat>) )
+    class lazy_split_view;
+
+    template <class _Vw, class _Pat>
+    class _Lazy_split_view_base : public view_interface<lazy_split_view<_Vw, _Pat>> {
+    protected:
+        /* [[no_unique_address]] */ _Defaultabox<iterator_t<_Vw>> _Current{};
+    };
+
+    template <forward_range _Vw, class _Pat>
+    class _Lazy_split_view_base<_Vw, _Pat> : public view_interface<lazy_split_view<_Vw, _Pat>> {};
+
+    _EXPORT_STD template <input_range _Vw, forward_range _Pat>
+        requires (view<_Vw> && view<_Pat> && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, _RANGES equal_to>
+                  && (forward_range<_Vw> || _Tiny_range<_Pat>) )
+    class lazy_split_view : public _Lazy_split_view_base<_Vw, _Pat> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        /* [[no_unique_address]] */ _Pat _Pattern{};
+
+        template <bool>
+        class _Inner_iter;
+
+        template <class>
+        class _Outer_iter_base {};
+
+        template <forward_iterator _Iter>
+        class _Outer_iter_base<_Iter> {
+        protected:
+            _Iter _Current{};
+
+        public:
+            using iterator_category = input_iterator_tag;
+
+            _Outer_iter_base() = default;
+            constexpr explicit _Outer_iter_base(_Iter _Current_) noexcept(is_nothrow_move_constructible_v<_Iter>)
+                : _Current{_STD move(_Current_)} {}
+        };
+
+        template <bool _Const>
+        class _Outer_iter : public _Outer_iter_base<iterator_t<_Maybe_const<_Const, _Vw>>> {
+        private:
+            friend lazy_split_view;
+
+            using _Mybase   = _Outer_iter_base<iterator_t<_Maybe_const<_Const, _Vw>>>;
+            using _ParentTy = _Maybe_const<_Const, lazy_split_view>;
+            using _BaseTy   = _Maybe_const<_Const, _Vw>;
+
+            _ParentTy* _Parent   = nullptr;
+            bool _Trailing_empty = false;
+
+            _NODISCARD constexpr iterator_t<_BaseTy>& _Get_current() noexcept {
+                if constexpr (forward_range<_BaseTy>) {
+                    return this->_Current;
+                } else {
+                    return *_Parent->_Current;
+                }
+            }
+
+            _NODISCARD constexpr const iterator_t<_BaseTy>& _Get_current() const noexcept {
+                if constexpr (forward_range<_BaseTy>) {
+                    return this->_Current;
+                } else {
+                    return *_Parent->_Current;
+                }
+            }
+
+            _NODISCARD constexpr bool _At_end() const
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Get_current() == _RANGES end(_Parent->_Range)))) {
+                return _Get_current() == _RANGES end(_Parent->_Range);
+            }
+
+        public:
+            using iterator_concept = conditional_t<forward_range<_BaseTy>, forward_iterator_tag, input_iterator_tag>;
+            using difference_type  = range_difference_t<_BaseTy>;
+
+            class value_type : public view_interface<value_type> {
+            private:
+                /* [[no_unique_address]] */ _Outer_iter _First{};
+
+                constexpr explicit value_type(_Outer_iter _First_)
+                    noexcept(is_nothrow_move_constructible_v<_Outer_iter>)
+                    : _First{_STD move(_First_)} {}
+
+                friend _Outer_iter;
+
+            public:
+                _NODISCARD constexpr auto begin() const {
+                    return _Inner_iter<_Const>{_First};
+                }
+
+                _NODISCARD constexpr default_sentinel_t end() const noexcept {
+                    return default_sentinel;
+                }
+            };
+
+            _Outer_iter() = default;
+
+            constexpr explicit _Outer_iter(_ParentTy& _Parent_) noexcept // strengthened
+                requires (!forward_range<_BaseTy>)
+                : _Parent{_STD addressof(_Parent_)} {}
+
+            constexpr _Outer_iter(_ParentTy& _Parent_, iterator_t<_BaseTy> _Current_)
+                noexcept(is_nothrow_move_constructible_v<iterator_t<_BaseTy>>) // strengthened
+                requires forward_range<_BaseTy>
+                : _Mybase{_STD move(_Current_)}, _Parent{_STD addressof(_Parent_)} {}
+
+            constexpr _Outer_iter(_Outer_iter<!_Const> _It)
+                requires _Const && convertible_to<iterator_t<_Vw>, iterator_t<_BaseTy>>
+                : _Mybase{_STD move(_It._Current)}, _Parent{_It._Parent}, _Trailing_empty{_It._Trailing_empty} {}
+
+            _NODISCARD constexpr auto operator*() const noexcept(noexcept(value_type{*this})) /* strengthened */ {
+                return value_type{*this};
+            }
+
+            constexpr _Outer_iter& operator++() {
+                const auto _End = _RANGES end(_Parent->_Range);
+                auto& _Cur      = _Get_current();
+                if (_Cur == _End) {
+                    _Trailing_empty = false;
+                    return *this;
+                }
+
+                const auto _Pat_first = _RANGES begin(_Parent->_Pattern);
+                const auto _Pat_last  = _RANGES end(_Parent->_Pattern);
+                if (_Pat_first == _Pat_last) {
+                    ++_Cur;
+                } else if constexpr (_Tiny_range<_Pat>) {
+                    _Cur = _RANGES _Find_unchecked(_STD move(_Cur), _End, *_Pat_first);
+                    if (_Cur != _End) {
+                        ++_Cur;
+                        if (_Cur == _End) {
+                            _Trailing_empty = true;
+                        }
+                    }
+                } else {
+                    do {
+                        auto _Result = _RANGES mismatch(_Cur, _End, _Pat_first, _Pat_last);
+                        if (_Result.in2 == _Pat_last) { // pattern matches
+                            _Cur = _STD move(_Result.in1);
+                            if (_Cur == _End) {
+                                _Trailing_empty = true;
+                            }
+                            break;
+                        }
+                    } while (++_Cur != _End);
+                }
+                return *this;
+            }
+
+            constexpr decltype(auto) operator++(int) {
+                if constexpr (forward_range<_BaseTy>) {
+                    auto _Tmp = *this;
+                    ++*this;
+                    return _Tmp;
+                } else {
+                    ++*this;
+                }
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Outer_iter& _Left, const _Outer_iter& _Right)
+                noexcept(noexcept(_Left._Current == _Right._Current)) /* strengthened */
+                requires forward_range<_BaseTy>
+            {
+                return _Left._Current == _Right._Current && _Left._Trailing_empty == _Right._Trailing_empty;
+            }
+            _NODISCARD friend constexpr bool operator==(const _Outer_iter& _Left, default_sentinel_t)
+                noexcept(noexcept(_Left._At_end())) /* strengthened */ {
+                return _Left._At_end() && !_Left._Trailing_empty;
+            }
+        };
+
+        template <class _BaseTy>
+        class _Inner_iter_base {};
+
+        template <forward_range _BaseTy>
+        class _Inner_iter_base<_BaseTy> {
+        private:
+            using _BaseCategory = iterator_traits<iterator_t<_BaseTy>>::iterator_category;
+
+        public:
+            using iterator_category =
+                conditional_t<derived_from<_BaseCategory, forward_iterator_tag>, forward_iterator_tag, _BaseCategory>;
+        };
+
+        template <bool _Const>
+        class _Inner_iter : public _Inner_iter_base<_Maybe_const<_Const, _Vw>> {
+        private:
+            using _BaseTy = _Maybe_const<_Const, _Vw>;
+
+            _Outer_iter<_Const> _It{};
+            bool _Incremented = false;
+
+            _NODISCARD constexpr bool _Equal(const _Inner_iter& _Right) const {
+                return _It._Get_current() == _Right._It._Get_current();
+            }
+
+            _NODISCARD constexpr iterator_t<_BaseTy>& _Get_current() noexcept {
+                return _It._Get_current();
+            }
+
+            _NODISCARD constexpr const iterator_t<_BaseTy>& _Get_current() const noexcept {
+                return _It._Get_current();
+            }
+
+            _NODISCARD constexpr bool _At_end() const {
+                auto _Pat_pos       = _RANGES begin(_It._Parent->_Pattern);
+                const auto _Pat_end = _RANGES end(_It._Parent->_Pattern);
+                auto _Last          = _RANGES end(_It._Parent->_Range);
+                if constexpr (_Tiny_range<_Pat>) {
+                    const auto& _Cur = _It._Get_current(); // Intentionally a reference. Since _Pat is tiny, this could
+                                                           // be a move-only iterator type.
+                    if (_Cur == _Last) {
+                        return true;
+                    }
+
+                    if (_Pat_pos == _Pat_end) {
+                        return _Incremented;
+                    }
+                    return *_Cur == *_Pat_pos;
+                } else {
+                    auto _Cur = _It._Get_current(); // Intentionally not a reference. _Pat is not tiny, so this is a
+                                                    // forward (copyable) iterator.
+                    if (_Cur == _Last) {
+                        return true;
+                    }
+
+                    if (_Pat_pos == _Pat_end) {
+                        return _Incremented;
+                    }
+
+                    do {
+                        if (*_Cur != *_Pat_pos) {
+                            return false;
+                        }
+
+                        if (++_Pat_pos == _Pat_end) {
+                            return true;
+                        }
+                    } while (++_Cur != _Last);
+                    return false;
+                }
+            }
+
+        public:
+            using iterator_concept = _Outer_iter<_Const>::iterator_concept;
+            using value_type       = range_value_t<_BaseTy>;
+            using difference_type  = range_difference_t<_BaseTy>;
+
+            _Inner_iter() = default;
+            constexpr explicit _Inner_iter(_Outer_iter<_Const> _It_)
+                noexcept(is_nothrow_move_constructible_v<_Outer_iter<_Const>>) // strengthened
+                : _It{_STD move(_It_)} {}
+
+            _NODISCARD constexpr const iterator_t<_BaseTy>& base() const& noexcept {
+                return _It._Get_current();
+            }
+
+            _NODISCARD constexpr iterator_t<_BaseTy> base() && noexcept(
+                is_nothrow_move_constructible_v<iterator_t<_BaseTy>>) /* strengthened */
+                requires forward_range<_Vw>
+            {
+                return _STD move(_It._Get_current());
+            }
+
+            _NODISCARD constexpr decltype(auto) operator*() const {
+                return *_It._Get_current();
+            }
+
+            constexpr _Inner_iter& operator++() {
+                _Incremented = true;
+                if constexpr (!forward_range<_BaseTy>) {
+                    if constexpr (_Pat::size() == 0) {
+                        return *this;
+                    }
+                }
+                ++_It._Get_current();
+                return *this;
+            }
+
+            constexpr decltype(auto) operator++(int) {
+                if constexpr (forward_range<_BaseTy>) {
+                    auto _Tmp = *this;
+                    ++*this;
+                    return _Tmp;
+                } else {
+                    ++*this;
+                }
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Inner_iter& _Left, const _Inner_iter& _Right)
+                requires forward_range<_BaseTy>
+            {
+                return _Left._Equal(_Right);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Inner_iter& _Left, default_sentinel_t) {
+                return _Left._At_end();
+            }
+
+            _NODISCARD friend constexpr decltype(auto) iter_move(const _Inner_iter& _Iter)
+                noexcept(noexcept(_RANGES iter_move(_Iter._Get_current()))) {
+                return _RANGES iter_move(_Iter._Get_current());
+            }
+
+            friend constexpr void iter_swap(const _Inner_iter& _Left, const _Inner_iter& _Right)
+                noexcept(noexcept(_RANGES iter_swap(_Left._Get_current(), _Right._Get_current())))
+                requires indirectly_swappable<iterator_t<_BaseTy>>
+            {
+                _RANGES iter_swap(_Left._Get_current(), _Right._Get_current());
+            }
+        };
+
+    public:
+        lazy_split_view()
+            requires default_initializable<_Vw> && default_initializable<_Pat>
+        = default;
+
+        constexpr explicit lazy_split_view(_Vw _Range_, _Pat _Pattern_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Pat>) // strengthened
+            : _Range(_STD move(_Range_)), _Pattern(_STD move(_Pattern_)) {}
+
+        template <input_range _Rng>
+            requires constructible_from<_Vw, views::all_t<_Rng>>
+                      && constructible_from<_Pat, single_view<range_value_t<_Rng>>>
+        constexpr explicit lazy_split_view(_Rng&& _Range_, range_value_t<_Rng> _Elem)
+            noexcept(noexcept(_Vw(views::all(_STD forward<_Rng>(_Range_))))
+                     && noexcept(_Pat(views::single(_STD move(_Elem))))) // strengthened
+            : _Range(views::all(_STD forward<_Rng>(_Range_))), _Pattern(views::single(_STD move(_Elem))) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() {
+            if constexpr (forward_range<_Vw>) {
+                constexpr bool _Both_simple = _Simple_view<_Vw> && _Simple_view<_Pat>;
+                return _Outer_iter<_Both_simple>{*this, _RANGES begin(_Range)};
+            } else {
+                this->_Current = _RANGES begin(_Range);
+                return _Outer_iter<false>{*this};
+            }
+        }
+
+        _NODISCARD constexpr auto begin() const
+            requires forward_range<_Vw> && forward_range<const _Vw> && forward_range<const _Pat>
+        {
+            return _Outer_iter<true>{*this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto end()
+            requires forward_range<_Vw> && common_range<_Vw>
+        {
+            constexpr bool _Both_simple = _Simple_view<_Vw> && _Simple_view<_Pat>;
+            return _Outer_iter<_Both_simple>{*this, _RANGES end(_Range)};
+        }
+
+        _NODISCARD constexpr auto end() const {
+            if constexpr (forward_range<_Vw> && forward_range<const _Vw> && common_range<const _Vw>
+                          && forward_range<const _Pat>) {
+                return _Outer_iter<true>{*this, _RANGES end(_Range)};
+            } else {
+                return default_sentinel;
+            }
+        }
+    };
+
+    template <class _Rng, class _Pat>
+    lazy_split_view(_Rng&&, _Pat&&) -> lazy_split_view<views::all_t<_Rng>, views::all_t<_Pat>>;
+
+    template <input_range _Rng>
+    lazy_split_view(_Rng&&, range_value_t<_Rng>)
+        -> lazy_split_view<views::all_t<_Rng>, single_view<range_value_t<_Rng>>>;
+
+#if _HAS_CXX23
+    template <class _Rng, class _Pat>
+    constexpr auto _Compile_time_max_size<lazy_split_view<_Rng, _Pat>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng, class _Pat>
+    constexpr auto _Compile_time_max_size<const lazy_split_view<_Rng, _Pat>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        struct _Lazy_split_fn {
+            template <viewable_range _Rng, class _Pat>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Pat&& _Pattern)
+                noexcept(noexcept(lazy_split_view(_STD forward<_Rng>(_Range), _STD forward<_Pat>(_Pattern))))
+                requires requires { lazy_split_view(static_cast<_Rng&&>(_Range), static_cast<_Pat&&>(_Pattern)); }
+            {
+                return lazy_split_view(_STD forward<_Rng>(_Range), _STD forward<_Pat>(_Pattern));
+            }
+
+            template <class _Delim>
+                requires constructible_from<decay_t<_Delim>, _Delim>
+            _NODISCARD static constexpr auto operator()(_Delim&& _Delimiter)
+                noexcept(is_nothrow_constructible_v<decay_t<_Delim>, _Delim>) {
+                return _Range_closure<_Lazy_split_fn, decay_t<_Delim>>{_STD forward<_Delim>(_Delimiter)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Lazy_split_fn lazy_split;
+    } // namespace views
+
+    _EXPORT_STD template <forward_range _Vw, forward_range _Pat>
+        requires view<_Vw> && view<_Pat> && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, _RANGES equal_to>
+    class split_view : public view_interface<split_view<_Vw, _Pat>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        /* [[no_unique_address]] */ _Pat _Pattern{};
+        _Non_propagating_cache<subrange<iterator_t<_Vw>>> _Next{};
+
+        class _Iterator {
+        private:
+            friend split_view;
+
+            split_view* _Parent             = nullptr;
+            iterator_t<_Vw> _Current        = {};
+            subrange<iterator_t<_Vw>> _Next = {};
+            bool _Trailing_empty            = false;
+
+        public:
+            using iterator_concept  = forward_iterator_tag;
+            using iterator_category = input_iterator_tag;
+            using value_type        = subrange<iterator_t<_Vw>>;
+            using difference_type   = range_difference_t<_Vw>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(split_view& _Parent_, iterator_t<_Vw> _Current_, subrange<iterator_t<_Vw>> _Next_)
+                noexcept(is_nothrow_move_constructible_v<iterator_t<_Vw>>) // strengthened
+                : _Parent{_STD addressof(_Parent_)}, _Current{_STD move(_Current_)}, _Next{_STD move(_Next_)} {}
+
+            _NODISCARD constexpr iterator_t<_Vw> base() const
+                noexcept(is_nothrow_copy_constructible_v<iterator_t<_Vw>>) /* strengthened */ {
+                return _Current;
+            }
+
+            _NODISCARD constexpr value_type operator*() const
+                noexcept(is_nothrow_copy_constructible_v<iterator_t<_Vw>>) /* strengthened */ {
+                return {_Current, _Next.begin()};
+            }
+
+            constexpr _Iterator& operator++() {
+                const auto _Last = _RANGES end(_Parent->_Range);
+                _Current         = _Next.begin();
+                if (_Current == _Last) {
+                    _Trailing_empty = false;
+                    return *this;
+                }
+
+                _Current = _Next.end();
+                if (_Current == _Last) {
+                    _Trailing_empty = true;
+                    _Next           = {_Current, _Current};
+                    return *this;
+                }
+
+                auto [_Begin, _End] = _RANGES search(subrange{_Current, _Last}, _Parent->_Pattern);
+                if (_Begin != _Last && _RANGES empty(_Parent->_Pattern)) {
+                    ++_Begin;
+                    ++_End;
+                }
+
+                _Next = {_STD move(_Begin), _STD move(_End)};
+                return *this;
+            }
+
+            constexpr _Iterator operator++(int) {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current == _Right._Current)) /* strengthened */ {
+                return _Left._Current == _Right._Current && _Left._Trailing_empty == _Right._Trailing_empty;
+            }
+        };
+
+        class _Sentinel {
+        private:
+            /* [[no_unique_address]] */ sentinel_t<_Vw> _Last{};
+
+            _NODISCARD constexpr bool _Equal(const _Iterator& _It) const
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_It._Current == _Last))) {
+                return !_It._Trailing_empty && _It._Current == _Last;
+            }
+
+        public:
+            _Sentinel() = default;
+            constexpr explicit _Sentinel(split_view& _Parent)
+                noexcept(noexcept(_RANGES end(_Parent._Range))
+                         && is_nothrow_move_constructible_v<sentinel_t<_Vw>>) // strengthened
+                : _Last(_RANGES end(_Parent._Range)) {}
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _It, const _Sentinel& _Se)
+                noexcept(noexcept(_Se._Equal(_It))) /* strengthened */ {
+                return _Se._Equal(_It);
+            }
+        };
+
+        constexpr subrange<iterator_t<_Vw>> _Find_next(iterator_t<_Vw> _It) {
+            const auto _Last    = _RANGES end(_Range);
+            auto [_Begin, _End] = _RANGES search(subrange{_It, _Last}, _Pattern);
+            if (_Begin != _Last && _RANGES empty(_Pattern)) {
+                ++_Begin;
+                ++_End;
+            }
+
+            return {_STD move(_Begin), _STD move(_End)};
+        }
+
+    public:
+        split_view()
+            requires default_initializable<_Vw> && default_initializable<_Pat>
+        = default;
+
+        constexpr explicit split_view(_Vw _Range_, _Pat _Pattern_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Pat>) // strengthened
+            : _Range(_STD move(_Range_)), _Pattern(_STD move(_Pattern_)) {}
+
+        template <forward_range _Rng>
+            requires constructible_from<_Vw, views::all_t<_Rng>>
+                      && constructible_from<_Pat, single_view<range_value_t<_Rng>>>
+        constexpr explicit split_view(_Rng&& _Range_, range_value_t<_Rng> _Elem)
+            noexcept(is_nothrow_constructible_v<_Vw, views::all_t<_Rng>>
+                     && is_nothrow_constructible_v<_Pat, single_view<range_value_t<_Rng>>>
+                     && is_nothrow_move_constructible_v<range_value_t<_Rng>>) // strengthened
+            : _Range(views::all(_STD forward<_Rng>(_Range_))), _Pattern(views::single(_STD move(_Elem))) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() {
+            auto _First = _RANGES begin(_Range);
+            if (!_Next) {
+                _Next._Emplace(_Find_next(_First));
+            }
+            return _Iterator{*this, _First, *_Next};
+        }
+
+        _NODISCARD constexpr auto end() {
+            if constexpr (common_range<_Vw>) {
+                return _Iterator{*this, _RANGES end(_Range), {}};
+            } else {
+                return _Sentinel{*this};
+            }
+        }
+    };
+
+    template <class _Rng, class _Pat>
+    split_view(_Rng&&, _Pat&&) -> split_view<views::all_t<_Rng>, views::all_t<_Pat>>;
+
+    template <forward_range _Rng>
+    split_view(_Rng&&, range_value_t<_Rng>) -> split_view<views::all_t<_Rng>, single_view<range_value_t<_Rng>>>;
+
+#if _HAS_CXX23
+    template <class _Rng, class _Pat>
+    constexpr auto _Compile_time_max_size<split_view<_Rng, _Pat>> = _Compile_time_max_size<_Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        struct _Split_fn {
+            template <viewable_range _Rng, class _Pat>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Pat&& _Pattern)
+                noexcept(noexcept(split_view(_STD forward<_Rng>(_Range), _STD forward<_Pat>(_Pattern))))
+                requires requires { split_view(static_cast<_Rng&&>(_Range), static_cast<_Pat&&>(_Pattern)); }
+            {
+                return split_view(_STD forward<_Rng>(_Range), _STD forward<_Pat>(_Pattern));
+            }
+
+            template <class _Delim>
+                requires constructible_from<decay_t<_Delim>, _Delim>
+            _NODISCARD static constexpr auto operator()(_Delim&& _Delimiter)
+                noexcept(is_nothrow_constructible_v<decay_t<_Delim>, _Delim>) {
+                return _Range_closure<_Split_fn, decay_t<_Delim>>{_STD forward<_Delim>(_Delimiter)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Split_fn split;
+
+        class _Counted_fn {
+        private:
+            enum class _St { _None, _Span, _Subrange, _Subrange_counted };
+
+            template <class _It>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                using _Decayed = decay_t<_It>;
+                _STL_INTERNAL_STATIC_ASSERT(input_or_output_iterator<_Decayed>);
+                if constexpr (contiguous_iterator<_Decayed>) {
+                    return {_St::_Span, true};
+                } else if constexpr (random_access_iterator<_Decayed>) {
+                    return {_St::_Subrange,
+                        noexcept(subrange(_STD declval<_It>(), _STD declval<_It>() + iter_difference_t<_Decayed>{}))};
+                } else if constexpr (is_convertible_v<_It, _Decayed>) {
+                    return {_St::_Subrange_counted,
+                        noexcept(subrange(
+                            counted_iterator(_STD declval<_It>(), iter_difference_t<_Decayed>{}), default_sentinel))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _It>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_It>();
+
+        public:
+            template <class _It>
+                requires (input_or_output_iterator<decay_t<_It>> && _Choice<_It>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_It&& _First, const iter_difference_t<decay_t<_It>> _Count)
+                noexcept(_Choice<_It>._No_throw) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Count >= 0, "The size passed to views::counted must be non-negative");
+#endif
+                constexpr _St _Strat = _Choice<_It>._Strategy;
+
+                if constexpr (_Strat == _St::_Span) {
+                    return span(_STD to_address(_STD forward<_It>(_First)), static_cast<size_t>(_Count));
+                } else if constexpr (_Strat == _St::_Subrange) {
+                    return subrange(_First, _First + _Count);
+                } else if constexpr (_Strat == _St::_Subrange_counted) {
+                    return subrange(counted_iterator(_STD forward<_It>(_First), _Count), default_sentinel);
+                }
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Counted_fn counted;
+    } // namespace views
+
+    _EXPORT_STD template <view _Vw>
+        requires (!common_range<_Vw> && copyable<iterator_t<_Vw>>)
+    class common_view : public view_interface<common_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Base{};
+
+    public:
+        common_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit common_view(_Vw _Base_) noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Base(_STD move(_Base_)) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Base;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Base);
+        }
+
+        _NODISCARD constexpr auto begin() noexcept(
+            noexcept(_RANGES begin(_Base)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (random_access_range<_Vw> && sized_range<_Vw>) {
+                return _RANGES begin(_Base);
+            } else {
+                return common_iterator<iterator_t<_Vw>, sentinel_t<_Vw>>{_RANGES begin(_Base)};
+            }
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(
+            noexcept(_RANGES begin(_Base)) && is_nothrow_move_constructible_v<iterator_t<const _Vw>>) /* strengthened */
+            requires range<const _Vw>
+        {
+            if constexpr (random_access_range<const _Vw> && sized_range<const _Vw>) {
+                return _RANGES begin(_Base);
+            } else {
+                return common_iterator<iterator_t<const _Vw>, sentinel_t<const _Vw>>{_RANGES begin(_Base)};
+            }
+        }
+
+        _NODISCARD constexpr auto end()
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (random_access_range<_Vw> && sized_range<_Vw>) {
+                return _RANGES begin(_Base) + _RANGES distance(_Base);
+            } else {
+                return common_iterator<iterator_t<_Vw>, sentinel_t<_Vw>>{_RANGES end(_Base)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            requires range<const _Vw>
+        {
+            if constexpr (random_access_range<const _Vw> && sized_range<const _Vw>) {
+                return _RANGES begin(_Base) + _RANGES distance(_Base);
+            } else {
+                return common_iterator<iterator_t<const _Vw>, sentinel_t<const _Vw>>{_RANGES end(_Base)};
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Base))) /* strengthened */
+            requires sized_range<_Vw>
+        {
+            return _RANGES size(_Base);
+        }
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Base))) /* strengthened */
+            requires sized_range<const _Vw>
+        {
+            return _RANGES size(_Base);
+        }
+    };
+
+    template <class _Rng>
+    common_view(_Rng&&) -> common_view<views::all_t<_Rng>>;
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<common_view<_Rng>> = enable_borrowed_range<_Rng>;
+
+#if _HAS_CXX23
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<common_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const common_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        class _Common_fn : public _Pipe::_Base<_Common_fn> {
+        private:
+            enum class _St { _None, _All, _Common };
+
+            template <class _Rng>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                if constexpr (common_range<_Rng>) {
+                    return {_St::_All, noexcept(views::all(_STD declval<_Rng>()))};
+                } else if constexpr (copyable<iterator_t<_Rng>>) {
+                    return {_St::_Common, noexcept(common_view{_STD declval<_Rng>()})};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Rng>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();
+
+        public:
+            template <viewable_range _Rng>
+                requires (_Choice<_Rng>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
+                constexpr _St _Strat = _Choice<_Rng>._Strategy;
+
+                if constexpr (_Strat == _St::_All) {
+                    return views::all(_STD forward<_Rng>(_Range));
+                } else if constexpr (_Strat == _St::_Common) {
+                    return common_view{_STD forward<_Rng>(_Range)};
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Common_fn common;
+    } // namespace views
+
+    _EXPORT_STD template <view _Vw>
+        requires bidirectional_range<_Vw>
+    class reverse_view : public _Cached_position_t<!common_range<_Vw>, _Vw, reverse_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+
+        template <class _Rng>
+        using _Rev_iter = reverse_iterator<iterator_t<_Rng>>;
+
+    public:
+        reverse_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit reverse_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr _Rev_iter<_Vw> begin() {
+            if constexpr (common_range<_Vw>) {
+                return _Rev_iter<_Vw>{_RANGES end(_Range)};
+            } else {
+                if (this->_Has_cache()) {
+                    return _Rev_iter<_Vw>{this->_Get_cache(_Range)};
+                }
+
+                iterator_t<_Vw> _First;
+                if constexpr (sized_range<_Vw>) {
+                    _First = _RANGES next(_RANGES begin(_Range), _RANGES distance(_Range));
+                } else {
+                    _First = _RANGES next(_RANGES begin(_Range), _RANGES end(_Range));
+                }
+                this->_Set_cache(_Range, _First);
+                return _Rev_iter<_Vw>{_STD move(_First)};
+            }
+        }
+
+        _NODISCARD constexpr auto begin() const
+            noexcept(noexcept(_Rev_iter<const _Vw>{_RANGES end(_Range)})) /* strengthened */
+            requires common_range<const _Vw>
+        {
+            return _Rev_iter<const _Vw>{_RANGES end(_Range)};
+        }
+
+        _NODISCARD constexpr _Rev_iter<_Vw> end()
+            noexcept(noexcept(_Rev_iter<_Vw>{_RANGES begin(_Range)})) /* strengthened */ {
+            return _Rev_iter<_Vw>{_RANGES begin(_Range)};
+        }
+        _NODISCARD constexpr auto end() const
+            noexcept(noexcept(_Rev_iter<const _Vw>{_RANGES begin(_Range)})) /* strengthened */
+            requires common_range<const _Vw>
+        {
+            return _Rev_iter<const _Vw>{_RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Range))) /* strengthened */
+            requires sized_range<_Vw>
+        {
+            return _RANGES size(_Range);
+        }
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Range))) /* strengthened */
+            requires sized_range<const _Vw>
+        {
+            return _RANGES size(_Range);
+        }
+    };
+
+    template <class _Rng>
+    reverse_view(_Rng&&) -> reverse_view<views::all_t<_Rng>>;
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<reverse_view<_Rng>> = enable_borrowed_range<_Rng>;
+
+#if _HAS_CXX23
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<reverse_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const reverse_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
+    namespace views {
+        template <class _Rng>
+        concept _Can_extract_base = requires(_Rng&& __r) { static_cast<_Rng&&>(__r).base(); };
+
+        template <class _Rng>
+        concept _Can_reverse = requires(_Rng&& __r) { reverse_view{static_cast<_Rng&&>(__r)}; };
+
+        class _Reverse_fn : public _Pipe::_Base<_Reverse_fn> {
+        private:
+            enum class _St { _None, _Base, _Subrange_unsized, _Subrange_sized, _Reverse };
+
+            template <class>
+            static constexpr auto _Reversed_subrange = -1;
+
+            template <class _It, subrange_kind _Ki>
+            static constexpr auto _Reversed_subrange<subrange<reverse_iterator<_It>, reverse_iterator<_It>, _Ki>> =
+                static_cast<int>(_Ki);
+
+            template <class _Rng>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                using _Ty = remove_cvref_t<_Rng>;
+
+                if constexpr (_Is_specialization_v<_Ty, reverse_view>) {
+                    if constexpr (_Can_extract_base<_Rng>) {
+                        return {_St::_Base, noexcept(_STD declval<_Rng>().base())};
+                    }
+                } else if constexpr (_Reversed_subrange<_Ty> == 0) {
+                    using _It = decltype(_STD declval<_Rng&>().begin().base());
+                    return {_St::_Subrange_unsized,
+                        noexcept(subrange<_It, _It, subrange_kind::unsized>{
+                            _STD declval<_Rng&>().end().base(), _STD declval<_Rng&>().begin().base()})};
+                } else if constexpr (_Reversed_subrange<_Ty> == 1) {
+                    using _It = decltype(_STD declval<_Rng&>().begin().base());
+                    return {_St::_Subrange_sized,
+                        noexcept(subrange<_It, _It, subrange_kind::sized>{_STD declval<_Rng&>().end().base(),
+                            _STD declval<_Rng&>().begin().base(), _STD declval<_Rng&>().size()})};
+                } else if constexpr (_Can_reverse<_Rng>) {
+                    return {_St::_Reverse, noexcept(reverse_view{_STD declval<_Rng>()})};
+                }
+
+                return {_St::_None};
+            }
+
+            template <class _Rng>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();
+
+        public:
+            template <viewable_range _Rng>
+                requires (_Choice<_Rng>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
+                constexpr _St _Strat = _Choice<_Rng>._Strategy;
+
+                if constexpr (_Strat == _St::_Base) {
+                    return _STD forward<_Rng>(_Range).base();
+                } else if constexpr (_Strat == _St::_Subrange_unsized) {
+                    return subrange{_Range.end().base(), _Range.begin().base()};
+                } else if constexpr (_Strat == _St::_Subrange_sized) {
+                    return subrange{_Range.end().base(), _Range.begin().base(), _Range.size()};
+                } else if constexpr (_Strat == _St::_Reverse) {
+                    return reverse_view{_STD forward<_Rng>(_Range)};
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Reverse_fn reverse;
+    } // namespace views
+
+#if _HAS_CXX23
+    _EXPORT_STD template <view _Vw>
+        requires input_range<_Vw>
+    class as_const_view : public view_interface<as_const_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+
+    public:
+        as_const_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit as_const_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) // strengthened
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() noexcept(noexcept(_RANGES cbegin(_Range))) // strengthened
+            requires (!_Simple_view<_Vw>)
+        {
+            return _RANGES cbegin(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(noexcept(_RANGES cbegin(_Range))) // strengthened
+            requires range<const _Vw>
+        {
+            return _RANGES cbegin(_Range);
+        }
+
+        _NODISCARD constexpr auto end() noexcept(noexcept(_RANGES cend(_Range))) // strengthened
+            requires (!_Simple_view<_Vw>)
+        {
+            return _RANGES cend(_Range);
+        }
+
+        _NODISCARD constexpr auto end() const noexcept(noexcept(_RANGES cend(_Range))) // strengthened
+            requires range<const _Vw>
+        {
+            return _RANGES cend(_Range);
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Range))) // strengthened
+            requires sized_range<_Vw>
+        {
+            return _RANGES size(_Range);
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Range))) // strengthened
+            requires sized_range<const _Vw>
+        {
+            return _RANGES size(_Range);
+        }
+    };
+
+    template <class _Rng>
+    as_const_view(_Rng&&) -> as_const_view<views::all_t<_Rng>>;
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<as_const_view<_Rng>> = enable_borrowed_range<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<as_const_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const as_const_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+
+    namespace views {
+        template <class _Rng>
+        concept _Can_as_const = requires(_Rng&& __r) { as_const_view{static_cast<_Rng&&>(__r)}; };
+
+        class _As_const_fn : public _Pipe::_Base<_As_const_fn> {
+        private:
+            enum class _St { _None, _All, _Empty, _Reconstruct_span, _Reconstruct_ref, _Ref, _As_const };
+
+            template <class>
+            static constexpr bool _Can_reconstruct_ref_view_v = false;
+
+            template <class _Ty>
+                requires constant_range<const _Ty>
+            static constexpr bool _Can_reconstruct_ref_view_v<ref_view<_Ty>> = true;
+
+            template <class _Rng>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                using _Ty = remove_cvref_t<_Rng>;
+
+                if constexpr (constant_range<views::all_t<_Rng>>) {
+                    return {_St::_All, noexcept(views::all(_STD declval<_Rng>()))};
+                } else if constexpr (_Is_specialization_v<_Ty, empty_view>) {
+                    return {_St::_Empty, true};
+                } else if constexpr (_Is_span_v<_Ty>) {
+                    return {_St::_Reconstruct_span, true};
+                } else if constexpr (_Can_reconstruct_ref_view_v<_Ty>) {
+                    return {_St::_Reconstruct_ref, noexcept(ref_view{_STD as_const(_STD declval<_Rng>().base())})};
+                } else if constexpr (is_lvalue_reference_v<_Rng> && constant_range<const _Ty> && !view<_Ty>) {
+                    return {_St::_Ref, noexcept(ref_view{_STD as_const(_STD declval<_Rng>())})};
+                } else if constexpr (_Can_as_const<_Rng>) {
+                    return {_St::_As_const, noexcept(as_const_view{_STD declval<_Rng>()})};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Rng>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();
+
+        public:
+            template <viewable_range _Rng>
+                requires (_Choice<_Rng>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
+                using _Ty            = remove_cvref_t<_Rng>;
+                constexpr _St _Strat = _Choice<_Rng>._Strategy;
+
+                if constexpr (_Strat == _St::_All) {
+                    return views::all(_STD forward<_Rng>(_Range));
+                } else if constexpr (_Strat == _St::_Empty) {
+                    return empty_view<const remove_reference_t<range_reference_t<_Rng>>>{};
+                } else if constexpr (_Strat == _St::_Reconstruct_span) {
+                    return span<const typename _Ty::element_type, _Ty::extent>{_STD forward<_Rng>(_Range)};
+                } else if constexpr (_Strat == _St::_Reconstruct_ref) {
+                    return ref_view{_STD as_const(_STD forward<_Rng>(_Range).base())};
+                } else if constexpr (_Strat == _St::_Ref) {
+                    return ref_view{_STD as_const(_STD forward<_Rng>(_Range))};
+                } else if constexpr (_Strat == _St::_As_const) {
+                    return as_const_view{_STD forward<_Rng>(_Range)};
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+
+        _EXPORT_STD inline constexpr _As_const_fn as_const;
+    } // namespace views
+#endif // _HAS_CXX23
+
+    template <class _Tuple, size_t _Index>
+    concept _Has_tuple_element =
+#if _HAS_CXX23
+        _Tuple_like<_Tuple> && _Index < tuple_size_v<_Tuple>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        requires(_Tuple __t) {
+            typename tuple_size<_Tuple>::type;
+            requires _Index < tuple_size_v<_Tuple>;
+            typename tuple_element_t<_Index, _Tuple>;
+            { _STD get<_Index>(__t) } -> convertible_to<const tuple_element_t<_Index, _Tuple>&>;
+        };
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+    template <class _Tuple, size_t _Index>
+    concept _Returnable_element = is_reference_v<_Tuple> || move_constructible<tuple_element_t<_Index, _Tuple>>;
+
+    _EXPORT_STD template <input_range _Vw, size_t _Index>
+        requires view<_Vw> && _Has_tuple_element<range_value_t<_Vw>, _Index>
+              && _Has_tuple_element<remove_reference_t<range_reference_t<_Vw>>, _Index>
+              && _Returnable_element<range_reference_t<_Vw>, _Index>
+    class elements_view : public view_interface<elements_view<_Vw, _Index>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+
+        template <class _Base>
+        struct _Category_base {};
+
+        template <forward_range _Base>
+        struct _Category_base<_Base> {
+            using iterator_category =
+                conditional_t<!is_lvalue_reference_v<decltype(_STD get<_Index>(*_STD declval<iterator_t<_Base>>()))>,
+                    input_iterator_tag,
+                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_Base>>, random_access_iterator_tag>,
+                        random_access_iterator_tag, _Iter_cat_t<iterator_t<_Base>>>>;
+        };
+
+        template <bool _Const>
+        class _Iterator : public _Category_base<_Maybe_const<_Const, _Vw>> {
+        private:
+            friend elements_view;
+
+            using _Base = _Maybe_const<_Const, _Vw>;
+
+            iterator_t<_Base> _Current{};
+
+        public:
+            using iterator_concept = conditional_t<random_access_range<_Base>, random_access_iterator_tag,
+                conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag,
+                    conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>>>;
+            using value_type       = remove_cvref_t<tuple_element_t<_Index, range_value_t<_Base>>>;
+            using difference_type  = range_difference_t<_Base>;
+
+            _Iterator()
+                requires default_initializable<iterator_t<_Base>>
+            = default;
+
+            constexpr explicit _Iterator(iterator_t<_Base> _Current_)
+                noexcept(is_nothrow_move_constructible_v<iterator_t<_Base>>) // strengthened
+                : _Current{_STD move(_Current_)} {}
+
+            constexpr _Iterator(_Iterator<!_Const> _It)
+                noexcept(is_nothrow_constructible_v<iterator_t<_Base>, iterator_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<iterator_t<_Vw>, iterator_t<_Base>>
+                : _Current(_STD move(_It._Current)) {}
+
+            _NODISCARD constexpr const iterator_t<_Base>& base() const& noexcept {
+                return _Current;
+            }
+
+            _NODISCARD constexpr iterator_t<_Base> base() && noexcept(
+                is_nothrow_move_constructible_v<iterator_t<_Base>>) /* strengthened */ {
+                return _STD move(_Current);
+            }
+
+            _NODISCARD constexpr decltype(auto) operator*() const
+                noexcept(noexcept(_STD get<_Index>(*_Current))) /* strengthened */
+                requires is_reference_v<range_reference_t<_Base>>
+            {
+                return _STD get<_Index>(*_Current);
+            }
+
+            _NODISCARD constexpr decltype(auto) operator*() const
+                noexcept(is_nothrow_move_constructible_v<tuple_element_t<_Index, range_reference_t<_Base>>>
+                         && noexcept(_STD get<_Index>(*_Current))) /* strengthened */ {
+                using _ElemTy = remove_cv_t<tuple_element_t<_Index, range_reference_t<_Base>>>;
+                return static_cast<_ElemTy>(_STD get<_Index>(*_Current));
+            }
+
+            constexpr _Iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+                ++_Current;
+                return *this;
+            }
+
+            constexpr void operator++(int) noexcept(noexcept(++_Current)) /* strengthened */ {
+                ++_Current;
+            }
+
+            constexpr _Iterator operator++(int)
+                noexcept(noexcept(++_Current) && is_nothrow_copy_constructible_v<iterator_t<_Base>>) /* strengthened */
+                requires forward_range<_Base>
+            {
+                auto _Tmp = *this;
+                ++_Current;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--() noexcept(noexcept(--_Current)) /* strengthened */
+                requires bidirectional_range<_Base>
+            {
+                --_Current;
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                noexcept(noexcept(--_Current) && is_nothrow_copy_constructible_v<iterator_t<_Base>>) /* strengthened */
+                requires bidirectional_range<_Base>
+            {
+                auto _Tmp = *this;
+                --_Current;
+                return _Tmp;
+            }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            constexpr void _Verify_offset(const difference_type _Off) const
+                requires random_access_range<_Base>
+            {
+                if constexpr (_Offset_verifiable_v<iterator_t<_Base>>) {
+                    _Current._Verify_offset(_Off);
+                }
+            }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                noexcept(noexcept(_Current += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Current += _Off;
+                return *this;
+            }
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                noexcept(noexcept(_Current -= _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Off != _Min_possible_v<difference_type>, "integer overflow");
+                _Verify_offset(-_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Current -= _Off;
+                return *this;
+            }
+
+            _NODISCARD constexpr decltype(auto) operator[](const difference_type _Idx) const
+                noexcept(noexcept(_STD get<_Index>(*(_Current + _Idx)))) /* strengthened */
+                requires random_access_range<_Base> && is_reference_v<range_reference_t<_Base>>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Verify_offset(_Idx);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return _STD get<_Index>(*(_Current + _Idx));
+            }
+
+            _NODISCARD constexpr decltype(auto) operator[](const difference_type _Idx) const
+                noexcept(is_nothrow_move_constructible_v<tuple_element_t<_Index, range_reference_t<_Base>>>
+                         && noexcept(_STD get<_Index>(*(_Current + _Idx)))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _Verify_offset(_Idx);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                using _ElemTy = remove_cv_t<tuple_element_t<_Index, range_reference_t<_Base>>>;
+                return static_cast<_ElemTy>(_STD get<_Index>(*(_Current + _Idx)));
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current == _Right._Current)) /* strengthened */
+                requires equality_comparable<iterator_t<_Base>>
+            {
+                return _Left._Current == _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return _Left._Current < _Right._Current;
+            }
+            _NODISCARD friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return _Right < _Left;
+            }
+            _NODISCARD friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return !(_Right < _Left);
+            }
+            _NODISCARD friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current < _Right._Current)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return !(_Left < _Right);
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current <=> _Right._Current)) /* strengthened */
+                requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+            {
+                return _Left._Current <=> _Right._Current;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off)
+                noexcept(noexcept(_STD declval<iterator_t<_Base>&>() += _Off)
+                         && is_nothrow_copy_constructible_v<iterator_t<_Base>>) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _It._Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                auto _Copy = _It;
+                _Copy._Current += _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It)
+                noexcept(noexcept(_STD declval<iterator_t<_Base>&>() += _Off)
+                         && is_nothrow_copy_constructible_v<iterator_t<_Base>>) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _It._Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                auto _Copy = _It;
+                _Copy._Current += _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off)
+                noexcept(noexcept(_STD declval<iterator_t<_Base>&>() -= _Off)
+                         && is_nothrow_copy_constructible_v<iterator_t<_Base>>) /* strengthened */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Off != _Min_possible_v<difference_type>, "integer overflow");
+                _It._Verify_offset(-_Off);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                auto _Copy = _It;
+                _Copy._Current -= _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current - _Right._Current)) /* strengthened */
+                requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+            {
+                return _Left._Current - _Right._Current;
+            }
+        };
+
+        template <bool _Const>
+        class _Sentinel {
+        private:
+            friend elements_view;
+
+            using _Base = _Maybe_const<_Const, _Vw>;
+            template <bool _OtherConst>
+            using _Maybe_const_iter = iterator_t<_Maybe_const<_OtherConst, _Vw>>;
+
+            sentinel_t<_Base> _Last{};
+
+            template <bool _OtherConst>
+            _NODISCARD static constexpr const _Maybe_const_iter<_OtherConst>& _Get_current(
+                const _Iterator<_OtherConst>& _It) noexcept {
+                return _It._Current;
+            }
+
+        public:
+            _Sentinel() = default;
+            constexpr explicit _Sentinel(sentinel_t<_Base> _Last_)
+                noexcept(is_nothrow_move_constructible_v<sentinel_t<_Base>>) // strengthened
+                : _Last(_STD move(_Last_)) {}
+
+            constexpr _Sentinel(_Sentinel<!_Const> _Se)
+                noexcept(is_nothrow_constructible_v<sentinel_t<_Base>, sentinel_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<sentinel_t<_Vw>, sentinel_t<_Base>>
+                : _Last(_STD move(_Se._Last)) {}
+
+            _NODISCARD constexpr sentinel_t<_Base> base() const
+                noexcept(is_nothrow_copy_constructible_v<sentinel_t<_Base>>) /* strengthened */ {
+                return _Last;
+            }
+
+            template <bool _OtherConst>
+                requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_OtherConst>& _Left, const _Sentinel& _Right)
+                noexcept(noexcept(_Get_current(_Left) == _Right._Last)) /* strengthened */ {
+                return _Get_current(_Left) == _Right._Last;
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _OtherConst>
+                requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD friend constexpr typename _Iterator<_OtherConst>::difference_type operator-(
+                const _Iterator<_OtherConst>& _Left, const _Sentinel& _Right)
+                noexcept(noexcept(_Get_current(_Left) - _Right._Last)) /* strengthened */ {
+                return _Get_current(_Left) - _Right._Last;
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _OtherConst>
+                requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
+            _NODISCARD friend constexpr typename _Iterator<_OtherConst>::difference_type operator-(
+                const _Sentinel& _Left, const _Iterator<_OtherConst>& _Right)
+                noexcept(noexcept(_Left._Last - _Get_current(_Right))) /* strengthened */ {
+                return _Left._Last - _Get_current(_Right);
+            }
+        };
+
+    public:
+        elements_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit elements_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr _Iterator<false> begin() noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */
+            requires (!_Simple_view<_Vw>)
+        {
+            return _Iterator<false>{_RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr _Iterator<true> begin() const
+            noexcept(noexcept(_RANGES begin(_Range))
+                     && is_nothrow_move_constructible_v<iterator_t<const _Vw>>) /* strengthened */
+            requires range<const _Vw>
+        {
+            return _Iterator<true>{_RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto end() noexcept(
+            noexcept(_RANGES end(_Range)) && is_nothrow_move_constructible_v<sentinel_t<_Vw>>) /* strengthened */
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (common_range<_Vw>) {
+                return _Iterator<false>{_RANGES end(_Range)};
+            } else {
+                return _Sentinel<false>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const noexcept(
+            noexcept(_RANGES end(_Range)) && is_nothrow_move_constructible_v<sentinel_t<const _Vw>>) /* strengthened */
+            requires range<const _Vw>
+        {
+            if constexpr (common_range<const _Vw>) {
+                return _Iterator<true>{_RANGES end(_Range)};
+            } else {
+                return _Sentinel<true>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Range))) /* strengthened */
+            requires sized_range<_Vw>
+        {
+            return _RANGES size(_Range);
+        }
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Range))) /* strengthened */
+            requires sized_range<const _Vw>
+        {
+            return _RANGES size(_Range);
+        }
+    };
+
+    template <class _Rng, size_t _Index>
+    constexpr bool enable_borrowed_range<elements_view<_Rng, _Index>> = enable_borrowed_range<_Rng>;
+
+#if _HAS_CXX23
+    template <class _Rng, size_t _Index>
+    constexpr auto _Compile_time_max_size<elements_view<_Rng, _Index>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng, size_t _Index>
+    constexpr auto _Compile_time_max_size<const elements_view<_Rng, _Index>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
+    _EXPORT_STD template <class _Rng>
+    using keys_view = elements_view<_Rng, 0>;
+    _EXPORT_STD template <class _Rng>
+    using values_view = elements_view<_Rng, 1>;
+
+    namespace views {
+        template <size_t _Index>
+        struct _Elements_fn : public _Pipe::_Base<_Elements_fn<_Index>> {
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range)
+                noexcept(noexcept(elements_view<views::all_t<_Rng>, _Index>{_STD forward<_Rng>(_Range)}))
+                requires requires { elements_view<views::all_t<_Rng>, _Index>{static_cast<_Rng&&>(_Range)}; }
+            {
+                return elements_view<views::all_t<_Rng>, _Index>{_STD forward<_Rng>(_Range)};
+            }
+        };
+
+        _EXPORT_STD template <size_t _Index>
+        constexpr _Elements_fn<_Index> elements;
+        _EXPORT_STD inline constexpr auto keys   = elements<0>;
+        _EXPORT_STD inline constexpr auto values = elements<1>;
+    } // namespace views
+
+#if _HAS_CXX23
+    template <class _Rng>
+    concept _Range_with_movable_references = input_range<_Rng> && move_constructible<range_reference_t<_Rng>>
+                                          && move_constructible<range_rvalue_reference_t<_Rng>>;
+
+    _EXPORT_STD template <view _Vw>
+        requires _Range_with_movable_references<_Vw>
+    class enumerate_view : public view_interface<enumerate_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+
+        template <bool _Const>
+        class _Iterator {
+        private:
+            friend enumerate_view;
+
+            using _Base_t         = _Maybe_const<_Const, _Vw>;
+            using _Base_iterator  = iterator_t<_Base_t>;
+            using _Reference_type = tuple<range_difference_t<_Base_t>, range_reference_t<_Base_t>>;
+
+            _MSVC_NO_UNIQUE_ADDRESS _Base_iterator _Current{};
+            range_difference_t<_Base_t> _Pos = 0;
+
+            constexpr explicit _Iterator(_Base_iterator _Current_, range_difference_t<_Base_t> _Pos_)
+                noexcept(is_nothrow_move_constructible_v<_Base_iterator>) // strengthened
+                : _Current(_STD move(_Current_)), _Pos(_Pos_) {}
+
+        public:
+            using iterator_category = input_iterator_tag;
+            using iterator_concept  = conditional_t<random_access_range<_Base_t>, random_access_iterator_tag,
+                conditional_t<bidirectional_range<_Base_t>, bidirectional_iterator_tag,
+                    conditional_t<forward_range<_Base_t>, forward_iterator_tag, input_iterator_tag>>>;
+            using difference_type   = range_difference_t<_Base_t>;
+            using value_type        = tuple<difference_type, range_value_t<_Base_t>>;
+
+            _Iterator()
+                requires default_initializable<_Base_iterator>
+            = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _Other)
+                noexcept(is_nothrow_constructible_v<_Base_iterator, iterator_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<iterator_t<_Vw>, _Base_iterator>
+                : _Current(_STD move(_Other._Current)), _Pos(_Other._Pos) {}
+
+            _NODISCARD constexpr const _Base_iterator& base() const& noexcept {
+                return _Current;
+            }
+
+            _NODISCARD constexpr _Base_iterator base() && noexcept(
+                is_nothrow_move_constructible_v<_Base_iterator>) /* strengthened */ {
+                return _STD move(_Current);
+            }
+
+            _NODISCARD constexpr difference_type index() const noexcept {
+                return _Pos;
+            }
+
+            _NODISCARD constexpr auto operator*() const noexcept(
+                noexcept(*_Current) && is_nothrow_copy_constructible_v<range_reference_t<_Base_t>>) /* strengthened */ {
+                return _Reference_type{_Pos, *_Current};
+            }
+
+            constexpr _Iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+                ++_Current;
+                ++_Pos;
+                return *this;
+            }
+
+            constexpr void operator++(int) noexcept(noexcept(++_Current)) /* strengthened */ {
+                ++*this;
+            }
+
+            constexpr _Iterator operator++(int)
+                noexcept(noexcept(++*this) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires forward_range<_Base_t>
+            {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--() noexcept(noexcept(--_Current)) // strengthened
+                requires bidirectional_range<_Base_t>
+            {
+                --_Current;
+                --_Pos;
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                noexcept(noexcept(--*this) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires bidirectional_range<_Base_t>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                noexcept(noexcept(_Current += _Off)) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                _Current += _Off;
+                _Pos += _Off;
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                noexcept(noexcept(_Current -= _Off)) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                _Current -= _Off;
+                _Pos -= _Off;
+                return *this;
+            }
+
+            _NODISCARD constexpr auto operator[](const difference_type _Off) const noexcept(
+                noexcept(_Current[_Off]) && is_nothrow_copy_constructible_v<range_reference_t<_Base_t>>) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                return _Reference_type{static_cast<difference_type>(_Pos + _Off), _Current[_Off]};
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right) noexcept {
+                return _Left._Pos == _Right._Pos;
+            }
+
+            _NODISCARD friend constexpr strong_ordering operator<=>(
+                const _Iterator& _Left, const _Iterator& _Right) noexcept {
+                return _Left._Pos <=> _Right._Pos;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off)
+                noexcept(is_nothrow_copy_constructible_v<_Iterator>
+                         && noexcept(_STD declval<_Iterator&>() += _Off)) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                auto _Tmp = _It;
+                _Tmp += _Off;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It)
+                noexcept(noexcept(_It + _Off)) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                return _It + _Off;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off)
+                noexcept(is_nothrow_copy_constructible_v<_Iterator>
+                         && noexcept(_STD declval<_Iterator&>() -= _Off)) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                auto _Tmp = _It;
+                _Tmp -= _Off;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(
+                const _Iterator& _Left, const _Iterator& _Right) noexcept {
+                return _Left._Pos - _Right._Pos;
+            }
+
+            _NODISCARD friend constexpr auto iter_move(const _Iterator& _It)
+                noexcept(noexcept(_RANGES iter_move(_It._Current))
+                         && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base_t>>) {
+                return tuple<difference_type, range_rvalue_reference_t<_Base_t>>{
+                    _It._Pos, _RANGES iter_move(_It._Current)};
+            }
+        };
+
+        template <bool _Const>
+        class _Sentinel {
+        private:
+            friend enumerate_view;
+
+            using _Base_t        = _Maybe_const<_Const, _Vw>;
+            using _Base_sentinel = sentinel_t<_Base_t>;
+
+            _MSVC_NO_UNIQUE_ADDRESS _Base_sentinel _End{};
+
+            constexpr explicit _Sentinel(_Base_sentinel _End_)
+                noexcept(is_nothrow_move_constructible_v<_Base_sentinel>) // strengthened
+                : _End(_STD move(_End_)) {}
+
+            template <bool _OtherConst>
+                requires sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD constexpr bool _Equal(const _Iterator<_OtherConst>& _It) const
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_It._Current == _End))) {
+                return _It._Current == _End;
+            }
+
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD constexpr _Iterator<_OtherConst>::difference_type _Distance_from(
+                const _Iterator<_OtherConst>& _It) const noexcept(noexcept(_End - _It._Current)) {
+                return _End - _It._Current;
+            }
+
+        public:
+            _Sentinel() = default;
+
+            constexpr _Sentinel(_Sentinel<!_Const> _Other)
+                noexcept(is_nothrow_constructible_v<_Base_sentinel, sentinel_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<sentinel_t<_Vw>, _Base_sentinel>
+                : _End(_STD move(_Other._End)) {}
+
+            _NODISCARD constexpr _Base_sentinel base() const
+                noexcept(is_nothrow_copy_constructible_v<_Base_sentinel>) /* strengthened */ {
+                return _End;
+            }
+
+            template <bool _OtherConst>
+                requires sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_OtherConst>& _It, const _Sentinel& _Se)
+                noexcept(noexcept(_Se._Equal(_It))) /* strengthened */ {
+                return _Se._Equal(_It);
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD friend constexpr typename _Iterator<_OtherConst>::difference_type operator-(
+                const _Iterator<_OtherConst>& _It, const _Sentinel& _Se)
+                noexcept(noexcept(_Se._Distance_from(_It))) /* strengthened */ {
+                return -_Se._Distance_from(_It);
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD friend constexpr typename _Iterator<_OtherConst>::difference_type operator-(const _Sentinel& _Se,
+                const _Iterator<_OtherConst>& _It) noexcept(noexcept(_Se._Distance_from(_It))) /* strengthened */ {
+                return _Se._Distance_from(_It);
+            }
+        };
+
+        template <class _Rng>
+        static constexpr bool _Is_end_nothrow_v =
+            is_nothrow_move_constructible_v<sentinel_t<_Rng>> && noexcept(_RANGES end(_STD declval<_Rng&>()));
+
+        template <class _Rng>
+            requires common_range<_Rng> && sized_range<_Rng>
+        static constexpr bool _Is_end_nothrow_v<_Rng> =
+            is_nothrow_move_constructible_v<sentinel_t<_Rng>> && noexcept(_RANGES end(_STD declval<_Rng&>()))
+            && noexcept(_RANGES distance(_STD declval<_Rng&>()));
+
+    public:
+        constexpr enumerate_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit enumerate_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)) {}
+
+        _NODISCARD constexpr auto begin() noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) // strengthened
+            requires (!_Simple_view<_Vw>)
+        {
+            return _Iterator<false>{_RANGES begin(_Range), 0};
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<const _Vw>>) // strengthened
+            requires _Range_with_movable_references<const _Vw>
+        {
+            return _Iterator<true>{_RANGES begin(_Range), 0};
+        }
+
+        _NODISCARD constexpr auto end() noexcept(_Is_end_nothrow_v<_Vw>) // strengthened
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (forward_range<_Vw> && common_range<_Vw> && sized_range<_Vw>) {
+                return _Iterator<false>{_RANGES end(_Range), _RANGES distance(_Range)};
+            } else {
+                return _Sentinel<false>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const noexcept(_Is_end_nothrow_v<const _Vw>) // strengthened
+            requires _Range_with_movable_references<const _Vw>
+        {
+            if constexpr (forward_range<const _Vw> && common_range<const _Vw> && sized_range<const _Vw>) {
+                return _Iterator<true>{_RANGES end(_Range), _RANGES distance(_Range)};
+            } else {
+                return _Sentinel<true>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Range))) // strengthened
+            requires sized_range<_Vw>
+        {
+            return _RANGES size(_Range);
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Range))) // strengthened
+            requires sized_range<const _Vw>
+        {
+            return _RANGES size(_Range);
+        }
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) // strengthened
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+    };
+
+    template <class _Rng>
+    enumerate_view(_Rng&&) -> enumerate_view<views::all_t<_Rng>>;
+
+    template <class _Rng>
+    constexpr bool enable_borrowed_range<enumerate_view<_Rng>> = enable_borrowed_range<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<enumerate_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const enumerate_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+
+    namespace views {
+        struct _Enumerate_fn : public _Pipe::_Base<_Enumerate_fn> {
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range)
+                noexcept(noexcept(enumerate_view<views::all_t<_Rng>>{_STD forward<_Rng>(_Range)}))
+                requires requires { enumerate_view<views::all_t<_Rng>>{_STD forward<_Rng>(_Range)}; }
+            {
+                return enumerate_view<views::all_t<_Rng>>{_STD forward<_Rng>(_Range)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Enumerate_fn enumerate;
+    } // namespace views
+
+    template <class _Int>
+    _NODISCARD constexpr _Int _Div_ceil(const _Int _Num, const _Int _Denom) noexcept {
+        _STL_INTERNAL_STATIC_ASSERT(_Signed_integer_like<_Int>);
+        _STL_INTERNAL_CHECK(_Num >= 0);
+        _STL_INTERNAL_CHECK(_Denom > 0);
+
+        if constexpr (same_as<_Int, _Signed128>) {
+            return _Int::_Div_ceil(_Num, _Denom);
+        } else {
+            _Int _Result = _Num / _Denom;
+            if (_Num % _Denom != 0) {
+                ++_Result;
+            }
+            return _Result;
+        }
+    }
+
+    _EXPORT_STD template <view _Vw>
+        requires input_range<_Vw>
+    class chunk_view : public view_interface<chunk_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range;
+        range_difference_t<_Vw> _Count;
+        range_difference_t<_Vw> _Remainder = 0;
+        _Non_propagating_cache<iterator_t<_Vw>> _Current{};
+
+        class _Inner_iterator {
+        private:
+            friend chunk_view;
+            chunk_view* _Parent{};
+
+            constexpr explicit _Inner_iterator(chunk_view* _Parent_) noexcept : _Parent(_Parent_) {}
+
+            _NODISCARD constexpr range_difference_t<_Vw> _Get_remainder() const noexcept {
+                return _Parent->_Remainder;
+            }
+
+            _NODISCARD constexpr range_difference_t<_Vw> _Get_size() const
+                noexcept(noexcept(_RANGES end(_Parent->_Range) - *_Parent->_Current)) {
+                return (_STD min) (_Parent->_Remainder, _RANGES end(_Parent->_Range) - *_Parent->_Current);
+            }
+
+            _NODISCARD constexpr const iterator_t<_Vw>& _Get_current() const noexcept {
+                return *_Parent->_Current;
+            }
+
+        public:
+            using iterator_concept = input_iterator_tag;
+            using difference_type  = range_difference_t<_Vw>;
+            using value_type       = range_value_t<_Vw>;
+
+            _Inner_iterator(_Inner_iterator&&)            = default;
+            _Inner_iterator& operator=(_Inner_iterator&&) = default;
+
+            _NODISCARD constexpr const iterator_t<_Vw>& base() const& noexcept /* strengthened */ {
+                return *_Parent->_Current;
+            }
+
+            _NODISCARD constexpr range_reference_t<_Vw> operator*() const
+                noexcept(noexcept(**_Parent->_Current)) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(*this != default_sentinel, "cannot dereference chunk_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return **_Parent->_Current;
+            }
+
+            constexpr _Inner_iterator& operator++() noexcept(
+                noexcept(++*_Parent->_Current)
+                && noexcept(static_cast<bool>(*_Parent->_Current == _RANGES end(_Parent->_Range)))) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(*this != default_sentinel, "cannot increment chunk_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                ++*_Parent->_Current;
+                if (*_Parent->_Current == _RANGES end(_Parent->_Range)) {
+                    _Parent->_Remainder = 0;
+                } else {
+                    --_Parent->_Remainder;
+                }
+
+                return *this;
+            }
+
+            constexpr void operator++(int) noexcept(
+                noexcept(++*_Parent->_Current)
+                && noexcept(static_cast<bool>(*_Parent->_Current == _RANGES end(_Parent->_Range)))) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(*this != default_sentinel, "cannot increment chunk_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                ++*_Parent->_Current;
+                if (*_Parent->_Current == _RANGES end(_Parent->_Range)) {
+                    _Parent->_Remainder = 0;
+                } else {
+                    --_Parent->_Remainder;
+                }
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Inner_iterator& _Left, default_sentinel_t) noexcept
+            /* strengthened */ {
+                return _Left._Get_remainder() == 0;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(default_sentinel_t, const _Inner_iterator& _Right)
+                noexcept(noexcept(_Right._Get_size())) /* strengthened */
+                requires sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>
+            {
+                return _Right._Get_size();
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Inner_iterator& _Left, default_sentinel_t)
+                noexcept(noexcept(_Left._Get_size())) /* strengthened */
+                requires sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>
+            {
+                return -_Left._Get_size();
+            }
+
+            _NODISCARD friend constexpr range_rvalue_reference_t<_Vw> iter_move(const _Inner_iterator& _It)
+                noexcept(noexcept(_RANGES iter_move(_It._Get_current()))) {
+                return _RANGES iter_move(_It._Get_current());
+            }
+
+            friend constexpr void iter_swap(const _Inner_iterator& _Left, const _Inner_iterator& _Right)
+                noexcept(noexcept(_RANGES iter_swap(_Left._Get_current(), _Right._Get_current())))
+                requires indirectly_swappable<iterator_t<_Vw>>
+            {
+                _RANGES iter_swap(_Left._Get_current(), _Right._Get_current());
+            }
+        };
+
+        class _Outer_iterator {
+        private:
+            friend chunk_view;
+            chunk_view* _Parent{};
+
+            constexpr explicit _Outer_iterator(chunk_view* _Parent_) noexcept : _Parent(_Parent_) {}
+
+            _NODISCARD constexpr bool _Is_end() const
+                noexcept(noexcept(*_Parent->_Current == _RANGES end(_Parent->_Range) && true)) {
+                return *_Parent->_Current == _RANGES end(_Parent->_Range) && _Parent->_Remainder != 0;
+            }
+
+            _NODISCARD constexpr range_difference_t<_Vw> _Get_size() const
+                noexcept(noexcept(_RANGES end(_Parent->_Range) - *_Parent->_Current)) {
+                const auto _Size = _RANGES end(_Parent->_Range) - *_Parent->_Current;
+                if (_Size < _Parent->_Remainder) {
+                    return _Size == 0 ? 0 : 1;
+                }
+                return _Div_ceil(_Size - _Parent->_Remainder, _Parent->_Count) + 1;
+            }
+
+        public:
+            using iterator_concept = input_iterator_tag;
+            using difference_type  = range_difference_t<_Vw>;
+
+            struct value_type : view_interface<value_type> {
+            private:
+                friend _Outer_iterator;
+                chunk_view* _Parent{};
+
+                constexpr explicit value_type(chunk_view* _Parent_) noexcept : _Parent(_Parent_) {}
+
+            public:
+                _NODISCARD constexpr _Inner_iterator begin() const noexcept {
+                    return _Inner_iterator{_Parent};
+                }
+
+                _NODISCARD constexpr default_sentinel_t end() const noexcept {
+                    return default_sentinel;
+                }
+
+                _NODISCARD constexpr auto size() const
+                    noexcept(noexcept(_RANGES end(_Parent->_Range) - *_Parent->_Current)) /* strengthened */
+                    requires sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>
+                {
+                    return _To_unsigned_like(
+                        (_STD min) (_Parent->_Remainder, _RANGES end(_Parent->_Range) - *_Parent->_Current));
+                }
+            };
+
+            _Outer_iterator(_Outer_iterator&&)            = default;
+            _Outer_iterator& operator=(_Outer_iterator&&) = default;
+
+            _NODISCARD constexpr value_type operator*() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(*this != default_sentinel, "cannot dereference chunk_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return value_type{_Parent};
+            }
+
+            constexpr _Outer_iterator& operator++() /* not strengthened, see _RANGES advance */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(*this != default_sentinel, "cannot increment chunk_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _RANGES advance(*_Parent->_Current, _Parent->_Remainder, _RANGES end(_Parent->_Range));
+                _Parent->_Remainder = _Parent->_Count;
+                return *this;
+            }
+
+            constexpr void operator++(int) /* not strengthened, see _RANGES advance */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(*this != default_sentinel, "cannot increment chunk_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _RANGES advance(*_Parent->_Current, _Parent->_Remainder, _RANGES end(_Parent->_Range));
+                _Parent->_Remainder = _Parent->_Count;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Outer_iterator& _Left, default_sentinel_t)
+                noexcept(noexcept(_Left._Is_end())) /* strengthened */ {
+                return _Left._Is_end();
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(default_sentinel_t, const _Outer_iterator& _Right)
+                noexcept(noexcept(_Right._Get_size())) /* strengthened */
+                requires sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>
+            {
+                return _Right._Get_size();
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Outer_iterator& _Left, default_sentinel_t)
+                noexcept(noexcept(_Left._Get_size())) /* strengthened */
+                requires sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>
+            {
+                return -_Left._Get_size();
+            }
+        };
+
+    public:
+        constexpr explicit chunk_view(_Vw _Range_, const range_difference_t<_Vw> _Count_)
+            noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */
+            : _Range(_STD move(_Range_)), _Count{_Count_} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Count > 0, "chunk size must be greater than 0");
+#endif
+        }
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr _Outer_iterator begin()
+            noexcept(noexcept(_Current._Emplace(_RANGES begin(_Range)))) /* strengthened */ {
+            _Current._Emplace(_RANGES begin(_Range));
+            _Remainder = _Count;
+            return _Outer_iterator{this};
+        }
+
+        _NODISCARD constexpr default_sentinel_t end() const noexcept {
+            return default_sentinel;
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES distance(_Range))) /* strengthened */
+            requires sized_range<_Vw>
+        {
+            return _To_unsigned_like(_Div_ceil(_RANGES distance(_Range), _Count));
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES distance(_Range))) /* strengthened */
+            requires sized_range<const _Vw>
+        {
+            return _To_unsigned_like(_Div_ceil(_RANGES distance(_Range), _Count));
+        }
+    };
+
+    template <view _Vw>
+        requires forward_range<_Vw>
+    class chunk_view<_Vw> : public view_interface<chunk_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range;
+        range_difference_t<_Vw> _Count;
+
+        template <bool _Const>
+        class _Iterator {
+        private:
+            friend chunk_view;
+
+            using _ParentTy      = _Maybe_const<_Const, chunk_view>;
+            using _Base          = _Maybe_const<_Const, _Vw>;
+            using _Base_iterator = iterator_t<_Base>;
+            using _Base_sentinel = sentinel_t<_Base>;
+
+            _MSVC_NO_UNIQUE_ADDRESS _Base_iterator _Current{};
+            _MSVC_NO_UNIQUE_ADDRESS _Base_sentinel _End{};
+            range_difference_t<_Base> _Count   = 0;
+            range_difference_t<_Base> _Missing = 0;
+
+            constexpr _Iterator(_ParentTy* _Parent, _Base_iterator _Current_, range_difference_t<_Base> _Missing_ = 0)
+                noexcept(noexcept(_RANGES end(_Parent->_Range)) && is_nothrow_move_constructible_v<_Base_iterator>
+                         && is_nothrow_move_constructible_v<_Base_sentinel>) /* strengthened */
+                : _Current(_STD move(_Current_)), _End(_RANGES end(_Parent->_Range)), _Count(_Parent->_Count),
+                  _Missing(_Missing_) {}
+
+        public:
+            using iterator_category = input_iterator_tag;
+            using iterator_concept  = conditional_t<random_access_range<_Base>, random_access_iterator_tag,
+                conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag, forward_iterator_tag>>;
+            using value_type        = decltype(views::take(subrange(_Current, _End), _Count));
+            using difference_type   = range_difference_t<_Base>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _Other)
+                noexcept(is_nothrow_constructible_v<_Base_iterator, typename _Iterator<!_Const>::_Base_iterator>
+                         && is_nothrow_constructible_v<_Base_sentinel,
+                             typename _Iterator<!_Const>::_Base_sentinel>) /* strengthened */
+                requires _Const && convertible_to<iterator_t<_Vw>, _Base_iterator>
+                          && convertible_to<sentinel_t<_Vw>, _Base_sentinel>
+                : _Current(_STD move(_Other._Current)), _End(_STD move(_Other._End)), _Count(_Other._Count),
+                  _Missing(_Other._Missing) {}
+
+            _NODISCARD constexpr _Base_iterator base() const
+                noexcept(is_nothrow_copy_constructible_v<_Base_iterator>) /* strengthened */ {
+                return _Current;
+            }
+
+            _NODISCARD constexpr value_type operator*() const
+                noexcept(noexcept(views::take(subrange(_Current, _End), _Count))) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Current != _End, "cannot dereference chunk_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return views::take(subrange(_Current, _End), _Count);
+            }
+
+            constexpr _Iterator& operator++() /* not strengthened, see _RANGES advance */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Current != _End, "cannot increment chunk_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Missing = _RANGES advance(_Current, _Count, _End);
+                return *this;
+            }
+
+            constexpr _Iterator operator++(int) /* not strengthened, see _RANGES advance */ {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--() /* not strengthened, see _RANGES advance */
+                requires bidirectional_range<_Base>
+            {
+                _RANGES advance(_Current, _Missing - _Count);
+                _Missing = 0;
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int) /* not strengthened, see _RANGES advance */
+                requires bidirectional_range<_Base>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off) /* not strengthened, see _RANGES advance */
+                requires random_access_range<_Base>
+            {
+                if (_Off > 0) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                    _STL_VERIFY(_Count <= (numeric_limits<difference_type>::max)() / _Off,
+                        "cannot advance chunk_view iterator past end (integer overflow)");
+                    if constexpr (sized_sentinel_for<_Base_sentinel, _Base_iterator>) {
+                        _STL_VERIFY(_End - _Current > _Count * (_Off - 1), //
+                            "cannot advance chunk_view iterator past end");
+                    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+                    if constexpr (sized_sentinel_for<_Base_sentinel, _Base_iterator>) {
+                        _Missing = _RANGES advance(_Current, _Count * _Off, _End);
+                    } else {
+                        _Current += static_cast<difference_type>(_Count * (_Off - 1));
+                        _Missing = _RANGES advance(_Current, _Count, _End);
+                    }
+                } else if (_Off < 0) {
+                    _Current += static_cast<difference_type>(_Count * _Off + _Missing);
+                    _Missing = 0;
+                }
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off) /* not strengthened, see _RANGES advance */
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Off != (numeric_limits<difference_type>::min)(),
+                    "cannot advance chunk_view iterator past end (integer overflow)");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return *this += -_Off;
+            }
+
+            _NODISCARD constexpr value_type operator[](const difference_type _Off) const
+                noexcept(noexcept(*(*this + _Off))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return *(*this + _Off);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current == _Right._Current))) /* strengthened */ {
+                return _Left._Current == _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, default_sentinel_t)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current == _Left._End))) /* strengthened */ {
+                return _Left._Current == _Left._End;
+            }
+
+            _NODISCARD friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current < _Right._Current))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return _Left._Current < _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Right._Current < _Left._Current))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return _Right._Current < _Left._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(!(_Right._Current < _Left._Current)))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return !(_Right._Current < _Left._Current);
+            }
+
+            _NODISCARD friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(!(_Left._Current < _Right._Current)))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return !(_Left._Current < _Right._Current);
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current <=> _Right._Current)) /* strengthened */
+                requires random_access_range<_Base> && three_way_comparable<_Base_iterator>
+            {
+                return _Left._Current <=> _Right._Current;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off)
+                noexcept(is_nothrow_copy_constructible_v<_Iterator>
+                         && noexcept(_STD declval<_Iterator&>() += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy += _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It)
+                noexcept(is_nothrow_copy_constructible_v<_Iterator>
+                         && noexcept(_STD declval<_Iterator&>() += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy += _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off)
+                noexcept(is_nothrow_copy_constructible_v<_Iterator>
+                         && noexcept(_STD declval<_Iterator&>() -= _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy -= _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current - _Right._Current)) /* strengthened */
+                requires sized_sentinel_for<_Base_iterator, _Base_iterator>
+            {
+                return (_Left._Current - _Right._Current + _Left._Missing - _Right._Missing) / _Left._Count;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(default_sentinel_t, const _Iterator& _Right)
+                noexcept(noexcept(_Right._End - _Right._Current)) /* strengthened */
+                requires sized_sentinel_for<_Base_sentinel, _Base_iterator>
+            {
+                return _Div_ceil(_Right._End - _Right._Current, _Right._Count);
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, default_sentinel_t)
+                noexcept(noexcept(_Left._End - _Left._Current)) /* strengthened */
+                requires sized_sentinel_for<_Base_sentinel, _Base_iterator>
+            {
+                return -_Div_ceil(_Left._End - _Left._Current, _Left._Count);
+            }
+        };
+
+    public:
+        constexpr explicit chunk_view(_Vw _Range_, const range_difference_t<_Vw> _Count_)
+            noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */
+            : _Range(_STD move(_Range_)), _Count{_Count_} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Count > 0, "chunk size must be greater than 0");
+#endif
+        }
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin() noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */
+            requires (!_Simple_view<_Vw>)
+        {
+            return _Iterator<false>{this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto begin() const
+            noexcept(noexcept(_RANGES begin(_Range))
+                     && is_nothrow_move_constructible_v<iterator_t<const _Vw>>) /* strengthened */
+            requires forward_range<const _Vw>
+        {
+            return _Iterator<true>{this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto end() noexcept(noexcept(_RANGES distance(_Range)) && noexcept(_RANGES end(_Range))
+                                                 && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (common_range<_Vw> && sized_range<_Vw>) {
+                const auto _Missing = static_cast<range_difference_t<_Vw>>(_Count - _RANGES distance(_Range) % _Count);
+                if (_Missing == _Count) {
+                    return _Iterator<false>{this, _RANGES end(_Range)};
+                }
+                return _Iterator<false>{this, _RANGES end(_Range), _Missing};
+            } else if constexpr (common_range<_Vw> && !bidirectional_range<_Vw>) {
+                return _Iterator<false>{this, _RANGES end(_Range)};
+            } else {
+                return default_sentinel;
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            noexcept(noexcept(_RANGES distance(_Range)) && noexcept(_RANGES end(_Range))
+                     && is_nothrow_move_constructible_v<iterator_t<const _Vw>>) /* strengthened */
+            requires forward_range<const _Vw>
+        {
+            if constexpr (common_range<const _Vw> && sized_range<const _Vw>) {
+                const auto _Missing = static_cast<range_difference_t<_Vw>>(_Count - _RANGES distance(_Range) % _Count);
+                if (_Missing == _Count) {
+                    return _Iterator<true>{this, _RANGES end(_Range)};
+                }
+                return _Iterator<true>{this, _RANGES end(_Range), _Missing};
+            } else if constexpr (common_range<const _Vw> && !bidirectional_range<const _Vw>) {
+                return _Iterator<true>{this, _RANGES end(_Range)};
+            } else {
+                return default_sentinel;
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES distance(_Range))) /* strengthened */
+            requires sized_range<_Vw>
+        {
+            return _To_unsigned_like(_Div_ceil(_RANGES distance(_Range), _Count));
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES distance(_Range))) /* strengthened */
+            requires sized_range<const _Vw>
+        {
+            return _To_unsigned_like(_Div_ceil(_RANGES distance(_Range), _Count));
+        }
+    };
+
+    template <class _Rng>
+    chunk_view(_Rng&&, range_difference_t<_Rng>) -> chunk_view<views::all_t<_Rng>>;
+
+    template <class _Vw>
+    constexpr bool enable_borrowed_range<chunk_view<_Vw>> = enable_borrowed_range<_Vw> && forward_range<_Vw>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<chunk_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+        requires forward_range<_Rng>
+    constexpr auto _Compile_time_max_size<const chunk_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+
+    namespace views {
+        struct _Chunk_fn {
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, const range_difference_t<_Rng> _Count)
+                noexcept(noexcept(chunk_view(_STD forward<_Rng>(_Range), _Count)))
+                requires requires { chunk_view(_STD forward<_Rng>(_Range), _Count); }
+            {
+                return chunk_view(_STD forward<_Rng>(_Range), _Count);
+            }
+
+            template <class _Ty>
+                requires constructible_from<decay_t<_Ty>, _Ty>
+            _NODISCARD static constexpr auto operator()(_Ty&& _Count)
+                noexcept(is_nothrow_constructible_v<decay_t<_Ty>, _Ty>) {
+                return _Range_closure<_Chunk_fn, decay_t<_Ty>>{_STD forward<_Ty>(_Count)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Chunk_fn chunk;
+    } // namespace views
+
+    template <class _Vw>
+    concept _Slide_caches_nothing = random_access_range<_Vw> && sized_range<_Vw>;
+
+    template <class _Vw>
+    concept _Slide_caches_last = !_Slide_caches_nothing<_Vw> && bidirectional_range<_Vw> && common_range<_Vw>;
+
+    template <class _Vw>
+    concept _Slide_caches_first = !_Slide_caches_nothing<_Vw> && !_Slide_caches_last<_Vw>;
+
+    _EXPORT_STD template <forward_range _Vw>
+        requires view<_Vw>
+    class slide_view : public _Cached_position_t<!_Slide_caches_nothing<_Vw>, _Vw, slide_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range;
+        range_difference_t<_Vw> _Count;
+
+        template <class>
+        class _Iter_base {};
+
+        template <_Slide_caches_first _Base>
+        class _Iter_base<_Base> {
+        protected:
+            using _Base_iterator = iterator_t<_Base>;
+            _Base_iterator _Last_element{};
+
+        public:
+            _Iter_base() = default;
+            constexpr explicit _Iter_base(_Base_iterator _Last_element_)
+                noexcept(is_nothrow_move_constructible_v<_Base_iterator>)
+                : _Last_element{_STD move(_Last_element_)} {}
+
+            _NODISCARD constexpr const _Base_iterator& _Get_last_element() const noexcept {
+                return _Last_element;
+            }
+        };
+
+        template <bool _Const>
+        class _Iterator : public _Iter_base<_Maybe_const<_Const, _Vw>> {
+        private:
+            friend slide_view;
+
+            using _Base          = _Maybe_const<_Const, _Vw>;
+            using _Base_iterator = iterator_t<_Base>;
+
+            /* [[no_unique_address]] */ _Base_iterator _Current{};
+            range_difference_t<_Base> _Count = 0;
+
+            constexpr _Iterator(_Base_iterator _Current_, range_difference_t<_Base> _Count_)
+                noexcept(is_nothrow_move_constructible_v<_Base_iterator>) /* strengthened */
+                requires (!_Slide_caches_first<_Base>)
+                : _Current(_STD move(_Current_)), _Count(_Count_) {}
+
+            constexpr _Iterator(_Base_iterator _Current_, _Base_iterator _Last_, range_difference_t<_Base> _Count_)
+                noexcept(is_nothrow_move_constructible_v<_Base_iterator>) /* strengthened */
+                requires _Slide_caches_first<_Base>
+                : _Iter_base<_Base>(_STD move(_Last_)), _Current(_STD move(_Current_)), _Count(_Count_) {}
+
+        public:
+            using value_type        = decltype(views::counted(_Current, _Count));
+            using difference_type   = range_difference_t<_Base>;
+            using iterator_category = input_iterator_tag;
+            using iterator_concept  = conditional_t<random_access_range<_Base>, random_access_iterator_tag,
+                conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag, forward_iterator_tag>>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _Other)
+                noexcept(is_nothrow_constructible_v<_Base_iterator, iterator_t<_Vw>>) // strengthened
+                requires _Const && convertible_to<iterator_t<_Vw>, _Base_iterator>
+                : _Current(_STD move(_Other._Current)), _Count(_Other._Count) {}
+
+            _NODISCARD constexpr value_type operator*() const
+                noexcept(noexcept(views::counted(_Current, _Count))) /* strengthened */ {
+                return views::counted(_Current, _Count);
+            }
+
+            constexpr _Iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+                ++_Current;
+
+                if constexpr (_Slide_caches_first<_Base>) {
+                    ++this->_Last_element;
+                }
+                return *this;
+            }
+
+            constexpr _Iterator operator++(int)
+                noexcept(is_nothrow_copy_constructible_v<_Base_iterator> && noexcept(++_Current)) /* strengthened */ {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--() noexcept(noexcept(--_Current)) /* strengthened */
+                requires bidirectional_range<_Base>
+            {
+                --_Current;
+
+                if constexpr (_Slide_caches_first<_Base>) {
+                    --this->_Last_element;
+                }
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                noexcept(is_nothrow_copy_constructible_v<_Base_iterator> && noexcept(--_Current)) /* strengthened */
+                requires bidirectional_range<_Base>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                noexcept(noexcept(_Current += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                _Current += _Off;
+
+                if constexpr (_Slide_caches_first<_Base>) {
+                    this->_Last_element += _Off;
+                }
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                noexcept(noexcept(_Current -= _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                _Current -= _Off;
+
+                if constexpr (_Slide_caches_first<_Base>) {
+                    this->_Last_element -= _Off;
+                }
+                return *this;
+            }
+
+            _NODISCARD constexpr value_type operator[](const difference_type _Off) const
+                noexcept(noexcept(views::counted(_Current + _Off, _Count))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return views::counted(_Current + _Off, _Count);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current == _Right._Current))) /* strengthened */ {
+                if constexpr (_Slide_caches_first<_Base>) {
+                    return _Left._Last_element == _Right._Last_element;
+                } else {
+                    return _Left._Current == _Right._Current;
+                }
+            }
+
+            _NODISCARD friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current < _Right._Current))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return _Left._Current < _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Right._Current < _Left._Current))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return _Right._Current < _Left._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(!(_Right._Current < _Left._Current)))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return !(_Right._Current < _Left._Current);
+            }
+
+            _NODISCARD friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(!(_Left._Current < _Right._Current)))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return !(_Left._Current < _Right._Current);
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current <=> _Right._Current)) /* strengthened */
+                requires random_access_range<_Base> && three_way_comparable<_Base_iterator>
+            {
+                return _Left._Current <=> _Right._Current;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off)
+                noexcept(noexcept(_STD declval<_Iterator&>() += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy += _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It)
+                noexcept(noexcept(_STD declval<_Iterator&>() += _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy += _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off)
+                noexcept(noexcept(_STD declval<_Iterator&>() -= _Off)) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy -= _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current - _Right._Current)) /* strengthened */
+                requires sized_sentinel_for<_Base_iterator, _Base_iterator>
+            {
+                if constexpr (_Slide_caches_first<_Base>) {
+                    return _Left._Last_element - _Right._Last_element;
+                } else {
+                    return _Left._Current - _Right._Current;
+                }
+            }
+        };
+
+        class _Sentinel {
+        private:
+            friend slide_view;
+            _MSVC_NO_UNIQUE_ADDRESS sentinel_t<_Vw> _Last{};
+
+            constexpr explicit _Sentinel(sentinel_t<_Vw> _Last_)
+                noexcept(is_nothrow_move_constructible_v<sentinel_t<_Vw>>) /* strengthened */
+                : _Last(_STD move(_Last_)) {}
+
+        public:
+            _Sentinel() = default;
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator<false>& _Left, const _Sentinel& _Right)
+                noexcept(noexcept(
+                    _STD _Fake_copy_init<bool>(_Left._Get_last_element() == _Right._Last))) /* strengthened */ {
+                return _Left._Get_last_element() == _Right._Last;
+            }
+
+            _NODISCARD friend constexpr range_difference_t<_Vw> operator-(const _Iterator<false>& _Left,
+                const _Sentinel& _Right) noexcept(noexcept(_Left._Get_last_element() - _Right._Last)) /* strengthened */
+                requires sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>
+            {
+                return _Left._Get_last_element() - _Right._Last;
+            }
+
+            _NODISCARD friend constexpr range_difference_t<_Vw> operator-(
+                const _Sentinel& _Left, const _Iterator<false>& _Right)
+                noexcept(noexcept(_Left._Last - _Right._Get_last_element())) /* strengthened */
+                requires sized_sentinel_for<sentinel_t<_Vw>, iterator_t<_Vw>>
+            {
+                return _Left._Last - _Right._Get_last_element();
+            }
+        };
+
+    public:
+        constexpr explicit slide_view(_Vw _Range_, const range_difference_t<_Vw> _Count_)
+            noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */
+            : _Range(_STD move(_Range_)), _Count{_Count_} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Count > 0, "The window size must be positive (N4950 [range.slide.view]/1)");
+#endif
+        }
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) // strengthened
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin()
+            requires (!(_Simple_view<_Vw> && _Slide_caches_nothing<const _Vw>) )
+        {
+            if constexpr (_Slide_caches_first<_Vw>) {
+                auto _First = _RANGES begin(_Range);
+                if (this->_Has_cache()) {
+                    return _Iterator<false>{_STD move(_First), this->_Get_cache(_Range), _Count};
+                }
+
+                auto _Current_last = _RANGES next(_First, _Count - 1, _RANGES end(_Range));
+                this->_Set_cache(_Range, _Current_last);
+                return _Iterator<false>{_STD move(_First), _STD move(_Current_last), _Count};
+            } else {
+                return _Iterator<false>{_RANGES begin(_Range), _Count};
+            }
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */
+            requires _Slide_caches_nothing<const _Vw>
+        {
+            return _Iterator<true>{_RANGES begin(_Range), _Count};
+        }
+
+        _NODISCARD constexpr auto end()
+            requires (!(_Simple_view<_Vw> && _Slide_caches_nothing<const _Vw>) )
+        {
+            if constexpr (_Slide_caches_nothing<_Vw>) {
+                const auto _Size = _RANGES distance(_Range) - (_Count - 1);
+                if (_Size < 0) {
+                    return _Iterator<false>{_RANGES begin(_Range), _Count};
+                }
+
+                return _Iterator<false>{_RANGES begin(_Range) + _Size, _Count};
+            } else if constexpr (_Slide_caches_last<_Vw>) {
+                if (this->_Has_cache()) {
+                    return _Iterator<false>{this->_Get_cache(_Range), _Count};
+                }
+
+                auto _Current_last = _RANGES prev(_RANGES end(_Range), _Count - 1, _RANGES begin(_Range));
+                this->_Set_cache(_Range, _Current_last);
+                return _Iterator<false>{_STD move(_Current_last), _Count};
+            } else if constexpr (common_range<_Vw>) {
+                const auto _Last = _RANGES end(_Range);
+                return _Iterator<false>{_Last, _Last, _Count};
+            } else {
+                return _Sentinel{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            noexcept(is_nothrow_move_constructible_v<iterator_t<_Vw>> && noexcept(_RANGES distance(_Range))
+                     && noexcept(_RANGES begin(_Range) + _Count)) /* strengthened */
+            requires _Slide_caches_nothing<const _Vw>
+        {
+            const auto _Size = _RANGES distance(_Range) - (_Count - 1);
+            if (_Size < 0) {
+                return _Iterator<true>{_RANGES begin(_Range), _Count};
+            }
+
+            return _Iterator<true>{_RANGES begin(_Range) + _Size, _Count};
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES distance(_Range))) /* strengthened */
+            requires sized_range<_Vw>
+        {
+            auto _Size = _RANGES distance(_Range) - (_Count - 1);
+            if (_Size < 0) {
+                _Size = 0;
+            }
+
+            return _To_unsigned_like(_Size);
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES distance(_Range))) /* strengthened */
+            requires sized_range<const _Vw>
+        {
+            auto _Size = _RANGES distance(_Range) - (_Count - 1);
+            if (_Size < 0) {
+                _Size = 0;
+            }
+            return _To_unsigned_like(_Size);
+        }
+    };
+
+    template <class _Rng>
+    slide_view(_Rng&&, range_difference_t<_Rng>) -> slide_view<views::all_t<_Rng>>;
+
+    template <class _Vw>
+    constexpr bool enable_borrowed_range<slide_view<_Vw>> = enable_borrowed_range<_Vw>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<slide_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const slide_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+
+    namespace views {
+        struct _Slide_fn {
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, const range_difference_t<_Rng> _Count)
+                noexcept(noexcept(slide_view(_STD forward<_Rng>(_Range), _Count)))
+                requires requires { slide_view(_STD forward<_Rng>(_Range), _Count); }
+            {
+                return slide_view(_STD forward<_Rng>(_Range), _Count);
+            }
+
+            template <class _Ty>
+                requires constructible_from<decay_t<_Ty>, _Ty>
+            _NODISCARD static constexpr auto operator()(_Ty&& _Count)
+                noexcept(is_nothrow_constructible_v<decay_t<_Ty>, _Ty>) {
+                return _Range_closure<_Slide_fn, decay_t<_Ty>>{_STD forward<_Ty>(_Count)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Slide_fn slide;
+    } // namespace views
+
+    template <class _Pr>
+    struct _Negated_pred {
+        template <class _Ty1, class _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) {
+            return !_STD invoke(_Pred, _STD forward<_Ty1>(_Left), _STD forward<_Ty2>(_Right));
+        }
+
+        _Pr& _Pred;
+    };
+
+    template <class _Pr>
+    struct _Backward_negated_pred {
+        template <class _Ty1, class _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) {
+            return !_STD invoke(_Pred, _STD forward<_Ty2>(_Right), _STD forward<_Ty1>(_Left));
+        }
+
+        _Pr& _Pred;
+    };
+
+    _EXPORT_STD template <forward_range _Vw, indirect_binary_predicate<iterator_t<_Vw>, iterator_t<_Vw>> _Pr>
+        requires view<_Vw> && is_object_v<_Pr>
+    class chunk_by_view : public _Cached_position<_Vw, chunk_by_view<_Vw, _Pr>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+        /* [[no_unique_address]] */ _Movable_box<_Pr> _Pred{};
+
+        class _Iterator {
+        private:
+            friend chunk_by_view;
+
+            chunk_by_view* _Parent{};
+            /* [[no_unique_address]] */ iterator_t<_Vw> _Current{};
+            /* [[no_unique_address]] */ iterator_t<_Vw> _Next{};
+
+            constexpr _Iterator(chunk_by_view& _Parent_, iterator_t<_Vw> _Current_, iterator_t<_Vw> _Next_)
+                noexcept(is_nothrow_move_constructible_v<iterator_t<_Vw>>) // strengthened
+                : _Parent(_STD addressof(_Parent_)), _Current(_STD move(_Current_)), _Next(_STD move(_Next_)) {}
+
+        public:
+            using value_type        = subrange<iterator_t<_Vw>>;
+            using difference_type   = range_difference_t<_Vw>;
+            using iterator_category = input_iterator_tag;
+            using iterator_concept =
+                conditional_t<bidirectional_range<_Vw>, bidirectional_iterator_tag, forward_iterator_tag>;
+
+            _Iterator() = default;
+
+            _NODISCARD constexpr value_type operator*() const
+                noexcept(is_nothrow_copy_constructible_v<iterator_t<_Vw>>) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Current != _Next, "cannot dereference chunk_by_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return subrange{_Current, _Next};
+            }
+
+            constexpr _Iterator& operator++() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Current != _Next, "cannot increment chunk_by_view iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Current = _Next;
+                _Next    = _Parent->_Find_next(_Next);
+                return *this;
+            }
+
+            constexpr _Iterator operator++(int) {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--()
+                requires bidirectional_range<_Vw>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Parent != nullptr, "cannot decrement value-initialized chunk_by_view iterator");
+                _STL_VERIFY(
+                    _Current != _RANGES begin(_Parent->_Range), "cannot decrement chunk_by_view iterator before begin");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Next    = _Current;
+                _Current = _Parent->_Find_prev(_Current);
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                requires bidirectional_range<_Vw>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current == _Right._Current))) /* strengthened */ {
+                return _Left._Current == _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, default_sentinel_t)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current == _Left._Next))) /* strengthened */ {
+                return _Left._Current == _Left._Next;
+            }
+        };
+
+        _NODISCARD constexpr iterator_t<_Vw> _Find_next(iterator_t<_Vw> _It) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "cannot increment a chunk_by_view iterator whose parent view has no predicate");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+            const auto _Before_next = _RANGES adjacent_find(_It, _RANGES end(_Range), _Negated_pred<_Pr>{*_Pred});
+            return _RANGES next(_Before_next, 1, _RANGES end(_Range));
+        }
+
+        _NODISCARD constexpr iterator_t<_Vw> _Find_prev(iterator_t<_Vw> _It) {
+            _STL_INTERNAL_STATIC_ASSERT(bidirectional_range<_Vw>);
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "cannot decrement a chunk_by_view iterator whose parent view has no predicate");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+            reverse_view _Rv{subrange{_RANGES begin(_Range), _It}};
+            const auto _After_prev = _RANGES adjacent_find(_Rv, _Backward_negated_pred<_Pr>{*_Pred});
+            return _RANGES prev(_After_prev.base(), 1, _RANGES begin(_Range));
+        }
+
+    public:
+        chunk_by_view()
+            requires default_initializable<_Vw> && default_initializable<_Pr>
+        = default;
+
+        constexpr explicit chunk_by_view(_Vw _Range_, _Pr _Pred_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Pr>) // strengthened
+            : _Range(_STD move(_Range_)), _Pred{in_place, _STD move(_Pred_)} {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr const _Pr& pred() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "chunk_by_view has no predicate");
+#endif
+            return *_Pred;
+        }
+
+        _NODISCARD constexpr _Iterator begin() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Pred, "cannot call begin on a chunk_by_view with no predicate");
+#endif
+
+            const auto _First = _RANGES begin(_Range);
+            if (this->_Has_cache()) {
+                return _Iterator{*this, _First, this->_Get_cache(_Range)};
+            }
+
+            const auto _Result = _Find_next(_First);
+            this->_Set_cache(_Range, _Result);
+            return _Iterator{*this, _First, _Result};
+        }
+
+        _NODISCARD constexpr auto end() {
+            if constexpr (common_range<_Vw>) {
+                const auto _Last = _RANGES end(_Range);
+                return _Iterator{*this, _Last, _Last};
+            } else {
+                return default_sentinel;
+            }
+        }
+    };
+
+    template <class _Rng, class _Pr>
+    chunk_by_view(_Rng&&, _Pr) -> chunk_by_view<views::all_t<_Rng>, _Pr>;
+
+    template <class _Rng, class _Pr>
+    constexpr auto _Compile_time_max_size<chunk_by_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+
+    namespace views {
+        struct _Chunk_by_fn {
+            template <viewable_range _Rng, class _Pr>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Pr&& _Pred)
+                noexcept(noexcept(chunk_by_view(_STD forward<_Rng>(_Range), _STD forward<_Pr>(_Pred))))
+                requires requires { chunk_by_view(_STD forward<_Rng>(_Range), _STD forward<_Pr>(_Pred)); }
+            {
+                return chunk_by_view(_STD forward<_Rng>(_Range), _STD forward<_Pr>(_Pred));
+            }
+
+            template <class _Pr>
+                requires constructible_from<decay_t<_Pr>, _Pr>
+            _NODISCARD static constexpr auto operator()(_Pr&& _Pred)
+                noexcept(is_nothrow_constructible_v<decay_t<_Pr>, _Pr>) {
+                return _Range_closure<_Chunk_by_fn, decay_t<_Pr>>{_STD forward<_Pr>(_Pred)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Chunk_by_fn chunk_by;
+    } // namespace views
+
+    _EXPORT_STD template <input_range _Vw>
+        requires view<_Vw>
+    class stride_view : public view_interface<stride_view<_Vw>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range;
+        range_difference_t<_Vw> _Stride;
+
+        template <class _BaseTy>
+        class _Category_base {};
+
+        template <forward_range _BaseTy>
+        class _Category_base<_BaseTy> {
+        private:
+            using _BaseCategory = iterator_traits<iterator_t<_BaseTy>>::iterator_category;
+
+        public:
+            using iterator_category = conditional_t<derived_from<_BaseCategory, random_access_iterator_tag>,
+                random_access_iterator_tag, _BaseCategory>;
+        };
+
+        template <bool _Const>
+        class _Iterator : public _Category_base<_Maybe_const<_Const, _Vw>> {
+        private:
+            friend stride_view;
+
+            using _ParentTy      = _Maybe_const<_Const, stride_view>;
+            using _Base          = _Maybe_const<_Const, _Vw>;
+            using _Base_iterator = iterator_t<_Base>;
+            using _Base_sentinel = sentinel_t<_Base>;
+
+            /* [[no_unique_address]] */ _Base_iterator _Current{};
+            /* [[no_unique_address]] */ _Base_sentinel _End{};
+            range_difference_t<_Base> _Stride  = 0;
+            range_difference_t<_Base> _Missing = 0;
+
+            constexpr _Iterator(_ParentTy* _Parent, _Base_iterator _Current_,
+                range_difference_t<_Base> _Missing_ = 0)
+                noexcept(noexcept(_RANGES end(_Parent->_Range)) && is_nothrow_move_constructible_v<_Base_iterator>
+                         && is_nothrow_move_constructible_v<_Base_sentinel>) // strengthened
+                : _Current(_STD move(_Current_)), _End(_RANGES end(_Parent->_Range)), _Stride(_Parent->_Stride),
+                  _Missing(_Missing_) {}
+
+        public:
+            using difference_type  = range_difference_t<_Base>;
+            using value_type       = range_value_t<_Base>;
+            using iterator_concept = conditional_t<random_access_range<_Base>, random_access_iterator_tag,
+                conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag,
+                    conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>>>;
+
+            _Iterator()
+                requires default_initializable<_Base_iterator>
+            = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _Other)
+                noexcept(is_nothrow_constructible_v<_Base_iterator, iterator_t<_Vw>>
+                         && is_nothrow_constructible_v<_Base_sentinel, sentinel_t<_Vw>>) /* strengthened */
+                requires _Const && convertible_to<iterator_t<_Vw>, _Base_iterator>
+                          && convertible_to<sentinel_t<_Vw>, _Base_sentinel>
+                : _Current(_STD move(_Other._Current)), _End(_STD move(_Other._End)), _Stride(_Other._Stride),
+                  _Missing(_Other._Missing) {}
+
+            _NODISCARD constexpr _Base_iterator base() && noexcept(
+                is_nothrow_move_constructible_v<_Base_iterator>) /* strengthened */ {
+                return _STD move(_Current);
+            }
+
+            _NODISCARD constexpr const _Base_iterator& base() const& noexcept {
+                return _Current;
+            }
+
+            _NODISCARD constexpr decltype(auto) operator*() const noexcept(noexcept(*_Current)) /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Current != _End, "cannot dereference stride_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return *_Current;
+            }
+
+            constexpr _Iterator& operator++() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Current != _End, "cannot increment stride_view end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                _Missing = _RANGES advance(_Current, _Stride, _End);
+                return *this;
+            }
+
+            constexpr void operator++(int) {
+                ++*this;
+            }
+
+            constexpr _Iterator operator++(int)
+                requires forward_range<_Base>
+            {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--()
+                requires bidirectional_range<_Base>
+            {
+                _RANGES advance(_Current, _Missing - _Stride);
+                _Missing = 0;
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                requires bidirectional_range<_Base>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                requires random_access_range<_Base>
+            {
+                if (_Off > 0) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                    _STL_VERIFY(_Stride <= (numeric_limits<difference_type>::max)() / _Off,
+                        "cannot advance stride_view iterator past end (integer overflow)");
+                    if constexpr (sized_sentinel_for<_Base_sentinel, _Base_iterator>) {
+                        _STL_VERIFY(_End - _Current > _Stride * (_Off - 1), //
+                            "cannot advance stride_view iterator past end");
+                    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+                    if constexpr (sized_sentinel_for<_Base_sentinel, _Base_iterator>) {
+                        _Missing = _RANGES advance(_Current, _Stride * _Off, _End);
+                    } else {
+                        _Current += static_cast<difference_type>(_Stride * (_Off - 1));
+                        _Missing = _RANGES advance(_Current, _Stride, _End);
+                    }
+                } else if (_Off < 0) {
+                    _Current += static_cast<difference_type>(_Stride * _Off + _Missing);
+                    _Missing = 0;
+                }
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                requires random_access_range<_Base>
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_VERIFY(_Off != (numeric_limits<difference_type>::min)(),
+                    "cannot advance stride_view iterator past end (integer overflow)");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                return *this += -_Off;
+            }
+
+            _NODISCARD constexpr decltype(auto) operator[](const difference_type _Off) const
+                noexcept(noexcept(*(*this + _Off))) /* strengthened */
+                requires random_access_range<_Base>
+            {
+                return *(*this + _Off);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _It, default_sentinel_t)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_It._Current == _It._End))) /* strengthened */ {
+                return _It._Current == _It._End;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current == _Right._Current))) // strengthened
+                requires equality_comparable<_Base_iterator>
+            {
+                return _Left._Current == _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current < _Right._Current))) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Left._Current < _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_Right._Current < _Left._Current))) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Right._Current < _Left._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(!(_Right._Current < _Left._Current)))) // strengthened
+                requires random_access_range<_Base>
+            {
+                return !(_Right._Current < _Left._Current);
+            }
+
+            _NODISCARD friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(!(_Left._Current < _Right._Current)))) // strengthened
+                requires random_access_range<_Base>
+            {
+                return !(_Left._Current < _Right._Current);
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current <=> _Right._Current)) // strengthened
+                requires random_access_range<_Base> && three_way_comparable<_Base_iterator>
+            {
+                return _Left._Current <=> _Right._Current;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off)
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy += _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It)
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy += _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off)
+                requires random_access_range<_Base>
+            {
+                auto _Copy = _It;
+                _Copy -= _Off;
+                return _Copy;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current - _Right._Current)) // strengthened
+                requires sized_sentinel_for<_Base_iterator, _Base_iterator>
+            {
+                const auto _Diff = _Left._Current - _Right._Current;
+                if constexpr (forward_range<_Base>) {
+                    return (_Diff + _Left._Missing - _Right._Missing) / _Left._Stride;
+                } else {
+                    if (_Diff < 0) {
+                        return -_Div_ceil(-_Diff, _Left._Stride);
+                    } else {
+                        return _Div_ceil(_Diff, _Left._Stride);
+                    }
+                }
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(default_sentinel_t, const _Iterator& _It)
+                noexcept(noexcept(_It._End - _It._Current)) // strengthened
+                requires sized_sentinel_for<_Base_sentinel, _Base_iterator>
+            {
+                return _Div_ceil(_It._End - _It._Current, _It._Stride);
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _It, default_sentinel_t)
+                noexcept(noexcept(_It._End - _It._Current)) // strengthened
+                requires sized_sentinel_for<_Base_sentinel, _Base_iterator>
+            {
+                return -_Div_ceil(_It._End - _It._Current, _It._Stride);
+            }
+
+            _NODISCARD friend constexpr range_rvalue_reference_t<_Base> iter_move(const _Iterator& _It)
+                noexcept(noexcept(_RANGES iter_move(_It._Current))) {
+                return _RANGES iter_move(_It._Current);
+            }
+
+            friend constexpr void iter_swap(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_RANGES iter_swap(_Left._Current, _Right._Current)))
+                requires indirectly_swappable<_Base_iterator>
+            {
+                return _RANGES iter_swap(_Left._Current, _Right._Current);
+            }
+        };
+
+    public:
+        constexpr explicit stride_view(_Vw _Range_, const range_difference_t<_Vw> _Stride_)
+            noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)), _Stride(_Stride_) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Stride > 0, "stride must be greater than 0");
+#endif
+        }
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) // strengthened
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr range_difference_t<_Vw> stride() const noexcept {
+            return _Stride;
+        }
+
+        _NODISCARD constexpr auto begin() noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) // strengthened
+            requires (!_Simple_view<_Vw>)
+        {
+            return _Iterator<false>{this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(
+            noexcept(_RANGES begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<const _Vw>>) // strengthened
+            requires range<const _Vw>
+        {
+            return _Iterator<true>{this, _RANGES begin(_Range)};
+        }
+
+        _NODISCARD constexpr auto end() noexcept(noexcept(_RANGES distance(_Range)) && noexcept(_RANGES end(_Range))
+                                                 && is_nothrow_move_constructible_v<iterator_t<_Vw>>) // strengthened
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (common_range<_Vw> && sized_range<_Vw> && forward_range<_Vw>) {
+                const auto _Missing =
+                    static_cast<range_difference_t<_Vw>>(_Stride - _RANGES distance(_Range) % _Stride);
+                if (_Missing == _Stride) {
+                    return _Iterator<false>{this, _RANGES end(_Range)};
+                } else {
+                    return _Iterator<false>{this, _RANGES end(_Range), _Missing};
+                }
+            } else if constexpr (common_range<_Vw> && !bidirectional_range<_Vw>) {
+                return _Iterator<false>{this, _RANGES end(_Range)};
+            } else {
+                return default_sentinel;
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            noexcept(noexcept(_RANGES distance(_Range)) && noexcept(_RANGES end(_Range))
+                     && is_nothrow_move_constructible_v<iterator_t<const _Vw>>) // strengthened
+            requires range<const _Vw>
+        {
+            if constexpr (common_range<const _Vw> && sized_range<const _Vw> && forward_range<const _Vw>) {
+                const auto _Missing =
+                    static_cast<range_difference_t<_Vw>>(_Stride - _RANGES distance(_Range) % _Stride);
+                if (_Missing == _Stride) {
+                    return _Iterator<true>{this, _RANGES end(_Range)};
+                } else {
+                    return _Iterator<true>{this, _RANGES end(_Range), _Missing};
+                }
+            } else if constexpr (common_range<const _Vw> && !bidirectional_range<const _Vw>) {
+                return _Iterator<true>{this, _RANGES end(_Range)};
+            } else {
+                return default_sentinel;
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES distance(_Range))) // strengthened
+            requires sized_range<_Vw>
+        {
+            return _To_unsigned_like(_Div_ceil(_RANGES distance(_Range), _Stride));
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES distance(_Range))) // strengthened
+            requires sized_range<const _Vw>
+        {
+            return _To_unsigned_like(_Div_ceil(_RANGES distance(_Range), _Stride));
+        }
+    };
+
+    template <class _Rng>
+    stride_view(_Rng&&, range_difference_t<_Rng>) -> stride_view<views::all_t<_Rng>>;
+
+    template <class _Vw>
+    constexpr bool enable_borrowed_range<stride_view<_Vw>> = enable_borrowed_range<_Vw>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<stride_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    constexpr auto _Compile_time_max_size<const stride_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+
+    namespace views {
+        struct _Stride_fn {
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, const range_difference_t<_Rng> _Stride)
+                noexcept(noexcept(stride_view(_STD forward<_Rng>(_Range), _Stride)))
+                requires requires { stride_view(_STD forward<_Rng>(_Range), _Stride); }
+            {
+                return stride_view(_STD forward<_Rng>(_Range), _Stride);
+            }
+
+            template <class _Ty>
+                requires constructible_from<decay_t<_Ty>, _Ty>
+            _NODISCARD static constexpr auto operator()(_Ty&& _Stride)
+                noexcept(is_nothrow_constructible_v<decay_t<_Ty>, _Ty>) {
+                return _Range_closure<_Stride_fn, decay_t<_Ty>>{_STD forward<_Ty>(_Stride)};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Stride_fn stride;
+    } // namespace views
+
+    template <class... _RangeTypes>
+    concept _Zip_is_common = (sizeof...(_RangeTypes) == 1 && (common_range<_RangeTypes> && ...))
+                          || (!(bidirectional_range<_RangeTypes> && ...) && (common_range<_RangeTypes> && ...))
+                          || ((random_access_range<_RangeTypes> && ...) && (sized_range<_RangeTypes> && ...));
+
+    template <class _CallbackType>
+    constexpr auto _Tuple_transform_closure(_CallbackType& _Callback) noexcept {
+        return [&_Callback]<class... _ViewTupleTypes>(_ViewTupleTypes&&... _View_tuples) noexcept(
+                   noexcept(tuple<invoke_result_t<_CallbackType&, _ViewTupleTypes>...>{
+                       _STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))...})) {
+            return tuple<invoke_result_t<_CallbackType&, _ViewTupleTypes>...>{
+                _STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))...};
+        };
+    }
+
+    template <class _CallbackType, class _TupleType>
+    constexpr auto _Tuple_transform(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept(noexcept(
+        _STD apply(_Tuple_transform_closure(_Callback), _STD forward<_TupleType>(_Tuple)))) /* strengthened */ {
+        return _STD apply(_Tuple_transform_closure(_Callback), _STD forward<_TupleType>(_Tuple));
+    }
+
+    template <class _CallbackType>
+    constexpr auto _Tuple_for_each_closure(_CallbackType& _Callback) noexcept {
+        return [&_Callback]<class... _ViewTupleTypes>(_ViewTupleTypes&&... _View_tuples) noexcept(
+                   noexcept(((void) (_STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))), ...))) {
+            ((void) (_STD invoke(_Callback, _STD forward<_ViewTupleTypes>(_View_tuples))), ...);
+        };
+    }
+
+    template <class _CallbackType, class _TupleType>
+    constexpr void _Tuple_for_each(_CallbackType&& _Callback, _TupleType&& _Tuple) noexcept(
+        noexcept(_STD apply(_Tuple_for_each_closure(_Callback), _STD forward<_TupleType>(_Tuple)))) /* strengthened */ {
+        _STD apply(_Tuple_for_each_closure(_Callback), _STD forward<_TupleType>(_Tuple));
+    }
+
+    template <bool _IsConst, class... _Views>
+    concept _All_random_access = (random_access_range<_Maybe_const<_IsConst, _Views>> && ...);
+
+    template <bool _IsConst, class... _Views>
+    concept _All_bidirectional = (bidirectional_range<_Maybe_const<_IsConst, _Views>> && ...);
+
+    template <bool _IsConst, class... _Views>
+    concept _All_forward = (forward_range<_Maybe_const<_IsConst, _Views>> && ...);
+
+    template <class _ResultType, class... _LHSTupleTypes, class... _RHSTupleTypes>
+        requires (sizeof...(_LHSTupleTypes) == sizeof...(_RHSTupleTypes))
+    _NODISCARD constexpr _ResultType _Zip_get_smallest_distance(
+        const tuple<_LHSTupleTypes...>& _Lhs_tuple, const tuple<_RHSTupleTypes...>& _Rhs_tuple)
+        noexcept((noexcept(static_cast<_ResultType>(
+                      _STD declval<const _LHSTupleTypes&>() - _STD declval<const _RHSTupleTypes&>()))
+                  && ...)) {
+        constexpr bool _Is_noexcept = (noexcept(static_cast<_ResultType>(_STD declval<const _LHSTupleTypes&>()
+                                                                         - _STD declval<const _RHSTupleTypes&>()))
+                                       && ...);
+        const auto _Get_smallest_distance_closure = [&_Lhs_tuple,
+                                                        &_Rhs_tuple]<size_t _FirstIdx /* = 0 */, size_t... _Idxs>(
+                                                        index_sequence<_FirstIdx, _Idxs...>) noexcept(_Is_noexcept) {
+            const _ResultType _First_size = static_cast<_ResultType>(_STD get<0>(_Lhs_tuple) - _STD get<0>(_Rhs_tuple));
+
+            if (_First_size == 0) {
+                return static_cast<_ResultType>(0);
+            }
+            const initializer_list<_ResultType> _Sizes = {
+                _First_size, (_STD get<_Idxs>(_Lhs_tuple) - _STD get<_Idxs>(_Rhs_tuple))...};
+            return _First_size < 0 ? static_cast<_ResultType>((_RANGES max) (_Sizes))
+                                   : static_cast<_ResultType>((_RANGES min) (_Sizes));
+        };
+
+        return _Get_smallest_distance_closure(index_sequence_for<_LHSTupleTypes...>{});
+    }
+
+    template <class... _LHSTupleTypes, class... _RHSTupleTypes>
+        requires (sizeof...(_LHSTupleTypes) == sizeof...(_RHSTupleTypes))
+    _NODISCARD constexpr bool _Zip_iterator_sentinel_equal(
+        const tuple<_LHSTupleTypes...>& _Lhs_tuple, const tuple<_RHSTupleTypes...>& _Rhs_tuple)
+        noexcept((noexcept(_STD declval<const _LHSTupleTypes&>() == _STD declval<const _RHSTupleTypes&>()) && ...)) {
+        const auto _Evaluate_equality_closure =
+            [&_Lhs_tuple, &_Rhs_tuple]<size_t... _Indices>(index_sequence<_Indices...>) noexcept(
+                (noexcept(_STD declval<const _LHSTupleTypes&>() == _STD declval<const _RHSTupleTypes&>()) &&...)) {
+                return ((_STD get<_Indices>(_Lhs_tuple) == _STD get<_Indices>(_Rhs_tuple)) || ... || false);
+            };
+
+        return _Evaluate_equality_closure(index_sequence_for<_LHSTupleTypes...>{});
+    }
+
+    template <class _Func, class... _Views>
+    concept _Zip_transform_constraints =
+        move_constructible<_Func> && is_object_v<_Func> && (sizeof...(_Views) > 0) && (input_range<_Views> && ...)
+        && (view<_Views> && ...) && regular_invocable<_Func&, range_reference_t<_Views>...>
+        && _Can_reference<invoke_result_t<_Func&, range_reference_t<_Views>...>>;
+
+    _EXPORT_STD template <input_range... _ViewTypes>
+        requires (view<_ViewTypes> && ...) && (sizeof...(_ViewTypes) > 0)
+    class zip_view : public view_interface<zip_view<_ViewTypes...>> {
+    private:
+        /* [[no_unique_address]] */ tuple<_ViewTypes...> _Views;
+
+        template <bool _IsConst>
+        struct _Category_base {};
+
+        template <bool _IsConst>
+            requires _All_forward<_IsConst, _ViewTypes...>
+        struct _Category_base<_IsConst> {
+            using iterator_category = input_iterator_tag;
+        };
+
+        template <bool _IsConst>
+        class _Iterator : public _Category_base<_IsConst> {
+        private:
+            friend zip_view;
+
+            template <class _Func, class... _OtherViews>
+                requires _Zip_transform_constraints<_Func, _OtherViews...>
+            friend class zip_transform_view;
+
+            using _My_tuple = tuple<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>...>;
+
+            /* [[no_unique_address]] */ _My_tuple _Current;
+
+            constexpr explicit _Iterator(_My_tuple _Current_)
+                noexcept(is_nothrow_move_constructible_v<_My_tuple>) // strengthened
+                : _Current(_STD move(_Current_)) {}
+
+        public:
+            using iterator_concept = conditional_t<_All_random_access<_IsConst, _ViewTypes...>,
+                random_access_iterator_tag,
+                conditional_t<_All_bidirectional<_IsConst, _ViewTypes...>, bidirectional_iterator_tag,
+                    conditional_t<_All_forward<_IsConst, _ViewTypes...>, forward_iterator_tag, input_iterator_tag>>>;
+
+            using value_type      = tuple<range_value_t<_Maybe_const<_IsConst, _ViewTypes>>...>;
+            using difference_type = common_type_t<range_difference_t<_Maybe_const<_IsConst, _ViewTypes>>...>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_IsConst> _Rhs) noexcept(
+                (is_nothrow_convertible_v<iterator_t<_ViewTypes>, iterator_t<const _ViewTypes>> && ...)) // strengthened
+                requires (_IsConst && (convertible_to<iterator_t<_ViewTypes>, iterator_t<const _ViewTypes>> && ...))
+                : _Current(_STD move(_Rhs._Current)) {}
+
+            _NODISCARD constexpr auto operator*() const
+                noexcept((noexcept(*(_STD declval<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>&>()))
+                          && ...)) /* strengthened */ {
+                return _Tuple_transform(
+                    [](auto& _Itr) static noexcept(noexcept(*_Itr)) -> decltype(auto) { return *_Itr; }, _Current);
+            }
+
+            constexpr _Iterator& operator++() noexcept(noexcept(_Tuple_for_each(
+                [](auto& _Itr) static noexcept(noexcept(++_Itr)) { ++_Itr; }, _Current))) /* strengthened */ {
+                _Tuple_for_each([](auto& _Itr) static noexcept(noexcept(++_Itr)) { ++_Itr; }, _Current);
+                return *this;
+            }
+
+            constexpr void operator++(int) noexcept(noexcept(++(_STD declval<_Iterator>()))) /* strengthened */ {
+                ++*this;
+            }
+
+            constexpr _Iterator operator++(int) noexcept(
+                noexcept(++(_STD declval<_Iterator>())) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires _All_forward<_IsConst, _ViewTypes...>
+            {
+                auto _Temp = *this;
+                ++*this;
+
+                return _Temp;
+            }
+
+            constexpr _Iterator& operator--() noexcept(noexcept(_Tuple_for_each(
+                [](auto& _Itr) static noexcept(noexcept(--_Itr)) { --_Itr; }, _Current))) // strengthened
+                requires _All_bidirectional<_IsConst, _ViewTypes...>
+            {
+                _Tuple_for_each([](auto& _Itr) static noexcept(noexcept(--_Itr)) { --_Itr; }, _Current);
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int) noexcept(
+                noexcept(--(_STD declval<_Iterator>())) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires _All_bidirectional<_IsConst, _ViewTypes...>
+            {
+                auto _Temp = *this;
+                --*this;
+
+                return _Temp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                noexcept((noexcept(_STD declval<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>&>() +=
+                                   static_cast<iter_difference_t<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>>(_Off))
+                          && ...)) // strengthened
+                requires _All_random_access<_IsConst, _ViewTypes...>
+            {
+                _Tuple_for_each(
+                    [&_Off]<class _IteratorType>(_IteratorType& _Itr) noexcept(
+                        noexcept(_Itr += static_cast<iter_difference_t<_IteratorType>>(_Off))) {
+                        _Itr += static_cast<iter_difference_t<_IteratorType>>(_Off);
+                    },
+                    _Current);
+
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                noexcept((noexcept(_STD declval<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>&>() -=
+                                   static_cast<iter_difference_t<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>>(_Off))
+                          && ...)) // strengthened
+                requires _All_random_access<_IsConst, _ViewTypes...>
+            {
+                _Tuple_for_each(
+                    [&_Off]<class _IteratorType>(_IteratorType& _Itr) noexcept(
+                        noexcept(_Itr -= static_cast<iter_difference_t<_IteratorType>>(_Off))) {
+                        _Itr -= static_cast<iter_difference_t<_IteratorType>>(_Off);
+                    },
+                    _Current);
+
+                return *this;
+            }
+
+            _NODISCARD constexpr auto operator[](const difference_type _Where) const noexcept(
+                (noexcept((_STD declval<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>&>())
+                         [static_cast<iter_difference_t<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>>(_Where)])
+                    && ...)) // strengthened
+                requires _All_random_access<_IsConst, _ViewTypes...>
+            {
+                return _Tuple_transform(
+                    [&_Where]<class _IteratorType>(_IteratorType& _Itr) noexcept(
+                        noexcept(_Itr[static_cast<iter_difference_t<_IteratorType>>(_Where)])) -> decltype(auto) {
+                        return _Itr[static_cast<iter_difference_t<_IteratorType>>(_Where)];
+                    },
+                    _Current);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Lhs, const _Iterator& _Rhs)
+                noexcept(noexcept(_Zip_iterator_sentinel_equal(_Lhs._Current, _Rhs._Current))) // strengthened
+                requires (equality_comparable<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)
+            {
+                if constexpr (!_Zip_is_common<_Maybe_const<_IsConst, _ViewTypes>...>
+                              || _All_random_access<_IsConst, _ViewTypes...> || sizeof...(_ViewTypes) == 1) {
+                    return _STD get<0>(_Lhs._Current) == _STD get<0>(_Rhs._Current);
+                } else {
+                    return _Zip_iterator_sentinel_equal(_Lhs._Current, _Rhs._Current);
+                }
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Lhs, const _Iterator& _Rhs)
+                requires _All_random_access<_IsConst, _ViewTypes...>
+            {
+                return _Lhs._Current <=> _Rhs._Current;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _Lhs, const difference_type _Rhs)
+                noexcept(noexcept(_STD declval<_Iterator&>() += _Rhs)
+                         && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires _All_random_access<_IsConst, _ViewTypes...>
+            {
+                auto _Modified_iterator = _Lhs;
+                _Modified_iterator += _Rhs;
+
+                return _Modified_iterator;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Lhs, const _Iterator& _Rhs)
+                noexcept(noexcept(_Rhs + _Lhs)) /* strengthened */
+                requires _All_random_access<_IsConst, _ViewTypes...>
+            {
+                return _Rhs + _Lhs;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _Lhs, const difference_type _Rhs)
+                noexcept(noexcept(_STD declval<_Iterator&>() -= _Rhs)
+                         && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires _All_random_access<_IsConst, _ViewTypes...>
+            {
+                auto _Modified_iterator = _Lhs;
+                _Modified_iterator -= _Rhs;
+
+                return _Modified_iterator;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Lhs, const _Iterator& _Rhs)
+                noexcept(noexcept(_Zip_get_smallest_distance<difference_type>(_STD declval<_My_tuple>(),
+                    _STD declval<_My_tuple>()))) // strengthened
+                requires (sized_sentinel_for<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>,
+                              iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>
+                          && ...)
+            {
+                return _Zip_get_smallest_distance<difference_type>(_Lhs._Current, _Rhs._Current);
+            }
+
+            _NODISCARD friend constexpr auto iter_move(const _Iterator& _Itr) noexcept(
+                (noexcept(_RANGES iter_move(_STD declval<const iterator_t<_Maybe_const<_IsConst, _ViewTypes>>&>()))
+                    && ...)
+                && (is_nothrow_move_constructible_v<range_rvalue_reference_t<_Maybe_const<_IsConst, _ViewTypes>>>
+                    && ...)) {
+                return _Tuple_transform(_RANGES iter_move, _Itr._Current);
+            }
+
+            friend constexpr void iter_swap(const _Iterator& _Lhs, const _Iterator& _Rhs)
+                noexcept((noexcept(_RANGES iter_swap(_STD declval<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>&>(),
+                              _STD declval<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>&>()))
+                          && ...))
+                requires (indirectly_swappable<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>> && ...)
+            {
+                const auto _Swap_every_pair_closure =
+                    [&_Lhs, &_Rhs]<size_t... _Indices>(index_sequence<_Indices...>) noexcept(noexcept(
+                        ((_RANGES iter_swap(_STD get<_Indices>(_Lhs._Current), _STD get<_Indices>(_Rhs._Current))),
+                            ...))) {
+                        ((_RANGES iter_swap(_STD get<_Indices>(_Lhs._Current), _STD get<_Indices>(_Rhs._Current))),
+                            ...);
+                    };
+
+                _Swap_every_pair_closure(index_sequence_for<_ViewTypes...>{});
+            }
+        };
+
+        template <bool _IsConst>
+        class _Sentinel {
+        private:
+            friend zip_view;
+
+            template <bool _IteratorConst>
+            using _Difference_type = _Iterator<_IteratorConst>::difference_type;
+
+            using _My_tuple = tuple<sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>...>;
+
+            /* [[no_unique_address]] */ _My_tuple _End;
+
+            constexpr explicit _Sentinel(_My_tuple _End_)
+                noexcept(is_nothrow_copy_constructible_v<_My_tuple>) // strengthened
+                : _End(_End_) {}
+
+            template <bool _IteratorConst>
+            _NODISCARD static constexpr const auto& _Get_iterator_tuple(
+                const _Iterator<_IteratorConst>& _Itr) noexcept {
+                // NOTE: This function is necessary because friend functions are never
+                // member functions, and friendship is not transitive.
+                return _Itr._Current;
+            }
+
+        public:
+            _Sentinel() = default;
+
+            constexpr _Sentinel(_Sentinel<!_IsConst> _Rhs) noexcept(
+                (is_nothrow_convertible_v<sentinel_t<_ViewTypes>, sentinel_t<const _ViewTypes>> && ...)) // strengthened
+                requires (_IsConst && (convertible_to<sentinel_t<_ViewTypes>, sentinel_t<const _ViewTypes>> && ...))
+                : _End(_STD move(_Rhs._End)) {}
+
+            template <bool _IteratorConst>
+                requires (sentinel_for<sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>,
+                              iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>
+                          && ...)
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs)
+                noexcept(
+                    noexcept(_Zip_iterator_sentinel_equal(_Get_iterator_tuple(_Lhs), _Rhs._End))) /* strengthened */ {
+                return _Zip_iterator_sentinel_equal(_Get_iterator_tuple(_Lhs), _Rhs._End);
+            }
+
+            template <bool _IteratorConst>
+                requires (sized_sentinel_for<sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>,
+                              iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>
+                          && ...)
+            _NODISCARD friend constexpr _Difference_type<_IteratorConst> operator-(
+                const _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs)
+                noexcept(noexcept(_Zip_get_smallest_distance<_Difference_type<_IteratorConst>>(
+                    _Get_iterator_tuple(_Lhs), _Rhs._End))) /* strengthened */ {
+                return _Zip_get_smallest_distance<_Difference_type<_IteratorConst>>(
+                    _Get_iterator_tuple(_Lhs), _Rhs._End);
+            }
+
+            template <bool _IteratorConst>
+                requires (sized_sentinel_for<sentinel_t<_Maybe_const<_IsConst, _ViewTypes>>,
+                              iterator_t<_Maybe_const<_IteratorConst, _ViewTypes>>>
+                          && ...)
+            _NODISCARD friend constexpr _Difference_type<_IteratorConst> operator-(const _Sentinel& _Lhs,
+                const _Iterator<_IteratorConst>& _Rhs) noexcept(noexcept(-(_Rhs - _Lhs))) /* strengthened */ {
+                return -(_Rhs - _Lhs);
+            }
+        };
+
+        template <bool _IsConst>
+        _NODISCARD static consteval bool _Is_end_noexcept() noexcept {
+            if constexpr (!_Zip_is_common<_Maybe_const<_IsConst, _ViewTypes>...>) {
+                return noexcept(_Sentinel<_IsConst>{
+                    _Tuple_transform(_RANGES end, _STD declval<_Maybe_const<_IsConst, tuple<_ViewTypes...>>&>())});
+            } else if constexpr ((random_access_range<_Maybe_const<_IsConst, _ViewTypes>> && ...)) {
+                // Operations on iter_difference_t values must be noexcept, so we only
+                // need to check the noexcept of begin().
+                return noexcept(_STD declval<_Maybe_const<_IsConst, zip_view>&>().begin());
+            } else {
+                return noexcept(_Iterator<_IsConst>{
+                    _Tuple_transform(_RANGES end, _STD declval<_Maybe_const<_IsConst, tuple<_ViewTypes...>>&>())});
+            }
+        }
+
+        static constexpr auto _Size_closure = [](auto... _Sizes) static noexcept {
+            using _Common_unsigned_type = _Make_unsigned_like_t<common_type_t<decltype(_Sizes)...>>;
+            return (_RANGES min) ({static_cast<_Common_unsigned_type>(_Sizes)...});
+        };
+
+    public:
+        zip_view() noexcept((is_nothrow_default_constructible_v<_ViewTypes> && ...)) = default;
+
+        constexpr explicit zip_view(_ViewTypes... _Args)
+            noexcept((is_nothrow_move_constructible_v<_ViewTypes> && ...)) // strengthened
+            : _Views(_STD move(_Args)...) {}
+
+        _NODISCARD constexpr auto begin()
+            noexcept(noexcept(_Iterator<false>{_Tuple_transform(_RANGES begin, _Views)})) // strengthened
+            requires (!(_Simple_view<_ViewTypes> && ...))
+        {
+            return _Iterator<false>{_Tuple_transform(_RANGES begin, _Views)};
+        }
+
+        _NODISCARD constexpr auto begin() const
+            noexcept(noexcept(_Iterator<true>{_Tuple_transform(_RANGES begin, _Views)})) // strengthened
+            requires (range<const _ViewTypes> && ...)
+        {
+            return _Iterator<true>{_Tuple_transform(_RANGES begin, _Views)};
+        }
+
+        _NODISCARD constexpr auto end() noexcept(_Is_end_noexcept<false>()) // strengthened
+            requires (!(_Simple_view<_ViewTypes> && ...))
+        {
+            if constexpr (!_Zip_is_common<_ViewTypes...>) {
+                return _Sentinel<false>{_Tuple_transform(_RANGES end, _Views)};
+            } else if constexpr ((random_access_range<_ViewTypes> && ...)) {
+                return begin() + static_cast<iter_difference_t<_Iterator<false>>>(size());
+            } else {
+                return _Iterator<false>{_Tuple_transform(_RANGES end, _Views)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const noexcept(_Is_end_noexcept<true>()) // strengthened
+            requires (range<const _ViewTypes> && ...)
+        {
+            if constexpr (!_Zip_is_common<const _ViewTypes...>) {
+                return _Sentinel<true>{_Tuple_transform(_RANGES end, _Views)};
+            } else if constexpr ((random_access_range<const _ViewTypes> && ...)) {
+                return begin() + static_cast<iter_difference_t<_Iterator<true>>>(size());
+            } else {
+                return _Iterator<true>{_Tuple_transform(_RANGES end, _Views)};
+            }
+        }
+
+        _NODISCARD constexpr auto size()
+            noexcept(noexcept(_STD apply(_Size_closure, _Tuple_transform(_RANGES size, _Views)))) // strengthened
+            requires (sized_range<_ViewTypes> && ...)
+        {
+            return _STD apply(_Size_closure, _Tuple_transform(_RANGES size, _Views));
+        }
+
+        _NODISCARD constexpr auto size() const
+            noexcept(noexcept(_STD apply(_Size_closure, _Tuple_transform(_RANGES size, _Views)))) // strengthened
+            requires (sized_range<const _ViewTypes> && ...)
+        {
+            return _STD apply(_Size_closure, _Tuple_transform(_RANGES size, _Views));
+        }
+    };
+
+    template <class... _RangeTypes>
+    zip_view(_RangeTypes&&...) -> zip_view<views::all_t<_RangeTypes>...>;
+
+    template <class... _ViewTypes>
+    constexpr bool enable_borrowed_range<zip_view<_ViewTypes...>> = (enable_borrowed_range<_ViewTypes> && ...);
+
+    template <class... _Rngs>
+    _NODISCARD consteval auto _Zip_view_compile_time_max_size() {
+        using _Size_type = common_type_t<decltype(_Compile_time_max_size<_Rngs>)...>;
+        return (_STD min) ({static_cast<_Size_type>(_Compile_time_max_size<_Rngs>)...});
+    }
+
+    template <class... _Rngs>
+    constexpr auto _Compile_time_max_size<zip_view<_Rngs...>> = _Zip_view_compile_time_max_size<_Rngs...>();
+
+    template <class... _Rngs>
+    constexpr auto _Compile_time_max_size<const zip_view<_Rngs...>> = _Zip_view_compile_time_max_size<const _Rngs...>();
+
+    namespace views {
+        class _Zip_fn {
+        private:
+            template <class... _Types>
+            _NODISCARD static consteval bool _Is_invocation_noexcept() {
+                if constexpr (sizeof...(_Types) == 0) {
+                    // NOTE: views::empty<tuple<>> is nothrow copy-constructible.
+                    return true;
+                } else {
+                    return noexcept(zip_view<views::all_t<_Types>...>(_STD declval<_Types>()...));
+                }
+            }
+
+        public:
+            template <class... _Types>
+            _NODISCARD static constexpr auto operator()(_Types&&... _Args)
+                noexcept(_Is_invocation_noexcept<_Types...>())
+                requires (sizeof...(_Types) == 0)
+                      || requires { zip_view<views::all_t<_Types>...>(_STD forward<_Types>(_Args)...); }
+            {
+                if constexpr (sizeof...(_Types) == 0) {
+                    return empty_view<tuple<>>{};
+                } else {
+                    return zip_view<views::all_t<_Types>...>(_STD forward<_Types>(_Args)...);
+                }
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Zip_fn zip{};
+    } // namespace views
+
+    template <class _Func, class... _ViewTypes>
+    concept _Can_const_iterate_zip_transform_view =
+        range<const zip_view<_ViewTypes...>> && regular_invocable<const _Func&, range_reference_t<const _ViewTypes>...>;
+
+    _EXPORT_STD template <class _Func, class... _ViewTypes>
+        requires _Zip_transform_constraints<_Func, _ViewTypes...>
+    class zip_transform_view : public view_interface<zip_transform_view<_Func, _ViewTypes...>> {
+    private:
+        using _Inner_view = zip_view<_ViewTypes...>;
+
+        /* [[no_unique_address]] */ _Movable_box<_Func> _Function;
+        /* [[no_unique_address]] */ _Inner_view _Zip;
+
+        template <bool _IsConst>
+        using _Ziperator = iterator_t<_Maybe_const<_IsConst, _Inner_view>>;
+
+        template <bool _IsConst>
+        using _Zentinel = sentinel_t<_Maybe_const<_IsConst, _Inner_view>>;
+
+        template <bool _IsConst>
+        struct _Category_base {};
+
+        template <bool _IsConst>
+            requires forward_range<_Maybe_const<_IsConst, _Inner_view>>
+        struct _Category_base<_IsConst> {
+        private:
+            template <class _Tag_type>
+            static constexpr bool _Iterators_derive_from_tag =
+                (derived_from<
+                     typename iterator_traits<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>>::iterator_category,
+                     _Tag_type>
+                    && ...);
+
+            using _Invoke_t = invoke_result_t<_Maybe_const<_IsConst, _Func>&,
+                range_reference_t<_Maybe_const<_IsConst, _ViewTypes>>...>;
+
+        public:
+            using iterator_category = conditional_t<!is_reference_v<_Invoke_t>, input_iterator_tag,
+                conditional_t<_Iterators_derive_from_tag<random_access_iterator_tag>, random_access_iterator_tag,
+                    conditional_t<_Iterators_derive_from_tag<bidirectional_iterator_tag>, bidirectional_iterator_tag,
+                        conditional_t<_Iterators_derive_from_tag<forward_iterator_tag>, forward_iterator_tag,
+                            input_iterator_tag>>>>;
+        };
+
+        template <bool _IsConst>
+        class _Iterator : public _Category_base<_IsConst> {
+        private:
+            friend zip_transform_view;
+
+            using _Parent_t = _Maybe_const<_IsConst, zip_transform_view>;
+            using _Base_t   = _Maybe_const<_IsConst, _Inner_view>;
+
+            _Parent_t* _Parent = nullptr;
+            /* [[no_unique_address]] */ _Ziperator<_IsConst> _Inner;
+
+            constexpr _Iterator(_Parent_t& _Parent_, _Ziperator<_IsConst> _Inner_)
+                noexcept(is_nothrow_move_constructible_v<_Ziperator<_IsConst>>) // strengthened
+                : _Parent(_STD addressof(_Parent_)), _Inner(_STD move(_Inner_)) {}
+
+        public:
+            using iterator_concept = _Ziperator<_IsConst>::iterator_concept;
+            using value_type       = remove_cvref_t<invoke_result_t<_Maybe_const<_IsConst, _Func>&,
+                range_reference_t<_Maybe_const<_IsConst, _ViewTypes>>...>>;
+            using difference_type  = range_difference_t<_Base_t>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_IsConst> _Rhs)
+                noexcept(is_nothrow_convertible_v<_Ziperator<false>, _Ziperator<_IsConst>>) // strengthened
+                requires (_IsConst && convertible_to<_Ziperator<false>, _Ziperator<_IsConst>>)
+                : _Parent(_Rhs._Parent), _Inner(_STD move(_Rhs._Inner)) {}
+
+            _NODISCARD constexpr decltype(auto) operator*() const
+                noexcept(noexcept(_STD apply(_Dereference_closure(), _Inner._Current))) {
+                return _STD apply(_Dereference_closure(), _Inner._Current);
+            }
+
+            constexpr _Iterator& operator++() noexcept(noexcept(++_Inner)) /* strengthened */ {
+                ++_Inner;
+                return *this;
+            }
+
+            constexpr void operator++(int) noexcept(noexcept(++_STD declval<_Iterator&>())) /* strengthened */ {
+                ++*this;
+            }
+
+            constexpr _Iterator operator++(int)
+                noexcept(is_nothrow_copy_constructible_v<_Iterator> && noexcept(++*this)) // strengthened
+                requires forward_range<_Base_t>
+            {
+                auto _Temp = *this;
+                ++*this;
+                return _Temp;
+            }
+
+            constexpr _Iterator& operator--() noexcept(noexcept(--_Inner)) // strengthened
+                requires bidirectional_range<_Base_t>
+            {
+                --_Inner;
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                noexcept(is_nothrow_copy_constructible_v<_Iterator> && noexcept(--*this)) // strengthened
+                requires bidirectional_range<_Base_t>
+            {
+                auto _Temp = *this;
+                --*this;
+                return _Temp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                noexcept(noexcept(_Inner += _Off)) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                _Inner += _Off;
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                noexcept(noexcept(_Inner -= _Off)) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                _Inner -= _Off;
+                return *this;
+            }
+
+            _NODISCARD constexpr decltype(auto) operator[](const difference_type _Where) const
+                noexcept(noexcept(_STD apply(_Subscript_closure(_Where), _Inner._Current))) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                return _STD apply(_Subscript_closure(_Where), _Inner._Current);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Lhs, const _Iterator& _Rhs)
+                noexcept(noexcept(_Lhs._Inner == _Rhs._Inner)) // strengthened
+                requires equality_comparable<_Ziperator<_IsConst>>
+            {
+                return _Lhs._Inner == _Rhs._Inner;
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Lhs, const _Iterator& _Rhs)
+                noexcept(noexcept(_Lhs._Inner <=> _Rhs._Inner)) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                return _Lhs._Inner <=> _Rhs._Inner;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _Lhs, const difference_type _Rhs)
+                noexcept(noexcept(_Iterator{*_Lhs._Parent, _Lhs._Inner + _Rhs})) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                return _Iterator{*_Lhs._Parent, _Lhs._Inner + _Rhs};
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Lhs, const _Iterator& _Rhs)
+                noexcept(noexcept(_Iterator{*_Rhs._Parent, _Rhs._Inner + _Lhs})) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                return _Iterator{*_Rhs._Parent, _Rhs._Inner + _Lhs};
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _Lhs, const difference_type _Rhs)
+                noexcept(noexcept(_Iterator{*_Lhs._Parent, _Lhs._Inner - _Rhs})) // strengthened
+                requires random_access_range<_Base_t>
+            {
+                return _Iterator{*_Lhs._Parent, _Lhs._Inner - _Rhs};
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Lhs,
+                const _Iterator& _Rhs) noexcept(noexcept(_Lhs._Inner - _Rhs._Inner)) // strengthened
+                requires sized_sentinel_for<_Ziperator<_IsConst>, _Ziperator<_IsConst>>
+            {
+                return _Lhs._Inner - _Rhs._Inner;
+            }
+
+        private:
+            _NODISCARD constexpr auto _Dereference_closure() const noexcept {
+                return [this](const auto&... _Itrs) noexcept(noexcept(_STD invoke(*_Parent->_Function,
+                           *_Itrs...))) -> decltype(auto) { return _STD invoke(*_Parent->_Function, *_Itrs...); };
+            }
+
+            _NODISCARD constexpr auto _Subscript_closure(const difference_type _Where) const noexcept {
+                return [this, _Where]<class... _Iterator_types>(const _Iterator_types&... _Iters) noexcept(
+                           noexcept(_STD invoke(*_Parent->_Function,
+                               _Iters[static_cast<iter_difference_t<_Iterator_types>>(_Where)]...))) -> decltype(auto) {
+                    return _STD invoke(
+                        *_Parent->_Function, _Iters[static_cast<iter_difference_t<_Iterator_types>>(_Where)]...);
+                };
+            }
+        };
+
+        template <bool _IsConst>
+        class _Sentinel {
+        private:
+            friend zip_transform_view;
+
+            /* [[no_unique_address]] */ _Zentinel<_IsConst> _Inner;
+
+            constexpr explicit _Sentinel(_Zentinel<_IsConst> _Inner_)
+                noexcept(is_nothrow_copy_constructible_v<_Zentinel<_IsConst>>) // strengthened
+                : _Inner(_Inner_) {}
+
+            template <bool _IteratorConst>
+            _NODISCARD static constexpr const auto& _Get_iterator_inner(
+                const _Iterator<_IteratorConst>& _Itr) noexcept {
+                return _Itr._Inner;
+            }
+
+        public:
+            _Sentinel() = default;
+
+            constexpr _Sentinel(_Sentinel<!_IsConst> _Rhs)
+                noexcept(is_nothrow_convertible_v<_Zentinel<false>, _Zentinel<_IsConst>>) // strengthened
+                requires (_IsConst && convertible_to<_Zentinel<false>, _Zentinel<_IsConst>>)
+                : _Inner(_STD move(_Rhs._Inner)) {}
+
+            template <bool _IteratorConst>
+                requires sentinel_for<_Zentinel<_IsConst>, _Ziperator<_IteratorConst>>
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs)
+                noexcept(noexcept(_Get_iterator_inner(_Lhs) == _Rhs._Inner)) /* strengthened */ {
+                return _Get_iterator_inner(_Lhs) == _Rhs._Inner;
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _IteratorConst>
+                requires sized_sentinel_for<_Zentinel<_IsConst>, _Ziperator<_IteratorConst>>
+            _NODISCARD friend constexpr typename _Iterator<_IteratorConst>::difference_type operator-(
+                const _Iterator<_IteratorConst>& _Lhs, const _Sentinel& _Rhs)
+                noexcept(noexcept(_Get_iterator_inner(_Lhs) - _Rhs._Inner)) /* strengthened */ {
+                return _Get_iterator_inner(_Lhs) - _Rhs._Inner;
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _IteratorConst>
+                requires sized_sentinel_for<_Zentinel<_IsConst>, _Ziperator<_IteratorConst>>
+            _NODISCARD friend constexpr typename _Iterator<_IteratorConst>::difference_type operator-(
+                const _Sentinel& _Lhs, const _Iterator<_IteratorConst>& _Rhs)
+                noexcept(noexcept(_Lhs._Inner - _Get_iterator_inner(_Rhs))) /* strengthened */ {
+                return _Lhs._Inner - _Get_iterator_inner(_Rhs);
+            }
+        };
+
+        template <bool _IsConst>
+        _NODISCARD static consteval bool _Is_end_noexcept() noexcept {
+            if constexpr (common_range<_Maybe_const<_IsConst, _Inner_view>>) {
+                return noexcept(_Iterator<_IsConst>{_STD declval<_Maybe_const<_IsConst, zip_transform_view>&>(),
+                    _STD declval<_Maybe_const<_IsConst, _Inner_view>&>().end()});
+            } else {
+                return noexcept(_Sentinel<_IsConst>{_STD declval<_Maybe_const<_IsConst, _Inner_view>&>().end()});
+            }
+        }
+
+    public:
+        zip_transform_view() = default;
+
+        constexpr explicit zip_transform_view(_Func _Function_, _ViewTypes... _Views)
+            noexcept(is_nothrow_move_constructible_v<_Func>
+                     && is_nothrow_constructible_v<_Inner_view, remove_reference_t<_ViewTypes>&&...>) // strengthened
+            : _Function(in_place, _STD move(_Function_)), _Zip(_STD move(_Views)...) {}
+
+        _NODISCARD constexpr auto begin() noexcept(noexcept(_Iterator<false>{*this, _Zip.begin()})) /* strengthened */ {
+            return _Iterator<false>{*this, _Zip.begin()};
+        }
+
+        _NODISCARD constexpr auto begin() const noexcept(noexcept(_Iterator<true>{*this, _Zip.begin()})) // strengthened
+            requires _Can_const_iterate_zip_transform_view<_Func, _ViewTypes...>
+        {
+            return _Iterator<true>{*this, _Zip.begin()};
+        }
+
+        _NODISCARD constexpr auto end() noexcept(_Is_end_noexcept<false>()) /* strengthened */ {
+            if constexpr (common_range<_Inner_view>) {
+                return _Iterator<false>{*this, _Zip.end()};
+            } else {
+                return _Sentinel<false>{_Zip.end()};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const noexcept(_Is_end_noexcept<true>()) // strengthened
+            requires _Can_const_iterate_zip_transform_view<_Func, _ViewTypes...>
+        {
+            if constexpr (common_range<const _Inner_view>) {
+                return _Iterator<true>{*this, _Zip.end()};
+            } else {
+                return _Sentinel<true>{_Zip.end()};
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_Zip.size())) // strengthened
+            requires sized_range<_Inner_view>
+        {
+            return _Zip.size();
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_Zip.size())) // strengthened
+            requires sized_range<const _Inner_view>
+        {
+            return _Zip.size();
+        }
+    };
+
+    template <class _Func, class... _Ranges>
+    zip_transform_view(_Func, _Ranges&&...) -> zip_transform_view<_Func, views::all_t<_Ranges>...>;
+
+    template <class _Fn, class... _Rngs>
+    constexpr auto _Compile_time_max_size<zip_transform_view<_Fn, _Rngs...>> =
+        _Compile_time_max_size<zip_view<_Rngs...>>;
+
+    template <class _Fn, class... _Rngs>
+    constexpr auto _Compile_time_max_size<const zip_transform_view<_Fn, _Rngs...>> =
+        _Compile_time_max_size<const zip_view<_Rngs...>>;
+
+    namespace views {
+        class _Zip_transform_fn {
+        private:
+            template <class _Func, class... _Types>
+            _NODISCARD static consteval bool _Is_invocation_noexcept() {
+                if constexpr (sizeof...(_Types) == 0) {
+                    return true;
+                } else {
+                    return noexcept(zip_transform_view(_STD declval<_Func>(), _STD declval<_Types>()...));
+                }
+            }
+
+            template <class _Func, class... _Types>
+            _NODISCARD static consteval bool _Enable_cpo() {
+                if constexpr (sizeof...(_Types) == 0) {
+                    // This is a more efficient implementation of the CPO requirements listed in
+                    // N4950 [range.zip.transform.overview]/2.1.1.
+                    using _Decayed_func = decay_t<_Func>;
+                    if constexpr (move_constructible<_Decayed_func> && regular_invocable<_Decayed_func&>) {
+                        return !is_void_v<invoke_result_t<_Decayed_func&>>;
+                    } else {
+                        return false;
+                    }
+                } else {
+                    return requires(_Func&& _Function, _Types&&... _Args) {
+                        zip_transform_view(_STD forward<_Func>(_Function), _STD forward<_Types>(_Args)...);
+                    };
+                }
+            }
+
+        public:
+            template <class _Func, class... _Types>
+                requires (_Enable_cpo<_Func, _Types...>())
+            _NODISCARD static constexpr auto operator()(_Func&& _Function, _Types&&... _Args)
+                noexcept(_Is_invocation_noexcept<_Func, _Types...>()) /* strengthened */ {
+                if constexpr (sizeof...(_Types) == 0) {
+                    using _Decayed_func = decay_t<_Func>;
+                    return empty_view<decay_t<invoke_result_t<_Decayed_func&>>>{};
+                } else {
+                    return zip_transform_view(_STD forward<_Func>(_Function), _STD forward<_Types>(_Args)...);
+                }
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Zip_transform_fn zip_transform{};
+    } // namespace views
+
+    template <class _Ty, size_t>
+    using _Repeat_type = _Ty;
+
+    template <class _Ty, class _Indices>
+    struct _Repeated_tuple_impl;
+
+    template <class _Ty, size_t... _Indices>
+    struct _Repeated_tuple_impl<_Ty, index_sequence<_Indices...>> {
+        using type = tuple<_Repeat_type<_Ty, _Indices>...>;
+    };
+
+    template <class _Ty, size_t _Nx>
+    using _Repeated_tuple = _Repeated_tuple_impl<_Ty, make_index_sequence<_Nx>>::type;
+
+    template <class _Fn, class _Ty, class _Indices>
+    constexpr bool _Regular_invocable_with_repeated_type_impl = false;
+
+    template <class _Fn, class _Ty, size_t... _Indices>
+    constexpr bool _Regular_invocable_with_repeated_type_impl<_Fn, _Ty, index_sequence<_Indices...>> =
+        regular_invocable<_Fn, _Repeat_type<_Ty, _Indices>...>;
+
+    template <class _Fn, class _Ty, size_t _Nx>
+    concept _Regular_invocable_with_repeated_type =
+        _Regular_invocable_with_repeated_type_impl<_Fn, _Ty, make_index_sequence<_Nx>>;
+
+    template <class _Fn, class _Ty, class _Indices>
+    struct _Invoke_result_with_repeated_type_impl;
+
+    template <class _Fn, class _Ty, size_t... _Indices>
+    struct _Invoke_result_with_repeated_type_impl<_Fn, _Ty, index_sequence<_Indices...>> {
+        using type = invoke_result_t<_Fn, _Repeat_type<_Ty, _Indices>...>;
+    };
+
+    template <class _Fn, class _Ty, size_t _Nx>
+    using _Invoke_result_with_repeated_type =
+        _Invoke_result_with_repeated_type_impl<_Fn, _Ty, make_index_sequence<_Nx>>::type;
+
+    template <class _Vw, class _Fn, size_t _Nx>
+    concept _Adjacent_transform_constraints =
+        (_Nx > 0) && forward_range<_Vw> && view<_Vw> && is_object_v<_Fn> && move_constructible<_Fn>
+        && _Regular_invocable_with_repeated_type<_Fn&, range_reference_t<_Vw>, _Nx>
+        && _Can_reference<_Invoke_result_with_repeated_type<_Fn&, range_reference_t<_Vw>, _Nx>>;
+
+    _EXPORT_STD template <class _Vw, class _Fn, size_t _Nx>
+        requires _Adjacent_transform_constraints<_Vw, _Fn, _Nx>
+    class adjacent_transform_view;
+
+    _EXPORT_STD template <forward_range _Vw, size_t _Nx>
+        requires view<_Vw> && (_Nx > 0)
+    class adjacent_view : public view_interface<adjacent_view<_Vw, _Nx>> {
+    private:
+        /* [[no_unique_address]] */ _Vw _Range{};
+
+        struct _As_sentinel {
+            explicit _As_sentinel() = default;
+        };
+
+        template <bool _Const>
+        class _Iterator {
+        private:
+            friend adjacent_view;
+
+            template <class _Vw2, class _Fn, size_t _Nx2>
+                requires _Adjacent_transform_constraints<_Vw2, _Fn, _Nx2>
+            friend class adjacent_transform_view;
+
+            using _Base          = _Maybe_const<_Const, _Vw>;
+            using _Base_iterator = iterator_t<_Base>;
+
+            array<_Base_iterator, _Nx> _Current{};
+
+            constexpr _Iterator(_Base_iterator _First, sentinel_t<_Base> _Last) {
+                _Current.front() = _First;
+                for (size_t _Ix = 1; _Ix < _Nx; ++_Ix) {
+                    _RANGES advance(_First, 1, _Last);
+                    _Current[_Ix] = _First;
+                }
+            }
+
+            constexpr _Iterator(_As_sentinel, _Base_iterator _First, _Base_iterator _Last) {
+                if constexpr (!bidirectional_range<_Base>) {
+                    _Current.fill(_Last);
+                } else {
+                    _Current.back() = _Last;
+                    for (size_t _Ix = 1; _Ix < _Nx; ++_Ix) {
+                        _RANGES advance(_Last, -1, _First);
+                        _Current[_Nx - 1 - _Ix] = _Last;
+                    }
+                }
+            }
+
+            template <size_t... _Indices>
+            constexpr _Iterator(_Iterator<!_Const>& _Other, index_sequence<_Indices...>)
+                noexcept(is_nothrow_convertible_v<iterator_t<_Vw>, _Base_iterator>)
+                requires _Const && convertible_to<iterator_t<_Vw>, _Base_iterator>
+                : _Current{_STD move(_Other._Current[_Indices])...} {}
+
+        public:
+            using iterator_category = input_iterator_tag;
+            using iterator_concept  = conditional_t<random_access_range<_Base>, random_access_iterator_tag,
+                conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag, forward_iterator_tag>>;
+            using value_type        = _Repeated_tuple<range_value_t<_Base>, _Nx>;
+            using difference_type   = range_difference_t<_Base>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _Other)
+                noexcept(is_nothrow_convertible_v<iterator_t<_Vw>, _Base_iterator>) // strengthened
+                requires _Const && convertible_to<iterator_t<_Vw>, _Base_iterator>
+                : _Iterator(_Other, make_index_sequence<_Nx>{}) {}
+
+            _NODISCARD constexpr auto operator*() const {
+                return _RANGES _Tuple_transform([](auto& _It) static -> decltype(auto) { return *_It; }, _Current);
+            }
+
+            constexpr _Iterator& operator++() noexcept(noexcept(++_Current.front())) /* strengthened */ {
+                for (_Base_iterator& _It : _Current) {
+                    ++_It;
+                }
+                return *this;
+            }
+
+            constexpr _Iterator operator++(int)
+                noexcept(noexcept(++*this) && is_nothrow_copy_constructible_v<_Iterator>) /* strengthened */ {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--() noexcept(noexcept(--_Current.back())) // strengthened
+                requires bidirectional_range<_Base>
+            {
+                for (_Base_iterator& _It : _Current) {
+                    --_It;
+                }
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                noexcept(noexcept(--*this) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires bidirectional_range<_Base>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                noexcept(noexcept(_Current.back() += _Off)) // strengthened
+                requires random_access_range<_Base>
+            {
+                for (_Base_iterator& _It : _Current) {
+                    _It += _Off;
+                }
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                noexcept(noexcept(_Current.back() -= _Off)) // strengthened
+                requires random_access_range<_Base>
+            {
+                for (_Base_iterator& _It : _Current) {
+                    _It -= _Off;
+                }
+                return *this;
+            }
+
+            _NODISCARD constexpr auto operator[](const difference_type _Off) const
+                requires random_access_range<_Base>
+            {
+                return _RANGES _Tuple_transform([&](auto& _It) -> decltype(auto) { return _It[_Off]; }, _Current);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right) noexcept(
+                noexcept(_STD _Fake_copy_init<bool>(_Left._Current.back() == _Right._Current.back()))) // strengthened
+            {
+                return _Left._Current.back() == _Right._Current.back();
+            }
+
+            _NODISCARD friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right) noexcept(
+                noexcept(_STD _Fake_copy_init<bool>(_Left._Current.back() < _Right._Current.back()))) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Left._Current.back() < _Right._Current.back();
+            }
+
+            _NODISCARD friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Right < _Left)) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Right < _Left;
+            }
+
+            _NODISCARD friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(!(_Right < _Left))) // strengthened
+                requires random_access_range<_Base>
+            {
+                return !(_Right < _Left);
+            }
+
+            _NODISCARD friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(!(_Left < _Right))) // strengthened
+                requires random_access_range<_Base>
+            {
+                return !(_Left < _Right);
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current.back() <=> _Right._Current.back())) // strengthened
+                requires random_access_range<_Base> && three_way_comparable<_Base_iterator>
+            {
+                return _Left._Current.back() <=> _Right._Current.back();
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off)
+                noexcept(noexcept(_STD declval<_Iterator&>() += _Off)
+                         && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires random_access_range<_Base>
+            {
+                auto _Tmp = _It;
+                _Tmp += _Off;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It)
+                noexcept(noexcept(_STD declval<_Iterator&>() += _Off)
+                         && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires random_access_range<_Base>
+            {
+                auto _Tmp = _It;
+                _Tmp += _Off;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off)
+                noexcept(noexcept(_STD declval<_Iterator&>() -= _Off)
+                         && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires random_access_range<_Base>
+            {
+                auto _Tmp = _It;
+                _Tmp -= _Off;
+                return _Tmp;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Current.back() - _Right._Current.back())) // strengthened
+                requires sized_sentinel_for<_Base_iterator, _Base_iterator>
+            {
+                return _Left._Current.back() - _Right._Current.back();
+            }
+
+            _NODISCARD friend constexpr auto iter_move(const _Iterator& _It)
+                noexcept(noexcept(_RANGES iter_move(_STD declval<const _Base_iterator&>()))
+                         && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>) {
+                return _RANGES _Tuple_transform(_RANGES iter_move, _It._Current);
+            }
+
+            friend constexpr void iter_swap(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_RANGES iter_swap(_STD declval<_Base_iterator>(), _STD declval<_Base_iterator>())))
+                requires indirectly_swappable<_Base_iterator>
+            {
+                for (size_t _Ix = 0; _Ix < _Nx; ++_Ix) {
+                    _RANGES iter_swap(_Left._Current[_Ix], _Right._Current[_Ix]);
+                }
+            }
+        };
+
+        template <bool _Const>
+        class _Sentinel {
+        private:
+            friend adjacent_view;
+
+            using _Base          = _Maybe_const<_Const, _Vw>;
+            using _Base_sentinel = sentinel_t<_Base>;
+
+            /* [[no_unique_address]] */ _Base_sentinel _End{};
+
+            constexpr explicit _Sentinel(_Base_sentinel _Last_)
+                noexcept(is_nothrow_move_constructible_v<_Base_sentinel>) // strengthened
+                : _End(_STD move(_Last_)) {}
+
+            template <bool _OtherConst>
+                requires sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD constexpr bool _Equal(const _Iterator<_OtherConst>& _It) const
+                noexcept(noexcept(_STD _Fake_copy_init<bool>(_It._Current.back() == _End))) {
+                return _It._Current.back() == _End;
+            }
+
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD constexpr _Iterator<_OtherConst>::difference_type _Distance_from(
+                const _Iterator<_OtherConst>& _It) const noexcept(noexcept(_End - _It._Current.back())) {
+                return _End - _It._Current.back();
+            }
+
+        public:
+            _Sentinel() = default;
+
+            constexpr _Sentinel(_Sentinel<!_Const> _Other)
+                noexcept(is_nothrow_convertible_v<sentinel_t<_Vw>, _Base_sentinel>) // strengthened
+                requires _Const && convertible_to<sentinel_t<_Vw>, _Base_sentinel>
+                : _End(_STD move(_Other._End)) {}
+
+            template <bool _OtherConst>
+                requires sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_OtherConst>& _It, const _Sentinel& _Se)
+                noexcept(noexcept(_Se._Equal(_It))) /* strengthened */ {
+                return _Se._Equal(_It);
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD friend constexpr typename _Iterator<_OtherConst>::difference_type operator-(
+                const _Iterator<_OtherConst>& _It, const _Sentinel& _Se)
+                noexcept(noexcept(_Se._Distance_from(_It))) /* strengthened */ {
+                return -_Se._Distance_from(_It);
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Base_sentinel, iterator_t<_Maybe_const<_OtherConst, _Vw>>>
+            _NODISCARD friend constexpr typename _Iterator<_OtherConst>::difference_type operator-(const _Sentinel& _Se,
+                const _Iterator<_OtherConst>& _It) noexcept(noexcept(_Se._Distance_from(_It))) /* strengthened */ {
+                return _Se._Distance_from(_It);
+            }
+        };
+
+    public:
+        adjacent_view()
+            requires default_initializable<_Vw>
+        = default;
+
+        constexpr explicit adjacent_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) // strengthened
+            : _Range(_STD move(_Range_)) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) // strengthened
+            requires copy_constructible<_Vw>
+        {
+            return _Range;
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>) /* strengthened */ {
+            return _STD move(_Range);
+        }
+
+        _NODISCARD constexpr auto begin()
+            requires (!_Simple_view<_Vw>)
+        {
+            return _Iterator<false>{_RANGES begin(_Range), _RANGES end(_Range)};
+        }
+
+        _NODISCARD constexpr auto begin() const
+            requires range<const _Vw>
+        {
+            return _Iterator<true>{_RANGES begin(_Range), _RANGES end(_Range)};
+        }
+
+        _NODISCARD constexpr auto end()
+            requires (!_Simple_view<_Vw>)
+        {
+            if constexpr (common_range<_Vw>) {
+                return _Iterator<false>{_As_sentinel{}, _RANGES begin(_Range), _RANGES end(_Range)};
+            } else {
+                return _Sentinel<false>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            requires range<const _Vw>
+        {
+            if constexpr (common_range<const _Vw>) {
+                return _Iterator<true>{_As_sentinel{}, _RANGES begin(_Range), _RANGES end(_Range)};
+            } else {
+                return _Sentinel<true>{_RANGES end(_Range)};
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_RANGES size(_Range))) // strengthened
+            requires sized_range<_Vw>
+        {
+            using _Size_type        = decltype(_RANGES size(_Range));
+            using _Common_size_type = common_type_t<_Size_type, size_t>;
+            auto _Size              = static_cast<_Common_size_type>(_RANGES size(_Range));
+            _Size -= (_STD min) (_Size, static_cast<_Common_size_type>(_Nx - 1));
+            return static_cast<_Size_type>(_Size);
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_RANGES size(_Range))) // strengthened
+            requires sized_range<const _Vw>
+        {
+            using _Size_type        = decltype(_RANGES size(_Range));
+            using _Common_size_type = common_type_t<_Size_type, size_t>;
+            auto _Size              = static_cast<_Common_size_type>(_RANGES size(_Range));
+            _Size -= (_STD min) (_Size, static_cast<_Common_size_type>(_Nx - 1));
+            return static_cast<_Size_type>(_Size);
+        }
+    };
+
+    template <class _Rng, size_t _Nx>
+    constexpr bool enable_borrowed_range<adjacent_view<_Rng, _Nx>> = enable_borrowed_range<_Rng>;
+
+    template <class _Rng, size_t _Nx>
+    _NODISCARD consteval auto _Adjacent_view_compile_time_max_size() {
+        using _Size_type = common_type_t<decltype(_Compile_time_max_size<_Rng>), size_t>;
+        auto _Size       = static_cast<_Size_type>(_Compile_time_max_size<_Rng>);
+        _Size -= (_STD min) (_Size, static_cast<_Size_type>(_Nx - 1));
+        return static_cast<_Size_type>(_Size);
+    }
+
+    template <class _Rng, size_t _Nx>
+    constexpr auto _Compile_time_max_size<adjacent_view<_Rng, _Nx>> = _Adjacent_view_compile_time_max_size<_Rng, _Nx>();
+
+    template <class _Rng, size_t _Nx>
+    constexpr auto _Compile_time_max_size<const adjacent_view<_Rng, _Nx>> =
+        _Adjacent_view_compile_time_max_size<const _Rng, _Nx>();
+
+    namespace views {
+        template <size_t _Nx>
+        struct _Adjacent_fn : public _Pipe::_Base<_Adjacent_fn<_Nx>> {
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range)
+                noexcept(noexcept(adjacent_view<views::all_t<_Rng>, _Nx>{_STD forward<_Rng>(_Range)}))
+                requires requires { adjacent_view<views::all_t<_Rng>, _Nx>{_STD forward<_Rng>(_Range)}; }
+            {
+                return adjacent_view<views::all_t<_Rng>, _Nx>{_STD forward<_Rng>(_Range)};
+            }
+
+            template <viewable_range _Rng>
+            _NODISCARD static constexpr auto operator()(_Rng&&) noexcept
+                requires (_Nx == 0) && forward_range<_Rng>
+            {
+                return empty_view<tuple<>>{};
+            }
+        };
+
+        _EXPORT_STD template <size_t _Nx>
+        constexpr _Adjacent_fn<_Nx> adjacent;
+        _EXPORT_STD inline constexpr _Adjacent_fn<2> pairwise;
+    } // namespace views
+
+    _EXPORT_STD template <class _Vw, class _Fn, size_t _Nx>
+        requires _Adjacent_transform_constraints<_Vw, _Fn, _Nx>
+    class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vw, _Fn, _Nx>> {
+    private:
+        using _Inner_view = adjacent_view<_Vw, _Nx>;
+        template <bool _Const>
+        using _Inner_iterator = iterator_t<_Maybe_const<_Const, _Inner_view>>;
+        template <bool _Const>
+        using _Inner_sentinel = sentinel_t<_Maybe_const<_Const, _Inner_view>>;
+
+        /* [[no_unique_address]] */ _Movable_box<_Fn> _Func;
+        /* [[no_unique_address]] */ _Inner_view _Inner;
+
+        template <bool _Const>
+        class _Iterator {
+        private:
+            friend adjacent_transform_view;
+
+            using _Parent_t = _Maybe_const<_Const, adjacent_transform_view>;
+            using _Base     = _Maybe_const<_Const, _Vw>;
+
+            _Parent_t* _Parent = nullptr;
+            _Inner_iterator<_Const> _Inner;
+
+            constexpr _Iterator(_Parent_t& _Parent_, _Inner_iterator<_Const> _Inner_)
+                noexcept(is_nothrow_move_constructible_v<_Inner_iterator<_Const>>) // strengthened
+                : _Parent(_STD addressof(_Parent_)), _Inner(_STD move(_Inner_)) {}
+
+            _NODISCARD static consteval auto _Get_iterator_category() noexcept {
+                if constexpr (!is_reference_v<_Invoke_result_with_repeated_type<_Maybe_const<_Const, _Fn>&,
+                                  range_reference_t<_Base>, _Nx>>) {
+                    return input_iterator_tag{};
+                } else {
+                    using _Cat = iterator_traits<iterator_t<_Base>>::iterator_category;
+
+                    if constexpr (derived_from<_Cat, random_access_iterator_tag>) {
+                        return random_access_iterator_tag{};
+                    } else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>) {
+                        return bidirectional_iterator_tag{};
+                    } else if constexpr (derived_from<_Cat, forward_iterator_tag>) {
+                        return forward_iterator_tag{};
+                    } else {
+                        return input_iterator_tag{};
+                    }
+                }
+            }
+
+            template <size_t... _Indices>
+            _NODISCARD static consteval bool _Is_indirection_nothrow(index_sequence<_Indices...>) noexcept {
+                return noexcept(_STD invoke(_STD declval<_Maybe_const<_Const, _Fn>&>(),
+                    *_STD get<_Indices>(_STD declval<const _Inner_iterator<_Const>&>()._Current)...));
+            }
+
+        public:
+            using iterator_category = decltype(_Get_iterator_category());
+            using iterator_concept  = _Inner_iterator<_Const>::iterator_concept;
+            using value_type        = remove_cvref_t<
+                _Invoke_result_with_repeated_type<_Maybe_const<_Const, _Fn>&, range_reference_t<_Base>, _Nx>>;
+            using difference_type = range_difference_t<_Base>;
+
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _Other)
+                requires _Const && convertible_to<_Inner_iterator<false>, _Inner_iterator<_Const>>
+                : _Parent(_Other._Parent), _Inner(_STD move(_Other._Inner)) {}
+
+            _NODISCARD constexpr decltype(auto) operator*() const
+                noexcept(_Is_indirection_nothrow(make_index_sequence<_Nx>{})) {
+                return _STD apply(
+                    [&](const auto&... _Iters) -> decltype(auto) { return _STD invoke(*_Parent->_Func, *_Iters...); },
+                    _Inner._Current);
+            }
+
+            constexpr _Iterator& operator++() noexcept(noexcept(++_Inner)) /* strengthened */ {
+                ++_Inner;
+                return *this;
+            }
+
+            constexpr _Iterator operator++(int)
+                noexcept(noexcept(++*this) && is_nothrow_copy_constructible_v<_Iterator>) /* strengthened */ {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--() noexcept(noexcept(--_Inner)) /* strengthened */
+                requires bidirectional_range<_Base>
+            {
+                --_Inner;
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                noexcept(noexcept(--*this) && is_nothrow_copy_constructible_v<_Iterator>) // strengthened
+                requires bidirectional_range<_Base>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                noexcept(noexcept(_Inner += _Off)) // strengthened
+                requires random_access_range<_Base>
+            {
+                _Inner += _Off;
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                noexcept(noexcept(_Inner -= _Off)) // strengthened
+                requires random_access_range<_Base>
+            {
+                _Inner -= _Off;
+                return *this;
+            }
+
+            _NODISCARD constexpr decltype(auto) operator[](const difference_type _Off) const
+                requires random_access_range<_Base>
+            {
+                return _STD apply(
+                    [&](const auto&... _Iters) -> decltype(auto) {
+                        return _STD invoke(*_Parent->_Func, _Iters[_Off]...);
+                    },
+                    _Inner._Current);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Inner == _Right._Inner)) /* strengthened */ {
+                return _Left._Inner == _Right._Inner;
+            }
+
+            _NODISCARD friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Inner < _Right._Inner)) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Left._Inner < _Right._Inner;
+            }
+
+            _NODISCARD friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Inner > _Right._Inner)) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Left._Inner > _Right._Inner;
+            }
+
+            _NODISCARD friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Inner <= _Right._Inner)) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Left._Inner <= _Right._Inner;
+            }
+
+            _NODISCARD friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Inner >= _Right._Inner)) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Left._Inner >= _Right._Inner;
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Inner <=> _Right._Inner)) // strengthened
+                requires random_access_range<_Base> && three_way_comparable<_Inner_iterator<_Const>>
+            {
+                return _Left._Inner <=> _Right._Inner;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off) noexcept(
+                noexcept(_It._Inner + _Off) && is_nothrow_move_constructible_v<_Inner_iterator<_Const>>) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Iterator{*_It._Parent, _It._Inner + _Off};
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It) noexcept(
+                noexcept(_It._Inner + _Off) && is_nothrow_move_constructible_v<_Inner_iterator<_Const>>) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Iterator{*_It._Parent, _It._Inner + _Off};
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off) noexcept(
+                noexcept(_It._Inner - _Off) && is_nothrow_move_constructible_v<_Inner_iterator<_Const>>) // strengthened
+                requires random_access_range<_Base>
+            {
+                return _Iterator{*_It._Parent, _It._Inner - _Off};
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(noexcept(_Left._Inner - _Right._Inner)) // strengthened
+                requires sized_sentinel_for<_Inner_iterator<_Const>, _Inner_iterator<_Const>>
+            {
+                return _Left._Inner - _Right._Inner;
+            }
+        };
+
+        template <bool _Const>
+        class _Sentinel {
+        private:
+            friend adjacent_transform_view;
+
+            /* [[no_unique_address]] */ _Inner_sentinel<_Const> _Inner;
+
+            constexpr explicit _Sentinel(_Inner_sentinel<_Const> _Inner_) : _Inner(_Inner_) {}
+
+            template <bool _OtherConst>
+                requires sentinel_for<_Inner_sentinel<_Const>, _Inner_iterator<_OtherConst>>
+            _NODISCARD constexpr bool _Equal(const _Iterator<_OtherConst>& _It) const
+                noexcept(noexcept(_It._Inner == _Inner)) {
+                return _It._Inner == _Inner;
+            }
+
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Inner_sentinel<_Const>, _Inner_iterator<_OtherConst>>
+            _NODISCARD constexpr _Iterator<_OtherConst>::difference_type _Distance_from(
+                const _Iterator<_OtherConst>& _It) const noexcept(noexcept(_Inner - _It._Inner)) {
+                return _Inner - _It._Inner;
+            }
+
+        public:
+            _Sentinel() = default;
+
+            constexpr _Sentinel(_Sentinel<!_Const> _Other)
+                requires _Const && convertible_to<_Inner_sentinel<false>, _Inner_sentinel<_Const>>
+                : _Inner(_STD move(_Other._Inner)) {}
+
+            template <bool _OtherConst>
+                requires sentinel_for<_Inner_sentinel<_Const>, _Inner_iterator<_OtherConst>>
+            _NODISCARD friend constexpr bool operator==(const _Iterator<_OtherConst>& _It, const _Sentinel& _Se)
+                noexcept(noexcept(_Se._Equal(_It))) /* strengthened */ {
+                return _Se._Equal(_It);
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Inner_sentinel<_Const>, _Inner_iterator<_OtherConst>>
+            _NODISCARD friend constexpr typename _Iterator<_OtherConst>::difference_type operator-(
+                const _Iterator<_OtherConst>& _It, const _Sentinel& _Se)
+                noexcept(noexcept(_Se._Distance_from(_It))) /* strengthened */ {
+                return -_Se._Distance_from(_It);
+            }
+
+            // typename is a workaround for VSO-2680018 (EDG)
+            template <bool _OtherConst>
+                requires sized_sentinel_for<_Inner_sentinel<_Const>, _Inner_iterator<_OtherConst>>
+            _NODISCARD friend constexpr typename _Iterator<_OtherConst>::difference_type operator-(const _Sentinel& _Se,
+                const _Iterator<_OtherConst>& _It) noexcept(noexcept(_Se._Distance_from(_It))) /* strengthened */ {
+                return _Se._Distance_from(_It);
+            }
+        };
+
+    public:
+        adjacent_transform_view() = default;
+
+        constexpr explicit adjacent_transform_view(_Vw _Range_, _Fn _Func_)
+            noexcept(is_nothrow_move_constructible_v<_Vw> && is_nothrow_move_constructible_v<_Fn>) // strengthened
+            : _Func(in_place, _STD move(_Func_)), _Inner(_STD move(_Range_)) {}
+
+        _NODISCARD constexpr _Vw base() const& noexcept(noexcept(_Inner.base())) // strengthened
+            requires copy_constructible<_Vw>
+        {
+            return _Inner.base();
+        }
+
+        _NODISCARD constexpr _Vw base() && noexcept(noexcept(_STD move(_Inner).base())) /* strengthened */ {
+            return _STD move(_Inner).base();
+        }
+
+        _NODISCARD constexpr auto begin() {
+            return _Iterator<false>{*this, _Inner.begin()};
+        }
+
+        _NODISCARD constexpr auto begin() const
+            requires range<const _Inner_view>
+                  && _Regular_invocable_with_repeated_type<const _Fn&, range_reference_t<const _Vw>, _Nx>
+        {
+            return _Iterator<true>{*this, _Inner.begin()};
+        }
+
+        _NODISCARD constexpr auto end() {
+            if constexpr (common_range<_Inner_view>) {
+                return _Iterator<false>{*this, _Inner.end()};
+            } else {
+                return _Sentinel<false>{_Inner.end()};
+            }
+        }
+
+        _NODISCARD constexpr auto end() const
+            requires range<const _Inner_view>
+                  && _Regular_invocable_with_repeated_type<const _Fn&, range_reference_t<const _Vw>, _Nx>
+        {
+            if constexpr (common_range<const _Inner_view>) {
+                return _Iterator<true>{*this, _Inner.end()};
+            } else {
+                return _Sentinel<true>{_Inner.end()};
+            }
+        }
+
+        _NODISCARD constexpr auto size() noexcept(noexcept(_Inner.size())) // strengthened
+            requires sized_range<_Inner_view>
+        {
+            return _Inner.size();
+        }
+
+        _NODISCARD constexpr auto size() const noexcept(noexcept(_Inner.size())) // strengthened
+            requires sized_range<const _Inner_view>
+        {
+            return _Inner.size();
+        }
+    };
+
+    template <class _Rng, class _Fn, size_t _Nx>
+    constexpr auto _Compile_time_max_size<adjacent_transform_view<_Rng, _Fn, _Nx>> =
+        _Compile_time_max_size<adjacent_view<_Rng, _Nx>>;
+
+    template <class _Rng, class _Fn, size_t _Nx>
+    constexpr auto _Compile_time_max_size<const adjacent_transform_view<_Rng, _Fn, _Nx>> =
+        _Compile_time_max_size<const adjacent_view<_Rng, _Nx>>;
+
+    namespace views {
+        template <size_t _Nx>
+        struct _Adjacent_transform_fn {
+            template <viewable_range _Rng, class _Fn>
+            _NODISCARD static constexpr auto operator()(_Rng&&, _Fn&& _Func)
+                noexcept(noexcept(views::zip_transform(_STD forward<_Fn>(_Func))))
+                requires (_Nx == 0)
+                      && forward_range<_Rng> && requires { views::zip_transform(_STD forward<_Fn>(_Func)); }
+            {
+                return views::zip_transform(_STD forward<_Fn>(_Func));
+            }
+
+            template <viewable_range _Rng, class _Fn>
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Fn&& _Func)
+                noexcept(noexcept(adjacent_transform_view<views::all_t<_Rng>, decay_t<_Fn>, _Nx>(
+                    _STD forward<_Rng>(_Range), _STD forward<_Fn>(_Func))))
+                requires requires {
+                    adjacent_transform_view<views::all_t<_Rng>, decay_t<_Fn>, _Nx>(
+                        _STD forward<_Rng>(_Range), _STD forward<_Fn>(_Func));
+                }
+            {
+                return adjacent_transform_view<views::all_t<_Rng>, decay_t<_Fn>, _Nx>(
+                    _STD forward<_Rng>(_Range), _STD forward<_Fn>(_Func));
+            }
+
+            template <class _Fn>
+                requires constructible_from<decay_t<_Fn>, _Fn>
+            _NODISCARD static constexpr auto operator()(_Fn&& _Func)
+                noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>) {
+                return _Range_closure<_Adjacent_transform_fn, decay_t<_Fn>>{_STD forward<_Fn>(_Func)};
+            }
+        };
+
+        _EXPORT_STD template <size_t _Nx>
+        constexpr _Adjacent_transform_fn<_Nx> adjacent_transform;
+        _EXPORT_STD inline constexpr _Adjacent_transform_fn<2> pairwise_transform;
+    } // namespace views
+
+    template <bool _Const, class _First, class... _Rest>
+    concept _Cartesian_product_is_random_access =
+        (random_access_range<_Maybe_const<_Const, _First>> && ...
+            && (random_access_range<_Maybe_const<_Const, _Rest>> && sized_range<_Maybe_const<_Const, _Rest>>) );
+
+    template <class _Rng>
+    concept _Cartesian_product_common_arg = common_range<_Rng> || (sized_range<_Rng> && random_access_range<_Rng>);
+
+    template <bool _Const, class _First, class... _Rest>
+    concept _Cartesian_product_is_bidirectional = (bidirectional_range<_Maybe_const<_Const, _First>> && ...
+                                                   && (bidirectional_range<_Maybe_const<_Const, _Rest>>
+                                                       && _Cartesian_product_common_arg<_Maybe_const<_Const, _Rest>>) );
+
+    template <class _First /*, class... _Rest*/>
+    concept _Cartesian_product_is_common = _Cartesian_product_common_arg<_First>;
+
+    template <class... _Rngs>
+    concept _Cartesian_product_is_sized = (sized_range<_Rngs> && ...);
+
+    template <bool _Const, template <class> class _FirstSent, class _First, class... _Rest>
+    concept _Cartesian_is_sized_sentinel =
+        (sized_sentinel_for<_FirstSent<_Maybe_const<_Const, _First>>, iterator_t<_Maybe_const<_Const, _First>>> && ...
+            && (sized_range<_Maybe_const<_Const, _Rest>>
+                && sized_sentinel_for<iterator_t<_Maybe_const<_Const, _Rest>>,
+                    iterator_t<_Maybe_const<_Const, _Rest>>>) );
+
+    template <_Cartesian_product_common_arg _Rng>
+    _NODISCARD constexpr auto _Cartesian_common_arg_end(_Rng& _Range) {
+        if constexpr (common_range<_Rng>) {
+            return _RANGES end(_Range);
+        } else {
+            return _RANGES begin(_Range) + _RANGES distance(_Range);
+        }
+    }
+
+    template <class _Rng>
+    _NODISCARD consteval int _Cartesian_product_max_size_bit_width() {
+        using _Size_type = decltype(_Compile_time_max_size<_Rng>);
+        if constexpr (requires { _STD bit_width(_Compile_time_max_size<_Rng>); }) {
+            return _STD bit_width(_Compile_time_max_size<_Rng>);
+        } else {
+            return numeric_limits<_Size_type>::digits;
+        }
+    }
+
+    template <class... _Rngs>
+        requires (sizeof...(_Rngs) > 0)
+    _NODISCARD consteval auto _Cartesian_product_optimal_size_type() noexcept {
+        constexpr int _Optimal_size_type_bit_width = (_Cartesian_product_max_size_bit_width<_Rngs>() + ...);
+        if constexpr (_Optimal_size_type_bit_width <= 8) {
+            return uint8_t{};
+        } else if constexpr (_Optimal_size_type_bit_width <= 16) {
+            return uint16_t{};
+        } else if constexpr (_Optimal_size_type_bit_width <= 32) {
+            return uint32_t{};
+        } else if constexpr (_Optimal_size_type_bit_width <= 64) {
+            return uint64_t{};
+        } else {
+            return _Unsigned128{};
+        }
+    }
+
+    _EXPORT_STD template <input_range _First, forward_range... _Rest>
+        requires (view<_First> && ... && view<_Rest>)
+    class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Rest...>> {
+    private:
+        template <bool _Const>
+        using _Optimal_size_type = decltype(_Cartesian_product_optimal_size_type<_Maybe_const<_Const, _First>,
+            _Maybe_const<_Const, _Rest>...>());
+
+        template <bool _Const>
+        using _Difference_type = common_type_t<_Make_signed_like_t<_Optimal_size_type<_Const>>,
+            range_difference_t<_Maybe_const<_Const, _First>>, range_difference_t<_Maybe_const<_Const, _Rest>>...>;
+
+        template <bool _Const>
+        using _Size_type = common_type_t<_Optimal_size_type<_Const>, range_size_t<_Maybe_const<_Const, _First>>,
+            range_size_t<_Maybe_const<_Const, _Rest>>...>;
+
+        /* [[no_unique_address]] */ tuple<_First, _Rest...> _Bases;
+
+        template <bool _Const>
+        class _Iterator {
+        public:
+            using iterator_category = input_iterator_tag;
+
+            using iterator_concept = conditional_t<_Cartesian_product_is_random_access<_Const, _First, _Rest...>,
+                random_access_iterator_tag,
+                conditional_t<_Cartesian_product_is_bidirectional<_Const, _First, _Rest...>, bidirectional_iterator_tag,
+                    conditional_t<forward_range<_Maybe_const<_Const, _First>>, forward_iterator_tag,
+                        input_iterator_tag>>>;
+
+            using value_type =
+                tuple<range_value_t<_Maybe_const<_Const, _First>>, range_value_t<_Maybe_const<_Const, _Rest>>...>;
+            using reference       = tuple<range_reference_t<_Maybe_const<_Const, _First>>,
+                range_reference_t<_Maybe_const<_Const, _Rest>>...>;
+            using difference_type = _Difference_type<_Const>;
+
+        private:
+            friend cartesian_product_view;
+            using _Parent_t = _Maybe_const<_Const, cartesian_product_view>;
+
+            _Parent_t* _Parent = nullptr;
+            tuple<iterator_t<_Maybe_const<_Const, _First>>, iterator_t<_Maybe_const<_Const, _Rest>>...> _Current;
+
+            template <size_t _Index = sizeof...(_Rest)>
+            constexpr void _Next() {
+                auto& _It = _STD get<_Index>(_Current);
+                ++_It;
+                if constexpr (_Index > 0) {
+                    auto& _Range = _STD get<_Index>(_Parent->_Bases);
+                    if (_It == _RANGES end(_Range)) {
+                        _It = _RANGES begin(_Range);
+                        _Next<_Index - 1>();
+                    }
+                }
+            }
+
+            template <size_t _Index = sizeof...(_Rest)>
+            constexpr void _Prev() {
+                auto& _It = _STD get<_Index>(_Current);
+                if constexpr (_Index > 0) {
+                    auto& _Range = _STD get<_Index>(_Parent->_Bases);
+                    if (_It == _RANGES begin(_Range)) {
+                        _It = _Cartesian_common_arg_end(_Range);
+                        _Prev<_Index - 1>();
+                    }
+                }
+                --_It;
+            }
+
+            template <size_t... _Indices>
+            _NODISCARD constexpr bool _Entire_tail_at_begin(index_sequence<_Indices...>) const {
+                return ((_STD get<_Indices + 1>(_Current) == _RANGES begin(_STD get<_Indices + 1>(_Parent->_Bases)))
+                        && ...);
+            }
+
+            template <size_t _Index = sizeof...(_Rest)>
+            constexpr void _Advance(const difference_type _Off) {
+                if (_Off == 0) {
+                    return;
+                }
+
+                auto& _Range = _STD get<_Index>(_Parent->_Bases);
+                auto& _It    = _STD get<_Index>(_Current);
+                using _Iter  = remove_reference_t<decltype(_It)>;
+
+                if constexpr (_Index > 0) {
+                    const auto _Size       = static_cast<difference_type>(_RANGES ssize(_Range));
+                    const auto _Begin      = _RANGES begin(_Range);
+                    const auto _It_off     = static_cast<difference_type>(_It - _Begin);
+                    const auto _It_new_off = static_cast<difference_type>((_It_off + _Off) % _Size);
+                    const auto _Next_off   = static_cast<difference_type>((_It_off + _Off) / _Size);
+                    if (_It_new_off < 0) {
+                        _It = _Begin + static_cast<iter_difference_t<_Iter>>(_It_new_off + _Size);
+                        _Advance<_Index - 1>(_Next_off - 1);
+                    } else {
+                        _It = _Begin + static_cast<iter_difference_t<_Iter>>(_It_new_off);
+                        _Advance<_Index - 1>(_Next_off);
+                    }
+                } else {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                    const auto _It_off = static_cast<difference_type>(_It - _RANGES begin(_Range));
+                    _STL_VERIFY(_It_off + _Off >= 0, "Cannot advance cartesian_product_view iterator before begin "
+                                                     "(N4950 [range.cartesian.iterator]/19).");
+                    if constexpr (sized_range<decltype(_Range)>) {
+                        const auto _Size = static_cast<difference_type>(_RANGES ssize(_Range));
+                        _STL_VERIFY(_It_off + _Off < _Size
+                                        || (_It_off + _Off == _Size
+                                            && _Entire_tail_at_begin(make_index_sequence<sizeof...(_Rest)>{})),
+                            "Cannot advance cartesian_product_view iterator past end (N4950 "
+                            "[range.cartesian.iterator]/19).");
+                    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                    _It += static_cast<iter_difference_t<_Iter>>(_Off);
+                }
+            }
+
+            template <size_t... _Indices>
+            _NODISCARD constexpr bool _Is_end(index_sequence<_Indices...>) const {
+                return ((_STD get<_Indices>(_Current) == _RANGES end(_STD get<_Indices>(_Parent->_Bases))) || ...);
+            }
+
+            template <size_t... _Indices>
+            _NODISCARD constexpr auto _End_tuple(index_sequence<_Indices...>) const {
+                return tuple<sentinel_t<_Maybe_const<_Const, _First>>, iterator_t<_Maybe_const<_Const, _Rest>>...>{
+                    _RANGES end(_STD get<0>(_Parent->_Bases)),
+                    _RANGES begin(_STD get<_Indices + 1>(_Parent->_Bases))...};
+            }
+
+            template <size_t _Index = sizeof...(_Rest), class _Tuple>
+            _NODISCARD constexpr difference_type _Distance_from(const _Tuple& _Tpl) const {
+                const auto _Diff = static_cast<difference_type>(_STD get<_Index>(_Current) - _STD get<_Index>(_Tpl));
+                if constexpr (_Index > 0) {
+                    difference_type _Result{1};
+                    const auto _Size = static_cast<difference_type>(_RANGES size(_STD get<_Index>(_Parent->_Bases)));
+                    [[maybe_unused]] const bool _Overflow =
+                        _Mul_overflow(_Size, _Distance_from<_Index - 1>(_Tpl), _Result)
+                        || _Add_overflow(_Result, _Diff, _Result);
+#if _ITERATOR_DEBUG_LEVEL != 0
+                    _STL_VERIFY(!_Overflow, "Scaled-sum cannot be represented by difference_type (N4950 "
+                                            "[range.cartesian.iterator]/8).");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+                    return _Result;
+                } else {
+                    return _Diff;
+                }
+            }
+
+            template <size_t... _Indices>
+            _NODISCARD static consteval bool _Is_iter_move_nothrow(index_sequence<_Indices...>) noexcept {
+                return conjunction_v<
+                           is_nothrow_move_constructible<range_rvalue_reference_t<_Maybe_const<_Const, _First>>>,
+                           is_nothrow_move_constructible<range_rvalue_reference_t<_Maybe_const<_Const, _Rest>>>...>
+                    && (noexcept(_RANGES iter_move(_STD get<_Indices>(_STD declval<const _Iterator&>()._Current)))
+                        && ...);
+            }
+
+            template <size_t... _Indices>
+            _NODISCARD static consteval bool _Is_iter_swap_nothrow(index_sequence<_Indices...>) noexcept {
+                return (noexcept(_RANGES iter_swap(_STD get<_Indices>(_STD declval<const _Iterator&>()._Current),
+                            _STD get<_Indices>(_STD declval<const _Iterator&>()._Current)))
+                        && ...);
+            }
+
+            constexpr _Iterator(_Parent_t& _Parent_,
+                tuple<iterator_t<_Maybe_const<_Const, _First>>, iterator_t<_Maybe_const<_Const, _Rest>>...> _Current_)
+                : _Parent(_STD addressof(_Parent_)), _Current(_STD move(_Current_)) {}
+
+        public:
+            _Iterator() = default;
+
+            constexpr _Iterator(_Iterator<!_Const> _It)
+                requires _Const
+                          && (convertible_to<iterator_t<_First>, iterator_t<const _First>> && ...
+                              && convertible_to<iterator_t<_Rest>, iterator_t<const _Rest>>)
+                : _Parent(_It._Parent), _Current(_STD move(_It._Current)) {}
+
+            _NODISCARD constexpr auto operator*() const {
+                return _RANGES _Tuple_transform([](auto& _It) static -> decltype(auto) { return *_It; }, _Current);
+            }
+
+            constexpr _Iterator& operator++() {
+                _Next();
+                return *this;
+            }
+
+            constexpr void operator++(int) {
+                ++*this;
+            }
+
+            constexpr _Iterator operator++(int)
+                requires forward_range<_Maybe_const<_Const, _First>>
+            {
+                auto _Tmp = *this;
+                ++*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator--()
+                requires _Cartesian_product_is_bidirectional<_Const, _First, _Rest...>
+            {
+                _Prev();
+                return *this;
+            }
+
+            constexpr _Iterator operator--(int)
+                requires _Cartesian_product_is_bidirectional<_Const, _First, _Rest...>
+            {
+                auto _Tmp = *this;
+                --*this;
+                return _Tmp;
+            }
+
+            constexpr _Iterator& operator+=(const difference_type _Off)
+                requires _Cartesian_product_is_random_access<_Const, _First, _Rest...>
+            {
+                _Advance(_Off);
+                return *this;
+            }
+
+            constexpr _Iterator& operator-=(const difference_type _Off)
+                requires _Cartesian_product_is_random_access<_Const, _First, _Rest...>
+            {
+                _Advance(-_Off);
+                return *this;
+            }
+
+            _NODISCARD constexpr reference operator[](const difference_type _Off) const
+                requires _Cartesian_product_is_random_access<_Const, _First, _Rest...>
+            {
+                return *(*this + _Off);
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right)
+                requires equality_comparable<iterator_t<_Maybe_const<_Const, _First>>>
+            {
+                return _Left._Current == _Right._Current;
+            }
+
+            _NODISCARD friend constexpr bool operator==(const _Iterator& _It, default_sentinel_t) {
+                return _It._Is_end(make_index_sequence<1 + sizeof...(_Rest)>{});
+            }
+
+            _NODISCARD friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right)
+                requires _All_random_access<_Const, _First, _Rest...>
+            {
+                return _Left._Current <=> _Right._Current;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off)
+                requires _Cartesian_product_is_random_access<_Const, _First, _Rest...>
+            {
+                return _Iterator{_It} += _Off;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It)
+                requires _Cartesian_product_is_random_access<_Const, _First, _Rest...>
+            {
+                return _It + _Off;
+            }
+
+            _NODISCARD friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off)
+                requires _Cartesian_product_is_random_access<_Const, _First, _Rest...>
+            {
+                return _Iterator{_It} -= _Off;
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _Left, const _Iterator& _Right)
+                requires _Cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Rest...>
+            {
+                return _Left._Distance_from(_Right._Current);
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(const _Iterator& _It, default_sentinel_t)
+                requires _Cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Rest...>
+            {
+                return _It._Distance_from(_It._End_tuple(make_index_sequence<sizeof...(_Rest)>{}));
+            }
+
+            _NODISCARD friend constexpr difference_type operator-(default_sentinel_t _Se, const _Iterator& _It)
+                requires _Cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Rest...>
+            {
+                return -(_It - _Se);
+            }
+
+            _NODISCARD friend constexpr auto iter_move(const _Iterator& _It)
+                noexcept(_Is_iter_move_nothrow(make_index_sequence<1 + sizeof...(_Rest)>{})) {
+                return _RANGES _Tuple_transform(_RANGES iter_move, _It._Current);
+            }
+
+            friend constexpr void iter_swap(const _Iterator& _Left, const _Iterator& _Right)
+                noexcept(_Is_iter_swap_nothrow(make_index_sequence<1 + sizeof...(_Rest)>{}))
+                requires (indirectly_swappable<iterator_t<_Maybe_const<_Const, _First>>> && ...
+                          && indirectly_swappable<iterator_t<_Maybe_const<_Const, _Rest>>>)
+            {
+                [&]<size_t... _Indices>(index_sequence<_Indices...>) {
+                    (_RANGES iter_swap(_STD get<_Indices>(_Left._Current), _STD get<_Indices>(_Right._Current)), ...);
+                }(make_index_sequence<1 + sizeof...(_Rest)>{});
+            }
+        };
+
+        template <size_t _Index>
+        _NODISCARD constexpr auto _Begin_or_first_end([[maybe_unused]] const bool _Is_empty) {
+            if constexpr (_Index == 0) {
+                return _Is_empty ? _RANGES begin(_STD get<_Index>(_Bases))
+                                 : _Cartesian_common_arg_end(_STD get<_Index>(_Bases));
+            } else {
+                return _RANGES begin(_STD get<_Index>(_Bases));
+            }
+        }
+
+        template <size_t _Index>
+        _NODISCARD constexpr auto _Begin_or_first_end([[maybe_unused]] const bool _Is_empty) const {
+            if constexpr (_Index == 0) {
+                return _Is_empty ? _RANGES begin(_STD get<_Index>(_Bases))
+                                 : _Cartesian_common_arg_end(_STD get<_Index>(_Bases));
+            } else {
+                return _RANGES begin(_STD get<_Index>(_Bases));
+            }
+        }
+
+    public:
+        constexpr cartesian_product_view() = default;
+
+        constexpr explicit cartesian_product_view(_First _First_base, _Rest... _Other_bases) noexcept(
+            (is_nothrow_move_constructible_v<_First> && ... && is_nothrow_move_constructible_v<_Rest>) ) // strengthened
+            : _Bases(_STD move(_First_base), _STD move(_Other_bases)...) {}
+
+        _NODISCARD constexpr _Iterator<false> begin()
+            requires (!_Simple_view<_First> || ... || !_Simple_view<_Rest>)
+        {
+            return _Iterator<false>{*this, _RANGES _Tuple_transform(_RANGES begin, _Bases)};
+        }
+
+        _NODISCARD constexpr _Iterator<true> begin() const
+            requires (range<const _First> && ... && range<const _Rest>)
+        {
+            return _Iterator<true>{*this, _RANGES _Tuple_transform(_RANGES begin, _Bases)};
+        }
+
+        _NODISCARD constexpr _Iterator<false> end()
+            requires ((!_Simple_view<_First> || ... || !_Simple_view<_Rest>) && _Cartesian_product_is_common<_First>)
+        {
+            const bool _Is_empty = [&]<size_t... _Indices>(index_sequence<_Indices...>) {
+                return (_RANGES empty(_STD get<_Indices + 1>(_Bases)) || ... || false);
+            }(make_index_sequence<sizeof...(_Rest)>{});
+
+            const auto _Make_iter_tuple = [&]<size_t... _Indices>(index_sequence<_Indices...>) {
+                return tuple<iterator_t<_First>, iterator_t<_Rest>...>{_Begin_or_first_end<_Indices>(_Is_empty)...};
+            };
+            return _Iterator<false>{*this, _Make_iter_tuple(make_index_sequence<1 + sizeof...(_Rest)>{})};
+        }
+
+        _NODISCARD constexpr _Iterator<true> end() const
+            requires _Cartesian_product_is_common<const _First>
+        {
+            const bool _Is_empty = [&]<size_t... _Indices>(index_sequence<_Indices...>) {
+                return (_RANGES empty(_STD get<_Indices + 1>(_Bases)) || ... || false);
+            }(make_index_sequence<sizeof...(_Rest)>{});
+
+            const auto _Make_iter_tuple = [&]<size_t... _Indices>(index_sequence<_Indices...>) {
+                return tuple<iterator_t<const _First>, iterator_t<const _Rest>...>{
+                    _Begin_or_first_end<_Indices>(_Is_empty)...};
+            };
+            return _Iterator<true>{*this, _Make_iter_tuple(make_index_sequence<1 + sizeof...(_Rest)>{})};
+        }
+
+        _NODISCARD constexpr default_sentinel_t end() const noexcept {
+            return default_sentinel;
+        }
+
+        _NODISCARD constexpr auto size()
+            requires _Cartesian_product_is_sized<_First, _Rest...>
+        {
+            return [&]<size_t... _Indices>(index_sequence<_Indices...>) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                const array _Sizes   = {static_cast<_Size_type<false>>(_RANGES size(_STD get<_Indices>(_Bases)))...};
+                const bool _Any_zero = ((_Sizes[_Indices] == 0) || ...);
+                if (_Any_zero) {
+                    return _Size_type<false>{0};
+                }
+
+                _Size_type<false> _Product{1};
+                const bool _Overflow = (_Mul_overflow(_Product, _Sizes[_Indices], _Product) || ...);
+                _STL_VERIFY(!_Overflow, "Size of cartesian product cannot be represented by size type (N4950 "
+                                        "[range.cartesian.view]/10).");
+                return _Product;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL != 0 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+                return (static_cast<_Size_type<false>>(_RANGES size(_STD get<_Indices>(_Bases))) * ...);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+            }(make_index_sequence<1 + sizeof...(_Rest)>{});
+        }
+
+        _NODISCARD constexpr auto size() const
+            requires _Cartesian_product_is_sized<const _First, const _Rest...>
+        {
+            return [&]<size_t... _Indices>(index_sequence<_Indices...>) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                const array _Sizes   = {static_cast<_Size_type<true>>(_RANGES size(_STD get<_Indices>(_Bases)))...};
+                const bool _Any_zero = ((_Sizes[_Indices] == 0) || ...);
+                if (_Any_zero) {
+                    return _Size_type<true>{0};
+                }
+
+                _Size_type<true> _Product{1};
+                const bool _Overflow = (_Mul_overflow(_Product, _Sizes[_Indices], _Product) || ...);
+                _STL_VERIFY(!_Overflow, "Size of cartesian product cannot be represented by size type (N4950 "
+                                        "[range.cartesian.view]/10).");
+                return _Product;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL != 0 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+                return (static_cast<_Size_type<true>>(_RANGES size(_STD get<_Indices>(_Bases))) * ...);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+            }(make_index_sequence<1 + sizeof...(_Rest)>{});
+        }
+    };
+
+    template <class... _Rngs>
+    cartesian_product_view(_Rngs&&...) -> cartesian_product_view<views::all_t<_Rngs>...>;
+
+    template <class... _Rngs>
+    _NODISCARD consteval auto _Cartesian_product_view_compile_time_max_size() {
+        using _Size_type = common_type_t<decltype(_Cartesian_product_optimal_size_type<_Rngs...>()),
+            decltype(_Compile_time_max_size<_Rngs>)...>;
+        _Size_type _Result{1};
+        const bool _Overflow =
+            (_Mul_overflow(static_cast<_Size_type>(_Compile_time_max_size<_Rngs>), _Result, _Result) || ...);
+        if (_Overflow) {
+            return (numeric_limits<_Size_type>::max)();
+        } else {
+            return _Result;
+        }
+    }
+
+    template <class... _Rngs>
+    constexpr auto _Compile_time_max_size<cartesian_product_view<_Rngs...>> =
+        _Cartesian_product_view_compile_time_max_size<_Rngs...>();
+
+    template <class... _Rngs>
+    constexpr auto _Compile_time_max_size<const cartesian_product_view<_Rngs...>> =
+        _Cartesian_product_view_compile_time_max_size<const _Rngs...>();
+
+    namespace views {
+        struct _Cartesian_product_fn {
+            _NODISCARD static constexpr auto operator()() noexcept {
+                return views::single(tuple{});
+            }
+
+            template <class... _Rngs>
+            _NODISCARD static constexpr auto operator()(_Rngs&&... _Ranges)
+                noexcept(noexcept(cartesian_product_view<views::all_t<_Rngs>...>{_STD forward<_Rngs>(_Ranges)...}))
+                requires requires { cartesian_product_view<views::all_t<_Rngs>...>{_STD forward<_Rngs>(_Ranges)...}; }
+            {
+                return cartesian_product_view<views::all_t<_Rngs>...>{_STD forward<_Rngs>(_Ranges)...};
+            }
+        };
+
+        _EXPORT_STD inline constexpr _Cartesian_product_fn cartesian_product;
+    } // namespace views
+#endif // _HAS_CXX23
+} // namespace ranges
+
+_EXPORT_STD namespace views = ranges::views;
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _RANGES_
diff --git a/msvc-stl/stl/inc/ratio b/msvc-stl/stl/inc/ratio
new file mode 100644
index 0000000..7d17b36
--- /dev/null
+++ b/msvc-stl/stl/inc/ratio
@@ -0,0 +1,295 @@
+// ratio standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _RATIO_
+#define _RATIO_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstdint>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+_NODISCARD constexpr intmax_t _Abs(const intmax_t _Val) noexcept {
+    return _Val < 0 ? -_Val : _Val;
+}
+
+template <intmax_t _Ax, intmax_t _Bx, bool _Sfinae = false,
+    bool _Good = _Abs(_Ax) <= INTMAX_MAX / (_Bx == 0 ? 1 : _Abs(_Bx))>
+struct _Safe_mult : integral_constant<intmax_t, _Ax * _Bx> {}; // computes _Ax * _Bx without overflow
+
+template <intmax_t _Ax, intmax_t _Bx, bool _Sfinae>
+struct _Safe_mult<_Ax, _Bx, _Sfinae, false> { // _Ax * _Bx would overflow
+    static_assert(_Sfinae, "integer arithmetic overflow");
+};
+
+_NODISCARD constexpr intmax_t _Sign_of(const intmax_t _Val) noexcept {
+    return _Val < 0 ? -1 : 1;
+}
+
+inline void _Safe_add_integer_arithmetic_overflow_error() noexcept {}
+
+_NODISCARD constexpr intmax_t _Safe_add(const intmax_t _Ax, const intmax_t _Bx) noexcept {
+    if (_Sign_of(_Ax) == _Sign_of(_Bx) && _Abs(_Ax) > INTMAX_MAX - _Abs(_Bx)) {
+        _Safe_add_integer_arithmetic_overflow_error();
+    }
+
+    return _Ax + _Bx;
+}
+
+_NODISCARD constexpr intmax_t _Gcd(intmax_t _Ax, intmax_t _Bx) noexcept {
+    // computes GCD of abs(_Ax) and abs(_Bx)
+    if (_Ax == 0 && _Bx == 0) {
+        return 1; // contrary to mathematical convention; avoids division by 0 in ratio_less
+    }
+
+    _Ax = _Abs(_Ax);
+    _Bx = _Abs(_Bx);
+
+    while (_Bx != 0) {
+        const intmax_t _Ax2 = _Ax;
+        _Ax                 = _Bx;
+        _Bx                 = _Ax2 % _Bx;
+    }
+
+    return _Ax;
+}
+
+_EXPORT_STD template <intmax_t _Nx, intmax_t _Dx = 1>
+struct _NO_SPECIALIZATIONS_CITING("N5014 [namespace.std]/2.1") ratio { // holds the ratio of _Nx to _Dx
+    static_assert(_Dx != 0, "zero denominator");
+    static_assert(-INTMAX_MAX <= _Nx, "numerator too negative");
+    static_assert(-INTMAX_MAX <= _Dx, "denominator too negative");
+
+    static constexpr intmax_t num = _Sign_of(_Nx) * _Sign_of(_Dx) * _Abs(_Nx) / _Gcd(_Nx, _Dx);
+    static constexpr intmax_t den = _Abs(_Dx) / _Gcd(_Nx, _Dx);
+
+    using type = ratio<num, den>;
+};
+
+template <class _Ty>
+constexpr bool _Is_ratio_v = false; // test for ratio type
+
+template <intmax_t _Rx1, intmax_t _Rx2>
+constexpr bool _Is_ratio_v<ratio<_Rx1, _Rx2>> = true;
+
+template <class _Rx1, class _Rx2>
+struct _Ratio_add { // add two ratios
+    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_add<R1, R2> requires R1 and R2 to be ratio<>s.");
+
+    static constexpr intmax_t _Nx1 = _Rx1::num;
+    static constexpr intmax_t _Dx1 = _Rx1::den;
+    static constexpr intmax_t _Nx2 = _Rx2::num;
+    static constexpr intmax_t _Dx2 = _Rx2::den;
+
+    static constexpr intmax_t _Gx = _Gcd(_Dx1, _Dx2);
+
+    // typename ratio<>::type is necessary here
+    using type = typename ratio<_Safe_add(_Safe_mult<_Nx1, _Dx2 / _Gx>::value, _Safe_mult<_Nx2, _Dx1 / _Gx>::value),
+        _Safe_mult<_Dx1, _Dx2 / _Gx>::value>::type;
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+using ratio_add = typename _Ratio_add<_Rx1, _Rx2>::type;
+
+template <class _Rx1, class _Rx2>
+struct _Ratio_subtract { // subtract two ratios
+    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_subtract<R1, R2> requires R1 and R2 to be ratio<>s.");
+
+    static constexpr intmax_t _Nx2 = _Rx2::num;
+    static constexpr intmax_t _Dx2 = _Rx2::den;
+
+    using type = ratio_add<_Rx1, ratio<-_Nx2, _Dx2>>;
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+using ratio_subtract = typename _Ratio_subtract<_Rx1, _Rx2>::type;
+
+template <class _Rx1, class _Rx2>
+struct _Ratio_multiply { // multiply two ratios
+    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_multiply<R1, R2> requires R1 and R2 to be ratio<>s.");
+
+    static constexpr intmax_t _Nx1 = _Rx1::num;
+    static constexpr intmax_t _Dx1 = _Rx1::den;
+    static constexpr intmax_t _Nx2 = _Rx2::num;
+    static constexpr intmax_t _Dx2 = _Rx2::den;
+
+    static constexpr intmax_t _Gx = _Gcd(_Nx1, _Dx2);
+    static constexpr intmax_t _Gy = _Gcd(_Nx2, _Dx1);
+
+    using _Num = _Safe_mult<_Nx1 / _Gx, _Nx2 / _Gy, true>;
+    using _Den = _Safe_mult<_Dx1 / _Gy, _Dx2 / _Gx, true>;
+};
+
+template <class _Rx1, class _Rx2, bool _Sfinae = true, class = void>
+struct _Ratio_multiply_sfinae { // detect overflow during multiplication
+    static_assert(_Sfinae, "integer arithmetic overflow");
+};
+
+template <class _Rx1, class _Rx2, bool _Sfinae>
+struct _Ratio_multiply_sfinae<_Rx1, _Rx2, _Sfinae,
+    void_t<typename _Ratio_multiply<_Rx1, _Rx2>::_Num::type,
+        typename _Ratio_multiply<_Rx1, _Rx2>::_Den::type>> { // typename ratio<>::type is unnecessary here
+    using type = ratio<_Ratio_multiply<_Rx1, _Rx2>::_Num::value, _Ratio_multiply<_Rx1, _Rx2>::_Den::value>;
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+using ratio_multiply = typename _Ratio_multiply_sfinae<_Rx1, _Rx2, false>::type;
+
+template <class _Rx1, class _Rx2>
+struct _Ratio_divide { // divide two ratios
+    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_divide<R1, R2> requires R1 and R2 to be ratio<>s.");
+
+    static constexpr intmax_t _Nx2 = _Rx2::num;
+    static constexpr intmax_t _Dx2 = _Rx2::den;
+
+    using _Rx2_inverse = ratio<_Dx2, _Nx2>;
+};
+
+template <class _Rx1, class _Rx2, bool _Sfinae = true>
+using _Ratio_divide_sfinae =
+    typename _Ratio_multiply_sfinae<_Rx1, typename _Ratio_divide<_Rx1, _Rx2>::_Rx2_inverse, _Sfinae>::type;
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+using ratio_divide = _Ratio_divide_sfinae<_Rx1, _Rx2, false>;
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+struct ratio_equal : bool_constant<_Rx1::num == _Rx2::num && _Rx1::den == _Rx2::den> { // tests if ratio == ratio
+    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool ratio_equal_v = ratio_equal<_Rx1, _Rx2>::value;
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+struct ratio_not_equal : bool_constant<!ratio_equal_v<_Rx1, _Rx2>> { // tests if ratio != ratio
+    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_not_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool ratio_not_equal_v = ratio_not_equal<_Rx1, _Rx2>::value;
+
+struct _Big_uint128 {
+    uint64_t _Upper;
+    uint64_t _Lower;
+
+    _NODISCARD constexpr bool operator<(const _Big_uint128 _Rhs) const noexcept {
+        if (_Upper != _Rhs._Upper) {
+            return _Upper < _Rhs._Upper;
+        }
+
+        return _Lower < _Rhs._Lower;
+    }
+};
+
+constexpr _Big_uint128 _Big_multiply(const uint64_t _Lfactor,
+    const uint64_t _Rfactor) noexcept { // multiply two 64-bit integers into a 128-bit integer, Knuth's algorithm M
+    const uint64_t _Llow  = _Lfactor & 0xFFFF'FFFFULL;
+    const uint64_t _Lhigh = _Lfactor >> 32;
+    const uint64_t _Rlow  = _Rfactor & 0xFFFF'FFFFULL;
+    const uint64_t _Rhigh = _Rfactor >> 32;
+
+    uint64_t _Temp          = _Llow * _Rlow;
+    const uint64_t _Lower32 = _Temp & 0xFFFF'FFFFULL;
+    uint64_t _Carry         = _Temp >> 32;
+
+    _Temp                     = _Llow * _Rhigh + _Carry;
+    const uint64_t _Mid_lower = _Temp & 0xFFFF'FFFFULL;
+    const uint64_t _Mid_upper = _Temp >> 32;
+
+    _Temp  = _Lhigh * _Rlow + _Mid_lower;
+    _Carry = _Temp >> 32;
+
+    return {_Lhigh * _Rhigh + _Mid_upper + _Carry, (_Temp << 32) + _Lower32};
+}
+
+constexpr bool _Ratio_less(const int64_t _Nx1, const int64_t _Dx1, const int64_t _Nx2, const int64_t _Dx2) noexcept {
+    if (_Nx1 >= 0 && _Nx2 >= 0) {
+        return _Big_multiply(static_cast<uint64_t>(_Nx1), static_cast<uint64_t>(_Dx2))
+             < _Big_multiply(static_cast<uint64_t>(_Nx2), static_cast<uint64_t>(_Dx1));
+    }
+
+    if (_Nx1 < 0 && _Nx2 < 0) {
+        return _Big_multiply(static_cast<uint64_t>(-_Nx2), static_cast<uint64_t>(_Dx1))
+             < _Big_multiply(static_cast<uint64_t>(-_Nx1), static_cast<uint64_t>(_Dx2));
+    }
+
+    return _Nx1 < _Nx2;
+}
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+struct ratio_less : bool_constant<_Ratio_less(_Rx1::num, _Rx1::den, _Rx2::num, _Rx2::den)> { // tests if ratio < ratio
+    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_less<R1, R2> requires R1 and R2 to be ratio<>s.");
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool ratio_less_v = ratio_less<_Rx1, _Rx2>::value;
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+struct ratio_less_equal : bool_constant<!ratio_less_v<_Rx2, _Rx1>> { // tests if ratio <= ratio
+    static_assert(
+        _Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_less_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool ratio_less_equal_v = ratio_less_equal<_Rx1, _Rx2>::value;
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+struct ratio_greater : ratio_less<_Rx2, _Rx1>::type { // tests if ratio > ratio
+    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_greater<R1, R2> requires R1 and R2 to be ratio<>s.");
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool ratio_greater_v = ratio_greater<_Rx1, _Rx2>::value;
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+struct ratio_greater_equal : bool_constant<!ratio_less_v<_Rx1, _Rx2>> { // tests if ratio >= ratio
+    static_assert(
+        _Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_greater_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
+};
+
+_EXPORT_STD template <class _Rx1, class _Rx2>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool ratio_greater_equal_v = ratio_greater_equal<_Rx1, _Rx2>::value;
+
+_EXPORT_STD using atto  = ratio<1, 1000000000000000000LL>;
+_EXPORT_STD using femto = ratio<1, 1000000000000000LL>;
+_EXPORT_STD using pico  = ratio<1, 1000000000000LL>;
+_EXPORT_STD using nano  = ratio<1, 1000000000>;
+_EXPORT_STD using micro = ratio<1, 1000000>;
+_EXPORT_STD using milli = ratio<1, 1000>;
+_EXPORT_STD using centi = ratio<1, 100>;
+_EXPORT_STD using deci  = ratio<1, 10>;
+_EXPORT_STD using deca  = ratio<10, 1>;
+_EXPORT_STD using hecto = ratio<100, 1>;
+_EXPORT_STD using kilo  = ratio<1000, 1>;
+_EXPORT_STD using mega  = ratio<1000000, 1>;
+_EXPORT_STD using giga  = ratio<1000000000, 1>;
+_EXPORT_STD using tera  = ratio<1000000000000LL, 1>;
+_EXPORT_STD using peta  = ratio<1000000000000000LL, 1>;
+_EXPORT_STD using exa   = ratio<1000000000000000000LL, 1>;
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _RATIO_
diff --git a/msvc-stl/stl/inc/regex b/msvc-stl/stl/inc/regex
new file mode 100644
index 0000000..a29abc0
--- /dev/null
+++ b/msvc-stl/stl/inc/regex
@@ -0,0 +1,6079 @@
+// regex standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _REGEX_
+#define _REGEX_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <algorithm>
+#include <cctype>
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+#include <cwchar>
+#include <iterator>
+#include <locale>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// Controls whether LWG-2503 "multiline option should be added to syntax_option_type" is implemented.
+// Defining this to 0 requests Standard behavior:
+// * For ECMAScript, matching is non-multiline by default, but regex_constants::multiline can be requested.
+// * For POSIX grammars, matching is non-multiline, and regex_constants::multiline is ignored (N5008 [tab:re.synopt]).
+// Defining this to 1 requests legacy behavior:
+// * For all grammars, matching is multiline, and regex_constants::multiline is redundant.
+#ifndef _REGEX_LEGACY_MULTILINE_MODE
+#define _REGEX_LEGACY_MULTILINE_MODE 0
+#endif
+
+#ifndef _ENHANCED_REGEX_VISUALIZER
+#ifdef _DEBUG
+#define _ENHANCED_REGEX_VISUALIZER 1
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _ENHANCED_REGEX_VISUALIZER 0
+#endif // ^^^ !defined(_DEBUG) ^^^
+#endif // !defined(_ENHANCED_REGEX_VISUALIZER)
+
+#if defined(_CPPRTTI) && !defined(_M_CEE_PURE)
+extern "C" {
+_STD size_t __stdcall __std_regex_transform_primary_char(
+    _Out_writes_(_Last1 - _First1) _Post_readable_size_(return) char* _First1, char* _Last1,
+    _In_reads_(_Last2 - _First2) const char* _First2, const char* _Last2, _In_opt_ const _Collvec*) noexcept;
+_STD size_t __stdcall __std_regex_transform_primary_wchar_t(
+    _Out_writes_(_Last1 - _First1) _Post_readable_size_(return) wchar_t* _First1, wchar_t* _Last1,
+    _In_reads_(_Last2 - _First2) const wchar_t* _First2, const wchar_t* _Last2, _In_opt_ const _Collvec*) noexcept;
+} // extern "C"
+#endif // ^^^ defined(_CPPRTTI) && !defined(_M_CEE_PURE) ^^^
+
+_STD_BEGIN
+
+enum _Meta_type : int { // meta character representations for parser
+    _Meta_lpar  = '(',
+    _Meta_rpar  = ')',
+    _Meta_dlr   = '$',
+    _Meta_caret = '^',
+    _Meta_dot   = '.',
+    _Meta_star  = '*',
+    _Meta_plus  = '+',
+    _Meta_query = '?',
+    _Meta_lsq   = '[',
+    _Meta_rsq   = ']',
+    _Meta_bar   = '|',
+    _Meta_esc   = '\\',
+    _Meta_dash  = '-',
+    _Meta_lbr   = '{',
+    _Meta_rbr   = '}',
+    _Meta_comma = ',',
+    _Meta_colon = ':',
+    _Meta_equal = '=',
+    _Meta_exc   = '!',
+    _Meta_eos   = -1,
+    _Meta_nl    = '\n',
+    _Meta_cr    = '\r',
+    _Meta_bsp   = '\b',
+    _Meta_ls    = L'\u2028',
+    _Meta_ps    = L'\u2029',
+    _Meta_chr   = 0,
+
+    _Esc_bsl      = '\\',
+    _Esc_word     = 'b',
+    _Esc_not_word = 'B',
+    _Esc_ctrl_a   = 'a',
+    _Esc_ctrl_b   = 'b',
+    _Esc_ctrl_f   = 'f',
+    _Esc_ctrl_n   = 'n',
+    _Esc_ctrl_r   = 'r',
+    _Esc_ctrl_t   = 't',
+    _Esc_ctrl_v   = 'v',
+    _Esc_ctrl     = 'c',
+    _Esc_hex      = 'x',
+    _Esc_uni      = 'u'
+};
+
+namespace regex_constants {
+    // constants used in regular expressions
+    _EXPORT_STD enum syntax_option_type : int { // specify RE syntax rules
+        ECMAScript = 0x01,
+        basic      = 0x02,
+        extended   = 0x04,
+        awk        = 0x08,
+        grep       = 0x10,
+        egrep      = 0x20,
+        _Gmask     = 0x3F,
+        _Any_posix = basic | extended | grep | egrep | awk,
+
+        icase     = 0x0100,
+        nosubs    = 0x0200,
+        optimize  = 0x0400,
+        collate   = 0x0800,
+        multiline = 0x1000
+    };
+
+    _BITMASK_OPS(_EXPORT_STD, syntax_option_type)
+
+    _EXPORT_STD enum match_flag_type : int { // specify matching and formatting rules
+        match_default     = 0x0000,
+        match_not_bol     = 0x0001,
+        match_not_eol     = 0x0002,
+        match_not_bow     = 0x0004,
+        match_not_eow     = 0x0008,
+        match_any         = 0x0010,
+        match_not_null    = 0x0020,
+        match_continuous  = 0x0040,
+        match_prev_avail  = 0x0100,
+        format_default    = 0x0000,
+        format_sed        = 0x0400,
+        format_no_copy    = 0x0800,
+        format_first_only = 0x1000,
+        _Match_not_null   = 0x2000,
+        // TRANSITION, ABI: Flag 0x4000 was used by the matcher in the past
+    };
+
+    _BITMASK_OPS(_EXPORT_STD, match_flag_type)
+
+    _EXPORT_STD enum error_type { // identify error
+        error_collate,
+        error_ctype,
+        error_escape,
+        error_backref,
+        error_brack,
+        error_paren,
+        error_brace,
+        error_badbrace,
+        error_range,
+        error_space,
+        error_badrepeat,
+        error_complexity,
+        error_stack,
+        _Error_parse, // TRANSITION, was error_parse, keeping behavior
+        _Error_syntax // TRANSITION, was error_syntax, keeping behavior
+    };
+} // namespace regex_constants
+
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xregex_error(regex_constants::error_type _Code);
+
+_EXPORT_STD template <class _Elem>
+class regex_traits;
+
+struct _Cl_names { // structure to associate class name with mask value
+    const char* _Narrow;
+    const wchar_t* _Wide;
+    unsigned int _Len;
+    ctype_base::mask _Ctype;
+
+    template <class _Elem>
+    _NODISCARD const _Elem* _Get() const noexcept {
+        if constexpr (is_same_v<_Elem, char>) {
+            return _Narrow;
+        } else {
+            return _Wide;
+        }
+    }
+};
+
+template <class _CharT>
+struct _Std_char_traits_eq {
+    static bool operator()(_CharT _Left, _CharT _Right) noexcept {
+        return char_traits<_CharT>::eq(_Left, _Right);
+    }
+};
+
+template <class _CharT>
+struct _Std_char_traits_lt {
+    static bool operator()(_CharT _Left, _CharT _Right) noexcept {
+        return char_traits<_CharT>::lt(_Left, _Right);
+    }
+};
+
+// signed char and other unsigned integral types are supported as an extension.
+template <class _Ty>
+constexpr bool _Is_predefined_char_like_type = _Is_character<_Ty>::value || is_unsigned_v<_Ty>;
+
+// library-provided char_traits::eq behaves like equal_to<_Elem>
+template <class _Elem>
+constexpr bool _Can_memcmp_elements_with_pred<_Elem, _Elem, _Std_char_traits_eq<_Elem>> =
+    _Is_predefined_char_like_type<_Elem> && _Can_memcmp_elements<_Elem, _Elem>;
+
+template <class _Elem, bool = _Is_predefined_char_like_type<_Elem>>
+struct _Lex_compare_memcmp_classify_pred_for_std_char_traits_lt {
+    using _UElem = make_unsigned_t<_Elem>;
+    using _Pred  = conditional_t<_Lex_compare_memcmp_classify_elements<_UElem, _UElem>, less<int>, void>;
+};
+template <class _Elem>
+struct _Lex_compare_memcmp_classify_pred_for_std_char_traits_lt<_Elem, false> {
+    using _Pred = void;
+};
+
+// library-provided char_traits::lt behaves like less<make_unsigned_t<_Elem>>
+template <class _Elem>
+struct _Lex_compare_memcmp_classify_pred<_Elem, _Elem, _Std_char_traits_lt<_Elem>>
+    : _Lex_compare_memcmp_classify_pred_for_std_char_traits_lt<_Elem> {};
+
+template <class _RxTraits>
+struct _Cmp_icase { // functor to compare for equality following case-insensitive translation of both characters
+    using _Elem = typename _RxTraits::char_type;
+
+    explicit _Cmp_icase(const _RxTraits& _Tr) noexcept : _Traits(_Tr) {}
+
+    bool operator()(_Elem _Ex1, _Elem _Ex2) const {
+        return _Traits.translate_nocase(_Ex1) == _Traits.translate_nocase(_Ex2);
+    }
+
+    const _RxTraits& _Traits;
+};
+
+template <class _RxTraits>
+struct _Cmp_collate { // functor to compare for equality following collating translation of both characters
+    using _Elem = typename _RxTraits::char_type;
+
+    explicit _Cmp_collate(const _RxTraits& _Tr) noexcept : _Traits(_Tr) {}
+
+    bool operator()(_Elem _Ex1, _Elem _Ex2) const {
+        return _Traits.translate(_Ex1) == _Traits.translate(_Ex2);
+    }
+
+    const _RxTraits& _Traits;
+};
+
+template <class _RxTraits>
+struct _Cmp_icase_translateleft {
+    // functor to compare for equality following case-insensitive translation of the left character
+    using _Elem = typename _RxTraits::char_type;
+
+    explicit _Cmp_icase_translateleft(const _RxTraits& _Tr) noexcept : _Traits(_Tr) {}
+
+    bool operator()(_Elem _Ex1, _Elem _Ex2) const {
+        return _Traits.translate_nocase(_Ex1) == _Ex2;
+    }
+
+    const _RxTraits& _Traits;
+};
+
+template <class _RxTraits>
+struct _Cmp_collate_translateleft {
+    // functor to compare for equality following collating translation of the left character
+    using _Elem = typename _RxTraits::char_type;
+
+    explicit _Cmp_collate_translateleft(const _RxTraits& _Tr) noexcept : _Traits(_Tr) {}
+
+    bool operator()(_Elem _Ex1, _Elem _Ex2) const {
+        return _Traits.translate(_Ex1) == _Ex2;
+    }
+
+    const _RxTraits& _Traits;
+};
+
+struct _Regex_traits_base { // base of all regular expression traits
+    enum _Char_class_type {
+        _Ch_alnum  = ctype_base::alnum,
+        _Ch_alpha  = ctype_base::alpha,
+        _Ch_cntrl  = ctype_base::cntrl,
+        _Ch_digit  = ctype_base::digit,
+        _Ch_graph  = ctype_base::graph,
+        _Ch_lower  = ctype_base::lower,
+        _Ch_print  = ctype_base::print,
+        _Ch_punct  = ctype_base::punct,
+        _Ch_space  = ctype_base::space,
+        _Ch_upper  = ctype_base::upper,
+        _Ch_xdigit = ctype_base::xdigit,
+        _Ch_blank  = ctype_base::blank
+    };
+    using char_class_type = ctype_base::mask;
+};
+
+#if defined(_CPPRTTI) && !defined(_M_CEE_PURE)
+inline size_t _Regex_transform_primary(_Out_writes_(_Last1 - _First1) _Post_readable_size_(return) char* _First1,
+    char* _Last1, _In_reads_(_Last2 - _First2) const char* _First2, const char* _Last2,
+    _In_opt_ const _Locinfo::_Collvec* _Vector) noexcept {
+    return __std_regex_transform_primary_char(_First1, _Last1, _First2, _Last2, _Vector);
+}
+
+inline size_t _Regex_transform_primary(_Out_writes_(_Last1 - _First1) _Post_readable_size_(return) wchar_t* _First1,
+    wchar_t* _Last1, _In_reads_(_Last2 - _First2) const wchar_t* _First2, const wchar_t* _Last2,
+    _In_opt_ const _Locinfo::_Collvec* _Vector) noexcept {
+    return __std_regex_transform_primary_wchar_t(_First1, _Last1, _First2, _Last2, _Vector);
+}
+#endif // ^^^ defined(_CPPRTTI) && !defined(_M_CEE_PURE) ^^^
+
+template <class _Elem>
+class _Regex_traits : public _Regex_traits_base { // base class for regular expression traits
+public:
+    using char_type   = _Elem;
+    using size_type   = size_t;
+    using string_type = basic_string<_Elem>;
+    using locale_type = locale;
+
+    static size_type length(const _Elem* _Str) {
+        return char_traits<_Elem>::length(_Str);
+    }
+
+    _Regex_traits() {
+        _Cache_locale();
+    }
+
+    _Regex_traits(const _Regex_traits& _Right) : _Loc(_Right._Loc) {
+        _Cache_locale();
+    }
+
+    _Regex_traits& operator=(const _Regex_traits& _Right) {
+        _Loc = _Right._Loc;
+        _Cache_locale();
+        return *this;
+    }
+
+    _Elem translate(_Elem _Ch) const { // provide locale-sensitive mapping
+        return _Ch;
+    }
+
+    _Elem translate_nocase(_Elem _Ch) const { // provide case-insensitive mapping
+        return _Getctype()->tolower(_Ch);
+    }
+
+    template <class _FwdIt>
+    string_type transform(_FwdIt _First, _FwdIt _Last) const { // apply locale-specific transformation
+        const string_type _Str(_First, _Last);
+        return _Getcoll()->transform(_Str.data(), _Str.data() + _Str.size());
+    }
+
+    template <class _FwdIt>
+    string_type transform_primary(_FwdIt _First, _FwdIt _Last) const {
+        // apply locale-specific case-insensitive transformation
+        string_type _Res;
+#if defined(_CPPRTTI) && !defined(_M_CEE_PURE)
+        if (_First != _Last) {
+            const collate<_Elem>* _Coll = _Getcoll();
+            const auto& _Coll_type      = typeid(*_Coll);
+            // TRANSITION, ABI: GH-5394: locale creates collate objects of type collate, not collate_byname.
+            // Depending on the resolution of LWG-2338, comparison to typeid(collate) might also become
+            // required by the standard.
+            if (_Coll_type == typeid(collate_byname<_Elem>) || _Coll_type == typeid(collate<_Elem>)) {
+                // non-empty string with known collate facet, transform it
+                const string_type _Src(_First, _Last);
+                const auto _Src_first = _Src.data();
+                const auto _Src_last  = _Src_first + _Src.size();
+
+                size_t _Count = _Src.size();
+                while (_Res.size() < _Count) {
+                    _Res.resize(_Count);
+                    _Count = _STD _Regex_transform_primary(
+                        &_Res[0], &_Res[0] + _Count, _Src_first, _Src_last, &_Coll->_Coll);
+
+                    if (_Count == static_cast<size_t>(-1)) {
+                        // return empty string in case of error
+                        _Count = 0;
+                        break;
+                    }
+                }
+                _Res.resize(_Count);
+            }
+        }
+#else // ^^^ defined(_CPPRTTI) && !defined(_M_CEE_PURE) / !defined(_CPPRTTI) || defined(_M_CEE_PURE) vvv
+        (void) _First;
+        (void) _Last;
+#endif // ^^^ !defined(_CPPRTTI) || defined(_M_CEE_PURE) ^^^
+        return _Res;
+    }
+
+    bool isctype(_Elem _Ch, char_class_type _Fx) const {
+        if (_Fx != static_cast<char_class_type>(-1)) {
+            return _Getctype()->is(_Fx, _Ch);
+        } else {
+            return _Ch == '_' // assumes L'_' == '_'
+                || _Getctype()->is(_Ch_alnum, _Ch);
+        }
+    }
+
+    template <class _Iter>
+    char_class_type lookup_classname(_Iter _First, _Iter _Last, bool _Icase = false) const {
+        // map [_First, _Last) to character class mask value
+#define _REGEX_CHAR_CLASS_NAME(n, c)                            \
+    {                                                           \
+        n, L##n, static_cast<unsigned int>(_STD size(n) - 1), c \
+    }
+        static constexpr _Cl_names _Names[] = {
+            // map class names to numeric constants
+            _REGEX_CHAR_CLASS_NAME("alnum", _Ch_alnum),
+            _REGEX_CHAR_CLASS_NAME("alpha", _Ch_alpha),
+            _REGEX_CHAR_CLASS_NAME("blank", _Ch_blank),
+            _REGEX_CHAR_CLASS_NAME("cntrl", _Ch_cntrl),
+            _REGEX_CHAR_CLASS_NAME("d", _Ch_digit),
+            _REGEX_CHAR_CLASS_NAME("digit", _Ch_digit),
+            _REGEX_CHAR_CLASS_NAME("graph", _Ch_graph),
+            _REGEX_CHAR_CLASS_NAME("lower", _Ch_lower),
+            _REGEX_CHAR_CLASS_NAME("print", _Ch_print),
+            _REGEX_CHAR_CLASS_NAME("punct", _Ch_punct),
+            _REGEX_CHAR_CLASS_NAME("space", _Ch_space),
+            _REGEX_CHAR_CLASS_NAME("s", _Ch_space),
+            _REGEX_CHAR_CLASS_NAME("upper", _Ch_upper),
+            _REGEX_CHAR_CLASS_NAME("w", static_cast<ctype_base::mask>(-1)),
+            _REGEX_CHAR_CLASS_NAME("xdigit", _Ch_xdigit),
+            {nullptr, nullptr, 0, 0},
+        };
+#undef _REGEX_CHAR_CLASS_NAME
+
+        _Adl_verify_range(_First, _Last);
+        unsigned int _Ix = 0;
+        for (; _Names[_Ix]._Get<_Elem>(); ++_Ix) {
+            if (_STD equal(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Names[_Ix]._Get<_Elem>(),
+                    _Names[_Ix]._Get<_Elem>() + _Names[_Ix]._Len, _Cmp_icase<_Regex_traits<_Elem>>{*this})) {
+                break;
+            }
+        }
+
+        char_class_type _Mask{};
+        if (_Names[_Ix]._Get<_Elem>()) {
+            _Mask = _Names[_Ix]._Ctype;
+        }
+
+        if (_Icase && (_Mask & (_Ch_lower | _Ch_upper))) {
+            _Mask |= _Ch_lower | _Ch_upper;
+        }
+
+        return _Mask;
+    }
+
+    template <class _FwdIt>
+    string_type lookup_collatename(_FwdIt _First, _FwdIt _Last) const { // map [_First, _Last) to collation element
+        if (_First != _Last && _STD next(_First) == _Last) {
+            return string_type{_First, _Last};
+        }
+        return string_type{};
+    }
+
+    locale_type imbue(locale_type _Lx) { // store locale object
+        locale_type _Tmp = _Loc;
+        _Loc             = _Lx;
+        _Cache_locale();
+        return _Tmp;
+    }
+
+    locale_type getloc() const noexcept /* strengthened */ {
+        return _Loc;
+    }
+
+    const collate<_Elem>* _Getcoll() const noexcept { // get collate facet pointer
+        return _Pcoll;
+    }
+
+    const ctype<_Elem>* _Getctype() const noexcept { // get ctype facet pointer
+        return _Pctype;
+    }
+
+private:
+    void _Cache_locale() { // populate _Pcoll and _Pctype with _Loc locale
+        _Pcoll  = _STD addressof(_STD use_facet<collate<_Elem>>(_Loc));
+        _Pctype = _STD addressof(_STD use_facet<ctype<_Elem>>(_Loc));
+    }
+
+    const collate<_Elem>* _Pcoll;
+    const ctype<_Elem>* _Pctype;
+    locale_type _Loc;
+};
+
+template <>
+class regex_traits<char> : public _Regex_traits<char> {
+public:
+    int value(char _Ch, int _Base) const { // map character value to numeric value
+        if ((_Base != 8 && '0' <= _Ch && _Ch <= '9') || (_Base == 8 && '0' <= _Ch && _Ch <= '7')) {
+            return _Ch - '0';
+        }
+
+        if (_Base != 16) {
+            return -1;
+        }
+
+        if ('a' <= _Ch && _Ch <= 'f') {
+            return _Ch - 'a' + 10;
+        }
+
+        if ('A' <= _Ch && _Ch <= 'F') {
+            return _Ch - 'A' + 10;
+        }
+
+        return -1;
+    }
+};
+
+template <>
+class regex_traits<wchar_t> : public _Regex_traits<wchar_t> {
+public:
+    int value(wchar_t _Ch, int _Base) const { // map character value to numeric value
+        if ((_Base != 8 && L'0' <= _Ch && _Ch <= L'9') || (_Base == 8 && L'0' <= _Ch && _Ch <= L'7')) {
+            return _Ch - L'0';
+        }
+
+        if (_Base != 16) {
+            return -1;
+        }
+
+        if (L'a' <= _Ch && _Ch <= L'f') {
+            return _Ch - L'a' + 10;
+        }
+
+        if (L'A' <= _Ch && _Ch <= L'F') {
+            return _Ch - L'A' + 10;
+        }
+
+        return -1;
+    }
+};
+
+_EXPORT_STD class _NODISCARD regex_error : public runtime_error { // type of all regular expression exceptions
+public:
+    explicit regex_error(regex_constants::error_type _Ex) : runtime_error(_Stringify(_Ex)), _Err(_Ex) {}
+
+    _NODISCARD regex_constants::error_type code() const noexcept /* strengthened */ {
+        return _Err;
+    }
+
+private:
+    static const char* _Stringify(regex_constants::error_type _Ex) noexcept { // map error code to string
+        switch (_Ex) { // select known error_type message
+        case regex_constants::error_collate:
+            return "regex_error(error_collate): The expression "
+                   "contained an invalid collating element name.";
+        case regex_constants::error_ctype:
+            return "regex_error(error_ctype): The expression "
+                   "contained an invalid character class name.";
+        case regex_constants::error_escape:
+            return "regex_error(error_escape): The expression "
+                   "contained an invalid escaped character, "
+                   "or a trailing escape.";
+        case regex_constants::error_backref:
+            return "regex_error(error_backref): The expression "
+                   "contained an invalid back reference.";
+        case regex_constants::error_brack:
+            return "regex_error(error_brack): The expression "
+                   "contained mismatched [ and ].";
+        case regex_constants::error_paren:
+            return "regex_error(error_paren): The expression "
+                   "contained mismatched ( and ).";
+        case regex_constants::error_brace:
+            return "regex_error(error_brace): The expression "
+                   "contained mismatched { and }.";
+        case regex_constants::error_badbrace:
+            return "regex_error(error_badbrace): The expression "
+                   "contained an invalid range in a {} expression.";
+        case regex_constants::error_range:
+            return "regex_error(error_range): The expression "
+                   "contained an invalid character range, "
+                   "such as [b-a] in most encodings.";
+        case regex_constants::error_space:
+            return "regex_error(error_space): There was insufficient "
+                   "memory to convert the expression into "
+                   "a finite state machine.";
+        case regex_constants::error_badrepeat:
+            return "regex_error(error_badrepeat): One of *?+{ "
+                   "was not preceded by a valid regular expression.";
+        case regex_constants::error_complexity:
+            return "regex_error(error_complexity): The complexity of "
+                   "an attempted match against a regular expression "
+                   "exceeded a pre-set level.";
+        case regex_constants::error_stack:
+            return "regex_error(error_stack): There was insufficient "
+                   "memory to determine whether the regular expression "
+                   "could match the specified character sequence.";
+        case regex_constants::_Error_parse: // TRANSITION, keeping behavior
+            return "regex_error(error_parse)";
+        case regex_constants::_Error_syntax:
+            return "regex_error(error_syntax)";
+        default:
+            return "regex_error";
+        }
+    }
+
+    regex_constants::error_type _Err;
+};
+
+inline bool _Is_word(unsigned char _UCh) {
+    // special casing char to avoid branches for std::regex in this path
+    static constexpr bool _Is_word_table[_STD _Max_limit<unsigned char>() + 1] = {
+        //       X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 XA XB XC XD XE XF
+        /* 0X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        /* 1X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        /* 2X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        /* 3X */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 0-9
+        /* 4X */ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A-Z
+        /* 5X */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 5F == _
+        /* 6X */ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // a-z
+        /* 7X */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
+        // non-ASCII values initialized to 0
+    };
+    return _Is_word_table[_UCh];
+}
+
+inline bool _Is_word(char _Ch) {
+    return _Is_word(static_cast<unsigned char>(_Ch));
+}
+
+template <class _Elem>
+bool _Is_word(_Elem _Ch) {
+    // assumes that ASCII characters are represented at ASCII code points
+    const auto _Uchar = static_cast<unsigned char>(_Ch);
+    return static_cast<_Elem>(_Uchar) == _Ch && _Uchar <= 'z' && _Is_word(_Uchar);
+}
+
+_EXPORT_STD template <class _BidIt>
+class sub_match : public pair<_BidIt, _BidIt> { // class to hold contents of a capture group
+public:
+    using _Mybase         = pair<_BidIt, _BidIt>;
+    using value_type      = typename iterator_traits<_BidIt>::value_type;
+    using difference_type = typename iterator_traits<_BidIt>::difference_type;
+    using iterator        = _BidIt;
+    using string_type     = basic_string<value_type>;
+
+    constexpr sub_match() = default;
+
+    bool matched = false;
+
+    _NODISCARD difference_type length() const {
+        const _Mybase _Range(_Effective_range());
+        return _STD distance(_Range.first, _Range.second);
+    }
+
+    operator string_type() const { // convert matched text to string
+        return str();
+    }
+
+    _NODISCARD string_type str() const { // convert matched text to string
+        const _Mybase _Range(_Effective_range());
+        return string_type{_Range.first, _Range.second};
+    }
+
+    _NODISCARD int compare(const sub_match& _Right) const { // compare *this to _Right
+        const _Mybase _LRange(_Effective_range());
+        const _Mybase _RRange(_Right._Effective_range());
+        return _Iter_compare(_LRange.first, _LRange.second, _RRange.first, _RRange.second);
+    }
+
+    _NODISCARD int compare(const string_type& _Right) const { // compare *this to _Right
+        return _Compare(_Right.data(), _Right.size());
+    }
+
+    _NODISCARD int compare(_In_z_ const value_type* _Ptr) const { // compare *this to array pointed to by _Ptr
+        return _Compare(_Ptr, char_traits<value_type>::length(_Ptr));
+    }
+
+    void swap(sub_match& _Other) noexcept(_Is_nothrow_swappable<_BidIt>::value) {
+        _Mybase::swap(_Other);
+        _STD swap(matched, _Other.matched);
+    }
+
+    template <class _FwdIt2>
+    static int _Iter_compare(_BidIt _First1, _BidIt _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) {
+        // compare two iterator ranges:
+        // if [_First1, _Last1) is lexicographically less than [_First2, _Last2), a negative value
+        // if [_First2, _Last2) is lexicographically less than [_First1, _Last1), a positive value
+        // otherwise, zero
+        static_assert(is_same_v<_Iter_value_t<_FwdIt2>, value_type>, "bad _FwdIt2 to _Iter_compare");
+
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        auto _UFirst1 = _Get_unwrapped(_First1);
+        auto _ULast1  = _Get_unwrapped(_Last1);
+        auto _UFirst2 = _Get_unwrapped(_First2);
+        auto _ULast2  = _Get_unwrapped(_Last2);
+
+        if constexpr (is_pointer_v<decltype(_UFirst1)> && is_pointer_v<decltype(_UFirst2)>) {
+            return _Traits_compare<char_traits<value_type>>(
+                _UFirst1, static_cast<size_t>(_ULast1 - _UFirst1), _UFirst2, static_cast<size_t>(_ULast2 - _UFirst2));
+        } else {
+            const auto _Cmp = _STD mismatch(_UFirst1, _ULast1, _UFirst2, _ULast2, _Std_char_traits_eq<value_type>{});
+
+            if (_Cmp.first == _ULast1) {
+                if (_Cmp.second == _ULast2) {
+                    return 0;
+                } else {
+                    return -1;
+                }
+            }
+
+            if (_Cmp.second == _ULast2) {
+                return 1;
+            }
+
+            if (char_traits<value_type>::lt(*_Cmp.first, *_Cmp.second)) {
+                return -1;
+            } else {
+                return 1;
+            }
+        }
+    }
+
+    int _Compare(const value_type* const _Ptr, const size_t _Count) const {
+        // compare *this to array [_Ptr, _Ptr + _Count)
+        const _Mybase _Range(_Effective_range());
+        return _Iter_compare(_Range.first, _Range.second, _Ptr, _Ptr + _Count);
+    }
+
+    bool _Match_equal(const sub_match& _Right) const { // check *this to _Right for equality
+        const _Mybase _LRange(_Effective_range());
+        const _Mybase _RRange(_Right._Effective_range());
+        return _STD equal(
+            _LRange.first, _LRange.second, _RRange.first, _RRange.second, _Std_char_traits_eq<value_type>{});
+    }
+
+    bool _Match_equal(const value_type* const _Ptr, const size_t _Count) const {
+        // check *this to array [_Ptr, _Ptr + _Count) for equality
+        const _Mybase _Range(_Effective_range());
+        return _STD equal(_Range.first, _Range.second, _Ptr, _Ptr + _Count, _Std_char_traits_eq<value_type>{});
+    }
+
+    bool _Match_equal(const value_type* const _Ptr) const { // check *this to C-string _Ptr for equality
+        return _Match_equal(_Ptr, char_traits<value_type>::length(_Ptr));
+    }
+
+    bool _Less(const sub_match& _Right) const { // check whether *this is less than _Right
+        const _Mybase _LRange(_Effective_range());
+        const _Mybase _RRange(_Right._Effective_range());
+        return _STD lexicographical_compare(
+            _LRange.first, _LRange.second, _RRange.first, _RRange.second, _Std_char_traits_lt<value_type>{});
+    }
+
+    bool _Less(const value_type* const _Ptr, const size_t _Count) const {
+        // check whether *this is less than [_Ptr, _Ptr + _Count)
+        const _Mybase _Range(_Effective_range());
+        return _STD lexicographical_compare(
+            _Range.first, _Range.second, _Ptr, _Ptr + _Count, _Std_char_traits_lt<value_type>{});
+    }
+
+    bool _Less(const value_type* const _Ptr) const { // check whether *this is less than C-string _Ptr
+        return _Less(_Ptr, char_traits<value_type>::length(_Ptr));
+    }
+
+    bool _Greater(const value_type* const _Ptr, const size_t _Count) const {
+        // check whether *this is greater than [_Ptr, _Ptr + _Count)
+        const _Mybase _Range(_Effective_range());
+        return _STD lexicographical_compare(
+            _Ptr, _Ptr + _Count, _Range.first, _Range.second, _Std_char_traits_lt<value_type>{});
+    }
+
+    bool _Greater(const value_type* const _Ptr) const { // check whether *this is greater than C-string _Ptr
+        return _Greater(_Ptr, char_traits<value_type>::length(_Ptr));
+    }
+
+    _Mybase _Effective_range() const { // if matched, returns *this; otherwise returns an empty range
+        if (matched) {
+            return *this;
+        } else {
+            return _Mybase{};
+        }
+    }
+};
+
+_EXPORT_STD using csub_match  = sub_match<const char*>;
+_EXPORT_STD using wcsub_match = sub_match<const wchar_t*>;
+_EXPORT_STD using ssub_match  = sub_match<string::const_iterator>;
+_EXPORT_STD using wssub_match = sub_match<wstring::const_iterator>;
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD bool operator==(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Left._Match_equal(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _BidIt>
+_NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    using _Comparison_category = _Get_comparison_category_t<char_traits<_Iter_value_t<_BidIt>>>;
+    return static_cast<_Comparison_category>(_Left.compare(_Right) <=> 0);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _BidIt>
+_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Left._Less(_Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD bool operator==(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
+    return _Left._Match_equal(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _BidIt>
+_NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
+    using _Comparison_category = _Get_comparison_category_t<char_traits<_Iter_value_t<_BidIt>>>;
+    return static_cast<_Comparison_category>(_Left.compare(_Right) <=> 0);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _BidIt>
+_NODISCARD bool operator==(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
+    return _Right._Match_equal(_Left);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator!=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
+    return _Right._Greater(_Left);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>=(const _Iter_value_t<_BidIt>* _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Left < _Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
+    return _Left._Less(_Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
+    return _Right < _Left;
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD bool operator==(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
+    return _Left._Match_equal(_STD addressof(_Right), 1);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _BidIt>
+_NODISCARD auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
+    using _Comparison_category = _Get_comparison_category_t<char_traits<_Iter_value_t<_BidIt>>>;
+    return static_cast<_Comparison_category>(_Left._Compare(_STD addressof(_Right), 1) <=> 0);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _BidIt>
+_NODISCARD bool operator==(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Right._Match_equal(_STD addressof(_Left), 1);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator!=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Right._Greater(_STD addressof(_Left), 1);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>=(const _Iter_value_t<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Left < _Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator!=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
+    return _Left._Less(_STD addressof(_Right), 1);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _BidIt>
+_NODISCARD bool operator<=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _BidIt>
+_NODISCARD bool operator>=(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator==(
+    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
+    return _Left._Match_equal(_Right.data(), _Right.size());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD auto operator<=>(
+    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
+    using _Comparison_category = _Get_comparison_category_t<char_traits<_Iter_value_t<_BidIt>>>;
+    return static_cast<_Comparison_category>(_Left._Compare(_Right.data(), _Right.size()) <=> 0);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator==(
+    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Right._Match_equal(_Left.data(), _Left.size());
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator!=(
+    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator<(
+    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Right._Greater(_Left.data(), _Left.size());
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator>(
+    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator<=(
+    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator>=(
+    const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Left, const sub_match<_BidIt>& _Right) {
+    return !(_Left < _Right);
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator!=(
+    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator<(
+    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
+    return _Left._Less(_Right.data(), _Right.size());
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator>(
+    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator<=(
+    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _BidIt, class _Traits, class _Alloc>
+_NODISCARD bool operator>=(
+    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Elem, class _Traits, class _BidIt>
+basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const sub_match<_BidIt>& _Match) {
+    return _Ostr << _Match.str();
+}
+
+_EXPORT_STD template <class _BidIt, class _Alloc = allocator<sub_match<_BidIt>>>
+class match_results;
+
+template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
+_OutIt _Format_default(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
+    regex_constants::match_flag_type _Flags = regex_constants::format_default);
+
+template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
+_OutIt _Format_sed(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
+    regex_constants::match_flag_type _Flags = regex_constants::format_default);
+
+_EXPORT_STD template <class _BidIt, class _Alloc>
+class match_results { // class to hold contents of all capture groups
+public:
+    using _Elem     = sub_match<_BidIt>;
+    using _MyCont   = vector<_Elem, _Alloc>;
+    using _Mytraits = allocator_traits<_Alloc>;
+
+    using value_type      = _Elem;
+    using const_reference = const value_type&;
+    using reference       = value_type&;
+    using const_iterator  = typename _MyCont::const_iterator;
+    using iterator        = const_iterator;
+    using difference_type = typename iterator_traits<_BidIt>::difference_type;
+    using size_type       = typename _Mytraits::size_type;
+    using allocator_type  = _Alloc;
+    using char_type       = typename iterator_traits<_BidIt>::value_type;
+    using string_type     = basic_string<char_type>;
+
+    match_results() = default;
+
+    explicit match_results(const _Alloc& _Al) : _Matches(_Al) {}
+
+    match_results(const match_results& _Other, const _Alloc& _Al)
+        : _Org(_Other._Org), _Ready(_Other._Ready), _Matches(_Other._Matches, _Al), _Prefix(_Other._Prefix),
+          _Suffix(_Other._Suffix), _Null_elem(_Other._Null_elem) {}
+
+    match_results(match_results&& _Other, const _Alloc& _Al) noexcept(
+        conjunction_v<typename _Mytraits::is_always_equal, is_nothrow_move_constructible<_BidIt>>) // strengthened
+        : _Org(_STD move(_Other._Org)), _Ready(_Other._Ready), _Matches(_STD move(_Other._Matches), _Al),
+          _Prefix(_STD move(_Other._Prefix)), _Suffix(_STD move(_Other._Suffix)),
+          _Null_elem(_STD move(_Other._Null_elem)) {}
+
+    _NODISCARD bool ready() const noexcept /* strengthened */ {
+        return _Ready;
+    }
+
+    _NODISCARD size_type size() const noexcept /* strengthened */ {
+        return _Matches.size();
+    }
+
+    _NODISCARD size_type max_size() const noexcept /* strengthened */ {
+        return _Matches.max_size();
+    }
+
+    _NODISCARD bool empty() const noexcept /* strengthened */ {
+        return _Matches.empty();
+    }
+
+    _NODISCARD difference_type length(size_type _Sub = 0) const {
+        return (*this)[_Sub].length();
+    }
+
+    _NODISCARD difference_type position(size_type _Sub = 0) const {
+        return _STD distance(_Org, (*this)[_Sub].first);
+    }
+
+    _NODISCARD string_type str(size_type _Sub = 0) const {
+        return string_type{(*this)[_Sub]};
+    }
+
+    _NODISCARD const_reference operator[](size_type _Sub) const noexcept /* strengthened */ {
+        return _Matches.size() <= _Sub ? _Null_elem : _Matches[_Sub];
+    }
+
+    _NODISCARD const_reference prefix() const noexcept /* strengthened */ {
+        return _Prefix;
+    }
+
+    _NODISCARD const_reference suffix() const noexcept /* strengthened */ {
+        return _Suffix;
+    }
+
+    _NODISCARD const_iterator begin() const noexcept /* strengthened */ {
+        return _Matches.begin();
+    }
+
+    _NODISCARD const_iterator end() const noexcept /* strengthened */ {
+        return _Matches.end();
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept /* strengthened */ {
+        return _Matches.begin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept /* strengthened */ {
+        return _Matches.end();
+    }
+
+    const _Elem* _Unchecked_begin() const noexcept {
+        return _Matches._Unchecked_begin();
+    }
+
+    const _Elem* _Unchecked_end() const noexcept {
+        return _Matches._Unchecked_end();
+    }
+
+    template <class _OutIt>
+    _OutIt _Format1(_OutIt _Out, const char_type* _Fmt_begin, const char_type* _Fmt_end,
+        regex_constants::match_flag_type _Flags) const { // format text, replacing matches
+        return _Flags & regex_constants::format_sed ? _Format_sed(*this, _Out, _Fmt_begin, _Fmt_end, _Flags)
+                                                    : _Format_default(*this, _Out, _Fmt_begin, _Fmt_end, _Flags);
+    }
+
+    template <class _OutIt>
+    _OutIt format(_OutIt _Out, const char_type* _Fmt_begin, const char_type* _Fmt_end,
+        regex_constants::match_flag_type _Flags = regex_constants::format_default) const {
+        // format text, replacing matches
+        _Adl_verify_range(_Fmt_begin, _Fmt_end);
+        _Seek_wrapped(_Out, _Format1(_Get_unwrapped_unverified(_Out), _Fmt_begin, _Fmt_end, _Flags));
+        return _Out;
+    }
+
+    template <class _OutIt, class _Traits1, class _Alloc1>
+    _OutIt format(_OutIt _Out, const basic_string<char_type, _Traits1, _Alloc1>& _Fmt,
+        regex_constants::match_flag_type _Flags = regex_constants::format_default) const {
+        // format text, replacing matches
+        _Seek_wrapped(_Out, _Format1(_Get_unwrapped_unverified(_Out), _Fmt.data(), _Fmt.data() + _Fmt.size(), _Flags));
+        return _Out;
+    }
+
+    template <class _Traits1, class _Alloc1>
+    _NODISCARD basic_string<char_type, _Traits1, _Alloc1> format(const basic_string<char_type, _Traits1, _Alloc1>& _Fmt,
+        regex_constants::match_flag_type _Flags = regex_constants::format_default) const {
+        // format text, replacing matches
+        basic_string<char_type, _Traits1, _Alloc1> _Str;
+        format(_STD back_inserter(_Str), _Fmt.data(), _Fmt.data() + _Fmt.size(), _Flags);
+        return _Str;
+    }
+
+    _NODISCARD string_type format(
+        const char_type* _Fmt_begin, regex_constants::match_flag_type _Flags = regex_constants::format_default) const {
+        // format text, replacing matches
+        return format(static_cast<string_type>(_Fmt_begin), _Flags);
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept /* strengthened */ {
+        return static_cast<allocator_type>(_Matches.get_allocator());
+    }
+
+    void swap(match_results& _Right) noexcept(_Is_nothrow_swappable<_BidIt>::value) /* strengthened */ {
+        using _STD swap;
+        _STD swap(_Ready, _Right._Ready);
+        swap(_Org, _Right._Org); // intentional ADL
+        _Matches.swap(_Right._Matches);
+        _STD swap(_Prefix, _Right._Prefix);
+        _STD swap(_Suffix, _Right._Suffix);
+    }
+
+    void _Resize(unsigned int _Nx) {
+        _Matches.resize(_Nx);
+    }
+
+    _Elem& _Pfx() noexcept {
+        return _Prefix;
+    }
+
+    _Elem& _Sfx() noexcept {
+        return _Suffix;
+    }
+
+    _Elem& _Null() noexcept {
+        return _Null_elem;
+    }
+
+    _Elem& _At(unsigned int _Sub) noexcept {
+        return _Matches[_Sub];
+    }
+
+    _Elem _At(unsigned int _Sub) const noexcept {
+        return _Matches[_Sub];
+    }
+
+    _BidIt _Org = _BidIt();
+    bool _Ready = false;
+
+private:
+    _MyCont _Matches;
+    _Elem _Prefix;
+    _Elem _Suffix;
+    _Elem _Null_elem;
+};
+
+_EXPORT_STD template <class _BidIt, class _Alloc>
+_NODISCARD bool operator==(const match_results<_BidIt, _Alloc>& _Left, const match_results<_BidIt, _Alloc>& _Right) {
+    if (!_Left.ready() && !_Right.ready()) {
+        return true;
+    } else if (!_Left.ready() || !_Right.ready()) {
+        return false;
+    } else if (_Left.empty() && _Right.empty()) {
+        return true;
+    } else if (_Left.empty() || _Right.empty()) {
+        return false;
+    } else {
+        return _Left.size() == _Right.size() && _Left.prefix() == _Right.prefix() && _Left.suffix() == _Right.suffix()
+            && _STD equal(_Left.begin(), _Left.end(), _Right.begin());
+    }
+}
+
+#if !_HAS_CXX20
+template <class _BidIt, class _Alloc>
+_NODISCARD bool operator!=(const match_results<_BidIt, _Alloc>& _Left, const match_results<_BidIt, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_INLINE_VAR constexpr unsigned int _Bmp_max   = 256U; // must fit in an unsigned int
+_INLINE_VAR constexpr unsigned int _Bmp_shift = 3U;
+_INLINE_VAR constexpr unsigned int _Bmp_chrs  = 1U << _Bmp_shift; // # of bits to be stored in each char
+_INLINE_VAR constexpr unsigned int _Bmp_mask  = _Bmp_chrs - 1U;
+_INLINE_VAR constexpr unsigned int _Bmp_size  = (_Bmp_max + _Bmp_chrs - 1U) / _Bmp_chrs;
+
+_INLINE_VAR constexpr unsigned int _ARRAY_THRESHOLD = 4U;
+
+enum _Node_flags : int { // flags for nfa nodes with special properties
+    _Fl_none              = 0x0000,
+    _Fl_negate            = 0x0001,
+    _Fl_greedy            = 0x0002,
+    _Fl_longest           = 0x0008, // TRANSITION, ABI: 0x004 is unused; the parser previously marked some nodes with it
+    _Fl_class_negated_w   = 0x0100,
+    _Fl_class_negated_s   = 0x0200,
+    _Fl_class_negated_d   = 0x0400,
+    _Fl_class_cl_all_bits = 0x0800, // TRANSITION, ABI: GH-5242
+    _Fl_begin_needs_w     = 0x0100,
+    _Fl_begin_needs_s     = 0x0200,
+    _Fl_begin_needs_d     = 0x0400,
+    _Fl_rep_branchless    = 0x1000,
+};
+
+_BITMASK_OPS(_EMPTY_ARGUMENT, _Node_flags)
+
+enum _Node_type { // type flag for nfa nodes
+    _N_none,
+    _N_nop, // TRANSITION, ABI: preserved for binary compatibility, the parser no longer generates _N_nop nodes
+    _N_bol,
+    _N_eol,
+    _N_wbound,
+    _N_dot,
+    _N_str,
+    _N_class,
+    _N_group,
+    _N_end_group,
+    _N_assert,
+    _N_neg_assert,
+    _N_end_assert,
+    _N_capture,
+    _N_end_capture,
+    _N_back,
+    _N_if,
+    _N_endif,
+    _N_rep,
+    _N_end_rep,
+    _N_begin,
+    _N_end
+};
+
+template <class _Elem>
+struct _Buf { // character buffer
+    _Buf() = default;
+
+    ~_Buf() noexcept {
+        _CSTD free(_Chrs);
+    }
+
+    unsigned int _Size() const noexcept {
+        return _Nchrs;
+    }
+
+    _Elem _At(unsigned int _Idx) const {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Idx < _Nchrs, "regex buffer subscript out of range");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Chrs[_Idx];
+    }
+
+    const _Elem* _Str() const {
+        return _Chrs;
+    }
+
+    void _Insert2(_Elem _Ch) { // append _Ch
+        if (_Sz <= _Nchrs) {
+            _Expand2(1U);
+        }
+
+        _Chrs[_Nchrs++] = _Ch;
+    }
+
+    _Elem _Del() noexcept { // remove and return last character
+        return _Chrs[--_Nchrs];
+    }
+
+    template <class _FwdIt>
+    void _Insert2(_FwdIt _First, _FwdIt _Last) { // append multiple characters
+        while (_First != _Last) {
+            _Insert2(*_First++);
+        }
+    }
+
+private:
+    unsigned int _Calculate_expansion(unsigned int _Increase) const {
+        constexpr size_t _Max_elems      = static_cast<size_t>(-1) / sizeof(_Elem);
+        constexpr unsigned int _Max_uint = static_cast<unsigned int>(-1);
+        constexpr unsigned int _Max      = _Max_elems < _Max_uint ? static_cast<unsigned int>(_Max_elems) : _Max_uint;
+
+        constexpr unsigned int _Buf_incr = 16U;
+
+        if (_Increase < _Buf_incr) {
+            _Increase = _Buf_incr;
+        }
+
+        if (_Increase < (_Sz >> 1)) {
+            _Increase = _Sz >> 1;
+        }
+
+        if (_Max <= _Increase || _Max - _Increase <= _Sz) {
+            return _Max;
+        }
+
+        return _Sz + _Increase;
+    }
+
+    void _Expand2(const unsigned int _Min_increase) { // expand buffer by at least _Min_increase
+        const unsigned int _Len = _Calculate_expansion(_Min_increase);
+        if (_Len - _Sz < _Min_increase) {
+            _Xregex_error(regex_constants::error_space);
+        }
+        _Elem* _Tmp = static_cast<_Elem*>(_CSTD realloc(_Chrs, sizeof(_Elem) * static_cast<size_t>(_Len)));
+        if (!_Tmp) {
+            _Xregex_error(regex_constants::error_space);
+        }
+
+        _Chrs = _Tmp;
+        _Sz   = _Len;
+    }
+
+    unsigned int _Sz    = 0;
+    unsigned int _Nchrs = 0;
+    _Elem* _Chrs        = nullptr;
+};
+
+struct _Bitmap { // accelerator table for small character values
+    _Bitmap() = default;
+
+    template <class _Elem>
+    void _Mark(_Elem _Ch) noexcept { // mark character _Ch
+        static_assert(is_unsigned_v<_Elem>, "_Elem must be unsigned");
+        unsigned int _Wide = _Ch;
+        _Chrs[_Wide >> _Bmp_shift] |= (1 << (_Wide & _Bmp_mask));
+    }
+
+    template <class _Elem>
+    bool _Find(_Elem _Ch) const noexcept {
+        static_assert(is_unsigned_v<_Elem>, "_Elem must be unsigned");
+        unsigned int _Wide = _Ch;
+        return (_Chrs[_Wide >> _Bmp_shift] & (1 << (_Wide & _Bmp_mask))) != 0;
+    }
+
+private:
+    unsigned char _Chrs[_Bmp_size]{};
+};
+
+template <class _Elem>
+struct _Sequence { // holds sequences of _Sz elements
+    explicit _Sequence(unsigned int _Len) noexcept : _Sz(_Len) {}
+
+    unsigned int _Sz;
+    _Buf<_Elem> _Data;
+    _Sequence* _Next = nullptr;
+};
+
+class _Node_base { // base class for all nfa nodes
+public:
+    explicit _Node_base(_Node_type _Ty, _Node_flags _Fl = _Fl_none) noexcept : _Kind(_Ty), _Flags(_Fl) {}
+
+    _Node_type _Kind;
+    _Node_flags _Flags;
+    _Node_base* _Next = nullptr;
+    _Node_base* _Prev = nullptr;
+
+    virtual ~_Node_base() noexcept {}
+};
+
+inline void _Destroy_node(_Node_base* _Nx, _Node_base* _Ne = nullptr) noexcept { // destroy sublist of nodes
+    while (_Nx != _Ne && _Nx) { // destroy node
+        _Node_base* _Tmp = _Nx;
+        _Nx              = _Nx->_Next;
+        _Tmp->_Next      = nullptr;
+        delete _Tmp;
+    }
+}
+
+class _Root_node : public _Node_base { // root of parse tree
+public:
+    _Root_node() noexcept : _Node_base(_N_begin) {
+        static_assert(sizeof(_Refs) == sizeof(_Atomic_counter_t), "invalid _Refs size");
+    }
+
+    regex_constants::syntax_option_type _Fl{};
+    unsigned int _Loops = 0;
+    unsigned int _Marks = 0;
+    unsigned int _Refs  = 0;
+};
+
+class _Node_end_group : public _Node_base { // node that marks end of a group
+public:
+    _Node_end_group(_Node_type _Ty, _Node_flags _Fl, _Node_base* _Bx) noexcept : _Node_base(_Ty, _Fl), _Back(_Bx) {}
+
+    _Node_base* _Back;
+};
+
+class _Node_assert : public _Node_base { // node that holds an ECMAScript assertion
+public:
+    explicit _Node_assert(_Node_type _Ty, _Node_flags _Fl = _Fl_none) noexcept : _Node_base(_Ty, _Fl) {}
+
+    ~_Node_assert() noexcept {
+        _Destroy_node(_Child);
+    }
+
+    _Node_base* _Child = nullptr;
+};
+
+class _Node_capture : public _Node_base { // node that marks beginning of a capture group
+public:
+    explicit _Node_capture(unsigned int _Ix) noexcept : _Node_base(_N_capture, _Fl_none), _Idx(_Ix) {}
+
+    unsigned int _Idx;
+};
+
+class _Node_back : public _Node_base { // node that holds a back reference
+public:
+    explicit _Node_back(unsigned int _Ix) noexcept : _Node_base(_N_back, _Fl_none), _Idx(_Ix) {}
+
+    unsigned int _Idx;
+};
+
+template <class _Elem>
+class _Node_str : public _Node_base { // node that holds text
+public:
+    explicit _Node_str(_Node_flags _Fl = _Fl_none) noexcept : _Node_base(_N_str, _Fl) {}
+
+    _Buf<_Elem> _Data;
+};
+
+template <class _Elem, class _RxTraits>
+class _Node_class : public _Node_base { // node that holds a character class (POSIX bracket expression)
+public:
+    explicit _Node_class(_Node_type _Ty = _N_class, _Node_flags _Fl = _Fl_none) noexcept : _Node_base(_Ty, _Fl) {}
+
+    ~_Node_class() noexcept {
+        _Tidy(_Coll);
+        delete _Small;
+        delete _Large;
+        delete _Ranges;
+        _Tidy(_Equiv);
+    }
+
+    void _Tidy(_Sequence<_Elem>* _Head) noexcept { // clean up a list of sequences
+        while (_Head) { // delete the head of the list
+            _Sequence<_Elem>* _Temp = _Head;
+            _Head                   = _Head->_Next;
+            delete _Temp;
+        }
+    }
+
+    _Sequence<_Elem>* _Coll = nullptr;
+    _Bitmap* _Small         = nullptr;
+    _Buf<_Elem>* _Large     = nullptr;
+    _Buf<_Elem>* _Ranges    = nullptr;
+    typename _RxTraits::char_class_type _Classes{};
+    _Sequence<_Elem>* _Equiv = nullptr;
+};
+
+class _Node_endif : public _Node_base { // node that marks the end of an alternative
+public:
+    _Node_endif() noexcept : _Node_base(_N_endif, _Fl_none) {}
+};
+
+class _Node_if : public _Node_base { // node that marks the beginning of an alternative
+public:
+    explicit _Node_if(_Node_base* _End) noexcept
+        : _Node_base(_N_if, _Fl_none), _Endif(static_cast<_Node_endif*>(_End)) {}
+
+    ~_Node_if() noexcept {
+        _Node_if* _Cur = _Child;
+        while (_Cur) { // destroy branch
+            _Node_if* _Tmp = _Cur;
+            _Cur           = _Cur->_Child;
+            _Tmp->_Child   = nullptr;
+            _Destroy_node(_Tmp, _Endif);
+        }
+    }
+
+    _Node_endif* _Endif;
+    _Node_if* _Child = nullptr;
+};
+
+class _Node_rep;
+
+class _Node_end_rep : public _Node_base { // node that marks the end of a repetition
+public:
+    _Node_end_rep() noexcept : _Node_base(_N_end_rep) {}
+
+    _Node_rep* _Begin_rep = nullptr;
+
+    _Node_end_rep& operator=(const _Node_end_rep&) = delete;
+};
+
+template <class _Diff>
+struct _Loop_vals_v3_t { // storage for loop administration
+    size_t _Loop_frame_idx    = 0;
+    int _Loop_idx             = 0;
+    unsigned int _Group_first = 0;
+    _Diff _Loop_length{};
+};
+
+class _Node_rep : public _Node_base { // node that marks the beginning of a repetition
+public:
+    _Node_rep(bool _Greedy, int _Min_, int _Max_, _Node_end_rep* _End, unsigned int _Number) noexcept
+        : _Node_base(_N_rep, _Greedy ? _Fl_greedy : _Fl_none), _Min(_Min_), _Max(_Max_), _End_rep(_End),
+          _Loop_number(_Number) {}
+
+    const int _Min;
+    const int _Max; // non-negative if bounded, -1 if unbounded
+    _Node_end_rep* _End_rep;
+    unsigned int _Loop_number;
+    int _Simple_loop = -1; // -1 undetermined, 0 contains if/do, 1 simple
+
+    _Node_rep& operator=(const _Node_rep&) = delete;
+};
+
+enum class _Rx_char_class_kind : int { // must be aligned with corresponding _Node_flags
+    _Positive  = 0,
+    _Negated_w = _Fl_class_negated_w,
+    _Negated_s = _Fl_class_negated_s,
+    _Negated_d = _Fl_class_negated_d
+};
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+class _Builder2 { // provides operations used by _Parser2 to build the nfa
+public:
+    _Builder2(const _RxTraits& _Tr, regex_constants::syntax_option_type);
+    void _Setlong();
+    void _Tidy() noexcept;
+    _Node_base* _Getmark() const;
+
+    void _Add_bol();
+    void _Add_eol();
+    void _Add_wbound();
+    void _Add_dot();
+    void _Add_char(_Elem _Ch);
+    void _Add_class();
+    void _Add_char_to_class(_Elem _Ch);
+    void _Add_range(_Elem, _Elem);
+    void _Add_named_class(typename _RxTraits::char_class_type, _Rx_char_class_kind);
+    void _Add_equiv(const _Elem*, const _Elem*);
+    void _Add_coll(const _Elem*, const _Elem*);
+    _Node_base* _Begin_group();
+    void _End_group(_Node_base* _Back);
+    _Node_assert* _Begin_assert_group2(bool _Neg);
+    void _End_assert_group2(_Node_assert* _Assert_start);
+    _Node_base* _Begin_capture_group(unsigned int _Idx);
+    void _Add_backreference(unsigned int _Idx);
+    _Node_base* _Begin_if(_Node_base* _Start);
+    void _Else_if2(_Node_base*, _Node_base*);
+    void _Add_rep(int _Min, int _Max, bool _Greedy);
+    void _Negate();
+    _Root_node* _End_pattern();
+
+private:
+    _Node_base* _Link_node(_Node_base*);
+    static void _Insert_node(_Node_base*, _Node_base*);
+    _Node_base* _New_node(_Node_type _Kind);
+    void _Add_str_node();
+    void _Add_char_to_bitmap(unsigned char _Ch);
+    void _Add_char_to_array(_Elem _Ch);
+    void _Add_elts(_Node_class<_Elem, _RxTraits>*, typename _RxTraits::char_class_type, bool);
+    void _Char_to_elts(const _Elem*, const _Elem*, _Sequence<_Elem>**);
+
+    _Root_node* _Root;
+    _Node_base* _Current;
+    regex_constants::syntax_option_type _Flags;
+    const _RxTraits& _Traits;
+
+public:
+    _Builder2(const _Builder2&)            = delete;
+    _Builder2& operator=(const _Builder2&) = delete;
+};
+
+template <class _Ty, class _Alloc = allocator<_Ty>>
+class _Rx_fixed_size_buffer {
+public:
+    using _Al_pointer       = _Alloc_ptr_t<_Alloc>;
+    using _Al_const_pointer = typename allocator_traits<_Alloc>::const_pointer;
+
+private:
+    using _Al_size_type = _Alloc_size_t<_Alloc>;
+
+    struct _Buffer_range {
+        _Al_pointer _First{};
+        _Al_pointer _Last{};
+        bool _Allocated{false};
+    };
+
+public:
+    explicit _Rx_fixed_size_buffer(const _Alloc& _Al = _Alloc{}) : _Mypair(_One_then_variadic_args_t{}, _Al) {}
+
+    _Rx_fixed_size_buffer(const _Rx_fixed_size_buffer&)            = delete;
+    _Rx_fixed_size_buffer(_Rx_fixed_size_buffer&&)                 = delete;
+    _Rx_fixed_size_buffer& operator=(const _Rx_fixed_size_buffer&) = delete;
+    _Rx_fixed_size_buffer& operator=(_Rx_fixed_size_buffer&&)      = delete;
+
+    void _Initialize(void*& _Stack_buf, size_t& _Stack_size, const size_t _Size) {
+        if (_Size == 0U) {
+            return; // nothing to do
+        }
+
+        const auto _Bytes = _Size * sizeof(_Ty);
+
+        if (_STD align(alignof(_Ty), _Bytes, _Stack_buf, _Stack_size)) {
+            _Use_external_buf(_Stack_buf, _Size);
+
+            _Stack_buf = static_cast<unsigned char*>(_Stack_buf) + _Bytes;
+            _Stack_size -= _Bytes;
+        } else {
+            _Allocate_buf(_Size);
+        }
+    }
+
+    ~_Rx_fixed_size_buffer() {
+        auto& _Data = _Mypair._Myval2;
+        if (_Data._Allocated) {
+            auto& _Al = _Mypair._Get_first();
+            _STD _Destroy_range(_Data._First, _Data._Last, _Al);
+            _Al.deallocate(_Data._First, static_cast<_Al_size_type>(_Data._Last - _Data._First));
+        } else {
+            _STD _Destroy_range(_Data._First, _Data._Last);
+        }
+    }
+
+    _NODISCARD _Ty& operator[](const size_t _Pos) {
+        auto& _Data = _Mypair._Myval2;
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(
+            _Pos < static_cast<size_t>(_Data._Last - _Data._First), "_Rx_fixed_size_buffer subscript out of range");
+#endif
+        return _Data._First[_Pos];
+    }
+
+    _NODISCARD const _Ty& operator[](const size_t _Pos) const {
+        auto& _Data = _Mypair._Myval2;
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(
+            _Pos < static_cast<size_t>(_Data._Last - _Data._First), "_Rx_fixed_size_buffer subscript out of range");
+#endif
+        return _Data._First[_Pos];
+    }
+
+    _NODISCARD _Al_pointer _Begin() {
+        return _Mypair._Myval2._First;
+    }
+
+    _NODISCARD _Al_const_pointer _Begin() const {
+        return _Mypair._Myval2._First;
+    }
+
+    _NODISCARD _Al_pointer _End() {
+        return _Mypair._Myval2._Last;
+    }
+
+    _NODISCARD _Al_const_pointer _End() const {
+        return _Mypair._Myval2._Last;
+    }
+
+    _NODISCARD size_t _Size() const {
+        auto& _Data = _Mypair._Myval2;
+        return static_cast<size_t>(_Data._Last - _Data._First);
+    }
+
+private:
+    void _Use_external_buf(void* _Buf, size_t _Ty_size) {
+        auto _Ty_first = _STD _Refancy<_Al_pointer>(reinterpret_cast<_Ty*>(_Buf));
+        auto _Ty_last  = _Ty_first + _Ty_size;
+        auto& _Data    = _Mypair._Myval2;
+        _STD uninitialized_fill(_Ty_first, _Ty_last, _Ty{}); // uninitialized_value_construct() is C++17
+        _Data._Allocated = false;
+        _Data._First     = _Ty_first;
+        _Data._Last      = _Ty_last;
+    }
+
+    void _Allocate_buf(size_t _Ty_size) {
+        auto& _Al = _Mypair._Get_first();
+
+        if (_Ty_size > size_t{PTRDIFF_MAX} || _Ty_size > allocator_traits<_Alloc>::max_size(_Al)) {
+            _Xregex_error(regex_constants::error_stack);
+        }
+
+        auto _Al_size  = static_cast<_Al_size_type>(_Ty_size);
+        auto _Ty_first = _Al.allocate(_Al_size);
+        _Allocation_guard<_Alloc> _Guard{_Al, _Ty_first, _Al_size};
+        auto& _Data      = _Mypair._Myval2;
+        _Data._Last      = _STD _Uninitialized_value_construct_n(_Ty_first, _Ty_size, _Al);
+        _Data._Allocated = true;
+        _Data._First     = _Ty_first;
+        _Guard._Ptr      = nullptr;
+    }
+
+    _Compressed_pair<_Alloc, _Buffer_range> _Mypair;
+};
+
+using _Rx_bitset_int_type = size_t;
+
+template <class _Alloc = allocator<bool>>
+class _Rx_fixed_size_bitset {
+private:
+    static constexpr size_t _Bits = sizeof(_Rx_bitset_int_type) * CHAR_BIT;
+
+    using _Buffer_type = _Rx_fixed_size_buffer<_Rx_bitset_int_type, _Rebind_alloc_t<_Alloc, _Rx_bitset_int_type>>;
+
+public:
+    explicit _Rx_fixed_size_bitset(const _Alloc& _Al) : _Buffer(_Al) {}
+
+    void _Initialize(void*& _Stack_buf, size_t& _Stack_size, const size_t _Bit_size) {
+        const auto _Word_size = _Bit_size / _Bits + (_Bit_size % _Bits != 0U);
+        _Buffer._Initialize(_Stack_buf, _Stack_size, _Word_size);
+    }
+
+    _NODISCARD bool _Get(const size_t _Pos) const {
+        return (_Buffer[_Pos / _Bits] & static_cast<_Rx_bitset_int_type>(_Rx_bitset_int_type{1} << (_Pos % _Bits)))
+            != _Rx_bitset_int_type{};
+    }
+
+    void _Clear(const size_t _Pos) {
+        _Buffer[_Pos / _Bits] &= static_cast<_Rx_bitset_int_type>(~(_Rx_bitset_int_type{1} << (_Pos % _Bits)));
+    }
+
+    void _Set(const size_t _Pos) {
+        _Buffer[_Pos / _Bits] |= static_cast<_Rx_bitset_int_type>(_Rx_bitset_int_type{1} << (_Pos % _Bits));
+    }
+
+    void _Clear_range_at_least_until(const size_t _First, const size_t _Last) {
+        if (_First < _Last) {
+            size_t _Buffer_first      = _First / _Bits;
+            const size_t _Buffer_last = _Last / _Bits + (_Last % _Bits != 0U);
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(_Buffer_last <= _Buffer._Size(), "_Rx_fixed_size_bitset subscript out of range");
+#endif
+
+            _Buffer[_Buffer_first] &=
+                static_cast<_Rx_bitset_int_type>((_Rx_bitset_int_type{1} << (_First % _Bits)) - 1U);
+
+            ++_Buffer_first;
+            if (_Buffer_first < _Buffer_last) {
+                auto _Begin = _Buffer._Begin();
+                _STD fill(_Begin + static_cast<ptrdiff_t>(_Buffer_first), _Begin + static_cast<ptrdiff_t>(_Buffer_last),
+                    _Rx_bitset_int_type{});
+            }
+        }
+    }
+
+    _NODISCARD typename _Buffer_type::_Al_pointer _Buffer_begin() {
+        return _Buffer._Begin();
+    }
+
+    _NODISCARD typename _Buffer_type::_Al_const_pointer _Buffer_begin() const {
+        return _Buffer._Begin();
+    }
+
+    _NODISCARD typename _Buffer_type::_Al_pointer _Buffer_end() {
+        return _Buffer._End();
+    }
+
+    _NODISCARD typename _Buffer_type::_Al_const_pointer _Buffer_end() const {
+        return _Buffer._End();
+    }
+
+private:
+    _Buffer_type _Buffer;
+};
+
+template <class _BidIt>
+struct _Rx_capture_range_t { // stores a pair of iterators
+    _BidIt _Begin{};
+    _BidIt _End{};
+};
+
+template <class _BidIt, class _Alloc>
+class _Tgt_state_v2_t { // holds the current state of the match
+public:
+    explicit _Tgt_state_v2_t(const _Alloc& _Al = _Alloc()) : _Grps(_Al), _Grp_valid(_Al) {}
+
+    void _Copy_from(const _Tgt_state_v2_t& _Source) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Source._Grps._End() - _Source._Grps._Begin() == _Grps._End() - _Grps._Begin(),
+            "Source and destination must have same amount of storage for capture group ranges");
+        _STL_VERIFY(_Source._Grp_valid._Buffer_end() - _Source._Grp_valid._Buffer_begin()
+                        == _Grp_valid._Buffer_end() - _Grp_valid._Buffer_begin(),
+            "Source and destination must have same amount of storage for capture group validity markers");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        _Cur = _Source._Cur;
+        _STD copy(_Source._Grps._Begin(), _Source._Grps._End(), _Grps._Begin());
+        _STD copy(_Source._Grp_valid._Buffer_begin(), _Source._Grp_valid._Buffer_end(), _Grp_valid._Buffer_begin());
+    }
+
+    _BidIt _Cur;
+    _Rx_fixed_size_buffer<_Rx_capture_range_t<_BidIt>, _Rebind_alloc_t<_Alloc, _Rx_capture_range_t<_BidIt>>> _Grps;
+    _Rx_fixed_size_bitset<_Rebind_alloc_t<_Alloc, bool>> _Grp_valid;
+};
+
+enum class _Rx_unwind_ops {
+    _After_assert = 1,
+    _After_neg_assert,
+    _Disjunction_eval_alternative,
+    _Do_nothing,
+    _Loop_simple_nongreedy,
+    _Loop_simple_greedy_firstrep,
+    _Loop_simple_greedy_intermediaterep,
+    _Loop_simple_greedy_lastrep,
+    _Loop_nongreedy,
+    _Loop_greedy,
+    _Loop_restore_vals,
+    _Capture_restore_begin,
+    _Capture_restore_unmatched_end,
+    _Capture_restore_matched_end,
+    _Capture_restore_matched,
+};
+
+template <class _BidIt>
+class _Rx_state_frame_t {
+public:
+    _Rx_unwind_ops _Code{};
+    union {
+        int _Loop_idx_sav;
+        unsigned int _Capture_idx;
+    };
+    _Node_base* _Node{};
+    _BidIt _Pos{};
+    size_t _Loop_frame_idx_sav{};
+};
+
+template <class _Ty, class _Alloc = allocator<_Ty>>
+class _Rx_small_vector {
+private:
+    using _Al_pointer       = _Alloc_ptr_t<_Alloc>;
+    using _Al_const_pointer = typename allocator_traits<_Alloc>::const_pointer;
+    using _Al_size_type     = _Alloc_size_t<_Alloc>;
+
+    struct _Vector_state {
+        _Al_pointer _First{};
+        _Al_pointer _Last{};
+        _Al_pointer _End{};
+        bool _Allocated{false};
+    };
+
+public:
+    _CONSTEXPR20 explicit _Rx_small_vector(const _Alloc& _Al = _Alloc{}) : _Mypair(_One_then_variadic_args_t{}, _Al) {}
+
+    _Rx_small_vector(const _Rx_small_vector&)            = delete;
+    _Rx_small_vector(_Rx_small_vector&&)                 = delete;
+    _Rx_small_vector& operator=(const _Rx_small_vector&) = delete;
+    _Rx_small_vector& operator=(_Rx_small_vector&&)      = delete;
+
+    void _Initialize_and_consume_remaining_buffer(void*& _Stack_buf, size_t& _Stack_buf_size) {
+        if (_STD align(alignof(_Ty), sizeof(_Ty), _Stack_buf, _Stack_buf_size)) {
+            const size_t _Count = _Stack_buf_size / sizeof(_Ty); // must calculate after calling _STD align()
+
+            auto& _Data        = _Mypair._Myval2;
+            const auto _Ty_buf = reinterpret_cast<_Ty*>(_Stack_buf);
+            _Data._First       = _STD _Refancy(_Ty_buf);
+            _Data._Last        = _Data._First;
+            _Data._End         = _STD _Refancy(_Ty_buf + _Count);
+        }
+
+        _Stack_buf      = nullptr;
+        _Stack_buf_size = 0;
+    }
+
+    _CONSTEXPR20 ~_Rx_small_vector() {
+        auto& _Data = _Mypair._Myval2;
+        if (_Data._Allocated) {
+            auto& _Al = _Mypair._Get_first();
+            _STD _Destroy_range(_Data._First, _Data._Last, _Al);
+            _Al.deallocate(_Data._First, static_cast<_Al_size_type>(_Data._End - _Data._First));
+        } else {
+            _STD _Destroy_range(_Data._First, _Data._Last);
+        }
+    }
+
+    _NODISCARD _Ty& operator[](const size_t _Pos) {
+        auto& _Data = _Mypair._Myval2;
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Pos < static_cast<size_t>(_Data._Last - _Data._First), "_Rx_small_vector subscript out of range");
+#endif
+        return _Data._First[_Pos];
+    }
+
+    _NODISCARD const _Ty& operator[](const size_t _Pos) const {
+        auto& _Data = _Mypair._Myval2;
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Pos < static_cast<size_t>(_Data._Last - _Data._First), "_Rx_small_vector subscript out of range");
+#endif
+        return _Data._First[_Pos];
+    }
+
+    void _Push_back(_Ty&& _Val) {
+        auto& _Data = _Mypair._Myval2;
+        if (_Data._Last == _Data._End) {
+            _Realloc_buf();
+        }
+
+        if (_Data._Allocated) {
+            allocator_traits<_Alloc>::construct(
+                _Mypair._Get_first(), _STD _Unfancy(_Data._Last), _STD forward<_Ty>(_Val));
+        } else {
+            _STD _Construct_in_place(*_Data._Last, _STD forward<_Ty>(_Val));
+        }
+        ++_Data._Last;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_t _Max_size() const noexcept {
+        const auto _Max_capacity = (_STD min) (static_cast<_Al_size_type>(_STD _Max_limit<_Iter_diff_t<_Al_pointer>>()),
+            allocator_traits<_Alloc>::max_size(_Mypair._Get_first()));
+        if (_Max_capacity > size_t{PTRDIFF_MAX}) {
+            return size_t{PTRDIFF_MAX};
+        }
+        return static_cast<size_t>(_Max_capacity);
+    }
+
+    _NODISCARD size_t _Size() const {
+        auto& _Data = _Mypair._Myval2;
+        return static_cast<size_t>(_Data._Last - _Data._First);
+    }
+
+    _NODISCARD _Al_pointer _Begin() {
+        return _Mypair._Myval2._First;
+    }
+
+    _NODISCARD _Al_const_pointer _Begin() const {
+        return _Mypair._Myval2._First;
+    }
+
+    _NODISCARD _Al_pointer _End() {
+        return _Mypair._Myval2._Last;
+    }
+
+    _NODISCARD _Al_const_pointer _End() const {
+        return _Mypair._Myval2._Last;
+    }
+
+private:
+    _NODISCARD _Al_size_type _Calculate_new_capacity() {
+        auto& _Data              = _Mypair._Myval2;
+        const auto _Old_capacity = static_cast<_Al_size_type>(_Data._End - _Data._First);
+        const auto _Max_capacity = static_cast<_Al_size_type>(_Max_size());
+
+        const auto _Increase = (_STD max) (_Old_capacity / 2, _Al_size_type{1});
+
+        if (_Max_capacity - _Increase < _Old_capacity) {
+            return _Max_capacity;
+        } else {
+            return _Old_capacity + _Increase;
+        }
+    }
+
+    void _Realloc_buf() {
+        auto& _Al                = _Mypair._Get_first();
+        auto& _Data              = _Mypair._Myval2;
+        const auto _Old_first    = _Data._First;
+        const auto _Old_last     = _Data._Last;
+        const auto _Old_end      = _Data._End;
+        const auto _Old_capacity = static_cast<_Al_size_type>(_Old_end - _Old_first);
+        auto _New_capacity       = _Calculate_new_capacity();
+        if (_Old_capacity >= _New_capacity) {
+            _Xregex_error(regex_constants::error_stack);
+        }
+
+        const auto _New_first = _STD _Allocate_at_least_helper(_Al, _New_capacity);
+        _Allocation_guard<_Alloc> _Guard{_Al, _New_first, _New_capacity};
+        const auto _New_last = _STD _Uninitialized_move(_Old_first, _Old_last, _New_first, _Al);
+        _Data._First         = _New_first;
+        _Data._Last          = _New_last;
+        _Data._End           = _New_first + static_cast<_Iter_diff_t<_Al_pointer>>(_New_capacity);
+        _Guard._Ptr          = nullptr;
+
+        if (_Data._Allocated) {
+            _STD _Destroy_range(_Old_first, _Old_last, _Al);
+            _Al.deallocate(_Old_first, _Old_capacity);
+        } else {
+            _Data._Allocated = true;
+            _STD _Destroy_range(_Old_first, _Old_last);
+        }
+    }
+
+    _Compressed_pair<_Alloc, _Vector_state> _Mypair;
+};
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+class _Matcher3 { // provides ways to match a regular expression to a text sequence
+private:
+    using _Loop_vals_type   = _Loop_vals_v3_t<_Iter_diff_t<_It>>;
+    using _Tgt_state_type   = _Tgt_state_v2_t<_It, allocator<_It>>;
+    using _State_frame_type = _Rx_state_frame_t<_It>;
+
+public:
+    template <size_t _Stack_storage_size>
+    _Matcher3(_It _Pfirst, _It _Plast, const _RxTraits& _Tr, _Root_node* const _Re, const unsigned int _Nx,
+        const regex_constants::syntax_option_type _Sf, const regex_constants::match_flag_type _Mf,
+        unsigned char (&_Stack_storage)[_Stack_storage_size], const bool _Full_)
+        : _Traits(_Tr), _Begin(_Pfirst), _End(_Plast), _Sflags(_Sf), _Mflags(_Mf), _Ncap(_Nx),
+          _Longest((_Re->_Flags & _Fl_longest) && !(_Mf & regex_constants::match_any)), _Full(_Full_) {
+        _Adl_verify_range(_Pfirst, _Plast);
+        if (_Re->_Flags & _Fl_begin_needs_w) {
+            _Char_class_w = _Lookup_char_class(static_cast<_Elem>('W'));
+        }
+
+        if (_Re->_Flags & _Fl_begin_needs_s) {
+            _Char_class_s = _Lookup_char_class(static_cast<_Elem>('S'));
+        }
+
+        if (_Re->_Flags & _Fl_begin_needs_d) {
+            _Char_class_d = _Lookup_char_class(static_cast<_Elem>('D'));
+        }
+
+        _Iter_diff_t<_It> _Input_length = _STD distance(_Pfirst, _Plast);
+        _Frames_limit                   = _Calculate_frames_limit(_Input_length);
+        _Complexity_limit               = _Calculate_complexity_limit(_Input_length);
+
+        // TRANSITION, ABI, GH-6025:
+        // The first two nodes are of types _N_begin and _N_capture with capturing group 0.
+        // These nodes do not affect the state of the matcher and thus can be skipped immediately
+        // before engaging the expensive NFA interpreter loop.
+        _Start = _Re->_Next->_Next;
+
+        {
+            void* _Buf       = _Stack_storage;
+            size_t _Buf_size = _Stack_storage_size;
+
+            _Loop_vals._Initialize(_Buf, _Buf_size, _Re->_Loops);
+
+            if (_Ncap > 1U) {
+                _Tgt_state._Grps._Initialize(_Buf, _Buf_size, _Ncap - 1U);
+                if (_Longest) {
+                    _Res._Grps._Initialize(_Buf, _Buf_size, _Ncap - 1U);
+                }
+
+                _Tgt_state._Grp_valid._Initialize(_Buf, _Buf_size, _Ncap - 1U);
+                if (_Longest) {
+                    _Res._Grp_valid._Initialize(_Buf, _Buf_size, _Ncap - 1U);
+                }
+            }
+
+            _Frames._Initialize_and_consume_remaining_buffer(_Buf, _Buf_size);
+        }
+
+// sanitize multiline mode setting
+#if _REGEX_LEGACY_MULTILINE_MODE
+        _Sflags |= regex_constants::multiline; // old matcher applied multiline mode for all grammars
+#else // ^^^ _REGEX_LEGACY_MULTILINE_MODE / !_REGEX_LEGACY_MULTILINE_MODE vvv
+        if (_Sflags & regex_constants::_Any_posix) { // multiline mode is ECMAScript-only
+            _Sflags &= ~regex_constants::multiline;
+        }
+#endif // ^^^ !_REGEX_LEGACY_MULTILINE_MODE ^^^
+    }
+
+    void _Setf(regex_constants::match_flag_type _Mf) { // set specified flags
+        _Mflags |= _Mf;
+    }
+
+    void _Clearf(regex_constants::match_flag_type _Mf) { // clear specified flags
+        _Mflags &= ~_Mf;
+    }
+
+    bool _Match2(_It _Pfirst) { // try to match
+        _Begin = _Pfirst;
+        return _Match2();
+    }
+
+    bool _Match2() { // try to match
+        _Tgt_state._Cur = _Begin;
+        _Frames_count   = 0;
+        _Matched        = false;
+
+        return _Match_pat(_Start) || _Matched;
+    }
+
+    template <class _BidIt, class _Alsubmatch>
+    void _Copy_captures(match_results<_BidIt, _Alsubmatch>& _Matches);
+
+    _It _Skip(_It _First, _It _Last, const _Node_base* _Node_arg = nullptr, unsigned int _Recursion_depth = 0U);
+
+private:
+    long long _Complexity_limit;
+    _Tgt_state_type _Tgt_state;
+    _Tgt_state_type _Res;
+    _Rx_fixed_size_buffer<_Loop_vals_type> _Loop_vals;
+    _Rx_small_vector<_State_frame_type> _Frames;
+    size_t _Frames_count;
+    size_t _Frames_limit;
+    _Node_base* _Start;
+    const _RxTraits& _Traits;
+    _It _Begin;
+    _It _End;
+    regex_constants::syntax_option_type _Sflags;
+    regex_constants::match_flag_type _Mflags;
+    unsigned int _Ncap;
+    typename _RxTraits::char_class_type _Char_class_w{};
+    typename _RxTraits::char_class_type _Char_class_s{};
+    typename _RxTraits::char_class_type _Char_class_d{};
+    bool _Matched = false;
+    bool _Longest;
+    bool _Full;
+
+    size_t _Push_frame(_Rx_unwind_ops _Code, _Node_base* _Node);
+
+    size_t _Calculate_frames_limit(_Iter_diff_t<_It> _Input_length);
+    long long _Calculate_complexity_limit(_Iter_diff_t<_It> _Input_length);
+    void _Increase_complexity_count(_Iter_diff_t<_It> _Count);
+
+    void _Prepare_rep(_Node_rep*);
+    bool _Find_first_inner_capture_group(_Node_base*, _Loop_vals_type*);
+    void _Reset_capture_groups(unsigned int _First);
+    _It _Do_class(const _Node_base*, _It);
+    bool _Match_pat(_Node_base*);
+    bool _Better_match();
+    bool _Is_wbound() const;
+    typename _RxTraits::char_class_type _Lookup_char_class(_Elem) const;
+
+public:
+    _Matcher3(const _Matcher3&)            = delete;
+    _Matcher3& operator=(const _Matcher3&) = delete;
+};
+
+enum _Prs_ret { // indicate class element type
+    _Prs_none,
+    _Prs_chr,
+    _Prs_set
+};
+
+enum class _Lex_mode : unsigned char { _Default, _Character_class };
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+class _Parser2 { // parse a regular expression
+public:
+    _Parser2(const _RxTraits& _Tr, _FwdIt _Pfirst, _FwdIt _Plast, regex_constants::syntax_option_type _Fx);
+    _Root_node* _Compile();
+
+private:
+    unsigned int _Mark_count() const noexcept {
+        return _Grp_idx + 1;
+    }
+
+    // lexing
+    [[noreturn]] void _Error(regex_constants::error_type);
+
+    bool _Is_esc(_FwdIt) const;
+    void _Trans();
+    void _Next();
+    void _Expect(_Meta_type, regex_constants::error_type);
+
+    // parsing
+    int _Do_digits(int _Base, int _Initial, int _Count, regex_constants::error_type _Error_type);
+    bool _DecimalDigits(regex_constants::error_type _Error_type, int _Initial = 0);
+    void _HexDigits(int);
+    bool _OctalDigits();
+    _Prs_ret _Do_ex_class(_Meta_type);
+    bool _CharacterClassEscape(bool);
+    _Prs_ret _ClassEscape();
+    _Prs_ret _ClassAtom(bool);
+    void _ClassRanges();
+    void _CharacterClass();
+    bool _IdentityEscape(bool);
+    bool _IsIdentityEscape(bool) const;
+    bool _Do_ffn(_Elem);
+    bool _Do_ffnx(_Elem);
+    bool _CharacterEscape(bool);
+    void _AtomEscape();
+    void _Do_capture_group();
+    void _Do_noncapture_group();
+    void _Do_assert_group(bool _Neg);
+    bool _Wrapped_disjunction();
+    void _Quantifier();
+    void _Alternative2();
+    void _Disjunction();
+    void _Calculate_loop_simplicity(_Node_base* _Nx, _Node_base* _Ne, _Node_rep* _Outer_rep, bool _Nonreentrant);
+
+    _FwdIt _Pat;
+    _FwdIt _End;
+    unsigned int _Grp_idx = 0;
+    int _Disj_count       = 0;
+    vector<bool> _Finished_grps;
+    _Builder2<_FwdIt, _Elem, _RxTraits> _Nfa;
+    const _RxTraits& _Traits;
+    unsigned long long _L_flags;
+    regex_constants::syntax_option_type _Flags;
+    int _Val;
+    _Meta_type _Mchar;
+    _Lex_mode _Mode = _Lex_mode::_Default;
+    _Elem _Char;
+    _Elem _Unescaped_char;
+};
+
+enum _Lang_flags2 : unsigned long long { // describe language properties
+    _L_ext_rep    = 0x000000001ULL, // + and ? repetitions
+    _L_alt_pipe   = 0x000000002ULL, // uses '|' for alternation
+    _L_alt_nl     = 0x000000004ULL, // newlines outside parentheses/brackets represent alternations (grep, egrep)
+    _L_nex_grp    = 0x000000008ULL, // has non-escaped capture groups
+    _L_nex_rep    = 0x000000010ULL, // has non-escaped repeats
+    _L_nc_asrt    = 0x000000020ULL, // has non-capture groups (?:xxx) and generalized assertions (?=xxx), (?!xxx)
+    _L_asrt_wrd   = 0x000000040ULL, // has word boundary assertions (\b, \B)
+    _L_bckr       = 0x000000080ULL, // has backreferences (ERE doesn't)
+    _L_lim_bckr   = 0x000000100ULL, // has limited backreferences (BRE \1-\9)
+    _L_non_greedy = 0x000000200ULL, // has non-greedy repeats
+    _L_esc_uni    = 0x000000400ULL, // has Unicode escape sequences
+    _L_esc_hex    = 0x000000800ULL, // has hexadecimal escape sequences
+    _L_esc_oct    = 0x000001000ULL, // has octal escape sequences (awk)
+    _L_esc_bsp    = 0x000002000ULL, // has backspace escape in character classes
+    _L_esc_ffnx   = 0x000004000ULL, // has extra file escapes (\a and \b) (awk)
+    _L_esc_ffn    = 0x000008000ULL, // has limited file escapes (\f \n \r \t \v)
+    _L_esc_wsd    = 0x000010000ULL, // has w, s, and d character set escapes
+    _L_esc_ctrl   = 0x000020000ULL, // has control escape
+    _L_no_nl      = 0x000040000ULL, // newlines within parentheses/brackets are syntax errors (grep, egrep)
+    _L_bzr_chr    = 0x000080000ULL, // \0 is a valid character constant
+    _L_grp_esc    = 0x000100000ULL, // \ is special character in group
+    _L_ident_ECMA = 0x000200000ULL, // ECMA identity escape (not identifierpart)
+    _L_ident_ERE  = 0x000400000ULL, // ERE identity escape (.[\*^$, plus {+?}()
+    _L_ident_awk  = 0x000800000ULL, // awk identity escape (awk additionally supports " and / characters)
+    _L_anch_rstr  = 0x001000000ULL, // anchor restricted to beginning/end (BRE)
+    _L_star_beg   = 0x002000000ULL, // star okay at beginning of RE/expr (BRE)
+    _L_empty_grp  = 0x004000000ULL, // empty group allowed (ERE prohibits "()")
+    _L_paren_bal  = 0x008000000ULL, // ')'/'}' special only after '('/'{' (ERE)
+    _L_brk_bal    = 0x010000000ULL, // ']' special only after '[' (ERE, BRE)
+    _L_brk_rstr   = 0x020000000ULL, // ']' not special when first character in set (ERE, BRE)
+    _L_dsh_rstr   = 0x040000000ULL, // '-' forbidden at range start in set except when first character (ERE, BRE)
+    _L_mtch_long  = 0x080000000ULL, // find longest match (ERE, BRE)
+};
+
+class _Regex_base : public _Container_base { // base class for basic_regex to construct and destroy proxy
+public:
+#if 0 < _ITERATOR_DEBUG_LEVEL
+    _Regex_base() { // construct proxy
+        this->_Myproxy = new _Container_proxy;
+        this->_Myproxy->_Mycont = this;
+    }
+
+    ~_Regex_base() noexcept {
+        this->_Orphan_all();
+        delete this->_Myproxy;
+        this->_Myproxy = nullptr;
+    }
+#endif // 0 < _ITERATOR_DEBUG_LEVEL
+};
+
+_EXPORT_STD template <class _Elem, class _RxTraits = regex_traits<_Elem>>
+class basic_regex : public _Regex_base { // regular expression
+public:
+    using value_type  = _Elem;
+    using traits_type = _RxTraits;
+    using locale_type = typename _RxTraits::locale_type;
+    using string_type = typename _RxTraits::string_type;
+    using flag_type   = regex_constants::syntax_option_type;
+
+    static constexpr flag_type icase      = regex_constants::icase;
+    static constexpr flag_type nosubs     = regex_constants::nosubs;
+    static constexpr flag_type optimize   = regex_constants::optimize;
+    static constexpr flag_type collate    = regex_constants::collate;
+    static constexpr flag_type ECMAScript = regex_constants::ECMAScript;
+    static constexpr flag_type basic      = regex_constants::basic;
+    static constexpr flag_type extended   = regex_constants::extended;
+    static constexpr flag_type awk        = regex_constants::awk;
+    static constexpr flag_type grep       = regex_constants::grep;
+    static constexpr flag_type egrep      = regex_constants::egrep;
+    static constexpr flag_type multiline  = regex_constants::multiline;
+
+    basic_regex() = default; // construct empty object
+
+    explicit basic_regex(_In_z_ const _Elem* _Ptr, flag_type _Flags = regex_constants::ECMAScript) {
+        _Reset(_Ptr, _Ptr + _RxTraits::length(_Ptr), _Flags);
+    }
+
+    basic_regex(_In_reads_(_Count) const _Elem* _Ptr, size_t _Count, flag_type _Flags = regex_constants::ECMAScript) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Ptr != nullptr || _Count == 0, "constructing basic_regex from an invalid range");
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+        _Reset(_Ptr, _Ptr + _Count, _Flags);
+    }
+
+    template <class _STtraits, class _STalloc>
+    explicit basic_regex(
+        const basic_string<_Elem, _STtraits, _STalloc>& _Str, flag_type _Flags = regex_constants::ECMAScript) {
+        _Reset(_Str.data(), _Str.data() + static_cast<ptrdiff_t>(_Str.size()), _Flags);
+    }
+
+    template <class _InIt>
+    basic_regex(_InIt _First, _InIt _Last, flag_type _Flags) {
+        _Adl_verify_range(_First, _Last);
+        _Reset(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Flags);
+    }
+
+    template <class _InIt>
+    basic_regex(_InIt _First, _InIt _Last) {
+        _Adl_verify_range(_First, _Last);
+        _Reset(_Get_unwrapped(_First), _Get_unwrapped(_Last), regex_constants::ECMAScript);
+    }
+
+    basic_regex(const basic_regex& _Right)
+#if _ENHANCED_REGEX_VISUALIZER
+        : _Traits(_Right._Traits), _Visualization(_Right._Visualization)
+#else
+        : _Traits(_Right._Traits)
+#endif
+    { // construct copy of _Right
+        _Reset(_Right._Rep);
+    }
+
+    basic_regex(initializer_list<_Elem> _Ilist, flag_type _Flags = regex_constants::ECMAScript) {
+        _Reset(_Ilist.begin(), _Ilist.end(), _Flags);
+    }
+
+    basic_regex& operator=(initializer_list<_Elem> _Ilist) { // replace with regular expression in initializer_list
+        return assign(_Ilist);
+    }
+
+    basic_regex& assign(initializer_list<_Elem> _Ilist, flag_type _Flags = regex_constants::ECMAScript) {
+        // replace with regular expression in initializer_list
+        _Reset(_Ilist.begin(), _Ilist.end(), _Flags);
+        return *this;
+    }
+
+    basic_regex(basic_regex&& _Right) noexcept {
+        _Assign_rv(_STD move(_Right));
+    }
+
+    basic_regex& operator=(basic_regex&& _Right) noexcept {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void _Assign_rv(basic_regex&& _Right) {
+        if (this != _STD addressof(_Right)) { // clear this and steal from _Right
+            _Tidy();
+
+#if _ENHANCED_REGEX_VISUALIZER
+            _Visualization = _STD move(_Right._Visualization);
+#endif // _ENHANCED_REGEX_VISUALIZER
+
+            _Rep        = _Right._Rep;
+            _Right._Rep = nullptr;
+        }
+    }
+
+    basic_regex& assign(basic_regex&& _Right) noexcept {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    ~basic_regex() noexcept {
+        _Tidy();
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        const auto _Tombstone{reinterpret_cast<_Root_node*>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+        _Rep = _Tombstone;
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    }
+
+    basic_regex& operator=(const basic_regex& _Right) {
+        return assign(_Right);
+    }
+
+    basic_regex& operator=(_In_z_ const _Elem* _Ptr) {
+        _Reset(_Ptr, _Ptr + _RxTraits::length(_Ptr), ECMAScript);
+        return *this;
+    }
+
+    template <class _STtraits, class _STalloc>
+    basic_regex& operator=(const basic_string<_Elem, _STtraits, _STalloc>& _Str) {
+        _Reset(_Str.data(), _Str.data() + static_cast<ptrdiff_t>(_Str.size()), ECMAScript);
+        return *this;
+    }
+
+    unsigned int _Loop_count() const noexcept {
+        return _Rep ? _Rep->_Loops : 0;
+    }
+
+    _NODISCARD unsigned int mark_count() const noexcept /* strengthened */ {
+        return _Rep ? _Rep->_Marks - 1 : 0;
+    }
+
+    basic_regex& assign(const basic_regex& _Right) {
+#if _ENHANCED_REGEX_VISUALIZER
+        _Visualization = _Right._Visualization;
+#endif // _ENHANCED_REGEX_VISUALIZER
+
+        _Reset(_Right._Rep);
+        return *this;
+    }
+
+    basic_regex& assign(_In_z_ const _Elem* _Ptr, flag_type _Flags = regex_constants::ECMAScript) {
+        return assign(_Ptr, _RxTraits::length(_Ptr), _Flags);
+    }
+
+    basic_regex& assign(
+        _In_reads_(_Count) const _Elem* _Ptr, size_t _Count, flag_type _Flags = regex_constants::ECMAScript) {
+        _Reset(_Ptr, _Ptr + _Count, _Flags);
+        return *this;
+    }
+
+    template <class _STtraits, class _STalloc>
+    basic_regex& assign(
+        const basic_string<_Elem, _STtraits, _STalloc>& _Str, flag_type _Flags = regex_constants::ECMAScript) {
+        _Reset(_Str.data(), _Str.data() + static_cast<ptrdiff_t>(_Str.size()), _Flags);
+        return *this;
+    }
+
+    template <class _InIt>
+    basic_regex& assign(_InIt _First, _InIt _Last, flag_type _Flags = regex_constants::ECMAScript) {
+        _Adl_verify_range(_First, _Last);
+        _Reset(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Flags);
+        return *this;
+    }
+
+    _NODISCARD flag_type flags() const noexcept /* strengthened */ {
+        return _Rep ? _Rep->_Fl : flag_type{};
+    }
+
+    locale_type imbue(locale_type _Loc) { // clear regular expression and set locale to argument
+        _Tidy();
+        return _Traits.imbue(_Loc);
+    }
+
+    locale_type getloc() const {
+        return _Traits.getloc();
+    }
+
+    void swap(basic_regex& _Right) noexcept /* strengthened */ {
+        _STD swap(_Rep, _Right._Rep);
+
+#if _ENHANCED_REGEX_VISUALIZER
+        _Visualization.swap(_Right._Visualization);
+#endif // _ENHANCED_REGEX_VISUALIZER
+    }
+
+    _Root_node* _Get() const noexcept {
+        return _Rep;
+    }
+
+    bool _Empty() const noexcept {
+        return _Rep == nullptr;
+    }
+
+    const _RxTraits& _Get_traits() const noexcept {
+        return _Traits;
+    }
+
+private:
+    _Root_node* _Rep = nullptr;
+    _RxTraits _Traits;
+
+#if _ENHANCED_REGEX_VISUALIZER
+    basic_string<_Elem> _Visualization;
+#endif // _ENHANCED_REGEX_VISUALIZER
+
+    void _Tidy() noexcept { // free all storage
+        if (_Rep && _MT_DECR(reinterpret_cast<_Atomic_counter_t&>(_Rep->_Refs)) == 0) {
+            _Destroy_node(_Rep);
+        }
+
+        _Rep = nullptr;
+    }
+
+    template <class _InIt>
+    void _Reset(_InIt _First, _InIt _Last, flag_type _Flags) {
+        // build regular expression from iterator range
+        if constexpr (_Is_ranges_fwd_iter_v<_InIt>) {
+#if _ENHANCED_REGEX_VISUALIZER
+            _Visualization.assign(_First, _Last);
+#endif // _ENHANCED_REGEX_VISUALIZER
+
+            _Parser2<_InIt, _Elem, _RxTraits> _Prs(_Traits, _First, _Last, _Flags);
+            _Root_node* _Rx = _Prs._Compile();
+            _Reset(_Rx);
+        } else {
+            static_assert(_Is_ranges_input_iter_v<_InIt>, "Iterators must be at least input iterators");
+
+            basic_string<_Iter_value_t<_InIt>> _Str(_First, _Last);
+
+            _Reset(_Str.data(), _Str.data() + static_cast<ptrdiff_t>(_Str.size()), _Flags);
+        }
+    }
+
+    void _Reset(_Root_node* _Rx) { // build regular expression holding root node _Rx
+        if (_Rx) {
+            _MT_INCR(reinterpret_cast<_Atomic_counter_t&>(_Rx->_Refs));
+        }
+
+        _Tidy();
+        _Rep = _Rx;
+    }
+};
+
+#if _HAS_CXX17
+template <class _FwdIt>
+basic_regex(_FwdIt, _FwdIt, regex_constants::syntax_option_type = regex_constants::ECMAScript)
+    -> basic_regex<typename iterator_traits<_FwdIt>::value_type>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Elem, class _RxTraits>
+void swap(basic_regex<_Elem, _RxTraits>& _Left, basic_regex<_Elem, _RxTraits>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _BidIt, class _Alloc>
+void swap(match_results<_BidIt, _Alloc>& _Left, match_results<_BidIt, _Alloc>& _Right)
+    noexcept(noexcept(_Left.swap(_Right))) /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD using regex   = basic_regex<char>;
+_EXPORT_STD using wregex  = basic_regex<wchar_t>;
+_EXPORT_STD using cmatch  = match_results<const char*>;
+_EXPORT_STD using wcmatch = match_results<const wchar_t*>;
+_EXPORT_STD using smatch  = match_results<string::const_iterator>;
+_EXPORT_STD using wsmatch = match_results<wstring::const_iterator>;
+
+template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
+_OutIt _Format_default(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
+    regex_constants::match_flag_type) { // format with ECMAScript rules
+    while (_First != _Last) { // process one character or escape sequence
+        if (*_First != '$') {
+            *_Out++ = *_First++;
+        } else if (++_First == _Last) {
+            *_Out++ = '$'; // preserve $ at end
+        } else if (*_First == '$') { // replace $$
+            *_Out++ = '$';
+            ++_First;
+        } else if (*_First == '`') { // replace $`
+            _Out = _STD copy(_Match.prefix().first, _Match.prefix().second, _Out);
+            ++_First;
+        } else if (*_First == '\'') { // replace $'
+            _Out = _STD copy(_Match.suffix().first, _Match.suffix().second, _Out);
+            ++_First;
+        } else if (*_First == '&') { // replace $&
+            ++_First;
+            if (_Match.size() != 0) {
+                _Out = _STD copy(_Match._At(0).first, _Match._At(0).second, _Out);
+            }
+        } else if ('0' <= *_First && *_First <= '9') { // replace capture group descriptors $n, $nn
+            auto _Num              = static_cast<unsigned int>(*_First++ - '0');
+            const bool _Two_digits = _First != _Last && '0' <= *_First && *_First <= '9';
+            if (_Two_digits) { // process second digit
+                _Num *= 10;
+                _Num += static_cast<unsigned int>(*_First++ - '0');
+            }
+
+            if (_Num == 0) { // preserve $0, $00
+                *_Out++ = '$';
+                *_Out++ = '0';
+                if (_Two_digits) {
+                    *_Out++ = '0';
+                }
+            } else if (_Num < _Match.size()) {
+                _Out = _STD copy(_Match._At(_Num).first, _Match._At(_Num).second, _Out);
+            }
+        } else { // replace $x
+            *_Out++ = '$';
+            *_Out++ = *_First++;
+        }
+    }
+    return _Out;
+}
+
+template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
+_OutIt _Format_sed(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
+    regex_constants::match_flag_type) { // format with sed rules
+    while (_First != _Last) { // process one character or escape sequence
+        if (*_First == '&') { // replace with full match
+            ++_First;
+            if (_Match.size() != 0) {
+                _Out = _STD copy(_Match._At(0).first, _Match._At(0).second, _Out);
+            }
+        } else if (*_First != '\\') {
+            *_Out++ = *_First++;
+        } else if (++_First != _Last) {
+            if ('0' <= *_First && *_First <= '9') { // replace \n, including \0
+                const auto _Num = static_cast<unsigned int>(*_First++ - '0');
+                if (_Num < _Match.size()) {
+                    _Out = _STD copy(_Match._At(_Num).first, _Match._At(_Num).second, _Out);
+                }
+            } else {
+                *_Out++ = *_First++; // replace \x, including \\, \&
+            }
+        }
+    }
+
+    return _Out;
+}
+
+template <class _BidIt, class _Alloc, class _Elem, class _RxTraits, class _It>
+bool _Regex_match2(const _It _First, const _It _Last, match_results<_BidIt, _Alloc>* const _Matches,
+    const basic_regex<_Elem, _RxTraits>& _Re, const regex_constants::match_flag_type _Flgs) {
+    // try to match regular expression to target text
+    static_assert(_Is_ranges_bidi_iter_v<_It>,
+        "regex_match requires bidirectional iterators or stronger. See N5014 [re.alg.match]/1.");
+
+    if (_Matches) { // clear _Matches before doing work
+        _Matches->_Ready = true;
+        _Matches->_Resize(0);
+    }
+
+    if (_Re._Empty()) {
+        return false;
+    }
+
+    alignas(_Loop_vals_v3_t<_Iter_diff_t<_It>>) alignas(_Rx_capture_range_t<_It>) //
+        alignas(_Rx_state_frame_t<_It>) unsigned char _Stackbuf[4096];
+    _Matcher3<_Elem, _RxTraits, _It, void> _Mx(
+        _First, _Last, _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(), _Flgs, _Stackbuf, true);
+
+    if (!_Mx._Match2()) {
+        return false;
+    }
+
+    if (_Matches) {
+        _Mx._Copy_captures(*_Matches);
+        _Matches->_Org           = _First;
+        _Matches->_Pfx().first   = _First;
+        _Matches->_Pfx().matched = _Matches->_Pfx().first != _Matches->_Pfx().second;
+    }
+
+    return true;
+}
+
+_EXPORT_STD template <class _BidIt, class _Alloc, class _Elem, class _RxTraits>
+bool regex_match(_BidIt _First, _BidIt _Last, match_results<_BidIt, _Alloc>& _Matches,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // try to match regular expression to target text
+    _STD _Adl_verify_range(_First, _Last);
+    return _STD _Regex_match2(_First, _Last, _STD addressof(_Matches), _Re, _Flgs);
+}
+
+_EXPORT_STD template <class _BidIt, class _Elem, class _RxTraits>
+_NODISCARD bool regex_match(_BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
+    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // try to match regular expression to target text
+    _STD _Adl_verify_range(_First, _Last);
+    return _STD _Regex_match2(_Get_unwrapped(_First), _Get_unwrapped(_Last),
+        static_cast<match_results<_Unwrapped_t<const _BidIt&>>*>(nullptr), _Re, _Flgs | regex_constants::match_any);
+}
+
+_EXPORT_STD template <class _Elem, class _RxTraits>
+_NODISCARD bool regex_match(_In_z_ const _Elem* _Str, const basic_regex<_Elem, _RxTraits>& _Re,
+    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // try to match regular expression to target text
+    const _Elem* _Last = _Str + char_traits<_Elem>::length(_Str);
+    return _STD _Regex_match2(
+        _Str, _Last, static_cast<match_results<const _Elem*>*>(nullptr), _Re, _Flgs | regex_constants::match_any);
+}
+
+_EXPORT_STD template <class _Elem, class _Alloc, class _RxTraits>
+bool regex_match(_In_z_ const _Elem* _Str, match_results<const _Elem*, _Alloc>& _Matches,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // try to match regular expression to target text
+    const _Elem* _Last = _Str + char_traits<_Elem>::length(_Str);
+    return _STD _Regex_match2(_Str, _Last, _STD addressof(_Matches), _Re, _Flgs);
+}
+
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
+bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
+    match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>& _Matches,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // try to match regular expression to target text
+    return _STD _Regex_match2(_Str.begin(), _Str.end(), _STD addressof(_Matches), _Re, _Flgs);
+}
+
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
+bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>&&,
+    match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>&,
+    const basic_regex<_Elem, _RxTraits>&, regex_constants::match_flag_type = regex_constants::match_default) = delete;
+
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Elem, class _RxTraits>
+_NODISCARD bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // try to match regular expression to target text
+    return _STD _Regex_match2(_Str.data(), _Str.data() + _Str.size(),
+        static_cast<match_results<const _Elem*>*>(nullptr), _Re, _Flgs | regex_constants::match_any);
+}
+
+template <class _BidIt, class _Alloc, class _Elem, class _RxTraits, class _It>
+bool _Regex_search3(_It _First, _It _Last, match_results<_BidIt, _Alloc>* _Matches,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs) {
+    // search for regular expression match in target text
+    static_assert(_Is_ranges_bidi_iter_v<_It>,
+        "regex_search requires bidirectional iterators or stronger. See N5014 [re.alg.search]/1.");
+
+    if (_Matches) { // clear _Matches before doing work
+        _Matches->_Ready = true;
+        _Matches->_Resize(0);
+    }
+
+    if (_Re._Empty()) {
+        return false;
+    }
+
+    bool _Found      = false;
+    const _It _Begin = _First;
+
+    alignas(_Loop_vals_v3_t<_Iter_diff_t<_It>>) alignas(_Rx_capture_range_t<_It>) //
+        alignas(_Rx_state_frame_t<_It>) unsigned char _Stackbuf[4096];
+    _Matcher3<_Elem, _RxTraits, _It, void> _Mx(
+        _First, _Last, _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(), _Flgs, _Stackbuf, false);
+
+    if (_Mx._Match2()) {
+        _Found = true;
+    } else if (_First != _Last && !(_Flgs & regex_constants::match_continuous)) { // try more on suffixes
+        _Mx._Setf(regex_constants::match_prev_avail);
+        _Mx._Clearf(regex_constants::_Match_not_null);
+        while ((_First = _Mx._Skip(++_First, _Last)) != _Last) {
+            if (_Mx._Match2(_First)) { // found match starting at _First
+                _Found = true;
+                break;
+            }
+        }
+
+        if (!_Found && _Mx._Match2(_Last)) {
+            _Found = true;
+        }
+    }
+
+    if (_Found && _Matches) { // update _Matches
+        _Mx._Copy_captures(*_Matches);
+        _Matches->_Pfx().first   = _Begin;
+        _Matches->_Pfx().matched = _Matches->_Pfx().first != _Matches->_Pfx().second;
+    }
+    return _Found;
+}
+
+_EXPORT_STD template <class _BidIt, class _Alloc, class _Elem, class _RxTraits>
+bool regex_search(_BidIt _First, _BidIt _Last, match_results<_BidIt, _Alloc>& _Matches,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search for regular expression match in target text
+    _STD _Adl_verify_range(_First, _Last);
+    _Matches._Org = _First;
+    return _STD _Regex_search3(_First, _Last, _STD addressof(_Matches), _Re, _Flgs);
+}
+
+_EXPORT_STD template <class _BidIt, class _Elem, class _RxTraits>
+_NODISCARD bool regex_search(_BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
+    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search for regular expression match in target text
+    _STD _Adl_verify_range(_First, _Last);
+    return _STD _Regex_search3(_Get_unwrapped(_First), _Get_unwrapped(_Last),
+        static_cast<match_results<_Unwrapped_t<const _BidIt&>>*>(nullptr), _Re, _Flgs | regex_constants::match_any);
+}
+
+_EXPORT_STD template <class _Elem, class _RxTraits>
+_NODISCARD bool regex_search(_In_z_ const _Elem* _Str, const basic_regex<_Elem, _RxTraits>& _Re,
+    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search for regular expression match in target text
+    return _STD _Regex_search3(_Str, _Str + char_traits<_Elem>::length(_Str),
+        static_cast<match_results<const _Elem*>*>(nullptr), _Re, _Flgs | regex_constants::match_any);
+}
+
+_EXPORT_STD template <class _Elem, class _Alloc, class _RxTraits>
+bool regex_search(_In_z_ const _Elem* _Str, match_results<const _Elem*, _Alloc>& _Matches,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search for regular expression match in target text
+    _Matches._Org = _Str;
+    return _STD _Regex_search3(_Str, _Str + char_traits<_Elem>::length(_Str), _STD addressof(_Matches), _Re, _Flgs);
+}
+
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
+bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
+    match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>& _Matches,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search for regular expression match in target text
+    auto _First   = _Str.begin();
+    _Matches._Org = _First;
+    return _STD _Regex_search3(_First, _Str.end(), _STD addressof(_Matches), _Re, _Flgs);
+}
+
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
+bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>&&,
+    match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>&,
+    const basic_regex<_Elem, _RxTraits>&, regex_constants::match_flag_type = regex_constants::match_default) = delete;
+
+_EXPORT_STD template <class _StTraits, class _StAlloc, class _Elem, class _RxTraits>
+_NODISCARD bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
+    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search for regular expression match in target text
+    using _Iter = typename basic_string<_Elem, _StTraits, _StAlloc>::const_pointer;
+
+    _Iter _First = _Str.c_str();
+    _Iter _Last  = _First + _Str.size();
+    return _STD _Regex_search3(
+        _First, _Last, static_cast<match_results<_Iter>*>(nullptr), _Re, _Flgs | regex_constants::match_any);
+}
+
+template <class _OutIt, class _BidIt, class _RxTraits, class _Elem, class _Traits, class _Alloc>
+_OutIt _Regex_replace1(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
+    const basic_string<_Elem, _Traits, _Alloc>& _Fmt, regex_constants::match_flag_type _Flgs) {
+    static_assert(_Is_ranges_bidi_iter_v<_BidIt>,
+        "regex_replace requires bidirectional iterators or stronger. See N5014 [re.alg.replace].");
+    // search and replace
+    match_results<_BidIt> _Matches;
+    _BidIt _Pos                             = _First;
+    regex_constants::match_flag_type _Flags = _Flgs;
+    regex_constants::match_flag_type _Not_null{};
+
+    _Matches._Org = _Pos;
+    while (_STD _Regex_search3(_Pos, _Last, _STD addressof(_Matches), _Re, _Flags | _Not_null)) {
+
+        // replace at each match
+        if (!(_Flgs & regex_constants::format_no_copy)) {
+            _Result = _STD copy(_Matches.prefix().first, _Matches.prefix().second, _Result);
+        }
+
+        _Result = _Matches._Format1(_Result, _Fmt.data(), _Fmt.data() + _Fmt.size(), _Flags);
+
+        _Pos = _Matches[0].second;
+        if (_Pos == _Last || (_Flgs & regex_constants::format_first_only)) {
+            break;
+        }
+
+        if (_Matches[0].first == _Matches[0].second) {
+            _Not_null = regex_constants::_Match_not_null;
+        } else { // non-null match, recognize earlier text
+            _Not_null = regex_constants::match_flag_type{};
+            _Flags |= regex_constants::match_prev_avail;
+        }
+    }
+    return _Flgs & regex_constants::format_no_copy ? _Result : _STD _Copy_unchecked(_Pos, _Last, _Result);
+}
+
+_EXPORT_STD template <class _OutIt, class _BidIt, class _RxTraits, class _Elem, class _Traits, class _Alloc>
+_OutIt regex_replace(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
+    const basic_string<_Elem, _Traits, _Alloc>& _Fmt,
+    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search and replace, iterator result, string format
+    _Adl_verify_range(_First, _Last);
+    _Seek_wrapped(_Result, _Regex_replace1(_Get_unwrapped_unverified(_Result), _Get_unwrapped(_First),
+                               _Get_unwrapped(_Last), _Re, _Fmt, _Flgs));
+    return _Result;
+}
+
+_EXPORT_STD template <class _OutIt, class _BidIt, class _RxTraits, class _Elem>
+_OutIt regex_replace(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
+    const _Elem* _Ptr, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search and replace, iterator result, NTBS format
+    const basic_string<_Elem> _Fmt(_Ptr);
+    return _STD regex_replace(_Result, _First, _Last, _Re, _Fmt, _Flgs);
+}
+
+_EXPORT_STD template <class _RxTraits, class _Elem, class _Traits1, class _Alloc1, class _Traits2, class _Alloc2>
+_NODISCARD basic_string<_Elem, _Traits1, _Alloc1> regex_replace(const basic_string<_Elem, _Traits1, _Alloc1>& _Str,
+    const basic_regex<_Elem, _RxTraits>& _Re, const basic_string<_Elem, _Traits2, _Alloc2>& _Fmt,
+    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search and replace, string result, string target, string format
+    basic_string<_Elem, _Traits1, _Alloc1> _Res;
+    _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(), _Re, _Fmt, _Flgs);
+    return _Res;
+}
+
+_EXPORT_STD template <class _RxTraits, class _Elem, class _Traits1, class _Alloc1>
+_NODISCARD basic_string<_Elem, _Traits1, _Alloc1> regex_replace(const basic_string<_Elem, _Traits1, _Alloc1>& _Str,
+    const basic_regex<_Elem, _RxTraits>& _Re, const _Elem* _Ptr,
+    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search and replace, string result, string target, NTBS format
+    basic_string<_Elem, _Traits1, _Alloc1> _Res;
+    const basic_string<_Elem> _Fmt(_Ptr);
+    _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(), _Re, _Fmt, _Flgs);
+    return _Res;
+}
+
+_EXPORT_STD template <class _RxTraits, class _Elem, class _Traits2, class _Alloc2>
+_NODISCARD basic_string<_Elem> regex_replace(const _Elem* _Pstr, const basic_regex<_Elem, _RxTraits>& _Re,
+    const basic_string<_Elem, _Traits2, _Alloc2>& _Fmt,
+    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search and replace, string result, NTBS target, string format
+    basic_string<_Elem> _Res;
+    const basic_string<_Elem> _Str(_Pstr);
+    _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(), _Re, _Fmt, _Flgs);
+    return _Res;
+}
+
+_EXPORT_STD template <class _RxTraits, class _Elem>
+_NODISCARD basic_string<_Elem> regex_replace(const _Elem* _Pstr, const basic_regex<_Elem, _RxTraits>& _Re,
+    const _Elem* _Ptr, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
+    // search and replace, string result, NTBS target, NTBS format
+    basic_string<_Elem> _Res;
+    const basic_string<_Elem> _Str(_Pstr);
+    const basic_string<_Elem> _Fmt(_Ptr);
+    _STD regex_replace(_STD back_inserter(_Res), _Str.begin(), _Str.end(), _Re, _Fmt, _Flgs);
+    return _Res;
+}
+
+_EXPORT_STD template <class _BidIt, class _Elem = _Iter_value_t<_BidIt>, class _RxTraits = regex_traits<_Elem>>
+class regex_iterator : public _Iterator_base {
+public:
+    using regex_type        = basic_regex<_Elem, _RxTraits>;
+    using value_type        = match_results<_BidIt>;
+    using difference_type   = ptrdiff_t;
+    using pointer           = const value_type*;
+    using reference         = const value_type&;
+    using iterator_category = forward_iterator_tag;
+#if _HAS_CXX20
+    using iterator_concept = input_iterator_tag;
+#endif // _HAS_CXX20
+
+    regex_iterator() = default; // construct end of sequence iterator
+
+    regex_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re,
+        regex_constants::match_flag_type _Fl = regex_constants::match_default)
+        : _Begin(_First), _End(_Last), _MyRe(_STD addressof(_Re)), _Flags(_Fl) {
+        _STD _Adl_verify_range(_Begin, _End);
+        _MyVal._Org = _Begin;
+        if (!_STD _Regex_search3(_Begin, _End, _STD addressof(_MyVal), *_MyRe, _Flags)) {
+            _MyRe = nullptr;
+        } else {
+            this->_Adopt(_MyRe);
+        }
+    }
+
+    regex_iterator(
+        _BidIt, _BidIt, const regex_type&&, regex_constants::match_flag_type = regex_constants::match_default) = delete;
+
+    _NODISCARD bool operator==(const regex_iterator& _Right) const {
+        if (_MyRe != _Right._MyRe) {
+            return false;
+        } else if (!_MyRe) {
+            return true;
+        }
+
+        return _Begin == _Right._Begin && _End == _Right._End && _Flags == _Right._Flags
+            && _MyVal._At(0) == _Right._MyVal._At(0);
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const regex_iterator& _Right) const {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX20
+    _NODISCARD bool operator==(default_sentinel_t) const noexcept /* strengthened */ {
+        return !_MyRe;
+    }
+#endif // _HAS_CXX20
+
+    _NODISCARD const value_type& operator*() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_MyRe, "regex_iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _MyVal;
+    }
+
+    _NODISCARD const value_type* operator->() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_MyRe, "regex_iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _STD addressof(_MyVal);
+    }
+
+    regex_iterator& operator++() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_MyRe, "regex_iterator not incrementable");
+        _STL_VERIFY(this->_Getcont(), "regex_iterator orphaned");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        _BidIt _Start = _MyVal._At(0).second;
+        if (_MyVal._At(0).first == _Start) { // handle zero-length match
+
+            // _Adl_verify_range(_Start, _End) checked in constructor
+            if (_Start == _End
+                || !_STD _Regex_search3(_Start, _End, _STD addressof(_MyVal), *_MyRe,
+                    _Flags | regex_constants::_Match_not_null)) { // store end-of-sequence iterator
+                _MyRe = nullptr;
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+                this->_Adopt(nullptr);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+                return *this;
+            }
+
+            if (_MyVal._Pfx().second != _Start) {
+                _Flags |= regex_constants::match_prev_avail;
+            }
+
+            return *this;
+        }
+
+        _Flags |= regex_constants::match_prev_avail;
+
+        // _Adl_verify_range(_Start, _End) checked in constructor
+        if (!_STD _Regex_search3(_Start, _End, _STD addressof(_MyVal), *_MyRe, _Flags)) {
+            // mark at end of sequence
+            _MyRe = nullptr;
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            this->_Adopt(nullptr);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        }
+
+        return *this;
+    }
+
+    regex_iterator operator++(int) {
+        regex_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    bool _Atend() const noexcept { // test for end iterator
+        return !_MyRe;
+    }
+
+private:
+    _BidIt _Begin{}; // input sequence
+    _BidIt _End{}; // input sequence
+    const regex_type* _MyRe = nullptr; // pointer to basic_regex object
+    regex_constants::match_flag_type _Flags{};
+    match_results<_BidIt> _MyVal; // lookahead value (if _MyRe not null)
+};
+
+_EXPORT_STD using cregex_iterator  = regex_iterator<const char*>;
+_EXPORT_STD using wcregex_iterator = regex_iterator<const wchar_t*>;
+_EXPORT_STD using sregex_iterator  = regex_iterator<string::const_iterator>;
+_EXPORT_STD using wsregex_iterator = regex_iterator<wstring::const_iterator>;
+
+_EXPORT_STD template <class _BidIt, class _Elem = _Iter_value_t<_BidIt>, class _RxTraits = regex_traits<_Elem>>
+class regex_token_iterator {
+public:
+    using _Position         = regex_iterator<_BidIt, _Elem, _RxTraits>;
+    using regex_type        = basic_regex<_Elem, _RxTraits>;
+    using value_type        = sub_match<_BidIt>;
+    using difference_type   = ptrdiff_t;
+    using pointer           = const value_type*;
+    using reference         = const value_type&;
+    using iterator_category = forward_iterator_tag;
+#if _HAS_CXX20
+    using iterator_concept = input_iterator_tag;
+#endif // _HAS_CXX20
+
+    regex_token_iterator() = default; // construct end of sequence iterator
+
+    regex_token_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re, int _Sub = 0,
+        regex_constants::match_flag_type _Fl = regex_constants::match_default)
+        : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(&_Sub, &_Sub + 1) {
+        _Init(_First, _Last);
+    }
+
+    regex_token_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re, const vector<int>& _Subx,
+        regex_constants::match_flag_type _Fl = regex_constants::match_default)
+        : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(_Subx.begin(), _Subx.end()) {
+        if (_Subs.empty()) {
+            _Res = nullptr; // treat empty vector as end of sequence
+        } else {
+            _Init(_First, _Last);
+        }
+    }
+
+    template <size_t _Nx>
+    regex_token_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re, const int (&_Subx)[_Nx],
+        regex_constants::match_flag_type _Fl = regex_constants::match_default)
+        : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(_Subx, _Subx + _Nx) {
+        _Init(_First, _Last);
+    }
+
+    regex_token_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re, initializer_list<int> _Ilist,
+        regex_constants::match_flag_type _Fl = regex_constants::match_default)
+        : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(_Ilist.begin(), _Ilist.end()) {
+        _Init(_First, _Last);
+    }
+
+    regex_token_iterator(_BidIt, _BidIt, const regex_type&&, int = 0,
+        regex_constants::match_flag_type = regex_constants::match_default) = delete;
+
+    regex_token_iterator(_BidIt, _BidIt, const regex_type&&, const vector<int>&,
+        regex_constants::match_flag_type = regex_constants::match_default) = delete;
+
+    template <size_t _Nx>
+    regex_token_iterator(_BidIt, _BidIt, const regex_type&&, const int (&)[_Nx],
+        regex_constants::match_flag_type = regex_constants::match_default) = delete;
+
+    regex_token_iterator(_BidIt, _BidIt, const regex_type&&, initializer_list<int>,
+        regex_constants::match_flag_type = regex_constants::match_default) = delete;
+
+    regex_token_iterator(const regex_token_iterator& _Right)
+        : _Pos(_Right._Pos), _Suffix(_Right._Suffix), _Cur(_Right._Cur), _Subs(_Right._Subs) {
+        // construct copy of _Right
+        if (!_Right._Res) {
+            _Res = nullptr;
+        } else if (_Right._Res == _STD addressof(_Right._Suffix)) {
+            _Res = _STD addressof(_Suffix);
+        } else {
+            _Res = _Current();
+        }
+    }
+
+    regex_token_iterator& operator=(const regex_token_iterator& _Right) {
+        if (this != _STD addressof(_Right)) { // copy from _Right
+            _Pos    = _Right._Pos;
+            _Cur    = _Right._Cur;
+            _Suffix = _Right._Suffix;
+            _Subs   = _Right._Subs;
+            if (!_Right._Res) {
+                _Res = nullptr;
+            } else if (_Right._Res == _STD addressof(_Right._Suffix)) {
+                _Res = _STD addressof(_Suffix);
+            } else {
+                _Res = _Current();
+            }
+        }
+        return *this;
+    }
+
+    _NODISCARD bool operator==(const regex_token_iterator& _Right) const {
+        if (!_Res || !_Right._Res) {
+            return _Res == _Right._Res;
+        }
+
+        return *_Res == *_Right._Res && _Pos == _Right._Pos && _Subs == _Right._Subs;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const regex_token_iterator& _Right) const {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX20
+    _NODISCARD bool operator==(default_sentinel_t) const noexcept /* strengthened */ {
+        return !_Res;
+    }
+#endif // _HAS_CXX20
+
+    _NODISCARD const value_type& operator*() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Res, "regex_token_iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        _Analysis_assume_(_Res);
+        return *_Res;
+    }
+
+    _NODISCARD const value_type* operator->() const noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Res, "regex_token_iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Res;
+    }
+
+    regex_token_iterator& operator++() {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Res, "regex_token_iterator not incrementable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        if (_Res == _STD addressof(_Suffix)) {
+            _Res = nullptr;
+        } else if (++_Cur < _Subs.size()) {
+            _Res = _Current();
+        } else { // advance to next full match
+            _Cur = 0;
+            _Position _Prev(_Pos);
+            ++_Pos;
+            if (!_Pos._Atend()) {
+                _Res = _Current();
+            } else if (_Has_suffix() && _Prev->suffix().length() != 0) { // mark suffix
+                _Suffix.matched = true;
+                _Suffix.first   = _Prev->suffix().first;
+                _Suffix.second  = _Prev->suffix().second;
+                _Res            = _STD addressof(_Suffix);
+            } else {
+                _Res = nullptr;
+            }
+        }
+
+        return *this;
+    }
+
+    regex_token_iterator operator++(int) {
+        regex_token_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+private:
+    _Position _Pos;
+    const value_type* _Res = nullptr;
+    value_type _Suffix;
+    size_t _Cur = 0;
+    vector<int> _Subs;
+
+    bool _Has_suffix() const { // check for suffix specifier
+        return _STD find(_Subs.begin(), _Subs.end(), -1) != _Subs.end();
+    }
+
+    void _Init(_BidIt _First, _BidIt _Last) { // initialize
+        _Adl_verify_range(_First, _Last);
+        if (!_Pos._Atend()) {
+            _Res = _Current();
+        } else if (_Has_suffix()) { // mark suffix (no match)
+            _Suffix.matched = true;
+            _Suffix.first   = _First;
+            _Suffix.second  = _Last;
+            _Res            = _STD addressof(_Suffix);
+        } else {
+            _Res = nullptr;
+        }
+    }
+
+    const value_type* _Current() const noexcept {
+        return &(_Subs[_Cur] == -1 ? _Pos->prefix() : (*_Pos)[static_cast<size_t>(_Subs[_Cur])]);
+    }
+};
+
+_EXPORT_STD using cregex_token_iterator  = regex_token_iterator<const char*>;
+_EXPORT_STD using wcregex_token_iterator = regex_token_iterator<const wchar_t*>;
+_EXPORT_STD using sregex_token_iterator  = regex_token_iterator<string::const_iterator>;
+_EXPORT_STD using wsregex_token_iterator = regex_token_iterator<wstring::const_iterator>;
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Builder2<_FwdIt, _Elem, _RxTraits>::_Builder2(const _RxTraits& _Tr, regex_constants::syntax_option_type _Fx)
+    : _Root(new _Root_node), _Current(_Root), _Flags(_Fx), _Traits(_Tr) {}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Setlong() { // set flag
+    _Root->_Flags |= _Fl_longest;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Negate() { // set flag
+    _Current->_Flags ^= _Fl_negate;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Node_base* _Builder2<_FwdIt, _Elem, _RxTraits>::_Getmark() const {
+    return _Current;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Node_base* _Builder2<_FwdIt, _Elem, _RxTraits>::_Link_node(_Node_base* _Nx) { // insert _Nx at current location
+    _Nx->_Prev = _Current;
+    if (_Current->_Next) { // set back pointer
+        _Nx->_Next             = _Current->_Next;
+        _Current->_Next->_Prev = _Nx;
+    }
+    _Current->_Next = _Nx;
+    _Current        = _Nx;
+    return _Nx;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Insert_node(_Node_base* _Insert_before, _Node_base* _To_insert) {
+    // insert _To_insert into the graph before the node _Insert_before
+    _Insert_before->_Prev->_Next = _To_insert;
+    _To_insert->_Prev            = _Insert_before->_Prev;
+    _Insert_before->_Prev        = _To_insert;
+    _To_insert->_Next            = _Insert_before;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Node_base* _Builder2<_FwdIt, _Elem, _RxTraits>::_New_node(_Node_type _Kind) { // allocate and link simple node
+    return _Link_node(new _Node_base(_Kind));
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_bol() { // add bol node
+    _New_node(_N_bol);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_eol() { // add eol node
+    _New_node(_N_eol);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_wbound() { // add wbound node
+    _New_node(_N_wbound);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_dot() { // add dot node
+    _New_node(_N_dot);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_str_node() { // add string node
+    _Link_node(new _Node_str<_Elem>);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_char(_Elem _Ch) { // append character
+    if (_Current->_Kind != _N_str) {
+        _Add_str_node();
+    }
+
+    if (_Flags & regex_constants::icase) {
+        _Ch = _Traits.translate_nocase(_Ch);
+    } else if (_Flags & regex_constants::collate) {
+        _Ch = _Traits.translate(_Ch);
+    }
+
+    _Node_str<_Elem>* _Node = static_cast<_Node_str<_Elem>*>(_Current);
+    _Node->_Data._Insert2(_Ch);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_class() { // add bracket expression node
+    _Link_node(new _Node_class<_Elem, _RxTraits>);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_char_to_bitmap(unsigned char _Ch) { // add character to accelerator table
+    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
+
+    if (!_Node->_Small) {
+        _Node->_Small = new _Bitmap;
+    }
+
+    _Node->_Small->_Mark(_Ch);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_char_to_array(_Elem _Ch) { // append character to character array
+    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
+    if (!_Node->_Large) {
+        _Node->_Large = new _Buf<_Elem>;
+    }
+
+    _Node->_Large->_Insert2(_Ch);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_char_to_class(_Elem _Ch) { // add character to bracket expression
+    if (_Flags & regex_constants::icase) {
+        _Ch = _Traits.translate_nocase(_Ch);
+    } else if (_Flags & regex_constants::collate) {
+        _Ch = _Traits.translate(_Ch);
+    }
+
+    auto _Uchar = static_cast<unsigned char>(_Ch);
+    if (static_cast<_Elem>(_Uchar) == _Ch) {
+        _Add_char_to_bitmap(_Uchar);
+    } else {
+        _Add_char_to_array(_Ch);
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_range(_Elem _Arg0, const _Elem _Arg1) {
+    // add character range to set
+    using _String_type                   = typename _RxTraits::string_type;
+    using _Char_traits_type              = typename _String_type::traits_type;
+    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
+
+    // set bits and check that the range is non-empty
+    if (_Flags & regex_constants::collate) {
+        _Elem _Ch;
+        const auto _Ch_ptr           = _STD addressof(_Ch);
+        const auto _Arg0_ptr         = _STD addressof(_Arg0);
+        const auto _Arg1_ptr         = _STD addressof(_Arg1);
+        const _String_type _Arg0_key = _Traits.transform(_Arg0_ptr, _Arg0_ptr + 1);
+        const _String_type _Arg1_key = _Traits.transform(_Arg1_ptr, _Arg1_ptr + 1);
+
+        if (_Arg0_key > _Arg1_key) {
+            _Xregex_error(regex_constants::error_range);
+        }
+
+        for (unsigned int _UCh = 0; _UCh < _Bmp_max; ++_UCh) {
+            _Ch                        = static_cast<_Elem>(_UCh);
+            const _String_type _Ch_key = _Traits.transform(_Ch_ptr, _Ch_ptr + 1);
+            if (_Arg0_key <= _Ch_key && _Ch_key <= _Arg1_key) {
+                if (!_Node->_Small) {
+                    _Node->_Small = new _Bitmap;
+                }
+                _Node->_Small->_Mark(_UCh);
+            }
+        }
+    } else if (_Char_traits_type::lt(_Arg1, _Arg0)) {
+        _Xregex_error(regex_constants::error_range);
+    } else {
+        unsigned int _Ex0 = static_cast<unsigned char>(_Arg0);
+        if (static_cast<_Elem>(_Ex0) == _Arg0) {
+            if (!_Node->_Small) {
+                _Node->_Small = new _Bitmap;
+            }
+
+            unsigned int _Ex1           = static_cast<unsigned char>(_Arg1);
+            bool _Extends_beyond_bitmap = static_cast<_Elem>(_Ex1) != _Arg1;
+            if (_Extends_beyond_bitmap) {
+                _Ex1 = _Bmp_max - 1;
+            }
+
+            for (; _Ex0 <= _Ex1; ++_Ex0) {
+                _Node->_Small->_Mark(_Ex0);
+            }
+
+            if (!_Extends_beyond_bitmap) {
+                return;
+            }
+
+            _Arg0 = static_cast<_Elem>(_Ex0);
+        }
+
+        if constexpr (sizeof(_Elem) > 1U) {
+            if constexpr (is_integral_v<_Elem> || is_enum_v<_Elem>) {
+                using _Uelem = make_unsigned_t<_Elem>;
+                auto _First  = static_cast<_Uelem>(_Arg0);
+                auto _Last   = static_cast<_Uelem>(_Arg1);
+                auto _Count  = static_cast<_Uelem>(_Last - _First);
+                ++_Count;
+                if (_Count <= _ARRAY_THRESHOLD) {
+                    for (; _Count > 0; ++_First, --_Count) {
+                        _Add_char_to_array(static_cast<_Elem>(_First));
+                    }
+                    return;
+                }
+            } else {
+                auto _Last = static_cast<unsigned int>(_Arg1);
+                if (static_cast<_Elem>(_Last) == _Arg1) {
+                    auto _First = static_cast<unsigned int>(_Arg0);
+                    auto _Count = _Last - _First + 1U;
+                    if (_Count <= _ARRAY_THRESHOLD) {
+                        for (; _Count > 0; ++_First, --_Count) {
+                            _Add_char_to_array(static_cast<_Elem>(_First));
+                        }
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    // store remaining range as pair
+    if (!_Node->_Ranges) {
+        _Node->_Ranges = new _Buf<_Elem>;
+    }
+
+    _Node->_Ranges->_Insert2(_Arg0);
+    _Node->_Ranges->_Insert2(_Arg1);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_elts(
+    _Node_class<_Elem, _RxTraits>* _Node, typename _RxTraits::char_class_type _Cl, bool _Negative) {
+    // add characters in named class to set
+    for (unsigned int _Ch = 0; _Ch < _Bmp_max; ++_Ch) { // add elements or their inverse
+        bool _Matches = _Traits.isctype(static_cast<_Elem>(_Ch), _Cl);
+        if (_Matches != _Negative) { // add contents of named class to accelerator table
+            if (!_Node->_Small) {
+                _Node->_Small = new _Bitmap;
+            }
+
+            _Node->_Small->_Mark(_Ch);
+        }
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_named_class(
+    typename _RxTraits::char_class_type _Cl, const _Rx_char_class_kind _Kind) {
+    // add contents of named class to bracket expression
+    using _Char_class_type               = typename _RxTraits::char_class_type;
+    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
+    _Add_elts(_Node, _Cl, _Kind != _Rx_char_class_kind::_Positive);
+    if constexpr (sizeof(_Elem) > 1U) {
+        if (_Kind == _Rx_char_class_kind::_Positive) {
+            auto _Cl_all_bits_set = static_cast<_Char_class_type>(-1);
+            if ((_Node->_Classes != _Cl_all_bits_set && _Cl != _Cl_all_bits_set)
+                || _Node->_Classes == _Char_class_type{}) {
+                _Node->_Classes = static_cast<_Char_class_type>(_Node->_Classes | _Cl);
+            } else if (_Node->_Classes != _Cl) {
+                _Node->_Classes = static_cast<_Char_class_type>(_Node->_Classes & _Cl);
+                _Node->_Flags |= _Fl_class_cl_all_bits;
+            }
+        } else {
+            auto _Node_flag = static_cast<_Node_flags>(_Kind);
+            _Node->_Flags |= _Node_flag;
+            _Root->_Flags |= _Node_flag;
+        }
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Char_to_elts(const _Elem* const _First, const _Elem* const _Last,
+    _Sequence<_Elem>** _Cur) { // add collation element to element sequence
+    auto _Diff = static_cast<unsigned int>(_Last - _First);
+    while (*_Cur && _Diff < (*_Cur)->_Sz) {
+        _Cur = &(*_Cur)->_Next;
+    }
+
+    if (!(*_Cur) || _Diff != (*_Cur)->_Sz) {
+        // add new sequence holding elements of the same length
+        _Sequence<_Elem>* _Node = *_Cur;
+        *_Cur                   = new _Sequence<_Elem>(_Diff);
+        (*_Cur)->_Next          = _Node;
+    }
+    (*_Cur)->_Data._Insert2(_First, _Last);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_equiv(const _Elem* const _First, const _Elem* const _Last) {
+    // add elements of equivalence class to bracket expression
+    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
+    typename _RxTraits::string_type _Str = _Traits.transform_primary(_First, _Last);
+
+    if (_Str.empty()) {
+        _Xregex_error(regex_constants::error_collate);
+    }
+
+    for (unsigned int _Ch = 0; _Ch < _Bmp_max; ++_Ch) { // add elements
+        _Elem _Ex = static_cast<_Elem>(_Ch);
+        if (_Traits.transform_primary(_STD addressof(_Ex), _STD addressof(_Ex) + 1)
+            == _Str) { // insert equivalent character into bitmap
+            if (!_Node->_Small) {
+                _Node->_Small = new _Bitmap;
+            }
+
+            _Node->_Small->_Mark(_Ch);
+        }
+    }
+
+    if constexpr (sizeof(_Elem) > 1U) { // map range
+        _Sequence<_Elem>** _Cur = _STD addressof(_Node->_Equiv);
+        _Char_to_elts(_First, _Last, _Cur);
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_coll(const _Elem* const _First, const _Elem* const _Last) {
+    // add collation element to bracket expression
+    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
+    _Sequence<_Elem>** _Cur              = _STD addressof(_Node->_Coll);
+    _Char_to_elts(_First, _Last, _Cur);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Node_base* _Builder2<_FwdIt, _Elem, _RxTraits>::_Begin_group() { // add group node
+    return _New_node(_N_group);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_End_group(_Node_base* _Back) { // add end of group node
+    _Node_type _Elt;
+    if (_Back->_Kind == _N_group) {
+        _Elt = _N_end_group;
+    } else if (_Back->_Kind == _N_assert || _Back->_Kind == _N_neg_assert) {
+        _Elt = _N_end_assert;
+    } else {
+        _Elt = _N_end_capture;
+    }
+
+    _Link_node(new _Node_end_group(_Elt, _Fl_none, _Back));
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Node_assert* _Builder2<_FwdIt, _Elem, _RxTraits>::_Begin_assert_group2(const bool _Neg) { // add assert node
+    const auto _Node = new _Node_assert(_Neg ? _N_neg_assert : _N_assert);
+    _Link_node(_Node);
+    return _Node;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_End_assert_group2(_Node_assert* const _Assert_start) {
+    // add end of assert node
+    _End_group(_Assert_start);
+    _Assert_start->_Child = _Assert_start->_Next;
+    _Assert_start->_Next  = nullptr;
+    _Current              = _Assert_start;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Node_base* _Builder2<_FwdIt, _Elem, _RxTraits>::_Begin_capture_group(unsigned int _Idx) { // add capture group node
+    return _Link_node(new _Node_capture(_Idx));
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_backreference(unsigned int _Idx) { // add back reference node
+    _Link_node(new _Node_back(_Idx));
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Node_base* _Builder2<_FwdIt, _Elem, _RxTraits>::_Begin_if(_Node_base* _Start) { // add if node
+    // append endif node
+    _Node_base* _Res = new _Node_endif;
+    _Link_node(_Res);
+
+    // insert if_node
+    _Node_if* _Node1 = new _Node_if(_Res);
+    _Node_base* _Pos = _Start->_Next;
+    _Insert_node(_Pos, _Node1);
+    return _Res;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Else_if2(_Node_base* const _Start, _Node_base* const _End) { // add else node
+    auto _Parent = static_cast<_Node_if*>(_Start->_Next);
+    while (_Parent->_Child) {
+        _Parent = _Parent->_Child;
+    }
+
+    const auto _Elseif_node = new _Node_if(_End);
+    _Parent->_Child         = _Elseif_node;
+    const auto _First       = _End->_Next;
+    if (_First) {
+        _End->_Next         = nullptr;
+        _Elseif_node->_Next = _First;
+        _First->_Prev       = _Elseif_node;
+        _Current->_Next     = _End;
+    } else { // empty alternative
+        _Elseif_node->_Next = _End;
+    }
+
+    _Current = _End;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Add_rep(int _Min, int _Max, bool _Greedy) { // add repeat node
+    if (_Current->_Kind == _N_str
+        && static_cast<_Node_str<_Elem>*>(_Current)->_Data._Size() != 1) { // move final character to new string node
+        _Node_str<_Elem>* _Node = static_cast<_Node_str<_Elem>*>(_Current);
+        _Add_str_node();
+        _Add_char(_Node->_Data._Del());
+    }
+
+    _Node_base* _Pos = _Current;
+    if (_Pos->_Kind == _N_end_group || _Pos->_Kind == _N_end_capture) {
+        _Pos = static_cast<_Node_end_group*>(_Pos)->_Back;
+    } else if (_Min == 0 && _Max == 1) {
+        // Rewrite zero-or-one quantifiers as alternations to make the
+        // "simple loop" optimization more likely to engage.
+        //
+        // GH-5490: This rewrite becomes observably incorrect
+        // if the subexpression contains capture groups,
+        // so we don't apply it if the subexpression is surrounded
+        // by a capturing or non-capturing group.
+        _Node_endif* _End       = new _Node_endif;
+        _Node_if* _If_expr      = new _Node_if(_End);
+        _Node_if* _If_empty_str = new _Node_if(_End);
+        _If_empty_str->_Next    = _End;
+        _If_expr->_Child        = _If_empty_str;
+
+        _Link_node(_End);
+        _Insert_node(_Pos, _If_expr);
+
+        if (!_Greedy) {
+            _If_expr->_Next->_Prev = _If_empty_str;
+            _End->_Prev            = _If_expr;
+            _STD swap(_If_expr->_Next, _If_empty_str->_Next);
+        }
+        return;
+    }
+
+    if (_Root->_Loops == static_cast<unsigned int>(-1)) {
+        _Xregex_error(regex_constants::error_space);
+    }
+
+    _Node_end_rep* _Node0 = new _Node_end_rep();
+    _Link_node(_Node0);
+    _Node_rep* _Nx     = new _Node_rep(_Greedy, _Min, _Max, _Node0, _Root->_Loops++);
+    _Node0->_Begin_rep = _Nx;
+    _Insert_node(_Pos, _Nx);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Root_node* _Builder2<_FwdIt, _Elem, _RxTraits>::_End_pattern() { // wrap up
+    _New_node(_N_end);
+    return _Root;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Builder2<_FwdIt, _Elem, _RxTraits>::_Tidy() noexcept { // free memory
+    _Destroy_node(_Root);
+    _Root = nullptr;
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+size_t _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Push_frame(_Rx_unwind_ops _Code, _Node_base* _Node) {
+    if (_Frames_count >= _Frames._Size()) {
+        if (_Frames_count >= _Frames_limit) {
+            _Xregex_error(regex_constants::error_stack);
+        }
+
+        _Frames._Push_back({_Code, {0}, _Node, _Tgt_state._Cur, size_t{}});
+    } else {
+        auto& _Frame = _Frames[_Frames_count];
+        _Frame._Code = _Code;
+        _Frame._Node = _Node;
+        _Frame._Pos  = _Tgt_state._Cur;
+    }
+    return _Frames_count++;
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+size_t _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Calculate_frames_limit(_Iter_diff_t<_It> _Input_length) {
+    constexpr size_t _Fixed_part  = 10000000U / sizeof(_State_frame_type);
+    constexpr size_t _Divisor     = sizeof(_State_frame_type) / 10U;
+    const auto _Variable_part     = _Input_length / static_cast<_Iter_diff_t<_It>>(_Divisor);
+    const size_t _Max_frames_size = _Frames._Max_size();
+
+    if (PTRDIFF_MAX < _Variable_part) {
+        return _Max_frames_size;
+    }
+
+    return (_STD min) (_Max_frames_size, static_cast<size_t>(_Variable_part) + _Fixed_part);
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+long long _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Calculate_complexity_limit(_Iter_diff_t<_It> _Input_length) {
+    constexpr long long _Intercept = 300000LL;
+    constexpr long long _Gradient  = 256LL;
+    if ((LLONG_MAX - _Intercept) / _Gradient < _Input_length) {
+        return LLONG_MAX;
+    }
+    return _Gradient * static_cast<long long>(_Input_length) + _Intercept;
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+void _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Increase_complexity_count(_Iter_diff_t<_It> _Count) {
+    if (_Complexity_limit < _Count) {
+        _Xregex_error(regex_constants::error_complexity);
+    } else {
+        _Complexity_limit -= static_cast<long long>(_Count);
+    }
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+void _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Prepare_rep(_Node_rep* _Node) {
+    const auto _Psav = &_Loop_vals[_Node->_Loop_number];
+
+    // Determine first capture group in repetition for later capture group reset, if not done so previously.
+    // No capture group reset is performed for POSIX regexes,
+    // so we prevent any reset by setting the first capture group to the size of the capture group vector.
+    if (_Psav->_Group_first == 0U) {
+        if ((_Sflags & regex_constants::_Any_posix) || !_Find_first_inner_capture_group(_Node->_Next, _Psav)) {
+            _Psav->_Group_first = static_cast<unsigned int>(_Tgt_state._Grps._Size());
+        }
+    }
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+bool _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Find_first_inner_capture_group(
+    _Node_base* _Nx, _Loop_vals_type* _Loop_state) {
+
+    bool _Found_group = false;
+    while (_Nx) {
+        switch (_Nx->_Kind) {
+        case _N_nop:
+        case _N_bol:
+        case _N_eol:
+        case _N_wbound:
+        case _N_dot:
+        case _N_str:
+        case _N_class:
+        case _N_group:
+        case _N_end_group:
+        case _N_end_capture:
+        case _N_back:
+        case _N_begin:
+            break;
+
+        case _N_assert:
+        case _N_neg_assert:
+            if (_Find_first_inner_capture_group(static_cast<_Node_assert*>(_Nx)->_Child, _Loop_state)) {
+                _Found_group = true;
+                _Nx          = nullptr;
+            }
+            break;
+
+        case _N_capture:
+            {
+                _Node_capture* _Node      = static_cast<_Node_capture*>(_Nx);
+                _Loop_state->_Group_first = _Node->_Idx - 1U;
+                _Found_group              = true;
+                _Nx                       = nullptr;
+                break;
+            }
+
+        case _N_if:
+            for (_Node_if* _Node = static_cast<_Node_if*>(_Nx); _Node; _Node = _Node->_Child) {
+                if (_Find_first_inner_capture_group(_Node->_Next, _Loop_state)) {
+                    _Found_group = true;
+                    _Nx          = nullptr;
+                    break;
+                }
+            }
+
+            if (_Nx) { // continue search after the branches of the _N_if node
+                _Nx = static_cast<_Node_if*>(_Nx)->_Endif;
+            }
+            break;
+
+        case _N_rep:
+            {
+                const auto _Inner_rep        = static_cast<_Node_rep*>(_Nx);
+                const auto _Inner_loop_state = &_Loop_vals[_Inner_rep->_Loop_number];
+                if (_Find_first_inner_capture_group(_Inner_rep->_Next, _Inner_loop_state)) {
+                    _Loop_state->_Group_first = _Inner_loop_state->_Group_first;
+                    _Found_group              = true;
+                    _Nx                       = nullptr;
+                } else {
+                    _Inner_loop_state->_Group_first = static_cast<unsigned int>(_Tgt_state._Grps._Size());
+                    _Nx                             = _Inner_rep->_End_rep;
+                }
+                break;
+            }
+
+        case _N_end_assert:
+        case _N_endif:
+        case _N_end_rep:
+        case _N_end:
+        case _N_none:
+        default:
+            _Nx = nullptr;
+            break;
+        }
+
+        if (_Nx) {
+            _Nx = _Nx->_Next;
+        }
+    }
+
+    return _Found_group;
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+void _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Reset_capture_groups(unsigned int _First) {
+    size_t _Size = _Tgt_state._Grps._Size();
+    for (; _First < _Size; ++_First) {
+        if (_Tgt_state._Grp_valid._Get(_First)) {
+            _Tgt_state._Grp_valid._Clear(_First);
+            auto _Frame_idx                  = _Push_frame(_Rx_unwind_ops::_Capture_restore_matched, nullptr);
+            _Frames[_Frame_idx]._Capture_idx = _First;
+        }
+    }
+}
+
+template <class _BidIt1, class _BidIt2, class _Counter, class _Pr>
+_BidIt1 _Cmp_chrange(_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, _Counter& _Count, _Pr _Pred) {
+    // compare character ranges
+    _BidIt1 _Res = _Begin1;
+    while (_Begin1 != _End1 && _Begin2 != _End2) {
+        ++_Count;
+        if (!_Pred(*_Begin1++, *_Begin2++)) {
+            return _Res;
+        }
+    }
+    return _Begin2 == _End2 ? _Begin1 : _Res;
+}
+
+template <class _BidIt1, class _BidIt2, class _RxTraits, class _Counter>
+_BidIt1 _Compare_translate_both(_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2,
+    const _RxTraits& _Traits, regex_constants::syntax_option_type _Sflags, _Counter& _Count) {
+    // compare character ranges, translating characters in both ranges according to syntax options
+    if (_Sflags & regex_constants::icase) {
+        return _STD _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Count, _Cmp_icase<_RxTraits>{_Traits});
+    } else if constexpr (_Is_any_of_v<_RxTraits, regex_traits<char>, regex_traits<wchar_t>>) {
+        return _STD _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Count, equal_to<typename _RxTraits::char_type>{});
+    } else if (_Sflags & regex_constants::collate) {
+        return _STD _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Count, _Cmp_collate<_RxTraits>{_Traits});
+    } else {
+        return _STD _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Count, equal_to<typename _RxTraits::char_type>{});
+    }
+}
+
+template <class _BidIt1, class _BidIt2, class _RxTraits, class _Counter>
+_BidIt1 _Compare_translate_left(_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2,
+    const _RxTraits& _Traits, regex_constants::syntax_option_type _Sflags, _Counter& _Count) {
+    // compare character ranges, translating characters in the left range according to syntax options
+    if (_Sflags & regex_constants::icase) {
+        return _STD _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Count, _Cmp_icase_translateleft<_RxTraits>{_Traits});
+    } else if constexpr (_Is_any_of_v<_RxTraits, regex_traits<char>, regex_traits<wchar_t>>) {
+        return _STD _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Count, equal_to<typename _RxTraits::char_type>{});
+    } else if (_Sflags & regex_constants::collate) {
+        return _STD _Cmp_chrange(
+            _Begin1, _End1, _Begin2, _End2, _Count, _Cmp_collate_translateleft<_RxTraits>{_Traits});
+    } else {
+        return _STD _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Count, equal_to<typename _RxTraits::char_type>{});
+    }
+}
+
+template <class _BidIt1, class _BidIt2, class _RxTraits>
+_BidIt1 _Search_translate_left(_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, const _RxTraits& _Traits,
+    regex_constants::syntax_option_type _Sflags) {
+    // searching the right character sequence in the left sequence,
+    // after translating characters in the left sequence according to syntax options
+    if (_Sflags & regex_constants::icase) {
+        return _STD search(_Begin1, _End1, _Begin2, _End2, _Cmp_icase_translateleft<_RxTraits>{_Traits});
+    } else if constexpr (_Is_any_of_v<_RxTraits, regex_traits<char>, regex_traits<wchar_t>>) {
+        return _STD search(_Begin1, _End1, _Begin2, _End2, equal_to<typename _RxTraits::char_type>{});
+    } else if (_Sflags & regex_constants::collate) {
+        return _STD search(_Begin1, _End1, _Begin2, _End2, _Cmp_collate_translateleft<_RxTraits>{_Traits});
+    } else {
+        return _STD search(_Begin1, _End1, _Begin2, _End2, equal_to<typename _RxTraits::char_type>{});
+    }
+}
+
+template <class _Char_traits, class _Elem>
+bool _Lookup_range(const _Elem _Ch, const _Buf<_Elem>* const _Bufptr) { // check whether _Ch is in _Buf
+    for (unsigned int _Ix = 0; _Ix < _Bufptr->_Size(); _Ix += 2) { // check current position
+        const _Elem _Left  = _Bufptr->_At(_Ix);
+        const _Elem _Right = _Bufptr->_At(_Ix + 1);
+
+        bool _Within_range;
+        if constexpr (is_same_v<_Char_traits, char_traits<char>>) {
+            const auto _Uchar = static_cast<unsigned char>(_Ch);
+            _Within_range = static_cast<unsigned char>(_Left) <= _Uchar && _Uchar <= static_cast<unsigned char>(_Right);
+        } else if constexpr (is_same_v<_Char_traits, char_traits<wchar_t>>) {
+            _Within_range = _Left <= _Ch && _Ch <= _Right;
+        } else {
+            _Within_range = !_Char_traits::lt(_Ch, _Left) && !_Char_traits::lt(_Right, _Ch);
+        }
+
+        if (_Within_range) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+template <class _Elem, class _RxTraits>
+bool _Lookup_collating_range(const _Elem _Ch, const _Buf<_Elem>* const _Bufptr, const _RxTraits& _Traits) {
+    const typename _RxTraits::string_type _Str = _Traits.transform(_STD addressof(_Ch), _STD addressof(_Ch) + 1);
+    for (unsigned int _Ix = 0; _Ix < _Bufptr->_Size(); _Ix += 2) { // check current position
+        const _Elem _Left  = _Bufptr->_At(_Ix);
+        const _Elem _Right = _Bufptr->_At(_Ix + 1);
+        if (_Traits.transform(_STD addressof(_Left), _STD addressof(_Left) + 1) <= _Str
+            && _Str <= _Traits.transform(_STD addressof(_Right), _STD addressof(_Right) + 1)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+template <class _Elem, class _RxTraits>
+bool _Lookup_equiv2(_Elem _Ch, const _Sequence<_Elem>* _Eq, const _RxTraits& _Traits) {
+    // check whether _Ch is in _Eq
+    typename _RxTraits::string_type _Str0;
+    typename _RxTraits::string_type _Str1;
+    _Str1.push_back(_Ch);
+    _Str1 = _Traits.transform_primary(_Str1.begin(), _Str1.end());
+    while (_Eq) { // look for sequence of elements that are the right size
+        for (unsigned int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz) { // look for _Ch
+            _Str0.assign(_Eq->_Data._Str() + _Ix, _Eq->_Sz);
+            _Str0 = _Traits.transform_primary(_Str0.begin(), _Str0.end());
+            if (_Str0 == _Str1) {
+                return true;
+            }
+        }
+        _Eq = _Eq->_Next;
+    }
+    return false;
+}
+
+template <class _BidIt, class _Elem, class _RxTraits>
+_BidIt _Lookup_coll2(_Elem _First_ch, _BidIt _First, const _BidIt _Last, const _Sequence<_Elem>* _Seq,
+    const _RxTraits& _Traits, const regex_constants::syntax_option_type _Flags) {
+    // look for collation element [_First, _Last) in _Seq
+    typename _RxTraits::string_type _Str;
+
+    // extend translated input character sequence
+    if (_Seq) { // the longest collating elements come first
+        _Str.push_back(_First_ch);
+        const auto _Coll_size = _Seq->_Sz;
+        size_t _Str_size      = 1;
+        _BidIt _Pos           = _First;
+        ++_Pos;
+
+        for (; _Str_size < _Coll_size && _Pos != _Last; ++_Pos) {
+            _Elem _Ch = *_Pos;
+            if (_Flags & regex_constants::icase) {
+                _Ch = _Traits.translate_nocase(_Ch);
+            } else if (_Flags & regex_constants::collate) {
+                _Ch = _Traits.translate(_Ch);
+            }
+            _Str.push_back(_Ch);
+            ++_Str_size;
+        }
+    }
+
+    while (_Seq) { // look for sequence of elements that are the right size
+        const auto _Size = _Seq->_Sz;
+
+        // match input character sequence to stored collating elements
+        if (_Str.size() >= _Size) {
+            const _Elem* const _Str_first = _Str.data();
+            const _Elem* const _Str_last  = _Str_first + _Size;
+            const _Elem* _Current         = _Seq->_Data._Str();
+            for (auto _Remaining = _Seq->_Data._Size(); _Remaining >= _Size; _Current += _Size, _Remaining -= _Size) {
+                if (_STD equal(_Str_first, _Str_last, _Current)) {
+                    _STD advance(_First, static_cast<_Iter_diff_t<_BidIt>>(_Size));
+                    return _First;
+                }
+            }
+        }
+        _Seq = _Seq->_Next;
+    }
+    return _First;
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+_It _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Do_class(const _Node_base* const _Nx, _It _First) {
+    // apply bracket expression
+    bool _Found;
+    _Elem _Ch = *_First;
+    if (_Sflags & regex_constants::icase) {
+        _Ch = _Traits.translate_nocase(_Ch);
+    } else if (_Sflags & regex_constants::collate) {
+        _Ch = _Traits.translate(_Ch);
+    }
+    const auto _Uchar = static_cast<unsigned char>(_Ch);
+
+    _It _Res0 = _First;
+    ++_Res0;
+    _It _Resx;
+    const auto _Node = static_cast<const _Node_class<_Elem, _RxTraits>*>(_Nx);
+    if (_Node->_Coll
+        && (_Resx = _STD _Lookup_coll2(_Ch, _First, _End, _Node->_Coll, _Traits, _Sflags))
+               != _First) { // check for collation element
+        _Res0  = _Resx;
+        _Found = true;
+    } else if (_Node->_Ranges
+               && (_Sflags & regex_constants::collate
+                       ? _STD _Lookup_collating_range(_Ch, _Node->_Ranges, _Traits)
+                       : _STD _Lookup_range<typename _RxTraits::string_type::traits_type>(_Ch, _Node->_Ranges))) {
+        _Found = true;
+    } else if (static_cast<_Elem>(_Uchar) == _Ch) {
+        _Found = _Node->_Small && _Node->_Small->_Find(_Uchar);
+    } else if (_Node->_Large
+               && _STD find(_Node->_Large->_Str(), _Node->_Large->_Str() + _Node->_Large->_Size(), _Ch)
+                      != _Node->_Large->_Str() + _Node->_Large->_Size()) {
+        _Found = true;
+    } else if (_Node->_Classes != typename _RxTraits::char_class_type{} && _Traits.isctype(_Ch, _Node->_Classes)) {
+        _Found = true;
+    } else if ((_Node->_Flags & _Fl_class_cl_all_bits)
+               && _Traits.isctype(_Ch, static_cast<typename _RxTraits::char_class_type>(-1))) {
+        _Found = true;
+    } else if (_Node->_Equiv && _STD _Lookup_equiv2(_Ch, _Node->_Equiv, _Traits)) {
+        _Found = true;
+    } else if ((_Node->_Flags & _Fl_class_negated_w) && !_Traits.isctype(_Ch, _Char_class_w)) {
+        _Found = true;
+    } else if ((_Node->_Flags & _Fl_class_negated_s) && !_Traits.isctype(_Ch, _Char_class_s)) {
+        _Found = true;
+    } else if ((_Node->_Flags & _Fl_class_negated_d) && !_Traits.isctype(_Ch, _Char_class_d)) {
+        _Found = true;
+    } else {
+        _Found = false;
+    }
+
+    const bool _Negated = (_Node->_Flags & _Fl_negate) != 0;
+
+    if (_Found == _Negated) {
+        return _First;
+    } else {
+        return _Res0;
+    }
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+bool _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Better_match() {
+    // check for better match under leftmost-longest rule
+
+    // a longer match is better than a shorter one
+    if (_Res._Cur != _Tgt_state._Cur) {
+        return _STD distance(_Begin, _Res._Cur) < _STD distance(_Begin, _Tgt_state._Cur);
+    }
+
+    for (unsigned int _Ix = 0U; _Ix < _Ncap - 1U; ++_Ix) { // check each capture group
+        // any match (even an empty one) is better than no match at all
+        const bool _Valid_in_tgt_state = _Tgt_state._Grp_valid._Get(_Ix);
+        if (_Res._Grp_valid._Get(_Ix) != _Valid_in_tgt_state) {
+            return _Valid_in_tgt_state;
+        }
+
+        if (_Valid_in_tgt_state) { // now known to be equal to _Res._Grp_valid._Get(_Ix), no need to test both
+            // if both groups are matched, prefer the leftmost one
+            if (_Res._Grps[_Ix]._Begin != _Tgt_state._Grps[_Ix]._Begin) {
+                return _STD distance(_Begin, _Res._Grps[_Ix]._Begin)
+                     > _STD distance(_Begin, _Tgt_state._Grps[_Ix]._Begin);
+            }
+
+            // if both groups start at the same position, prefer the longer one
+            if (_Res._Grps[_Ix]._End != _Tgt_state._Grps[_Ix]._End) {
+                return _STD distance(_Res._Grps[_Ix]._Begin, _Res._Grps[_Ix]._End)
+                     < _STD distance(_Tgt_state._Grps[_Ix]._Begin, _Tgt_state._Grps[_Ix]._End);
+            }
+        }
+    }
+    return false;
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+bool _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Is_wbound() const {
+    if ((_Mflags & regex_constants::match_prev_avail)
+        || _Tgt_state._Cur != _Begin) { // if --_Cur is valid, check for preceding word character
+        if (_Tgt_state._Cur == _End) {
+            return (_Mflags & regex_constants::match_not_eow) == 0 && _STD _Is_word(*_Prev_iter(_Tgt_state._Cur));
+        } else {
+            return _STD _Is_word(*_Prev_iter(_Tgt_state._Cur)) != _STD _Is_word(*_Tgt_state._Cur);
+        }
+    } else { // --_Cur is not valid
+        if (_Tgt_state._Cur == _End) {
+            return false;
+        } else {
+            return (_Mflags & regex_constants::match_not_bow) == 0 && _STD _Is_word(*_Tgt_state._Cur);
+        }
+    }
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+typename _RxTraits::char_class_type _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Lookup_char_class(
+    const _Elem _Class_name) const {
+    // look up character class with single-character name
+    auto _Ptr = _STD addressof(_Class_name);
+    return _Traits.lookup_classname(_Ptr, _Ptr + 1, (_Sflags & regex_constants::icase) != 0);
+}
+
+template <class _Elem>
+bool _Is_ecmascript_line_terminator(_Elem _Ch) {
+    if constexpr (is_same_v<_Elem, char>) {
+        return _Ch == _Meta_nl || _Ch == _Meta_cr;
+    } else if constexpr (is_same_v<_Elem, wchar_t>) {
+        return _Ch == _Meta_nl || _Ch == _Meta_cr || _Ch == _Meta_ls || _Ch == _Meta_ps;
+    } else {
+        auto _UCh = static_cast<unsigned int>(_Ch);
+        return static_cast<_Elem>(_UCh) == _Ch
+            && (_UCh == _Meta_nl || _UCh == _Meta_cr || _UCh == _Meta_ls || _UCh == _Meta_ps);
+    }
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+bool _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Match_pat(_Node_base* _Nx) { // check for match
+    bool _Failed = false;
+
+    while (_Nx) {
+        do { // match current node
+            _Increase_complexity_count(_Iter_diff_t<_It>{1}); // one state transition
+            _Node_base* _Next = _Nx->_Next;
+            switch (_Nx->_Kind) { // handle current node's type
+            case _N_nop:
+                break;
+
+            case _N_bol:
+                if ((_Mflags & regex_constants::match_prev_avail)
+                    || _Tgt_state._Cur != _Begin) { // if --_Cur is valid, check for preceding newline
+                    _Failed = !(_Sflags & regex_constants::multiline)
+                           || !_STD _Is_ecmascript_line_terminator(*_STD _Prev_iter(_Tgt_state._Cur));
+                } else {
+                    _Failed = (_Mflags & regex_constants::match_not_bol) != 0;
+                }
+                break;
+
+            case _N_eol:
+                if (_Tgt_state._Cur == _End) {
+                    _Failed = (_Mflags & regex_constants::match_not_eol) != 0;
+                } else {
+                    _Failed = !(_Sflags & regex_constants::multiline)
+                           || !_STD _Is_ecmascript_line_terminator(*_Tgt_state._Cur);
+                }
+
+                break;
+
+            case _N_wbound:
+                _Failed = _Is_wbound() == ((_Nx->_Flags & _Fl_negate) != 0);
+                break;
+
+            case _N_dot:
+                if (_Tgt_state._Cur == _End) {
+                    _Failed = true;
+                } else {
+                    const _Elem _Ch = *_Tgt_state._Cur;
+                    if (_Sflags & regex_constants::_Any_posix) {
+                        if (_Ch == _Elem()) {
+                            _Failed = true;
+                        }
+                    } else if (_STD _Is_ecmascript_line_terminator(_Ch)) {
+                        _Failed = true;
+                    }
+
+                    if (!_Failed) {
+                        ++_Tgt_state._Cur;
+                    }
+                }
+
+                break;
+
+            case _N_str:
+                { // check for string match
+                    _Node_str<_Elem>* _Node = static_cast<_Node_str<_Elem>*>(_Nx);
+                    _It _Res0;
+                    _Iter_diff_t<_It> _Count{};
+                    if ((_Res0 = _STD _Compare_translate_left(_Tgt_state._Cur, _End, _Node->_Data._Str(),
+                             _Node->_Data._Str() + _Node->_Data._Size(), _Traits, _Sflags, _Count))
+                        != _Tgt_state._Cur) {
+                        _Tgt_state._Cur = _Res0;
+                    } else {
+                        _Failed = true;
+                    }
+
+                    // divide by 64 because character comparisons are cheaper than state transitions
+                    _Increase_complexity_count(static_cast<_Iter_diff_t<_It>>(_Count / 64));
+
+                    break;
+                }
+
+            case _N_class:
+                { // check for bracket expression match
+                    _It _Res;
+                    if (_Tgt_state._Cur != _End && (_Res = _Do_class(_Nx, _Tgt_state._Cur)) != _Tgt_state._Cur) {
+                        _Tgt_state._Cur = _Res;
+                    } else {
+                        _Failed = true;
+                    }
+                    break;
+                }
+
+            case _N_group:
+                break;
+
+            case _N_end_group:
+                break;
+
+            case _N_assert:
+                { // check assert
+                    auto _Node = static_cast<_Node_assert*>(_Nx);
+                    _Push_frame(_Rx_unwind_ops::_After_assert, _Node);
+                    _Next = _Node->_Child;
+                    break;
+                }
+
+            case _N_neg_assert:
+                { // check negative assert
+                    auto _Node = static_cast<_Node_assert*>(_Nx);
+                    _Push_frame(_Rx_unwind_ops::_After_neg_assert, _Node);
+                    _Next = _Node->_Child;
+                    break;
+                }
+
+            case _N_end_assert:
+                {
+                    size_t _Last_capture_restore_frame = 0U;
+                    unsigned int _Capture_first        = UINT_MAX;
+                    unsigned int _Capture_back         = 0U;
+                    for (;;) {
+                        --_Frames_count;
+                        const auto& _Frame = _Frames[_Frames_count];
+                        const auto _Code   = _Frame._Code;
+                        if (_Code == _Rx_unwind_ops::_After_assert || _Code == _Rx_unwind_ops::_After_neg_assert) {
+                            if (_Code == _Rx_unwind_ops::_After_assert) {
+                                _Tgt_state._Cur = _Frame._Pos;
+                                _Next           = _Frame._Node->_Next;
+                                if (_Last_capture_restore_frame != 0U) {
+                                    auto _Not_capture_restore = [](const auto& _Other_frame) static {
+                                        return _Other_frame._Code != _Rx_unwind_ops::_Capture_restore_begin
+                                            && _Other_frame._Code != _Rx_unwind_ops::_Capture_restore_unmatched_end;
+                                    };
+                                    const auto _Effective_frames_end =
+                                        _STD remove_if(_Frames._Begin() + static_cast<ptrdiff_t>(_Frames_count),
+                                            _Frames._Begin() + static_cast<ptrdiff_t>(_Last_capture_restore_frame) + 1,
+                                            _Not_capture_restore);
+                                    _Frames_count = static_cast<size_t>(_Effective_frames_end - _Frames._Begin());
+                                }
+                            } else {
+                                _Failed = true;
+                                if (_Capture_first <= _Capture_back) {
+                                    _Tgt_state._Grp_valid._Clear_range_at_least_until(
+                                        _Capture_first, _Capture_back + 1U);
+                                }
+                            }
+                            break;
+                        } else if (_Code == _Rx_unwind_ops::_Capture_restore_unmatched_end) {
+                            auto _Capture_idx = _Frame._Capture_idx;
+                            if (_Capture_first > _Capture_idx) {
+                                _Capture_first = _Capture_idx;
+                            }
+
+                            if (_Capture_back < _Capture_idx) {
+                                _Capture_back = _Capture_idx;
+                            }
+
+                            if (_Last_capture_restore_frame == 0U) {
+                                _Last_capture_restore_frame = _Frames_count;
+                            }
+                        }
+                    }
+                }
+                break;
+
+            case _N_capture:
+                { // record current position
+                    auto _Node = static_cast<_Node_capture*>(_Nx);
+                    _STL_INTERNAL_CHECK(_Node->_Idx != 0U);
+                    auto _Idx           = _Node->_Idx - 1U;
+                    auto& _Group        = _Tgt_state._Grps[_Idx];
+                    auto _Frame_idx     = _Push_frame(_Rx_unwind_ops::_Capture_restore_begin, _Node);
+                    auto& _Frame        = _Frames[_Frame_idx];
+                    _Frame._Pos         = _Group._Begin;
+                    _Frame._Capture_idx = _Idx;
+                    _Group._Begin       = _Tgt_state._Cur;
+                    break;
+                }
+
+            case _N_end_capture:
+                { // record successful capture
+                    auto _Node  = static_cast<_Node_end_group*>(_Nx);
+                    auto _Node0 = static_cast<_Node_capture*>(_Node->_Back);
+                    if (_Node0->_Idx != 0U) { // update capture data
+                        auto _Idx           = _Node0->_Idx - 1U;
+                        auto& _Group        = _Tgt_state._Grps[_Idx];
+                        bool _Matched       = _Tgt_state._Grp_valid._Get(_Idx);
+                        const auto _Code    = _Matched ? _Rx_unwind_ops::_Capture_restore_matched_end
+                                                       : _Rx_unwind_ops::_Capture_restore_unmatched_end;
+                        auto _Frame_idx     = _Push_frame(_Code, _Node0);
+                        auto& _Frame        = _Frames[_Frame_idx];
+                        _Frame._Pos         = _Group._End;
+                        _Frame._Capture_idx = _Idx;
+                        _Group._End         = _Tgt_state._Cur;
+                        _Tgt_state._Grp_valid._Set(_Idx);
+                    }
+                    break;
+                }
+
+            case _N_back:
+                { // check back reference
+                    _STL_INTERNAL_CHECK(
+                        (_Sflags & (regex_constants::extended | regex_constants::egrep | regex_constants::awk))
+                        == 0); // these grammars don't have backreferences
+                    _Node_back* _Node = static_cast<_Node_back*>(_Nx);
+                    const auto _Idx   = _Node->_Idx - 1U;
+                    if (_Tgt_state._Grp_valid._Get(_Idx)) { // check for match
+                        _It _Res0 = _Tgt_state._Cur;
+                        _It _Bx   = _Tgt_state._Grps[_Idx]._Begin;
+                        _It _Ex   = _Tgt_state._Grps[_Idx]._End;
+                        _Iter_diff_t<_It> _Count{};
+                        if (_Bx != _Ex // _Bx == _Ex for zero-length match
+                            && (_Res0 = _STD _Compare_translate_both(
+                                    _Tgt_state._Cur, _End, _Bx, _Ex, _Traits, _Sflags, _Count))
+                                   == _Tgt_state._Cur) {
+                            _Failed = true;
+                        } else {
+                            _Tgt_state._Cur = _Res0;
+                        }
+
+                        // divide by 64 because character comparisons are cheaper than state transitions
+                        _Increase_complexity_count(static_cast<_Iter_diff_t<_It>>(_Count / 64));
+                    } else if (_Sflags & (regex_constants::basic | regex_constants::grep)) {
+                        _Failed = true;
+                    }
+                    break;
+                }
+
+            case _N_if:
+                {
+                    auto _Node = static_cast<_Node_if*>(_Nx);
+                    if (_Node->_Child) {
+                        _Push_frame(_Rx_unwind_ops::_Disjunction_eval_alternative, _Node->_Child);
+                    }
+                    break;
+                }
+
+            case _N_endif:
+                break;
+
+            case _N_rep:
+                { // handle start of loop
+                    auto _Node = static_cast<_Node_rep*>(_Nx);
+                    _Prepare_rep(_Node);
+                    bool _Greedy = (_Node->_Flags & _Fl_greedy) != 0;
+                    auto& _Sav   = _Loop_vals[_Node->_Loop_number];
+
+                    if (_Node->_Simple_loop == 1) {
+                        _Sav._Loop_frame_idx = _Push_frame(_Rx_unwind_ops::_Do_nothing, _Node);
+                        if (_Node->_Min > 0 || (_Greedy && !_Longest && _Node->_Max != 0)) { // try a rep first
+                            _Sav._Loop_idx = 1;
+                            // _Next is already assigned correctly for matching a rep
+
+                            // set up stack unwinding for greedy matching if no rep is allowed
+                            if (_Node->_Min == 0) {
+                                auto& _Frame = _Frames[_Sav._Loop_frame_idx];
+                                _Frame._Code = _Rx_unwind_ops::_Loop_simple_greedy_firstrep;
+                            }
+                        } else { // try tail first
+                            _Sav._Loop_idx = 0;
+                            _Next          = _Node->_End_rep->_Next;
+
+                            // set up stack unwinding for non-greedy matching if at least one rep is allowed
+                            if (_Node->_Max != 0) {
+                                _Push_frame(_Rx_unwind_ops::_Loop_simple_nongreedy, _Node);
+                            }
+                        }
+                    } else {
+                        if (_Node->_Min > 0 || (_Greedy && !_Longest && _Node->_Max != 0)) { // try a rep first
+                            // set up stack unwinding for greedy matching or loop val restoration
+                            const auto _Code =
+                                _Node->_Min == 0 ? _Rx_unwind_ops::_Loop_greedy : _Rx_unwind_ops::_Loop_restore_vals;
+                            auto _Frame_idx            = _Push_frame(_Code, _Node);
+                            auto& _Frame               = _Frames[_Frame_idx];
+                            _Frame._Loop_idx_sav       = _Sav._Loop_idx;
+                            _Frame._Loop_frame_idx_sav = _Sav._Loop_frame_idx;
+                            _Sav._Loop_idx             = 1;
+                            _Sav._Loop_frame_idx       = _Frame_idx;
+                            // _Next is already assigned correctly for matching a rep
+                        } else { // try tail first
+                            _Next = _Node->_End_rep->_Next;
+                            // set up stack unwinding for non-greedy matching if at least one rep is allowed
+                            if (_Node->_Max != 0) {
+                                auto _Frame_idx            = _Push_frame(_Rx_unwind_ops::_Loop_nongreedy, _Node);
+                                auto& _Frame               = _Frames[_Frame_idx];
+                                _Frame._Loop_idx_sav       = _Sav._Loop_idx;
+                                _Frame._Loop_frame_idx_sav = _Sav._Loop_frame_idx;
+                                _Sav._Loop_idx             = 0;
+                                _Sav._Loop_frame_idx       = _Frame_idx;
+                            }
+                        }
+                    }
+                }
+
+                break;
+
+            case _N_end_rep:
+                { // handle end of loop
+                    _Node_rep* _Nr = static_cast<_Node_end_rep*>(_Nx)->_Begin_rep;
+                    auto& _Sav     = _Loop_vals[_Nr->_Loop_number];
+                    bool _Greedy   = (_Nr->_Flags & _Fl_greedy) != 0;
+                    if (_Nr->_Simple_loop != 0 || (_Nr->_Flags & _Fl_rep_branchless) != 0) {
+                        if (_Sav._Loop_idx == 1) {
+                            auto& _Base_frame = _Frames[_Sav._Loop_frame_idx];
+                            _Sav._Loop_length = _STD distance(_Base_frame._Pos, _Tgt_state._Cur);
+
+                            if (_Sav._Loop_length == _Iter_diff_t<_It>{}) { // initial match empty
+                                // loop is branchless, so it will only ever match empty strings
+                                // -> we only try tail for POSIX or if minimum number of reps is non-zero
+                                // _Next is already assigned correctly for matching tail
+                                if (!(_Sflags & regex_constants::_Any_posix) && _Nr->_Min == 0) {
+                                    _Failed = true;
+                                }
+                                break;
+                            }
+
+                            // allocate stack frame holding loop-specific unwinding opcode for second rep and beyond
+                            auto _New_frame_code = _Base_frame._Code == _Rx_unwind_ops::_Loop_simple_greedy_firstrep
+                                                        || _Base_frame._Code == _Rx_unwind_ops::_Loop_greedy
+                                                     ? _Rx_unwind_ops::_Loop_simple_greedy_lastrep
+                                                     : _Rx_unwind_ops::_Do_nothing;
+                            auto _New_frame_idx  = _Push_frame(_New_frame_code, _Nr);
+                            _Frames[_New_frame_idx]._Loop_frame_idx_sav = _Sav._Loop_frame_idx;
+                            _Sav._Loop_frame_idx                        = _New_frame_idx;
+                        } else { // discard stack frames for capturing group changes generated by this rep
+                            _Frames_count = _Sav._Loop_frame_idx + 1U;
+                        }
+
+                        if (_Sav._Loop_idx < _Nr->_Min) { // at least one more rep to reach minimum
+                            _Next = _Nr->_Next;
+                            ++_Sav._Loop_idx;
+                        } else if (_Greedy && !_Longest) { // greedy matching
+                            auto& _Frame = _Frames[_Sav._Loop_frame_idx];
+                            if (_Frame._Code == _Rx_unwind_ops::_Do_nothing) { // min reps reached
+                                _Frame._Code = _Rx_unwind_ops::_Loop_simple_greedy_lastrep;
+                                // set iterator in base frame to start of prior rep
+                                // (so to start of rep before reaching min reps)
+                                auto& _Before_unwind_pos = _Frames[_Frame._Loop_frame_idx_sav]._Pos;
+                                _Before_unwind_pos       = _Tgt_state._Cur;
+                                _STD advance(_Before_unwind_pos, -_Sav._Loop_length);
+                            } else {
+                                _STL_INTERNAL_CHECK(_Frame._Code == _Rx_unwind_ops::_Loop_simple_greedy_lastrep);
+                            }
+                            _Frame._Pos = _Tgt_state._Cur;
+
+                            if (_Sav._Loop_idx != _Nr->_Max) { // try one more rep
+                                _Next = _Nr->_Next;
+                                if (_Sav._Loop_idx < INT_MAX) { // avoid overflowing _Loop_idx
+                                    ++_Sav._Loop_idx;
+                                }
+                            } else { // try tail
+                                _STD advance(_Frame._Pos, -_Sav._Loop_length);
+                                if (_Frame._Pos != _Frames[_Frame._Loop_frame_idx_sav]._Pos) {
+                                    // capturing groups must be shifted when backtracking from tail
+                                    _Frame._Code = _Rx_unwind_ops::_Loop_simple_greedy_intermediaterep;
+                                } else {
+                                    --_Frames_count;
+                                }
+                                // _Next is already assigned correctly for matching tail
+                            }
+                        } else { // non-greedy matching
+                            // set up stack unwinding for non-greedy matching if one more rep is allowed
+                            if (_Sav._Loop_idx != _Nr->_Max) {
+                                auto& _Frame = _Frames[_Sav._Loop_frame_idx];
+                                _Frame._Pos  = _Tgt_state._Cur;
+                                _Frame._Code = _Rx_unwind_ops::_Loop_simple_nongreedy;
+                                _Frame._Node = _Nr;
+                            } else {
+                                --_Frames_count;
+                            }
+                            // _Next is already assigned correctly for matching tail
+                        }
+                    } else {
+                        const bool _Progress = _Frames[_Sav._Loop_frame_idx]._Pos != _Tgt_state._Cur;
+                        if (_Sav._Loop_idx < _Nr->_Min) { // try another required match
+                            auto _Frame_idx            = _Push_frame(_Rx_unwind_ops::_Loop_restore_vals, _Nr);
+                            auto& _Frame               = _Frames[_Frame_idx];
+                            _Frame._Loop_idx_sav       = _Sav._Loop_idx;
+                            _Frame._Loop_frame_idx_sav = _Sav._Loop_frame_idx;
+                            _Sav._Loop_frame_idx       = _Frame_idx;
+
+                            // optimization: try only one more match after an empty match
+                            // if there is no maximum number of reps
+                            if (!_Progress && _Nr->_Max < 0) {
+                                _Sav._Loop_idx = _Nr->_Min;
+                            } else {
+                                ++_Sav._Loop_idx;
+                            }
+
+                            _Reset_capture_groups(_Sav._Group_first);
+                            _Next = _Nr->_Next;
+                        } else if (!_Progress) { // latest rep match empty
+                            // An empty match is allowed if it is needed to reach the minimum number of reps.
+                            // Moreover, POSIX allows an empty repetition if the subexpression is matched only once.
+                            // So try tail in either case, else fail.
+                            if (_Sav._Loop_idx != _Nr->_Min
+                                && !((_Sflags & regex_constants::_Any_posix) && _Sav._Loop_idx == 1)) {
+                                _Failed = true;
+                            }
+                            // _Next is already assigned correctly for matching tail
+                        } else if (_Greedy && !_Longest && _Sav._Loop_idx != _Nr->_Max) { // one more rep to try next
+                            // set up stack unwinding for greedy matching
+                            auto _Frame_idx            = _Push_frame(_Rx_unwind_ops::_Loop_greedy, _Nr);
+                            auto& _Frame               = _Frames[_Frame_idx];
+                            _Frame._Loop_idx_sav       = _Sav._Loop_idx;
+                            _Frame._Loop_frame_idx_sav = _Sav._Loop_frame_idx;
+                            _Sav._Loop_frame_idx       = _Frame_idx;
+                            if (_Sav._Loop_idx < INT_MAX) {
+                                ++_Sav._Loop_idx;
+                            }
+
+                            _Reset_capture_groups(_Sav._Group_first);
+                            _Next = _Nr->_Next;
+                        } else { // non-greedy matching or greedy matching with maximum reached
+                            // set up stack unwinding for non-greedy matching if one more rep is allowed
+                            if (_Sav._Loop_idx != _Nr->_Max) {
+                                auto _Frame_idx            = _Push_frame(_Rx_unwind_ops::_Loop_nongreedy, _Nr);
+                                auto& _Frame               = _Frames[_Frame_idx];
+                                _Frame._Loop_idx_sav       = _Sav._Loop_idx;
+                                _Frame._Loop_frame_idx_sav = _Sav._Loop_frame_idx;
+                                _Sav._Loop_frame_idx       = _Frame_idx;
+                            }
+                            // _Next is already assigned correctly for matching tail
+                        }
+                    }
+                    break;
+                }
+
+            case _N_begin:
+                break;
+
+            case _N_end:
+                if (((_Mflags & (regex_constants::match_not_null | regex_constants::_Match_not_null))
+                        && _Begin == _Tgt_state._Cur)
+                    || (_Full && _Tgt_state._Cur != _End)) {
+                    _Failed = true;
+                } else if (!_Longest) { // match result found, skip unwinding
+                    return true;
+                } else if (!_Matched || _Better_match()) { // record successful match
+                    _Res._Copy_from(_Tgt_state);
+                    _Matched = true;
+                }
+                _Next = nullptr;
+                break;
+
+            case _N_none:
+            default:
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_REPORT_ERROR("internal data of regex node corrupted");
+#endif
+                return false;
+            }
+
+            if (_Failed) {
+                _Nx = nullptr;
+            } else {
+                _Nx = _Next;
+            }
+        } while (_Nx);
+
+        while (_Frames_count > 0 && !_Nx) {
+            _STL_INTERNAL_CHECK(_Failed || _Longest);
+
+            auto& _Frame = _Frames[--_Frames_count];
+            switch (_Frame._Code) {
+            case _Rx_unwind_ops::_After_assert: // matching pattern of positive assert failed
+            case _Rx_unwind_ops::_Do_nothing:
+                break;
+
+            case _Rx_unwind_ops::_After_neg_assert:
+                { // matching pattern of negative assert failed
+                    _Tgt_state._Cur = _Frame._Pos;
+                    _Nx             = _Frame._Node->_Next;
+                    _Failed         = false;
+                    break;
+                }
+
+            case _Rx_unwind_ops::_Disjunction_eval_alternative:
+                { // try next alternative in a disjunction
+                    auto _Node      = static_cast<_Node_if*>(_Frame._Node);
+                    _Nx             = _Node->_Next;
+                    _Tgt_state._Cur = _Frame._Pos;
+                    _Failed         = false;
+                    if (_Node->_Child) {
+                        _Frame._Node = _Node->_Child;
+                        ++_Frames_count;
+                    }
+                    break;
+                }
+
+            case _Rx_unwind_ops::_Loop_simple_nongreedy:
+                { // try one more rep
+                    auto _Node = static_cast<_Node_rep*>(_Frame._Node);
+                    auto& _Sav = _Loop_vals[_Node->_Loop_number];
+
+                    _Nx             = _Node->_Next;
+                    _Tgt_state._Cur = _Frame._Pos;
+                    _Failed         = false;
+                    if (_Sav._Loop_idx < INT_MAX) { // avoid overflowing _Loop_idx
+                        ++_Sav._Loop_idx;
+                    }
+                }
+                break;
+
+            case _Rx_unwind_ops::_Loop_simple_greedy_firstrep:
+                { // try tail after backtracking from first rep
+                    auto _Node = static_cast<_Node_rep*>(_Frame._Node);
+
+                    _Nx             = _Node->_End_rep->_Next;
+                    _Tgt_state._Cur = _Frame._Pos;
+                    _Failed         = false;
+                }
+                break;
+
+            case _Rx_unwind_ops::_Loop_simple_greedy_intermediaterep:
+                {
+                    // shift capturing groups, set up unwinding prior rep and try tail
+                    // when backtracking between the second and the last attempted rep
+                    auto _Node = static_cast<_Node_rep*>(_Frame._Node);
+
+                    // adjust capturing group begin and end iterators by rep length
+                    auto& _Sav = _Loop_vals[_Node->_Loop_number];
+                    for (auto _Capture_frame_idx = _Frame._Loop_frame_idx_sav + 1U; _Capture_frame_idx != _Frames_count;
+                        ++_Capture_frame_idx) {
+                        const auto& _Capture_frame = _Frames[_Capture_frame_idx];
+                        _STL_INTERNAL_CHECK(_Capture_frame._Code == _Rx_unwind_ops::_Capture_restore_begin
+                                            || _Capture_frame._Code == _Rx_unwind_ops::_Capture_restore_matched_end
+                                            || _Capture_frame._Code == _Rx_unwind_ops::_Capture_restore_unmatched_end);
+                        auto& _Grp = _Tgt_state._Grps[_Capture_frame._Capture_idx];
+                        _STD advance(
+                            _Capture_frame._Code == _Rx_unwind_ops::_Capture_restore_begin ? _Grp._Begin : _Grp._End,
+                            -_Sav._Loop_length);
+                    }
+                }
+                _FALLTHROUGH;
+
+            case _Rx_unwind_ops::_Loop_simple_greedy_lastrep:
+                {
+                    // set up unwinding prior rep and try tail
+                    // when backtracking from last attempted rep
+                    auto _Node = static_cast<_Node_rep*>(_Frame._Node);
+
+                    _Nx             = _Node->_End_rep->_Next;
+                    _Tgt_state._Cur = _Frame._Pos;
+                    _Failed         = false;
+
+                    auto& _Sav = _Loop_vals[_Node->_Loop_number];
+                    _STD advance(_Frame._Pos, -_Sav._Loop_length);
+
+                    // set up unwinding if prior rep is not first or minimum rep
+                    if (_Frames[_Frame._Loop_frame_idx_sav]._Pos != _Frame._Pos) {
+                        _Frame._Code = _Rx_unwind_ops::_Loop_simple_greedy_intermediaterep;
+                        ++_Frames_count;
+                    }
+                }
+                break;
+
+            case _Rx_unwind_ops::_Loop_greedy:
+                { // try tail
+                    auto _Node = static_cast<_Node_rep*>(_Frame._Node);
+
+                    _Nx             = _Node->_End_rep->_Next;
+                    _Tgt_state._Cur = _Frame._Pos;
+                    _Failed         = false;
+                }
+                _FALLTHROUGH;
+
+            case _Rx_unwind_ops::_Loop_restore_vals:
+                { // restore loop vals after processing of a rep is completed
+                    auto _Node = static_cast<_Node_rep*>(_Frame._Node);
+                    auto& _Sav = _Loop_vals[_Node->_Loop_number];
+
+                    _Sav._Loop_idx       = _Frame._Loop_idx_sav;
+                    _Sav._Loop_frame_idx = _Frame._Loop_frame_idx_sav;
+                }
+                break;
+
+            case _Rx_unwind_ops::_Loop_nongreedy:
+                { // try another rep
+                    auto _Node = static_cast<_Node_rep*>(_Frame._Node);
+                    auto& _Sav = _Loop_vals[_Node->_Loop_number];
+
+                    _Nx             = _Node->_Next;
+                    _Tgt_state._Cur = _Frame._Pos;
+                    _Failed         = false;
+                    if (_Sav._Loop_idx < INT_MAX) { // avoid overflowing _Loop_idx
+                        ++_Sav._Loop_idx;
+                    }
+
+                    _Frame._Code = _Rx_unwind_ops::_Loop_restore_vals;
+                    ++_Frames_count;
+                    _Reset_capture_groups(_Sav._Group_first);
+                }
+                break;
+
+            case _Rx_unwind_ops::_Capture_restore_begin:
+                { // restore begin of capturing group
+                    _Tgt_state._Grps[_Frame._Capture_idx]._Begin = _Frame._Pos;
+                }
+                break;
+
+            case _Rx_unwind_ops::_Capture_restore_unmatched_end:
+                { // restore end of capturing group that was previously unmatched
+                    _Tgt_state._Grp_valid._Clear(_Frame._Capture_idx);
+                }
+                _FALLTHROUGH;
+
+            case _Rx_unwind_ops::_Capture_restore_matched_end:
+                { // restore end of capturing group that was already matched
+                    _Tgt_state._Grps[_Frame._Capture_idx]._End = _Frame._Pos;
+                }
+                break;
+
+            case _Rx_unwind_ops::_Capture_restore_matched:
+                { // restore matched status of capturing group
+                    _Tgt_state._Grp_valid._Set(_Frame._Capture_idx);
+                }
+                break;
+
+            default:
+#if _ITERATOR_DEBUG_LEVEL != 0
+                _STL_REPORT_ERROR("internal stack of regex matcher corrupted");
+#endif
+                return false;
+            }
+        }
+    }
+
+    _STL_INTERNAL_CHECK(_Frames_count == 0);
+
+    return !_Failed;
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+template <class _BidIt, class _Alsubmatch>
+void _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Copy_captures(match_results<_BidIt, _Alsubmatch>& _Matches) {
+    // copy captures into match_results
+    _Matches._Resize(_Ncap);
+    const auto& _Result = _Longest ? _Res : _Tgt_state;
+
+    auto& _Submatch0   = _Matches._At(0U);
+    _Submatch0.matched = true;
+    _Submatch0.first   = _Begin;
+    _Submatch0.second  = _Result._Cur;
+
+    for (unsigned int _Idx = 1U; _Idx < _Ncap; ++_Idx) { // copy submatch _Idx
+        if (_Result._Grp_valid._Get(_Idx - 1U)) { // copy successful match
+            _Matches._At(_Idx).matched = true;
+            _Matches._At(_Idx).first   = _Result._Grps[_Idx - 1U]._Begin;
+            _Matches._At(_Idx).second  = _Result._Grps[_Idx - 1U]._End;
+        } else { // copy failed match
+            _Matches._At(_Idx).matched = false;
+            _Matches._At(_Idx).first   = _End;
+            _Matches._At(_Idx).second  = _End;
+        }
+    }
+    _Matches._Pfx().second = _Matches._At(0).first;
+
+    _Matches._Sfx().first   = _Matches._At(0).second;
+    _Matches._Sfx().second  = _End;
+    _Matches._Sfx().matched = _Matches._Sfx().first != _Matches._Sfx().second;
+
+    _Matches._Null().first  = _End;
+    _Matches._Null().second = _End;
+}
+
+template <class _FwdIt, class _Int>
+void _Advance_at_most(_FwdIt& _Pos, const _FwdIt& _Last, _Int _Amount) {
+    if constexpr (_Is_ranges_random_iter_v<_FwdIt>) {
+        auto _Shift_amount = _Last - _Pos;
+        if (_Shift_amount > _Amount) {
+            _Shift_amount = static_cast<decltype(_Shift_amount)>(_Amount);
+        }
+
+        _Pos += _Shift_amount;
+    } else {
+        while (_Amount > 0 && _Pos != _Last) {
+            ++_Pos;
+            --_Amount;
+        }
+    }
+}
+
+template <class _Elem, class _RxTraits, class _It, class _Alloc>
+_It _Matcher3<_Elem, _RxTraits, _It, _Alloc>::_Skip(
+    _It _First, const _It _Last, const _Node_base* const _Node_arg, const unsigned int _Recursion_depth) {
+    // skip until possible match
+    // assumes --_First is valid
+    static constexpr char _Line_terminators_char[]       = {static_cast<char>(_Meta_cr), static_cast<char>(_Meta_nl)};
+    static constexpr wchar_t _Line_terminators_wchar_t[] = {static_cast<wchar_t>(_Meta_cr),
+        static_cast<wchar_t>(_Meta_nl), static_cast<wchar_t>(_Meta_ls), static_cast<wchar_t>(_Meta_ps)};
+    constexpr unsigned int _Max_recursion_depth          = 50U;
+    constexpr short _Max_lookahead                       = 512;
+    const _Node_base* _Nx                                = _Node_arg ? _Node_arg : _Start;
+
+    while (_First != _Last && _Nx) { // check current node
+        switch (_Nx->_Kind) { // handle current node's type
+        case _N_nop:
+            break;
+
+        case _N_bol: // check for beginning anchor
+            if (_Sflags & regex_constants::multiline) {
+                // multiline mode: check for embedded line terminator
+                // return iterator to character just after the newline; for input like "\nabc"
+                // matching "^abc", _First could be pointing at 'a', so we need to check --_First for '\n'
+                if (!_STD _Is_ecmascript_line_terminator(*_STD _Prev_iter(_First))) {
+                    if constexpr (sizeof(_Elem) == 1) {
+                        _First =
+                            _STD find_first_of(_First, _Last, _Line_terminators_char, _STD end(_Line_terminators_char));
+                    } else {
+                        _First = _STD find_first_of(
+                            _First, _Last, _Line_terminators_wchar_t, _STD end(_Line_terminators_wchar_t));
+                    }
+
+                    if (_First != _Last) {
+                        ++_First;
+                    }
+                }
+
+                return _First;
+            } else {
+                // non-multiline mode: never matches because --_First is valid
+                return _Last;
+            }
+
+        case _N_eol:
+            if (_Sflags & regex_constants::multiline) {
+                // multiline mode: matches at next line terminator or end of input
+                if constexpr (sizeof(_Elem) == 1) {
+                    return _STD find_first_of(_First, _Last, _Line_terminators_char, _STD end(_Line_terminators_char));
+                } else {
+                    return _STD find_first_of(
+                        _First, _Last, _Line_terminators_wchar_t, _STD end(_Line_terminators_wchar_t));
+                }
+            } else {
+                return _Last; // non-multiline mode: matches at end of input or not at all
+            }
+
+        case _N_str:
+            { // check for string match
+                const auto _Node         = static_cast<const _Node_str<_Elem>*>(_Nx);
+                const auto _Str          = _Node->_Data._Str();
+                const unsigned int _Size = _Node->_Data._Size();
+
+                auto _Shifted_last = _Last;
+                if (_Last != _End && _Size > 1U) { // have to continue search beyond the search window
+                    _STD _Advance_at_most(_Shifted_last, _End, static_cast<long long>(_Size - 1U));
+                }
+
+                auto _Result = _STD _Search_translate_left(_First, _Shifted_last, _Str, _Str + _Size, _Traits, _Sflags);
+                if (_Shifted_last == _Result) { // correct for search window shift
+                    return _Last;
+                } else {
+                    return _Result;
+                }
+            }
+
+        case _N_class:
+            { // check for string match
+                const auto _Node = static_cast<const _Node_class<_Elem, _RxTraits>*>(_Nx);
+
+                for (; _First != _Last; ++_First) { // look for starting match
+                    if (_Do_class(_Node, _First) != _First) { // may read beyond search window
+                        return _First;
+                    }
+                }
+            }
+            return _First;
+
+        case _N_group:
+            break;
+
+        case _N_end_group:
+            break;
+
+        case _N_end_assert:
+            _Nx = nullptr;
+            break;
+
+        case _N_capture:
+            break;
+
+        case _N_end_capture:
+            break;
+
+        case _N_if:
+            {
+                const auto _Node = static_cast<const _Node_if*>(_Nx);
+
+                // TRANSITION, ABI: After GH-5539, the parser no longer generates single-branch _N_if nodes.
+                // But we retain this special handling to avoid some performance regression
+                // when an old parser gets mixed with a new matcher.
+                if (!_Node->_Child) {
+                    break;
+                }
+
+                if (_Recursion_depth >= _Max_recursion_depth) {
+                    return _First;
+                }
+
+                // GH-5452: If this node has two or more branches, examining all alternatives in a disjunction
+                // until the end of the input string could result in quadratic worst-case complexity.
+                // For this reason, we split the input string into search windows with a constant maximum length.
+                // This ensures that this heuristic has linear time complexity, because this bounds the number
+                // of characters that were read beyond the finally determined skip position by a constant.
+
+                for (;;) {
+                    _It _Lookahead_last = _First;
+                    _STD _Advance_at_most(_Lookahead_last, _Last, _Max_lookahead);
+
+                    _It _Alt_last = _Lookahead_last;
+
+                    for (const _Node_if* _Alternative = _Node; _Alternative && _First != _Alt_last;
+                        _Alternative                  = _Alternative->_Child) {
+                        _Alt_last = _Skip(_First, _Alt_last, _Alternative->_Next, _Recursion_depth + 1U);
+                    }
+
+                    _First = _Alt_last;
+                    if (_First != _Lookahead_last || _First == _Last) {
+                        break;
+                    }
+                }
+
+                return _First;
+            }
+
+        case _N_rep:
+            {
+                const auto _Node = static_cast<const _Node_rep*>(_Nx);
+
+                if (_Node->_Min > 0) {
+                    break;
+                }
+
+                if (_Recursion_depth >= _Max_recursion_depth) {
+                    return _First;
+                }
+
+                // As in GH-5452, examining the cases with no repetition and at least one repetition
+                // until the end of the input string could result in quadratic worst-case complexity.
+                // For this reason, we split the input string into search windows with a constant maximum length.
+                // This ensures that this heuristic has linear time complexity, because this bounds the number
+                // of characters that were read beyond the finally determined skip position by a constant.
+
+                for (;;) {
+                    _It _Lookahead_last = _First;
+                    _STD _Advance_at_most(_Lookahead_last, _Last, _Max_lookahead);
+                    const _It _Intermediate = _Skip(_First, _Lookahead_last, _Node->_Next, _Recursion_depth + 1U);
+                    _First = _Skip(_First, _Intermediate, _Node->_End_rep->_Next, _Recursion_depth + 1U);
+
+                    if (_First != _Lookahead_last || _First == _Last) {
+                        break;
+                    }
+                }
+
+                return _First;
+            }
+
+        case _N_assert:
+            {
+                if (_Recursion_depth >= _Max_recursion_depth) {
+                    return _First;
+                }
+
+                const auto _Node = static_cast<const _Node_assert*>(_Nx);
+                _First           = _Skip(_First, _Last, _Node->_Child, _Recursion_depth + 1U);
+                _It _Next;
+                for (;;) {
+                    _Next = _Skip(_First, _Last, _Node->_Next, _Recursion_depth + 1U);
+                    if (_Next == _First) {
+                        return _First;
+                    }
+
+                    _First = _Skip(_Next, _Last, _Node->_Child, _Recursion_depth + 1U);
+                    if (_Next == _First) {
+                        return _First;
+                    }
+                }
+            }
+
+        case _N_neg_assert:
+            // we skip the negated assertion body and continue examining the rest of the regex
+            break;
+
+        case _N_wbound:
+            {
+                const bool _Negated = (_Nx->_Flags & _Fl_negate) != 0;
+                bool _Prev_word     = _STD _Is_word(*_STD _Prev_iter(_First));
+                for (; _First != _Last; ++_First) {
+                    const bool _Next_word = _STD _Is_word(*_First);
+                    if (_Negated == (_Next_word == _Prev_word)) {
+                        break;
+                    }
+                    _Prev_word = _Next_word;
+                }
+                return _First;
+            }
+
+        case _N_dot:
+            {
+                if (_Recursion_depth >= _Max_recursion_depth) {
+                    return _First;
+                }
+
+                _First = _Skip(++_First, _Last, _Nx->_Next, _Recursion_depth + 1U);
+                return --_First;
+            }
+
+        case _N_begin:
+        case _N_endif:
+            break;
+
+        case _N_end:
+        case _N_none:
+        case _N_back:
+        case _N_end_rep:
+        default:
+            return _First;
+        }
+        if (_Nx) {
+            _Nx = _Nx->_Next;
+        }
+    }
+    return _First;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+[[noreturn]] void _Parser2<_FwdIt, _Elem, _RxTraits>::_Error(regex_constants::error_type _Code) { // handle error
+    _Xregex_error(_Code);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_Is_esc(_FwdIt _Ch0) const { // assumes _Ch0 != _End
+    return _Mode == _Lex_mode::_Default && ++_Ch0 != _End
+        && ((!(_L_flags & _L_nex_grp)
+                && (*_Ch0 == static_cast<char>(_Meta_lpar) || *_Ch0 == static_cast<char>(_Meta_rpar)))
+            || (!(_L_flags & _L_nex_rep)
+                && (*_Ch0 == static_cast<char>(_Meta_lbr) || *_Ch0 == static_cast<char>(_Meta_rbr))));
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Trans() { // map character to meta-character
+    static constexpr char _Meta_map[] = {_Meta_lpar, _Meta_rpar, _Meta_dlr, _Meta_caret, _Meta_dot, _Meta_star,
+        _Meta_plus, _Meta_query, _Meta_lsq, _Meta_rsq, _Meta_bar, _Meta_esc, _Meta_dash, _Meta_lbr, _Meta_rbr,
+        _Meta_comma, _Meta_colon, _Meta_equal, _Meta_exc, _Meta_nl, _Meta_cr, _Meta_bsp, 0}; // array of meta chars
+
+    if (_Pat == _End) {
+        _Mchar = _Meta_eos;
+        _Char  = _Elem{};
+    } else { // map current character
+        _Char       = *_Pat;
+        auto _Uchar = static_cast<unsigned char>(_Char);
+        if (static_cast<_Elem>(_Uchar) == _Char && _CSTD strchr(_Meta_map, static_cast<char>(_Uchar))) {
+            _Mchar = static_cast<_Meta_type>(_Uchar);
+        } else {
+            _Mchar = _Meta_chr;
+        }
+    }
+
+    switch (int{_Mchar}) { // handle special cases
+    case _Meta_esc:
+        if (_Is_esc(_Pat)) { // replace escape sequence
+            _FwdIt _Ch0 = _Pat;
+            _Char       = *++_Ch0;
+            _Mchar      = static_cast<_Meta_type>(static_cast<unsigned char>(_Char));
+        }
+        break;
+
+    case _Meta_nl:
+        if ((_L_flags & _L_alt_nl) && _Disj_count == 0) {
+            _Mchar = _Meta_bar;
+        }
+
+        break;
+
+    case _Meta_lpar:
+    case _Meta_rpar:
+        if (!(_L_flags & _L_nex_grp)) {
+            _Mchar = _Meta_chr;
+        }
+
+        break;
+
+    case _Meta_lbr:
+    case _Meta_rbr:
+        if (!(_L_flags & _L_nex_rep)) {
+            _Mchar = _Meta_chr;
+        }
+
+        break;
+
+    case _Meta_star:
+        // A star can always act as a quantifier outside bracket expressions,
+        // but _L_star_beg (used by basic/grep) allows its use as an ordinary character
+        // at the beginning of a (sub-)expression (potentially after an optional caret anchor).
+        // We'll handle that when we are parsing alternatives in disjunctions.
+        break;
+
+    case _Meta_caret:
+        // A caret can always negate a bracket expression,
+        // but _L_anch_rstr (used by basic/grep) restricts caret anchors to the beginning.
+        // We'll handle that restriction when we're about to add a bol node.
+        break;
+
+    case _Meta_dlr:
+        { // check if $ is special
+            _FwdIt _Next = _Pat;
+            if ((_L_flags & _L_anch_rstr) && ++_Next != _End) {
+                const bool _Escaped = *_Next == static_cast<char>(_Meta_esc) && _Is_esc(_Next);
+                if (_Escaped) {
+                    ++_Next;
+                }
+
+                // Only the basic and grep grammars set _L_anch_rstr, so _L_alt_pipe and _L_nex_grp must be unset.
+                // Therefore, we don't need to handle "dollar followed by pipe '|' for alternation"
+                // or "dollar followed by non-escaped right parenthesis ')' closing a group" below.
+                _STL_INTERNAL_CHECK((_L_flags & (_L_alt_pipe | _L_nex_grp)) == 0);
+
+                const _Elem _Ch = *_Next;
+                const bool _Is_end_of_alternative =
+                    ((_L_flags & _L_alt_nl) && _Ch == static_cast<char>(_Meta_nl)
+                        && _Disj_count == 0) // dollar followed by newline '\n' for alternation
+                    || (_Escaped && _Ch == static_cast<char>(_Meta_rpar)
+                        && _Disj_count != 0); // dollar followed by (escaped) right parenthesis ')' closing a group
+
+                if (!_Is_end_of_alternative) {
+                    _Mchar = _Meta_chr;
+                }
+            }
+
+            break;
+        }
+
+    case _Meta_plus:
+    case _Meta_query:
+        if (!(_L_flags & _L_ext_rep)) {
+            _Mchar = _Meta_chr;
+        }
+
+        break;
+
+    case _Meta_bar:
+        if (!(_L_flags & _L_alt_pipe)) {
+            _Mchar = _Meta_chr;
+        }
+
+        break;
+
+    default:
+        break;
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Next() { // advance to next input character
+    if (_Pat != _End) { // advance
+        if (*_Pat == static_cast<char>(_Meta_esc) && _Is_esc(_Pat)) {
+            ++_Pat;
+        }
+
+        ++_Pat;
+    }
+    _Trans();
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Expect(_Meta_type _St, regex_constants::error_type _Code) {
+    // check whether current meta-character is _St
+    if (_Mchar != _St) {
+        _Error(_Code);
+    }
+
+    _Next();
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+int _Parser2<_FwdIt, _Elem, _RxTraits>::_Do_digits(
+    int _Base, int _Initial, int _Count, regex_constants::error_type _Error_type) { // translate digits to numeric value
+    int _Chv;
+    _Val = _Initial;
+    while (_Count != 0 && (_Chv = _Traits.value(_Char, _Base)) != -1) { // append next digit
+        if (_Val > (INT_MAX - _Chv) / _Base) {
+            _Error(_Error_type);
+        }
+        --_Count;
+        _Val *= _Base;
+        _Val += _Chv;
+        _Next();
+    }
+    return _Count;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_DecimalDigits(
+    const regex_constants::error_type _Error_type, const int _Initial /* = 0 */) { // check for decimal value
+    return _Do_digits(10, _Initial, INT_MAX, _Error_type) != INT_MAX;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_HexDigits(int _Count) { // check for _Count hex digits
+    if (_Do_digits(16, 0, _Count, regex_constants::error_escape) != 0) {
+        _Error(regex_constants::error_escape);
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_OctalDigits() { // check for up to 3 octal digits
+    return _Do_digits(8, 0, 3, regex_constants::error_escape) != 3;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Prs_ret _Parser2<_FwdIt, _Elem, _RxTraits>::_Do_ex_class(
+    _Meta_type _End_arg) { // handle delimited expressions within bracket expression
+    const regex_constants::error_type _Errtype =
+        _End_arg == _Meta_colon ? regex_constants::error_ctype : regex_constants::error_collate;
+    const _FwdIt _Beg = _Pat;
+
+    while (_Mchar != _Meta_colon && _Mchar != _Meta_equal && _Mchar != _Meta_dot && _Mchar != _Meta_eos) {
+        // advance to end delimiter
+        _Next();
+    }
+
+    const _FwdIt _End = _Pat;
+    _Expect(_End_arg, _Errtype);
+    _Expect(_Meta_rsq, _Errtype);
+
+    if (_End_arg == _Meta_colon) { // handle named character class
+        typename _RxTraits::char_class_type _Cls =
+            _Traits.lookup_classname(_Beg, _End, (_Flags & regex_constants::icase) != 0);
+        if (!_Cls) {
+            _Error(regex_constants::error_ctype);
+        }
+
+        _Nfa._Add_named_class(_Cls, _Rx_char_class_kind::_Positive);
+        return _Prs_set;
+    } else {
+        typename _RxTraits::string_type _Coll_elem = _Traits.lookup_collatename(_Beg, _End);
+        const auto _Size                           = _Coll_elem.size();
+
+        if (_Size == 0) {
+            _Error(regex_constants::error_collate);
+        }
+
+        if (_Size > _Max_limit<unsigned int>()) {
+            _Error(regex_constants::error_space);
+        }
+
+        _Elem* const _Coll_elem_first      = &_Coll_elem.front();
+        const _Elem* const _Coll_elem_last = _Coll_elem_first + _Size;
+
+        if (_Size == 1 && _End_arg == _Meta_dot) {
+            // process single-element collating elements like individual characters
+            _Unescaped_char = *_Coll_elem_first;
+            return _Prs_chr;
+        }
+
+        if (_Flags & regex_constants::icase) {
+            for (auto _Current = _Coll_elem_first; _Current != _Coll_elem_last; ++_Current) {
+                *_Current = _Traits.translate_nocase(*_Current);
+            }
+        } else if (_Flags & regex_constants::collate) {
+            for (auto _Current = _Coll_elem_first; _Current != _Coll_elem_last; ++_Current) {
+                *_Current = _Traits.translate(*_Current);
+            }
+        }
+
+        if (_End_arg == _Meta_equal) { // process equivalence
+            _Nfa._Add_equiv(_Coll_elem_first, _Coll_elem_last);
+            return _Prs_set;
+        } else { // process collating element
+
+            // Character ranges with multi-character bounds cannot be represented in NFA nodes yet (see GH-5391).
+            // Provisionally treat multi-character collating elements as character sets.
+            _Nfa._Add_coll(_Coll_elem_first, _Coll_elem_last);
+            return _Prs_set;
+        }
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_CharacterClassEscape(bool _Addit) { // check for character class escape
+    typename _RxTraits::char_class_type _Cls;
+    _FwdIt _Ch0 = _Pat;
+    if (_Ch0 == _End || (_Cls = _Traits.lookup_classname(_Pat, ++_Ch0, (_Flags & regex_constants::icase) != 0)) == 0) {
+        return false;
+    }
+
+    auto _Kind = (_Char == 'W'   ? _Rx_char_class_kind::_Negated_w
+                  : _Char == 'S' ? _Rx_char_class_kind::_Negated_s
+                  : _Char == 'D' ? _Rx_char_class_kind::_Negated_d
+                                 : _Rx_char_class_kind::_Positive);
+
+    if (_Addit) {
+        _Nfa._Add_class();
+        // GH-992: Outside character class definitions, _Cls completely defines the character class
+        // so negating _Cls and negating the entire character class are equivalent.
+        // Since the former negation is defective, do the latter instead.
+        if (_Kind != _Rx_char_class_kind::_Positive) {
+            _Nfa._Negate();
+            _Kind = _Rx_char_class_kind::_Positive;
+        }
+    }
+
+    _Nfa._Add_named_class(_Cls, _Kind);
+    _Next();
+    return true;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Prs_ret _Parser2<_FwdIt, _Elem, _RxTraits>::_ClassEscape() { // check for class escape
+    if ((_L_flags & _L_esc_bsp) && _Char == static_cast<char>(_Esc_ctrl_b)) { // handle backspace escape
+        _Next();
+        _Unescaped_char = static_cast<_Elem>(static_cast<char>(_Meta_bsp));
+        return _Prs_chr;
+    } else if ((_L_flags & (_L_bzr_chr | _L_bckr))
+               && (_Val = _Traits.value(_Char, 10)) != -1) { // handle \0 and reject other escaped decimal literals
+        _Next();
+        if (!(_L_flags & _L_bzr_chr) || _Val != 0 || _Traits.value(_Char, 10) != -1) {
+            _Error(regex_constants::error_escape);
+        }
+
+        _Unescaped_char = _Elem{};
+        return _Prs_chr;
+    } else if (_CharacterEscape(true)) {
+        return _Prs_chr;
+    } else if ((_L_flags & _L_esc_wsd) && _CharacterClassEscape(false)) {
+        return _Prs_set;
+    }
+
+    _Error(regex_constants::error_escape);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Prs_ret _Parser2<_FwdIt, _Elem, _RxTraits>::_ClassAtom(const bool _Initial) { // check for class atom
+    if (_Mchar == _Meta_esc && (_L_flags & _L_grp_esc)) { // check for valid escape sequence
+        _Next();
+        return _ClassEscape();
+    } else if (_Mchar == _Meta_lsq) { // check for valid delimited expression
+        _Elem _Lsq = _Char;
+        _Next();
+        if (_Mchar == _Meta_colon || _Mchar == _Meta_equal || _Mchar == _Meta_dot) { // handle delimited expression
+            _Meta_type _St = _Mchar;
+            _Next();
+            return _Do_ex_class(_St);
+        } else { // handle ordinary [
+            _Unescaped_char = _Lsq;
+            return _Prs_chr;
+        }
+    } else if ((_Mchar == _Meta_rsq
+                   && (!(_L_flags & _L_brk_rstr)
+                       || !_Initial)) // initial ] does not close the class when it is not special
+               || _Mchar == _Meta_eos) {
+        return _Prs_none;
+    } else { // handle ordinary character
+        _Unescaped_char = _Char;
+        _Next();
+        return _Prs_chr;
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_ClassRanges() { // check for valid class ranges
+    _Prs_ret _Ret;
+
+    bool _Initial = true;
+    for (;;) { // process characters through end of bracket expression
+        if ((_Ret = _ClassAtom(_Initial)) == _Prs_none) {
+            return;
+        }
+        _Initial = false;
+
+        if (_Ret == _Prs_chr && !(_L_flags & _L_bzr_chr) && _Unescaped_char == _Elem{}) {
+            _Error(regex_constants::error_escape);
+        }
+
+        if (_Mchar == _Meta_dash) { // check for valid range
+            _Elem _Chr1 = _Unescaped_char;
+            _Elem _Dash = _Char;
+            _Next();
+            const bool _Set_preceding = _Ret == _Prs_set;
+            if ((_Ret = _ClassAtom(false)) == _Prs_none) { // treat - as ordinary character
+                if (!_Set_preceding) {
+                    _Nfa._Add_char_to_class(_Chr1);
+                }
+                _Nfa._Add_char_to_class(_Dash);
+                return;
+            }
+
+            if (_Set_preceding || _Ret == _Prs_set) {
+                _Error(regex_constants::error_range); // set precedes or follows dash
+            }
+
+            _Elem _Chr2 = _Unescaped_char;
+
+            // translate ends of range
+            if (_Flags & regex_constants::icase) {
+                _Chr1 = _Traits.translate_nocase(_Chr1);
+                _Chr2 = _Traits.translate_nocase(_Chr2);
+            } else if (_Flags & regex_constants::collate) {
+                _Chr1 = _Traits.translate(_Chr1);
+                _Chr2 = _Traits.translate(_Chr2);
+            }
+
+            _Nfa._Add_range(_Chr1, _Chr2);
+        } else if (_Ret == _Prs_chr) {
+            _Nfa._Add_char_to_class(_Unescaped_char);
+        }
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_CharacterClass() { // add bracket expression
+    _Nfa._Add_class();
+    if (_Mchar == _Meta_caret) { // negate bracket expression
+        _Nfa._Negate();
+        _Next();
+    }
+
+    _ClassRanges();
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Do_capture_group() { // add capture group
+    ++_Grp_idx;
+
+    if (_Grp_idx >= 1000) { // hardcoded limit
+        _Xregex_error(regex_constants::error_stack);
+    }
+
+    _Node_base* _Pos1 = _Nfa._Begin_capture_group(_Grp_idx);
+    _Disjunction();
+    _Nfa._End_group(_Pos1);
+    _Finished_grps.resize(_Grp_idx + 1);
+    _Finished_grps[static_cast<_Node_capture*>(_Pos1)->_Idx] = true;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Do_noncapture_group() { // add non-capture group
+    _Node_base* _Pos1 = _Nfa._Begin_group();
+    _Disjunction();
+    _Nfa._End_group(_Pos1);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Do_assert_group(const bool _Neg) { // add assert group
+    const auto _Assert_start = _Nfa._Begin_assert_group2(_Neg);
+    _Disjunction();
+    _Nfa._End_assert_group2(_Assert_start);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_Wrapped_disjunction() { // add disjunction inside group
+    ++_Disj_count;
+    if (_Disj_count >= 1000) { // hardcoded limit
+        _Error(regex_constants::error_stack);
+    }
+
+    if (!(_L_flags & _L_empty_grp) && _Mchar == _Meta_rpar) {
+        _Error(regex_constants::error_paren);
+    } else if ((_L_flags & _L_nc_asrt) && _Mchar == _Meta_query) { // check for valid ECMAScript (?x ... ) group
+        _Next();
+        _Meta_type _Ch = _Mchar;
+        _Next();
+        if (_Ch == _Meta_colon) { // process non-capture group (?:meow)
+            _Do_noncapture_group();
+        } else if (_Ch == _Meta_exc) { // process negative lookahead assertion (?!meow)
+            _Do_assert_group(true);
+            --_Disj_count;
+            return false;
+        } else if (_Ch == _Meta_equal) { // process positive lookahead assertion (?=meow)
+            _Do_assert_group(false);
+            --_Disj_count;
+            return false;
+        } else {
+            _Error(regex_constants::error_badrepeat);
+        }
+    } else if (_Flags & regex_constants::nosubs) {
+        _Do_noncapture_group();
+    } else {
+        _Do_capture_group();
+    }
+
+    --_Disj_count;
+    return true;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_IsIdentityEscape(bool _In_character_class) const {
+    // check for valid identity escape
+    auto _Uchar = static_cast<unsigned char>(_Char);
+
+    if (_L_flags & _L_ident_ECMA) {
+        // ECMAScript identity escape characters
+        if (static_cast<_Elem>(_Uchar) != _Char) {
+            return true;
+        }
+
+        switch (_Uchar) {
+        case 'c': // ASCII control character
+        case 'd': // digit
+        case 'D':
+        case 's': // whitespace
+        case 'S':
+        case 'w': // word character
+        case 'W':
+            return false;
+        default:
+            return true;
+        }
+    }
+
+    if (static_cast<_Elem>(_Uchar) != _Char) {
+        return false;
+    }
+
+    switch (_Uchar) {
+    case _Meta_esc:
+        // BRE, ERE, awk identity escape characters (anywhere in awk)
+        return true;
+    case _Meta_dot:
+    case _Meta_lsq:
+    case _Meta_rsq:
+    case _Meta_star:
+    case _Meta_caret:
+    case _Meta_dlr:
+        // BRE, ERE, awk identity escape characters (outside character classes only)
+        return !_In_character_class;
+    case _Meta_lpar:
+    case _Meta_rpar:
+    case _Meta_bar:
+    case _Meta_plus:
+    case _Meta_query:
+    case _Meta_lbr:
+    case _Meta_rbr:
+        // additional ERE identity escape characters (outside character classes only)
+        return (_L_flags & _L_ident_ERE) != 0 && !_In_character_class;
+    case '"':
+    case '/':
+        // additional awk identity escape characters (anywhere)
+        return (_L_flags & _L_ident_awk) != 0;
+    default:
+        return false;
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_IdentityEscape(bool _In_character_class) {
+    // check whether an escape is valid, and process it if so
+    if (_IsIdentityEscape(_In_character_class)) {
+        _Unescaped_char = _Char;
+        _Next();
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_Do_ffn(_Elem _Ch) { // check for limited file format escape characters
+    if (_Ch == static_cast<char>(_Esc_ctrl_f)) {
+        _Val = '\f';
+    } else if (_Ch == static_cast<char>(_Esc_ctrl_n)) {
+        _Val = '\n';
+    } else if (_Ch == static_cast<char>(_Esc_ctrl_r)) {
+        _Val = '\r';
+    } else if (_Ch == static_cast<char>(_Esc_ctrl_t)) {
+        _Val = '\t';
+    } else if (_Ch == static_cast<char>(_Esc_ctrl_v)) {
+        _Val = '\v';
+    } else {
+        return false;
+    }
+
+    return true;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_Do_ffnx(_Elem _Ch) { // check for the remaining file format escape characters
+    if (_Ch == static_cast<char>(_Esc_ctrl_a)) {
+        _Val = '\a';
+    } else if (_Ch == static_cast<char>(_Esc_ctrl_b)) {
+        _Val = '\b';
+    } else {
+        return false;
+    }
+
+    return true;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+bool _Parser2<_FwdIt, _Elem, _RxTraits>::_CharacterEscape(bool _In_character_class) {
+    // check for valid character escape
+    if (_Mchar == _Meta_eos) {
+        _Error(regex_constants::error_escape);
+    }
+
+    if ((_L_flags & _L_esc_ffn && _Do_ffn(_Char)) || (_L_flags & _L_esc_ffnx && _Do_ffnx(_Char))) {
+        _Next();
+    } else if (_Char == static_cast<char>(_Esc_ctrl) && (_L_flags & _L_esc_ctrl)) { // handle control escape sequence
+        _Next();
+
+        using _Char_traits_type = typename _RxTraits::string_type::traits_type;
+        if ((_Char_traits_type::lt(_Char, static_cast<_Elem>('a'))
+                || _Char_traits_type::lt(static_cast<_Elem>('z'), _Char))
+            && (_Char_traits_type::lt(_Char, static_cast<_Elem>('A'))
+                || _Char_traits_type::lt(static_cast<_Elem>('Z'), _Char))) {
+            _Error(regex_constants::error_escape);
+        }
+
+        _Val = static_cast<unsigned char>(_Char) % 32;
+        _Next();
+    } else if (_Char == static_cast<char>(_Esc_hex) && (_L_flags & _L_esc_hex)) { // handle hexadecimal escape sequence
+        _Next();
+        _HexDigits(2);
+    } else if (_Char == static_cast<char>(_Esc_uni) && (_L_flags & _L_esc_uni)) { // handle Unicode escape sequence
+        _Next();
+        _HexDigits(4);
+    } else if ((_L_flags & _L_esc_oct) && _OctalDigits()) { // handle octal escape sequence
+        if (_Val == 0) {
+            _Error(regex_constants::error_escape);
+        }
+    } else {
+        return _IdentityEscape(_In_character_class);
+    }
+
+    _Unescaped_char = static_cast<_Elem>(static_cast<unsigned int>(_Val));
+    int _Cast_val;
+    if constexpr (is_integral_v<_Elem> || is_enum_v<_Elem>) {
+        _Cast_val = static_cast<int>(static_cast<make_unsigned_t<_Elem>>(_Unescaped_char));
+    } else {
+        _Cast_val = static_cast<int>(static_cast<unsigned int>(_Unescaped_char));
+    }
+
+    if (_Cast_val != _Val) {
+        _Error(regex_constants::error_escape);
+    }
+
+    return true;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_AtomEscape() { // check for valid atom escape
+    if ((_L_flags & (_L_bzr_chr | _L_bckr)) && (_Val = _Traits.value(_Char, 10)) != -1) { // escaped decimal sequence
+        _Next();
+        if ((_L_flags & _L_bzr_chr) && _Val == 0) { // handle \0
+            if (_Traits.value(_Char, 10) != -1) {
+                _Error(regex_constants::error_escape);
+            }
+            _Nfa._Add_char(_Elem{});
+        } else if (_L_flags & _L_bckr) { // check for valid backreference
+            if (!(_L_flags & _L_lim_bckr)) {
+                (void) _DecimalDigits(regex_constants::error_backref, _Val);
+            }
+
+            if (_Val == 0) {
+                _Error(regex_constants::error_escape);
+            } else if (_Grp_idx < static_cast<size_t>(_Val) || _Finished_grps.size() <= static_cast<size_t>(_Val)
+                       || !_Finished_grps[static_cast<size_t>(_Val)]) {
+                _Error(regex_constants::error_backref);
+            } else {
+                _Nfa._Add_backreference(static_cast<size_t>(_Val));
+            }
+        }
+    } else if (_CharacterEscape(false)) {
+        _Nfa._Add_char(_Unescaped_char);
+    } else if (!(_L_flags & _L_esc_wsd) || !_CharacterClassEscape(true)) {
+        _Error(regex_constants::error_escape);
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Quantifier() { // check for quantifier following atom
+    int _Min = 0;
+    int _Max = -1;
+    if (_Mchar != _Meta_star) {
+        if (_Mchar == _Meta_plus) {
+            _Min = 1;
+        } else if (_Mchar == _Meta_query) {
+            _Max = 1;
+        } else if (_Mchar == _Meta_lbr) { // check for valid bracketed value
+            _Next();
+            if (!_DecimalDigits(regex_constants::error_badbrace)) {
+                _Error(regex_constants::error_badbrace);
+            }
+
+            _Min = _Val;
+            if (_Mchar != _Meta_comma) {
+                _Max = _Min;
+            } else { // check for decimal constant following comma
+                _Next();
+                if (_Mchar != _Meta_rbr) {
+                    if (!_DecimalDigits(regex_constants::error_badbrace)) {
+                        _Error(regex_constants::error_badbrace);
+                    }
+
+                    _Max = _Val;
+                }
+            }
+
+            if (_Mchar != _Meta_rbr || (_Max != -1 && _Max < _Min)) {
+                _Error(regex_constants::error_badbrace);
+            }
+        } else {
+            return;
+        }
+    }
+
+    _Next();
+    const bool _Greedy = !(_L_flags & _L_non_greedy) || _Mchar != _Meta_query;
+    if (!_Greedy) { // add non-greedy repeat node
+        _Next();
+    }
+
+    _Nfa._Add_rep(_Min, _Max, _Greedy);
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Alternative2() { // check for valid alternative
+    bool _Found = false;
+    while (_Mchar != _Meta_eos && _Mchar != _Meta_bar
+           && (_Mchar != _Meta_rpar || _Disj_count == 0)) { // concatenate valid elements
+        bool _Quant = true;
+        if (_Mchar == _Meta_rpar && !(_L_flags & _L_paren_bal)) {
+            _Error(regex_constants::error_paren);
+        } else if (_Mchar == _Meta_dot) { // add dot node
+            _Nfa._Add_dot();
+            _Next();
+        } else if (_Mchar == _Meta_esc) { // check for valid escape sequence
+            _Next();
+            if ((_L_flags & _L_asrt_wrd) && _Char == static_cast<char>(_Esc_word)) { // add word assert
+                _Nfa._Add_wbound();
+                _Next();
+                _Quant = false;
+            } else if ((_L_flags & _L_asrt_wrd) && _Char == static_cast<char>(_Esc_not_word)) { // add not-word assert
+                _Nfa._Add_wbound();
+                _Nfa._Negate();
+                _Next();
+                _Quant = false;
+            } else {
+                _AtomEscape();
+            }
+        } else if (_Mchar == _Meta_lsq) { // add bracket expression
+            _Mode = _Lex_mode::_Character_class;
+            _Next();
+            _CharacterClass();
+            _Mode = _Lex_mode::_Default;
+            _Expect(_Meta_rsq, regex_constants::error_brack);
+        } else if (_Mchar == _Meta_lpar) { // check for valid group
+            _Next();
+            _Quant = _Wrapped_disjunction();
+            _Expect(_Meta_rpar, regex_constants::error_paren);
+        } else if (_Mchar == _Meta_caret && (!(_L_flags & _L_anch_rstr) || !_Found)) { // add bol node
+            _Nfa._Add_bol();
+            _Next();
+            if ((_L_flags & _L_star_beg) && _Mchar == _Meta_star && !_Found) {
+                _Nfa._Add_char(_Char);
+                _Next();
+            } else {
+                _Quant = false;
+            }
+        } else if (_Mchar == _Meta_dlr) { // add eol node
+            _Nfa._Add_eol();
+            _Next();
+            _Quant = false;
+        } else if ((_Mchar == _Meta_star && (!(_L_flags & _L_star_beg) || _Found)) || _Mchar == _Meta_plus
+                   || _Mchar == _Meta_query || _Mchar == _Meta_lbr) {
+            _Error(regex_constants::error_badrepeat);
+        } else if (_Mchar == _Meta_rbr && !(_L_flags & _L_paren_bal)) {
+            _Error(regex_constants::error_brace);
+        } else if (_Mchar == _Meta_rsq && !(_L_flags & _L_brk_bal)) {
+            _Error(regex_constants::error_brack);
+        } else { // add character
+            _Nfa._Add_char(_Char);
+            _Next();
+        }
+
+        if (_Quant) {
+            _Quantifier();
+        }
+
+        _Found = true;
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Disjunction() { // check for valid disjunction
+    _Node_base* _Pos1 = _Nfa._Getmark();
+
+    _Alternative2();
+
+    if (_Mchar == _Meta_bar) { // at least one more alternative
+        _Node_base* _Pos2 = _Nfa._Begin_if(_Pos1);
+        do { // append terms as long as we keep finding | characters
+            _Next();
+            _Alternative2();
+            _Nfa._Else_if2(_Pos1, _Pos2);
+        } while (_Mchar == _Meta_bar);
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+void _Parser2<_FwdIt, _Elem, _RxTraits>::_Calculate_loop_simplicity(
+    _Node_base* _Nx, _Node_base* _Ne, _Node_rep* _Outer_rep, const bool _Nonreentrant) {
+    // walks regex NFA, calculates values of _Node_rep::_Simple_loop
+    for (; _Nx != _Ne && _Nx; _Nx = _Nx->_Next) {
+        switch (_Nx->_Kind) {
+        case _N_if:
+            // _Node_if inside a _Node_rep makes the rep not simple
+            if (_Outer_rep) {
+                _Outer_rep->_Simple_loop = 0;
+                _Outer_rep->_Flags &= ~_Fl_rep_branchless;
+            }
+
+            // visit each branch of the if
+            for (_Node_if* _Branch = static_cast<_Node_if*>(_Nx)->_Child; _Branch; _Branch = _Branch->_Child) {
+                _Calculate_loop_simplicity(_Branch->_Next, _Branch->_Endif, _Outer_rep, _Nonreentrant);
+            }
+            break;
+
+        case _N_assert:
+            // A positive lookahead assertion inside a _Node_rep makes the rep not simple
+            if (_Outer_rep) {
+                _Outer_rep->_Simple_loop = 0;
+                _Outer_rep->_Flags &= ~_Fl_rep_branchless;
+            }
+            _FALLTHROUGH;
+
+        case _N_neg_assert:
+            // visit the assertion body
+            // note _Outer_rep being reset: the assertion regex is completely independent
+            _Calculate_loop_simplicity(static_cast<_Node_assert*>(_Nx)->_Child, nullptr, nullptr, true);
+            break;
+
+        case _N_rep:
+            // _Node_rep inside another _Node_rep makes both not simple if _Outer_rep can be repeated more than once
+            // because the matcher does not reset capture group boundaries when handling simple loops.
+            // If _Outer_rep can repeat at most once, we have to analyze the structure of the inner loop.
+            if (_Outer_rep) {
+                _Outer_rep->_Simple_loop = 0;
+                _Outer_rep->_Flags &= ~_Fl_rep_branchless;
+                auto _Inner_rep = static_cast<_Node_rep*>(_Nx);
+                _Inner_rep->_Flags |= _Fl_rep_branchless;
+                const bool _Inner_nonreentrant = _Outer_rep->_Max >= 0 && _Outer_rep->_Max <= 1 && _Nonreentrant;
+                if (!_Inner_nonreentrant) {
+                    _Inner_rep->_Simple_loop = 0;
+                }
+
+                _Calculate_loop_simplicity(
+                    _Inner_rep->_Next, _Inner_rep->_End_rep->_Next, _Inner_rep, _Inner_nonreentrant);
+                _Nx = _Inner_rep->_End_rep;
+            } else {
+                _Outer_rep = static_cast<_Node_rep*>(_Nx);
+                _Outer_rep->_Flags |= _Fl_rep_branchless;
+            }
+            break;
+
+        case _N_end_rep:
+            if (_Outer_rep == static_cast<_Node_end_rep*>(_Nx)->_Begin_rep) {
+                // if the _Node_rep is still undetermined when we reach its end, it is simple
+                _Analysis_assume_(_Outer_rep);
+                if (_Outer_rep->_Simple_loop == -1) {
+                    _Outer_rep->_Simple_loop = 1;
+                }
+                _Outer_rep = nullptr;
+            }
+            break;
+
+        case _N_class:
+            if (_Outer_rep) {
+                // _Node_rep is not simple if a class can match character sequences of different lengths
+                auto _Node = static_cast<const _Node_class<_Elem, _RxTraits>*>(_Nx);
+                bool _Coll_diff_size =
+                    _Node->_Coll
+                    && (_Node->_Small || _Node->_Large || _Node->_Ranges || _Node->_Classes || _Node->_Coll->_Next);
+                if (_Coll_diff_size || _Node->_Equiv
+                    || ((_Flags & regex_constants::collate) && (_Node->_Ranges || (_Node->_Flags & _Fl_negate)))) {
+                    _Outer_rep->_Simple_loop = 0;
+                    _Outer_rep->_Flags &= ~_Fl_rep_branchless;
+                }
+            }
+            break;
+
+        case _N_back:
+            if (_Outer_rep && !_Nonreentrant) {
+                // The content and thus length of a back-reference may change
+                // when a loop is reentered
+                _Outer_rep->_Flags &= ~_Fl_rep_branchless;
+            }
+            break;
+
+        case _N_group:
+        case _N_capture:
+        case _N_none:
+        case _N_nop:
+        case _N_bol:
+        case _N_eol:
+        case _N_wbound:
+        case _N_dot:
+        case _N_str:
+        case _N_end_group:
+        case _N_end_assert:
+        case _N_end_capture:
+        case _N_endif:
+        case _N_begin:
+        case _N_end:
+        default:
+            break;
+        }
+    }
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Root_node* _Parser2<_FwdIt, _Elem, _RxTraits>::_Compile() { // compile regular expression
+    _Root_node* _Res = nullptr;
+    _Tidy_guard<decltype(_Nfa)> _Guard{_STD addressof(_Nfa)};
+    _Node_base* _Pos1 = _Nfa._Begin_capture_group(0);
+    _Disjunction();
+    _STL_INTERNAL_CHECK(_Pat == _End);
+
+    _Nfa._End_group(_Pos1);
+    _Res         = _Nfa._End_pattern();
+    _Res->_Fl    = _Flags;
+    _Res->_Marks = _Mark_count();
+    _Calculate_loop_simplicity(_Res, nullptr, nullptr, true);
+    _Guard._Target = nullptr;
+    return _Res;
+}
+
+template <class _FwdIt, class _Elem, class _RxTraits>
+_Parser2<_FwdIt, _Elem, _RxTraits>::_Parser2(
+    const _RxTraits& _Tr, _FwdIt _Pfirst, _FwdIt _Plast, regex_constants::syntax_option_type _Fx)
+    : _Pat(_Pfirst), _End(_Plast), _Nfa(_Tr, _Fx), _Traits(_Tr), _Flags(_Fx) {
+
+    constexpr unsigned long long _ECMA_flags = _L_ext_rep | _L_alt_pipe | _L_nex_grp | _L_nex_rep | _L_nc_asrt
+                                             | _L_asrt_wrd | _L_bckr | _L_non_greedy | _L_esc_uni | _L_esc_hex
+                                             | _L_esc_bsp | _L_esc_ffn | _L_esc_wsd | _L_esc_ctrl | _L_bzr_chr
+                                             | _L_grp_esc | _L_ident_ECMA | _L_empty_grp;
+
+    constexpr unsigned long long _Basic_flags = _L_bckr | _L_lim_bckr | _L_anch_rstr | _L_star_beg | _L_empty_grp
+                                              | _L_brk_bal | _L_brk_rstr | _L_dsh_rstr | _L_mtch_long;
+
+    constexpr unsigned long long _Grep_flags = _Basic_flags | _L_alt_nl | _L_no_nl;
+
+    constexpr unsigned long long _Extended_flags = _L_ext_rep | _L_alt_pipe | _L_nex_grp | _L_nex_rep | _L_ident_ERE
+                                                 | _L_paren_bal | _L_brk_bal | _L_brk_rstr | _L_dsh_rstr | _L_mtch_long;
+
+    constexpr unsigned long long _Awk_flags =
+        _Extended_flags | _L_esc_oct | _L_esc_ffn | _L_esc_ffnx | _L_grp_esc | _L_ident_awk;
+
+    constexpr unsigned long long _Egrep_flags = _Extended_flags | _L_alt_nl | _L_no_nl;
+
+    const regex_constants::syntax_option_type _Masked = _Flags & regex_constants::_Gmask;
+
+    if (_Masked == regex_constants::ECMAScript || _Masked == 0) {
+        _L_flags = _ECMA_flags;
+    } else if (_Masked == regex_constants::basic) {
+        _L_flags = _Basic_flags;
+    } else if (_Masked == regex_constants::extended) {
+        _L_flags = _Extended_flags;
+    } else if (_Masked == regex_constants::awk) {
+        _L_flags = _Awk_flags;
+    } else if (_Masked == regex_constants::grep) {
+        _L_flags = _Grep_flags;
+    } else if (_Masked == regex_constants::egrep) {
+        _L_flags = _Egrep_flags;
+    } else {
+        _L_flags = 0;
+    }
+
+    if (_L_flags & _L_mtch_long) {
+        _Nfa._Setlong();
+    }
+
+    _Trans();
+}
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _BidIt>
+    using match_results = _STD match_results<_BidIt, polymorphic_allocator<sub_match<_BidIt>>>;
+
+    _EXPORT_STD using cmatch  = match_results<const char*>;
+    _EXPORT_STD using wcmatch = match_results<const wchar_t*>;
+    _EXPORT_STD using smatch  = match_results<string::const_iterator>;
+    _EXPORT_STD using wsmatch = match_results<wstring::const_iterator>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _REGEX_
diff --git a/msvc-stl/stl/inc/scoped_allocator b/msvc-stl/stl/inc/scoped_allocator
new file mode 100644
index 0000000..69ce3ef
--- /dev/null
+++ b/msvc-stl/stl/inc/scoped_allocator
@@ -0,0 +1,295 @@
+// scoped_allocator standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SCOPED_ALLOCATOR_
+#define _SCOPED_ALLOCATOR_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xpolymorphic_allocator.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+template <class _Alloc, class = void>
+struct _Scoped_outermost_helper { // gets the outermost allocator
+    static decltype(auto) _Fn(_Alloc& _Al) { // gets the outermost allocator
+        return _Al;
+    }
+};
+
+template <class _Alloc>
+struct _Scoped_outermost_helper<_Alloc,
+    void_t<decltype(_STD declval<_Alloc&>().outer_allocator())>> { // gets the outermost allocator
+    using _Outer_alloc = decltype(_STD declval<_Alloc&>().outer_allocator());
+
+    static decltype(auto) _Fn(_Alloc& _Al) { // gets the outermost allocator
+        return _Scoped_outermost_helper<_Outer_alloc>::_Fn(_Al.outer_allocator());
+    }
+};
+
+template <class _Alloc>
+decltype(auto) _Scoped_outermost(_Alloc& _Al) { // gets the outermost allocator
+    return _Scoped_outermost_helper<_Alloc>::_Fn(_Al);
+}
+
+template <class _Alloc>
+using _Scoped_outermost_t = remove_reference_t<decltype(_STD _Scoped_outermost(_STD declval<_Alloc&>()))>;
+
+template <class _Alloc>
+using _Scoped_outermost_traits = allocator_traits<_Scoped_outermost_t<_Alloc>>;
+
+_EXPORT_STD template <class _Outer, class... _Inner>
+class scoped_allocator_adaptor;
+
+template <class _Outer, class... _Inner>
+struct _Scoped_base;
+
+struct _Secret_scoped_allocator_construct_tag {
+    explicit _Secret_scoped_allocator_construct_tag() = default;
+};
+
+template <class _Outer, class _Inner0, class... _Inner>
+struct _Scoped_base<_Outer, _Inner0, _Inner...> : _Outer { // nest of allocators, arbitrary depth
+    using _Myadaptor           = scoped_allocator_adaptor<_Outer, _Inner0, _Inner...>;
+    using inner_allocator_type = scoped_allocator_adaptor<_Inner0, _Inner...>;
+
+    inner_allocator_type _Inner_obj;
+
+    inner_allocator_type& _Get_inner_object(_Myadaptor&) {
+        return _Inner_obj;
+    }
+
+    const inner_allocator_type& _Get_inner_object(const _Myadaptor&) const {
+        return _Inner_obj;
+    }
+
+    _Scoped_base() : _Outer(), _Inner_obj() {} // value-initialize Outer and Inner
+
+    template <class _Other1, class... _Other2,
+        enable_if_t<sizeof...(_Other2) != 0 || !is_base_of_v<_Scoped_base, decay_t<_Other1>>, int> = 0>
+    _Scoped_base(_Other1&& _Outer_arg, _Other2&&... _Inner_args)
+        : _Outer(_STD forward<_Other1>(_Outer_arg)), _Inner_obj(_STD forward<_Other2>(_Inner_args)...) {
+        // also handles rebinding
+    }
+
+    _Scoped_base(const _Scoped_base&)            = default;
+    _Scoped_base(_Scoped_base&&)                 = default;
+    _Scoped_base& operator=(const _Scoped_base&) = default;
+    _Scoped_base& operator=(_Scoped_base&&)      = default;
+
+    _NODISCARD _Myadaptor select_on_container_copy_construction() const { // make new adaptor
+        return _Myadaptor(_Secret_scoped_allocator_construct_tag{},
+            allocator_traits<_Outer>::select_on_container_copy_construction(static_cast<const _Outer&>(*this)),
+            _Inner_obj.select_on_container_copy_construction());
+    }
+};
+
+template <class _Outer>
+struct _Scoped_base<_Outer> : _Outer { // nest of allocators, one deep
+    using _Myadaptor           = scoped_allocator_adaptor<_Outer>;
+    using inner_allocator_type = scoped_allocator_adaptor<_Outer>;
+
+    inner_allocator_type& _Get_inner_object(_Myadaptor& _Self) {
+        return _Self;
+    }
+
+    const inner_allocator_type& _Get_inner_object(const _Myadaptor& _Self) const {
+        return _Self;
+    }
+
+    _Scoped_base() : _Outer() {} // value-initialize
+
+    template <class _Other1, enable_if_t<!is_base_of_v<_Scoped_base, decay_t<_Other1>>, int> = 0>
+    _Scoped_base(_Other1&& _Outer_arg) : _Outer(_STD forward<_Other1>(_Outer_arg)) {} // also handles rebinding
+
+    _Scoped_base(const _Scoped_base&)            = default;
+    _Scoped_base(_Scoped_base&&)                 = default;
+    _Scoped_base& operator=(const _Scoped_base&) = default;
+    _Scoped_base& operator=(_Scoped_base&&)      = default;
+
+    _NODISCARD _Myadaptor select_on_container_copy_construction() const { // make new adaptor
+        return _Myadaptor(
+            allocator_traits<_Outer>::select_on_container_copy_construction(static_cast<const _Outer&>(*this)));
+    }
+};
+
+_EXPORT_STD template <class _Outer, class... _Inner>
+class scoped_allocator_adaptor : public _Scoped_base<_Outer, _Inner...> { // nest of allocators
+private:
+    using _Mybase       = _Scoped_base<_Outer, _Inner...>;
+    using _Outer_traits = allocator_traits<_Outer>;
+
+public:
+    using outer_allocator_type = _Outer;
+    using inner_allocator_type = typename _Mybase::inner_allocator_type;
+
+    using value_type         = typename _Outer_traits::value_type;
+    using pointer            = typename _Outer_traits::pointer;
+    using const_pointer      = typename _Outer_traits::const_pointer;
+    using void_pointer       = typename _Outer_traits::void_pointer;
+    using const_void_pointer = typename _Outer_traits::const_void_pointer;
+
+    using size_type       = typename _Outer_traits::size_type;
+    using difference_type = typename _Outer_traits::difference_type;
+
+    template <class _Other>
+    struct _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES rebind { // converts X<value_type> to X<_Other>
+        using _Other_alloc = typename _Get_rebind_type<_Outer, _Other>::type;
+        using other        = scoped_allocator_adaptor<_Other_alloc, _Inner...>;
+    };
+
+    using propagate_on_container_copy_assignment =
+        bool_constant<disjunction_v<typename allocator_traits<_Outer>::propagate_on_container_copy_assignment,
+            typename allocator_traits<_Inner>::propagate_on_container_copy_assignment...>>;
+
+    using propagate_on_container_move_assignment =
+        bool_constant<disjunction_v<typename allocator_traits<_Outer>::propagate_on_container_move_assignment,
+            typename allocator_traits<_Inner>::propagate_on_container_move_assignment...>>;
+
+    using propagate_on_container_swap =
+        bool_constant<disjunction_v<typename allocator_traits<_Outer>::propagate_on_container_swap,
+            typename allocator_traits<_Inner>::propagate_on_container_swap...>>;
+
+    using is_always_equal = bool_constant<conjunction_v<typename allocator_traits<_Outer>::is_always_equal,
+        typename allocator_traits<_Inner>::is_always_equal...>>;
+
+    scoped_allocator_adaptor() = default; // value-init handled in _Scoped_base
+
+    template <class _Other, enable_if_t<is_constructible_v<_Outer, _Other>, int> = 0>
+    scoped_allocator_adaptor(_Other&& _Other_arg, const _Inner&... _Inner_args) noexcept
+        : _Mybase(_STD forward<_Other>(_Other_arg), _Inner_args...) {
+        // also handles rebinding construction when sizeof...(_Inner) == 0
+    }
+
+    scoped_allocator_adaptor(const scoped_allocator_adaptor& _Right) noexcept : _Mybase(_Right) {}
+
+    scoped_allocator_adaptor(scoped_allocator_adaptor&& _Right) noexcept : _Mybase(_STD move(_Right)) {}
+
+    template <class _Other, bool _Enabled = sizeof...(_Inner) != 0 && is_constructible_v<_Outer, const _Other&>,
+        enable_if_t<_Enabled, int> = 0>
+    scoped_allocator_adaptor(const scoped_allocator_adaptor<_Other, _Inner...>& _Right) noexcept
+        : _Mybase(_Right.outer_allocator(), _Right.inner_allocator()) {}
+
+    template <class _Other, bool _Enabled = sizeof...(_Inner) != 0 && is_constructible_v<_Outer, _Other>,
+        enable_if_t<_Enabled, int> = 0>
+    scoped_allocator_adaptor(scoped_allocator_adaptor<_Other, _Inner...>&& _Right) noexcept
+        : _Mybase(_STD move(_Right.outer_allocator()), _STD move(_Right.inner_allocator())) {}
+
+    scoped_allocator_adaptor(_Secret_scoped_allocator_construct_tag, const outer_allocator_type& _Outer_arg,
+        const inner_allocator_type& _Inner_arg) noexcept
+        : _Mybase(_Outer_arg, _Inner_arg) {}
+
+    scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
+    scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&)      = default;
+
+    _NODISCARD inner_allocator_type& inner_allocator() noexcept { // get reference to inner allocator
+        return this->_Get_inner_object(*this);
+    }
+
+    _NODISCARD const inner_allocator_type& inner_allocator() const noexcept { // get reference to inner allocator
+        return this->_Get_inner_object(*this);
+    }
+
+    _NODISCARD outer_allocator_type& outer_allocator() noexcept { // get reference to outer allocator
+        return static_cast<_Outer&>(*this);
+    }
+
+    _NODISCARD const outer_allocator_type& outer_allocator() const noexcept { // get reference to outer allocator
+        return static_cast<const _Outer&>(*this);
+    }
+
+    _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) pointer allocate(_CRT_GUARDOVERFLOW size_type _Count) {
+        // allocate array of _Count elements, ignore hint
+        return _Outer_traits::allocate(outer_allocator(), _Count);
+    }
+
+    _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) pointer allocate(
+        _CRT_GUARDOVERFLOW size_type _Count, const_void_pointer _Hint) { // allocate array of _Count elements, with hint
+        return _Outer_traits::allocate(outer_allocator(), _Count, _Hint);
+    }
+
+    void deallocate(pointer _Ptr, size_type _Count) { // deallocate object at _Ptr, with size
+        return _Outer_traits::deallocate(outer_allocator(), _Ptr, _Count);
+    }
+
+    _NODISCARD size_type max_size() const { // estimate maximum array size
+        return _Outer_traits::max_size(outer_allocator());
+    }
+
+    template <class _Ty, class... _Types>
+    void construct(_Ty* _Ptr, _Types&&... _Args) { // construct with varying allocator styles
+#if _HAS_CXX20
+        _STD apply(
+            [_Ptr, this](auto&&... _New_args) {
+                _Scoped_outermost_traits<scoped_allocator_adaptor>::construct(
+                    _STD _Scoped_outermost(*this), _Ptr, _STD forward<decltype(_New_args)>(_New_args)...);
+            },
+            _STD uses_allocator_construction_args<_Ty>(inner_allocator(), _STD forward<_Types>(_Args)...));
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        if constexpr (_Is_cv_pair<_Ty>) {
+            _STD _Uses_alloc_construct_pair(
+                _Ptr, _STD _Scoped_outermost(*this), inner_allocator(), _STD forward<_Types>(_Args)...);
+        } else {
+            _STD _Uses_alloc_construct_non_pair(
+                _Ptr, _STD _Scoped_outermost(*this), inner_allocator(), _STD forward<_Types>(_Args)...);
+        }
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+
+    template <class _Ty>
+    void destroy(_Ty* _Ptr) { // destroy object at _Ptr
+        _Scoped_outermost_traits<scoped_allocator_adaptor>::destroy(_STD _Scoped_outermost(*this), _Ptr);
+    }
+
+    // select_on_container_copy_construction comes from _Scoped_base
+};
+
+#if _HAS_CXX17
+template <class _Outer, class... _Inner>
+scoped_allocator_adaptor(_Outer, _Inner...) -> scoped_allocator_adaptor<_Outer, _Inner...>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Outer1, class _Outer2, class... _Inner>
+_NODISCARD bool operator==(const scoped_allocator_adaptor<_Outer1, _Inner...>& _Left,
+    const scoped_allocator_adaptor<_Outer2, _Inner...>& _Right) noexcept {
+    if constexpr (sizeof...(_Inner) == 0) {
+        return _Left.outer_allocator() == _Right.outer_allocator();
+    } else {
+        return _Left.outer_allocator() == _Right.outer_allocator()
+            && _Left.inner_allocator() == _Right.inner_allocator();
+    }
+}
+
+#if !_HAS_CXX20
+template <class _Outer1, class _Outer2, class... _Inner>
+_NODISCARD bool operator!=(const scoped_allocator_adaptor<_Outer1, _Inner...>& _Left,
+    const scoped_allocator_adaptor<_Outer2, _Inner...>& _Right) noexcept {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SCOPED_ALLOCATOR_
diff --git a/msvc-stl/stl/inc/semaphore b/msvc-stl/stl/inc/semaphore
new file mode 100644
index 0000000..e012ece
--- /dev/null
+++ b/msvc-stl/stl/inc/semaphore
@@ -0,0 +1,309 @@
+// semaphore standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SEMAPHORE_
+#define _SEMAPHORE_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <semaphore> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <semaphore> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+
+#include <__msvc_chrono.hpp>
+#include <atomic>
+#include <climits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+template <class _Clock, class _Duration>
+_NODISCARD unsigned long _Semaphore_remaining_timeout(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+    const auto _Now = _Clock::now();
+    if (_Now >= _Abs_time) {
+        return 0;
+    }
+
+    const auto _Rel_time = chrono::ceil<chrono::milliseconds>(_Abs_time - _Now);
+    constexpr chrono::milliseconds _Ten_days{chrono::hours{24 * 10}};
+    _STL_INTERNAL_STATIC_ASSERT(_STD in_range<unsigned long>(_Ten_days.count()));
+    if (_Rel_time >= _Ten_days) {
+        return static_cast<unsigned long>(_Ten_days.count());
+    }
+
+    return static_cast<unsigned long>(_Rel_time.count());
+}
+
+inline constexpr ptrdiff_t _Semaphore_max = PTRDIFF_MAX;
+
+_EXPORT_STD template <ptrdiff_t _Least_max_value = _Semaphore_max>
+class counting_semaphore {
+public:
+    static_assert(_Least_max_value >= 0,
+        "The least maximum value for a counting_semaphore must be nonnegative (N4950 [thread.sema.cnt]/2).");
+
+    _NODISCARD static constexpr ptrdiff_t(max)() noexcept {
+        return _Least_max_value;
+    }
+
+    constexpr explicit counting_semaphore(const ptrdiff_t _Desired) noexcept /* strengthened */
+        : _Counter(_Desired) {
+        _STL_VERIFY(_Desired >= 0 && _Desired <= _Least_max_value,
+            "Precondition: desired >= 0, and desired <= max() (N4950 [thread.sema.cnt]/5)");
+    }
+
+    counting_semaphore(const counting_semaphore&)            = delete;
+    counting_semaphore& operator=(const counting_semaphore&) = delete;
+
+    void release(ptrdiff_t _Update = 1) noexcept /* strengthened */ {
+        if (_Update == 0) {
+            return;
+        }
+        _STL_VERIFY(_Update > 0 && _Update <= _Least_max_value,
+            "Precondition: update >= 0, and update <= max() - counter (N4950 [thread.sema.cnt]/8)");
+
+        // We need to notify (wake) at least _Update waiting threads.
+        // Errors towards waking more cannot be always avoided, but they are performance issues.
+        // Errors towards waking fewer must be avoided, as they are correctness issues.
+
+        // release thread: Increment semaphore counter, then load waiting counter;
+        // acquire thread: Increment waiting counter, then load semaphore counter;
+
+        // memory_order_seq_cst for all four operations guarantees that the release thread loads
+        // the incremented value, or the acquire thread loads the incremented value, or both, but not neither.
+        // memory_order_seq_cst might be superfluous for some hardware mappings of the C++ memory model,
+        // but from the point of view of the C++ memory model itself it is needed; weaker orders don't work.
+
+        const ptrdiff_t _Prev = _Counter.fetch_add(_Update);
+        _STL_VERIFY(_Prev >= 0 && _Update <= _Least_max_value - _Prev,
+            "Precondition: update <= max() - counter (N4950 [thread.sema.cnt]/8)");
+
+        const ptrdiff_t _Waiting_upper_bound = _Waiting.load();
+
+        if (_Waiting_upper_bound == 0) {
+            // Definitely no one is waiting
+        } else if (_Waiting_upper_bound <= _Update) {
+            // No more waiting threads than update, can wake everyone.
+            _Counter.notify_all();
+        } else {
+            // Wake at most _Update. Though repeated notify_one() is somewhat less efficient than single notify_all(),
+            // the amount of OS calls is still the same; the benefit from trying not to wake unnecessary threads
+            // is expected to be greater than the loss on extra calls and atomic operations.
+            for (; _Update != 0; --_Update) {
+                _Counter.notify_one();
+            }
+        }
+    }
+
+    void acquire() noexcept /* strengthened */ {
+        ptrdiff_t _Current = _Counter.load(memory_order_relaxed);
+        for (;;) {
+            while (_Current == 0) {
+                _Wait(__std_atomic_wait_no_timeout);
+                _Current = _Counter.load(memory_order_relaxed);
+            }
+            _STL_VERIFY(_Current > 0 && _Current <= _Least_max_value,
+                "Invariant: counter >= 0, and counter <= max() "
+                "possibly caused by preconditions violation (N4950 [thread.sema.cnt]/8)");
+
+            // "happens after release" ordering is provided by this CAS, so loads and waits can be relaxed
+            if (_Counter.compare_exchange_weak(_Current, _Current - 1)) {
+                return;
+            }
+        }
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_acquire() noexcept {
+        ptrdiff_t _Current = _Counter.load();
+        if (_Current == 0) {
+            return false;
+        }
+        _STL_VERIFY(_Current > 0 && _Current <= _Least_max_value,
+            "Invariant: counter >= 0, and counter <= max() "
+            "possibly caused by preconditions violation (N4950 [thread.sema.cnt]/8)");
+
+        return _Counter.compare_exchange_weak(_Current, _Current - 1);
+    }
+
+    template <class _Rep, class _Period>
+    _NODISCARD_TRY_CHANGE_STATE bool try_acquire_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
+        auto _Deadline     = _STD chrono::steady_clock::now() + _Rel_time;
+        ptrdiff_t _Current = _Counter.load(memory_order_relaxed);
+        for (;;) {
+            while (_Current == 0) {
+                const auto _Remaining_timeout = _Semaphore_remaining_timeout(_Deadline);
+                if (_Remaining_timeout == 0) {
+                    return false;
+                }
+                _Wait(_Remaining_timeout);
+                _Current = _Counter.load(memory_order_relaxed);
+            }
+            _STL_VERIFY(_Current > 0 && _Current <= _Least_max_value,
+                "Invariant: counter >= 0, and counter <= max() "
+                "possibly caused by preconditions violation (N4950 [thread.sema.cnt]/8)");
+
+            // "happens after release" ordering is provided by this CAS, so loads and waits can be relaxed
+            if (_Counter.compare_exchange_weak(_Current, _Current - 1)) {
+                return true;
+            }
+        }
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_TRY_CHANGE_STATE bool try_acquire_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
+        ptrdiff_t _Current = _Counter.load(memory_order_relaxed);
+        for (;;) {
+            while (_Current == 0) {
+                const unsigned long _Remaining_timeout = _Semaphore_remaining_timeout(_Abs_time);
+                if (_Remaining_timeout == 0) {
+                    return false;
+                }
+                _Wait(_Remaining_timeout);
+                _Current = _Counter.load(memory_order_relaxed);
+            }
+            _STL_VERIFY(_Current > 0 && _Current <= _Least_max_value,
+                "Invariant: counter >= 0, and counter <= max() "
+                "possibly caused by preconditions violation (N4950 [thread.sema.cnt]/8)");
+
+            // "happens after release" ordering is provided by this CAS, so loads and waits can be relaxed
+            if (_Counter.compare_exchange_weak(_Current, _Current - 1)) {
+                return true;
+            }
+        }
+    }
+
+private:
+    void _Wait(const unsigned long _Remaining_timeout) noexcept {
+        // See the comment in release()
+        _Waiting.fetch_add(1);
+        ptrdiff_t _Current = _Counter.load();
+        if (_Current == 0) {
+            __std_atomic_wait_direct(&_Counter, &_Current, sizeof(_Current), _Remaining_timeout);
+        }
+        _Waiting.fetch_sub(1, memory_order_relaxed);
+    }
+
+    atomic<ptrdiff_t> _Counter;
+    atomic<ptrdiff_t> _Waiting;
+};
+
+template <>
+class counting_semaphore<1> {
+public:
+    _NODISCARD static constexpr ptrdiff_t(max)() noexcept {
+        return 1;
+    }
+
+    constexpr explicit counting_semaphore(const ptrdiff_t _Desired) noexcept /* strengthened */
+        : _Counter(static_cast<unsigned char>(_Desired)) {
+        _STL_VERIFY((_Desired & ~1) == 0, "Precondition: desired >= 0, and desired <= max() "
+                                          "(N4950 [thread.sema.cnt]/5)");
+    }
+
+    counting_semaphore(const counting_semaphore&)            = delete;
+    counting_semaphore& operator=(const counting_semaphore&) = delete;
+
+    void release(const ptrdiff_t _Update = 1) noexcept /* strengthened */ {
+        if (_Update == 0) {
+            return;
+        }
+        _STL_VERIFY(_Update == 1, "Precondition: update >= 0, "
+                                  "and update <= max() - counter (N4950 [thread.sema.cnt]/8)");
+        // TRANSITION, GH-1133: should be memory_order_release
+        _Counter.store(1);
+        _Counter.notify_one();
+    }
+
+    void acquire() noexcept /* strengthened */ {
+        for (;;) {
+            // "happens after release" ordering is provided by this exchange, so loads and waits can be relaxed
+            // TRANSITION, GH-1133: should be memory_order_acquire
+            unsigned char _Prev = _Counter.exchange(0);
+            if (_Prev == 1) {
+                break;
+            }
+            _STL_VERIFY(_Prev == 0, "Invariant: semaphore counter is non-negative and doesn't exceed max(), "
+                                    "possibly caused by memory corruption");
+            _Counter.wait(0, memory_order_relaxed);
+        }
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_acquire() noexcept {
+        // TRANSITION, GH-1133: should be memory_order_acquire
+        unsigned char _Prev = _Counter.exchange(0);
+        _STL_VERIFY((_Prev & ~1) == 0, "Invariant: semaphore counter is non-negative and doesn't exceed max(), "
+                                       "possibly caused by memory corruption");
+        return reinterpret_cast<const bool&>(_Prev);
+    }
+
+    template <class _Rep, class _Period>
+    _NODISCARD_TRY_CHANGE_STATE bool try_acquire_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
+        auto _Deadline = _STD chrono::steady_clock::now() + _Rel_time;
+        for (;;) {
+            // "happens after release" ordering is provided by this exchange, so loads and waits can be relaxed
+            // TRANSITION, GH-1133: should be memory_order_acquire
+            unsigned char _Prev = _Counter.exchange(0);
+            if (_Prev == 1) {
+                return true;
+            }
+            _STL_VERIFY(_Prev == 0, "Invariant: semaphore counter is non-negative and doesn't exceed max(), "
+                                    "possibly caused by memory corruption");
+            const auto _Remaining_timeout = _Semaphore_remaining_timeout(_Deadline);
+            if (_Remaining_timeout == 0) {
+                return false;
+            }
+            __std_atomic_wait_direct(&_Counter, &_Prev, sizeof(_Prev), _Remaining_timeout);
+        }
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_TRY_CHANGE_STATE bool try_acquire_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
+        for (;;) {
+            // "happens after release" ordering is provided by this exchange, so loads and waits can be relaxed
+            // TRANSITION, GH-1133: should be memory_order_acquire
+            unsigned char _Prev = _Counter.exchange(0);
+            if (_Prev == 1) {
+                return true;
+            }
+            _STL_VERIFY(_Prev == 0, "Invariant: semaphore counter is non-negative and doesn't exceed max(), "
+                                    "possibly caused by memory corruption");
+
+            const unsigned long _Remaining_timeout = _Semaphore_remaining_timeout(_Abs_time);
+            if (_Remaining_timeout == 0) {
+                return false;
+            }
+
+            __std_atomic_wait_direct(&_Counter, &_Prev, sizeof(_Prev), _Remaining_timeout);
+        }
+    }
+
+private:
+    atomic<unsigned char> _Counter;
+};
+
+_EXPORT_STD using binary_semaphore = counting_semaphore<1>;
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SEMAPHORE_
diff --git a/msvc-stl/stl/inc/set b/msvc-stl/stl/inc/set
new file mode 100644
index 0000000..9d69548
--- /dev/null
+++ b/msvc-stl/stl/inc/set
@@ -0,0 +1,490 @@
+// set standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SET_
+#define _SET_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xtree>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+_STD_BEGIN
+template <class _Kty, // key/value type
+    class _Pr, // comparator predicate type
+    class _Alloc, // actual allocator type (should be value allocator)
+    bool _Mfl> // true if multiple equivalent keys are permitted
+class _Tset_traits { // traits required to make _Tree behave like a set
+public:
+    using key_type       = _Kty;
+    using value_type     = _Kty;
+    using key_compare    = _Pr;
+    using allocator_type = _Alloc;
+#if _HAS_CXX17
+    using node_type = _Node_handle<_Tree_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
+        _Node_handle_set_base, _Kty>;
+#endif // _HAS_CXX17
+
+    static constexpr bool _Multi = _Mfl;
+
+    template <class... _Args>
+    using _In_place_key_extractor = _In_place_key_extract_set<_Kty, _Args...>;
+
+    using value_compare = key_compare;
+
+    static const _Kty& _Kfn(const value_type& _Val) { // extract key from element value
+        return _Val;
+    }
+};
+
+_EXPORT_STD template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>>
+class set : public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, false>> {
+    // ordered red-black tree of key values, unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Kty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("set<T, Compare, Allocator>", "T"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+    using _Mybase                = _Tree<_Tset_traits<_Kty, _Pr, _Alloc, false>>;
+    using key_type               = _Kty;
+    using key_compare            = _Pr;
+    using value_compare          = typename _Mybase::value_compare;
+    using value_type             = typename _Mybase::value_type;
+    using allocator_type         = typename _Mybase::allocator_type;
+    using size_type              = typename _Mybase::size_type;
+    using difference_type        = typename _Mybase::difference_type;
+    using pointer                = typename _Mybase::pointer;
+    using const_pointer          = typename _Mybase::const_pointer;
+    using reference              = value_type&;
+    using const_reference        = const value_type&;
+    using iterator               = typename _Mybase::iterator;
+    using const_iterator         = typename _Mybase::const_iterator;
+    using reverse_iterator       = typename _Mybase::reverse_iterator;
+    using const_reverse_iterator = typename _Mybase::const_reverse_iterator;
+
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+
+#if _HAS_CXX17
+    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
+#endif // _HAS_CXX17
+
+    set() : _Mybase(key_compare()) {}
+
+    explicit set(const allocator_type& _Al) : _Mybase(key_compare(), _Al) {}
+
+    set(const set& _Right) : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    set(const set& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit set(const key_compare& _Pred) : _Mybase(_Pred) {}
+
+    set(const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {}
+
+    template <class _Iter>
+    set(_Iter _First, _Iter _Last) : _Mybase(key_compare()) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    set(_Iter _First, _Iter _Last, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    set(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    set(_Iter _First, _Iter _Last, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    set(from_range_t, _Rng&& _Range) : _Mybase(key_compare()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    set(from_range_t, _Rng&& _Range, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    set(from_range_t, _Rng&& _Range, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    set(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    set& operator=(const set& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    set(set&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    set(set&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    set& operator=(set&& _Right) noexcept(_Alnode_traits::is_always_equal::value && is_nothrow_move_assignable_v<_Pr>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    void swap(set& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    set(initializer_list<value_type> _Ilist) : _Mybase(key_compare()) {
+        this->insert(_Ilist);
+    }
+
+    set(initializer_list<value_type> _Ilist, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->insert(_Ilist);
+    }
+
+    set(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->insert(_Ilist);
+    }
+
+    set(initializer_list<value_type> _Ilist, const key_compare& _Pred, const allocator_type& _Al)
+        : _Mybase(_Pred, _Al) {
+        this->insert(_Ilist);
+    }
+
+    set& operator=(initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist);
+        return *this;
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Pr = less<_Iter_value_t<_Iter>>, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+set(_Iter, _Iter, _Pr = _Pr(), _Alloc = _Alloc()) -> set<_Iter_value_t<_Iter>, _Pr, _Alloc>;
+
+template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+set(initializer_list<_Kty>, _Pr = _Pr(), _Alloc = _Alloc()) -> set<_Kty, _Pr, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+set(_Iter, _Iter, _Alloc) -> set<_Iter_value_t<_Iter>, less<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+set(initializer_list<_Kty>, _Alloc) -> set<_Kty, less<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Pr = less<_RANGES range_value_t<_Rng>>,
+    _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+set(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc()) -> set<_RANGES range_value_t<_Rng>, _Pr, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+set(from_range_t, _Rng&&, _Alloc) -> set<_RANGES range_value_t<_Rng>, less<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator==(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
+    return _Left.size() == _Right.size()
+        && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD _Synth_three_way_result<_Kty> operator<=>(
+    const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
+    return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
+        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator!=(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator<(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
+    return _STD lexicographical_compare(
+        _Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin(), _Right._Unchecked_end_iter());
+}
+
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator>(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator<=(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator>=(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
+void swap(set<_Kty, _Pr, _Alloc>& _Left, set<_Kty, _Pr, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Keylt, class _Alloc, class _Pr>
+set<_Kty, _Keylt, _Alloc>::size_type erase_if(set<_Kty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>>
+class multiset : public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, true>> {
+    // ordered red-black tree of key values, non-unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Kty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("multiset<T, Compare, Allocator>", "T"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+    using _Mybase                = _Tree<_Tset_traits<_Kty, _Pr, _Alloc, true>>;
+    using key_type               = _Kty;
+    using key_compare            = _Pr;
+    using value_compare          = typename _Mybase::value_compare;
+    using value_type             = typename _Mybase::value_type;
+    using allocator_type         = typename _Mybase::allocator_type;
+    using size_type              = typename _Mybase::size_type;
+    using difference_type        = typename _Mybase::difference_type;
+    using pointer                = typename _Mybase::pointer;
+    using const_pointer          = typename _Mybase::const_pointer;
+    using reference              = value_type&;
+    using const_reference        = const value_type&;
+    using iterator               = typename _Mybase::iterator;
+    using const_iterator         = typename _Mybase::const_iterator;
+    using reverse_iterator       = typename _Mybase::reverse_iterator;
+    using const_reverse_iterator = typename _Mybase::const_reverse_iterator;
+
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+
+    multiset() : _Mybase(key_compare()) {}
+
+    explicit multiset(const allocator_type& _Al) : _Mybase(key_compare(), _Al) {}
+
+    multiset(const multiset& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    multiset(const multiset& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit multiset(const key_compare& _Pred) : _Mybase(_Pred) {}
+
+    multiset(const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {}
+
+    template <class _Iter>
+    multiset(_Iter _First, _Iter _Last) : _Mybase(key_compare()) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    multiset(_Iter _First, _Iter _Last, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    multiset(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    multiset(_Iter _First, _Iter _Last, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    multiset(from_range_t, _Rng&& _Range) : _Mybase(key_compare()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multiset(from_range_t, _Rng&& _Range, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multiset(from_range_t, _Rng&& _Range, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    multiset(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    multiset& operator=(const multiset& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    multiset(multiset&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    multiset(multiset&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    multiset& operator=(multiset&& _Right)
+        noexcept(_Alnode_traits::is_always_equal::value && is_nothrow_move_assignable_v<_Pr>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    template <class... _Valty>
+    iterator emplace(_Valty&&... _Val) {
+        return _Mybase::emplace(_STD forward<_Valty>(_Val)...).first;
+    }
+
+    void swap(multiset& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    multiset(initializer_list<value_type> _Ilist) : _Mybase(key_compare()) {
+        this->insert(_Ilist);
+    }
+
+    multiset(initializer_list<value_type> _Ilist, const key_compare& _Pred) : _Mybase(_Pred) {
+        this->insert(_Ilist);
+    }
+
+    multiset(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
+        this->insert(_Ilist);
+    }
+
+    multiset(initializer_list<value_type> _Ilist, const key_compare& _Pred, const allocator_type& _Al)
+        : _Mybase(_Pred, _Al) {
+        this->insert(_Ilist);
+    }
+
+    multiset& operator=(initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist);
+        return *this;
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Pr = less<_Iter_value_t<_Iter>>, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+multiset(_Iter, _Iter, _Pr = _Pr(), _Alloc = _Alloc()) -> multiset<_Iter_value_t<_Iter>, _Pr, _Alloc>;
+
+template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
+multiset(initializer_list<_Kty>, _Pr = _Pr(), _Alloc = _Alloc()) -> multiset<_Kty, _Pr, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+multiset(_Iter, _Iter, _Alloc) -> multiset<_Iter_value_t<_Iter>, less<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+multiset(initializer_list<_Kty>, _Alloc) -> multiset<_Kty, less<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Pr = less<_RANGES range_value_t<_Rng>>,
+    _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+multiset(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc()) -> multiset<_RANGES range_value_t<_Rng>, _Pr, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+multiset(from_range_t, _Rng&&, _Alloc)
+    -> multiset<_RANGES range_value_t<_Rng>, less<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator==(const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
+    return _Left.size() == _Right.size()
+        && _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD _Synth_three_way_result<_Kty> operator<=>(
+    const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
+    return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
+        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator!=(const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator<(const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
+    return _STD lexicographical_compare(
+        _Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin(), _Right._Unchecked_end_iter());
+}
+
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator>(const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator<=(const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Kty, class _Pr, class _Alloc>
+_NODISCARD bool operator>=(const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Kty, class _Pr, class _Alloc>
+void swap(multiset<_Kty, _Pr, _Alloc>& _Left, multiset<_Kty, _Pr, _Alloc>& _Right)
+    noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Keylt, class _Alloc, class _Pr>
+multiset<_Kty, _Keylt, _Alloc>::size_type erase_if(multiset<_Kty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Kty, class _Pr = less<_Kty>>
+    using set = _STD set<_Kty, _Pr, polymorphic_allocator<_Kty>>;
+
+    _EXPORT_STD template <class _Kty, class _Pr = less<_Kty>>
+    using multiset = _STD multiset<_Kty, _Pr, polymorphic_allocator<_Kty>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SET_
diff --git a/msvc-stl/stl/inc/shared_mutex b/msvc-stl/stl/inc/shared_mutex
new file mode 100644
index 0000000..116882d
--- /dev/null
+++ b/msvc-stl/stl/inc/shared_mutex
@@ -0,0 +1,348 @@
+// shared_mutex standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SHARED_MUTEX_
+#define _SHARED_MUTEX_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <shared_mutex> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#include <condition_variable>
+#include <mutex>
+#include <xthreads.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD class shared_mutex { // class for mutual exclusion shared across threads
+public:
+    using native_handle_type = _Smtx_t*;
+
+    shared_mutex()                               = default;
+    shared_mutex(const shared_mutex&)            = delete;
+    shared_mutex& operator=(const shared_mutex&) = delete;
+
+    void lock() noexcept /* strengthened */ { // lock exclusive
+        _Smtx_lock_exclusive(&_Myhandle);
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock() noexcept /* strengthened */ { // try to lock exclusive
+        return _Smtx_try_lock_exclusive(&_Myhandle) != 0;
+    }
+
+    void unlock() noexcept /* strengthened */ { // unlock exclusive
+        _Smtx_unlock_exclusive(&_Myhandle);
+    }
+
+    void lock_shared() noexcept /* strengthened */ { // lock non-exclusive
+        _Smtx_lock_shared(&_Myhandle);
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_shared() noexcept /* strengthened */ { // try to lock non-exclusive
+        return _Smtx_try_lock_shared(&_Myhandle) != 0;
+    }
+
+    void unlock_shared() noexcept /* strengthened */ { // unlock non-exclusive
+        _Smtx_unlock_shared(&_Myhandle);
+    }
+
+    _NODISCARD native_handle_type native_handle() noexcept /* strengthened */ { // get native handle
+        return &_Myhandle;
+    }
+
+private:
+    _Smtx_t _Myhandle = nullptr;
+};
+
+_EXPORT_STD class shared_timed_mutex { // class for mutual exclusion shared across threads
+private:
+    using _Read_cnt_t = unsigned int;
+
+    static constexpr _Read_cnt_t _Max_readers = static_cast<_Read_cnt_t>(-1);
+
+public:
+    shared_timed_mutex() = default;
+
+    shared_timed_mutex(const shared_timed_mutex&)            = delete;
+    shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
+
+    void lock() { // lock exclusive
+        unique_lock<mutex> _Lock(_Mymtx);
+        while (_Writing) {
+            _Write_queue.wait(_Lock);
+        }
+
+        _Writing = true;
+        while (0 < _Readers) {
+            _Read_queue.wait(_Lock); // wait for writing, no readers
+        }
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock() { // try to lock exclusive
+        lock_guard<mutex> _Lock(_Mymtx);
+        if (_Writing || 0 < _Readers) {
+            return false;
+        } else { // set writing, no readers
+            _Writing = true;
+            return true;
+        }
+    }
+
+    template <class _Rep, class _Period>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_for(
+        const chrono::duration<_Rep, _Period>& _Rel_time) { // try to lock for duration
+        return try_lock_until(_To_absolute_time(_Rel_time));
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        // try to lock until time point
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        auto _Not_writing  = [this] { return !_Writing; };
+        auto _Zero_readers = [this] { return _Readers == 0; };
+        unique_lock<mutex> _Lock(_Mymtx);
+
+        if (!_Write_queue.wait_until(_Lock, _Abs_time, _Not_writing)) {
+            return false;
+        }
+
+        _Writing = true;
+
+        if (!_Read_queue.wait_until(_Lock, _Abs_time, _Zero_readers)) { // timeout, leave writing state
+            _Writing = false;
+            _Lock.unlock(); // unlock before notifying, for efficiency
+            _Write_queue.notify_all();
+            return false;
+        }
+
+        return true;
+    }
+
+    void unlock() { // unlock exclusive
+        { // unlock before notifying, for efficiency
+            lock_guard<mutex> _Lock(_Mymtx);
+
+            _Writing = false;
+        }
+
+        _Write_queue.notify_all();
+    }
+
+    void lock_shared() { // lock non-exclusive
+        unique_lock<mutex> _Lock(_Mymtx);
+        while (_Writing || _Readers == _Max_readers) {
+            _Write_queue.wait(_Lock);
+        }
+
+        ++_Readers;
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_shared() { // try to lock non-exclusive
+        lock_guard<mutex> _Lock(_Mymtx);
+        if (_Writing || _Readers == _Max_readers) {
+            return false;
+        } else { // count another reader
+            ++_Readers;
+            return true;
+        }
+    }
+
+    template <class _Rep, class _Period>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_shared_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
+        // try to lock non-exclusive for relative time
+        return try_lock_shared_until(_To_absolute_time(_Rel_time));
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        // try to lock non-exclusive until absolute time
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        const auto _Can_acquire = [this] { return !_Writing && _Readers < _Max_readers; };
+
+        unique_lock<mutex> _Lock(_Mymtx);
+
+        if (!_Write_queue.wait_until(_Lock, _Abs_time, _Can_acquire)) {
+            return false;
+        }
+
+        ++_Readers;
+        return true;
+    }
+
+    void unlock_shared() { // unlock non-exclusive
+        _Read_cnt_t _Local_readers;
+        bool _Local_writing;
+
+        { // unlock before notifying, for efficiency
+            lock_guard<mutex> _Lock(_Mymtx);
+            --_Readers;
+            _Local_readers = _Readers;
+            _Local_writing = _Writing;
+        }
+
+        if (_Local_writing && _Local_readers == 0) {
+            _Read_queue.notify_one();
+        } else if (!_Local_writing && _Local_readers == _Max_readers - 1) {
+            _Write_queue.notify_all();
+        }
+    }
+
+private:
+    mutex _Mymtx{};
+    condition_variable _Read_queue{};
+    condition_variable _Write_queue{};
+    _Read_cnt_t _Readers = 0;
+    bool _Writing        = false;
+};
+
+_EXPORT_STD template <class _Mutex>
+class shared_lock { // shareable lock
+public:
+    using mutex_type = _Mutex;
+
+    shared_lock() noexcept = default;
+
+    _NODISCARD_LOCK explicit shared_lock(mutex_type& _Mtx)
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(true) { // construct with mutex and lock shared
+        _Mtx.lock_shared();
+    }
+
+    shared_lock(mutex_type& _Mtx, defer_lock_t) noexcept
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(false) {} // construct with unlocked mutex
+
+    _NODISCARD_LOCK shared_lock(mutex_type& _Mtx, try_to_lock_t)
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared()) {} // construct with mutex and try to lock shared
+
+    _NODISCARD_LOCK shared_lock(mutex_type& _Mtx, adopt_lock_t) noexcept // strengthened
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(true) {} // construct with mutex and adopt ownership
+
+    template <class _Rep, class _Period>
+    _NODISCARD_LOCK shared_lock(mutex_type& _Mtx, const chrono::duration<_Rep, _Period>& _Rel_time)
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared_for(_Rel_time)) {
+        // construct with mutex and try to lock for relative time
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_LOCK shared_lock(mutex_type& _Mtx, const chrono::time_point<_Clock, _Duration>& _Abs_time)
+        : _Pmtx(_STD addressof(_Mtx)), _Owns(_Mtx.try_lock_shared_until(_Abs_time)) {
+        // construct with mutex and try to lock until absolute time
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+    }
+
+    ~shared_lock() noexcept {
+        if (_Owns) {
+            _Pmtx->unlock_shared();
+        }
+    }
+
+    _NODISCARD_LOCK shared_lock(shared_lock&& _Other) noexcept : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns) {
+        _Other._Pmtx = nullptr;
+        _Other._Owns = false;
+    }
+
+    shared_lock& operator=(shared_lock&& _Right) noexcept {
+        shared_lock{_STD move(_Right)}.swap(*this);
+        return *this;
+    }
+
+    shared_lock(const shared_lock&)            = delete;
+    shared_lock& operator=(const shared_lock&) = delete;
+
+    void lock() { // lock the mutex
+        _Validate();
+        _Pmtx->lock_shared();
+        _Owns = true;
+    }
+
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock() { // try to lock the mutex
+        _Validate();
+        _Owns = _Pmtx->try_lock_shared();
+        return _Owns;
+    }
+
+    template <class _Rep, class _Period>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
+        // try to lock the mutex for _Rel_time
+        _Validate();
+        _Owns = _Pmtx->try_lock_shared_for(_Rel_time);
+        return _Owns;
+    }
+
+    template <class _Clock, class _Duration>
+    _NODISCARD_TRY_CHANGE_STATE bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        // try to lock the mutex until _Abs_time
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        _Validate();
+        _Owns = _Pmtx->try_lock_shared_until(_Abs_time);
+        return _Owns;
+    }
+
+    void unlock() { // try to unlock the mutex
+        if (!_Pmtx || !_Owns) {
+            _Throw_system_error(errc::operation_not_permitted);
+        }
+
+        _Pmtx->unlock_shared();
+        _Owns = false;
+    }
+
+    void swap(shared_lock& _Right) noexcept {
+        _STD swap(_Pmtx, _Right._Pmtx);
+        _STD swap(_Owns, _Right._Owns);
+    }
+
+    mutex_type* release() noexcept {
+        _Mutex* _Res = _Pmtx;
+        _Pmtx        = nullptr;
+        _Owns        = false;
+        return _Res;
+    }
+
+    _NODISCARD bool owns_lock() const noexcept {
+        return _Owns;
+    }
+
+    explicit operator bool() const noexcept {
+        return _Owns;
+    }
+
+    _NODISCARD mutex_type* mutex() const noexcept {
+        return _Pmtx;
+    }
+
+private:
+    _Mutex* _Pmtx = nullptr;
+    bool _Owns    = false;
+
+    void _Validate() const { // check if the mutex can be locked
+        if (!_Pmtx) {
+            _Throw_system_error(errc::operation_not_permitted);
+        }
+
+        if (_Owns) {
+            _Throw_system_error(errc::resource_deadlock_would_occur);
+        }
+    }
+};
+
+_EXPORT_STD template <class _Mutex>
+void swap(shared_lock<_Mutex>& _Left, shared_lock<_Mutex>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SHARED_MUTEX_
diff --git a/msvc-stl/stl/inc/source_location b/msvc-stl/stl/inc/source_location
new file mode 100644
index 0000000..f2c287b
--- /dev/null
+++ b/msvc-stl/stl/inc/source_location
@@ -0,0 +1,74 @@
+// source_location standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SOURCE_LOCATION_
+#define _SOURCE_LOCATION_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <source_location> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+
+#include <cstdint>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#ifndef _USE_DETAILED_FUNCTION_NAME_IN_SOURCE_LOCATION
+#define _USE_DETAILED_FUNCTION_NAME_IN_SOURCE_LOCATION 1
+#endif // ^^^ !defined(_USE_DETAILED_FUNCTION_NAME_IN_SOURCE_LOCATION) ^^^
+
+_STD_BEGIN
+_EXPORT_STD struct source_location {
+    _NODISCARD static consteval source_location current(const uint_least32_t _Line_ = __builtin_LINE(),
+        const uint_least32_t _Column_ = __builtin_COLUMN(), const char* const _File_ = __builtin_FILE(),
+#if _USE_DETAILED_FUNCTION_NAME_IN_SOURCE_LOCATION
+        const char* const _Function_ = __builtin_FUNCSIG()
+#else // ^^^ detailed / basic vvv
+        const char* const _Function_ = __builtin_FUNCTION()
+#endif // ^^^ basic ^^^
+            ) noexcept {
+        source_location _Result{};
+        _Result._Line     = _Line_;
+        _Result._Column   = _Column_;
+        _Result._File     = _File_;
+        _Result._Function = _Function_;
+        return _Result;
+    }
+
+    _NODISCARD constexpr source_location() noexcept = default;
+
+    _NODISCARD constexpr uint_least32_t line() const noexcept {
+        return _Line;
+    }
+    _NODISCARD constexpr uint_least32_t column() const noexcept {
+        return _Column;
+    }
+    _NODISCARD constexpr const char* file_name() const noexcept {
+        return _File;
+    }
+    _NODISCARD constexpr const char* function_name() const noexcept {
+        return _Function;
+    }
+
+private:
+    uint_least32_t _Line{};
+    uint_least32_t _Column{};
+    const char* _File     = "";
+    const char* _Function = "";
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SOURCE_LOCATION_
diff --git a/msvc-stl/stl/inc/span b/msvc-stl/stl/inc/span
new file mode 100644
index 0000000..97fe331
--- /dev/null
+++ b/msvc-stl/stl/inc/span
@@ -0,0 +1,583 @@
+// span standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SPAN_
+#define _SPAN_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <span> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+#include <compare>
+#include <cstddef>
+#include <type_traits>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_EXPORT_STD inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
+
+template <class _Ty>
+struct _Span_iterator {
+    using iterator_concept  = contiguous_iterator_tag;
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = remove_cv_t<_Ty>;
+    using difference_type   = ptrdiff_t;
+    using pointer           = _Ty*;
+    using reference         = _Ty&;
+
+    _NODISCARD constexpr reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mybegin, "cannot dereference value-initialized span iterator");
+        _STL_VERIFY(_Myptr < _Myend, "cannot dereference end span iterator");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        return *_Myptr;
+    }
+
+    _NODISCARD constexpr pointer operator->() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mybegin, "cannot dereference value-initialized span iterator");
+        _STL_VERIFY(_Myptr < _Myend, "cannot dereference end span iterator");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        return _Myptr;
+    }
+
+    constexpr _Span_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mybegin, "cannot increment value-initialized span iterator");
+        _STL_VERIFY(_Myptr < _Myend, "cannot increment span iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        ++_Myptr;
+        return *this;
+    }
+
+    constexpr _Span_iterator operator++(int) noexcept {
+        _Span_iterator _Tmp{*this};
+        ++*this;
+        return _Tmp;
+    }
+
+    constexpr _Span_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mybegin, "cannot decrement value-initialized span iterator");
+        _STL_VERIFY(_Mybegin < _Myptr, "cannot decrement span iterator before begin");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        --_Myptr;
+        return *this;
+    }
+
+    constexpr _Span_iterator operator--(int) noexcept {
+        _Span_iterator _Tmp{*this};
+        --*this;
+        return _Tmp;
+    }
+
+    constexpr void _Verify_offset([[maybe_unused]] const difference_type _Off) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Off != 0) {
+            _STL_VERIFY(_Mybegin, "cannot seek value-initialized span iterator");
+        }
+
+        if (_Off < 0) {
+            _STL_VERIFY(_Myptr - _Mybegin >= -_Off, "cannot seek span iterator before begin");
+        }
+
+        if (_Off > 0) {
+            _STL_VERIFY(_Myend - _Myptr >= _Off, "cannot seek span iterator after end");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+    }
+
+    constexpr _Span_iterator& operator+=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        _Myptr += _Off;
+        return *this;
+    }
+
+    _NODISCARD constexpr _Span_iterator operator+(const difference_type _Off) const noexcept {
+        _Span_iterator _Tmp{*this};
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend constexpr _Span_iterator operator+(const difference_type _Off, _Span_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    constexpr _Span_iterator& operator-=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Off != _Min_possible_v<difference_type>, "integer overflow");
+        _Verify_offset(-_Off);
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        _Myptr -= _Off;
+        return *this;
+    }
+
+    _NODISCARD constexpr _Span_iterator operator-(const difference_type _Off) const noexcept {
+        _Span_iterator _Tmp{*this};
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD constexpr difference_type operator-(const _Span_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(
+            _Mybegin == _Right._Mybegin && _Myend == _Right._Myend, "cannot subtract incompatible span iterators");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        return _Myptr - _Right._Myptr;
+    }
+
+    _NODISCARD constexpr reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD constexpr bool operator==(const _Span_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Mybegin == _Right._Mybegin && _Myend == _Right._Myend,
+            "cannot compare incompatible span iterators for equality");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        return _Myptr == _Right._Myptr;
+    }
+
+    _NODISCARD constexpr strong_ordering operator<=>(const _Span_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(
+            _Mybegin == _Right._Mybegin && _Myend == _Right._Myend, "cannot compare incompatible span iterators");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        return _Myptr <=> _Right._Myptr;
+    }
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+    friend constexpr void _Verify_range(const _Span_iterator& _First, const _Span_iterator& _Last) noexcept {
+        _STL_VERIFY(_First._Mybegin == _Last._Mybegin && _First._Myend == _Last._Myend,
+            "span iterators from different views do not form a range");
+        _STL_VERIFY(_First._Myptr <= _Last._Myptr, "span iterator range transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+    using _Prevent_inheriting_unwrap = _Span_iterator;
+
+    _NODISCARD constexpr pointer _Unwrapped() const noexcept {
+        return _Myptr;
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _ITERATOR_DEBUG_LEVEL == 0;
+
+    constexpr void _Seek_to(const pointer _It) noexcept {
+        _Myptr = _It;
+    }
+
+    pointer _Myptr = nullptr;
+#if _ITERATOR_DEBUG_LEVEL >= 1
+    pointer _Mybegin = nullptr;
+    pointer _Myend   = nullptr;
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+};
+
+template <class _Ty>
+struct pointer_traits<_Span_iterator<_Ty>> {
+    using pointer         = _Span_iterator<_Ty>;
+    using element_type    = _Ty;
+    using difference_type = ptrdiff_t;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+        return _Iter._Unwrapped();
+    }
+};
+
+template <class _Ty, size_t _Extent>
+struct _Span_extent_type {
+    using pointer = _Ty*;
+
+    constexpr _Span_extent_type() noexcept = default;
+
+    constexpr explicit _Span_extent_type(const pointer _Data, size_t) noexcept : _Mydata{_Data} {
+        // Verify that later calls to size_bytes() won't overflow:
+        static_assert(
+            _Mysize <= dynamic_extent / sizeof(_Ty), "size of span in bytes exceeds numeric_limits<size_t>::max()");
+    }
+
+    pointer _Mydata{nullptr};
+    static constexpr size_t _Mysize = _Extent;
+};
+
+template <class _Ty>
+struct _Span_extent_type<_Ty, dynamic_extent> {
+    using pointer = _Ty*;
+
+    constexpr _Span_extent_type() noexcept = default;
+
+    constexpr explicit _Span_extent_type(const pointer _Data, const size_t _Size) noexcept
+        : _Mydata{_Data}, _Mysize{_Size} {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        // Verify that later calls to size_bytes() won't overflow:
+        _STL_VERIFY(
+            _Mysize <= dynamic_extent / sizeof(_Ty), "size of span in bytes exceeds numeric_limits<size_t>::max()");
+#endif
+    }
+
+    pointer _Mydata{nullptr};
+    size_t _Mysize{0};
+};
+
+_EXPORT_STD template <class _Ty, size_t _Extent>
+class span;
+
+namespace ranges {
+    template <class _Ty, size_t _Extent>
+    constexpr bool enable_view<span<_Ty, _Extent>> = true;
+    template <class _Ty, size_t _Extent>
+    constexpr bool enable_borrowed_range<span<_Ty, _Extent>> = true;
+} // namespace ranges
+
+template <class>
+constexpr bool _Is_span_v = false;
+
+template <class _Ty, size_t _Extent>
+constexpr bool _Is_span_v<span<_Ty, _Extent>> = true;
+
+template <class>
+constexpr bool _Is_std_array_v = false;
+
+template <class _Ty, size_t _Size>
+constexpr bool _Is_std_array_v<array<_Ty, _Size>> = true;
+
+template <class _It, class _Ty>
+concept _Span_compatible_iterator =
+    contiguous_iterator<_It> && is_convertible_v<remove_reference_t<iter_reference_t<_It>> (*)[], _Ty (*)[]>;
+
+template <class _Sentinel, class _It>
+concept _Span_compatible_sentinel = sized_sentinel_for<_Sentinel, _It> && !is_convertible_v<_Sentinel, size_t>;
+
+template <class _Rng, class _Ty>
+concept _Span_compatible_range =
+    !is_array_v<remove_cvref_t<_Rng>> && !_Is_span_v<remove_cvref_t<_Rng>> && !_Is_std_array_v<remove_cvref_t<_Rng>>
+    && _RANGES contiguous_range<_Rng> && _RANGES sized_range<_Rng> && (_RANGES borrowed_range<_Rng> || is_const_v<_Ty>)
+    && is_convertible_v<remove_reference_t<_RANGES range_reference_t<_Rng>> (*)[], _Ty (*)[]>;
+
+// [views.span]
+_EXPORT_STD template <class _Ty, size_t _Extent = dynamic_extent>
+class span : private _Span_extent_type<_Ty, _Extent> {
+private:
+    using _Mybase = _Span_extent_type<_Ty, _Extent>;
+    using _Mybase::_Mydata;
+    using _Mybase::_Mysize;
+
+public:
+    using element_type     = _Ty;
+    using value_type       = remove_cv_t<_Ty>;
+    using size_type        = size_t;
+    using difference_type  = ptrdiff_t;
+    using pointer          = _Ty*;
+    using const_pointer    = const _Ty*;
+    using reference        = _Ty&;
+    using const_reference  = const _Ty&;
+    using iterator         = _Span_iterator<_Ty>;
+    using reverse_iterator = _STD reverse_iterator<iterator>;
+#if _HAS_CXX23
+    using const_iterator         = _STD const_iterator<iterator>;
+    using const_reverse_iterator = _STD const_iterator<reverse_iterator>;
+#endif // _HAS_CXX23
+
+    static constexpr size_type extent = _Extent;
+
+    // [span.cons] Constructors, copy, and assignment
+    constexpr span() noexcept
+        requires (_Extent == 0 || _Extent == dynamic_extent)
+    = default;
+
+    template <_Span_compatible_iterator<element_type> _It>
+    constexpr explicit(_Extent != dynamic_extent) span(_It _First, size_type _Count) noexcept // strengthened
+        : _Mybase(_STD to_address(_STD _Get_unwrapped_n(_First, _Count)), _Count) {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Extent != dynamic_extent) {
+            _STL_VERIFY(_Count == _Extent,
+                "Cannot construct span with static extent from range [first, first + count) as count != extent");
+        }
+#endif // _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <_Span_compatible_iterator<element_type> _It, _Span_compatible_sentinel<_It> _Sentinel>
+    constexpr explicit(_Extent != dynamic_extent) span(_It _First, _Sentinel _Last)
+        noexcept(noexcept(_Last - _First)) // strengthened
+        : _Mybase(_STD to_address(_First), static_cast<size_type>(_Last - _First)) {
+        _STD _Adl_verify_range(_First, _Last);
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Extent != dynamic_extent) {
+            _STL_VERIFY(_Last - _First == _Extent,
+                "Cannot construct span with static extent from range [first, last) as last - first != extent");
+        }
+#endif // _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <size_t _Size>
+        requires (_Extent == dynamic_extent || _Extent == _Size)
+    constexpr span(type_identity_t<element_type> (&_Arr)[_Size]) noexcept : _Mybase(_Arr, _Size) {}
+
+    template <class _OtherTy, size_t _Size>
+        requires (_Extent == dynamic_extent || _Extent == _Size) && is_convertible_v<_OtherTy (*)[], element_type (*)[]>
+    constexpr span(array<_OtherTy, _Size>& _Arr) noexcept : _Mybase(_Arr.data(), _Size) {}
+
+    template <class _OtherTy, size_t _Size>
+        requires (_Extent == dynamic_extent || _Extent == _Size)
+              && is_convertible_v<const _OtherTy (*)[], element_type (*)[]>
+    constexpr span(const array<_OtherTy, _Size>& _Arr) noexcept : _Mybase(_Arr.data(), _Size) {}
+
+    template <_Span_compatible_range<element_type> _Rng>
+    constexpr explicit(_Extent != dynamic_extent) span(_Rng&& _Range)
+        : _Mybase(_RANGES data(_Range), static_cast<size_type>(_RANGES size(_Range))) {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Extent != dynamic_extent) {
+            _STL_VERIFY(_RANGES size(_Range) == _Extent,
+                "Cannot construct span with static extent from range r as std::ranges::size(r) != extent");
+        }
+#endif // _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    template <class _OtherTy, size_t _OtherExtent>
+        requires (_Extent == dynamic_extent || _OtherExtent == dynamic_extent || _Extent == _OtherExtent)
+              && is_convertible_v<_OtherTy (*)[], element_type (*)[]>
+    constexpr explicit(_Extent != dynamic_extent && _OtherExtent == dynamic_extent)
+        span(const span<_OtherTy, _OtherExtent>& _Other) noexcept
+        : _Mybase(_Other.data(), _Other.size()) {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Extent != dynamic_extent) {
+            _STL_VERIFY(_Other.size() == _Extent,
+                "Cannot construct span with static extent from other span as other.size() != extent");
+        }
+#endif // _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    // [span.sub] Subviews
+    template <size_t _Count>
+    _NODISCARD constexpr auto first() const noexcept /* strengthened */ {
+        if constexpr (_Extent != dynamic_extent) {
+            static_assert(_Count <= _Extent, "Count out of range in span::first<Count>()");
+        }
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        else {
+            _STL_VERIFY(_Count <= _Mysize, "Count out of range in span::first<Count>()");
+        }
+#endif // _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+
+        return span<element_type, _Count>{_Mydata, _Count};
+    }
+
+    _NODISCARD constexpr auto first(const size_type _Count) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Count <= _Mysize, "Count out of range in span::first(count)");
+#endif
+
+        return span<element_type, dynamic_extent>{_Mydata, _Count};
+    }
+
+    template <size_t _Count>
+    _NODISCARD constexpr auto last() const noexcept /* strengthened */ {
+        if constexpr (_Extent != dynamic_extent) {
+            static_assert(_Count <= _Extent, "Count out of range in span::last<Count>()");
+        }
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        else {
+            _STL_VERIFY(_Count <= _Mysize, "Count out of range in span::last<Count>()");
+        }
+#endif // _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+
+        return span<element_type, _Count>{_Mydata + (_Mysize - _Count), _Count};
+    }
+
+    _NODISCARD constexpr auto last(const size_type _Count) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Count <= _Mysize, "Count out of range in span::last(count)");
+#endif
+
+        return span<element_type, dynamic_extent>{_Mydata + (_Mysize - _Count), _Count};
+    }
+
+    template <size_t _Offset, size_t _Count = dynamic_extent>
+    _NODISCARD constexpr auto subspan() const noexcept /* strengthened */ {
+        if constexpr (_Extent != dynamic_extent) {
+            static_assert(_Offset <= _Extent, "Offset out of range in span::subspan<Offset, Count>()");
+            static_assert(_Count == dynamic_extent || _Count <= _Extent - _Offset,
+                "Count out of range in span::subspan<Offset, Count>()");
+        }
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        else {
+            _STL_VERIFY(_Offset <= _Mysize, "Offset out of range in span::subspan<Offset, Count>()");
+
+            if constexpr (_Count != dynamic_extent) {
+                _STL_VERIFY(_Count <= _Mysize - _Offset, "Count out of range in span::subspan<Offset, Count>()");
+            }
+        }
+#endif // _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+
+        using _ReturnType = span<element_type,
+            _Count != dynamic_extent ? _Count : (_Extent != dynamic_extent ? _Extent - _Offset : dynamic_extent)>;
+        return _ReturnType{_Mydata + _Offset, _Count == dynamic_extent ? _Mysize - _Offset : _Count};
+    }
+
+    _NODISCARD constexpr auto subspan(const size_type _Offset, const size_type _Count = dynamic_extent) const noexcept
+    /* strengthened */ {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Offset <= _Mysize, "Offset out of range in span::subspan(offset, count)");
+        _STL_VERIFY(_Count == dynamic_extent || _Count <= _Mysize - _Offset,
+            "Count out of range in span::subspan(offset, count)");
+#endif // _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+
+        using _ReturnType = span<element_type, dynamic_extent>;
+        return _ReturnType{_Mydata + _Offset, _Count == dynamic_extent ? _Mysize - _Offset : _Count};
+    }
+
+    // [span.obs] Observers
+    _NODISCARD constexpr size_t size() const noexcept {
+        return _Mysize;
+    }
+
+    _NODISCARD constexpr size_type size_bytes() const noexcept {
+        // Under _ITERATOR_DEBUG_LEVEL != 0, span's constructors verify that this multiplication won't overflow.
+        return _Mysize * sizeof(element_type);
+    }
+
+    _NODISCARD constexpr bool empty() const noexcept {
+        return _Mysize == 0;
+    }
+
+    // [span.elem] Element access
+    _NODISCARD constexpr reference operator[](const size_type _Off) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off < _Mysize, "span subscript out of range");
+#endif
+
+        return _Mydata[_Off];
+    }
+
+    _NODISCARD constexpr reference front() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize > 0, "front() called on empty span");
+#endif
+
+        return _Mydata[0];
+    }
+
+    _NODISCARD constexpr reference back() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_SPAN || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize > 0, "back() called on empty span");
+#endif
+
+        return _Mydata[_Mysize - 1];
+    }
+
+    _NODISCARD constexpr pointer data() const noexcept {
+        return _Mydata;
+    }
+
+    // [span.iterators] Iterator support
+    _NODISCARD constexpr iterator begin() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        return {_Mydata, _Mydata, _Mydata + _Mysize};
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return {_Mydata};
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    _NODISCARD constexpr iterator end() const noexcept {
+        const auto _End = _Mydata + _Mysize;
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        return {_End, _Mydata, _End};
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        return {_End};
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+#if _HAS_CXX23
+    _NODISCARD constexpr const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD constexpr const_iterator cend() const noexcept {
+        return end();
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD constexpr reverse_iterator rbegin() const noexcept {
+        return reverse_iterator{end()};
+    }
+
+    _NODISCARD constexpr reverse_iterator rend() const noexcept {
+        return reverse_iterator{begin()};
+    }
+
+#if _HAS_CXX23
+    _NODISCARD constexpr const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD constexpr const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD constexpr pointer _Unchecked_begin() const noexcept {
+        return _Mydata;
+    }
+
+    _NODISCARD constexpr pointer _Unchecked_end() const noexcept {
+        return _Mydata + _Mysize;
+    }
+};
+
+template <class _Ty, size_t _Extent>
+span(_Ty (&)[_Extent]) -> span<_Ty, _Extent>;
+
+template <class _Ty, size_t _Size>
+span(array<_Ty, _Size>&) -> span<_Ty, _Size>;
+
+template <class _Ty, size_t _Size>
+span(const array<_Ty, _Size>&) -> span<const _Ty, _Size>;
+
+template <contiguous_iterator _It, class _End>
+span(_It, _End) -> span<remove_reference_t<iter_reference_t<_It>>>;
+
+template <_RANGES contiguous_range _Rng>
+span(_Rng&&) -> span<remove_reference_t<_RANGES range_reference_t<_Rng>>>;
+
+#ifdef __cpp_lib_byte
+// [span.objectrep] Views of object representation
+_EXPORT_STD template <class _Ty, size_t _Extent>
+    requires (!is_volatile_v<_Ty>)
+_NODISCARD auto as_bytes(span<_Ty, _Extent> _Sp) noexcept {
+    using _ReturnType = span<const byte, _Extent == dynamic_extent ? dynamic_extent : sizeof(_Ty) * _Extent>;
+    return _ReturnType{reinterpret_cast<const byte*>(_Sp.data()), _Sp.size_bytes()};
+}
+
+_EXPORT_STD template <class _Ty, size_t _Extent>
+    requires (!is_const_v<_Ty> && !is_volatile_v<_Ty>)
+_NODISCARD auto as_writable_bytes(span<_Ty, _Extent> _Sp) noexcept {
+    using _ReturnType = span<byte, _Extent == dynamic_extent ? dynamic_extent : sizeof(_Ty) * _Extent>;
+    return _ReturnType{reinterpret_cast<byte*>(_Sp.data()), _Sp.size_bytes()};
+}
+#endif // defined(__cpp_lib_byte)
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SPAN_
diff --git a/msvc-stl/stl/inc/spanstream b/msvc-stl/stl/inc/spanstream
new file mode 100644
index 0000000..bf189b0
--- /dev/null
+++ b/msvc-stl/stl/inc/spanstream
@@ -0,0 +1,401 @@
+// spanstream standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SPANSTREAM_
+#define _SPANSTREAM_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <spanstream> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+#include <__msvc_ostream.hpp>
+#include <concepts>
+#include <istream>
+#include <span>
+#include <streambuf>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+// In this file, _STD span is qualified to avoid ambiguity with span() member functions.
+// This qualification is consistently used even when it isn't strictly necessary.
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_spanbuf : public basic_streambuf<_Elem, _Traits> {
+private:
+    using _Mysb = basic_streambuf<_Elem, _Traits>;
+
+public:
+    using char_type   = _Elem;
+    using int_type    = _Traits::int_type;
+    using pos_type    = _Traits::pos_type;
+    using off_type    = _Traits::off_type;
+    using traits_type = _Traits;
+
+    // N4950 [spanbuf.cons], constructors
+    basic_spanbuf() = default;
+
+    explicit basic_spanbuf(ios_base::openmode _Which) : _Mysb(), _Mode(_Which) {}
+
+    explicit basic_spanbuf(_STD span<_Elem> _Span, ios_base::openmode _Which = ios_base::in | ios_base::out)
+        : _Mysb(), _Mode(_Which), _Buf() {
+        this->span(_Span);
+    }
+
+    basic_spanbuf(const basic_spanbuf&) = delete;
+    basic_spanbuf(basic_spanbuf&& _Right)
+        : _Mysb(_STD move(_Right)), _Mode(_Right._Mode), _Buf(_STD exchange(_Right._Buf, {})) {
+        _Right.setp(nullptr, nullptr, nullptr);
+        _Right.setg(nullptr, nullptr, nullptr);
+    }
+
+    // N4950 [spanbuf.assign], assignment and swap
+    basic_spanbuf& operator=(const basic_spanbuf&) = delete;
+
+    basic_spanbuf& operator=(basic_spanbuf&& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Buf = _STD span<_Elem>{};
+            this->setp(nullptr, nullptr, nullptr);
+            this->setg(nullptr, nullptr, nullptr);
+            this->swap(_Right);
+        }
+        return *this;
+    }
+
+    void swap(basic_spanbuf& _Right) noexcept /* strengthened */ {
+        _Mysb::swap(_Right);
+        _STD swap(_Mode, _Right._Mode);
+        _STD swap(_Buf, _Right._Buf);
+    }
+
+    // N4950 [spanbuf.members], member functions
+    _NODISCARD _STD span<_Elem> span() const noexcept {
+        if (_Mode & ios_base::out) {
+            return _STD span<_Elem>{_Mysb::pbase(), _Mysb::pptr()};
+        }
+
+        return _Buf;
+    }
+
+    void span(_STD span<_Elem> _Span) noexcept {
+        _Buf              = _Span;
+        const auto _First = _Buf.data();
+        const auto _Last  = _First + _Buf.size();
+        if (_Mode & ios_base::out) {
+            if (_Mode & ios_base::ate) {
+                _Mysb::setp(_First, _Last, _Last);
+            } else {
+                _Mysb::setp(_First, _First, _Last);
+            }
+        }
+
+        if (_Mode & ios_base::in) {
+            _Mysb::setg(_First, _First, _Last);
+        }
+    }
+
+protected:
+    // N4950 [spanbuf.virtuals], overridden virtual functions
+    pos_type seekoff(
+        off_type _Off, ios_base::seekdir _Way, ios_base::openmode _Which = ios_base::in | ios_base::out) override {
+        const bool _Sequence_in  = _Which & ios_base::in;
+        const bool _Sequence_out = _Which & ios_base::out;
+        switch (_Way) {
+        case ios_base::beg:
+            // N4950 [spanbuf.virtuals]/4.1 baseoff = 0
+            if (static_cast<size_t>(_Off) > _Buf.size()) { // negative wraparound to positive to save a compare
+                return pos_type{off_type{-1}}; // N4950 [spanbuf.virtuals]/5 report failure
+            }
+
+            break;
+        case ios_base::end:
+            {
+                // N4950 [spanbuf.virtuals]/4.3 baseoff =
+                const auto _Baseoff = (_Mode & ios_base::out) && !(_Mode & ios_base::in)
+                                        ? static_cast<off_type>(_Mysb::pptr() - _Mysb::pbase())
+                                        : static_cast<off_type>(_Buf.size());
+                if (_Off > _STD _Max_limit<off_type>() - _Baseoff) { // overflow, _Baseoff is always non-negative
+                    return pos_type{off_type{-1}}; // report failure
+                }
+
+                _Off += _Baseoff;
+                if (static_cast<size_t>(_Off) > _Buf.size()) { // negative wraparound to positive to save a compare
+                    return pos_type{off_type{-1}}; // N4950 [spanbuf.virtuals]/5 report failure
+                }
+
+                break;
+            }
+        case ios_base::cur:
+            if (_Sequence_in && _Sequence_out) {
+                return pos_type{off_type{-1}}; // report failure
+            } else if (_Sequence_in || _Sequence_out) {
+                const off_type _Oldoff  = _Sequence_in ? static_cast<off_type>(_Mysb::gptr() - _Mysb::eback())
+                                                       : static_cast<off_type>(_Mysb::pptr() - _Mysb::pbase());
+                const off_type _Oldleft = static_cast<off_type>(_Buf.size() - _Oldoff);
+                if (_Off < -_Oldoff || _Off > _Oldleft) { // out of bounds
+                    return pos_type{off_type{-1}};
+                }
+
+                _Off += _Oldoff;
+            } else {
+                return pos_type{off_type{-1}}; // report failure
+            }
+            break;
+        default:
+            return pos_type{off_type{-1}}; // report failure
+        }
+
+        // N4950 [spanbuf.virtuals]/4: For a sequence to be positioned, if its next pointer is a null pointer and newoff
+        // is not equal to 0, the positioning operation fails.
+        if (_Off != 0 && ((_Sequence_in && !_Mysb::gptr()) || (_Sequence_out && !_Mysb::pptr()))) {
+            return pos_type{off_type{-1}}; // report failure
+        }
+
+        if (_Sequence_in) {
+            _Mysb::gbump(static_cast<int>(_Off - (_Mysb::gptr() - _Mysb::eback())));
+        }
+
+        if (_Sequence_out) {
+            _Mysb::pbump(static_cast<int>(_Off - (_Mysb::pptr() - _Mysb::pbase())));
+        }
+
+        return pos_type{_Off};
+    }
+
+    pos_type seekpos(pos_type _Pos, ios_base::openmode _Which = ios_base::in | ios_base::out) override {
+        return seekoff(off_type{_Pos}, ios_base::beg, _Which);
+    }
+
+    _Mysb* setbuf(_Elem* _Buffer, streamsize _Count) override {
+        this->span(_STD span<_Elem>{_Buffer, static_cast<size_t>(_Count)});
+        return this;
+    }
+
+private:
+    ios_base::openmode _Mode{ios_base::in | ios_base::out};
+    _STD span<_Elem> _Buf{};
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_spanbuf<_Elem, _Traits>& _Left, basic_spanbuf<_Elem, _Traits>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+template <class _Elem, size_t _Extent>
+span<_Elem, _Extent> _As_nonconst_span(const span<const _Elem, _Extent> _Span) noexcept {
+    return span<_Elem, _Extent>{const_cast<_Elem*>(_Span.data()), _Span.size()};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_ispanstream : public basic_istream<_Elem, _Traits> {
+private:
+    using _Mybase = basic_istream<_Elem, _Traits>;
+    using _Mysb   = basic_spanbuf<_Elem, _Traits>;
+
+public:
+    using char_type   = _Elem;
+    using int_type    = _Traits::int_type;
+    using pos_type    = _Traits::pos_type;
+    using off_type    = _Traits::off_type;
+    using traits_type = _Traits;
+
+    // N4950 [ispanstream.cons], constructors
+    explicit basic_ispanstream(_STD span<_Elem> _Span, ios_base::openmode _Which = ios_base::in)
+        : _Mybase(_STD addressof(_Buf)), _Buf(_Span, _Which | ios_base::in) {}
+
+    basic_ispanstream(const basic_ispanstream&) = delete;
+
+    basic_ispanstream(basic_ispanstream&& _Right) : _Mybase(_STD move(_Right)), _Buf(_STD move(_Right._Buf)) {
+        _Mybase::set_rdbuf(_STD addressof(_Buf));
+    }
+
+    template <_RANGES borrowed_range _ReadOnlyRange>
+        requires (
+            !convertible_to<_ReadOnlyRange, _STD span<_Elem>> && convertible_to<_ReadOnlyRange, _STD span<const _Elem>>)
+    explicit basic_ispanstream(_ReadOnlyRange&& _Range)
+        : basic_ispanstream(
+              _STD _As_nonconst_span(static_cast<_STD span<const _Elem>>(_STD forward<_ReadOnlyRange>(_Range)))) {}
+
+    basic_ispanstream& operator=(const basic_ispanstream&) = delete;
+
+    basic_ispanstream& operator=(basic_ispanstream&& _Right) noexcept /* strengthened */ {
+        _Mybase::swap(_Right);
+        _Buf.swap(_Right._Buf);
+        return *this;
+    }
+
+    // N4950 [ispanstream.swap], swap
+    void swap(basic_ispanstream& _Right) noexcept /* strengthened */ {
+        _Mybase::swap(_Right);
+        _Buf.swap(_Right._Buf);
+    }
+
+    // N4950 [ispanstream.members], member functions
+    _NODISCARD _Mysb* rdbuf() const noexcept {
+        return const_cast<_Mysb*>(_STD addressof(_Buf));
+    }
+
+    _NODISCARD _STD span<const _Elem> span() const noexcept {
+        return rdbuf()->span();
+    }
+
+    void span(_STD span<_Elem> _Span) noexcept {
+        rdbuf()->span(_Span);
+    }
+
+    template <_RANGES borrowed_range _ReadOnlyRange>
+        requires (
+            !convertible_to<_ReadOnlyRange, _STD span<_Elem>> && convertible_to<_ReadOnlyRange, _STD span<const _Elem>>)
+    void span(_ReadOnlyRange&& _Range) noexcept {
+        const auto _Sp = static_cast<_STD span<const _Elem>>(_STD forward<_ReadOnlyRange>(_Range));
+        rdbuf()->span(_STD _As_nonconst_span(_Sp));
+    }
+
+private:
+    _Mysb _Buf;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_ispanstream<_Elem, _Traits>& _Left, basic_ispanstream<_Elem, _Traits>& _Right) noexcept
+/* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_ospanstream : public basic_ostream<_Elem, _Traits> {
+private:
+    using _Mybase = basic_ostream<_Elem, _Traits>;
+    using _Mysb   = basic_spanbuf<_Elem, _Traits>;
+
+public:
+    using char_type   = _Elem;
+    using int_type    = _Traits::int_type;
+    using pos_type    = _Traits::pos_type;
+    using off_type    = _Traits::off_type;
+    using traits_type = _Traits;
+
+    // N4950 [ospanstream.cons], constructors
+    explicit basic_ospanstream(_STD span<_Elem> _Span, ios_base::openmode _Which = ios_base::out)
+        : _Mybase(_STD addressof(_Buf)), _Buf(_Span, _Which | ios_base::out) {}
+
+    basic_ospanstream(const basic_ospanstream&) = delete;
+
+    basic_ospanstream(basic_ospanstream&& _Right) : _Mybase(_STD move(_Right)), _Buf(_STD move(_Right._Buf)) {
+        _Mybase::set_rdbuf(_STD addressof(_Buf));
+    }
+
+    basic_ospanstream& operator=(const basic_ospanstream&) = delete;
+
+    basic_ospanstream& operator=(basic_ospanstream&& _Right) noexcept /* strengthened */ {
+        _Mybase::swap(_Right);
+        _Buf.swap(_Right._Buf);
+        return *this;
+    }
+
+    // N4950 [ospanstream.swap], swap
+    void swap(basic_ospanstream& _Right) noexcept /* strengthened */ {
+        _Mybase::swap(_Right);
+        _Buf.swap(_Right._Buf);
+    }
+
+    // N4950 [ospanstream.members], member functions
+    _NODISCARD _Mysb* rdbuf() const noexcept {
+        return const_cast<_Mysb*>(_STD addressof(_Buf));
+    }
+
+    _NODISCARD _STD span<_Elem> span() const noexcept {
+        return rdbuf()->span();
+    }
+
+    void span(_STD span<_Elem> _Span) noexcept {
+        rdbuf()->span(_Span);
+    }
+
+private:
+    _Mysb _Buf;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_ospanstream<_Elem, _Traits>& _Left, basic_ospanstream<_Elem, _Traits>& _Right) noexcept
+/* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits>
+class basic_spanstream : public basic_iostream<_Elem, _Traits> {
+private:
+    using _Mybase = basic_iostream<_Elem, _Traits>;
+    using _Mysb   = basic_spanbuf<_Elem, _Traits>;
+
+public:
+    using char_type   = _Elem;
+    using int_type    = _Traits::int_type;
+    using pos_type    = _Traits::pos_type;
+    using off_type    = _Traits::off_type;
+    using traits_type = _Traits;
+
+    // N4950 [spanstream.cons], constructors
+    explicit basic_spanstream(_STD span<_Elem> _Span, ios_base::openmode _Which = ios_base::out | ios_base::in)
+        : _Mybase(_STD addressof(_Buf)), _Buf(_Span, _Which) {}
+
+    basic_spanstream(const basic_spanstream&) = delete;
+
+    basic_spanstream(basic_spanstream&& _Right) : _Mybase(_STD move(_Right)), _Buf(_STD move(_Right._Buf)) {
+        _Mybase::set_rdbuf(_STD addressof(_Buf));
+    }
+
+    basic_spanstream& operator=(const basic_spanstream&) = delete;
+
+    basic_spanstream& operator=(basic_spanstream&& _Right) noexcept /* strengthened */ {
+        _Mybase::swap(_Right);
+        _Buf.swap(_Right._Buf);
+        return *this;
+    }
+
+    // N4950 [spanstream.swap], swap
+    void swap(basic_spanstream& _Right) noexcept /* strengthened */ {
+        _Mybase::swap(_Right);
+        _Buf.swap(_Right._Buf);
+    }
+
+    // N4950 [spanstream.members], member functions
+    _NODISCARD _Mysb* rdbuf() const noexcept {
+        return const_cast<_Mysb*>(_STD addressof(_Buf));
+    }
+
+    _NODISCARD _STD span<_Elem> span() const noexcept {
+        return rdbuf()->span();
+    }
+
+    void span(_STD span<_Elem> _Span) noexcept {
+        rdbuf()->span(_Span);
+    }
+
+private:
+    _Mysb _Buf;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits>
+void swap(basic_spanstream<_Elem, _Traits>& _Left, basic_spanstream<_Elem, _Traits>& _Right) noexcept
+/* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX23 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SPANSTREAM_
diff --git a/msvc-stl/stl/inc/sstream b/msvc-stl/stl/inc/sstream
new file mode 100644
index 0000000..ae2d25d
--- /dev/null
+++ b/msvc-stl/stl/inc/sstream
@@ -0,0 +1,979 @@
+// sstream standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SSTREAM_
+#define _SSTREAM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <istream>
+#include <string>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+_STD_BEGIN
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+class basic_stringbuf
+    : public basic_streambuf<_Elem, _Traits> { // stream buffer maintaining an allocated character array
+public:
+    using allocator_type = _Alloc;
+    using _Mysb          = basic_streambuf<_Elem, _Traits>;
+    using _Mystr         = basic_string<_Elem, _Traits, _Alloc>;
+    using _Mysize_type   = typename _Mystr::size_type;
+
+#if _HAS_CXX20
+    using _Mystr_view = basic_string_view<_Elem, _Traits>;
+#endif // _HAS_CXX20
+
+    basic_stringbuf() : _Seekhigh(nullptr), _Mystate(_Getstate(ios_base::in | ios_base::out)), _Al() {}
+
+    explicit basic_stringbuf(ios_base::openmode _Mode) : _Seekhigh(nullptr), _Mystate(_Getstate(_Mode)), _Al() {}
+
+    explicit basic_stringbuf(const _Mystr& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
+        : _Al(_Str.get_allocator()) {
+        _Init(_Str.c_str(), _Str.size(), _Getstate(_Mode));
+    }
+
+#if _HAS_CXX20
+    explicit basic_stringbuf(const _Alloc& _Al_) : basic_stringbuf(ios_base::in | ios_base::out, _Al_) {}
+
+    basic_stringbuf(ios_base::openmode _Mode, const _Alloc& _Al_)
+        : _Seekhigh(nullptr), _Mystate(_Getstate(_Mode)), _Al(_Al_) {}
+
+    explicit basic_stringbuf(_Mystr&& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
+        : _Al(_STD move(_Str._Getal())) {
+        _Init_string_inplace(_STD move(_Str), _Getstate(_Mode));
+    }
+
+    template <class _Alloc2>
+    basic_stringbuf(const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode, const _Alloc& _Al_)
+        : _Al(_Al_) {
+        _Init(_Str.c_str(), _Convert_size<_Mysize_type>(_Str.size()), _Getstate(_Mode));
+    }
+
+    template <class _Alloc2>
+    basic_stringbuf(const basic_string<_Elem, _Traits, _Alloc2>& _Str, const _Alloc& _Al_)
+        : basic_stringbuf(_Str, ios_base::in | ios_base::out, _Al_) {}
+
+    template <class _Alloc2>
+        requires (!is_same_v<_Alloc2, _Alloc>)
+    explicit basic_stringbuf(
+        const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
+        : basic_stringbuf(_Str, _Mode, _Alloc{}) {}
+
+    basic_stringbuf(basic_stringbuf&& _Right, const _Alloc& _Al_) : _Seekhigh(nullptr), _Mystate(0), _Al(_Al_) {
+        if constexpr (!allocator_traits<_Alloc>::is_always_equal::value) {
+            if (_Al != _Right._Al) {
+                _Copy_into_self_and_tidy(_STD move(_Right));
+                return;
+            }
+        }
+
+        _Take_contents(_STD move(_Right));
+    }
+#endif // _HAS_CXX20
+
+    basic_stringbuf(basic_stringbuf&& _Right)
+        : _Seekhigh(_STD exchange(_Right._Seekhigh, nullptr)), _Mystate(_STD exchange(_Right._Mystate, 0)),
+          _Al(_Right._Al) {
+        _Mysb::swap(_Right);
+    }
+
+    basic_stringbuf& operator=(basic_stringbuf&& _Right)
+        noexcept(_Choose_pocma_v<_Alloc> != _Pocma_values::_No_propagate_allocators) /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Assign_rv_no_alias(_STD move(_Right));
+        }
+        return *this;
+    }
+
+    void _Take_contents(basic_stringbuf&& _Right) noexcept {
+        // pre: *this holds no dynamic buffer and _Al == _Right._Al
+        _Seekhigh = _STD exchange(_Right._Seekhigh, nullptr);
+        _Mystate  = _STD exchange(_Right._Mystate, 0);
+        _Mysb::swap(_Right);
+    }
+
+    void _Copy_into_self_and_tidy(basic_stringbuf&& _Right) {
+        // pre: *this holds no dynamic buffer and _Al != _Right._Al
+        if ((_Right._Mystate & _Allocated) == 0) {
+            return;
+        }
+
+        const auto _Right_data     = _Right._Mysb::eback();
+        const auto _Right_capacity = static_cast<typename allocator_traits<_Alloc>::size_type>(
+            (_Right._Mysb::pptr() ? _Right._Mysb::epptr() : _Right._Mysb::egptr()) - _Right_data);
+
+        auto _New_capacity   = _Right_capacity;
+        const auto _New_data = _STD _Unfancy(_STD _Allocate_at_least_helper(_Al, _New_capacity));
+
+        _Mysb::setg(_New_data, _New_data + (_Right._Mysb::gptr() - _Right_data),
+            _New_data + (_Right._Mysb::egptr() - _Right_data));
+        if (_Right._Mysb::pbase() != nullptr) {
+            const auto _Pbase_diff = _Right._Mysb::pbase() - _Right_data;
+            const auto _Pptr_diff  = _Right._Mysb::pptr() - _Right_data;
+            const auto _Epptr_diff = _Right._Mysb::epptr() - _Right_data;
+            _Mysb::setp(_New_data + _Pbase_diff, _New_data + _Pptr_diff, _New_data + _Epptr_diff);
+        } else {
+            _Mysb::setp(nullptr, nullptr, nullptr);
+        }
+
+        const auto _Right_view = _Right._Get_buffer_view();
+        if (_Right_view._Ptr != nullptr) {
+            _Traits::copy(_New_data + (_Right_view._Ptr - _Right_data), _Right_view._Ptr, _Right_view._Size);
+        }
+
+        _Seekhigh = _New_data + _New_capacity;
+        _Mystate  = _Right._Mystate;
+
+        _Right._Tidy();
+    }
+
+    void _Assign_rv_no_alias(basic_stringbuf&& _Right)
+        noexcept(_Choose_pocma_v<_Alloc> != _Pocma_values::_No_propagate_allocators) {
+        // pre: this != std::addressof(_Right)
+        _Tidy();
+        if constexpr (_Choose_pocma_v<_Alloc> == _Pocma_values::_No_propagate_allocators) {
+            if (_Al == _Right._Al) {
+                _Take_contents(_STD move(_Right));
+            } else {
+                _Copy_into_self_and_tidy(_STD move(_Right));
+            }
+        } else {
+            _Pocma(_Al, _Right._Al);
+            _Take_contents(_STD move(_Right));
+        }
+    }
+
+    void swap(basic_stringbuf& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            if constexpr (!allocator_traits<_Alloc>::propagate_on_container_swap::value) {
+                _STL_ASSERT(
+                    _Al == _Right._Al, "The allocators of basic_stringbuf should propagate or be equal on swap.");
+            }
+
+            _Mysb::swap(_Right);
+            _STD swap(_Seekhigh, _Right._Seekhigh);
+            _STD swap(_Mystate, _Right._Mystate);
+            // The same as basic_string::swap
+            _Pocs(_Al, _Right._Al);
+        }
+    }
+
+    basic_stringbuf(const basic_stringbuf&)            = delete;
+    basic_stringbuf& operator=(const basic_stringbuf&) = delete;
+
+    ~basic_stringbuf() noexcept override {
+        _Tidy();
+    }
+
+    enum { // constants for bits in stream state
+        _Allocated   = 1, // set if character array storage has been allocated, eback() points to allocated storage
+        _Constant    = 2, // set if character array nonmutable
+        _Noread      = 4, // set if character array cannot be read
+        _Append      = 8, // set if all writes are appends
+        _Atend       = 16, // set if initial writes are appends
+        _From_rvalue = 32 // set if character array is released from an rvalue of basic_string
+    };
+
+    using int_type = typename _Traits::int_type;
+    using pos_type = typename _Traits::pos_type;
+    using off_type = typename _Traits::off_type;
+
+    struct _Buffer_view {
+        _Elem* _Ptr;
+        _Mysize_type _Size;
+        _Mysize_type _Res;
+    };
+
+    _NODISCARD _Buffer_view _Get_buffer_view() const noexcept {
+        _Buffer_view _Result{};
+        if ((!(_Mystate & _Constant) || (_Mystate & _From_rvalue)) && _Mysb::pptr()) {
+            // writable, make string view from write buffer
+            const auto _Base = _Mysb::pbase();
+            _Result._Ptr     = _Base;
+            _Result._Size    = static_cast<_Mysize_type>((_STD max) (_Mysb::pptr(), _Seekhigh) - _Base);
+            _Result._Res     = static_cast<_Mysize_type>(_Mysb::epptr() - _Base);
+        } else if (!(_Mystate & _Noread) && _Mysb::gptr()) {
+            // readable, make string view from read buffer
+            const auto _Base = _Mysb::eback();
+            _Result._Ptr     = _Base;
+            _Result._Size    = static_cast<_Mysize_type>(_Mysb::egptr() - _Base);
+            _Result._Res     = _Result._Size;
+        }
+        return _Result;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD _Mystr str() const&
+#else
+    _NODISCARD _Mystr str() const
+#endif
+    {
+        _Mystr _Result(_Al);
+        const auto _View = _Get_buffer_view();
+        if (_View._Ptr) {
+            _Result.assign(_View._Ptr, _View._Size);
+        }
+        return _Result;
+    }
+
+    void str(const _Mystr& _Newstr) { // replace character array from string
+        _Tidy();
+        _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
+    }
+
+#if _HAS_CXX20
+    template <_Allocator_for_container _Alloc2>
+    _NODISCARD basic_string<_Elem, _Traits, _Alloc2> str(const _Alloc2& _Al) const {
+        return basic_string<_Elem, _Traits, _Alloc2>{view(), _Al};
+    }
+
+    // The buffer cannot be moved to a string directly, because
+    // the buffer may already be full, and the terminating char is not '\0'.
+    // In that case, copy the string as usual.
+    _NODISCARD _Mystr str() && {
+        _Mystr _Result{_Al};
+        const auto _View = _Get_buffer_view();
+        // _Size cannot be larger than _Res, but it could be equal,
+        // because basic_stringbuf doesn't allocate for the terminating '\0'.
+        if (_View._Size == _View._Res) {
+            // the buffer is full
+            _Result.assign(_View._Ptr, _View._Size);
+        } else {
+            if (_Result._Move_assign_from_buffer(_View._Ptr, _View._Size, _View._Res)) {
+                _Mystate &= ~_Allocated;
+            }
+        }
+
+        _Tidy();
+        return _Result;
+    }
+
+    _NODISCARD _Mystr_view view() const noexcept {
+        const auto _View = _Get_buffer_view();
+        return _Mystr_view{_View._Ptr, _View._Size};
+    }
+
+    template <class _Alloc2>
+        requires (!is_same_v<_Alloc2, _Alloc>)
+    void str(const basic_string<_Elem, _Traits, _Alloc2>& _Newstr) {
+        _Tidy();
+        _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
+    }
+
+    void str(_Mystr&& _Newstr) {
+        auto& _Newstr_al          = _Newstr._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alloc>;
+        if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Newstr_al) {
+                _Tidy();
+                _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
+                return;
+            }
+        }
+
+        _Tidy();
+        _Pocma(_Al, _Newstr_al);
+        _Init_string_inplace(_STD move(_Newstr), _Mystate);
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return _Al;
+    }
+#endif // _HAS_CXX20
+
+protected:
+    int_type overflow(int_type _Meta = _Traits::eof()) override { // put an element to stream
+        if (_Mystate & _Constant) {
+            return _Traits::eof(); // array nonmutable, fail
+        }
+
+        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            return _Traits::not_eof(_Meta); // EOF, return success code
+        }
+
+        const auto _Pptr  = _Mysb::pptr();
+        const auto _Epptr = _Mysb::epptr();
+        if (_Pptr && _Pptr < _Epptr) { // room in buffer, store it
+            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
+            _Seekhigh        = _Pptr + 1;
+            return _Meta;
+        }
+
+        // grow buffer and store element
+        _Mysize_type _Oldsize = 0;
+        const auto _Oldptr    = _Mysb::eback();
+        if (_Pptr) {
+            _Oldsize = static_cast<_Mysize_type>(_Epptr - _Oldptr);
+        }
+
+        _Mysize_type _Newsize;
+        if (_Oldsize < _MINSIZE) {
+            _Newsize = _MINSIZE;
+        } else if (_Oldsize < INT_MAX / 2) { // grow by 50 percent
+            _Newsize = _Oldsize << 1;
+        } else if (_Oldsize < INT_MAX) {
+            _Newsize = INT_MAX;
+        } else { // buffer can't grow, fail
+            return _Traits::eof();
+        }
+
+        const auto _Newptr = _Unfancy(_Allocate_at_least_helper(_Al, _Newsize));
+        _Traits::copy(_Newptr, _Oldptr, _Oldsize);
+
+        const auto _New_pnext = _Newptr + _Oldsize;
+        _Seekhigh             = _New_pnext + 1; // to include _Meta
+
+        _Mysb::setp(_Newptr, _New_pnext, _Newptr + _Newsize);
+        if (_Mystate & _Noread) { // maintain eback() == allocated pointer invariant
+            _Mysb::setg(_Newptr, _Newptr, _Newptr);
+        } else { // if readable, set the get area to initialized region
+            _Mysb::setg(_Newptr, _Newptr + (_Mysb::gptr() - _Oldptr), _Seekhigh);
+        }
+
+        if (_Mystate & _Allocated) {
+            _Al.deallocate(_Ptr_traits::pointer_to(*_Oldptr), _Oldsize);
+        }
+
+        _Mystate |= _Allocated;
+        *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
+        return _Meta;
+    }
+
+    int_type pbackfail(int_type _Meta = _Traits::eof()) override { // put an element back to stream
+        const auto _Gptr = _Mysb::gptr();
+        if (!_Gptr || _Gptr <= _Mysb::eback()
+            || (!_Traits::eq_int_type(_Traits::eof(), _Meta) && !_Traits::eq(_Traits::to_char_type(_Meta), _Gptr[-1])
+                && (_Mystate & _Constant))) { // can't put back, fail
+            return _Traits::eof();
+        }
+
+        // back up one position and store put-back character
+        _Mysb::gbump(-1);
+        if (!_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            *_Mysb::gptr() = _Traits::to_char_type(_Meta);
+        }
+
+        return _Traits::not_eof(_Meta);
+    }
+
+    int_type underflow() override { // get an element from stream, but don't point past it
+        const auto _Gptr = _Mysb::gptr();
+        if (!_Gptr) { // no character buffer, fail
+            return _Traits::eof();
+        }
+
+        if (_Gptr < _Mysb::egptr()) {
+            return _Traits::to_int_type(*_Gptr);
+        }
+
+        // try to add initialized characters from the put area into the get area
+        const auto _Pptr = _Mysb::pptr();
+        if (!_Pptr || (_Mystate & _Noread)) { // no put area or read disallowed
+            return _Traits::eof();
+        }
+
+        const auto _Local_highwater = (_STD max) (_Seekhigh, _Pptr);
+        if (_Local_highwater <= _Gptr) { // nothing in the put area to take
+            return _Traits::eof();
+        }
+
+        _Seekhigh = _Local_highwater;
+        _Mysb::setg(_Mysb::eback(), _Mysb::gptr(), _Local_highwater);
+        return _Traits::to_int_type(*_Mysb::gptr());
+    }
+
+    pos_type seekoff(
+        off_type _Off, ios_base::seekdir _Way, ios_base::openmode _Mode = ios_base::in | ios_base::out) override {
+        const bool _Need_read_but_cannot  = (_Mode & ios_base::in) != 0 && (_Mystate & _Noread) != 0;
+        const bool _Need_write_but_cannot = (_Mode & ios_base::out) != 0 && (_Mystate & _Constant) != 0;
+        if (_Need_read_but_cannot || _Need_write_but_cannot) {
+            return pos_type{off_type{-1}};
+        }
+
+        // change position by _Off, according to _Way, _Mode
+        const auto _Gptr_old = _Mysb::gptr();
+        const auto _Pptr_old = (_Mystate & _Constant) ? nullptr : _Mysb::pptr();
+        if (_Pptr_old && _Seekhigh < _Pptr_old) { // update high-water pointer
+            _Seekhigh = _Pptr_old;
+        }
+
+        const auto _Seeklow  = _Mysb::eback();
+        const auto _Seekdist = _Seekhigh - _Seeklow;
+        off_type _Newoff;
+        switch (_Way) {
+        case ios_base::beg:
+            _Newoff = 0;
+            break;
+        case ios_base::end:
+            _Newoff = _Seekdist;
+            break;
+        case ios_base::cur:
+            {
+                constexpr auto _Both = ios_base::in | ios_base::out;
+                if ((_Mode & _Both) != _Both) { // prohibited by N4950 [tab:stringbuf.seekoff.pos]
+                    if (_Mode & ios_base::in) {
+                        if (_Gptr_old || !_Seeklow) {
+                            _Newoff = _Gptr_old - _Seeklow;
+                            break;
+                        }
+                    } else if ((_Mode & ios_base::out) && (_Pptr_old || !_Seeklow)) {
+                        _Newoff = _Pptr_old - _Seeklow;
+                        break;
+                    }
+                }
+            }
+
+            _FALLTHROUGH;
+        default:
+            return pos_type{off_type{-1}};
+        }
+
+        if (static_cast<unsigned long long>(_Off) + _Newoff > static_cast<unsigned long long>(_Seekdist)) {
+            return pos_type{off_type{-1}};
+        }
+
+        _Off += _Newoff;
+        if (_Off != 0 && (((_Mode & ios_base::in) && !_Gptr_old) || ((_Mode & ios_base::out) && !_Pptr_old))) {
+            return pos_type{off_type{-1}};
+        }
+
+        const auto _Newptr = _Seeklow + _Off; // may perform nullptr + 0
+        if ((_Mode & ios_base::in) && _Gptr_old) {
+            _Mysb::setg(_Seeklow, _Newptr, _Seekhigh);
+        }
+
+        if ((_Mode & ios_base::out) && _Pptr_old) {
+            _Mysb::setp(_Seeklow, _Newptr, _Mysb::epptr());
+        }
+
+        return pos_type{_Off};
+    }
+
+    pos_type seekpos(pos_type _Pos, ios_base::openmode _Mode = ios_base::in | ios_base::out) override {
+        const bool _Need_read_but_cannot  = (_Mode & ios_base::in) != 0 && (_Mystate & _Noread) != 0;
+        const bool _Need_write_but_cannot = (_Mode & ios_base::out) != 0 && (_Mystate & _Constant) != 0;
+        if (_Need_read_but_cannot || _Need_write_but_cannot) {
+            return pos_type{off_type{-1}};
+        }
+
+        // change position to _Pos, according to _Mode
+        const auto _Off      = static_cast<streamoff>(_Pos);
+        const auto _Gptr_old = _Mysb::gptr();
+        const auto _Pptr_old = (_Mystate & _Constant) ? nullptr : _Mysb::pptr();
+        if (_Pptr_old && _Seekhigh < _Pptr_old) { // update high-water pointer
+            _Seekhigh = _Pptr_old;
+        }
+
+        const auto _Seeklow  = _Mysb::eback();
+        const auto _Seekdist = _Seekhigh - _Seeklow;
+        if (static_cast<unsigned long long>(_Off) > static_cast<unsigned long long>(_Seekdist)) {
+            return pos_type{off_type{-1}};
+        }
+
+        if (_Off != 0 && (((_Mode & ios_base::in) && !_Gptr_old) || ((_Mode & ios_base::out) && !_Pptr_old))) {
+            return pos_type{off_type{-1}};
+        }
+
+        const auto _Newptr = _Seeklow + _Off; // may perform nullptr + 0
+        if ((_Mode & ios_base::in) && _Gptr_old) {
+            _Mysb::setg(_Seeklow, _Newptr, _Seekhigh);
+        }
+
+        if ((_Mode & ios_base::out) && _Pptr_old) {
+            _Mysb::setp(_Seeklow, _Newptr, _Mysb::epptr());
+        }
+
+        return pos_type{_Off};
+    }
+
+    void _Init(const _Elem* _Ptr, const _Mysize_type _Count, int _State) {
+        // initialize buffer to [_Ptr, _Ptr + _Count), set state
+        _State &= ~_From_rvalue;
+
+        if (_Count > INT_MAX) { // TRANSITION, VSO-485517
+            _Xbad_alloc();
+        }
+
+        if (_Count != 0 && (_State & (_Noread | _Constant)) != (_Noread | _Constant)) {
+            // finite buffer that can be read or written, set it up
+            _Mysize_type _Newsize = _Count;
+            const auto _Pnew      = _Unfancy(_Allocate_at_least_helper(_Al, _Newsize));
+            _Traits::copy(_Pnew, _Ptr, _Count);
+            _Seekhigh = _Pnew + _Newsize;
+
+            if (!(_State & _Noread)) {
+                _Mysb::setg(_Pnew, _Pnew, _Seekhigh); // setup read buffer
+            }
+
+            if (!(_State & _Constant)) { // setup write buffer, and maybe read buffer
+                _Mysb::setp(_Pnew, (_State & (_Atend | _Append)) ? _Seekhigh : _Pnew, _Seekhigh);
+
+                if (_State & _Noread) { // maintain "_Allocated == eback() points to buffer base" invariant
+                    _Mysb::setg(_Pnew, _Pnew, _Pnew);
+                }
+            }
+
+            _State |= _Allocated;
+        } else {
+            _Seekhigh = nullptr;
+        }
+
+        _Mystate = _State;
+    }
+
+#if _HAS_CXX20
+    void _Init_string_inplace(_Mystr&& _Str, int _State) {
+        if ((_State & _Noread) && (_State & _Constant)) { // Cannot read / write buffer, do nothing
+            _Seekhigh = nullptr;
+            _Mystate  = _State | _From_rvalue;
+            return;
+        }
+
+        // finite buffer that can be read or written, set it up
+        auto [_Ptr, _Size, _Actual_allocation_size] = _Str._Release_to_buffer(_Al);
+        _Elem* const _Pnew                          = _Unfancy(_Ptr);
+        _Seekhigh                                   = _Pnew + _Size;
+        auto _Next                                  = (_State & (_Atend | _Append)) ? _Seekhigh : _Pnew;
+        auto _End_buffer                            = _Pnew + _Actual_allocation_size;
+
+        _Mysb::setp(_Pnew, _Next, _End_buffer);
+        if (_State & _Noread) { // maintain "_Allocated == eback() points to buffer base" invariant
+            _Mysb::setg(_Pnew, _Pnew, _Pnew);
+        } else {
+            _Mysb::setg(_Pnew, _Pnew, _Seekhigh);
+        }
+
+        _Mystate = _State | _Allocated | _From_rvalue;
+    }
+#endif // _HAS_CXX20
+
+    void _Tidy() noexcept { // discard any allocated buffer and clear pointers
+        if (_Mystate & _Allocated) {
+            _Al.deallocate(_Ptr_traits::pointer_to(*_Mysb::eback()),
+                static_cast<typename allocator_traits<allocator_type>::size_type>(
+                    (_Mysb::pptr() ? _Mysb::epptr() : _Mysb::egptr()) - _Mysb::eback()));
+        }
+
+        _Mysb::setg(nullptr, nullptr, nullptr);
+        _Mysb::setp(nullptr, nullptr);
+        _Seekhigh = nullptr;
+        _Mystate &= ~_Allocated;
+    }
+
+private:
+    using _Ptr_traits = pointer_traits<typename allocator_traits<allocator_type>::pointer>;
+
+    enum { // constant for minimum buffer size
+        _MINSIZE = 32
+    };
+
+    static int _Getstate(ios_base::openmode _Mode) noexcept { // convert open mode to stream state bits
+        int _State = 0;
+        if (!(_Mode & ios_base::in)) {
+            _State |= _Noread;
+        }
+
+        if (!(_Mode & ios_base::out)) {
+            _State |= _Constant;
+        }
+
+        if (_Mode & ios_base::app) {
+            _State |= _Append;
+        }
+
+        if (_Mode & ios_base::ate) {
+            _State |= _Atend;
+        }
+
+        return _State;
+    }
+
+    // TRANSITION, ABI, see GH-938
+    _Elem* _Seekhigh; // the high-water pointer in character array
+    int _Mystate; // the stream state
+    allocator_type _Al; // the allocator object
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+void swap(basic_stringbuf<_Elem, _Traits, _Alloc>& _Left, basic_stringbuf<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+class basic_istringstream : public basic_istream<_Elem, _Traits> { // input stream associated with a character array
+public:
+    using _Mybase        = basic_istream<_Elem, _Traits>;
+    using allocator_type = _Alloc;
+    using _Mysb          = basic_stringbuf<_Elem, _Traits, _Alloc>;
+    using _Mystr         = basic_string<_Elem, _Traits, _Alloc>;
+
+#if _HAS_CXX20
+    using _Mystr_view = basic_string_view<_Elem, _Traits>;
+#endif // _HAS_CXX20
+
+    basic_istringstream() : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(ios_base::in) {}
+
+    explicit basic_istringstream(ios_base::openmode _Mode)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Mode | ios_base::in) {}
+
+    explicit basic_istringstream(const _Mystr& _Str, ios_base::openmode _Mode = ios_base::in)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::in) {}
+
+#if _HAS_CXX20
+    basic_istringstream(ios_base::openmode _Mode, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Mode | ios_base::in, _Al) {}
+
+    explicit basic_istringstream(_Mystr&& _Str, ios_base::openmode _Mode = ios_base::in)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_STD move(_Str), _Mode | ios_base::in) {}
+
+    template <class _Alloc2>
+    basic_istringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, ios_base::in, _Al) {}
+
+    template <class _Alloc2>
+    basic_istringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::in, _Al) {}
+
+    template <class _Alloc2>
+        requires (!is_same_v<_Alloc2, _Alloc>)
+    explicit basic_istringstream(
+        const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode = ios_base::in)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::in) {}
+#endif // _HAS_CXX20
+
+    basic_istringstream(basic_istringstream&& _Right)
+        : _Mybase(_STD addressof(_Stringbuffer)),
+          _Stringbuffer((_Mybase::swap(_Right), _STD move(_Right._Stringbuffer))) {}
+
+    basic_istringstream& operator=(basic_istringstream&& _Right)
+        noexcept(_Choose_pocma_v<_Alloc> != _Pocma_values::_No_propagate_allocators) /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Stringbuffer._Assign_rv_no_alias(_STD move(_Right._Stringbuffer));
+        }
+        return *this;
+    }
+
+    void swap(basic_istringstream& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Stringbuffer.swap(_Right._Stringbuffer);
+        }
+    }
+
+    basic_istringstream(const basic_istringstream&)            = delete;
+    basic_istringstream& operator=(const basic_istringstream&) = delete;
+
+    ~basic_istringstream() noexcept override {}
+
+    _NODISCARD _Mysb* rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Mysb*>(_STD addressof(_Stringbuffer));
+    }
+
+#if _HAS_CXX20
+    _NODISCARD _Mystr str() const&
+#else
+    _NODISCARD _Mystr str() const
+#endif
+    {
+        return _Stringbuffer.str();
+    }
+
+    void str(const _Mystr& _Newstr) { // replace character array from string
+        _Stringbuffer.str(_Newstr);
+    }
+
+#if _HAS_CXX20
+    template <_Allocator_for_container _Alloc2>
+    _NODISCARD basic_string<_Elem, _Traits, _Alloc2> str(const _Alloc2& _Al) const {
+        return _Stringbuffer.str(_Al);
+    }
+
+    _NODISCARD _Mystr str() && {
+        return _STD move(_Stringbuffer).str();
+    }
+
+    _NODISCARD _Mystr_view view() const noexcept {
+        return _Stringbuffer.view();
+    }
+
+    template <class _Alloc2>
+        requires (!is_same_v<_Alloc2, _Alloc>)
+    void str(const basic_string<_Elem, _Traits, _Alloc2>& _Newstr) {
+        _Stringbuffer.str(_Newstr);
+    }
+
+    void str(_Mystr&& _Newstr) {
+        _Stringbuffer.str(_STD move(_Newstr));
+    }
+#endif // _HAS_CXX20
+
+private:
+    _Mysb _Stringbuffer;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+void swap(basic_istringstream<_Elem, _Traits, _Alloc>& _Left,
+    basic_istringstream<_Elem, _Traits, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+class basic_ostringstream : public basic_ostream<_Elem, _Traits> { // output stream associated with a character array
+public:
+    using _Mybase        = basic_ostream<_Elem, _Traits>;
+    using allocator_type = _Alloc;
+    using _Mysb          = basic_stringbuf<_Elem, _Traits, _Alloc>;
+    using _Mystr         = basic_string<_Elem, _Traits, _Alloc>;
+
+#if _HAS_CXX20
+    using _Mystr_view = basic_string_view<_Elem, _Traits>;
+#endif // _HAS_CXX20
+
+    basic_ostringstream() : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(ios_base::out) {}
+
+    explicit basic_ostringstream(ios_base::openmode _Mode)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Mode | ios_base::out) {}
+
+    explicit basic_ostringstream(const _Mystr& _Str, ios_base::openmode _Mode = ios_base::out)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::out) {}
+
+#if _HAS_CXX20
+    basic_ostringstream(ios_base::openmode _Mode, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Mode | ios_base::out, _Al) {}
+
+    explicit basic_ostringstream(_Mystr&& _Str, ios_base::openmode _Mode = ios_base::out)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_STD move(_Str), _Mode | ios_base::out) {}
+
+    template <class _Alloc2>
+    basic_ostringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, ios_base::out, _Al) {}
+
+    template <class _Alloc2>
+    basic_ostringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::out, _Al) {}
+
+    template <class _Alloc2>
+        requires (!is_same_v<_Alloc2, _Alloc>)
+    explicit basic_ostringstream(
+        const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode = ios_base::out)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::out) {}
+#endif // _HAS_CXX20
+
+    basic_ostringstream(basic_ostringstream&& _Right)
+        : _Mybase(_STD addressof(_Stringbuffer)),
+          _Stringbuffer((_Mybase::swap(_Right), _STD move(_Right._Stringbuffer))) {}
+
+    basic_ostringstream& operator=(basic_ostringstream&& _Right)
+        noexcept(_Choose_pocma_v<_Alloc> != _Pocma_values::_No_propagate_allocators) /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Stringbuffer._Assign_rv_no_alias(_STD move(_Right._Stringbuffer));
+        }
+        return *this;
+    }
+
+    void swap(basic_ostringstream& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Stringbuffer.swap(_Right._Stringbuffer);
+        }
+    }
+
+    basic_ostringstream(const basic_ostringstream&)            = delete;
+    basic_ostringstream& operator=(const basic_ostringstream&) = delete;
+
+    ~basic_ostringstream() noexcept override {}
+
+    _NODISCARD _Mysb* rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Mysb*>(_STD addressof(_Stringbuffer));
+    }
+
+#if _HAS_CXX20
+    _NODISCARD _Mystr str() const&
+#else
+    _NODISCARD _Mystr str() const
+#endif
+    {
+        return _Stringbuffer.str();
+    }
+
+    void str(const _Mystr& _Newstr) { // replace character array from string
+        _Stringbuffer.str(_Newstr);
+    }
+
+#if _HAS_CXX20
+    template <_Allocator_for_container _Alloc2>
+    _NODISCARD basic_string<_Elem, _Traits, _Alloc2> str(const _Alloc2& _Al) const {
+        return _Stringbuffer.str(_Al);
+    }
+
+    _NODISCARD _Mystr str() && {
+        return _STD move(_Stringbuffer).str();
+    }
+
+    _NODISCARD _Mystr_view view() const noexcept {
+        return _Stringbuffer.view();
+    }
+
+    template <class _Alloc2>
+        requires (!is_same_v<_Alloc2, _Alloc>)
+    void str(const basic_string<_Elem, _Traits, _Alloc2>& _Newstr) {
+        _Stringbuffer.str(_Newstr);
+    }
+
+    void str(_Mystr&& _Newstr) {
+        _Stringbuffer.str(_STD move(_Newstr));
+    }
+#endif // _HAS_CXX20
+
+private:
+    _Mysb _Stringbuffer;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+void swap(basic_ostringstream<_Elem, _Traits, _Alloc>& _Left,
+    basic_ostringstream<_Elem, _Traits, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+class basic_stringstream
+    : public basic_iostream<_Elem, _Traits> { // input/output stream associated with a character array
+public:
+    using _Mybase        = basic_iostream<_Elem, _Traits>;
+    using char_type      = _Elem;
+    using traits_type    = _Traits;
+    using allocator_type = _Alloc;
+    using int_type       = typename _Traits::int_type;
+    using pos_type       = typename _Traits::pos_type;
+    using off_type       = typename _Traits::off_type;
+    using _Mysb          = basic_stringbuf<_Elem, _Traits, _Alloc>;
+    using _Mystr         = basic_string<_Elem, _Traits, _Alloc>;
+
+#if _HAS_CXX20
+    using _Mystr_view = basic_string_view<_Elem, _Traits>;
+#endif // _HAS_CXX20
+
+    basic_stringstream() : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(ios_base::in | ios_base::out) {}
+
+    explicit basic_stringstream(ios_base::openmode _Mode)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Mode) {}
+
+    explicit basic_stringstream(const _Mystr& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode) {}
+
+#if _HAS_CXX20
+    basic_stringstream(ios_base::openmode _Mode, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Mode, _Al) {}
+
+    explicit basic_stringstream(_Mystr&& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_STD move(_Str), _Mode) {}
+
+    template <class _Alloc2>
+    basic_stringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, ios_base::in | ios_base::out, _Al) {}
+
+    template <class _Alloc2>
+    basic_stringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode, _Al) {}
+
+    template <class _Alloc2>
+        requires (!is_same_v<_Alloc2, _Alloc>)
+    explicit basic_stringstream(
+        const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
+        : _Mybase(_STD addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode) {}
+#endif // _HAS_CXX20
+
+    basic_stringstream(basic_stringstream&& _Right)
+        : _Mybase(_STD addressof(_Stringbuffer)),
+          _Stringbuffer((_Mybase::swap(_Right), _STD move(_Right._Stringbuffer))) {}
+
+    basic_stringstream& operator=(basic_stringstream&& _Right)
+        noexcept(_Choose_pocma_v<_Alloc> != _Pocma_values::_No_propagate_allocators) /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Stringbuffer._Assign_rv_no_alias(_STD move(_Right._Stringbuffer));
+        }
+        return *this;
+    }
+
+    void swap(basic_stringstream& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Stringbuffer.swap(_Right._Stringbuffer);
+        }
+    }
+
+    basic_stringstream(const basic_stringstream&)            = delete;
+    basic_stringstream& operator=(const basic_stringstream&) = delete;
+
+    ~basic_stringstream() noexcept override {}
+
+    _NODISCARD _Mysb* rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Mysb*>(_STD addressof(_Stringbuffer));
+    }
+
+#if _HAS_CXX20
+    _NODISCARD _Mystr str() const&
+#else
+    _NODISCARD _Mystr str() const
+#endif
+    {
+        return _Stringbuffer.str();
+    }
+
+    void str(const _Mystr& _Newstr) { // replace character array from string
+        _Stringbuffer.str(_Newstr);
+    }
+
+#if _HAS_CXX20
+    template <_Allocator_for_container _Alloc2>
+    _NODISCARD basic_string<_Elem, _Traits, _Alloc2> str(const _Alloc2& _Al) const {
+        return _Stringbuffer.str(_Al);
+    }
+
+    _NODISCARD _Mystr str() && {
+        return _STD move(_Stringbuffer).str();
+    }
+
+    _NODISCARD _Mystr_view view() const noexcept {
+        return _Stringbuffer.view();
+    }
+
+    template <class _Alloc2>
+        requires (!is_same_v<_Alloc2, _Alloc>)
+    void str(const basic_string<_Elem, _Traits, _Alloc2>& _Newstr) {
+        _Stringbuffer.str(_Newstr);
+    }
+
+    void str(_Mystr&& _Newstr) {
+        _Stringbuffer.str(_STD move(_Newstr));
+    }
+#endif // _HAS_CXX20
+
+private:
+    _Mysb _Stringbuffer;
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+void swap(basic_stringstream<_Elem, _Traits, _Alloc>& _Left,
+    basic_stringstream<_Elem, _Traits, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SSTREAM_
diff --git a/msvc-stl/stl/inc/stack b/msvc-stl/stl/inc/stack
new file mode 100644
index 0000000..7561d62
--- /dev/null
+++ b/msvc-stl/stl/inc/stack
@@ -0,0 +1,231 @@
+// stack standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STACK_
+#define _STACK_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <deque>
+
+#if _HAS_CXX23
+#include <__msvc_ranges_to.hpp>
+#include <__msvc_ranges_tuple_formatter.hpp>
+#include <iterator>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD template <class _Ty, class _Container = deque<_Ty>>
+class stack {
+public:
+    using value_type      = typename _Container::value_type;
+    using reference       = typename _Container::reference;
+    using const_reference = typename _Container::const_reference;
+    using size_type       = typename _Container::size_type;
+    using container_type  = _Container;
+
+    static_assert(is_same_v<_Ty, value_type>, "container adaptors require consistent types");
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids container adaptors of non-object types "
+                                    "because of [container.requirements].");
+
+    stack() = default;
+
+    explicit stack(const _Container& _Cont) : c(_Cont) {}
+
+    explicit stack(_Container&& _Cont) noexcept(is_nothrow_move_constructible_v<_Container>) // strengthened
+        : c(_STD move(_Cont)) {}
+
+#if _HAS_CXX23
+    template <_Iterator_for_container _InIt>
+    stack(_InIt _First, _InIt _Last) noexcept(is_nothrow_constructible_v<_Container, _InIt, _InIt>) // strengthened
+        : c(_STD move(_First), _STD move(_Last)) {}
+
+    template <_Container_compatible_range<_Ty> _Rng>
+    stack(from_range_t, _Rng&& _Range) : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range))) {}
+#endif // _HAS_CXX23
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    explicit stack(const _Alloc& _Al) noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>) // strengthened
+        : c(_Al) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    stack(const _Container& _Cont, const _Alloc& _Al) : c(_Cont, _Al) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    stack(_Container&& _Cont, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) // strengthened
+        : c(_STD move(_Cont), _Al) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    stack(const stack& _Right, const _Alloc& _Al) : c(_Right.c, _Al) {}
+
+    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
+    stack(stack&& _Right, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) // strengthened
+        : c(_STD move(_Right.c), _Al) {}
+
+#if _HAS_CXX23
+    template <_Iterator_for_container _InIt, class _Alloc>
+        requires uses_allocator_v<_Container, _Alloc>
+    stack(_InIt _First, _InIt _Last, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Container, _InIt, _InIt, const _Alloc&>) // strengthened
+        : c(_STD move(_First), _STD move(_Last), _Al) {}
+
+    template <_Container_compatible_range<_Ty> _Rng, class _Alloc>
+    stack(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+        : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)) {}
+#endif // _HAS_CXX23
+
+    _NODISCARD_EMPTY_MEMBER_NO_CLEAR bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
+        return c.empty();
+    }
+
+    _NODISCARD size_type size() const noexcept(noexcept(c.size())) /* strengthened */ {
+        return c.size();
+    }
+
+    _NODISCARD reference top() noexcept(noexcept(c.back())) /* strengthened */ {
+        return c.back();
+    }
+
+    _NODISCARD const_reference top() const noexcept(noexcept(c.back())) /* strengthened */ {
+        return c.back();
+    }
+
+    void push(const value_type& _Val) {
+        c.push_back(_Val);
+    }
+
+    void push(value_type&& _Val) {
+        c.push_back(_STD move(_Val));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    void push_range(_Rng&& _Range) {
+        if constexpr (requires { c.append_range(_STD forward<_Rng>(_Range)); }) {
+            c.append_range(_STD forward<_Rng>(_Range));
+        } else {
+            _RANGES copy(_Range, back_insert_iterator{c});
+        }
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Valty>
+    _ADAPTOR_EMPLACE_RETURN emplace(_Valty&&... _Val) {
+#if _HAS_CXX17
+        return c.emplace_back(_STD forward<_Valty>(_Val)...);
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        c.emplace_back(_STD forward<_Valty>(_Val)...);
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    void pop() noexcept(noexcept(c.pop_back())) /* strengthened */ {
+        c.pop_back();
+    }
+
+    void swap(stack& _Right) noexcept(_Is_nothrow_swappable<_Container>::value) {
+        using _STD swap;
+        swap(c, _Right.c); // intentional ADL
+    }
+
+    _NODISCARD const _Container& _Get_container() const noexcept {
+        return c;
+    }
+
+protected:
+    _Container c{};
+};
+
+#if _HAS_CXX17
+template <class _Container, enable_if_t<!_Is_allocator<_Container>::value, int> = 0>
+stack(_Container) -> stack<typename _Container::value_type, _Container>;
+
+template <class _Container, class _Alloc,
+    enable_if_t<conjunction_v<negation<_Is_allocator<_Container>>, uses_allocator<_Container, _Alloc>>, int> = 0>
+stack(_Container, _Alloc) -> stack<typename _Container::value_type, _Container>;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <_Iterator_for_container _InIt, _Allocator_for_container _Alloc = allocator<_Iter_value_t<_InIt>>>
+stack(_InIt, _InIt, _Alloc = _Alloc()) -> stack<_Iter_value_t<_InIt>, deque<_Iter_value_t<_InIt>, _Alloc>>;
+
+template <_RANGES input_range _Rng>
+stack(from_range_t, _Rng&&) -> stack<_RANGES range_value_t<_Rng>>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+stack(from_range_t, _Rng&&, _Alloc) -> stack<_RANGES range_value_t<_Rng>, deque<_RANGES range_value_t<_Rng>, _Alloc>>;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator==(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
+    return _Left._Get_container() == _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator!=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
+    return _Left._Get_container() != _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator<(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
+    return _Left._Get_container() < _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator>(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
+    return _Left._Get_container() > _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator<=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
+    return _Left._Get_container() <= _Right._Get_container();
+}
+
+_EXPORT_STD template <class _Ty, class _Container>
+_NODISCARD bool operator>=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
+    return _Left._Get_container() >= _Right._Get_container();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, three_way_comparable _Container>
+_NODISCARD compare_three_way_result_t<_Container> operator<=>(
+    const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
+    return _Left._Get_container() <=> _Right._Get_container();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
+void swap(stack<_Ty, _Container>& _Left, stack<_Ty, _Container>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+template <class _Ty, class _Container, class _Alloc>
+struct uses_allocator<stack<_Ty, _Container>, _Alloc> : uses_allocator<_Container, _Alloc>::type {};
+
+#if _HAS_CXX23
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+template <_Format_supported_charT _CharT, class _Ty, formattable<_CharT> _Container>
+struct formatter<stack<_Ty, _Container>, _CharT>
+    : _Adaptor_formatter_base<stack<_Ty, _Container>, _CharT, _RANGES ref_view> {};
+
+template <class _Ty, class _Container>
+constexpr bool enable_nonlocking_formatter_optimization<stack<_Ty, _Container>> = false;
+#endif // _HAS_CXX23
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STACK_
diff --git a/msvc-stl/stl/inc/stacktrace b/msvc-stl/stl/inc/stacktrace
new file mode 100644
index 0000000..82e7d6e
--- /dev/null
+++ b/msvc-stl/stl/inc/stacktrace
@@ -0,0 +1,421 @@
+// stacktrace standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STACKTRACE_
+#define _STACKTRACE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <stacktrace> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+
+#include <__msvc_formatter.hpp>
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// The separately compiled part of the <stacktrace> implementation calls a function pointer of _Stacktrace_string_fill
+// type to allocate a buffer for string output. The called function does the buffer allocation and calls a function
+// pointer of _Stacktrace_string_fill_callback type to fill the buffer. This is needed to type-erase <string> or
+// <ostream>, and makes it possible to keep the separately compiled implementation in the import library.
+//
+// Additionally, _Stacktrace_string_fill can be called with a null _Callback argument to determine the already reserved
+// string buffer for cases when the size is not known before an attempt to fill it -- this potentially avoids both an
+// extra fill attempt and an extra allocation if the reserved size is enough.
+
+extern "C" {
+using _Stacktrace_string_fill_callback = size_t(__stdcall*)(char* _Data, size_t _Size, void* _Context) _NOEXCEPT_FNPTR;
+
+using _Stacktrace_string_fill = size_t(__stdcall*)(
+    size_t _Size, void* _String, void* _Context, _Stacktrace_string_fill_callback _Callback);
+
+_NODISCARD unsigned short __stdcall __std_stacktrace_capture(unsigned long _Frames_to_skip,
+    unsigned long _Frames_to_capture, void** _Back_trace, unsigned long* _Back_trace_hash) noexcept;
+
+// Some of these functions may throw
+// (they would propagate bad_alloc potentially thrown from string::resize_and_overwrite)
+
+void __stdcall __std_stacktrace_address_to_string(const void* _Address, void* _Str, _Stacktrace_string_fill _Fill)
+    noexcept(false);
+
+void __stdcall __std_stacktrace_description(const void* _Address, void* _Str, _Stacktrace_string_fill _Fill)
+    noexcept(false);
+
+void __stdcall __std_stacktrace_source_file(const void* _Address, void* _Str, _Stacktrace_string_fill _Fill)
+    noexcept(false);
+
+_NODISCARD unsigned int __stdcall __std_stacktrace_source_line(const void* _Address) noexcept;
+
+void __stdcall __std_stacktrace_to_string(
+    const void* const* _Addresses, size_t _Size, void* _Str, _Stacktrace_string_fill _Fill) noexcept(false);
+} // extern "C"
+
+_STD_BEGIN
+inline size_t __stdcall _Stacktrace_string_fill_impl(
+    const size_t _Size, void* const _String, void* const _Context, const _Stacktrace_string_fill_callback _Callback) {
+    if (_Callback) {
+        static_cast<string*>(_String)->resize_and_overwrite(_Size,
+            [_Callback, _Context](char* _Data, size_t _Size) noexcept { return _Callback(_Data, _Size, _Context); });
+        return static_cast<string*>(_String)->size();
+    } else {
+        return static_cast<string*>(_String)->capacity();
+    }
+}
+
+_EXPORT_STD class stacktrace_entry {
+public:
+    using native_handle_type = void*;
+
+    constexpr stacktrace_entry() noexcept                                   = default;
+    constexpr stacktrace_entry(const stacktrace_entry&) noexcept            = default;
+    constexpr stacktrace_entry& operator=(const stacktrace_entry&) noexcept = default;
+
+    ~stacktrace_entry() = default;
+
+    _NODISCARD constexpr native_handle_type native_handle() const noexcept {
+        return _Address;
+    }
+
+    _NODISCARD constexpr explicit operator bool() const noexcept {
+        return _Address != nullptr;
+    }
+
+    _NODISCARD string description() const {
+        string _Result;
+        __std_stacktrace_description(_Address, &_Result, _Stacktrace_string_fill_impl);
+        return _Result;
+    }
+
+    _NODISCARD string source_file() const {
+        string _Result;
+        __std_stacktrace_source_file(_Address, &_Result, _Stacktrace_string_fill_impl);
+        return _Result;
+    }
+
+    _NODISCARD uint_least32_t source_line() const noexcept /* strengthened */ {
+        return __std_stacktrace_source_line(_Address);
+    }
+
+    _NODISCARD friend constexpr bool operator==(const stacktrace_entry&, const stacktrace_entry&) noexcept = default;
+
+    _NODISCARD friend constexpr strong_ordering operator<=>(
+        const stacktrace_entry&, const stacktrace_entry&) noexcept = default;
+
+private:
+    void* _Address = nullptr;
+};
+
+_EXPORT_STD template <class _Alloc>
+class basic_stacktrace {
+private:
+    using _Frames_t = vector<stacktrace_entry, _Alloc>;
+
+public:
+    using value_type             = stacktrace_entry;
+    using const_reference        = const value_type&;
+    using reference              = value_type&;
+    using const_iterator         = _Frames_t::const_iterator;
+    using iterator               = const_iterator;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+    using difference_type        = _Frames_t::difference_type;
+    using size_type              = _Frames_t::size_type;
+    using allocator_type         = _Alloc;
+
+    // __declspec(noinline) to make the same behavior for debug and release.
+    // We force the current function to be always noinline and add its frame to skipped.
+
+    _NODISCARD __declspec(noinline) static basic_stacktrace current(
+        const allocator_type& _Al = allocator_type()) noexcept {
+        _TRY_BEGIN
+        basic_stacktrace _Result{_Internal_t{}, _Max_frames, _Al};
+        const unsigned short _Actual_size = __std_stacktrace_capture(
+            1, static_cast<unsigned long>(_Max_frames), _Result._To_voidptr_array(), &_Result._Hash);
+        _Result._Frames.resize(_Actual_size);
+        return _Result;
+        _CATCH_ALL
+        return basic_stacktrace{_Al};
+        _CATCH_END
+    }
+
+    _NODISCARD __declspec(noinline) static basic_stacktrace current(
+        const size_type _Skip, const allocator_type& _Al = allocator_type()) noexcept {
+        _TRY_BEGIN
+        basic_stacktrace _Result{_Internal_t{}, _Max_frames, _Al};
+        const unsigned short _Actual_size = __std_stacktrace_capture(
+            _Adjust_skip(_Skip), static_cast<unsigned long>(_Max_frames), _Result._To_voidptr_array(), &_Result._Hash);
+        _Result._Frames.resize(_Actual_size);
+        return _Result;
+        _CATCH_ALL
+        return basic_stacktrace{_Al};
+        _CATCH_END
+    }
+
+    _NODISCARD __declspec(noinline) static basic_stacktrace current(
+        const size_type _Skip, size_type _Max_depth, const allocator_type& _Al = allocator_type()) noexcept {
+#if _MSVC_STL_HARDENING_BASIC_STACKTRACE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Skip <= _Skip + _Max_depth, "Mathematical result of (_Skip + _Max_depth) must be representable in "
+                                                 "size_t (N5008 [stacktrace.basic.cons]/5).");
+#endif // _MSVC_STL_HARDENING_BASIC_STACKTRACE || _ITERATOR_DEBUG_LEVEL != 0
+        _TRY_BEGIN
+        if (_Max_depth > _Max_frames) {
+            _Max_depth = _Max_frames;
+        }
+
+        basic_stacktrace _Result{_Internal_t{}, _Max_depth, _Al};
+
+        const unsigned short _Actual_size = __std_stacktrace_capture(
+            _Adjust_skip(_Skip), static_cast<unsigned long>(_Max_depth), _Result._To_voidptr_array(), &_Result._Hash);
+        _Result._Frames.resize(_Actual_size);
+        return _Result;
+        _CATCH_ALL
+        return basic_stacktrace{_Al};
+        _CATCH_END
+    }
+
+    basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>) = default;
+    explicit basic_stacktrace(const allocator_type& _Al) noexcept : _Frames(_Al) {}
+
+    basic_stacktrace(const basic_stacktrace&)     = default;
+    basic_stacktrace(basic_stacktrace&&) noexcept = default;
+    basic_stacktrace(const basic_stacktrace& _Other, const allocator_type& _Al)
+        : _Frames(_Other._Frames, _Al), _Hash(_Other._Hash) {}
+
+    basic_stacktrace(basic_stacktrace&& _Other, const allocator_type& _Al)
+        : _Frames(_STD move(_Other._Frames), _Al), _Hash(_Other._Hash) {}
+
+    basic_stacktrace& operator=(const basic_stacktrace&)                 = default;
+    basic_stacktrace& operator=(basic_stacktrace&&) noexcept(_Noex_move) = default;
+
+    ~basic_stacktrace() = default;
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return _Frames.get_allocator();
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        return _Frames.cbegin();
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        return _Frames.cend();
+    }
+
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return _Frames.crbegin();
+    }
+
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return _Frames.crend();
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return _Frames.cbegin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return _Frames.cend();
+    }
+
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return _Frames.crbegin();
+    }
+
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return _Frames.crend();
+    }
+
+    _NODISCARD_EMPTY_MEMBER_NO_CLEAR bool empty() const noexcept {
+        return _Frames.empty();
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _Frames.size();
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        return _Frames.max_size();
+    }
+
+    _NODISCARD const_reference operator[](const size_type _Sx) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STACKTRACE || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Sx < _Frames.size(), "basic_stacktrace subscript out of range");
+#endif // _MSVC_STL_HARDENING_BASIC_STACKTRACE || _ITERATOR_DEBUG_LEVEL != 0
+        return _Frames.data()[_Sx]; // avoid redundant checking
+    }
+
+    _NODISCARD const_reference at(const size_type _Sx) const {
+        return _Frames.at(_Sx);
+    }
+
+    template <class _Al2>
+    _NODISCARD friend bool operator==(const basic_stacktrace& _Lhs, const basic_stacktrace<_Al2>& _Rhs) noexcept {
+        return _Lhs._Hash == _Rhs._Hash && _STD equal(_Lhs.begin(), _Lhs.end(), _Rhs.begin(), _Rhs.end());
+    }
+
+    template <class _Al2>
+    _NODISCARD friend strong_ordering operator<=>(
+        const basic_stacktrace& _Lhs, const basic_stacktrace<_Al2>& _Rhs) noexcept {
+        const auto _Result = _Lhs._Frames.size() <=> _Rhs._Frames.size();
+        if (_Result != strong_ordering::equal) {
+            return _Result;
+        }
+
+        return _STD lexicographical_compare_three_way(_Lhs.begin(), _Lhs.end(), _Rhs.begin(), _Rhs.end());
+    }
+
+    void swap(basic_stacktrace& _Other) noexcept(allocator_traits<_Alloc>::propagate_on_container_swap::value
+                                                 || allocator_traits<_Alloc>::is_always_equal::value) {
+        _Frames.swap(_Other._Frames);
+        _STD swap(_Hash, _Other._Hash);
+    }
+
+    _NODISCARD unsigned long _Get_hash() const noexcept {
+        return _Hash;
+    }
+
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(void*) == sizeof(stacktrace_entry));
+    _STL_INTERNAL_STATIC_ASSERT(alignof(void*) == alignof(stacktrace_entry));
+
+    _NODISCARD const void* const* _To_voidptr_array() const noexcept {
+        return reinterpret_cast<const void* const*>(_Frames.data());
+    }
+
+    _NODISCARD void** _To_voidptr_array() noexcept {
+        return reinterpret_cast<void**>(_Frames.data());
+    }
+
+private:
+    static constexpr size_t _Max_frames = 0xFFFF;
+
+    static constexpr bool _Noex_move = allocator_traits<_Alloc>::propagate_on_container_move_assignment::value
+                                    || allocator_traits<_Alloc>::is_always_equal::value;
+
+    struct _Internal_t {
+        explicit _Internal_t() noexcept = default;
+    };
+
+    basic_stacktrace(_Internal_t, size_type _Max_depth, const allocator_type& _Al) : _Frames(_Max_depth, _Al) {}
+
+    _NODISCARD static unsigned long _Adjust_skip(size_t _Skip) noexcept {
+        return _Skip < ULONG_MAX - 1 ? static_cast<unsigned long>(_Skip + 1) : ULONG_MAX;
+    }
+
+    _Frames_t _Frames;
+    unsigned long _Hash = 0;
+};
+
+_EXPORT_STD using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;
+
+_EXPORT_STD template <class _Alloc>
+void swap(basic_stacktrace<_Alloc>& _Ax, basic_stacktrace<_Alloc>& _Bx) noexcept(noexcept(_Ax.swap(_Bx))) {
+    _Ax.swap(_Bx);
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(const stacktrace_entry& _Fx) {
+    string _Result;
+    __std_stacktrace_address_to_string(_Fx.native_handle(), &_Result, _Stacktrace_string_fill_impl);
+    return _Result;
+}
+
+_EXPORT_STD template <class _Alloc>
+_NODISCARD string to_string(const basic_stacktrace<_Alloc>& _St) {
+    string _Result;
+    __std_stacktrace_to_string(_St._To_voidptr_array(), _St.size(), &_Result, _Stacktrace_string_fill_impl);
+    return _Result;
+}
+
+_EXPORT_STD template <int = 0>
+ostream& operator<<(ostream& _Os, const stacktrace_entry& _Fx) {
+    return _Os << _STD to_string(_Fx);
+}
+
+_EXPORT_STD template <class _Alloc>
+ostream& operator<<(ostream& _Os, const basic_stacktrace<_Alloc>& _St) {
+    return _Os << _STD to_string(_St);
+}
+
+template <>
+struct formatter<stacktrace_entry> {
+    template <class _ParseContext = basic_format_parse_context<char>> // improves throughput, see GH-5003
+    constexpr _ParseContext::iterator parse(type_identity_t<_ParseContext&> _Parse_ctx) {
+        return _Impl._Parse(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(const stacktrace_entry& _Val, _FormatContext& _Format_ctx) const {
+        const auto _Str = _STD to_string(_Val);
+        return _Impl._Format(_Format_ctx, static_cast<int>(_Str.size()), _Fmt_align::_Left,
+            [&](_FormatContext::iterator _Out) { return _RANGES copy(_Str, _STD move(_Out)).out; });
+    }
+
+private:
+    _Fill_align_and_width_formatter<char> _Impl;
+};
+
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<stacktrace_entry> = true;
+
+template <class _Alloc>
+struct formatter<basic_stacktrace<_Alloc>> {
+    template <class _ParseContext = basic_format_parse_context<char>> // improves throughput, see GH-5003
+    constexpr _ParseContext::iterator parse(type_identity_t<_ParseContext&> _Parse_ctx) {
+        const auto _First = _Parse_ctx.begin();
+        if (_First != _Parse_ctx.end() && *_First != '}') {
+            _Throw_format_error("For formatter<basic_stacktrace<Allocator>>, format-spec must be empty.");
+        }
+
+        return _First;
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(const basic_stacktrace<_Alloc>& _Val, _FormatContext& _Format_ctx) const {
+        return _RANGES copy(_STD to_string(_Val), _Format_ctx.out()).out;
+    }
+};
+
+template <class _Alloc>
+constexpr bool enable_nonlocking_formatter_optimization<basic_stacktrace<_Alloc>> = true;
+
+namespace pmr {
+    _EXPORT_STD using stacktrace = basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
+}
+
+template <>
+struct hash<stacktrace_entry> {
+    // This is a C++23 feature, so argument_type and result_type are omitted.
+
+    _NODISCARD static size_t operator()(const stacktrace_entry& _Val) noexcept {
+        return _Hash_representation(_Val.native_handle());
+    }
+};
+
+template <class _Alloc>
+struct hash<basic_stacktrace<_Alloc>> {
+    // This is a C++23 feature, so argument_type and result_type are omitted.
+
+    _NODISCARD static size_t operator()(const basic_stacktrace<_Alloc>& _Val) noexcept {
+        return _Val._Get_hash();
+    }
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX23 ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STACKTRACE_
diff --git a/msvc-stl/stl/inc/stdexcept b/msvc-stl/stl/inc/stdexcept
new file mode 100644
index 0000000..e3c1869
--- /dev/null
+++ b/msvc-stl/stl/inc/stdexcept
@@ -0,0 +1,173 @@
+// stdexcept standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STDEXCEPT_
+#define _STDEXCEPT_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <exception>
+#include <xstring>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+_STD_BEGIN
+_EXPORT_STD class _NODISCARD logic_error : public exception { // base of all logic-error exceptions
+public:
+    using _Mybase = exception;
+
+    explicit logic_error(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit logic_error(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD class _NODISCARD domain_error : public logic_error { // base of all domain-error exceptions
+public:
+    using _Mybase = logic_error;
+
+    explicit domain_error(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit domain_error(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD class _NODISCARD invalid_argument : public logic_error { // base of all invalid-argument exceptions
+public:
+    using _Mybase = logic_error;
+
+    explicit invalid_argument(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit invalid_argument(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD class _NODISCARD length_error : public logic_error { // base of all length-error exceptions
+public:
+    using _Mybase = logic_error;
+
+    explicit length_error(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit length_error(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD class _NODISCARD out_of_range : public logic_error { // base of all out-of-range exceptions
+public:
+    using _Mybase = logic_error;
+
+    explicit out_of_range(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit out_of_range(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD class _NODISCARD runtime_error : public exception { // base of all runtime-error exceptions
+public:
+    using _Mybase = exception;
+
+    explicit runtime_error(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit runtime_error(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD class _NODISCARD overflow_error : public runtime_error { // base of all overflow-error exceptions
+public:
+    using _Mybase = runtime_error;
+
+    explicit overflow_error(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit overflow_error(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD class _NODISCARD underflow_error : public runtime_error { // base of all underflow-error exceptions
+public:
+    using _Mybase = runtime_error;
+
+    explicit underflow_error(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit underflow_error(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+_EXPORT_STD class _NODISCARD range_error : public runtime_error { // base of all range-error exceptions
+public:
+    using _Mybase = runtime_error;
+
+    explicit range_error(const string& _Message) : _Mybase(_Message.c_str()) {}
+
+    explicit range_error(const char* _Message) : _Mybase(_Message) {}
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+[[noreturn]] inline void _Throw_range_error(const char* const _Message) {
+    _THROW(range_error{_Message});
+}
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STDEXCEPT_
diff --git a/msvc-stl/stl/inc/stdfloat b/msvc-stl/stl/inc/stdfloat
new file mode 100644
index 0000000..9c8835a
--- /dev/null
+++ b/msvc-stl/stl/inc/stdfloat
@@ -0,0 +1,35 @@
+// stdfloat standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STDFLOAT_
+#define _STDFLOAT_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX23
+_EMIT_STL_WARNING(STL4038, "The contents of <stdfloat> are available only with C++23 or later.");
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// We don't support any optional extended floating-point types, but we do need to provide an empty `namespace std`.
+// We don't need to `export` it for modules, as the other headers will implicitly do so (N4950 [module.interface]/2.1).
+_STD_BEGIN
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // ^^^ _HAS_CXX23 ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STDFLOAT_
diff --git a/msvc-stl/stl/inc/stop_token b/msvc-stl/stl/inc/stop_token
new file mode 100644
index 0000000..7444a69
--- /dev/null
+++ b/msvc-stl/stl/inc/stop_token
@@ -0,0 +1,399 @@
+// stop_token standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STOP_TOKEN_
+#define _STOP_TOKEN_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <stop_token> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+
+#include <atomic>
+#include <xmemory>
+#include <xthreads.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD struct nostopstate_t {
+    explicit nostopstate_t() = default;
+};
+
+_EXPORT_STD inline constexpr nostopstate_t nostopstate{};
+
+struct _Stop_state;
+_EXPORT_STD class stop_token;
+
+class _Stop_callback_base {
+    friend _Stop_state;
+
+private:
+    using _Callback_fn = void(__cdecl*)(_Stop_callback_base*) _NOEXCEPT_FNPTR;
+
+public:
+    explicit _Stop_callback_base(const _Callback_fn _Fn_) noexcept : _Fn{_Fn_} {}
+
+    _Stop_callback_base(const _Stop_callback_base&)            = delete;
+    _Stop_callback_base& operator=(const _Stop_callback_base&) = delete;
+
+protected:
+    // if _Token is _Stop_requested, calls the callback;
+    // otherwise, inserts *this into the callback list if stop is possible
+    inline void _Attach(const stop_token& _Token) noexcept;
+    inline void _Attach(stop_token&& _Token) noexcept;
+
+    // if *this is in a callback list, removes it
+    inline void _Detach() noexcept;
+
+private:
+    template <bool _Transfer_ownership>
+    void _Do_attach(conditional_t<_Transfer_ownership, _Stop_state*&, _Stop_state* const> _State) noexcept;
+
+protected:
+    _Stop_state* _Parent       = nullptr;
+    _Stop_callback_base* _Next = nullptr;
+    _Stop_callback_base* _Prev = nullptr;
+    _Callback_fn _Fn;
+};
+
+struct _Stop_state {
+    atomic<uint32_t> _Stop_tokens  = 1; // plus one shared by all stop_sources
+    atomic<uint32_t> _Stop_sources = 2; // plus the low order bit is the stop requested bit
+    _Locked_pointer<_Stop_callback_base> _Callbacks;
+    // always uses relaxed operations; ordering provided by the _Callbacks lock
+    // (atomic just to get wait/notify support)
+    atomic<const _Stop_callback_base*> _Current_callback = nullptr;
+    _Thrd_id_t _Stopping_thread                          = 0;
+
+    _NODISCARD bool _Stop_requested() const noexcept {
+        return (_Stop_sources.load() & uint32_t{1}) != 0;
+    }
+
+    _NODISCARD bool _Stop_possible() const noexcept {
+        return _Stop_sources.load() != 0;
+    }
+
+    _NODISCARD bool _Request_stop() noexcept {
+        // Attempts to request stop and call callbacks, returns whether request was successful
+        if ((_Stop_sources.fetch_or(uint32_t{1}) & uint32_t{1}) != 0) {
+            // another thread already requested
+            return false;
+        }
+
+        _Stopping_thread = _Thrd_id();
+        for (;;) {
+            auto _Head = _Callbacks._Lock_and_load();
+            _Current_callback.store(_Head, memory_order_relaxed);
+            _Current_callback.notify_all();
+            if (_Head == nullptr) {
+                _Callbacks._Store_and_unlock(nullptr);
+                return true;
+            }
+
+            const auto _Next = _STD exchange(_Head->_Next, nullptr);
+            _STL_INTERNAL_CHECK(_Head->_Prev == nullptr);
+            if (_Next != nullptr) {
+                _Next->_Prev = nullptr;
+            }
+
+            _Callbacks._Store_and_unlock(_Next); // unlock before running _Head so other registrations
+                                                 // can detach without blocking on the callback
+
+            _Head->_Fn(_Head); // might destroy *_Head
+        }
+    }
+};
+
+_EXPORT_STD class stop_source;
+
+_EXPORT_STD class stop_token {
+    friend stop_source;
+    friend _Stop_callback_base;
+
+public:
+    stop_token() noexcept : _State{} {}
+    stop_token(const stop_token& _Other) noexcept : _State{_Other._State} {
+        const auto _Local = _State;
+        if (_Local != nullptr) {
+            _Local->_Stop_tokens.fetch_add(1, memory_order_relaxed);
+        }
+    }
+
+    stop_token(stop_token&& _Other) noexcept : _State{_STD exchange(_Other._State, nullptr)} {}
+    stop_token& operator=(const stop_token& _Other) noexcept {
+        stop_token{_Other}.swap(*this);
+        return *this;
+    }
+
+    stop_token& operator=(stop_token&& _Other) noexcept {
+        stop_token{_STD move(_Other)}.swap(*this);
+        return *this;
+    }
+
+    ~stop_token() {
+        const auto _Local = _State;
+        if (_Local != nullptr) {
+            if (_Local->_Stop_tokens.fetch_sub(1, memory_order_acq_rel) == 1) {
+                delete _Local;
+            }
+        }
+    }
+
+    void swap(stop_token& _Other) noexcept {
+        _STD swap(_State, _Other._State);
+    }
+
+    _NODISCARD bool stop_requested() const noexcept {
+        const auto _Local = _State;
+        return _Local != nullptr && _Local->_Stop_requested();
+    }
+
+    _NODISCARD bool stop_possible() const noexcept {
+        const auto _Local = _State;
+        return _Local != nullptr && _Local->_Stop_possible();
+    }
+
+    _NODISCARD friend bool operator==(const stop_token& _Lhs, const stop_token& _Rhs) noexcept = default;
+
+    friend void swap(stop_token& _Lhs, stop_token& _Rhs) noexcept {
+        _STD swap(_Lhs._State, _Rhs._State);
+    }
+
+private:
+    explicit stop_token(_Stop_state* const _State_) : _State{_State_} {}
+
+    _Stop_state* _State;
+};
+
+_EXPORT_STD class stop_source {
+public:
+    stop_source() : _State{new _Stop_state} {}
+    explicit stop_source(nostopstate_t) noexcept : _State{} {}
+    stop_source(const stop_source& _Other) noexcept : _State{_Other._State} {
+        const auto _Local = _State;
+        if (_Local != nullptr) {
+            _Local->_Stop_sources.fetch_add(2, memory_order_relaxed);
+        }
+    }
+
+    stop_source(stop_source&& _Other) noexcept : _State{_STD exchange(_Other._State, nullptr)} {}
+    stop_source& operator=(const stop_source& _Other) noexcept {
+        stop_source{_Other}.swap(*this);
+        return *this;
+    }
+
+    stop_source& operator=(stop_source&& _Other) noexcept {
+        stop_source{_STD move(_Other)}.swap(*this);
+        return *this;
+    }
+
+    ~stop_source() {
+        const auto _Local = _State;
+        if (_Local != nullptr) {
+            if ((_Local->_Stop_sources.fetch_sub(2, memory_order_acq_rel) >> 1) == 1) {
+                if (_Local->_Stop_tokens.fetch_sub(1, memory_order_acq_rel) == 1) {
+                    delete _Local;
+                }
+            }
+        }
+    }
+
+    void swap(stop_source& _Other) noexcept {
+        _STD swap(_State, _Other._State);
+    }
+
+    _NODISCARD stop_token get_token() const noexcept {
+        const auto _Local = _State;
+        if (_Local != nullptr) {
+            _Local->_Stop_tokens.fetch_add(1, memory_order_relaxed);
+        }
+
+        return stop_token{_Local};
+    }
+
+    _NODISCARD bool stop_requested() const noexcept {
+        const auto _Local = _State;
+        return _Local != nullptr && _Local->_Stop_requested();
+    }
+
+    _NODISCARD bool stop_possible() const noexcept {
+        return _State != nullptr;
+    }
+
+    bool request_stop() noexcept {
+        const auto _Local = _State;
+        return _Local && _Local->_Request_stop();
+    }
+
+    _NODISCARD friend bool operator==(const stop_source& _Lhs, const stop_source& _Rhs) noexcept = default;
+
+    friend void swap(stop_source& _Lhs, stop_source& _Rhs) noexcept {
+        _STD swap(_Lhs._State, _Rhs._State);
+    }
+
+private:
+    _Stop_state* _State;
+};
+
+template <bool _Transfer_ownership>
+void _Stop_callback_base::_Do_attach(
+    conditional_t<_Transfer_ownership, _Stop_state*&, _Stop_state* const> _State_raw) noexcept {
+    const auto _State = _State_raw; // avoid an indirection in all of the below
+    if (_State == nullptr) {
+        return;
+    }
+
+    // fast path check if the state is already known
+    auto _Local_sources = _State->_Stop_sources.load();
+    if ((_Local_sources & uint32_t{1}) != 0) {
+        // stop already requested
+        _Fn(this);
+        return;
+    }
+
+    if (_Local_sources == 0) {
+        return; // stop not possible
+    }
+
+    // fast path doesn't know, so try to insert
+    auto _Head = _State->_Callbacks._Lock_and_load();
+    // recheck the state in case it changed while we were waiting to acquire the lock
+    _Local_sources = _State->_Stop_sources.load();
+    if ((_Local_sources & uint32_t{1}) != 0) {
+        // stop already requested
+        _State->_Callbacks._Store_and_unlock(_Head);
+        _Fn(this);
+        return;
+    }
+
+    if (_Local_sources != 0) {
+        // stop possible, do the insert
+        _Parent = _State;
+        _Next   = _Head;
+        if constexpr (_Transfer_ownership) {
+            _State_raw = nullptr;
+        } else {
+            _State->_Stop_tokens.fetch_add(1, memory_order_relaxed);
+        }
+
+        if (_Head != nullptr) {
+            _Head->_Prev = this;
+        }
+
+        _Head = this;
+    }
+
+    _State->_Callbacks._Store_and_unlock(_Head);
+}
+
+inline void _Stop_callback_base::_Attach(const stop_token& _Token) noexcept {
+    this->_Do_attach<false>(_Token._State);
+}
+
+inline void _Stop_callback_base::_Attach(stop_token&& _Token) noexcept {
+    this->_Do_attach<true>(_Token._State);
+}
+
+inline void _Stop_callback_base::_Detach() noexcept {
+    stop_token _Token{_Parent}; // transfers ownership
+    if (_Token._State == nullptr) {
+        // callback was never inserted into the list
+        return;
+    }
+
+    auto _Head = _Token._State->_Callbacks._Lock_and_load();
+    if (this == _Head) {
+        // we are still in the list, so the callback is not being request_stop'd
+        const auto _Local_next = _Next;
+        if (_Local_next != nullptr) {
+            _Local_next->_Prev = nullptr;
+        }
+
+        _STL_INTERNAL_CHECK(_Prev == nullptr);
+        _Token._State->_Callbacks._Store_and_unlock(_Next);
+        return;
+    }
+
+    const auto _Local_prev = _Prev;
+    if (_Local_prev != nullptr) {
+        // we are still in the list, so the callback is not being request_stop'd, and there is at least one other
+        // callback still registered
+        const auto _Local_next = _Next;
+        if (_Local_next != nullptr) {
+            _Next->_Prev = _Local_prev;
+        }
+
+        _Prev->_Next = _Local_next;
+        _Token._State->_Callbacks._Store_and_unlock(_Head);
+        return;
+    }
+
+    // we aren't in the callback list even though we were added to it, so the stop requesting thread is attempting to
+    // call the callback
+    _STL_INTERNAL_CHECK((_Token._State->_Stop_sources.load() & uint32_t{1}) != 0);
+    if (_Token._State->_Current_callback.load(memory_order_acquire) != this
+        || _Token._State->_Stopping_thread == _Thrd_id()) {
+        // the callback is done or the dtor is being recursively reentered, do not block
+        _Token._State->_Callbacks._Store_and_unlock(_Head);
+        return;
+    }
+
+    // the callback is being executed by another thread, block until it is complete
+    _Token._State->_Callbacks._Store_and_unlock(_Head);
+    _Token._State->_Current_callback.wait(this, memory_order_acquire);
+}
+
+_EXPORT_STD template <class _Callback>
+class stop_callback : public _Stop_callback_base {
+public:
+    using callback_type = _Callback;
+
+    template <class _CbInitTy>
+        requires is_constructible_v<_Callback, _CbInitTy>
+    explicit stop_callback(const stop_token& _Token, _CbInitTy&& _Cb_)
+        noexcept(is_nothrow_constructible_v<_Callback, _CbInitTy>)
+        : _Stop_callback_base{_Invoke_by_stop}, _Cb(_STD forward<_CbInitTy>(_Cb_)) {
+        _Attach(_Token);
+    }
+
+    template <class _CbInitTy>
+        requires is_constructible_v<_Callback, _CbInitTy>
+    explicit stop_callback(stop_token&& _Token, _CbInitTy&& _Cb_)
+        noexcept(is_nothrow_constructible_v<_Callback, _CbInitTy>)
+        : _Stop_callback_base{_Invoke_by_stop}, _Cb(_STD forward<_CbInitTy>(_Cb_)) {
+        _Attach(_STD move(_Token));
+    }
+
+    ~stop_callback() {
+        _Detach();
+    }
+
+private:
+    static void __cdecl _Invoke_by_stop(_Stop_callback_base* const _This) noexcept // terminates
+    {
+        _STD forward<_Callback>(static_cast<stop_callback*>(_This)->_Cb)();
+    }
+
+    _Callback _Cb;
+};
+
+template <class _Callback>
+stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;
+
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STOP_TOKEN_
diff --git a/msvc-stl/stl/inc/streambuf b/msvc-stl/stl/inc/streambuf
new file mode 100644
index 0000000..92ad96c
--- /dev/null
+++ b/msvc-stl/stl/inc/streambuf
@@ -0,0 +1,419 @@
+// streambuf standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STREAMBUF_
+#define _STREAMBUF_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xiosbase>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD extern "C++" template <class _Elem, class _Traits>
+class basic_streambuf { // control read/write buffers
+protected:
+    __CLR_OR_THIS_CALL basic_streambuf() : _Plocale(new locale) {
+        _Init();
+    }
+
+    __CLR_OR_THIS_CALL basic_streambuf(_Uninitialized) noexcept {}
+
+    __CLR_OR_THIS_CALL basic_streambuf(const basic_streambuf& _Right) : _Plocale(new locale{_Right.getloc()}) {
+        _Init();
+        setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
+        setg(_Right.eback(), _Right.gptr(), _Right.egptr());
+    }
+
+    basic_streambuf& __CLR_OR_THIS_CALL operator=(const basic_streambuf& _Right) {
+        if (this != _STD addressof(_Right)) {
+            setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
+            setg(_Right.eback(), _Right.gptr(), _Right.egptr());
+            pubimbue(_Right.getloc());
+        }
+        return *this;
+    }
+
+    void __CLR_OR_THIS_CALL swap(basic_streambuf& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Elem* _Pfirst0 = pbase();
+            _Elem* _Pnext0  = pptr();
+            _Elem* _Pend    = epptr();
+            _Elem* _Gfirst0 = eback();
+            _Elem* _Gnext0  = gptr();
+            _Elem* _Gend    = egptr();
+
+            setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
+            _Right.setp(_Pfirst0, _Pnext0, _Pend);
+
+            setg(_Right.eback(), _Right.gptr(), _Right.egptr());
+            _Right.setg(_Gfirst0, _Gnext0, _Gend);
+
+            _STD swap(_Plocale, _Right._Plocale);
+        }
+    }
+
+public:
+    using char_type   = _Elem;
+    using traits_type = _Traits;
+
+    virtual __CLR_OR_THIS_CALL ~basic_streambuf() noexcept {
+        delete _Plocale;
+    }
+
+    using int_type = typename _Traits::int_type;
+    using pos_type = typename _Traits::pos_type;
+    using off_type = typename _Traits::off_type;
+
+    pos_type __CLR_OR_THIS_CALL pubseekoff(off_type _Off, ios_base::seekdir _Way,
+        ios_base::openmode _Mode = ios_base::in | ios_base::out) { // change position by _Off, according to _Way, _Mode
+        return seekoff(_Off, _Way, _Mode);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    pos_type __CLR_OR_THIS_CALL pubseekoff(off_type _Off, ios_base::seek_dir _Way,
+        ios_base::open_mode _Mode) { // change position by _Off, according to _Way, _Mode (old style)
+        return pubseekoff(_Off, static_cast<ios_base::seekdir>(_Way), static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    pos_type __CLR_OR_THIS_CALL pubseekpos(pos_type _Pos,
+        ios_base::openmode _Mode = ios_base::in | ios_base::out) { // change position to _Pos, according to _Mode
+        return seekpos(_Pos, _Mode);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    pos_type __CLR_OR_THIS_CALL pubseekpos(pos_type _Pos,
+        ios_base::open_mode _Mode) { // change position to _Pos, according to _Mode (old style)
+        return seekpos(_Pos, static_cast<ios_base::openmode>(_Mode));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    basic_streambuf* __CLR_OR_THIS_CALL pubsetbuf(_Elem* _Buffer,
+        streamsize _Count) { // offer _Buffer to external agent
+        return setbuf(_Buffer, _Count);
+    }
+
+    locale __CLR_OR_THIS_CALL pubimbue(const locale& _Newlocale) { // set locale to argument
+        locale _Oldlocale = *_Plocale;
+        imbue(_Newlocale);
+        *_Plocale = _Newlocale;
+        return _Oldlocale;
+    }
+
+    locale __CLR_OR_THIS_CALL getloc() const noexcept /* strengthened */ { // get locale
+        return *_Plocale;
+    }
+
+    streamsize __CLR_OR_THIS_CALL in_avail() {
+        streamsize _Res = _Gnavail();
+        return 0 < _Res ? _Res : showmanyc();
+    }
+
+    int __CLR_OR_THIS_CALL pubsync() { // synchronize with external agent
+        return sync();
+    }
+
+    int_type __CLR_OR_THIS_CALL sbumpc() { // get a character and point past it
+        return 0 < _Gnavail() ? _Traits::to_int_type(*_Gninc()) : uflow();
+    }
+
+    int_type __CLR_OR_THIS_CALL sgetc() { // get a character and don't point past it
+        return 0 < _Gnavail() ? _Traits::to_int_type(*gptr()) : underflow();
+    }
+
+    streamsize __CLR_OR_THIS_CALL sgetn(_Elem* _Ptr,
+        streamsize _Count) { // get up to _Count characters into array beginning at _Ptr
+        return xsgetn(_Ptr, _Count);
+    }
+
+    int_type __CLR_OR_THIS_CALL snextc() { // point to next character and return it
+        return 1 < _Gnavail()                                 ? _Traits::to_int_type(*_Gnpreinc())
+             : _Traits::eq_int_type(_Traits::eof(), sbumpc()) ? _Traits::eof()
+                                                              : sgetc();
+    }
+
+    int_type __CLR_OR_THIS_CALL sputbackc(_Elem _Ch) { // put back _Ch
+        if (gptr() && eback() < gptr() && _Traits::eq(_Ch, gptr()[-1])) {
+            return _Traits::to_int_type(*_Gndec());
+        }
+
+        return pbackfail(_Traits::to_int_type(_Ch));
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL stossc() { // point past a character
+        if (0 < _Gnavail()) {
+            _Gninc();
+        } else {
+            uflow();
+        }
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    int_type __CLR_OR_THIS_CALL sungetc() { // back up one position
+        return gptr() && eback() < gptr() ? _Traits::to_int_type(*_Gndec()) : pbackfail();
+    }
+
+    int_type __CLR_OR_THIS_CALL sputc(_Elem _Ch) { // put a character
+        return 0 < _Pnavail() ? _Traits::to_int_type(*_Pninc() = _Ch) : overflow(_Traits::to_int_type(_Ch));
+    }
+
+    streamsize __CLR_OR_THIS_CALL sputn(const _Elem* _Ptr,
+        streamsize _Count) { // put _Count characters from array beginning at _Ptr
+        return xsputn(_Ptr, _Count);
+    }
+
+    virtual void __CLR_OR_THIS_CALL _Lock() {} // set the thread lock (overridden by basic_filebuf)
+
+    virtual void __CLR_OR_THIS_CALL _Unlock() {} // clear the thread lock (overridden by basic_filebuf)
+
+protected:
+    _Elem* __CLR_OR_THIS_CALL eback() const noexcept /* strengthened */ {
+        return *_IGfirst;
+    }
+
+    _Elem* __CLR_OR_THIS_CALL gptr() const noexcept /* strengthened */ {
+        return *_IGnext;
+    }
+
+    _Elem* __CLR_OR_THIS_CALL pbase() const noexcept /* strengthened */ {
+        return *_IPfirst;
+    }
+
+    _Elem* __CLR_OR_THIS_CALL pptr() const noexcept /* strengthened */ {
+        return *_IPnext;
+    }
+
+    _Elem* __CLR_OR_THIS_CALL egptr() const noexcept /* strengthened */ {
+        return *_IGnext + *_IGcount;
+    }
+
+    void __CLR_OR_THIS_CALL gbump(int _Off) noexcept /* strengthened */ {
+        // alter current position in read buffer by _Off
+        *_IGcount -= _Off;
+        *_IGnext += _Off;
+    }
+
+    void __CLR_OR_THIS_CALL setg(_Elem* _First, _Elem* _Next, _Elem* _Last) noexcept /* strengthened */ {
+        // set pointers for read buffer
+        *_IGfirst = _First;
+        *_IGnext  = _Next;
+        *_IGcount = static_cast<int>(_Last - _Next);
+    }
+
+    _Elem* __CLR_OR_THIS_CALL epptr() const noexcept /* strengthened */ {
+        return *_IPnext + *_IPcount;
+    }
+
+    _Elem* __CLR_OR_THIS_CALL _Gndec() noexcept { // decrement current position in read buffer
+        ++*_IGcount;
+        return --*_IGnext;
+    }
+
+    _Elem* __CLR_OR_THIS_CALL _Gninc() noexcept { // increment current position in read buffer
+        --*_IGcount;
+        return (*_IGnext)++;
+    }
+
+    _Elem* __CLR_OR_THIS_CALL _Gnpreinc() noexcept { // preincrement current position in read buffer
+        --*_IGcount;
+        return ++(*_IGnext);
+    }
+
+    streamsize __CLR_OR_THIS_CALL _Gnavail() const noexcept { // count number of available elements in read buffer
+        return *_IGnext ? *_IGcount : 0;
+    }
+
+    void __CLR_OR_THIS_CALL pbump(int _Off) noexcept /* strengthened */ {
+        // alter current position in write buffer by _Off
+        *_IPcount -= _Off;
+        *_IPnext += _Off;
+    }
+
+    void __CLR_OR_THIS_CALL setp(_Elem* _First, _Elem* _Last) noexcept /* strengthened */ {
+        // set pointers for write buffer
+        *_IPfirst = _First;
+        *_IPnext  = _First;
+        *_IPcount = static_cast<int>(_Last - _First);
+    }
+
+    void __CLR_OR_THIS_CALL setp(_Elem* _First, _Elem* _Next, _Elem* _Last) noexcept /* strengthened */ {
+        // set pointers for write buffer, extended version
+        *_IPfirst = _First;
+        *_IPnext  = _Next;
+        *_IPcount = static_cast<int>(_Last - _Next);
+    }
+
+    _Elem* __CLR_OR_THIS_CALL _Pninc() noexcept { // increment current position in write buffer
+        --*_IPcount;
+        return (*_IPnext)++;
+    }
+
+    streamsize __CLR_OR_THIS_CALL _Pnavail() const noexcept { // count number of available positions in write buffer
+        return *_IPnext ? *_IPcount : 0;
+    }
+
+    void __CLR_OR_THIS_CALL _Init() noexcept { // initialize buffer parameters for no buffers
+        _IGfirst = &_Gfirst;
+        _IPfirst = &_Pfirst;
+        _IGnext  = &_Gnext;
+        _IPnext  = &_Pnext;
+        _IGcount = &_Gcount;
+        _IPcount = &_Pcount;
+        setp(nullptr, nullptr);
+        setg(nullptr, nullptr, nullptr);
+    }
+
+    void __CLR_OR_THIS_CALL _Init(_Elem** _Gf, _Elem** _Gn, int* _Gc, _Elem** _Pf, _Elem** _Pn, int* _Pc) noexcept {
+        // initialize buffer parameters as specified
+        _IGfirst = _Gf;
+        _IPfirst = _Pf;
+        _IGnext  = _Gn;
+        _IPnext  = _Pn;
+        _IGcount = _Gc;
+        _IPcount = _Pc;
+    }
+
+    virtual int_type __CLR_OR_THIS_CALL overflow(int_type = _Traits::eof()) { // put a character to stream (always fail)
+        return _Traits::eof();
+    }
+
+    virtual int_type __CLR_OR_THIS_CALL pbackfail(int_type = _Traits::eof()) {
+        // put a character back to stream (always fail)
+        return _Traits::eof();
+    }
+
+    virtual streamsize __CLR_OR_THIS_CALL showmanyc() {
+        return 0;
+    }
+
+    virtual int_type __CLR_OR_THIS_CALL underflow() { // get a character from stream, but don't point past it
+        return _Traits::eof();
+    }
+
+    virtual int_type __CLR_OR_THIS_CALL uflow() { // get a character from stream, point past it
+        return _Traits::eq_int_type(_Traits::eof(), underflow()) ? _Traits::eof() : _Traits::to_int_type(*_Gninc());
+    }
+
+    virtual streamsize __CLR_OR_THIS_CALL xsgetn(_Elem* _Ptr, streamsize _Count) { // get _Count characters from stream
+        const streamsize _Start_count = _Count;
+
+        while (0 < _Count) {
+            streamsize _Size = _Gnavail();
+            if (0 < _Size) { // copy from read buffer
+                if (_Count < _Size) {
+                    _Size = _Count;
+                }
+
+                _Traits::copy(_Ptr, gptr(), static_cast<size_t>(_Size));
+                _Ptr += _Size;
+                _Count -= _Size;
+                gbump(static_cast<int>(_Size));
+            } else {
+                const int_type _Meta = uflow();
+                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+                    break; // end of file, quit
+                }
+
+                // get a single character
+                *_Ptr++ = _Traits::to_char_type(_Meta);
+                --_Count;
+            }
+        }
+
+        return _Start_count - _Count;
+    }
+
+    virtual streamsize __CLR_OR_THIS_CALL xsputn(const _Elem* _Ptr, streamsize _Count) {
+        // put _Count characters to stream
+        const streamsize _Start_count = _Count;
+        while (0 < _Count) {
+            streamsize _Size = _Pnavail();
+            if (0 < _Size) { // copy to write buffer
+                if (_Count < _Size) {
+                    _Size = _Count;
+                }
+
+                _Traits::copy(pptr(), _Ptr, static_cast<size_t>(_Size));
+                _Ptr += _Size;
+                _Count -= _Size;
+                pbump(static_cast<int>(_Size));
+            } else if (_Traits::eq_int_type(_Traits::eof(), overflow(_Traits::to_int_type(*_Ptr)))) {
+                break; // single character put failed, quit
+            } else { // count character successfully put
+                ++_Ptr;
+                --_Count;
+            }
+        }
+
+        return _Start_count - _Count;
+    }
+
+    virtual pos_type __CLR_OR_THIS_CALL seekoff(
+        off_type, ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out) {
+        // change position by offset, according to way and mode
+        return pos_type{off_type{-1}};
+    }
+
+    virtual pos_type __CLR_OR_THIS_CALL seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out) {
+        // change to specified position, according to mode
+        return pos_type{off_type{-1}};
+    }
+
+    virtual basic_streambuf* __CLR_OR_THIS_CALL setbuf(_Elem*, streamsize) {
+        // offer buffer to external agent (do nothing)
+        return this;
+    }
+
+    virtual int __CLR_OR_THIS_CALL sync() { // synchronize with external agent (do nothing)
+        return 0;
+    }
+
+    virtual void __CLR_OR_THIS_CALL imbue(const locale&) {} // set locale to argument (do nothing)
+
+private:
+    _Elem* _Gfirst{}; // beginning of read buffer
+    _Elem* _Pfirst{}; // beginning of write buffer
+    _Elem** _IGfirst{}; // pointer to beginning of read buffer
+    _Elem** _IPfirst{}; // pointer to beginning of write buffer
+    _Elem* _Gnext{}; // current position in read buffer
+    _Elem* _Pnext{}; // current position in write buffer
+    _Elem** _IGnext{}; // pointer to current position in read buffer
+    _Elem** _IPnext{}; // pointer to current position in write buffer
+
+    int _Gcount{}; // length of read buffer
+    int _Pcount{}; // length of write buffer
+    int* _IGcount{}; // pointer to length of read buffer
+    int* _IPcount{}; // pointer to length of write buffer
+
+protected:
+    locale* _Plocale{}; // pointer to imbued locale object
+};
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT basic_streambuf<char, char_traits<char>>;
+template class _CRTIMP2_PURE_IMPORT basic_streambuf<wchar_t, char_traits<wchar_t>>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template class _CRTIMP2_PURE_IMPORT basic_streambuf<unsigned short, char_traits<unsigned short>>;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STREAMBUF_
diff --git a/msvc-stl/stl/inc/string b/msvc-stl/stl/inc/string
new file mode 100644
index 0000000..118f976
--- /dev/null
+++ b/msvc-stl/stl/inc/string
@@ -0,0 +1,548 @@
+// string standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STRING_
+#define _STRING_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+// The <cctype> include below is to workaround many projects that assumed
+// <string> includes it. We workaround it instead of fixing all the upstream
+// projects because <cctype> is inexpensive. See VSO-663136.
+
+#include <cctype> // TRANSITION, see note
+#include <xstring>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+basic_istream<_Elem, _Traits>& getline(
+    basic_istream<_Elem, _Traits>&& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str, const _Elem _Delim) {
+    // get characters into string, discard delimiter
+    using _Myis = basic_istream<_Elem, _Traits>;
+
+    typename _Myis::iostate _State = _Myis::goodbit;
+    bool _Changed                  = false;
+    const typename _Myis::sentry _Ok(_Istr, true);
+
+    if (_Ok) { // state okay, extract characters
+        _TRY_IO_BEGIN
+        _Str.erase();
+        const typename _Traits::int_type _Metadelim = _Traits::to_int_type(_Delim);
+        typename _Traits::int_type _Meta            = _Istr.rdbuf()->sgetc();
+
+        for (;; _Meta = _Istr.rdbuf()->snextc()) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                _State |= _Myis::eofbit;
+                break;
+            } else if (_Traits::eq_int_type(_Meta, _Metadelim)) { // got a delimiter, discard it and quit
+                _Changed = true;
+                _Istr.rdbuf()->sbumpc();
+                break;
+            } else if (_Str.max_size() <= _Str.size()) { // string too large, quit
+                _State |= _Myis::failbit;
+                break;
+            } else { // got a character, add it to string
+                _Str += _Traits::to_char_type(_Meta);
+                _Changed = true;
+            }
+        }
+        _CATCH_IO_(_Myis, _Istr)
+    }
+
+    if (!_Changed) {
+        _State |= _Myis::failbit;
+    }
+
+    _Istr.setstate(_State);
+    return static_cast<basic_istream<_Elem, _Traits>&>(_Istr);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+basic_istream<_Elem, _Traits>& getline(
+    basic_istream<_Elem, _Traits>&& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str) {
+    // get characters into string, discard newline
+    return _STD getline(_STD move(_Istr), _Str, _Istr.widen('\n'));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+basic_istream<_Elem, _Traits>& getline(
+    basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str, const _Elem _Delim) {
+    // get characters into string, discard delimiter
+    return _STD getline(_STD move(_Istr), _Str, _Delim);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+basic_istream<_Elem, _Traits>& getline(
+    basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str) {
+    // get characters into string, discard newline
+    return _STD getline(_STD move(_Istr), _Str, _Istr.widen('\n'));
+}
+
+_EXPORT_STD _NODISCARD inline int stoi(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref  = errno; // Nonzero cost, pay it once
+    const char* _Ptr = _Str.c_str();
+    char* _Eptr;
+    _Errno_ref      = 0;
+    const long _Ans = _CSTD strtol(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stoi argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stoi argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return static_cast<int>(_Ans);
+}
+
+_EXPORT_STD _NODISCARD inline long stol(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref  = errno; // Nonzero cost, pay it once
+    const char* _Ptr = _Str.c_str();
+    char* _Eptr;
+    _Errno_ref      = 0;
+    const long _Ans = _CSTD strtol(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stol argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stol argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline unsigned long stoul(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref  = errno; // Nonzero cost, pay it once
+    const char* _Ptr = _Str.c_str();
+    char* _Eptr;
+    _Errno_ref               = 0;
+    const unsigned long _Ans = _CSTD strtoul(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stoul argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stoul argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline long long stoll(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref  = errno; // Nonzero cost, pay it once
+    const char* _Ptr = _Str.c_str();
+    char* _Eptr;
+    _Errno_ref           = 0;
+    const long long _Ans = _CSTD strtoll(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stoll argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stoll argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline unsigned long long stoull(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref  = errno; // Nonzero cost, pay it once
+    const char* _Ptr = _Str.c_str();
+    char* _Eptr;
+    _Errno_ref                    = 0;
+    const unsigned long long _Ans = _CSTD strtoull(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stoull argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stoull argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline float stof(const string& _Str, size_t* _Idx = nullptr) {
+    int& _Errno_ref  = errno; // Nonzero cost, pay it once
+    const char* _Ptr = _Str.c_str();
+    char* _Eptr;
+    _Errno_ref       = 0;
+    const float _Ans = _CSTD strtof(_Ptr, &_Eptr);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stof argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stof argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline double stod(const string& _Str, size_t* _Idx = nullptr) {
+    int& _Errno_ref  = errno; // Nonzero cost, pay it once
+    const char* _Ptr = _Str.c_str();
+    char* _Eptr;
+    _Errno_ref        = 0;
+    const double _Ans = _CSTD strtod(_Ptr, &_Eptr);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stod argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stod argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline long double stold(const string& _Str, size_t* _Idx = nullptr) {
+    int& _Errno_ref  = errno; // Nonzero cost, pay it once
+    const char* _Ptr = _Str.c_str();
+    char* _Eptr;
+    _Errno_ref             = 0;
+    const long double _Ans = _CSTD strtold(_Ptr, &_Eptr);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stold argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stold argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline int stoi(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref     = errno; // Nonzero cost, pay it once
+    const wchar_t* _Ptr = _Str.c_str();
+    wchar_t* _Eptr;
+    _Errno_ref      = 0;
+    const long _Ans = _CSTD wcstol(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stoi argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stoi argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return static_cast<int>(_Ans);
+}
+
+_EXPORT_STD _NODISCARD inline long stol(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref     = errno; // Nonzero cost, pay it once
+    const wchar_t* _Ptr = _Str.c_str();
+    wchar_t* _Eptr;
+    _Errno_ref      = 0;
+    const long _Ans = _CSTD wcstol(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stol argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stol argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline unsigned long stoul(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref     = errno; // Nonzero cost, pay it once
+    const wchar_t* _Ptr = _Str.c_str();
+    wchar_t* _Eptr;
+    _Errno_ref               = 0;
+    const unsigned long _Ans = _CSTD wcstoul(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stoul argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stoul argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline long long stoll(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref     = errno; // Nonzero cost, pay it once
+    const wchar_t* _Ptr = _Str.c_str();
+    wchar_t* _Eptr;
+    _Errno_ref           = 0;
+    const long long _Ans = _CSTD wcstoll(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stoll argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stoll argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline unsigned long long stoull(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
+    int& _Errno_ref     = errno; // Nonzero cost, pay it once
+    const wchar_t* _Ptr = _Str.c_str();
+    wchar_t* _Eptr;
+    _Errno_ref                    = 0;
+    const unsigned long long _Ans = _CSTD wcstoull(_Ptr, &_Eptr, _Base);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stoull argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stoull argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline float stof(const wstring& _Str, size_t* _Idx = nullptr) {
+    int& _Errno_ref     = errno; // Nonzero cost, pay it once
+    const wchar_t* _Ptr = _Str.c_str();
+    wchar_t* _Eptr;
+    _Errno_ref       = 0;
+    const float _Ans = _CSTD wcstof(_Ptr, &_Eptr);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stof argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stof argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline double stod(const wstring& _Str, size_t* _Idx = nullptr) {
+    int& _Errno_ref     = errno; // Nonzero cost, pay it once
+    const wchar_t* _Ptr = _Str.c_str();
+    wchar_t* _Eptr;
+    _Errno_ref        = 0;
+    const double _Ans = _CSTD wcstod(_Ptr, &_Eptr);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stod argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stod argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+_EXPORT_STD _NODISCARD inline long double stold(const wstring& _Str, size_t* _Idx = nullptr) {
+    int& _Errno_ref     = errno; // Nonzero cost, pay it once
+    const wchar_t* _Ptr = _Str.c_str();
+    wchar_t* _Eptr;
+    _Errno_ref             = 0;
+    const long double _Ans = _CSTD wcstold(_Ptr, &_Eptr);
+
+    if (_Ptr == _Eptr) {
+        _Xinvalid_argument("invalid stold argument");
+    }
+
+    if (_Errno_ref == ERANGE) {
+        _Xout_of_range("stold argument out of range");
+    }
+
+    if (_Idx) {
+        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
+    }
+
+    return _Ans;
+}
+
+template <class _Elem, class _Ty>
+_NODISCARD basic_string<_Elem> _Integral_to_string(const _Ty _Val) {
+    // convert _Val to string
+    static_assert(is_integral_v<_Ty>, "_Ty must be integral");
+    _Elem _Buff[21]; // can hold -2^63 and 2^64 - 1, plus NUL
+    _Elem* const _Buff_end = _STD end(_Buff);
+    _Elem* _RNext          = _Buff_end;
+
+    if constexpr (is_signed_v<_Ty>) {
+        const auto _UVal = static_cast<make_unsigned_t<_Ty>>(_Val);
+        if (_Val < 0) {
+            _RNext    = _UIntegral_to_buff(_RNext, 0 - _UVal);
+            *--_RNext = '-';
+        } else {
+            _RNext = _UIntegral_to_buff(_RNext, _UVal);
+        }
+    } else {
+        _RNext = _UIntegral_to_buff(_RNext, _Val);
+    }
+
+    return basic_string<_Elem>(_RNext, _Buff_end);
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(int _Val) {
+    return _Integral_to_string<char>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(unsigned int _Val) {
+    return _Integral_to_string<char>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(long _Val) {
+    return _Integral_to_string<char>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(unsigned long _Val) {
+    return _Integral_to_string<char>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(long long _Val) {
+    return _Integral_to_string<char>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(unsigned long long _Val) {
+    return _Integral_to_string<char>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(double _Val) {
+    const auto _Len = static_cast<size_t>(_CSTD _scprintf("%f", _Val));
+    string _Str(_Len, '\0');
+    _CSTD sprintf_s(&_Str[0], _Len + 1, "%f", _Val);
+    return _Str;
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(float _Val) {
+    return _STD to_string(static_cast<double>(_Val));
+}
+
+_EXPORT_STD _NODISCARD inline string to_string(long double _Val) {
+    return _STD to_string(static_cast<double>(_Val));
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(int _Val) {
+    return _Integral_to_string<wchar_t>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(unsigned int _Val) {
+    return _Integral_to_string<wchar_t>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(long _Val) {
+    return _Integral_to_string<wchar_t>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(unsigned long _Val) {
+    return _Integral_to_string<wchar_t>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(long long _Val) {
+    return _Integral_to_string<wchar_t>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(unsigned long long _Val) {
+    return _Integral_to_string<wchar_t>(_Val);
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(double _Val) {
+    const auto _Len = static_cast<size_t>(_CSTD _scwprintf(L"%f", _Val));
+    wstring _Str(_Len, L'\0');
+    _CSTD swprintf_s(&_Str[0], _Len + 1, L"%f", _Val);
+    return _Str;
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(float _Val) {
+    return _STD to_wstring(static_cast<double>(_Val));
+}
+
+_EXPORT_STD _NODISCARD inline wstring to_wstring(long double _Val) {
+    return _STD to_wstring(static_cast<double>(_Val));
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STRING_
diff --git a/msvc-stl/stl/inc/string_view b/msvc-stl/stl/inc/string_view
new file mode 100644
index 0000000..ca46502
--- /dev/null
+++ b/msvc-stl/stl/inc/string_view
@@ -0,0 +1,22 @@
+// string_view standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STRING_VIEW_
+#define _STRING_VIEW_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <string_view> are available only with C++17 or later.");
+#else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#ifdef _LEGACY_CODE_ASSUMES_STRING_VIEW_INCLUDES_XSTRING
+#include <xstring>
+#else // ^^^ defined(_LEGACY_CODE_ASSUMES_STRING_VIEW_INCLUDES_XSTRING) /
+      // !defined(_LEGACY_CODE_ASSUMES_STRING_VIEW_INCLUDES_XSTRING) vvv
+#include <__msvc_string_view.hpp>
+#endif // ^^^ !defined(_LEGACY_CODE_ASSUMES_STRING_VIEW_INCLUDES_XSTRING) ^^^
+#endif // ^^^ _HAS_CXX17 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STRING_VIEW_
diff --git a/msvc-stl/stl/inc/strstream b/msvc-stl/stl/inc/strstream
new file mode 100644
index 0000000..e5a28f3
--- /dev/null
+++ b/msvc-stl/stl/inc/strstream
@@ -0,0 +1,627 @@
+// strstream standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STRSTREAM_
+#define _STRSTREAM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <istream>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD class _CXX17_DEPRECATE_STRSTREAM strstreambuf : public streambuf {
+    // stream buffer associated with static or allocated character array
+public:
+    using _Mysb = streambuf;
+    enum { // constants for bits in stream state
+        _Allocated = 1, // set if character array storage has been allocated
+        _Constant  = 2, // set if character array immutable
+        _Dynamic   = 4, // set if character array length grows on demand
+        _Frozen    = 8
+    }; // set if character array ownership given away
+    using _Strstate = int;
+
+    __CLR_OR_THIS_CALL strstreambuf() { // construct with empty character array
+        _Init(0);
+    }
+
+    explicit __CLR_OR_THIS_CALL strstreambuf(streamsize _Count) { // construct with suggested initial size
+        _Init(_Count);
+    }
+
+    __CLR_OR_THIS_CALL strstreambuf(
+        void*(__CLRCALL_OR_CDECL* _Allocfunc)(size_t), void(__CLRCALL_OR_CDECL* _Freefunc)(void*)) {
+        // construct with empty character array, allocation functions
+        _Init();
+        _Palloc = _Allocfunc;
+        _Pfree  = _Freefunc;
+    }
+
+    __CLR_OR_THIS_CALL strstreambuf(_In_opt_z_ char* _Getptr, streamsize _Count, _In_opt_z_ char* _Putptr = nullptr) {
+        // construct with [_Getptr, _Getptr + _Count), possibly mutable
+        _Init(_Count, _Getptr, _Putptr);
+    }
+
+    __CLR_OR_THIS_CALL strstreambuf(_In_z_ const char* _Getptr, streamsize _Count) {
+        // construct with [_Getptr, _Getptr + _Count), immutable
+        _Init(_Count, const_cast<char*>(_Getptr), nullptr, _Constant);
+    }
+
+    __CLR_OR_THIS_CALL strstreambuf(
+        _In_opt_z_ unsigned char* _Getptr, streamsize _Count, _In_opt_z_ unsigned char* _Putptr = nullptr) {
+        // construct with [_Getptr, _Getptr + _Count), possibly mutable
+        _Init(_Count, reinterpret_cast<char*>(_Getptr), reinterpret_cast<char*>(_Putptr));
+    }
+
+    __CLR_OR_THIS_CALL strstreambuf(_In_opt_z_ const unsigned char* _Getptr, streamsize _Count) {
+        // construct with [_Getptr, _Getptr + _Count), immutable
+        _Init(_Count, const_cast<char*>(reinterpret_cast<const char*>(_Getptr)), nullptr, _Constant);
+    }
+
+    __CLR_OR_THIS_CALL strstreambuf(strstreambuf&& _Right) {
+        _Init();
+        _Assign_rv(_STD move(_Right));
+    }
+
+    strstreambuf& __CLR_OR_THIS_CALL operator=(strstreambuf&& _Right) noexcept /* strengthened */ {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void __CLR_OR_THIS_CALL _Assign_rv(strstreambuf&& _Right) noexcept {
+        if (this != _STD addressof(_Right)) {
+            _Tidy();
+            this->swap(_Right);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL swap(strstreambuf& _Right) noexcept { // non-Standard
+        if (this != _STD addressof(_Right)) {
+            _Mysb::swap(_Right);
+            _STD swap(_Minsize, _Right._Minsize);
+            _STD swap(_Pendsave, _Right._Pendsave);
+            _STD swap(_Seekhigh, _Right._Seekhigh);
+            _STD swap(_Strmode, _Right._Strmode);
+            _STD swap(_Palloc, _Right._Palloc);
+            _STD swap(_Pfree, _Right._Pfree);
+        }
+    }
+
+    __CLR_OR_THIS_CALL ~strstreambuf() noexcept override {
+        _Tidy();
+    }
+
+    void __CLR_OR_THIS_CALL freeze(bool _Freezeit = true) noexcept /* strengthened */ { // freeze or unfreeze writing
+        if (_Strmode & _Dynamic) {
+            if (_Freezeit && !(_Strmode & _Frozen)) { // disable writing
+                _Strmode |= _Frozen;
+                _Pendsave = epptr();
+                setp(pbase(), pptr(), eback());
+            } else if (!_Freezeit && (_Strmode & _Frozen)) { // re-enable writing
+                _Strmode &= ~_Frozen;
+                setp(pbase(), pptr(), _Pendsave);
+            }
+        }
+    }
+
+    _NODISCARD char* __CLR_OR_THIS_CALL str() noexcept /* strengthened */ {
+        // freeze and return pointer to character array
+        freeze();
+        return eback();
+    }
+
+    _NODISCARD streamsize __CLR_OR_THIS_CALL pcount() const noexcept /* strengthened */ {
+        return pptr() ? static_cast<streamsize>(pptr() - pbase()) : 0;
+    }
+
+    __CLR_OR_THIS_CALL strstreambuf(
+        _In_opt_z_ signed char* _Getptr, streamsize _Count, _In_opt_z_ signed char* _Putptr = nullptr) {
+        // construct with [_Getptr, _Getptr + _Count), possibly mutable
+        _Init(_Count, reinterpret_cast<char*>(_Getptr), reinterpret_cast<char*>(_Putptr));
+    }
+
+    __CLR_OR_THIS_CALL strstreambuf(const signed char* _Getptr, streamsize _Count) {
+        // construct with [_Getptr, _Getptr + _Count), immutable
+        _Init(_Count, const_cast<char*>(reinterpret_cast<const char*>(_Getptr)), nullptr, _Constant);
+    }
+
+    void clear() noexcept /* strengthened */ { // free any allocated storage
+        _Tidy();
+    }
+
+protected:
+    int __CLR_OR_THIS_CALL overflow(int _Meta = EOF) override { // try to extend write area
+        if (_Meta == EOF) {
+            return 0; // nothing to write
+        }
+
+        if (pptr() && pptr() < epptr()) {
+            return static_cast<unsigned char>(*_Pninc() = static_cast<char>(_Meta));
+        }
+
+        if (!(_Strmode & _Dynamic) || (_Strmode & (_Constant | _Frozen))) {
+            return EOF; // can't extend
+        }
+
+        // okay to extend
+        const size_t _Oldsize = gptr() ? static_cast<size_t>(epptr() - eback()) : 0;
+        size_t _Newsize;
+        if (_Oldsize < _MINSIZE) {
+            _Newsize = _MINSIZE;
+        } else if (_Oldsize < INT_MAX / 2) { // grow by 50 percent
+            _Newsize = _Oldsize << 1;
+        } else if (_Oldsize < INT_MAX) {
+            _Newsize = INT_MAX;
+        } else { // buffer can't grow, fail
+            return EOF;
+        }
+
+        const auto _Ptr = _Alloc(_Newsize);
+        if (!_Ptr) { // couldn't grow, return failure
+            return EOF;
+        }
+
+        _CSTD memcpy(_Ptr, eback(), _Oldsize); // copy existing
+        if (_Strmode & _Allocated) { // buffer to free
+            _Free(eback());
+        }
+
+        _Strmode |= _Allocated;
+        _Seekhigh                            = _Ptr + _Oldsize;
+        const ptrdiff_t _Old_get_offset      = gptr() - eback();
+        const ptrdiff_t _Old_put_base_offset = pbase() - eback();
+        const ptrdiff_t _Old_put_offset      = pptr() - eback();
+        setp(_Ptr + _Old_put_base_offset, _Ptr + _Old_put_offset, _Ptr + _Newsize);
+        setg(_Ptr, _Ptr + _Old_get_offset, _Ptr + _Old_get_offset + 1);
+        return static_cast<unsigned char>(*_Pninc() = static_cast<char>(_Meta));
+    }
+
+    int __CLR_OR_THIS_CALL pbackfail(int _Meta = EOF) override { // try to putback a character
+        const auto _Old_gptr = gptr();
+        if (_Old_gptr && eback() < _Old_gptr) { // if the input sequence has a putback position available
+            if (_Meta == EOF) {
+                _Meta = 0; // a value other than EOF
+            } else if (!(_Strmode & _Constant)) { // non-constant, overwrite no matter what
+                _Old_gptr[-1] = static_cast<char>(_Meta);
+            } else if (_Old_gptr[-1] != static_cast<char>(_Meta)) { // constant, unequal, can't put it back
+                return EOF;
+            }
+
+            gbump(-1);
+            return _Meta;
+        }
+
+        return EOF;
+    }
+
+    int __CLR_OR_THIS_CALL underflow() override { // read if read position available
+        const auto _Old_gptr = gptr();
+        if (!_Old_gptr) {
+            return EOF; // no read buffer
+        }
+
+        if (_Old_gptr < egptr()) { // If the input sequence has a read position available, the function signals success
+                                   // by returning static_cast<unsigned char>(*gnext)
+            return static_cast<unsigned char>(*_Old_gptr);
+        }
+
+        const auto _Old_pptr = pptr();
+        if (_Old_pptr && _Old_pptr > egptr()
+            && _Old_gptr
+                   < _Old_pptr) { // Otherwise, if the current write next pointer pnext is not a null pointer and is
+                                  // greater than the current read end pointer gend, makes a read position available by
+                                  // assigning to gend a value greater than gnext and no greater than pnext.
+            if (_Seekhigh < _Old_pptr) { // TRANSITION, ABI: appears unused, maintained for ABI compat
+                _Seekhigh = _Old_pptr;
+            }
+
+            setg(eback(), gptr(), _Old_pptr);
+            return static_cast<unsigned char>(*_Old_gptr);
+        }
+
+        return EOF;
+    }
+
+    streampos __CLR_OR_THIS_CALL seekoff(
+        streamoff _Off, ios_base::seekdir _Way, ios_base::openmode _Which = ios_base::in | ios_base::out) override {
+        // seek by specified offset
+        if (pptr() && _Seekhigh < pptr()) { // TRANSITION, ABI: appears unused, maintained for ABI compat
+            _Seekhigh = pptr(); // update high water mark
+        }
+
+        if ((_Which & ios_base::in && !gptr())
+            || (_Which & ios_base::out && !pptr())) { // N4950 [depr.strstreambuf.virtuals]/15:
+                                                      // For a sequence to be positioned, if its next pointer
+                                                      // is a null pointer, the positioning operation fails.
+            return pos_type{off_type{-1}};
+        }
+
+        const auto _Seeklow  = eback();
+        const auto _Seekdist = _Seekhigh - _Seeklow;
+
+        // N4950 [depr.strstreambuf.virtuals]/16 effectively says check that the result will be in range
+        // [_Seeklow, _Seekhigh]; but we want to calculate this without potential integer overflow
+        switch (_Way) {
+        case ios_base::beg:
+            // check that _Off is in acceptable range [0, _Seekdist]
+            if (static_cast<unsigned long long>(_Off)
+                > static_cast<unsigned long long>(_Seekdist)) { // negative wraparound to positive to save a compare
+                return pos_type{off_type{-1}};
+            }
+            break;
+        case ios_base::end:
+            // check that _Off is in acceptable range [-_Seekdist, 0]
+            // is: _Off + _Seekdist in range [0, _Seekdist]
+            if (static_cast<unsigned long long>(_Off) + _Seekdist > static_cast<unsigned long long>(_Seekdist)) {
+                return pos_type{off_type{-1}};
+            }
+
+            _Off += _Seekdist;
+            break;
+        case ios_base::cur:
+            {
+                constexpr auto _Both = ios_base::in | ios_base::out;
+                if ((_Which & _Both) == _Both) { // prohibited by N4950 [tab:depr.strstreambuf.seekoff.pos]
+                    return pos_type{off_type{-1}};
+                }
+
+                off_type _Oldoff;
+                off_type _Oldleft;
+                if (_Which & ios_base::in) {
+                    _Oldoff  = gptr() - eback();
+                    _Oldleft = _Seekhigh - gptr();
+                } else if (_Which & ios_base::out) {
+                    _Oldoff  = pptr() - pbase();
+                    _Oldleft = _Seekhigh - pptr();
+                } else {
+                    return pos_type{off_type{-1}};
+                }
+
+                if (_Off < -_Oldoff // runs off beginning
+                    || _Off > _Oldleft) { // runs off end
+                    return pos_type{off_type{-1}};
+                }
+
+                _Off += _Oldoff;
+            }
+
+            break;
+        default:
+            return pos_type{off_type{-1}};
+        }
+
+        if (_Which & ios_base::in) {
+            gbump(static_cast<int>(_Off - (gptr() - eback())));
+        }
+
+        if (_Which & ios_base::out) {
+            pbump(static_cast<int>(_Off - (pptr() - pbase())));
+        }
+
+        return pos_type{_Off};
+    }
+
+    pos_type __CLR_OR_THIS_CALL seekpos(
+        pos_type _Sp, ios_base::openmode _Which = ios_base::in | ios_base::out) override {
+        // seek to memorized position
+        if (pptr() && _Seekhigh < pptr()) { // TRANSITION, ABI: appears unused, maintained for ABI compat
+            _Seekhigh = pptr(); // update high water mark
+        }
+
+        if (((_Which & ios_base::in) && !gptr()) || ((_Which & ios_base::out) && !pptr())) {
+            return pos_type{off_type{-1}};
+        }
+
+        const auto _Off      = static_cast<off_type>(_Sp);
+        const auto _Seeklow  = eback();
+        const auto _Seekdist = _Seekhigh - _Seeklow;
+        if (_Off > _Seekdist) {
+            return pos_type{off_type{-1}};
+        }
+
+        if (_Which & ios_base::in) {
+            gbump(static_cast<int>(_Off - (gptr() - eback())));
+        }
+
+        if (_Which & ios_base::out) {
+            pbump(static_cast<int>(_Off - (pptr() - pbase())));
+        }
+
+        return pos_type{_Off};
+    }
+
+    void __CLR_OR_THIS_CALL _Init(
+        streamsize _Count = 0, char* _Gp = nullptr, char* _Pp = nullptr, _Strstate _Mode = 0) noexcept {
+        // initialize with possibly static buffer
+        streambuf::_Init();
+        _Minsize  = _MINSIZE;
+        _Pendsave = nullptr;
+        _Seekhigh = nullptr;
+        _Palloc   = nullptr;
+        _Pfree    = nullptr;
+        _Strmode  = _Mode;
+
+        if (_Gp) { // make static
+            size_t _Size;
+            if (_Count == 0) {
+                _Size = _CSTD strlen(_Gp);
+            } else if (static_cast<unsigned long long>(_Count) < static_cast<unsigned long long>(INT_MAX)) {
+                _Size = static_cast<size_t>(_Count);
+            } else {
+                _Size = INT_MAX;
+            }
+
+            _Seekhigh = _Gp + _Size;
+            if (_Pp) { // make writable too
+                setg(_Gp, _Gp, _Pp);
+                setp(_Pp, _Pp + _Size);
+            } else { // set read pointers only
+                setg(_Gp, _Gp, _Gp + _Size);
+            }
+        } else { // make dynamic
+            _Strmode |= _Dynamic;
+            if (_Count > INT_MAX) {
+                _Minsize = INT_MAX;
+            } else if (_Minsize < _Count) {
+                _Minsize = static_cast<int>(_Count);
+            }
+        }
+    }
+
+    void __CLR_OR_THIS_CALL _Tidy() noexcept { // free any allocated storage
+        if ((_Strmode & (_Allocated | _Frozen)) == _Allocated) {
+            _Free(eback());
+        }
+
+        _Seekhigh = nullptr;
+        _Strmode &= ~(_Allocated | _Frozen);
+    }
+
+private:
+    enum { // constant for default minimum buffer size
+        _MINSIZE = 32
+    };
+
+    char* _Alloc(const size_t _To_allocate) const {
+        if (_Palloc) {
+            return static_cast<char*>(_Palloc(_To_allocate));
+        }
+
+        return static_cast<char*>(_CSTD _malloc_dbg(_To_allocate, _CRT_BLOCK, __FILE__, __LINE__));
+    }
+
+    void _Free(char* _Ptr) const {
+        if (_Pfree) {
+            _Pfree(_Ptr);
+            return;
+        }
+
+        _CSTD free(_Ptr);
+    }
+
+    int _Minsize; // the minimum buffer size
+    char* _Pendsave; // the saved end pointer during freeze
+    char* _Seekhigh; // the high-water pointer in character array
+    _Strstate _Strmode; // the stream state
+    void*(__CLRCALL_OR_CDECL* _Palloc)(size_t); // the pointer to allocator function
+    void(__CLRCALL_OR_CDECL* _Pfree)(void*); // the pointer to free function
+};
+
+inline void swap(strstreambuf& _Left, strstreambuf& _Right) noexcept { // non-Standard
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD class _CXX17_DEPRECATE_STRSTREAM istrstream : public istream {
+    // input stream associated with a character array
+public:
+    using _Mybase = istream;
+    using _Mysb   = strstreambuf;
+
+    explicit __CLR_OR_THIS_CALL istrstream(const char* _Ptr) : _Mybase(&_Strbuffer), _Strbuffer(_Ptr, 0) {
+        // construct with NTBS
+    }
+
+    __CLR_OR_THIS_CALL istrstream(const char* _Ptr, streamsize _Count)
+        : _Mybase(&_Strbuffer), _Strbuffer(_Ptr, _Count) {
+        // construct with [_Ptr, _Ptr + _Count)
+    }
+
+    explicit __CLR_OR_THIS_CALL istrstream(char* _Ptr) : _Mybase(&_Strbuffer), _Strbuffer(_Ptr, 0) {
+        // construct with NTBS
+    }
+
+    __CLR_OR_THIS_CALL istrstream(char* _Ptr, int _Count) : _Mybase(&_Strbuffer), _Strbuffer(_Ptr, _Count) {
+        // construct with [_Ptr, _Ptr + _Count)
+    }
+
+    __CLR_OR_THIS_CALL istrstream(istrstream&& _Right) : _Mybase(&_Strbuffer) {
+        _Assign_rv(_STD move(_Right));
+    }
+
+    istrstream& __CLR_OR_THIS_CALL operator=(istrstream&& _Right) noexcept /* strengthened */ {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void __CLR_OR_THIS_CALL _Assign_rv(istrstream&& _Right) noexcept {
+        if (this != _STD addressof(_Right)) {
+            _Strbuffer.clear();
+            this->swap(_Right);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL swap(istrstream& _Right) noexcept { // non-Standard
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Strbuffer.swap(_Right._Strbuffer);
+        }
+    }
+
+    __CLR_OR_THIS_CALL ~istrstream() noexcept override {}
+
+    _NODISCARD _Mysb* __CLR_OR_THIS_CALL rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Mysb*>(&_Strbuffer);
+    }
+
+    _NODISCARD char* __CLR_OR_THIS_CALL str() noexcept /* strengthened */ {
+        // freeze and return pointer to character array
+        return _Strbuffer.str();
+    }
+
+private:
+    _Mysb _Strbuffer; // the string buffer
+};
+
+inline void swap(istrstream& _Left, istrstream& _Right) noexcept { // non-Standard
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD class _CXX17_DEPRECATE_STRSTREAM ostrstream : public ostream {
+    // output stream associated with a character array
+public:
+    using _Mybase = ostream;
+    using _Mysb   = strstreambuf;
+
+    __CLR_OR_THIS_CALL ostrstream() : ostream(&_Strbuffer), _Strbuffer() {}
+
+    __CLR_OR_THIS_CALL ostrstream(char* _Ptr, streamsize _Count, ios_base::openmode _Mode = ios_base::out)
+        : ostream(&_Strbuffer),
+          _Strbuffer(_Ptr, _Count, _Ptr && (_Mode & ios_base::app) != 0 ? _Ptr + _CSTD strlen(_Ptr) : _Ptr) {
+        // construct with [_Ptr, _Ptr + _Count)
+    }
+
+    __CLR_OR_THIS_CALL ostrstream(ostrstream&& _Right) : _Mybase(&_Strbuffer) {
+        _Assign_rv(_STD move(_Right));
+    }
+
+    ostrstream& __CLR_OR_THIS_CALL operator=(ostrstream&& _Right) noexcept /* strengthened */ {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void __CLR_OR_THIS_CALL _Assign_rv(ostrstream&& _Right) noexcept {
+        if (this != _STD addressof(_Right)) {
+            _Strbuffer.clear();
+            this->swap(_Right);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL swap(ostrstream& _Right) noexcept { // non-Standard
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Strbuffer.swap(_Right._Strbuffer);
+        }
+    }
+
+    __CLR_OR_THIS_CALL ~ostrstream() noexcept override {}
+
+    _NODISCARD _Mysb* __CLR_OR_THIS_CALL rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Mysb*>(&_Strbuffer);
+    }
+
+    void __CLR_OR_THIS_CALL freeze(bool _Freezeit = true) noexcept /* strengthened */ { // freeze or unfreeze writing
+        _Strbuffer.freeze(_Freezeit);
+    }
+
+    _NODISCARD char* __CLR_OR_THIS_CALL str() noexcept /* strengthened */ {
+        // freeze and return pointer to character array
+        return _Strbuffer.str();
+    }
+
+    _NODISCARD streamsize __CLR_OR_THIS_CALL pcount() const noexcept /* strengthened */ {
+        return _Strbuffer.pcount();
+    }
+
+private:
+    _Mysb _Strbuffer; // the string buffer
+};
+
+inline void swap(ostrstream& _Left, ostrstream& _Right) noexcept { // non-Standard
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD class _CXX17_DEPRECATE_STRSTREAM strstream : public iostream {
+    // input/output stream associated with character array buffer
+public:
+    using _Mybase = iostream;
+    using _Mysb   = strstreambuf;
+
+    using char_type = char;
+    using int_type  = int;
+    using pos_type  = streampos;
+    using off_type  = streamoff;
+
+    __CLR_OR_THIS_CALL strstream() : _Mybase(&_Strbuffer), _Strbuffer() {}
+
+    __CLR_OR_THIS_CALL strstream(char* _Ptr, streamsize _Count, ios_base::openmode _Mode = ios_base::in | ios_base::out)
+        : iostream(&_Strbuffer),
+          _Strbuffer(_Ptr, _Count, _Ptr && (_Mode & ios_base::app) != 0 ? _Ptr + _CSTD strlen(_Ptr) : _Ptr) {
+        // construct with [_Ptr, _Ptr + _Count)
+    }
+
+    __CLR_OR_THIS_CALL strstream(strstream&& _Right) : _Mybase(&_Strbuffer) {
+        _Assign_rv(_STD move(_Right));
+    }
+
+    strstream& __CLR_OR_THIS_CALL operator=(strstream&& _Right) noexcept /* strengthened */ {
+        _Assign_rv(_STD move(_Right));
+        return *this;
+    }
+
+    void __CLR_OR_THIS_CALL _Assign_rv(strstream&& _Right) noexcept {
+        if (this != _STD addressof(_Right)) {
+            _Strbuffer.clear();
+            this->swap(_Right);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL swap(strstream& _Right) noexcept { // non-Standard
+        if (this != _STD addressof(_Right)) {
+            _Mybase::swap(_Right);
+            _Strbuffer.swap(_Right._Strbuffer);
+        }
+    }
+
+    __CLR_OR_THIS_CALL ~strstream() noexcept override {}
+
+    _NODISCARD _Mysb* __CLR_OR_THIS_CALL rdbuf() const noexcept /* strengthened */ {
+        return const_cast<_Mysb*>(&_Strbuffer);
+    }
+
+    void __CLR_OR_THIS_CALL freeze(bool _Freezeit = true) noexcept /* strengthened */ { // freeze or unfreeze writing
+        _Strbuffer.freeze(_Freezeit);
+    }
+
+    _NODISCARD char* __CLR_OR_THIS_CALL str() noexcept /* strengthened */ {
+        // freeze and return pointer to character array
+        return _Strbuffer.str();
+    }
+
+    _NODISCARD streamsize __CLR_OR_THIS_CALL pcount() const noexcept /* strengthened */ {
+        return _Strbuffer.pcount();
+    }
+
+private:
+    _Mysb _Strbuffer; // the string buffer
+};
+
+inline void swap(strstream& _Left, strstream& _Right) noexcept { // non-Standard
+    _Left.swap(_Right);
+}
+_STL_RESTORE_DEPRECATED_WARNING
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STRSTREAM_
diff --git a/msvc-stl/stl/inc/syncstream b/msvc-stl/stl/inc/syncstream
new file mode 100644
index 0000000..7fa466a
--- /dev/null
+++ b/msvc-stl/stl/inc/syncstream
@@ -0,0 +1,385 @@
+// syncstream standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SYNCSTREAM_
+#define _SYNCSTREAM_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX20
+_EMIT_STL_WARNING(STL4038, "The contents of <syncstream> are available only with C++20 or later.");
+#else // ^^^ !_HAS_CXX20 / _HAS_CXX20 vvv
+#include <memory>
+#include <ostream>
+#include <shared_mutex>
+#include <streambuf>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#pragma push_macro("emit")
+#undef new
+#undef emit
+
+extern "C" {
+_NODISCARD _STD shared_mutex* __stdcall __std_acquire_shared_mutex_for_instance(void* _Ptr) noexcept;
+void __stdcall __std_release_shared_mutex_for_instance(void* _Ptr) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+
+template <class _Elem, class _Traits>
+class _Basic_syncbuf_impl : public basic_streambuf<_Elem, _Traits> {
+public:
+    void set_emit_on_sync(const bool _Val) noexcept {
+        _Emit_on_sync = _Val;
+    }
+
+    virtual bool _Do_emit() = 0;
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    _NODISCARD bool _Stl_internal_check_get_emit_on_sync() const noexcept {
+        return _Emit_on_sync;
+    }
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+protected:
+    using _Mysb = basic_streambuf<_Elem, _Traits>;
+
+    _Basic_syncbuf_impl() = default;
+
+    _Basic_syncbuf_impl(_Basic_syncbuf_impl&& _Right) {
+        _Swap(_Right);
+    }
+
+    void _Swap(_Basic_syncbuf_impl& _Right) noexcept {
+        _Mysb::swap(_Right);
+        _STD swap(_Emit_on_sync, _Right._Emit_on_sync);
+        _STD swap(_Sync_recorded, _Right._Sync_recorded);
+    }
+
+    bool _Emit_on_sync{false};
+    bool _Sync_recorded{false};
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+class basic_syncbuf : public _Basic_syncbuf_impl<_Elem, _Traits> {
+public:
+    using int_type       = _Traits::int_type;
+    using pos_type       = _Traits::pos_type;
+    using off_type       = _Traits::off_type;
+    using allocator_type = _Alloc;
+    using streambuf_type = basic_streambuf<_Elem, _Traits>;
+
+    using _Mybase    = _Basic_syncbuf_impl<_Elem, _Traits>;
+    using _Pointer   = allocator_traits<_Alloc>::pointer;
+    using _Size_type = allocator_traits<_Alloc>::size_type;
+
+    using _Mybase::set_emit_on_sync;
+
+    basic_syncbuf() = default;
+
+    explicit basic_syncbuf(streambuf_type* _Strbuf) : basic_syncbuf(_Strbuf, _Alloc{}) {}
+
+    basic_syncbuf(streambuf_type* _Strbuf, const _Alloc& _Al_)
+        : _Wrapped(_Strbuf), _Mypair{_One_then_variadic_args_t{}, _Al_, nullptr} {
+        if (_Wrapped) {
+            auto& _Mutex = _Get_mutex();
+            _Mutex       = __std_acquire_shared_mutex_for_instance(_Wrapped);
+            if (!_Mutex) {
+                _Xbad_alloc();
+            }
+        }
+        _Init();
+    }
+
+    basic_syncbuf(basic_syncbuf&& _Right) : _Mypair{_One_then_variadic_args_t{}, _STD move(_Right._Getal()), nullptr} {
+        _Swap_except_al(_Right);
+    }
+
+    ~basic_syncbuf() {
+        _Emit();
+        _Tidy();
+    }
+
+    basic_syncbuf& operator=(basic_syncbuf&& _Right) {
+        emit();
+
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alloc>;
+        if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                _Tidy();
+
+                _Size_type _Right_buf_size        = _Right._Get_buffer_size();
+                const _Size_type _Right_data_size = _Right._Get_data_size();
+
+                _Elem* const _New_ptr = _Unfancy(_Allocate_at_least_helper(_Al, _Right_buf_size));
+                _Traits::copy(_New_ptr, _Right.pbase(), _Right_data_size);
+
+                streambuf_type::setp(_New_ptr, _New_ptr + _Right_data_size, _New_ptr + _Right_buf_size);
+                _STD swap(streambuf_type::_Plocale, _Right._Plocale);
+
+                _STD swap(_Mybase::_Emit_on_sync, _Right._Emit_on_sync);
+                _STD swap(_Mybase::_Sync_recorded, _Right._Sync_recorded);
+                _STD swap(_Wrapped, _Right._Wrapped);
+                _STD swap(_Get_mutex(), _Right._Get_mutex());
+
+                _Right._Tidy();
+                return *this;
+            }
+        }
+
+        _Tidy();
+        _Pocma(_Al, _Right_al);
+        _Swap_except_al(_Right);
+        return *this;
+    }
+
+    void swap(basic_syncbuf& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+            _Swap_except_al(_Right);
+        }
+    }
+
+    bool emit() {
+        if (!_Wrapped) {
+            return false;
+        }
+
+        bool _Result                = true;
+        const _Size_type _Data_size = _Get_data_size();
+        _Elem* const _Begin_seq_ptr = streambuf_type::pbase();
+        if (_Data_size > 0 || _Mybase::_Sync_recorded) {
+            scoped_lock _Guard(*_Get_mutex());
+
+            if (_Data_size > 0
+                && _Data_size
+                       != static_cast<_Size_type>(
+                           _Wrapped->sputn(_Begin_seq_ptr, static_cast<streamsize>(_Data_size)))) {
+                _Result = false;
+            }
+
+            if (_Mybase::_Sync_recorded) {
+                if (_Wrapped->pubsync() == -1) {
+                    _Result = false;
+                }
+            }
+        }
+        _Mybase::_Sync_recorded = false;
+        streambuf_type::setp(_Begin_seq_ptr, streambuf_type::epptr()); // reset written data
+        return _Result;
+    }
+
+    _NODISCARD streambuf_type* get_wrapped() const noexcept {
+        return _Wrapped;
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+protected:
+    int sync() override {
+        _Mybase::_Sync_recorded = true;
+
+        if (_Mybase::_Emit_on_sync) {
+            if (!emit()) {
+                return -1;
+            }
+        }
+        return 0;
+    }
+
+    int_type overflow(int_type _Current_elem) override {
+        if (!_Wrapped) {
+            return _Traits::eof();
+        }
+        const bool _Chk_eof = _Traits::eq_int_type(_Current_elem, _Traits::eof());
+        if (_Chk_eof) {
+            return _Traits::not_eof(_Current_elem);
+        }
+
+        auto& _Al                        = _Getal();
+        const _Size_type _Buf_size       = _Get_buffer_size();
+        const _Size_type _Max_allocation = allocator_traits<_Alloc>::max_size(_Al);
+        if (_Buf_size == _Max_allocation) {
+            return _Traits::eof();
+        }
+
+        _Size_type _New_capacity        = _Calculate_growth(_Buf_size, _Buf_size + 1, _Max_allocation);
+        _Elem* const _Old_ptr           = streambuf_type::pbase();
+        const _Size_type _Old_data_size = _Get_data_size();
+
+        _Elem* const _New_ptr = _Unfancy(_Allocate_at_least_helper(_Al, _New_capacity));
+        _Traits::copy(_New_ptr, _Old_ptr, _Old_data_size);
+        if (0 < _Buf_size) {
+            _Al.deallocate(_Refancy<_Pointer>(_Old_ptr), _Buf_size);
+        }
+
+        streambuf_type::setp(_New_ptr, _New_ptr + _Old_data_size, _New_ptr + _New_capacity);
+        streambuf_type::sputc(_Traits::to_char_type(_Current_elem));
+
+        return _Current_elem;
+    }
+
+private:
+    static constexpr _Size_type _Min_size = 32; // constant for minimum buffer size
+
+    void _Init() {
+        _Size_type _New_capacity = _Min_size;
+        _Elem* const _New_ptr    = _Unfancy(_Allocate_at_least_helper(_Getal(), _New_capacity));
+        streambuf_type::setp(_New_ptr, _New_ptr + _New_capacity);
+    }
+
+    void _Tidy() noexcept {
+        const _Size_type _Buf_size = _Get_buffer_size();
+        if (0 < _Buf_size) {
+            _Getal().deallocate(_Refancy<_Pointer>(streambuf_type::pbase()), _Buf_size);
+        }
+
+        streambuf_type::setp(nullptr, nullptr, nullptr);
+        if (_Wrapped) {
+            __std_release_shared_mutex_for_instance(_Wrapped);
+            _Wrapped     = nullptr;
+            _Get_mutex() = nullptr;
+        }
+    }
+
+    void _Swap_except_al(basic_syncbuf& _Right) noexcept {
+        _Mybase::_Swap(_Right);
+        _STD swap(_Wrapped, _Right._Wrapped);
+        _STD swap(_Get_mutex(), _Right._Get_mutex());
+    }
+
+    bool _Do_emit() override {
+        return emit();
+    }
+
+    bool _Emit() noexcept {
+        _TRY_BEGIN
+        return emit();
+        _CATCH_ALL
+        return false;
+        _CATCH_END
+    }
+
+    _NODISCARD static constexpr _Size_type _Calculate_growth(
+        const _Size_type _Oldsize, const _Size_type _Newsize, const _Size_type _Maxsize) {
+        if (_Oldsize > _Maxsize - _Oldsize / 2) {
+            return _Maxsize; // geometric growth would overflow
+        }
+
+        const _Size_type _Geometric = _Oldsize + _Oldsize / 2;
+
+        if (_Geometric < _Newsize) {
+            return _Newsize; // geometric growth would be insufficient
+        }
+
+        return _Geometric; // geometric growth is sufficient
+    }
+
+    _NODISCARD _Size_type _Get_data_size() const noexcept {
+        return static_cast<_Size_type>(streambuf_type::pptr() - streambuf_type::pbase());
+    }
+
+    _NODISCARD _Size_type _Get_buffer_size() const noexcept {
+        return static_cast<_Size_type>(streambuf_type::epptr() - streambuf_type::pbase());
+    }
+
+    _NODISCARD _Alloc& _Getal() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _NODISCARD shared_mutex*& _Get_mutex() noexcept {
+        return _Mypair._Myval2;
+    }
+
+    streambuf_type* _Wrapped{nullptr};
+    _Compressed_pair<_Alloc, shared_mutex*> _Mypair{_Zero_then_variadic_args_t{}, nullptr};
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+void swap(basic_syncbuf<_Elem, _Traits, _Alloc>& _Left, basic_syncbuf<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+class basic_osyncstream : public basic_ostream<_Elem, _Traits> {
+public:
+    using char_type      = _Elem;
+    using int_type       = _Traits::int_type;
+    using pos_type       = _Traits::pos_type;
+    using off_type       = _Traits::off_type;
+    using traits_type    = _Traits;
+    using allocator_type = _Alloc;
+    using streambuf_type = basic_streambuf<_Elem, _Traits>;
+    using syncbuf_type   = basic_syncbuf<_Elem, _Traits, _Alloc>;
+
+    using _Mybase = basic_ostream<_Elem, _Traits>;
+    using _Myios  = basic_ios<_Elem, _Traits>;
+
+    basic_osyncstream(streambuf_type* _Strbuf, const _Alloc& _Al)
+        : _Mybase(_STD addressof(_Sync_buf)), _Sync_buf(_Strbuf, _Al) {}
+
+    explicit basic_osyncstream(streambuf_type* _Strbuf) : basic_osyncstream(_Strbuf, _Alloc{}) {}
+
+    basic_osyncstream(basic_ostream<_Elem, _Traits>& _Ostr, const _Alloc& _Al)
+        : basic_osyncstream(_Ostr.rdbuf(), _Al) {}
+
+    explicit basic_osyncstream(basic_ostream<_Elem, _Traits>& _Ostr) : basic_osyncstream(_Ostr, _Alloc{}) {}
+
+    basic_osyncstream(basic_osyncstream&& _Right) noexcept
+        : _Mybase(_STD move(_Right)), _Sync_buf(_STD move(_Right._Sync_buf)) {
+        _Mybase::set_rdbuf(_STD addressof(_Sync_buf));
+    }
+
+    ~basic_osyncstream() = default;
+
+    basic_osyncstream& operator=(basic_osyncstream&&) = default;
+
+    void emit() {
+        ios_base::iostate _State = ios_base::goodbit;
+        const typename _Mybase::sentry _Ok(*this);
+        if (!_Ok) {
+            _State |= ios_base::badbit;
+        } else {
+            _TRY_IO_BEGIN
+            if (!_Sync_buf.emit()) {
+                _State |= ios_base::badbit;
+            }
+            _CATCH_IO_END
+        }
+        _Mybase::setstate(_State);
+    }
+    _NODISCARD streambuf_type* get_wrapped() const noexcept {
+        return _Sync_buf.get_wrapped();
+    }
+    _NODISCARD syncbuf_type* rdbuf() const noexcept {
+        return const_cast<syncbuf_type*>(_STD addressof(_Sync_buf));
+    }
+
+private:
+    syncbuf_type _Sync_buf;
+};
+
+_STD_END
+
+#pragma pop_macro("emit")
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX20 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SYNCSTREAM_
diff --git a/msvc-stl/stl/inc/system_error b/msvc-stl/stl/inc/system_error
new file mode 100644
index 0000000..6fd1adf
--- /dev/null
+++ b/msvc-stl/stl/inc/system_error
@@ -0,0 +1,749 @@
+// system_error standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _SYSTEM_ERROR_
+#define _SYSTEM_ERROR_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_system_error_abi.hpp>
+#include <cerrno>
+#include <cstdlib>
+#include <stdexcept>
+#include <xcall_once.h>
+#include <xerrc.h>
+
+#ifndef _M_CEE_PURE
+#include <atomic>
+#endif // !defined(_M_CEE_PURE)
+
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("noop_dtor")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef noop_dtor
+#undef no_specializations
+
+_STD_BEGIN
+_EXPORT_STD enum class io_errc { // error codes for ios_base::failure
+    stream = 1
+};
+
+_EXPORT_STD template <class _Enum>
+struct is_error_code_enum : false_type {};
+
+template <>
+struct is_error_code_enum<io_errc> : true_type {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool is_error_code_enum_v = is_error_code_enum<_Ty>::value;
+
+_EXPORT_STD template <class _Enum>
+struct is_error_condition_enum : false_type {};
+
+template <>
+struct is_error_condition_enum<errc> : true_type {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool is_error_condition_enum_v =
+    is_error_condition_enum<_Ty>::value;
+
+_EXPORT_STD class error_code;
+_EXPORT_STD class error_condition;
+
+namespace _Ensure_adl {
+    void make_error_code()      = delete;
+    void make_error_condition() = delete;
+} // namespace _Ensure_adl
+
+_EXPORT_STD class error_category;
+
+_EXPORT_STD _NODISCARD const error_category& generic_category() noexcept;
+_EXPORT_STD _NODISCARD const error_category& iostream_category() noexcept;
+_EXPORT_STD _NODISCARD const error_category& system_category() noexcept;
+
+_EXPORT_STD class __declspec(novtable) error_category { // categorize an error
+public:
+#ifdef _M_CEE_PURE
+    /* constexpr */ error_category() noexcept { // TRANSITION, ABI
+        _Addr = reinterpret_cast<uintptr_t>(this);
+    }
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#pragma warning(push)
+#pragma warning(disable : 4355) // 'this': used in base member initializer list
+    constexpr error_category() noexcept : _Addr(this) {}
+#pragma warning(pop)
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    _CONSTEXPR20 virtual ~error_category() noexcept = default;
+
+    _NODISCARD virtual const char* name() const noexcept = 0;
+
+    _NODISCARD virtual string message(int _Errval) const = 0;
+
+    _NODISCARD virtual error_condition default_error_condition(int _Errval) const noexcept;
+
+    _NODISCARD virtual bool equivalent(int _Errval, const error_condition& _Cond) const noexcept;
+
+    _NODISCARD virtual bool equivalent(const error_code& _Code, int _Errval) const noexcept;
+
+    _NODISCARD bool operator==(const error_category& _Right) const noexcept {
+#ifdef _M_CEE_PURE
+        return _Addr == _Right._Addr;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+        return _Bit_cast<uintptr_t>(_Addr) == _Bit_cast<uintptr_t>(_Right._Addr);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+    }
+
+#if _HAS_CXX20
+    _NODISCARD strong_ordering operator<=>(const error_category& _Right) const noexcept {
+        return _Bit_cast<uintptr_t>(_Addr) <=> _Bit_cast<uintptr_t>(_Right._Addr);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const error_category& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const error_category& _Right) const noexcept {
+#ifdef _M_CEE_PURE
+        return _Addr < _Right._Addr;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+        return _Bit_cast<uintptr_t>(_Addr) < _Bit_cast<uintptr_t>(_Right._Addr);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    error_category(const error_category&)            = delete;
+    error_category& operator=(const error_category&) = delete;
+
+protected:
+#ifdef _M_CEE_PURE
+    uintptr_t _Addr;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+    union _Addr_storage {
+    private:
+        uintptr_t _Num;
+        error_category* _Ptr;
+
+    public:
+        constexpr explicit _Addr_storage(const uintptr_t _Addr_num) noexcept : _Num(_Addr_num) {}
+        constexpr explicit _Addr_storage(error_category* const _Addr_ptr) noexcept : _Ptr(_Addr_ptr) {}
+
+        // TRANSITION: As of Boost 1.80.0, boost::system::detail::std_category assigns to _Addr.
+        constexpr _Addr_storage& operator=(const uintptr_t _Addr_num) noexcept {
+            _Num = _Addr_num;
+            return *this;
+        }
+    };
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Addr_storage) == sizeof(uintptr_t));
+    _STL_INTERNAL_STATIC_ASSERT(alignof(_Addr_storage) == alignof(uintptr_t));
+
+    _Addr_storage _Addr;
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    constexpr explicit error_category(const uintptr_t _Addr_) noexcept : _Addr(_Addr_) {}
+
+    enum : uintptr_t { // symbolic addresses for Standard error_category objects
+        _Future_addr   = 1,
+        _Generic_addr  = 3,
+        _Iostream_addr = 5,
+        _System_addr   = 7
+    };
+};
+
+#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+_NODISCARD inline bool _System_error_equal(const error_code&, const error_condition&) noexcept;
+#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+
+_EXPORT_STD class error_code { // store an implementation-specific error code and category
+public:
+    error_code() noexcept : _Myval(0), _Mycat(&_STD system_category()) {} // construct non-error
+
+    error_code(int _Val, const error_category& _Cat) noexcept : _Myval(_Val), _Mycat(&_Cat) {}
+
+    template <class _Enum, enable_if_t<is_error_code_enum_v<_Enum>, int> = 0>
+    error_code(_Enum _Errcode) noexcept : _Myval(0), _Mycat(nullptr) {
+        using _Ensure_adl::make_error_code;
+        *this = make_error_code(_Errcode); // intentional ADL
+    }
+
+    void assign(int _Val, const error_category& _Cat) noexcept {
+        _Myval = _Val;
+        _Mycat = &_Cat;
+    }
+
+    template <class _Enum, enable_if_t<is_error_code_enum_v<_Enum>, int> = 0>
+    error_code& operator=(_Enum _Errcode) noexcept {
+        using _Ensure_adl::make_error_code;
+        *this = make_error_code(_Errcode); // intentional ADL
+        return *this;
+    }
+
+    void clear() noexcept {
+        _Myval = 0;
+        _Mycat = &_STD system_category();
+    }
+
+    _NODISCARD int value() const noexcept {
+        return _Myval;
+    }
+
+    _NODISCARD const error_category& category() const noexcept {
+        return *_Mycat;
+    }
+
+    _NODISCARD error_condition default_error_condition() const noexcept;
+
+    _NODISCARD string message() const {
+        return category().message(value());
+    }
+
+    explicit operator bool() const noexcept {
+        return value() != 0;
+    }
+
+#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+    _NODISCARD friend bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
+        return _Left.category() == _Right.category() && _Left.value() == _Right.value();
+    }
+
+    _NODISCARD friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
+        return _System_error_equal(_Left, _Right);
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
+        if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
+            return _Result;
+        }
+        return _Left.value() <=> _Right.value();
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD friend bool operator<(const error_code& _Left, const error_code& _Right) noexcept {
+        return _Left.category() < _Right.category()
+            || (_Left.category() == _Right.category() && _Left.value() < _Right.value());
+    }
+    _NODISCARD friend bool operator==(const error_condition& _Left, const error_code& _Right) noexcept {
+        return _System_error_equal(_Right, _Left);
+    }
+
+    _NODISCARD friend bool operator!=(const error_code& _Left, const error_code& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+
+    _NODISCARD friend bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept {
+        return !_System_error_equal(_Left, _Right);
+    }
+
+    _NODISCARD friend bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept {
+        return !_System_error_equal(_Right, _Left);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+
+private:
+    int _Myval; // the stored error number
+    const error_category* _Mycat; // pointer to error category
+};
+
+_EXPORT_STD class error_condition { // store an abstract error code and category
+public:
+    error_condition() noexcept : _Myval(0), _Mycat(&_STD generic_category()) {} // construct non-error
+
+    error_condition(int _Val, const error_category& _Cat) noexcept : _Myval(_Val), _Mycat(&_Cat) {}
+
+    template <class _Enum, enable_if_t<is_error_condition_enum_v<_Enum>, int> = 0>
+    error_condition(_Enum _Errcode) noexcept : _Myval(0), _Mycat(nullptr) {
+        using _Ensure_adl::make_error_condition;
+        *this = make_error_condition(_Errcode); // intentional ADL
+    }
+
+    void assign(int _Val, const error_category& _Cat) noexcept {
+        _Myval = _Val;
+        _Mycat = &_Cat;
+    }
+
+    template <class _Enum, enable_if_t<is_error_condition_enum_v<_Enum>, int> = 0>
+    error_condition& operator=(_Enum _Errcode) noexcept {
+        using _Ensure_adl::make_error_condition;
+        *this = make_error_condition(_Errcode); // intentional ADL
+        return *this;
+    }
+
+    void clear() noexcept {
+        _Myval = 0;
+        _Mycat = &_STD generic_category();
+    }
+
+    _NODISCARD int value() const noexcept {
+        return _Myval;
+    }
+
+    _NODISCARD const error_category& category() const noexcept {
+        return *_Mycat;
+    }
+
+    _NODISCARD string message() const {
+        return category().message(value());
+    }
+
+    explicit operator bool() const noexcept {
+        return value() != 0;
+    }
+
+#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+    _NODISCARD friend bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
+        return _Left.category() == _Right.category() && _Left.value() == _Right.value();
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend strong_ordering operator<=>(
+        const error_condition& _Left, const error_condition& _Right) noexcept {
+        if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
+            return _Result;
+        }
+        return _Left.value() <=> _Right.value();
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD friend bool operator<(const error_condition& _Left, const error_condition& _Right) noexcept {
+        return _Left.category() < _Right.category()
+            || (_Left.category() == _Right.category() && _Left.value() < _Right.value());
+    }
+    _NODISCARD friend bool operator!=(const error_condition& _Left, const error_condition& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    // We grant friendship to the operators from error_code here to allow is_error_code_enum_v but not
+    // is_error_condition_enum_v enums to be compared directly with error_condition; for example:
+    // io_errc::stream == make_error_condition(errc::out_of_memory)
+    friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept;
+#if !_HAS_CXX20
+    friend bool operator==(const error_condition& _Left, const error_code& _Right) noexcept;
+    friend bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept;
+    friend bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept;
+#endif // !_HAS_CXX20
+#endif // _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+
+private:
+    int _Myval; // the stored error number
+    const error_category* _Mycat; // pointer to error category
+};
+
+#if _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+_NODISCARD inline bool _System_error_equal(const error_code& _Left, const error_condition& _Right) noexcept {
+    return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
+}
+#else // ^^^ _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS / !_STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS vvv
+_EXPORT_STD _NODISCARD inline bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
+    return _Left.category() == _Right.category() && _Left.value() == _Right.value();
+}
+
+_EXPORT_STD _NODISCARD inline bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
+    return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
+}
+
+_EXPORT_STD _NODISCARD inline bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
+    return _Left.category() == _Right.category() && _Left.value() == _Right.value();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
+    if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
+        return _Result;
+    }
+    return _Left.value() <=> _Right.value();
+}
+
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(
+    const error_condition& _Left, const error_condition& _Right) noexcept {
+    if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
+        return _Result;
+    }
+    return _Left.value() <=> _Right.value();
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+_NODISCARD inline bool operator<(const error_code& _Left, const error_code& _Right) noexcept {
+    return _Left.category() < _Right.category()
+        || (_Left.category() == _Right.category() && _Left.value() < _Right.value());
+}
+
+_NODISCARD inline bool operator<(const error_condition& _Left, const error_condition& _Right) noexcept {
+    return _Left.category() < _Right.category()
+        || (_Left.category() == _Right.category() && _Left.value() < _Right.value());
+}
+
+_NODISCARD inline bool operator==(const error_condition& _Left, const error_code& _Right) noexcept {
+    return _Right.category().equivalent(_Right.value(), _Left) || _Left.category().equivalent(_Right, _Left.value());
+}
+
+_NODISCARD inline bool operator!=(const error_code& _Left, const error_code& _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD inline bool operator!=(const error_code& _Left, const error_condition& _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD inline bool operator!=(const error_condition& _Left, const error_code& _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD inline bool operator!=(const error_condition& _Left, const error_condition& _Right) noexcept {
+    return !(_Left == _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+#endif // ^^^ !_STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS ^^^
+
+_NODISCARD inline error_condition error_category::default_error_condition(int _Errval) const noexcept {
+    // make error_condition for error code
+    return error_condition(_Errval, *this);
+}
+
+_NODISCARD inline bool error_category::equivalent(int _Errval, const error_condition& _Cond) const noexcept {
+    return default_error_condition(_Errval) == _Cond;
+}
+
+_NODISCARD inline bool error_category::equivalent(const error_code& _Code, int _Errval) const noexcept {
+    return *this == _Code.category() && _Code.value() == _Errval;
+}
+
+_NODISCARD inline error_condition error_code::default_error_condition() const noexcept {
+    // make error_condition for error code
+    return category().default_error_condition(value());
+}
+
+_EXPORT_STD _NODISCARD inline error_code make_error_code(errc _Ec) noexcept {
+    return error_code(static_cast<int>(_Ec), _STD generic_category());
+}
+
+_EXPORT_STD _NODISCARD inline error_code make_error_code(io_errc _Ec) noexcept {
+    return error_code(static_cast<int>(_Ec), _STD iostream_category());
+}
+
+_EXPORT_STD _NODISCARD inline error_condition make_error_condition(errc _Ec) noexcept {
+    return error_condition(static_cast<int>(_Ec), _STD generic_category());
+}
+
+_EXPORT_STD _NODISCARD inline error_condition make_error_condition(io_errc _Ec) noexcept {
+    return error_condition(static_cast<int>(_Ec), _STD iostream_category());
+}
+
+template <>
+struct hash<error_code> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = error_code;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(const error_code& _Keyval) noexcept {
+        return hash<int>{}(_Keyval.value());
+    }
+};
+
+template <>
+struct hash<error_condition> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = error_condition;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(const error_condition& _Keyval) noexcept {
+        return hash<int>{}(_Keyval.value());
+    }
+};
+
+class _NODISCARD _System_error : public runtime_error { // base of all system-error exceptions
+private:
+    static string _Makestr(error_code _Errcode, string _Message) { // compose error message
+        if (!_Message.empty()) {
+            _Message.append(": ");
+        }
+
+        _Message.append(_Errcode.message());
+        return _Message;
+    }
+
+protected:
+#if _HAS_EXCEPTIONS
+    _System_error(error_code _Errcode) : runtime_error(_Errcode.message()), _Mycode(_Errcode) {}
+
+    _System_error(error_code _Errcode, const string& _Message)
+        : runtime_error(_Makestr(_Errcode, _Message)), _Mycode(_Errcode) {}
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+    _System_error(error_code _Errcode) : runtime_error("system error"), _Mycode(_Errcode) {}
+
+    _System_error(error_code _Errcode, const string&) : runtime_error("system error"), _Mycode(_Errcode) {}
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+
+    error_code _Mycode; // the stored error code
+};
+
+_EXPORT_STD class _NODISCARD system_error : public _System_error { // base of all system-error exceptions
+private:
+    using _Mybase = _System_error;
+
+public:
+    system_error(error_code _Errcode) : _Mybase(_Errcode) {}
+
+    system_error(error_code _Errcode, const string& _Message) : _Mybase(_Errcode, _Message) {}
+
+    system_error(error_code _Errcode, const char* _Message) : _Mybase(_Errcode, _Message) {}
+
+    system_error(int _Errval, const error_category& _Errcat) : _Mybase(error_code(_Errval, _Errcat)) {}
+
+    system_error(int _Errval, const error_category& _Errcat, const string& _Message)
+        : _Mybase(error_code(_Errval, _Errcat), _Message) {}
+
+    system_error(int _Errval, const error_category& _Errcat, const char* _Message)
+        : _Mybase(error_code(_Errval, _Errcat), _Message) {}
+
+    _NODISCARD const error_code& code() const noexcept {
+        return _Mycode;
+    }
+
+#if !_HAS_EXCEPTIONS
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+#endif // !_HAS_EXCEPTIONS
+};
+
+[[noreturn]] inline void _Throw_system_error(const errc _Ec) {
+    _THROW(system_error{_STD make_error_code(_Ec)});
+}
+
+extern "C++" _CRTIMP2_PURE const char* __CLRCALL_PURE_OR_CDECL _Syserror_map(int);
+extern "C++" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Winerror_map(int);
+
+struct _System_error_message {
+    char* _Str;
+    size_t _Length;
+
+    explicit _System_error_message(const unsigned long _Ec) noexcept
+        : _Str(nullptr), _Length(_CSTD __std_system_error_allocate_message(_Ec, &_Str)) {}
+
+    _System_error_message(const _System_error_message&)            = delete;
+    _System_error_message& operator=(const _System_error_message&) = delete;
+
+    ~_System_error_message() {
+        _CSTD __std_system_error_deallocate_message(_Str);
+    }
+};
+
+class _Generic_error_category : public error_category { // categorize a generic error
+public:
+    constexpr _Generic_error_category() noexcept : error_category(_Generic_addr) {}
+
+    _NODISCARD const char* name() const noexcept override {
+        return "generic";
+    }
+
+    _NODISCARD string message(int _Errcode) const override {
+        return _Syserror_map(_Errcode);
+    }
+};
+
+class _Iostream_error_category2 : public error_category { // categorize an iostream error
+public:
+    constexpr _Iostream_error_category2() noexcept : error_category(_Iostream_addr) {}
+
+    _NODISCARD const char* name() const noexcept override {
+        return "iostream";
+    }
+
+    _NODISCARD string message(int _Errcode) const override {
+        if (_Errcode == static_cast<int>(io_errc::stream)) {
+            static constexpr char _Iostream_error[] = "iostream stream error";
+            constexpr size_t _Iostream_error_length = sizeof(_Iostream_error) - 1; // TRANSITION, DevCom-906503
+            return string{_Iostream_error, _Iostream_error_length};
+        } else {
+            return _Syserror_map(_Errcode);
+        }
+    }
+};
+
+class _System_error_category : public error_category { // categorize an operating system error
+public:
+    constexpr _System_error_category() noexcept : error_category(_System_addr) {}
+
+    _NODISCARD const char* name() const noexcept override {
+        return "system";
+    }
+
+    _NODISCARD string message(int _Errcode) const override {
+        const _System_error_message _Msg(static_cast<unsigned long>(_Errcode));
+
+        if (_Msg._Str && _Msg._Length != 0) {
+            // CodeQL [SM02310] _Msg's ctor inits _Str(nullptr) before doing work, then we test _Msg._Str above.
+            return string{_Msg._Str, _Msg._Length};
+        } else {
+            static constexpr char _Unknown_error[] = "unknown error";
+            constexpr size_t _Unknown_error_length = sizeof(_Unknown_error) - 1; // TRANSITION, DevCom-906503
+            return string{_Unknown_error, _Unknown_error_length};
+        }
+    }
+
+    _NODISCARD error_condition default_error_condition(int _Errval) const noexcept override {
+        if (_Errval == 0) {
+            return error_condition(0, _STD generic_category());
+        }
+
+        // make error_condition for error code (generic if possible)
+        const int _Posv = _Winerror_map(_Errval);
+        if (_Posv == 0) {
+            return error_condition(_Errval, _STD system_category());
+        } else {
+            return error_condition(_Posv, _STD generic_category());
+        }
+    }
+};
+
+// _Immortalize_memcpy_image is used to provide a nonstandard guarantee.
+// Specifically, we want the error category objects returned from things like std::system_category() to always
+//   be available, even during DLL unload (otherwise, <system_error> would be a huge regression vs. legacy error codes).
+// Moreover, we need to be very conservative in the runtime support we request. Thus, we have these constraints:
+//
+// * can't use magic statics in standard modes, because that would inject a .TLS section into all binaries using
+//   <system_error> and would likely put borderline programs over the TLS slot count limit, and would destroy the
+//   variable during DLL unload
+// * can't declare the error_category as an ordinary constexpr variable for most compilers before C++20, because
+//   error_category has a virtual destructor
+// * can't declare the error_category as an ordinary non-constexpr variable even with a constexpr constructor, because
+//   the compiler will emit code to destroy it which invalidates its use in these DLL shutdown scenarios
+//
+// As a result, we use a workaround: We create an atomic<uintptr_t> array to store the error_category instance, test
+//   if the first atomic is nonzero (acquire), and if so, we know we have formed the instance and can return a
+//   reinterpreted pointer to that storage. If the first atomic is zero, we write all except the first atomic (relaxed),
+//   then write the first one as a store-release. (The non-first values are transferred to other threads in the
+//   release sequence).
+//
+// Acknowledged undefined and implementation-defined behavior happening here:
+// * There is a data race when filling in the values other than the first atomic; this is OK on all hardware we target
+//   because the racing threads are all writing identical values that never change afterwards.
+// * We are reaching into the layout of atomic<uintptr_t>[N] and assuming we can reinterpret that as some other type.
+// * We are assuming that virtual functions are implemented with a vfptr located as the first member of an object.
+// (there are probably others)
+//
+// Inspecting the resulting assembly of any callers of _Immortalize_memcpy_image is recommended.
+//
+
+#if defined(_M_CEE_PURE)
+// /clr:pure doesn't ever do constant initialization, so rely on the CLR and magic statics
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    /* MAGIC */ static _Immortalizer_impl<_Ty> _Static;
+    return _Static._Storage;
+}
+#elif _HAS_CXX20
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    static constexpr _Ty _Static;
+    return _Static;
+}
+#elif defined(__clang__)
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    [[_Clang::__require_constant_initialization__]] static _Ty _Static;
+    return _Static;
+}
+#elif !defined(_M_CEE)
+template <class _Ty>
+struct _Constexpr_immortalize_impl {
+    union {
+        _Ty _Storage;
+    };
+
+    constexpr _Constexpr_immortalize_impl() noexcept : _Storage{} {}
+
+    _Constexpr_immortalize_impl(const _Constexpr_immortalize_impl&)            = delete;
+    _Constexpr_immortalize_impl& operator=(const _Constexpr_immortalize_impl&) = delete;
+
+    _MSVC_NOOP_DTOR ~_Constexpr_immortalize_impl() {
+        // do nothing, allowing _Ty to be used during shutdown
+    }
+};
+
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    static _Constexpr_immortalize_impl<_Ty> _Static;
+    return _Static._Storage;
+}
+#else // ^^^ !defined(_M_CEE) / defined(_M_CEE), TRANSITION, VSO-1153256 vvv
+template <class _Ty>
+_NODISCARD const _Ty& _Immortalize_memcpy_image() noexcept {
+    // return reference to a memcpy'd default-initialized _Ty
+    // pre: A default-initialized _Ty sets the first pointer-sized field to nonzero
+    constexpr size_t _Pointer_count = sizeof(_Ty) / sizeof(uintptr_t);
+    static atomic<uintptr_t> _Storage[_Pointer_count];
+    static_assert(sizeof(_Storage) == sizeof(_Ty), "Bad storage size");
+    static_assert(alignof(decltype(_Storage)) >= alignof(_Ty), "Bad alignment assumptions");
+    if (_Storage[0].load(memory_order_acquire) != 0) {
+        return reinterpret_cast<_Ty&>(_Storage);
+    }
+
+    const _Ty _Target;
+    const auto _Target_iter = reinterpret_cast<const uintptr_t*>(_STD addressof(_Target));
+    _CSTD memcpy(_Storage + 1, _Target_iter + 1, sizeof(_Ty) - sizeof(uintptr_t));
+    _Storage[0].store(_Target_iter[0], memory_order_release);
+    return reinterpret_cast<_Ty&>(_Storage);
+}
+#endif // ^^^ defined(_M_CEE), TRANSITION, VSO-1153256 ^^^
+
+_EXPORT_STD _NODISCARD inline const error_category& generic_category() noexcept {
+    return _Immortalize_memcpy_image<_Generic_error_category>();
+}
+
+_EXPORT_STD _NODISCARD inline const error_category& iostream_category() noexcept {
+    return _Immortalize_memcpy_image<_Iostream_error_category2>();
+}
+
+_EXPORT_STD _NODISCARD inline const error_category& system_category() noexcept {
+    return _Immortalize_memcpy_image<_System_error_category>();
+}
+_STD_END
+
+#if _HAS_CXX17
+extern "C" {
+enum class __std_win_error : unsigned long;
+} // extern "C"
+
+_STD_BEGIN
+// We would really love to use the proper way of building error_code by specializing
+// is_error_code_enum and make_error_code for __std_win_error, but because:
+//   1. We would like to keep the definition of __std_win_error in xfilesystem_abi.h
+//   2. and xfilesystem_abi.h cannot include <system_error>
+//   3. and specialization of is_error_code_enum and overload of make_error_code
+//      need to be kept together with the enum (see limerick in N4950 [temp.expl.spec]/8)
+// we resort to using this _Make_ec helper.
+_NODISCARD inline error_code _Make_ec(__std_win_error _Errno) noexcept { // make an error_code
+    return {static_cast<int>(_Errno), _STD system_category()};
+}
+
+[[noreturn]] inline void _Throw_system_error_from_std_win_error(const __std_win_error _Errno) {
+    _THROW(system_error{_Make_ec(_Errno)});
+}
+_STD_END
+#endif // _HAS_CXX17
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("noop_dtor")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _SYSTEM_ERROR_
diff --git a/msvc-stl/stl/inc/thread b/msvc-stl/stl/inc/thread
new file mode 100644
index 0000000..641d48a
--- /dev/null
+++ b/msvc-stl/stl/inc/thread
@@ -0,0 +1,446 @@
+// thread standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _THREAD_
+#define _THREAD_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _M_CEE_PURE
+#error <thread> is not supported when compiling with /clr:pure.
+#endif // defined(_M_CEE_PURE)
+
+#include <__msvc_chrono.hpp>
+#include <memory>
+#include <process.h>
+#include <tuple>
+#include <xthreads.h>
+
+#if _HAS_CXX20
+#include <compare>
+#include <stop_token>
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+#include <__msvc_formatter.hpp>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#if _HAS_CXX20
+_EXPORT_STD class jthread;
+#endif // _HAS_CXX20
+
+_EXPORT_STD class thread { // class for observing and managing threads
+public:
+    class id;
+
+    using native_handle_type = void*;
+
+    thread() noexcept : _Thr{} {}
+
+private:
+#if _HAS_CXX20
+    friend jthread;
+#endif // _HAS_CXX20
+
+    template <class _Tuple, size_t... _Indices>
+    static unsigned int __stdcall _Invoke(void* _RawVals) noexcept /* terminates */ {
+        // adapt invoke of user's callable object to _beginthreadex's thread procedure
+        const unique_ptr<_Tuple> _FnVals(static_cast<_Tuple*>(_RawVals));
+        _Tuple& _Tup = *_FnVals.get(); // avoid ADL, handle incomplete types
+        _STD invoke(_STD move(_STD get<_Indices>(_Tup))...);
+        _Cnd_do_broadcast_at_thread_exit(); // TRANSITION, ABI
+        return 0;
+    }
+
+    template <class _Tuple, size_t... _Indices>
+    _NODISCARD static constexpr auto _Get_invoke(index_sequence<_Indices...>) noexcept {
+        return &_Invoke<_Tuple, _Indices...>;
+    }
+
+#pragma warning(push) // pointer or reference to potentially throwing function passed to 'extern "C"' function under
+#pragma warning(disable : 5039) // -EHc. Undefined behavior may occur if this function throws an exception. (/Wall)
+    template <class _Fn, class... _Args>
+    void _Start(_Fn&& _Fx, _Args&&... _Ax) {
+        using _Tuple                 = tuple<decay_t<_Fn>, decay_t<_Args>...>;
+        auto _Decay_copied           = _STD make_unique<_Tuple>(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...);
+        constexpr auto _Invoker_proc = _Get_invoke<_Tuple>(make_index_sequence<1 + sizeof...(_Args)>{});
+
+        _Thr._Hnd =
+            reinterpret_cast<void*>(_CSTD _beginthreadex(nullptr, 0, _Invoker_proc, _Decay_copied.get(), 0, &_Thr._Id));
+
+        if (_Thr._Hnd) { // ownership transferred to the thread
+            (void) _Decay_copied.release();
+        } else { // failed to start thread
+            _Thr._Id = 0;
+            _Throw_Cpp_error(_RESOURCE_UNAVAILABLE_TRY_AGAIN);
+        }
+    }
+#pragma warning(pop)
+
+public:
+    template <class _Fn, class... _Args, enable_if_t<!is_same_v<_Remove_cvref_t<_Fn>, thread>, int> = 0>
+    _NODISCARD_CTOR_THREAD explicit thread(_Fn&& _Fx, _Args&&... _Ax) {
+        _Start(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...);
+    }
+
+    ~thread() noexcept {
+        if (joinable()) {
+            _STD terminate(); // per N4950 [thread.thread.destr]/1
+        }
+    }
+
+    thread(thread&& _Other) noexcept : _Thr(_STD exchange(_Other._Thr, {})) {}
+
+    thread& operator=(thread&& _Other) noexcept {
+        if (joinable()) {
+            _STD terminate(); // per N4950 [thread.thread.assign]/1
+        }
+
+        _Thr = _STD exchange(_Other._Thr, {});
+        return *this;
+    }
+
+    thread(const thread&)            = delete;
+    thread& operator=(const thread&) = delete;
+
+    void swap(thread& _Other) noexcept {
+        _STD swap(_Thr, _Other._Thr);
+    }
+
+    _NODISCARD bool joinable() const noexcept {
+        return _Thr._Id != 0;
+    }
+
+    void join() {
+        if (!joinable()) {
+            _Throw_Cpp_error(_INVALID_ARGUMENT);
+        }
+
+        if (_Thr._Id == _Thrd_id()) {
+            _Throw_Cpp_error(_RESOURCE_DEADLOCK_WOULD_OCCUR);
+        }
+
+        if (_Thrd_join(_Thr, nullptr) != _Thrd_result::_Success) {
+            _Throw_Cpp_error(_NO_SUCH_PROCESS);
+        }
+
+        _Thr = {};
+    }
+
+    void detach() {
+        if (!joinable()) {
+            _Throw_Cpp_error(_INVALID_ARGUMENT);
+        }
+
+        if (_Thrd_detach(_Thr) != _Thrd_result::_Success) {
+            _Throw_Cpp_error(_INVALID_ARGUMENT);
+        }
+
+        _Thr = {};
+    }
+
+    _NODISCARD id get_id() const noexcept;
+
+    _NODISCARD native_handle_type native_handle() noexcept /* strengthened */ { // return Win32 HANDLE as void *
+        return _Thr._Hnd;
+    }
+
+    _NODISCARD static unsigned int hardware_concurrency() noexcept {
+        return _Thrd_hardware_concurrency();
+    }
+
+private:
+    _Thrd_t _Thr;
+};
+
+template <class _Rep, class _Period>
+_NODISCARD auto _To_absolute_time(const chrono::duration<_Rep, _Period>& _Rel_time) noexcept {
+    constexpr auto _Zero                 = chrono::duration<_Rep, _Period>::zero();
+    const auto _Now                      = chrono::steady_clock::now();
+    decltype(_Now + _Rel_time) _Abs_time = _Now; // return common type
+    if (_Rel_time > _Zero) {
+        constexpr auto _Forever = (decltype(_Abs_time)::max)();
+        if (_Abs_time < _Forever - _Rel_time) {
+            _Abs_time += _Rel_time;
+        } else {
+            _Abs_time = _Forever;
+        }
+    }
+    return _Abs_time;
+}
+
+struct _Clamped_rel_time_ms_count_result {
+    unsigned long _Count;
+    bool _Clamped;
+};
+
+template <class _Duration>
+_NODISCARD _Clamped_rel_time_ms_count_result _Clamped_rel_time_ms_count(const _Duration& _Rel) {
+    // _Clamp must be less than 2^32 - 1 (INFINITE) milliseconds, but is otherwise arbitrary.
+    constexpr chrono::milliseconds _Clamp{chrono::hours{24}};
+
+    if (_Rel > _Clamp) {
+        return {static_cast<unsigned long>(_Clamp.count()), true};
+    } else {
+        const auto _Rel_ms = chrono::ceil<chrono::milliseconds>(_Rel);
+        return {static_cast<unsigned long>(_Rel_ms.count()), false};
+    }
+}
+
+namespace this_thread {
+    _EXPORT_STD _NODISCARD thread::id get_id() noexcept;
+
+    _EXPORT_STD inline void yield() noexcept {
+        _Thrd_yield();
+    }
+
+    _EXPORT_STD template <class _Clock, class _Duration>
+    void sleep_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
+        static_assert(chrono::_Is_clock_v<_Clock>, "Clock type required");
+        for (;;) {
+            const auto _Now = _Clock::now();
+            if (_Abs_time <= _Now) {
+                return;
+            }
+
+            const unsigned long _Rel_ms_count = _Clamped_rel_time_ms_count(_Abs_time - _Now)._Count;
+            _Thrd_sleep_for(_Rel_ms_count);
+        }
+    }
+
+    _EXPORT_STD template <class _Rep, class _Period>
+    void sleep_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
+        sleep_until(_To_absolute_time(_Rel_time));
+    }
+} // namespace this_thread
+
+class thread::id { // thread id
+public:
+    id() noexcept = default; // id for no thread
+
+#if _HAS_CXX23
+    _NODISCARD _Thrd_id_t _Get_underlying_id() const noexcept {
+        return _Id;
+    }
+#endif // _HAS_CXX23
+
+private:
+    explicit id(_Thrd_id_t _Other_id) noexcept : _Id(_Other_id) {}
+
+    _Thrd_id_t _Id = 0;
+
+    friend thread::id thread::get_id() const noexcept;
+    friend thread::id this_thread::get_id() noexcept;
+    friend bool operator==(thread::id _Left, thread::id _Right) noexcept;
+#if _HAS_CXX20
+    friend strong_ordering operator<=>(thread::id _Left, thread::id _Right) noexcept;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    friend bool operator<(thread::id _Left, thread::id _Right) noexcept;
+#endif // ^^^ !_HAS_CXX20 ^^^
+    template <class _Ch, class _Tr>
+    friend basic_ostream<_Ch, _Tr>& operator<<(basic_ostream<_Ch, _Tr>& _Str, thread::id _Id);
+    friend hash<thread::id>;
+};
+
+_NODISCARD inline thread::id thread::get_id() const noexcept {
+    return thread::id{_Thr._Id};
+}
+
+_EXPORT_STD _NODISCARD inline thread::id this_thread::get_id() noexcept {
+    return thread::id{_Thrd_id()};
+}
+
+_EXPORT_STD inline void swap(thread& _Left, thread& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD _NODISCARD inline bool operator==(thread::id _Left, thread::id _Right) noexcept {
+    return _Left._Id == _Right._Id;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD inline strong_ordering operator<=>(thread::id _Left, thread::id _Right) noexcept {
+    return _Left._Id <=> _Right._Id;
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+_NODISCARD inline bool operator!=(thread::id _Left, thread::id _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+_NODISCARD inline bool operator<(thread::id _Left, thread::id _Right) noexcept {
+    return _Left._Id < _Right._Id;
+}
+
+_NODISCARD inline bool operator<=(thread::id _Left, thread::id _Right) noexcept {
+    return !(_Right < _Left);
+}
+
+_NODISCARD inline bool operator>(thread::id _Left, thread::id _Right) noexcept {
+    return _Right < _Left;
+}
+
+_NODISCARD inline bool operator>=(thread::id _Left, thread::id _Right) noexcept {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Ch, class _Tr>
+basic_ostream<_Ch, _Tr>& operator<<(basic_ostream<_Ch, _Tr>& _Str, thread::id _Id) {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Thrd_id_t) == 4);
+    _Ch _Buff[11]; // can hold 2^32 - 1, plus terminating null
+    _Ch* _RNext = _STD end(_Buff);
+    *--_RNext   = static_cast<_Ch>('\0');
+    _RNext      = _STD _UIntegral_to_buff(_RNext, _Id._Id);
+    return _Str << _RNext;
+}
+
+#if _HAS_CXX23
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+template <_Format_supported_charT _CharT>
+struct formatter<thread::id, _CharT> {
+    template <class _ParseContext = basic_format_parse_context<_CharT>> // improves throughput, see GH-5003
+    constexpr _ParseContext::iterator parse(type_identity_t<_ParseContext&> _Parse_ctx) {
+        return _Impl._Parse(_Parse_ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(thread::id _Val, _FormatContext& _Format_ctx) const {
+        _STL_INTERNAL_STATIC_ASSERT(sizeof(_Thrd_id_t) == 4);
+        _CharT _Buff[10]; // can hold 2^32 - 1
+        _CharT* const _Last        = _STD end(_Buff);
+        const _CharT* const _First = _STD _UIntegral_to_buff(_Last, _Val._Get_underlying_id());
+        return _Impl._Format(_Format_ctx, static_cast<int>(_Last - _First), _Fmt_align::_Right,
+            [&](_FormatContext::iterator _Out) { return _RANGES copy(_First, _Last, _STD move(_Out)).out; });
+    }
+
+private:
+    _Fill_align_and_width_formatter<_CharT> _Impl;
+};
+
+template <>
+inline constexpr bool enable_nonlocking_formatter_optimization<thread::id> = true;
+#endif // _HAS_CXX23
+
+template <>
+struct hash<thread::id> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = thread::id;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(const thread::id _Keyval) noexcept {
+        return _Hash_representation(_Keyval._Id);
+    }
+};
+
+#if _HAS_CXX20
+_EXPORT_STD class jthread {
+public:
+    using id                 = thread::id;
+    using native_handle_type = thread::native_handle_type;
+
+    jthread() noexcept : _Impl{}, _Ssource{nostopstate} {}
+
+    template <class _Fn, class... _Args>
+        requires (!is_same_v<remove_cvref_t<_Fn>, jthread>)
+    _NODISCARD_CTOR_JTHREAD explicit jthread(_Fn&& _Fx, _Args&&... _Ax) {
+        if constexpr (is_invocable_v<decay_t<_Fn>, stop_token, decay_t<_Args>...>) {
+            _Impl._Start(_STD forward<_Fn>(_Fx), _Ssource.get_token(), _STD forward<_Args>(_Ax)...);
+        } else {
+            _Impl._Start(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...);
+        }
+    }
+
+    ~jthread() {
+        _Try_cancel_and_join();
+    }
+
+    jthread(const jthread&)            = delete;
+    jthread(jthread&&) noexcept        = default;
+    jthread& operator=(const jthread&) = delete;
+
+    jthread& operator=(jthread&& _Other) noexcept {
+        if (this == _STD addressof(_Other)) {
+            return *this;
+        }
+
+        _Try_cancel_and_join();
+        _Impl    = _STD move(_Other._Impl);
+        _Ssource = _STD move(_Other._Ssource);
+        return *this;
+    }
+
+    void swap(jthread& _Other) noexcept {
+        _Impl.swap(_Other._Impl);
+        _Ssource.swap(_Other._Ssource);
+    }
+
+    _NODISCARD bool joinable() const noexcept {
+        return _Impl.joinable();
+    }
+
+    void join() {
+        _Impl.join();
+    }
+
+    void detach() {
+        _Impl.detach();
+    }
+
+    _NODISCARD id get_id() const noexcept {
+        return _Impl.get_id();
+    }
+
+    _NODISCARD native_handle_type native_handle() noexcept /* strengthened */ {
+        return _Impl.native_handle();
+    }
+
+    _NODISCARD stop_source get_stop_source() noexcept {
+        return _Ssource;
+    }
+
+    _NODISCARD stop_token get_stop_token() const noexcept {
+        return _Ssource.get_token();
+    }
+
+    bool request_stop() noexcept {
+        return _Ssource.request_stop();
+    }
+
+    friend void swap(jthread& _Lhs, jthread& _Rhs) noexcept {
+        _Lhs.swap(_Rhs);
+    }
+
+    _NODISCARD static unsigned int hardware_concurrency() noexcept {
+        return thread::hardware_concurrency();
+    }
+
+private:
+    void _Try_cancel_and_join() noexcept {
+        if (_Impl.joinable()) {
+            _Ssource.request_stop();
+            _Impl.join();
+        }
+    }
+
+    thread _Impl;
+    stop_source _Ssource;
+};
+#endif // _HAS_CXX20
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _THREAD_
diff --git a/msvc-stl/stl/inc/tuple b/msvc-stl/stl/inc/tuple
new file mode 100644
index 0000000..c560c46
--- /dev/null
+++ b/msvc-stl/stl/inc/tuple
@@ -0,0 +1,1346 @@
+// tuple standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _TUPLE_
+#define _TUPLE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+#include <__msvc_iter_core.hpp>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_conditional_explicit_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_conditional_explicit_v0<true, tuple<_Dests...>, _Srcs...> =
+    !conjunction_v<is_convertible<_Srcs, _Dests>...>;
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_conditional_explicit_v =
+    _Tuple_conditional_explicit_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_constructible_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_constructible<_Dests, _Srcs>...>;
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_constructible_v =
+    _Tuple_constructible_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+template <class _Dest, class... _Srcs>
+struct _Tuple_constructible_val : bool_constant<_Tuple_constructible_v<_Dest, _Srcs...>> {};
+
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_nothrow_constructible_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_nothrow_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_nothrow_constructible<_Dests, _Srcs>...>;
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_nothrow_constructible_v =
+    _Tuple_nothrow_constructible_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_assignable_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_assignable<_Dests&, _Srcs>...>; // note _Dests& instead of _Dests
+
+#if _HAS_CXX23
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_assignable_v0<true, const tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_assignable<const _Dests&, _Srcs>...>;
+#endif // _HAS_CXX23
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_assignable_v = _Tuple_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+template <class _Dest, class... _Srcs>
+struct _Tuple_assignable_val : bool_constant<_Tuple_assignable_v<_Dest, _Srcs...>> {};
+
+template <bool _Same, class _Dest, class... _Srcs>
+constexpr bool _Tuple_nothrow_assignable_v0 = false;
+
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_nothrow_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_nothrow_assignable<_Dests&, _Srcs>...>; // note _Dests& instead of _Dests
+
+#if _HAS_CXX23
+template <class... _Dests, class... _Srcs>
+constexpr bool _Tuple_nothrow_assignable_v0<true, const tuple<_Dests...>, _Srcs...> =
+    conjunction_v<is_nothrow_assignable<const _Dests&, _Srcs>...>;
+#endif // _HAS_CXX23
+
+template <class _Dest, class... _Srcs>
+constexpr bool _Tuple_nothrow_assignable_v =
+    _Tuple_nothrow_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+
+// Constrain tuple's converting constructors
+template <class _Myself, class _OtherTuple, class... _Other>
+struct _Tuple_convert_val : true_type {};
+
+template <class _This, class _OtherTuple, class _Uty>
+struct _Tuple_convert_val<tuple<_This>, _OtherTuple, _Uty>
+    : bool_constant<!disjunction_v<is_same<_This, _Uty>, is_constructible<_This, _OtherTuple>,
+          is_convertible<_OtherTuple, _This>>> {};
+
+// Constrain tuple's perfect forwarding constructor (LWG-3121)
+template <class _Myself, class _This2, class... _Rest2>
+struct _Tuple_perfect_val : true_type {};
+
+template <class _Myself, class _This2>
+struct _Tuple_perfect_val<_Myself, _This2> : bool_constant<!is_same_v<_Myself, _Remove_cvref_t<_This2>>> {};
+
+template <class _Ty0, class _Ty1, class _Uty0, class _Uty1>
+struct _Tuple_perfect_val<tuple<_Ty0, _Ty1>, _Uty0, _Uty1>
+    : bool_constant<disjunction_v<negation<is_same<_Remove_cvref_t<_Uty0>, allocator_arg_t>>,
+          is_same<_Remove_cvref_t<_Ty0>, allocator_arg_t>>> {};
+
+template <class _Ty0, class _Ty1, class _Ty2, class _Uty0, class _Uty1, class _Uty2>
+struct _Tuple_perfect_val<tuple<_Ty0, _Ty1, _Ty2>, _Uty0, _Uty1, _Uty2>
+    : bool_constant<disjunction_v<negation<is_same<_Remove_cvref_t<_Uty0>, allocator_arg_t>>,
+          is_same<_Remove_cvref_t<_Ty0>, allocator_arg_t>>> {};
+
+// Note: To improve throughput, this file uses extra _STD qualification for names that appear in the
+// arguments of enable_if_t. Specifically, we qualify names which appear anywhere in the STL as members of
+// some class - including injected-class-names! - that we know are not members of the class being defined.
+// This avoids pointless class-member lookup for those names in this context.
+
+template <class _Ty>
+struct _Tuple_val { // stores each value in a tuple
+    // Use of remove_cv_t corresponds to N5008 [allocator.uses.construction]/5.
+    using _Dty = remove_cv_t<_Ty>;
+
+    constexpr _Tuple_val() : _Val() {}
+
+    template <class _Other>
+    constexpr _Tuple_val(_Other&& _Arg) : _Val(_STD forward<_Other>(_Arg)) {}
+
+    template <class _Alloc, class... _Other, enable_if_t<!uses_allocator_v<_Dty, _Alloc>, int> = 0>
+    constexpr _Tuple_val(const _Alloc&, allocator_arg_t, _Other&&... _Arg) : _Val(_STD forward<_Other>(_Arg)...) {}
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD uses_allocator<_Dty, _Alloc>,
+                        _STD is_constructible<_Ty, _STD allocator_arg_t, const _Alloc&, _Other...>>,
+            int> = 0>
+    constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg)
+        : _Val(allocator_arg_t{}, _Al, _STD forward<_Other>(_Arg)...) {}
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD uses_allocator<_Dty, _Alloc>,
+                        _STD negation<_STD is_constructible<_Ty, _STD allocator_arg_t, const _Alloc&, _Other...>>>,
+            int> = 0>
+    constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg)
+        : _Val(_STD forward<_Other>(_Arg)..., _Al) {}
+
+    _Ty _Val;
+};
+
+struct _Exact_args_t {
+    explicit _Exact_args_t() = default;
+}; // tag type to disambiguate construction (from one arg per element)
+
+struct _Unpack_tuple_t {
+    explicit _Unpack_tuple_t() = default;
+}; // tag type to disambiguate construction (from unpacking a tuple/pair)
+
+struct _Alloc_exact_args_t {
+    explicit _Alloc_exact_args_t() = default;
+}; // tag type to disambiguate construction (from an allocator and one arg per element)
+
+struct _Alloc_unpack_tuple_t {
+    explicit _Alloc_unpack_tuple_t() = default;
+}; // tag type to disambiguate construction (from an allocator and unpacking a tuple/pair)
+
+#if _HAS_CXX23
+template <class _Tuple, class _Other, class _Indices = make_index_sequence<tuple_size_v<_Tuple>>>
+constexpr bool _Can_construct_values_from_tuple_like_v = false;
+
+template <class... _Types, class _Other, size_t... _Indices>
+constexpr bool _Can_construct_values_from_tuple_like_v<tuple<_Types...>, _Other, index_sequence<_Indices...>> =
+    conjunction_v<is_constructible<_Types, decltype(_STD get<_Indices>(_STD declval<_Other>()))>...>;
+
+#ifdef __EDG__ // TRANSITION, VSO-1900279
+template <class _TupleLike, class _Tuple>
+concept _Can_construct_from_tuple_like = _Different_from<_TupleLike, _Tuple> && _Tuple_like_non_subrange<_TupleLike>
+                                      && (tuple_size_v<_Tuple> == tuple_size_v<remove_cvref_t<_TupleLike>>)
+                                      && _Can_construct_values_from_tuple_like_v<_Tuple, _TupleLike>
+                                      && (tuple_size_v<_Tuple> != 1
+                                          || (!is_convertible_v<_TupleLike, tuple_element_t<0, _Tuple>>
+                                              && !is_constructible_v<tuple_element_t<0, _Tuple>, _TupleLike>) );
+#endif // ^^^ workaround ^^^
+
+template <class _TTuple, class _UTuple, class _Indices = make_index_sequence<tuple_size_v<_UTuple>>>
+struct _Three_way_comparison_result_with_tuple_like {};
+
+template <class... _TTypes, class _UTuple, size_t... _Indices>
+    requires
+#if !defined(__clang__) && !defined(__EDG__) && _MSC_VER < 1951 // TRANSITION, toolset update
+    (sizeof...(_TTypes) == sizeof...(_Indices)) &&
+#endif // ^^^ workaround ^^^
+    (requires { typename _Synth_three_way_result<_TTypes, tuple_element_t<_Indices, _UTuple>>; } && ...)
+struct _Three_way_comparison_result_with_tuple_like<tuple<_TTypes...>, _UTuple, index_sequence<_Indices...>> {
+    using type = common_comparison_category_t<_Synth_three_way_result<_TTypes, tuple_element_t<_Indices, _UTuple>>...>;
+};
+
+template <class _TTuple, _Tuple_like _UTuple>
+using _Three_way_comparison_result_with_tuple_like_t =
+    _Three_way_comparison_result_with_tuple_like<_TTuple, _UTuple>::type;
+
+template <class _Ty>
+concept _Tuple_like_non_tuple = !_Is_specialization_v<_Ty, tuple> && _Tuple_like<_Ty>;
+
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+template <class _Tuple, class... _Args>
+constexpr bool _Tuple_reference_constructs_from_temporary = false;
+template <class... _TupleTypes, class... _Args>
+constexpr bool _Tuple_reference_constructs_from_temporary<tuple<_TupleTypes...>, _Args...> =
+    (reference_constructs_from_temporary_v<_TupleTypes, _Args> || ...);
+
+template <class _Tuple, class _TupleLike, class _IdxSeq = make_index_sequence<tuple_size_v<_Tuple>>>
+constexpr bool _Tuple_reference_constructs_from_temporary_for_tuple_like = false;
+template <class _Tuple, _Tuple_like _TupleLike, size_t... _Indices>
+    requires (tuple_size_v<_Tuple> == tuple_size_v<remove_reference_t<_TupleLike>>)
+constexpr bool
+    _Tuple_reference_constructs_from_temporary_for_tuple_like<_Tuple, _TupleLike, index_sequence<_Indices...>> =
+        _Tuple_reference_constructs_from_temporary<_Tuple, decltype(_STD get<_Indices>(_STD declval<_TupleLike>()))...>;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+template <>
+class tuple<> { // empty tuple
+public:
+    constexpr tuple() noexcept = default; /* strengthened */
+
+    constexpr tuple(const tuple&) noexcept /* strengthened */ {} // TRANSITION, ABI: should be defaulted
+
+#if _HAS_CXX23
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple(_Other&&) noexcept /* strengthened */ {}
+#endif // _HAS_CXX23
+
+    template <class _Alloc>
+    _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc&) noexcept /* strengthened */ {}
+
+    template <class _Alloc>
+    _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept /* strengthened */ {}
+
+#if _HAS_CXX23
+    template <class _Alloc, _Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple(allocator_arg_t, const _Alloc&, _Other&&) noexcept /* strengthened */ {}
+#endif // _HAS_CXX23
+
+    template <class _Tag, enable_if_t<is_same_v<_Tag, _STD _Exact_args_t>, int> = 0>
+    constexpr tuple(_Tag) noexcept /* strengthened */ {}
+
+    template <class _Tag, class _Alloc, enable_if_t<is_same_v<_Tag, _STD _Alloc_exact_args_t>, int> = 0>
+    constexpr tuple(_Tag, const _Alloc&) noexcept /* strengthened */ {}
+
+    constexpr tuple& operator=(const tuple&) = default;
+#if _HAS_CXX23
+    constexpr const tuple& operator=(const tuple&) const noexcept /* strengthened */ {
+        return *this;
+    }
+
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr tuple& operator=(_Other&&) noexcept /* strengthened */ {
+        return *this;
+    }
+
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like<_Other> && (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    constexpr const tuple& operator=(_Other&&) const noexcept /* strengthened */ {
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void swap(tuple&) noexcept {}
+#if _HAS_CXX23
+    constexpr void swap(const tuple&) const noexcept {}
+#endif // _HAS_CXX23
+
+    constexpr bool _Equals(const tuple&) const noexcept {
+        return true;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering _Three_way_compare(const tuple&) const noexcept {
+        return strong_ordering::equal;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD constexpr bool _Less(const tuple&) const noexcept {
+        return false;
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX23
+    template <_Tuple_like_non_tuple _Other>
+    _NODISCARD friend constexpr bool operator==(const tuple&, const _Other&) noexcept /* strengthened */ {
+        static_assert(tuple_size_v<_Other> == 0, "Cannot compare tuples of different sizes (N4950 [tuple.rel]/2).");
+        return true;
+    }
+
+    template <_Tuple_like_non_tuple _Other>
+        requires (tuple_size_v<remove_cvref_t<_Other>> == 0)
+    _NODISCARD friend constexpr strong_ordering operator<=>(const tuple&, const _Other&) noexcept /* strengthened */ {
+        return strong_ordering::equal;
+    }
+#endif // _HAS_CXX23
+};
+
+template <class _This, class... _Rest>
+class tuple<_This, _Rest...> : private tuple<_Rest...> { // recursive tuple definition
+public:
+    using _This_type = _This;
+    using _Mybase    = tuple<_Rest...>;
+
+    template <class _Tag, class _This2, class... _Rest2, enable_if_t<is_same_v<_Tag, _STD _Exact_args_t>, int> = 0>
+    constexpr tuple(_Tag, _This2&& _This_arg, _Rest2&&... _Rest_arg)
+        : _Mybase(_Exact_args_t{}, _STD forward<_Rest2>(_Rest_arg)...), _Myfirst(_STD forward<_This2>(_This_arg)) {}
+
+    template <class _Tag, class _Tpl, size_t... _Indices, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> = 0>
+    constexpr tuple(_Tag, _Tpl&& _Right, index_sequence<_Indices...>);
+
+    template <class _Tag, class _Tpl, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> = 0>
+    constexpr tuple(_Tag, _Tpl&& _Right)
+        : tuple(_Unpack_tuple_t{}, _STD forward<_Tpl>(_Right),
+              make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}
+
+    template <class _Tag, class _Alloc, class _This2, class... _Rest2,
+        enable_if_t<is_same_v<_Tag, _STD _Alloc_exact_args_t>, int> = 0>
+    constexpr tuple(_Tag, const _Alloc& _Al, _This2&& _This_arg, _Rest2&&... _Rest_arg)
+        : _Mybase(_Alloc_exact_args_t{}, _Al, _STD forward<_Rest2>(_Rest_arg)...),
+          _Myfirst(_Al, allocator_arg, _STD forward<_This2>(_This_arg)) {}
+
+    template <class _Tag, class _Alloc, class _Tpl, size_t... _Indices,
+        enable_if_t<is_same_v<_Tag, _STD _Alloc_unpack_tuple_t>, int> = 0>
+    constexpr tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right, index_sequence<_Indices...>);
+
+    template <class _Tag, class _Alloc, class _Tpl, enable_if_t<is_same_v<_Tag, _STD _Alloc_unpack_tuple_t>, int> = 0>
+    constexpr tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD forward<_Tpl>(_Right),
+              make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}
+
+    template <class _This2 = _This,
+        enable_if_t<conjunction_v<_STD is_default_constructible<_This2>, _STD is_default_constructible<_Rest>...>,
+            int>           = 0>
+    constexpr explicit(
+        !conjunction_v<_Is_implicitly_default_constructible<_This2>, _Is_implicitly_default_constructible<_Rest>...>)
+        tuple() noexcept(conjunction_v<is_nothrow_default_constructible<_This2>,
+            is_nothrow_default_constructible<_Rest>...>) // strengthened
+        : _Mybase(), _Myfirst() {}
+
+    template <class _This2 = _This, enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _This2&, const _Rest&...>)
+        tuple(const _This& _This_arg, const _Rest&... _Rest_arg)
+            noexcept(conjunction_v<is_nothrow_copy_constructible<_This2>,
+                is_nothrow_copy_constructible<_Rest>...>) // strengthened
+        : tuple(_Exact_args_t{}, _This_arg, _Rest_arg...) {}
+
+    template <class _This2, class... _Rest2,
+        enable_if_t<conjunction_v<_STD _Tuple_perfect_val<tuple, _This2, _Rest2...>,
+                        _STD _Tuple_constructible_val<tuple, _This2, _Rest2...>>,
+            int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>)
+        tuple(_This2&& _This_arg, _Rest2&&... _Rest_arg)
+            noexcept(_Tuple_nothrow_constructible_v<tuple, _This2, _Rest2...>) // strengthened
+        : tuple(_Exact_args_t{}, _STD forward<_This2>(_This_arg), _STD forward<_Rest2>(_Rest_arg)...) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _This2, class... _Rest2,
+        enable_if_t<conjunction_v<_STD _Tuple_perfect_val<tuple, _This2, _Rest2...>,
+                        _STD _Tuple_constructible_val<tuple, _This2, _Rest2...>>,
+            int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _This2&&, _Rest2&&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>) tuple(_This2&&, _Rest2&&...) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    tuple(const tuple&) = default;
+    tuple(tuple&&)      = default;
+
+#if _HAS_CXX23
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other&...>,
+                                               _STD _Tuple_convert_val<tuple, tuple<_Other...>&, _Other...>>,
+                                   int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _Other&...>) tuple(tuple<_Other...>& _Right)
+        noexcept(_Tuple_nothrow_constructible_v<tuple, _Other&...>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _Right) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other&...>,
+                                               _STD _Tuple_convert_val<tuple, tuple<_Other...>&, _Other...>>,
+                                   int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _Other&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, _Other&...>) tuple(tuple<_Other...>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other&...>,
+                                               _STD _Tuple_convert_val<tuple, const tuple<_Other...>&, _Other...>>,
+                                   int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _Other&...>) tuple(const tuple<_Other...>& _Right)
+        noexcept(_Tuple_nothrow_constructible_v<tuple, const _Other&...>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _Right) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other&...>,
+                                               _STD _Tuple_convert_val<tuple, const tuple<_Other...>&, _Other...>>,
+                                   int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, const _Other&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, const _Other&...>) tuple(const tuple<_Other...>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other...>,
+                                               _STD _Tuple_convert_val<tuple, tuple<_Other...>, _Other...>>,
+                                   int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _Other...>) tuple(tuple<_Other...>&& _Right)
+        noexcept(_Tuple_nothrow_constructible_v<tuple, _Other...>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other...>,
+                                               _STD _Tuple_convert_val<tuple, tuple<_Other...>, _Other...>>,
+                                   int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _Other&&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, _Other...>) tuple(tuple<_Other...>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other...>,
+                                               _STD _Tuple_convert_val<tuple, const tuple<_Other...>, _Other...>>,
+                                   int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _Other...>) tuple(const tuple<_Other...>&& _Right)
+        noexcept(_Tuple_nothrow_constructible_v<tuple, const _Other...>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class... _Other, enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other...>,
+                                               _STD _Tuple_convert_val<tuple, const tuple<_Other...>, _Other...>>,
+                                   int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, const _Other&&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, const _Other...>) tuple(const tuple<_Other...>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+    template <class _First, class _Second, enable_if_t<_Tuple_constructible_v<tuple, _First&, _Second&>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _First&, _Second&>) tuple(pair<_First, _Second>& _Right)
+        noexcept(_Tuple_nothrow_constructible_v<tuple, _First&, _Second&>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _Right) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _First, class _Second, enable_if_t<_Tuple_constructible_v<tuple, _First&, _Second&>, int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _First&, _Second&>
+    explicit(_Tuple_conditional_explicit_v<tuple, _First&, _Second&>) tuple(pair<_First, _Second>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First&, const _Second&>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First&, const _Second&>)
+        tuple(const pair<_First, _Second>& _Right)
+            noexcept(_Tuple_nothrow_constructible_v<tuple, const _First&, const _Second&>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _Right) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First&, const _Second&>, int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, const _First&, const _Second&>
+    explicit(_Tuple_conditional_explicit_v<tuple, const _First&, const _Second&>)
+        tuple(const pair<_First, _Second>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _First, class _Second, enable_if_t<_Tuple_constructible_v<tuple, _First, _Second>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _First, _Second>) tuple(pair<_First, _Second>&& _Right)
+        noexcept(_Tuple_nothrow_constructible_v<tuple, _First, _Second>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _First, class _Second, enable_if_t<_Tuple_constructible_v<tuple, _First, _Second>, int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _First&&, _Second&&>
+    explicit(_Tuple_conditional_explicit_v<tuple, _First, _Second>) tuple(pair<_First, _Second>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+    template <class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First, const _Second>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First, const _Second>)
+        tuple(const pair<_First, _Second>&& _Right)
+            noexcept(_Tuple_nothrow_constructible_v<tuple, const _First, const _Second>) // strengthened
+        : tuple(_Unpack_tuple_t{}, _STD move(_Right)) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First, const _Second>, int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, const _First&&, const _Second&&>
+    explicit(_Tuple_conditional_explicit_v<tuple, const _First, const _Second>)
+        tuple(const pair<_First, _Second>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+    template <class _Other, class _Indices = index_sequence_for<_Rest...>>
+    static constexpr bool _Is_tuple_like_constructor_explicit_v = false;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Is_tuple_like_constructor_explicit_v<_Other, index_sequence<_Indices...>> =
+        negation_v<conjunction<is_convertible<decltype(_STD get<0>(_STD declval<_Other>())), _This>,
+            is_convertible<decltype(_STD get<_Indices + 1>(_STD declval<_Other>())), _Rest>...>>;
+
+#ifdef __EDG__ // TRANSITION, VSO-1900279
+    template <class _Other, enable_if_t<_Can_construct_from_tuple_like<_Other, tuple>, int> = 0>
+#else // ^^^ workaround / no workaround vvv
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like_non_subrange<_Other> && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_construct_values_from_tuple_like_v<tuple, _Other>
+              && (sizeof...(_Rest) != 0 || (!is_convertible_v<_Other, _This> && !is_constructible_v<_This, _Other>) )
+#endif // ^^^ no workaround ^^^
+    constexpr explicit(_Is_tuple_like_constructor_explicit_v<_Other>) tuple(_Other&& _Right)
+        : tuple(_Unpack_tuple_t{}, _STD forward<_Other>(_Right)) {
+    }
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like_non_subrange<_Other> && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+                  && _Can_construct_values_from_tuple_like_v<tuple, _Other>
+                  && (sizeof...(_Rest) != 0
+                      || (!is_convertible_v<_Other, _This> && !is_constructible_v<_This, _Other>) )
+                  && _Tuple_reference_constructs_from_temporary_for_tuple_like<tuple, _Other&&>
+    explicit(_Is_tuple_like_constructor_explicit_v<_Other>) tuple(_Other&&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class _This2 = _This,
+        enable_if_t<conjunction_v<_STD is_default_constructible<_This2>, _STD is_default_constructible<_Rest>...>,
+            int> = 0>
+    _CONSTEXPR20 explicit(
+        !conjunction_v<_Is_implicitly_default_constructible<_This2>, _Is_implicitly_default_constructible<_Rest>...>)
+        tuple(allocator_arg_t, const _Alloc& _Al)
+        : _Mybase(allocator_arg, _Al), _Myfirst(_Al, allocator_arg) {}
+
+    template <class _Alloc, class _This2 = _This,
+        enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, const _This2&, const _Rest&...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const _This& _This_arg, const _Rest&... _Rest_arg)
+        : tuple(_Alloc_exact_args_t{}, _Al, _This_arg, _Rest_arg...) {}
+
+    template <class _Alloc, class _This2, class... _Rest2,
+        enable_if_t<conjunction_v<_STD _Tuple_perfect_val<tuple, _This2, _Rest2...>,
+                        _STD _Tuple_constructible_val<tuple, _This2, _Rest2...>>,
+            int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, _This2&& _This_arg, _Rest2&&... _Rest_arg)
+        : tuple(_Alloc_exact_args_t{}, _Al, _STD forward<_This2>(_This_arg), _STD forward<_Rest2>(_Rest_arg)...) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class _This2, class... _Rest2,
+        enable_if_t<conjunction_v<_STD _Tuple_perfect_val<tuple, _This2, _Rest2...>,
+                        _STD _Tuple_constructible_val<tuple, _This2, _Rest2...>>,
+            int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _This2&&, _Rest2&&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>)
+        tuple(allocator_arg_t, const _Alloc&, _This2&&, _Rest2&&...) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class _This2 = _This,
+        enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
+    _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc& _Al, const tuple& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+
+    template <class _Alloc, class _This2 = _This, enable_if_t<_Tuple_constructible_v<tuple, _This2, _Rest...>, int> = 0>
+    _CONSTEXPR20 tuple(allocator_arg_t, const _Alloc& _Al, tuple&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+
+#if _HAS_CXX23
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other&...>,
+                        _STD _Tuple_convert_val<tuple, tuple<_Other...>&, _Other...>>,
+            int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _Other&...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, tuple<_Other...>& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other&...>,
+                        _STD _Tuple_convert_val<tuple, tuple<_Other...>&, _Other...>>,
+            int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _Other&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, _Other&...>)
+        tuple(allocator_arg_t, const _Alloc&, tuple<_Other...>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other&...>,
+                        _STD _Tuple_convert_val<tuple, const tuple<_Other...>&, _Other...>>,
+            int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, const _Other&...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const tuple<_Other...>& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other&...>,
+                        _STD _Tuple_convert_val<tuple, const tuple<_Other...>&, _Other...>>,
+            int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, const _Other&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, const _Other&...>)
+        tuple(allocator_arg_t, const _Alloc&, const tuple<_Other...>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other...>,
+                        _STD _Tuple_convert_val<tuple, tuple<_Other...>, _Other...>>,
+            int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, _Other...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, tuple<_Other...>&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, _Other...>,
+                        _STD _Tuple_convert_val<tuple, tuple<_Other...>, _Other...>>,
+            int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _Other&&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, _Other...>)
+        tuple(allocator_arg_t, const _Alloc&, tuple<_Other...>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other...>,
+                        _STD _Tuple_convert_val<tuple, const tuple<_Other...>, _Other...>>,
+            int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _Other...>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const tuple<_Other...>&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class... _Other,
+        enable_if_t<conjunction_v<_STD _Tuple_constructible_val<tuple, const _Other...>,
+                        _STD _Tuple_convert_val<tuple, const tuple<_Other...>, _Other...>>,
+            int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, const _Other&&...>
+    explicit(_Tuple_conditional_explicit_v<tuple, const _Other...>)
+        tuple(allocator_arg_t, const _Alloc&, const tuple<_Other...>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, _First&, _Second&>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _First&, _Second&>)
+        tuple(allocator_arg_t, const _Alloc& _Al, pair<_First, _Second>& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, _First&, _Second&>, int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _First&, _Second&>
+    explicit(_Tuple_conditional_explicit_v<tuple, _First&, _Second&>)
+        tuple(allocator_arg_t, const _Alloc&, pair<_First, _Second>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First&, const _Second&>, int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, const _First&, const _Second&>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const pair<_First, _Second>& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First&, const _Second&>, int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, const _First&, const _Second&>
+    explicit(_Tuple_conditional_explicit_v<tuple, const _First&, const _Second&>)
+        tuple(allocator_arg_t, const _Alloc&, const pair<_First, _Second>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, _First, _Second>, int> = 0>
+    _CONSTEXPR20 explicit(_Tuple_conditional_explicit_v<tuple, _First, _Second>)
+        tuple(allocator_arg_t, const _Alloc& _Al, pair<_First, _Second>&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, _First, _Second>, int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, _First&&, _Second&&>
+    explicit(_Tuple_conditional_explicit_v<tuple, _First, _Second>)
+        tuple(allocator_arg_t, const _Alloc&, pair<_First, _Second>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First, const _Second>, int> = 0>
+    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First, const _Second>)
+        tuple(allocator_arg_t, const _Alloc& _Al, const pair<_First, _Second>&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD move(_Right)) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, class _First, class _Second,
+        enable_if_t<_Tuple_constructible_v<tuple, const _First, const _Second>, int> = 0>
+        requires _Tuple_reference_constructs_from_temporary<tuple, const _First&&, const _Second&&>
+    explicit(_Tuple_conditional_explicit_v<tuple, const _First, const _Second>)
+        tuple(allocator_arg_t, const _Alloc&, const pair<_First, _Second>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+#ifdef __EDG__ // TRANSITION, VSO-1900279
+    template <class _Alloc, class _Other, enable_if_t<_Can_construct_from_tuple_like<_Other, tuple>, int> = 0>
+#else // ^^^ workaround / no workaround vvv
+    template <class _Alloc, _Different_from<tuple> _Other>
+        requires _Tuple_like_non_subrange<_Other> && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_construct_values_from_tuple_like_v<tuple, _Other>
+              && (sizeof...(_Rest) != 0 || (!is_convertible_v<_Other, _This> && !is_constructible_v<_This, _Other>) )
+#endif // ^^^ no workaround ^^^
+    constexpr explicit(_Is_tuple_like_constructor_explicit_v<_Other>)
+        tuple(allocator_arg_t, const _Alloc& _Al, _Other&& _Right)
+        : tuple(_Alloc_unpack_tuple_t{}, _Al, _STD forward<_Other>(_Right)) {
+    }
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Alloc, _Different_from<tuple> _Other>
+        requires _Tuple_like_non_subrange<_Other> && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+                  && _Can_construct_values_from_tuple_like_v<tuple, _Other>
+                  && (sizeof...(_Rest) != 0
+                      || (!is_convertible_v<_Other, _This> && !is_constructible_v<_This, _Other>) )
+                  && _Tuple_reference_constructs_from_temporary_for_tuple_like<tuple, _Other&&>
+    explicit(_Is_tuple_like_constructor_explicit_v<_Other>) tuple(allocator_arg_t, const _Alloc&, _Other&&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    tuple& operator=(const volatile tuple&) = delete;
+
+    template <class _Myself = tuple, class _This2 = _This,
+        enable_if_t<conjunction_v<_STD _Is_copy_assignable_no_precondition_check<_This2>,
+                        _STD _Is_copy_assignable_no_precondition_check<_Rest>...>,
+            int> = 0>
+    _CONSTEXPR20 tuple& operator=(_Identity_t<const _Myself&> _Right) noexcept(
+        conjunction_v<is_nothrow_copy_assignable<_This2>, is_nothrow_copy_assignable<_Rest>...>) /* strengthened */ {
+        _Myfirst._Val = _Right._Myfirst._Val;
+        _Get_rest()   = _Right._Get_rest();
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Myself = tuple>
+        requires conjunction_v<_STD _Is_copy_assignable_no_precondition_check<const _This>,
+            _STD _Is_copy_assignable_no_precondition_check<const _Rest>...>
+    constexpr const tuple& operator=(_Identity_t<const _Myself&> _Right) const
+        noexcept(conjunction_v<is_nothrow_copy_assignable<const _This>,
+            is_nothrow_copy_assignable<const _Rest>...>) /* strengthened */ {
+        _Myfirst._Val = _Right._Myfirst._Val;
+        _Get_rest()   = _Right._Get_rest();
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _Myself = tuple, class _This2 = _This,
+        enable_if_t<conjunction_v<_STD _Is_move_assignable_no_precondition_check<_This2>,
+                        _STD _Is_move_assignable_no_precondition_check<_Rest>...>,
+            int> = 0>
+    _CONSTEXPR20 tuple& operator=(_Identity_t<_Myself&&> _Right)
+        noexcept(conjunction_v<is_nothrow_move_assignable<_This2>, is_nothrow_move_assignable<_Rest>...>) {
+        _Myfirst._Val = _STD forward<_This>(_Right._Myfirst._Val);
+        _Get_rest()   = _STD forward<_Mybase>(_Right._Get_rest());
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Myself = tuple>
+        requires conjunction_v<_STD _Is_assignable_no_precondition_check<const _This&, _This>,
+            _STD _Is_assignable_no_precondition_check<const _Rest&, _Rest>...>
+    constexpr const tuple& operator=(_Identity_t<_Myself&&> _Right) const
+        noexcept(conjunction_v<is_nothrow_assignable<const _This&, _This>,
+            is_nothrow_assignable<const _Rest&, _Rest>...>) /* strengthened */ {
+        _Myfirst._Val = _STD forward<_This>(_Right._Myfirst._Val);
+        _Get_rest()   = _STD forward<_Mybase>(_Right._Get_rest());
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD negation<_STD is_same<tuple, _STD tuple<_Other...>>>,
+                                               _STD _Tuple_assignable_val<tuple, const _Other&...>>,
+                                   int> = 0>
+    _CONSTEXPR20 tuple& operator=(const tuple<_Other...>& _Right)
+        noexcept(_Tuple_nothrow_assignable_v<tuple, const _Other&...>) /* strengthened */ {
+        _Myfirst._Val = _Right._Myfirst._Val;
+        _Get_rest()   = _Right._Get_rest();
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class... _Other>
+        requires (!is_same_v<tuple, _STD tuple<_Other...>>) && _Tuple_assignable_v<const tuple, const _Other&...>
+    constexpr const tuple& operator=(const tuple<_Other...>& _Right) const
+        noexcept(_Tuple_nothrow_assignable_v<const tuple, const _Other&...>) /* strengthened */ {
+        _Myfirst._Val = _Right._Myfirst._Val;
+        _Get_rest()   = _Right._Get_rest();
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Other, enable_if_t<conjunction_v<_STD negation<_STD is_same<tuple, _STD tuple<_Other...>>>,
+                                               _STD _Tuple_assignable_val<tuple, _Other...>>,
+                                   int> = 0>
+    _CONSTEXPR20 tuple& operator=(tuple<_Other...>&& _Right)
+        noexcept(_Tuple_nothrow_assignable_v<tuple, _Other...>) /* strengthened */ {
+        _Myfirst._Val = _STD forward<typename tuple<_Other...>::_This_type>(_Right._Myfirst._Val);
+        _Get_rest()   = _STD forward<typename tuple<_Other...>::_Mybase>(_Right._Get_rest());
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class... _Other>
+        requires (!is_same_v<tuple, _STD tuple<_Other...>>) && _Tuple_assignable_v<const tuple, _Other...>
+    constexpr const tuple& operator=(tuple<_Other...>&& _Right) const
+        noexcept(_Tuple_nothrow_assignable_v<const tuple, _Other...>) /* strengthened */ {
+        _Myfirst._Val = _STD forward<typename tuple<_Other...>::_This_type>(_Right._Myfirst._Val);
+        _Get_rest()   = _STD forward<typename tuple<_Other...>::_Mybase>(_Right._Get_rest());
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _First, class _Second,
+        enable_if_t<_Tuple_assignable_v<tuple, const _First&, const _Second&>, int> = 0>
+    _CONSTEXPR20 tuple& operator=(const pair<_First, _Second>& _Right)
+        noexcept(_Tuple_nothrow_assignable_v<tuple, const _First&, const _Second&>) /* strengthened */ {
+        _Myfirst._Val             = _Right.first;
+        _Get_rest()._Myfirst._Val = _Right.second;
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _First, class _Second>
+        requires _Tuple_assignable_v<const tuple, const _First&, const _Second&>
+    constexpr const tuple& operator=(const pair<_First, _Second>& _Right) const
+        noexcept(_Tuple_nothrow_assignable_v<const tuple, const _First&, const _Second&>) /* strengthened */ {
+        _Myfirst._Val             = _Right.first;
+        _Get_rest()._Myfirst._Val = _Right.second;
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _First, class _Second, enable_if_t<_Tuple_assignable_v<tuple, _First, _Second>, int> = 0>
+    _CONSTEXPR20 tuple& operator=(pair<_First, _Second>&& _Right)
+        noexcept(_Tuple_nothrow_assignable_v<tuple, _First, _Second>) /* strengthened */ {
+        _Myfirst._Val             = _STD forward<_First>(_Right.first);
+        _Get_rest()._Myfirst._Val = _STD forward<_Second>(_Right.second);
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _First, class _Second>
+        requires _Tuple_assignable_v<const tuple, _First, _Second>
+    constexpr const tuple& operator=(pair<_First, _Second>&& _Right) const
+        noexcept(_Tuple_nothrow_assignable_v<const tuple, _First, _Second>) /* strengthened */ {
+        _Myfirst._Val             = _STD forward<_First>(_Right.first);
+        _Get_rest()._Myfirst._Val = _STD forward<_Second>(_Right.second);
+        return *this;
+    }
+
+    template <bool _Const_assignment, class _Other, class _Indices = index_sequence_for<_Rest...>>
+    static constexpr bool _Can_assign_values_from_tuple_like_v = false;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Can_assign_values_from_tuple_like_v<false, _Other, index_sequence<_Indices...>> =
+        conjunction_v<is_assignable<_This&, decltype(_STD get<0>(_STD declval<_Other>()))>,
+            is_assignable<_Rest&, decltype(_STD get<_Indices + 1>(_STD declval<_Other>()))>...>;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    static constexpr bool _Can_assign_values_from_tuple_like_v<true, _Other, index_sequence<_Indices...>> =
+        conjunction_v<is_assignable<const _This&, decltype(_STD get<0>(_STD declval<_Other>()))>,
+            is_assignable<const _Rest&, decltype(_STD get<_Indices + 1>(_STD declval<_Other>()))>...>;
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    constexpr void _Assign_tuple_like(_Other&& _Right, index_sequence<_Indices...>) {
+        ((void) (_STD get<_Indices>(*this) = _STD get<_Indices>(_STD forward<_Other>(_Right))), ...);
+    }
+
+    template <_Tuple_like _Other, size_t... _Indices>
+    constexpr void _Assign_tuple_like(_Other&& _Right, index_sequence<_Indices...>) const {
+        ((void) (_STD get<_Indices>(*this) = _STD get<_Indices>(_STD forward<_Other>(_Right))), ...);
+    }
+
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like_non_subrange<_Other> && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_assign_values_from_tuple_like_v<false, _Other>
+    constexpr tuple& operator=(_Other&& _Right) {
+        _Assign_tuple_like(_STD forward<_Other>(_Right), make_index_sequence<1 + sizeof...(_Rest)>{});
+        return *this;
+    }
+
+    template <_Different_from<tuple> _Other>
+        requires _Tuple_like_non_subrange<_Other> && (1 + sizeof...(_Rest) == tuple_size_v<remove_cvref_t<_Other>>)
+              && _Can_assign_values_from_tuple_like_v<true, _Other>
+    constexpr const tuple& operator=(_Other&& _Right) const {
+        _Assign_tuple_like(_STD forward<_Other>(_Right), make_index_sequence<1 + sizeof...(_Rest)>{});
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void swap(tuple& _Right)
+        noexcept(conjunction_v<_Is_nothrow_swappable<_This>, _Is_nothrow_swappable<_Rest>...>) {
+        using _STD swap;
+        swap(_Myfirst._Val, _Right._Myfirst._Val); // intentional ADL
+        _Mybase::swap(_Right._Get_rest());
+    }
+
+#if _HAS_CXX23
+    template <int = 0> // see GH-3013
+    constexpr void swap(const tuple& _Right) const
+        noexcept(conjunction_v<is_nothrow_swappable<const _This>, is_nothrow_swappable<const _Rest>...>) {
+        using _STD swap;
+        swap(_Myfirst._Val, _Right._Myfirst._Val); // intentional ADL
+        _Mybase::swap(_Right._Get_rest());
+    }
+#endif // _HAS_CXX23
+
+    constexpr _Mybase& _Get_rest() noexcept { // get reference to rest of elements
+        return *this;
+    }
+
+    constexpr const _Mybase& _Get_rest() const noexcept { // get const reference to rest of elements
+        return *this;
+    }
+
+    template <class... _Other>
+    constexpr bool _Equals(const tuple<_Other...>& _Right) const {
+        return _Myfirst._Val == _Right._Myfirst._Val && _Mybase::_Equals(_Right._Get_rest());
+    }
+
+#if _HAS_CXX20
+    template <class _First, class... _Other>
+    _NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_This, _First>,
+        _Synth_three_way_result<_Rest, _Other>...> _Three_way_compare(const tuple<_First, _Other...>& _Right) const {
+        if (auto _Result = _Synth_three_way{}(_Myfirst._Val, _Right._Myfirst._Val); _Result != 0) {
+            return _Result;
+        }
+        return _Mybase::_Three_way_compare(_Right._Get_rest());
+    }
+
+#if _HAS_CXX23
+    template <class _Other, class _Indices = make_index_sequence<1 + sizeof...(_Rest)>>
+    static constexpr bool _Can_equal_compare_with_tuple_like_v = false;
+
+    template <class _Other, size_t... _Indices>
+    static constexpr bool _Can_equal_compare_with_tuple_like_v<_Other, index_sequence<_Indices...>> =
+        (requires(const tuple& _Left, const _Other& _Right) {
+            { _STD get<_Indices>(_Left) == _STD get<_Indices>(_Right) }->_Boolean_testable;
+        } && ...);
+
+    template <class _Other, size_t... _Indices>
+    _NODISCARD constexpr bool _Equals_to_tuple_like(const _Other& _Right, index_sequence<_Indices...>) const {
+        return ((_STD get<_Indices>(*this) == _STD get<_Indices>(_Right)) && ...);
+    }
+
+    template <_Tuple_like_non_tuple _Other>
+    _NODISCARD friend constexpr bool operator==(const tuple& _Left, const _Other& _Right) {
+        static_assert(1 + sizeof...(_Rest) == tuple_size_v<_Other>,
+            "Cannot compare tuples of different sizes (N4950 [tuple.rel]/2).");
+        static_assert(_Can_equal_compare_with_tuple_like_v<_Other>,
+            "For all i, where 0 <= i < sizeof...(TTypes), get<i>(t) == get<i>(u) must be a valid expression (N4950 "
+            "[tuple.rel]/2).");
+        return _Left._Equals_to_tuple_like(_Right, make_index_sequence<1 + sizeof...(_Rest)>{});
+    }
+
+    template <class _Other, size_t... _Indices>
+    _NODISCARD constexpr auto _Three_way_compare_with_tuple_like(
+        const _Other& _Right, index_sequence<_Indices...>) const {
+        _Three_way_comparison_result_with_tuple_like_t<tuple, _Other> _Result = strong_ordering::equal;
+        (void) (((_Result = _Synth_three_way{}(_STD get<_Indices>(*this), _STD get<_Indices>(_Right))) == 0) && ...);
+        return _Result;
+    }
+
+    template <_Tuple_like_non_tuple _Other>
+    _NODISCARD friend constexpr auto operator<=>(const tuple& _Left, const _Other& _Right)
+        -> _Three_way_comparison_result_with_tuple_like_t<tuple, _Other> {
+        return _Left._Three_way_compare_with_tuple_like(_Right, make_index_sequence<1 + sizeof...(_Rest)>{});
+    }
+#endif // _HAS_CXX23
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    template <class... _Other>
+    _NODISCARD constexpr bool _Less(const tuple<_Other...>& _Right) const {
+        return _Myfirst._Val < _Right._Myfirst._Val
+            || (!(_Right._Myfirst._Val < _Myfirst._Val) && _Mybase::_Less(_Right._Get_rest()));
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    template <size_t _Index, class... _Types>
+    friend constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;
+
+    template <size_t _Index, class... _Types>
+    friend constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;
+
+    template <size_t _Index, class... _Types>
+    friend constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;
+
+    template <size_t _Index, class... _Types>
+    friend constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;
+
+    template <size_t _Index, class... _Types>
+    friend constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept;
+
+    template <class _Ty, class... _Types>
+    friend constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept;
+
+    template <class _Ty, class... _Types>
+    friend constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept;
+
+    template <class _Ty, class... _Types>
+    friend constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept;
+
+    template <class _Ty, class... _Types>
+    friend constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept;
+
+    _Tuple_val<_This> _Myfirst; // the stored element
+};
+
+#if _HAS_CXX17
+template <class... _Types>
+tuple(_Types...) -> tuple<_Types...>;
+
+template <class _Ty1, class _Ty2>
+tuple(pair<_Ty1, _Ty2>) -> tuple<_Ty1, _Ty2>;
+
+template <class _Alloc, class... _Types>
+tuple(allocator_arg_t, _Alloc, _Types...) -> tuple<_Types...>;
+
+template <class _Alloc, class _Ty1, class _Ty2>
+tuple(allocator_arg_t, _Alloc, pair<_Ty1, _Ty2>) -> tuple<_Ty1, _Ty2>;
+
+template <class _Alloc, class... _Types>
+tuple(allocator_arg_t, _Alloc, tuple<_Types...>) -> tuple<_Types...>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator==(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    static_assert(
+        sizeof...(_Types1) == sizeof...(_Types2), "Cannot compare tuples of different sizes (N4950 [tuple.rel]/2).");
+    return _Left._Equals(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class... _Types1, class... _Types2>
+_NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Types1, _Types2>...> operator<=>(
+    const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return _Left._Three_way_compare(_Right);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator!=(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator<(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
+    return _Left._Less(_Right);
+}
+
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator>=(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return !(_Left < _Right);
+}
+
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator>(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return _Right < _Left;
+}
+
+template <class... _Types1, class... _Types2>
+_NODISCARD constexpr bool operator<=(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
+    return !(_Right < _Left);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class... _Types, enable_if_t<conjunction_v<_Is_swappable<_Types>...>, int> = 0>
+_CONSTEXPR20 void swap(tuple<_Types...>& _Left, tuple<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class... _Types>
+    requires conjunction_v<is_swappable<const _Types>...>
+constexpr void swap(const tuple<_Types...>& _Left, const tuple<_Types...>& _Right)
+    noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept {
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
+}
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept {
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
+}
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept {
+    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
+}
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept {
+    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
+}
+
+template <size_t _Index, class... _Types>
+_NODISCARD constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept {
+    // used by pair's piecewise constructor
+    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
+    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
+    return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept {
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
+    } else {
+        static_assert(false, "get<T>(tuple<Types...>&) "
+                             "requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept {
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
+    } else {
+        static_assert(false, "get<T>(const tuple<Types...>&) "
+                             "requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept {
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
+    } else {
+        static_assert(false, "get<T>(tuple<Types...>&&) "
+                             "requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept {
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
+    } else {
+        static_assert(false, "get<T>(const tuple<Types...>&&) "
+                             "requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
+}
+
+template <class _This, class... _Rest>
+template <class _Tag, class _Tpl, size_t... _Indices, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> /* = 0 */>
+constexpr tuple<_This, _Rest...>::tuple(_Tag, _Tpl&& _Right, index_sequence<_Indices...>)
+    : tuple(_Exact_args_t{}, _STD get<_Indices>(_STD forward<_Tpl>(_Right))...) {}
+
+template <class _This, class... _Rest>
+template <class _Tag, class _Alloc, class _Tpl, size_t... _Indices,
+    enable_if_t<is_same_v<_Tag, _STD _Alloc_unpack_tuple_t>, int> /* = 0 */>
+constexpr tuple<_This, _Rest...>::tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right, index_sequence<_Indices...>)
+    : tuple(_Alloc_exact_args_t{}, _Al, _STD get<_Indices>(_STD forward<_Tpl>(_Right))...) {}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr tuple<_Unrefwrap_t<_Types>...> make_tuple(_Types&&... _Args) { // make tuple from elements
+    using _Ttype = tuple<_Unrefwrap_t<_Types>...>;
+    return _Ttype(_STD forward<_Types>(_Args)...);
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr tuple<_Types&...> tie(_Types&... _Args) noexcept { // make tuple from elements
+    using _Ttype = tuple<_Types&...>;
+    return _Ttype(_Args...);
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr tuple<_Types&&...> forward_as_tuple(_Types&&... _Args) noexcept { // forward arguments in a tuple
+    return tuple<_Types&&...>(_STD forward<_Types>(_Args)...);
+}
+
+template <class _Ty, class _Kx_arg, class _Ix_arg, size_t _Ix_next, class... _Sequences>
+struct _Tuple_cat2;
+
+template <class _Ty, size_t... _Kx, size_t... _Ix, size_t _Ix_next>
+struct _Tuple_cat2<_Ty, index_sequence<_Kx...>, index_sequence<_Ix...>, _Ix_next> {
+    using _Ret    = tuple<tuple_element_t<_Kx, _Remove_cvref_t<tuple_element_t<_Ix, _Ty>>>...>;
+    using _Kx_seq = index_sequence<_Kx...>;
+    using _Ix_seq = index_sequence<_Ix...>;
+};
+
+template <class _Ty, size_t... _Kx, size_t... _Ix, size_t _Ix_next, size_t... _Kx_next, class... _Rest>
+struct _Tuple_cat2<_Ty, index_sequence<_Kx...>, index_sequence<_Ix...>, _Ix_next, index_sequence<_Kx_next...>, _Rest...>
+    : _Tuple_cat2<_Ty, index_sequence<_Kx..., _Kx_next...>,
+          index_sequence<_Ix..., (_Ix_next + 0 * _Kx_next)...>, // repeat _Ix_next, ignoring the elements of _Kx_next
+          _Ix_next + 1, _Rest...> {};
+
+#if _HAS_CXX23
+template <_Tuple_like... _Tuples>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class... _Tuples>
+#endif // ^^^ !_HAS_CXX23 ^^^
+using _Tuple_cat1 = _Tuple_cat2<tuple<_Tuples&&...>, index_sequence<>, index_sequence<>, 0,
+    make_index_sequence<tuple_size_v<_Remove_cvref_t<_Tuples>>>...>;
+
+template <class _Ret, size_t... _Kx, size_t... _Ix, class _Ty>
+constexpr _Ret _Tuple_cat(index_sequence<_Kx...>, index_sequence<_Ix...>, _Ty _Arg) {
+    return _Ret{_STD get<_Kx>(_STD get<_Ix>(_STD move(_Arg)))...};
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Tuple_like... _Tuples>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+_EXPORT_STD template <class... _Tuples>
+#endif // ^^^ !_HAS_CXX23 ^^^
+_NODISCARD constexpr typename _Tuple_cat1<_Tuples...>::_Ret tuple_cat(_Tuples&&... _Tpls) { // concatenate tuples
+    using _Cat1   = _Tuple_cat1<_Tuples...>;
+    using _Ret    = typename _Cat1::_Ret;
+    using _Kx_seq = typename _Cat1::_Kx_seq;
+    using _Ix_seq = typename _Cat1::_Ix_seq;
+    return _STD _Tuple_cat<_Ret>(_Kx_seq{}, _Ix_seq{}, _STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...));
+}
+
+#if _HAS_CXX17
+#if _HAS_CXX23
+template <class _Callable, _Tuple_like _Tuple, size_t... _Indices>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class _Callable, class _Tuple, size_t... _Indices>
+#endif // ^^^ !_HAS_CXX23 ^^^
+constexpr decltype(auto) _Apply_impl(_Callable&& _Obj, _Tuple&& _Tpl, index_sequence<_Indices...>)
+    noexcept(noexcept(_STD invoke(_STD forward<_Callable>(_Obj), _STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...))) {
+    return _STD invoke(_STD forward<_Callable>(_Obj), _STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Callable, _Tuple_like _Tuple>
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+_EXPORT_STD template <class _Callable, class _Tuple>
+#endif // ^^^ !_HAS_CXX23 ^^^
+constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl)
+    noexcept(noexcept(_STD _Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
+        make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) {
+    return _STD _Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
+        make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
+}
+
+template <class _Ty, class _Tuple, class _Seq = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>>
+constexpr bool _Can_make_from_tuple = false;
+template <class _Ty, class _Tuple, size_t... _Indices>
+constexpr bool _Can_make_from_tuple<_Ty, _Tuple, index_sequence<_Indices...>> =
+    is_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD declval<_Tuple>()))...>;
+
+template <class _Ty, class _Tuple, size_t... _Indices>
+constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>)
+    noexcept(is_nothrow_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl)))...>) {
+    return _Ty(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ty, _Tuple_like _Tuple>
+    requires _Can_make_from_tuple<_Ty, _Tuple>
+#elif _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Tuple>
+    requires _Can_make_from_tuple<_Ty, _Tuple>
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Tuple, enable_if_t<_Can_make_from_tuple<_Ty, _Tuple>, int> = 0>
+#endif // ^^^ !_HAS_CXX20 ^^^
+_NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_STD _Make_from_tuple_impl<_Ty>(
+    _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) /* strengthened */ {
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    if constexpr (tuple_size_v<remove_reference_t<_Tuple>> == 1) {
+        static_assert(!reference_constructs_from_temporary_v<_Ty, decltype(_STD get<0>(_STD forward<_Tuple>(_Tpl)))>,
+            "Cannot bind a temporary to the returned reference which will always be dangling (N5014 [tuple.apply]/2).");
+    }
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+    // construct _Ty from the elements of _Tpl
+    return _STD _Make_from_tuple_impl<_Ty>(
+        _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
+}
+#endif // _HAS_CXX17
+
+template <class... _Types, class _Alloc>
+struct uses_allocator<tuple<_Types...>, _Alloc> : true_type {}; // true_type if container allocator enabled
+
+#if _HAS_CXX23
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, template <class> class _TQual, template <class> class _UQual,
+    class _Indices = make_index_sequence<tuple_size_v<_TTuple>>>
+struct _Tuple_like_common_reference;
+
+template <class _TTuple, class _UTuple, template <class> class _TQual, template <class> class _UQual,
+    size_t... _Indices>
+    requires requires {
+        typename tuple<common_reference_t<_TQual<tuple_element_t<_Indices, _TTuple>>,
+            _UQual<tuple_element_t<_Indices, _UTuple>>>...>;
+    }
+struct _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual, index_sequence<_Indices...>> {
+    using type = tuple<
+        common_reference_t<_TQual<tuple_element_t<_Indices, _TTuple>>, _UQual<tuple_element_t<_Indices, _UTuple>>>...>;
+};
+
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, template <class> class _TQual, template <class> class _UQual>
+    requires (_Is_specialization_v<_TTuple, tuple> || _Is_specialization_v<_UTuple, tuple>)
+          && is_same_v<_TTuple, decay_t<_TTuple>> && is_same_v<_UTuple, decay_t<_UTuple>>
+          && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
+          && requires { typename _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type; }
+struct basic_common_reference<_TTuple, _UTuple, _TQual, _UQual> {
+    using type = _Tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type;
+};
+
+template <_Tuple_like _TTuple, _Tuple_like _UTuple, class _Indices = make_index_sequence<tuple_size_v<_TTuple>>>
+struct _Tuple_like_common_type;
+
+template <class _TTuple, class _UTuple, size_t... _Indices>
+    requires requires {
+        typename tuple<common_type_t<tuple_element_t<_Indices, _TTuple>, tuple_element_t<_Indices, _UTuple>>...>;
+    }
+struct _Tuple_like_common_type<_TTuple, _UTuple, index_sequence<_Indices...>> {
+    using type = tuple<common_type_t<tuple_element_t<_Indices, _TTuple>, tuple_element_t<_Indices, _UTuple>>...>;
+};
+
+template <_Tuple_like _TTuple, _Tuple_like _UTuple>
+    requires (_Is_specialization_v<_TTuple, tuple> || _Is_specialization_v<_UTuple, tuple>)
+          && is_same_v<_TTuple, decay_t<_TTuple>> && is_same_v<_UTuple, decay_t<_UTuple>>
+          && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
+          && requires { typename _Tuple_like_common_type<_TTuple, _UTuple>::type; }
+struct common_type<_TTuple, _UTuple> {
+    using type = _Tuple_like_common_type<_TTuple, _UTuple>::type;
+};
+#endif // _HAS_CXX23
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _TUPLE_
diff --git a/msvc-stl/stl/inc/type_traits b/msvc-stl/stl/inc/type_traits
new file mode 100644
index 0000000..743cd69
--- /dev/null
+++ b/msvc-stl/stl/inc/type_traits
@@ -0,0 +1,2699 @@
+// type_traits standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _TYPE_TRAITS_
+#define _TYPE_TRAITS_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstddef>
+#include <cstdint>
+#include <xtr1common>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("intrinsic")
+#pragma push_macro("known_semantics")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef intrinsic
+#undef known_semantics
+#undef no_specializations
+
+_STD_BEGIN
+template <bool _First_value, class _First, class... _Rest>
+struct _Conjunction { // handle false trait or last trait
+    using type = _First;
+};
+
+template <class _True, class _Next, class... _Rest>
+struct _Conjunction<true, _True, _Next, _Rest...> { // the first trait is true, try the next one
+    using type = typename _Conjunction<static_cast<bool>(_Next::value), _Next, _Rest...>::type;
+};
+
+_EXPORT_STD template <class... _Traits>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS conjunction : true_type {}; // If _Traits is empty, true_type
+
+template <class _First, class... _Rest>
+struct conjunction<_First, _Rest...> : _Conjunction<static_cast<bool>(_First::value), _First, _Rest...>::type {
+    // the first false trait in _Traits, or the last trait if none are false
+};
+
+_EXPORT_STD template <class... _Traits>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool conjunction_v = conjunction<_Traits...>::value;
+
+_EXPORT_STD template <class _Trait>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS negation : bool_constant<!static_cast<bool>(_Trait::value)> {
+    // The negated result of _Trait
+};
+
+_EXPORT_STD template <class _Trait>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool negation_v = negation<_Trait>::value;
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_void_v = is_same_v<remove_cv_t<_Ty>, void>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_void : bool_constant<is_void_v<_Ty>> {};
+
+_EXPORT_STD template <class... _Types>
+using void_t = void;
+
+template <class _Ty>
+struct _Identity {
+    using type = _Ty;
+};
+template <class _Ty>
+using _Identity_t _MSVC_KNOWN_SEMANTICS = typename _Identity<_Ty>::type;
+
+// Type modifiers
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS add_const { // add top-level const qualifier
+    using type = const _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_const_t = typename add_const<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS add_volatile { // add top-level volatile qualifier
+    using type = volatile _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_volatile_t = typename add_volatile<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS add_cv { // add top-level const and volatile qualifiers
+    using type = const volatile _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_cv_t = typename add_cv<_Ty>::type;
+
+template <class _Ty, class = void>
+struct _Add_reference { // add reference (non-referenceable type)
+    using _Lvalue = _Ty;
+    using _Rvalue = _Ty;
+};
+
+template <class _Ty>
+struct _Add_reference<_Ty, void_t<_Ty&>> { // (referenceable type)
+    using _Lvalue = _Ty&;
+    using _Rvalue = _Ty&&;
+};
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS add_lvalue_reference {
+    using type = typename _Add_reference<_Ty>::_Lvalue;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_lvalue_reference_t = typename _Add_reference<_Ty>::_Lvalue;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS add_rvalue_reference {
+    using type = typename _Add_reference<_Ty>::_Rvalue;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_rvalue_reference_t = typename _Add_reference<_Ty>::_Rvalue;
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-volatile"
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Ty>
+add_rvalue_reference_t<_Ty> declval() noexcept {
+    static_assert(false, "Calling declval is ill-formed, see N4950 [declval]/2.");
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS remove_extent { // remove array extent
+    using type = _Ty;
+};
+
+template <class _Ty, size_t _Ix>
+struct remove_extent<_Ty[_Ix]> {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_extent<_Ty[]> {
+    using type = _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_extent_t = typename remove_extent<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS remove_all_extents { // remove all array extents
+    using type = _Ty;
+};
+
+template <class _Ty, size_t _Ix>
+struct remove_all_extents<_Ty[_Ix]> {
+    using type = typename remove_all_extents<_Ty>::type;
+};
+
+template <class _Ty>
+struct remove_all_extents<_Ty[]> {
+    using type = typename remove_all_extents<_Ty>::type;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_all_extents_t = typename remove_all_extents<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS remove_pointer {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_pointer<_Ty*> {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_pointer<_Ty* const> {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_pointer<_Ty* volatile> {
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_pointer<_Ty* const volatile> {
+    using type = _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_pointer_t = typename remove_pointer<_Ty>::type;
+
+template <class _Ty, class = void>
+struct _Add_pointer { // add pointer (pointer type cannot be formed)
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct _Add_pointer<_Ty, void_t<remove_reference_t<_Ty>*>> { // (pointer type can be formed)
+    using type = remove_reference_t<_Ty>*;
+};
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS add_pointer {
+    using type = typename _Add_pointer<_Ty>::type;
+};
+
+_EXPORT_STD template <class _Ty>
+using add_pointer_t = typename _Add_pointer<_Ty>::type;
+
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_array_v = false; // determine whether type argument is an array
+
+template <class _Ty, size_t _Nx>
+constexpr bool is_array_v<_Ty[_Nx]> = true;
+
+template <class _Ty>
+constexpr bool is_array_v<_Ty[]> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_array : bool_constant<is_array_v<_Ty>> {};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_bounded_array_v = false;
+
+template <class _Ty, size_t _Nx>
+constexpr bool is_bounded_array_v<_Ty[_Nx]> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_bounded_array : bool_constant<is_bounded_array_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_unbounded_array_v = false;
+
+template <class _Ty>
+constexpr bool is_unbounded_array_v<_Ty[]> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_unbounded_array : bool_constant<is_unbounded_array_v<_Ty>> {};
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_lvalue_reference_v =
+    false; // determine whether type argument is an lvalue reference
+
+template <class _Ty>
+constexpr bool is_lvalue_reference_v<_Ty&> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_lvalue_reference : bool_constant<is_lvalue_reference_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_rvalue_reference_v =
+    false; // determine whether type argument is an rvalue reference
+
+template <class _Ty>
+constexpr bool is_rvalue_reference_v<_Ty&&> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_rvalue_reference : bool_constant<is_rvalue_reference_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_reference_v =
+    false; // determine whether type argument is a reference
+
+template <class _Ty>
+constexpr bool is_reference_v<_Ty&> = true;
+
+template <class _Ty>
+constexpr bool is_reference_v<_Ty&&> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_reference : bool_constant<is_reference_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_pointer_v = false; // determine whether _Ty is a pointer
+
+template <class _Ty>
+constexpr bool is_pointer_v<_Ty*> = true;
+
+template <class _Ty>
+constexpr bool is_pointer_v<_Ty* const> = true;
+
+template <class _Ty>
+constexpr bool is_pointer_v<_Ty* volatile> = true;
+
+template <class _Ty>
+constexpr bool is_pointer_v<_Ty* const volatile> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_pointer : bool_constant<is_pointer_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_null_pointer_v =
+    is_same_v<remove_cv_t<_Ty>, nullptr_t>; // determine whether _Ty is cv-qualified nullptr_t
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_null_pointer : bool_constant<is_null_pointer_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_union : bool_constant<__is_union(_Ty)> {
+}; // determine whether _Ty is a union
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_union_v = __is_union(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_class : bool_constant<__is_class(_Ty)> {
+}; // determine whether _Ty is a class
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_class_v = __is_class(_Ty);
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_fundamental_v =
+    is_arithmetic_v<_Ty> || is_void_v<_Ty> || is_null_pointer_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_fundamental : bool_constant<is_fundamental_v<_Ty>> {
+    // determine whether _Ty is a fundamental type
+};
+
+_EXPORT_STD template <class _From, class _To>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
+    // determine whether _From is convertible to _To
+};
+
+_EXPORT_STD template <class _From, class _To>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_convertible_v = __is_convertible_to(_From, _To);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_enum : bool_constant<__is_enum(_Ty)> {
+}; // determine whether _Ty is an enumerated type
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_enum_v = __is_enum(_Ty);
+
+#if _HAS_CXX23
+#ifdef __clang__ // TRANSITION, DevCom-10870354 (MSVC, EDG)
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_scoped_enum_v = __is_scoped_enum(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_scoped_enum : bool_constant<__is_scoped_enum(_Ty)> {};
+#else // ^^^ no workaround / workaround vvv
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_scoped_enum_v =
+    conjunction_v<is_enum<_Ty>, negation<is_convertible<_Ty, int>>>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_scoped_enum : bool_constant<is_scoped_enum_v<_Ty>> {};
+#endif // ^^^ workaround ^^^
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_compound : bool_constant<!is_fundamental_v<_Ty>> {
+    // determine whether _Ty is a compound type
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_compound_v = !is_fundamental_v<_Ty>;
+
+#define _EMIT_CDECL(FUNC, OPT1, OPT2, OPT3) FUNC(__cdecl, OPT1, OPT2, OPT3)
+
+#ifdef _M_CEE
+#define _EMIT_CLRCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__clrcall, OPT1, OPT2, OPT3)
+#else // ^^^ __clrcall supported / __clrcall not supported vvv
+#define _EMIT_CLRCALL(FUNC, OPT1, OPT2, OPT3)
+#endif // ^^^ __clrcall not supported ^^^
+
+#if defined(_M_IX86) && !defined(_M_CEE)
+#define _EMIT_FASTCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__fastcall, OPT1, OPT2, OPT3)
+#else // ^^^ __fastcall supported / __fastcall not supported vvv
+#define _EMIT_FASTCALL(FUNC, OPT1, OPT2, OPT3)
+#endif // ^^^ __fastcall not supported ^^^
+
+#ifdef _M_IX86
+#define _EMIT_STDCALL(FUNC, OPT1, OPT2, OPT3)  FUNC(__stdcall, OPT1, OPT2, OPT3)
+#define _EMIT_THISCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__thiscall, OPT1, OPT2, OPT3)
+#else // ^^^ __stdcall and __thiscall supported / __stdcall and __thiscall not supported vvv
+#define _EMIT_STDCALL(FUNC, OPT1, OPT2, OPT3)
+#define _EMIT_THISCALL(FUNC, OPT1, OPT2, OPT3)
+#endif // ^^^ __stdcall and __thiscall not supported ^^^
+
+#if ((defined(_M_IX86) && _M_IX86_FP >= 2) || (defined(_M_X64) && !defined(_M_ARM64EC))) && !defined(_M_CEE)
+#define _EMIT_VECTORCALL(FUNC, OPT1, OPT2, OPT3) FUNC(__vectorcall, OPT1, OPT2, OPT3)
+#else // ^^^ __vectorcall supported / __vectorcall not supported vvv
+#define _EMIT_VECTORCALL(FUNC, OPT1, OPT2, OPT3)
+#endif // ^^^ __vectorcall not supported ^^^
+
+#define _NON_MEMBER_CALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
+    _EMIT_CDECL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)          \
+    _EMIT_CLRCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)        \
+    _EMIT_FASTCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)       \
+    _EMIT_STDCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)        \
+    _EMIT_VECTORCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)
+
+#define _NON_MEMBER_CALL_CV(FUNC, REF_OPT, NOEXCEPT_OPT)    \
+    _NON_MEMBER_CALL(FUNC, , REF_OPT, NOEXCEPT_OPT)         \
+    _NON_MEMBER_CALL(FUNC, const, REF_OPT, NOEXCEPT_OPT)    \
+    _NON_MEMBER_CALL(FUNC, volatile, REF_OPT, NOEXCEPT_OPT) \
+    _NON_MEMBER_CALL(FUNC, const volatile, REF_OPT, NOEXCEPT_OPT)
+
+#define _NON_MEMBER_CALL_CV_REF(FUNC, NOEXCEPT_OPT) \
+    _NON_MEMBER_CALL_CV(FUNC, , NOEXCEPT_OPT)       \
+    _NON_MEMBER_CALL_CV(FUNC, &, NOEXCEPT_OPT)      \
+    _NON_MEMBER_CALL_CV(FUNC, &&, NOEXCEPT_OPT)
+
+#ifdef __cpp_noexcept_function_type
+#define _NON_MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) \
+    _NON_MEMBER_CALL_CV_REF(FUNC, )            \
+    _NON_MEMBER_CALL_CV_REF(FUNC, noexcept)
+#else // ^^^ defined(__cpp_noexcept_function_type) / !defined(__cpp_noexcept_function_type) vvv
+#define _NON_MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) _NON_MEMBER_CALL_CV_REF(FUNC, )
+#endif // ^^^ !defined(__cpp_noexcept_function_type) ^^^
+
+#define _MEMBER_CALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
+    _EMIT_CDECL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)      \
+    _EMIT_CLRCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)    \
+    _EMIT_FASTCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)   \
+    _EMIT_STDCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)    \
+    _EMIT_THISCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)   \
+    _EMIT_VECTORCALL(FUNC, CV_OPT, REF_OPT, NOEXCEPT_OPT)
+
+#define _MEMBER_CALL_CV(FUNC, REF_OPT, NOEXCEPT_OPT)    \
+    _MEMBER_CALL(FUNC, , REF_OPT, NOEXCEPT_OPT)         \
+    _MEMBER_CALL(FUNC, const, REF_OPT, NOEXCEPT_OPT)    \
+    _MEMBER_CALL(FUNC, volatile, REF_OPT, NOEXCEPT_OPT) \
+    _MEMBER_CALL(FUNC, const volatile, REF_OPT, NOEXCEPT_OPT)
+
+#define _MEMBER_CALL_CV_REF(FUNC, NOEXCEPT_OPT) \
+    _MEMBER_CALL_CV(FUNC, , NOEXCEPT_OPT)       \
+    _MEMBER_CALL_CV(FUNC, &, NOEXCEPT_OPT)      \
+    _MEMBER_CALL_CV(FUNC, &&, NOEXCEPT_OPT)
+
+#ifdef __cpp_noexcept_function_type
+#define _MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) \
+    _MEMBER_CALL_CV_REF(FUNC, )            \
+    _MEMBER_CALL_CV_REF(FUNC, noexcept)
+#else // ^^^ defined(__cpp_noexcept_function_type) / !defined(__cpp_noexcept_function_type) vvv
+#define _MEMBER_CALL_CV_REF_NOEXCEPT(FUNC) _MEMBER_CALL_CV_REF(FUNC, )
+#endif // ^^^ !defined(__cpp_noexcept_function_type) ^^^
+
+#ifdef __cpp_noexcept_function_type
+#define _CLASS_DEFINE_CV_REF_NOEXCEPT(CLASS) \
+    CLASS(_EMPTY_ARGUMENT)                   \
+    CLASS(const)                             \
+    CLASS(volatile)                          \
+    CLASS(const volatile)                    \
+    CLASS(&)                                 \
+    CLASS(const&)                            \
+    CLASS(volatile&)                         \
+    CLASS(const volatile&)                   \
+    CLASS(&&)                                \
+    CLASS(const&&)                           \
+    CLASS(volatile&&)                        \
+    CLASS(const volatile&&)                  \
+    CLASS(noexcept)                          \
+    CLASS(const noexcept)                    \
+    CLASS(volatile noexcept)                 \
+    CLASS(const volatile noexcept)           \
+    CLASS(& noexcept)                        \
+    CLASS(const& noexcept)                   \
+    CLASS(volatile& noexcept)                \
+    CLASS(const volatile& noexcept)          \
+    CLASS(&& noexcept)                       \
+    CLASS(const&& noexcept)                  \
+    CLASS(volatile&& noexcept)               \
+    CLASS(const volatile&& noexcept)
+#else // ^^^ defined(__cpp_noexcept_function_type) / !defined(__cpp_noexcept_function_type) vvv
+#define _CLASS_DEFINE_CV_REF_NOEXCEPT(CLASS) \
+    CLASS(_EMPTY_ARGUMENT)                   \
+    CLASS(const)                             \
+    CLASS(volatile)                          \
+    CLASS(const volatile)                    \
+    CLASS(&)                                 \
+    CLASS(const&)                            \
+    CLASS(volatile&)                         \
+    CLASS(const volatile&)                   \
+    CLASS(&&)                                \
+    CLASS(const&&)                           \
+    CLASS(volatile&&)                        \
+    CLASS(const volatile&&)
+#endif // ^^^ !defined(__cpp_noexcept_function_type) ^^^
+
+template <class... _Types>
+struct _Arg_types {}; // provide argument_type, etc. when sizeof...(_Types) is 1 or 2
+
+template <class _Ty1>
+struct _Arg_types<_Ty1> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty1;
+};
+
+template <class _Ty1, class _Ty2>
+struct _Arg_types<_Ty1, _Ty2> {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty1;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty2;
+};
+
+template <class _Ty>
+struct _Is_memfunptr { // base class for member function pointer predicates
+    using _Bool_type = false_type; // NB: members are user-visible via _Weak_types
+};
+
+#define _IS_MEMFUNPTR(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT)                            \
+    template <class _Ret, class _Arg0, class... _Types>                                   \
+    struct _Is_memfunptr<_Ret (CALL_OPT _Arg0::*)(_Types...) CV_OPT REF_OPT NOEXCEPT_OPT> \
+        : _Arg_types<CV_OPT _Arg0*, _Types...> {                                          \
+        using _Bool_type                                          = true_type;            \
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;                 \
+        using _Class_type                                         = _Arg0;                \
+        using _Guide_type = enable_if<!is_same_v<int REF_OPT, int&&>, _Ret(_Types...)>;   \
+    };
+
+_MEMBER_CALL_CV_REF_NOEXCEPT(_IS_MEMFUNPTR)
+#undef _IS_MEMFUNPTR
+
+#define _IS_MEMFUNPTR_ELLIPSIS(CV_REF_NOEXCEPT_OPT)                                   \
+    template <class _Ret, class _Arg0, class... _Types>                               \
+    struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...)                              \
+            CV_REF_NOEXCEPT_OPT> { /* no calling conventions for ellipsis */          \
+        using _Bool_type                                          = true_type;        \
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;             \
+        using _Class_type                                         = _Arg0;            \
+        using _Guide_type                                         = enable_if<false>; \
+    };
+
+_CLASS_DEFINE_CV_REF_NOEXCEPT(_IS_MEMFUNPTR_ELLIPSIS)
+#undef _IS_MEMFUNPTR_ELLIPSIS
+
+#if _HAS_CXX23
+#define _IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT) \
+    template <class _Ret, class _Self, class... _Args>                              \
+    struct _Is_memfunptr<_Ret(CALL_OPT*)(_Self, _Args...) NOEXCEPT_OPT> {           \
+        using _Bool_type  = false_type;                                             \
+        using _Guide_type = _Identity<_Ret(_Args...)>;                              \
+    };
+
+_NON_MEMBER_CALL(_IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES, , , )
+#ifdef __cpp_noexcept_function_type
+_NON_MEMBER_CALL(_IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES, , , noexcept)
+#endif // defined(__cpp_noexcept_function_type)
+
+#undef _IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES
+#endif // _HAS_CXX23
+
+#ifdef __clang__
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Ty);
+#else // ^^^ Clang / Other vvv
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_member_function_pointer_v =
+    _Is_memfunptr<remove_cv_t<_Ty>>::_Bool_type::value;
+#endif // ^^^ Other ^^^
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_member_function_pointer
+    : bool_constant<is_member_function_pointer_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_const_v =
+    false; // determine whether type argument is const qualified
+
+template <class _Ty>
+constexpr bool is_const_v<const _Ty> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_const : bool_constant<is_const_v<_Ty>> {};
+
+_EXPORT_STD template <class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_volatile_v =
+    false; // determine whether type argument is volatile qualified
+
+template <class _Ty>
+constexpr bool is_volatile_v<volatile _Ty> = true;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_volatile : bool_constant<is_volatile_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool
+    is_function_v = // only function types and reference types can't be const qualified
+    !is_const_v<const _Ty> && !is_reference_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_function : bool_constant<is_function_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool
+    is_object_v = // only function types and reference types can't be const qualified
+    is_const_v<const _Ty> && !is_void_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_object : bool_constant<is_object_v<_Ty>> {};
+
+template <class>
+struct _Is_member_object_pointer {
+    static constexpr bool value = false;
+};
+
+template <class _Ty1, class _Ty2>
+struct _Is_member_object_pointer<_Ty1 _Ty2::*> {
+    static constexpr bool value = !is_function_v<_Ty1>;
+    using _Class_type           = _Ty2;
+};
+
+#ifdef __clang__
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Ty);
+#else // ^^^ Clang / Other vvv
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_member_object_pointer_v =
+    _Is_member_object_pointer<remove_cv_t<_Ty>>::value;
+#endif // ^^^ Other ^^^
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_member_object_pointer : bool_constant<is_member_object_pointer_v<_Ty>> {};
+
+#ifdef __clang__
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_member_pointer_v = __is_member_pointer(_Ty);
+#else // ^^^ Clang / Other vvv
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_member_pointer_v =
+    is_member_object_pointer_v<_Ty> || is_member_function_pointer_v<_Ty>;
+#endif // ^^^ Other ^^^
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_member_pointer : bool_constant<is_member_pointer_v<_Ty>> {
+    // determine whether _Ty is a pointer to member
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_scalar_v = // determine whether _Ty is a scalar type
+    is_arithmetic_v<_Ty> || is_enum_v<_Ty> || is_pointer_v<_Ty> || is_member_pointer_v<_Ty> || is_null_pointer_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_scalar : bool_constant<is_scalar_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+struct _CXX20_DEPRECATE_IS_POD _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_pod : bool_constant<__is_pod(_Ty)> {
+    // determine whether _Ty is a POD type
+};
+
+_EXPORT_STD template <class _Ty>
+_CXX20_DEPRECATE_IS_POD _NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_pod_v = __is_pod(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_empty : bool_constant<__is_empty(_Ty)> {
+}; // determine whether _Ty is an empty class
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_empty_v = __is_empty(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_polymorphic : bool_constant<__is_polymorphic(_Ty)> {
+    // determine whether _Ty is a polymorphic type
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_polymorphic_v = __is_polymorphic(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_abstract : bool_constant<__is_abstract(_Ty)> {
+    // determine whether _Ty is an abstract class
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_abstract_v = __is_abstract(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_final : bool_constant<__is_final(_Ty)> {
+}; // determine whether _Ty is a final class
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_final_v = __is_final(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_standard_layout : bool_constant<__is_standard_layout(_Ty)> {
+    // determine whether _Ty is standard layout
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_standard_layout_v = __is_standard_layout(_Ty);
+
+#if _HAS_DEPRECATED_IS_LITERAL_TYPE
+_EXPORT_STD template <class _Ty>
+struct _CXX17_DEPRECATE_IS_LITERAL_TYPE _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_literal_type
+    : bool_constant<__is_literal_type(_Ty)> {
+    // determine whether _Ty is a literal type
+};
+
+_EXPORT_STD template <class _Ty>
+_CXX17_DEPRECATE_IS_LITERAL_TYPE _NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_literal_type_v =
+    __is_literal_type(_Ty);
+#endif // _HAS_DEPRECATED_IS_LITERAL_TYPE
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivial : bool_constant<__is_trivial(_Ty)> {
+}; // determine whether _Ty is a trivial type
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivial_v = __is_trivial(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_copyable : bool_constant<__is_trivially_copyable(_Ty)> {
+    // determine whether _Ty is a trivially copyable type
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Ty);
+
+#if _HAS_CXX23
+#ifdef __cpp_lib_is_implicit_lifetime // TRANSITION, toolset update
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_implicit_lifetime : bool_constant<__builtin_is_implicit_lifetime(_Ty)> {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_implicit_lifetime_v = __builtin_is_implicit_lifetime(_Ty);
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS has_virtual_destructor : bool_constant<__has_virtual_destructor(_Ty)> {
+    // determine whether _Ty has a virtual destructor
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Ty);
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS has_unique_object_representations
+    : bool_constant<__has_unique_object_representations(_Ty)> {
+    // determine whether _Ty has unique object representations
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool has_unique_object_representations_v =
+    __has_unique_object_representations(_Ty);
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+_EXPORT_STD template <class _Ty, class _Uty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS reference_constructs_from_temporary
+    : bool_constant<__reference_constructs_from_temporary(_Ty, _Uty)> {};
+
+_EXPORT_STD template <class _Ty, class _Uty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool reference_constructs_from_temporary_v =
+    __reference_constructs_from_temporary(_Ty, _Uty);
+
+_EXPORT_STD template <class _Ty, class _Uty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS reference_converts_from_temporary
+    : bool_constant<__reference_converts_from_temporary(_Ty, _Uty)> {};
+
+_EXPORT_STD template <class _Ty, class _Uty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool reference_converts_from_temporary_v =
+    __reference_converts_from_temporary(_Ty, _Uty);
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+#if _HAS_CXX17
+#ifdef __EDG__ // TRANSITION, VSO-1690654
+template <class _Ty>
+struct _Is_aggregate_impl : bool_constant<__is_aggregate(_Ty)> {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_aggregate_v =
+    disjunction_v<is_array<_Ty>, _Is_aggregate_impl<_Ty>>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_aggregate : bool_constant<is_aggregate_v<_Ty>> {};
+#else // ^^^ workaround / no workaround vvv
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_aggregate : bool_constant<__is_aggregate(_Ty)> {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_aggregate_v = __is_aggregate(_Ty);
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty, class... _Args>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_constructible : bool_constant<__is_constructible(_Ty, _Args...)> {
+    // determine whether _Ty can be direct-initialized with _Args...
+};
+
+_EXPORT_STD template <class _Ty, class... _Args>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_constructible_v = __is_constructible(_Ty, _Args...);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_copy_constructible
+    : bool_constant<__is_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether _Ty can be direct-initialized with an lvalue const _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_copy_constructible_v =
+    __is_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_default_constructible : bool_constant<__is_constructible(_Ty)> {
+    // determine whether _Ty can be value-initialized
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_default_constructible_v = __is_constructible(_Ty);
+
+template <class _Ty, class = void>
+struct _Is_implicitly_default_constructible : false_type {
+    // determine whether _Ty can be copy-initialized with {}
+};
+
+template <class _Ty>
+void _Implicitly_default_construct(const _Ty&);
+
+template <class _Ty>
+struct _Is_implicitly_default_constructible<_Ty, void_t<decltype(_Implicitly_default_construct<_Ty>({}))>> : true_type {
+};
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_move_constructible : bool_constant<__is_constructible(_Ty, _Ty)> {
+    // determine whether _Ty can be direct-initialized from an rvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_move_constructible_v = __is_constructible(_Ty, _Ty);
+
+_EXPORT_STD template <class _To, class _From>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_assignable : bool_constant<__is_assignable(_To, _From)> {
+    // determine whether _From can be assigned to _To
+};
+
+_EXPORT_STD template <class _To, class _From>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_assignable_v = __is_assignable(_To, _From);
+
+#if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED)
+template <class _To, class _From>
+struct _Is_assignable_no_precondition_check : bool_constant<__is_assignable_no_precondition_check(_To, _From)> {};
+#else // ^^^ Use intrinsic / intrinsic not supported vvv
+template <class _To, class _From>
+using _Is_assignable_no_precondition_check = is_assignable<_To, _From>;
+#endif // ^^^ intrinsic not supported ^^^
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_copy_assignable
+    : bool_constant<__is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether an lvalue const _Ty can be assigned to an lvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_copy_assignable_v =
+    __is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+
+#if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED)
+template <class _Ty>
+struct _Is_copy_assignable_no_precondition_check
+    : bool_constant<__is_assignable_no_precondition_check(
+          add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {};
+
+template <class _Ty>
+constexpr bool _Is_copy_assignable_unchecked_v =
+    __is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+#else // ^^^ Use intrinsic / intrinsic not supported vvv
+template <class _Ty>
+using _Is_copy_assignable_no_precondition_check = is_copy_assignable<_Ty>;
+
+template <class _Ty>
+constexpr bool _Is_copy_assignable_unchecked_v = is_copy_assignable_v<_Ty>;
+#endif // ^^^ intrinsic not supported ^^^
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_move_assignable
+    : bool_constant<__is_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
+    // determine whether an rvalue _Ty can be assigned to an lvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_move_assignable_v =
+    __is_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+
+#if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED)
+template <class _Ty>
+struct _Is_move_assignable_no_precondition_check
+    : bool_constant<__is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, _Ty)> {};
+
+template <class _Ty>
+constexpr bool _Is_move_assignable_unchecked_v =
+    __is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, _Ty);
+#else // ^^^ Use intrinsic / intrinsic not supported vvv
+template <class _Ty>
+using _Is_move_assignable_no_precondition_check = is_move_assignable<_Ty>;
+
+template <class _Ty>
+constexpr bool _Is_move_assignable_unchecked_v = is_move_assignable_v<_Ty>;
+#endif // ^^^ intrinsic not supported ^^^
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_destructible : bool_constant<__is_destructible(_Ty)> {
+    // true iff remove_all_extents_t<_Ty> is a reference type, or can be explicitly destroyed
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_destructible_v = __is_destructible(_Ty);
+
+_EXPORT_STD template <class _Ty, class... _Args>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_constructible
+    : bool_constant<__is_trivially_constructible(_Ty, _Args...)> {
+    // determine whether direct-initialization of _Ty with _Args... is trivial
+};
+
+_EXPORT_STD template <class _Ty, class... _Args>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_constructible_v =
+    __is_trivially_constructible(_Ty, _Args...);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_copy_constructible
+    : bool_constant<__is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether direct-initialization of _Ty with an lvalue const _Ty is trivial
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_copy_constructible_v =
+    __is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_default_constructible
+    : bool_constant<__is_trivially_constructible(_Ty)> {
+    // determine whether value-initialization of _Ty is trivial
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_default_constructible_v =
+    __is_trivially_constructible(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_move_constructible
+    : bool_constant<__is_trivially_constructible(_Ty, _Ty)> {
+    // determine whether direct-initialization of _Ty with an rvalue _Ty is trivial
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_move_constructible_v =
+    __is_trivially_constructible(_Ty, _Ty);
+
+_EXPORT_STD template <class _To, class _From>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_assignable
+    : bool_constant<__is_trivially_assignable(_To, _From)> {
+    // determine whether _From can be trivially assigned to _To
+};
+
+_EXPORT_STD template <class _To, class _From>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_To, _From);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_copy_assignable
+    : bool_constant<__is_trivially_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether an lvalue const _Ty can be trivially assigned to an lvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_copy_assignable_v =
+    __is_trivially_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_move_assignable
+    : bool_constant<__is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
+    // determine whether an rvalue _Ty can be trivially assigned to an lvalue _Ty
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_move_assignable_v =
+    __is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_trivially_destructible : bool_constant<__is_trivially_destructible(_Ty)> {
+    // determine whether remove_all_extents_t<_Ty> is a reference type or can trivially be explicitly destroyed
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_trivially_destructible_v = __is_trivially_destructible(_Ty);
+
+_EXPORT_STD template <class _Ty, class... _Args>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_constructible
+    : bool_constant<__is_nothrow_constructible(_Ty, _Args...)> {
+    // determine whether direct-initialization of _Ty from _Args... is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty, class... _Args>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_constructible_v =
+    __is_nothrow_constructible(_Ty, _Args...);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_copy_constructible
+    : bool_constant<__is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether direct-initialization of _Ty from an lvalue const _Ty is both valid
+    // and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_copy_constructible_v =
+    __is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_default_constructible
+    : bool_constant<__is_nothrow_constructible(_Ty)> {
+    // determine whether value-initialization of _Ty is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_move_constructible
+    : bool_constant<__is_nothrow_constructible(_Ty, _Ty)> {
+    // determine whether direct-initialization of _Ty from an rvalue _Ty is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_move_constructible_v =
+    __is_nothrow_constructible(_Ty, _Ty);
+
+_EXPORT_STD template <class _To, class _From>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_assignable : bool_constant<__is_nothrow_assignable(_To, _From)> {
+    // determine whether assignment of _From to _To is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _To, class _From>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_To, _From);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_copy_assignable
+    : bool_constant<__is_nothrow_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
+    // determine whether assignment of an lvalue const _Ty to an lvalue _Ty is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_copy_assignable_v =
+    __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_move_assignable
+    : bool_constant<__is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
+    // determine whether assignment of an rvalue _Ty to an lvalue _Ty is both valid and not potentially-throwing
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_move_assignable_v =
+    __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_destructible : bool_constant<__is_nothrow_destructible(_Ty)> {
+    // determine whether remove_all_extents_t<_Ty> is a reference type or has
+    // non-potentially-throwing explicit destruction
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_destructible_v = __is_nothrow_destructible(_Ty);
+
+template <class _Ty, bool = is_integral_v<_Ty>>
+struct _Sign_base { // determine whether integral type _Ty is signed or unsigned
+    using _Uty = remove_cv_t<_Ty>;
+
+    static constexpr bool _Signed   = static_cast<_Uty>(-1) < static_cast<_Uty>(0);
+    static constexpr bool _Unsigned = !_Signed;
+};
+
+template <class _Ty>
+struct _Sign_base<_Ty, false> { // floating-point _Ty is signed
+                                // non-arithmetic _Ty is neither signed nor unsigned
+    static constexpr bool _Signed   = is_floating_point_v<_Ty>;
+    static constexpr bool _Unsigned = false;
+};
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_signed : bool_constant<_Sign_base<_Ty>::_Signed> {
+    // determine whether _Ty is a signed type
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_signed_v = _Sign_base<_Ty>::_Signed;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_unsigned : bool_constant<_Sign_base<_Ty>::_Unsigned> {
+    // determine whether _Ty is an unsigned type
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_unsigned_v = _Sign_base<_Ty>::_Unsigned;
+
+template <bool>
+struct _Select { // Select between aliases that extract either their first or second parameter
+    template <class _Ty1, class>
+    using _Apply = _Ty1;
+};
+
+template <>
+struct _Select<false> {
+    template <class, class _Ty2>
+    using _Apply = _Ty2;
+};
+
+template <size_t>
+struct _Make_signed2; // Choose make_signed strategy by type size
+
+template <>
+struct _Make_signed2<1> {
+    template <class>
+    using _Apply = signed char;
+};
+
+template <>
+struct _Make_signed2<2> {
+    template <class>
+    using _Apply = short;
+};
+
+template <>
+struct _Make_signed2<4> {
+    template <class _Ty>
+    using _Apply = // assumes LLP64
+        typename _Select<is_same_v<_Ty, long> || is_same_v<_Ty, unsigned long>>::template _Apply<long, int>;
+};
+
+template <>
+struct _Make_signed2<8> {
+    template <class>
+    using _Apply = long long;
+};
+
+template <class _Ty>
+using _Make_signed1 = // signed partner to cv-unqualified _Ty
+    typename _Make_signed2<sizeof(_Ty)>::template _Apply<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS make_signed { // signed partner to _Ty
+    static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
+        "make_signed<T> requires that T shall be a (possibly cv-qualified) "
+        "integral type or enumeration but not a bool type.");
+
+    using type = typename remove_cv<_Ty>::template _Apply<_Make_signed1>;
+};
+
+_EXPORT_STD template <class _Ty>
+using make_signed_t = typename make_signed<_Ty>::type;
+
+template <size_t>
+struct _Make_unsigned2; // Choose make_unsigned strategy by type size
+
+template <>
+struct _Make_unsigned2<1> {
+    template <class>
+    using _Apply = unsigned char;
+};
+
+template <>
+struct _Make_unsigned2<2> {
+    template <class>
+    using _Apply = unsigned short;
+};
+
+template <>
+struct _Make_unsigned2<4> {
+    template <class _Ty>
+    using _Apply = // assumes LLP64
+        typename _Select<is_same_v<_Ty, long> || is_same_v<_Ty, unsigned long>>::template _Apply<unsigned long,
+            unsigned int>;
+};
+
+template <>
+struct _Make_unsigned2<8> {
+    template <class>
+    using _Apply = unsigned long long;
+};
+
+template <class _Ty>
+using _Make_unsigned1 = // unsigned partner to cv-unqualified _Ty
+    typename _Make_unsigned2<sizeof(_Ty)>::template _Apply<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS make_unsigned { // unsigned partner to _Ty
+    static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
+        "make_unsigned<T> requires that T shall be a (possibly cv-qualified) "
+        "integral type or enumeration but not a bool type.");
+
+    using type = typename remove_cv<_Ty>::template _Apply<_Make_unsigned1>;
+};
+
+_EXPORT_STD template <class _Ty>
+using make_unsigned_t = typename make_unsigned<_Ty>::type;
+
+template <class _Rep>
+constexpr make_unsigned_t<_Rep> _Unsigned_value(_Rep _Val) { // makes _Val unsigned
+    return static_cast<make_unsigned_t<_Rep>>(_Val);
+}
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS alignment_of : integral_constant<size_t, alignof(_Ty)> {
+}; // determine alignment of _Ty
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr size_t alignment_of_v = alignof(_Ty);
+
+template <class _Ty, size_t _Len>
+union _Align_type { // union with size _Len bytes and alignment of _Ty
+    _Ty _Val;
+    char _Pad[_Len];
+};
+
+template <size_t _Len, size_t _Align, class _Ty, bool _Ok>
+struct _Aligned; // define type with size _Len and alignment _Ty
+
+template <size_t _Len, size_t _Align, class _Ty>
+struct _Aligned<_Len, _Align, _Ty, true> {
+    using type = _Align_type<_Ty, _Len>;
+};
+
+template <size_t _Len, size_t _Align>
+struct _Aligned<_Len, _Align, double, false> {
+#ifdef _ENABLE_EXTENDED_ALIGNED_STORAGE
+    struct type {
+        alignas(_Align) char _Space[_Len];
+    };
+#else // ^^^ defined(_ENABLE_EXTENDED_ALIGNED_STORAGE) / !defined(_ENABLE_EXTENDED_ALIGNED_STORAGE) vvv
+#ifndef _DISABLE_EXTENDED_ALIGNED_STORAGE
+    static_assert(false,
+        "You've instantiated std::aligned_storage<Len, Align> with an extended alignment (in other "
+        "words, Align > alignof(max_align_t)). Before VS 2017 15.8, the member \"type\" would "
+        "non-conformingly have an alignment of only alignof(max_align_t). VS 2017 15.8 was fixed to "
+        "handle this correctly, but the fix inherently changes layout and breaks binary compatibility "
+        "(*only* for uses of aligned_storage with extended alignments). "
+        "To suppress this error, please define either "
+        "(1) _ENABLE_EXTENDED_ALIGNED_STORAGE to confirm that you want a type with an extended alignment, or "
+        "(2) _DISABLE_EXTENDED_ALIGNED_STORAGE to get the old non-conforming behavior.");
+#endif // ^^^ !defined(_DISABLE_EXTENDED_ALIGNED_STORAGE) ^^^
+    using type = _Align_type<max_align_t, _Len>;
+#endif // ^^^ !defined(_ENABLE_EXTENDED_ALIGNED_STORAGE) ^^^
+};
+
+template <size_t _Len, size_t _Align>
+struct _Aligned<_Len, _Align, int, false> {
+    using _Next                 = double;
+    static constexpr bool _Fits = _Align <= alignof(_Next);
+    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
+};
+
+template <size_t _Len, size_t _Align>
+struct _Aligned<_Len, _Align, short, false> {
+    using _Next                 = int;
+    static constexpr bool _Fits = _Align <= alignof(_Next);
+    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
+};
+
+template <size_t _Len, size_t _Align>
+struct _Aligned<_Len, _Align, char, false> {
+    using _Next                 = short;
+    static constexpr bool _Fits = _Align <= alignof(_Next);
+    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
+};
+
+// TRANSITION, ABI: Internal non-deprecated version to avoid ABI changes due to deprecation
+template <size_t _Len, size_t _Align = alignof(max_align_t)>
+struct _Aligned_storage { // define type with size _Len and alignment _Align
+    using _Next                 = char;
+    static constexpr bool _Fits = _Align <= alignof(_Next);
+    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
+};
+
+template <size_t _Len, size_t _Align = alignof(max_align_t)>
+using _Aligned_storage_t = typename _Aligned_storage<_Len, _Align>::type;
+
+_EXPORT_STD template <size_t _Len, size_t _Align = alignof(max_align_t)>
+struct _CXX23_DEPRECATE_ALIGNED_STORAGE _NO_SPECIALIZATIONS_OF_TYPE_TRAITS aligned_storage {
+    // define type with size _Len and alignment _Align
+    using type = _Aligned_storage_t<_Len, _Align>;
+};
+
+_EXPORT_STD template <size_t _Len, size_t _Align = alignof(max_align_t)>
+using aligned_storage_t _CXX23_DEPRECATE_ALIGNED_STORAGE = _Aligned_storage_t<_Len, _Align>;
+
+template <size_t... _Vals>
+struct _Maximum;
+
+template <>
+struct _Maximum<> : integral_constant<size_t, 0> {}; // maximum of nothing is 0
+
+template <size_t _Val>
+struct _Maximum<_Val> : integral_constant<size_t, _Val> {}; // maximum of _Val is _Val
+
+template <size_t _First, size_t _Second, size_t... _Rest>
+struct _Maximum<_First, _Second, _Rest...> : _Maximum<(_First < _Second ? _Second : _First), _Rest...>::type {
+    // find maximum value in _First, _Second, _Rest...
+};
+
+_EXPORT_STD template <size_t _Len, class... _Types>
+struct _CXX23_DEPRECATE_ALIGNED_UNION _NO_SPECIALIZATIONS_OF_TYPE_TRAITS aligned_union {
+    // define type with size at least _Len, for storing anything in _Types
+    static constexpr size_t _Max_len        = _Maximum<_Len, sizeof(_Types)...>::value; // NOT sizeof...(_Types)
+    static constexpr size_t alignment_value = _Maximum<alignof(_Types)...>::value;
+
+    using type = _Aligned_storage_t<_Max_len, alignment_value>;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <size_t _Len, class... _Types>
+using aligned_union_t _CXX23_DEPRECATE_ALIGNED_UNION = typename aligned_union<_Len, _Types...>::type;
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, bool = is_enum_v<_Ty>>
+struct _Underlying_type {
+    using type = __underlying_type(_Ty);
+};
+
+template <class _Ty>
+struct _Underlying_type<_Ty, false> {};
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS underlying_type : _Underlying_type<_Ty> {
+}; // determine underlying type for enum
+
+_EXPORT_STD template <class _Ty>
+using underlying_type_t = typename _Underlying_type<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr size_t rank_v = 0; // determine number of dimensions of array _Ty
+
+template <class _Ty, size_t _Nx>
+constexpr size_t rank_v<_Ty[_Nx]> = rank_v<_Ty> + 1;
+
+template <class _Ty>
+constexpr size_t rank_v<_Ty[]> = rank_v<_Ty> + 1;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS rank : integral_constant<size_t, rank_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty, unsigned int _Ix = 0>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr size_t extent_v = 0; // determine extent of dimension _Ix of array _Ty
+
+template <class _Ty, size_t _Nx>
+constexpr size_t extent_v<_Ty[_Nx], 0> = _Nx;
+
+template <class _Ty, unsigned int _Ix, size_t _Nx>
+constexpr size_t extent_v<_Ty[_Nx], _Ix> = extent_v<_Ty, _Ix - 1>;
+
+template <class _Ty, unsigned int _Ix>
+constexpr size_t extent_v<_Ty[], _Ix> = extent_v<_Ty, _Ix - 1>;
+
+_EXPORT_STD template <class _Ty, unsigned int _Ix = 0>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS extent : integral_constant<size_t, extent_v<_Ty, _Ix>> {};
+
+_EXPORT_STD template <class _Base, class _Derived>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_base_of : bool_constant<__is_base_of(_Base, _Derived)> {
+    // determine whether _Base is a base of or the same as _Derived
+};
+
+_EXPORT_STD template <class _Base, class _Derived>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS decay { // determines decayed version of _Ty
+    using _Ty1 = remove_reference_t<_Ty>;
+    using _Ty2 = typename _Select<is_function_v<_Ty1>>::template _Apply<add_pointer<_Ty1>, remove_cv<_Ty1>>;
+    using type = typename _Select<is_array_v<_Ty1>>::template _Apply<add_pointer<remove_extent_t<_Ty1>>, _Ty2>::type;
+};
+
+_EXPORT_STD template <class _Ty>
+using decay_t = typename decay<_Ty>::type;
+
+template <class _Ty1, class _Ty2>
+using _Conditional_type = decltype(false ? _STD declval<_Ty1>() : _STD declval<_Ty2>());
+
+#if _HAS_CXX20
+template <class _Ty1, class _Ty2>
+struct _Const_lvalue_cond_oper {};
+
+// N4950 [meta.trans.other]/3.3.4 (per the proposed resolution of LWG-3205): "Otherwise, if remove_cvref_t</**/> denotes
+// a type..."
+template <class _Ty1, class _Ty2>
+    requires requires { typename _Conditional_type<const _Ty1&, const _Ty2&>; }
+struct _Const_lvalue_cond_oper<_Ty1, _Ty2> {
+    using type = remove_cvref_t<_Conditional_type<const _Ty1&, const _Ty2&>>;
+};
+
+template <class _Ty1, class _Ty2, class = void>
+struct _Decayed_cond_oper : _Const_lvalue_cond_oper<_Ty1, _Ty2> {};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty1, class _Ty2, class = void>
+struct _Decayed_cond_oper {};
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Ty1, class _Ty2>
+struct _Decayed_cond_oper<_Ty1, _Ty2, void_t<_Conditional_type<_Ty1, _Ty2>>> {
+    using type = decay_t<_Conditional_type<_Ty1, _Ty2>>;
+};
+
+_EXPORT_STD template <class... _Ty>
+struct common_type; // specializations allowed by N5014 [meta.trans.other]/5
+
+_EXPORT_STD template <class... _Ty>
+using common_type_t = typename common_type<_Ty...>::type;
+
+template <>
+struct common_type<> {};
+
+template <class _Ty1>
+struct common_type<_Ty1> : common_type<_Ty1, _Ty1> {};
+
+template <class _Ty1, class _Ty2, class _Decayed1 = decay_t<_Ty1>, class _Decayed2 = decay_t<_Ty2>>
+struct _Common_type2 : common_type<_Decayed1, _Decayed2> {};
+
+template <class _Ty1, class _Ty2>
+struct _Common_type2<_Ty1, _Ty2, _Ty1, _Ty2> : _Decayed_cond_oper<_Ty1, _Ty2> {};
+
+template <class _Ty1, class _Ty2>
+struct common_type<_Ty1, _Ty2> : _Common_type2<_Ty1, _Ty2> {};
+
+template <class _Void, class _Ty1, class _Ty2, class... _Rest>
+struct _Common_type3 {};
+
+template <class _Ty1, class _Ty2, class... _Rest>
+struct _Common_type3<void_t<common_type_t<_Ty1, _Ty2>>, _Ty1, _Ty2, _Rest...>
+    : common_type<common_type_t<_Ty1, _Ty2>, _Rest...> {};
+
+template <class _Ty1, class _Ty2, class... _Rest>
+struct common_type<_Ty1, _Ty2, _Rest...> : _Common_type3<void, _Ty1, _Ty2, _Rest...> {};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-volatile"
+#endif // defined(__clang__)
+
+template <class _Ty>
+_Ty _Returns_exactly() noexcept; // not defined
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+#if _HAS_CXX20
+_EXPORT_STD template <class, class, template <class> class, template <class> class>
+struct basic_common_reference {}; // specializations allowed by N5014 [meta.trans.other]/7
+
+template <class _From>
+struct _Copy_cv_impl {
+    template <class _To>
+    using _Apply = _To;
+};
+template <class _From>
+struct _Copy_cv_impl<const _From> {
+    template <class _To>
+    using _Apply = const _To;
+};
+template <class _From>
+struct _Copy_cv_impl<volatile _From> {
+    template <class _To>
+    using _Apply = volatile _To;
+};
+template <class _From>
+struct _Copy_cv_impl<const volatile _From> {
+    template <class _To>
+    using _Apply = const volatile _To;
+};
+template <class _From, class _To>
+using _Copy_cv = // N4950 [meta.trans.other]/2.3
+    _Copy_cv_impl<_From>::template _Apply<_To>;
+
+template <class _Ty1>
+struct _Add_qualifiers { // _Add_qualifiers<A>::template _Apply is XREF(A) from N4950 [meta.trans.other]/2.2
+    template <class _Ty2>
+    using _Apply = _Copy_cv<_Ty1, _Ty2>;
+};
+template <class _Ty1>
+struct _Add_qualifiers<_Ty1&> {
+    template <class _Ty2>
+    using _Apply = add_lvalue_reference_t<_Copy_cv<_Ty1, _Ty2>>;
+};
+template <class _Ty1>
+struct _Add_qualifiers<_Ty1&&> {
+    template <class _Ty2>
+    using _Apply = add_rvalue_reference_t<_Copy_cv<_Ty1, _Ty2>>;
+};
+
+template <class _Ty1, class _Ty2>
+using _Cond_res = // N4950 [meta.trans.other]/2.4
+    decltype(false ? _Returns_exactly<_Ty1>() : _Returns_exactly<_Ty2>());
+
+_EXPORT_STD template <class...>
+struct _NO_SPECIALIZATIONS_CITING("N5014 [meta.rqmts]/4; instead, you should specialize std::basic_common_reference "
+                                  "as allowed by N5014 [meta.trans.other]/7") common_reference;
+
+_EXPORT_STD template <class... _Types>
+using common_reference_t = common_reference<_Types...>::type;
+
+// N4950 [meta.trans.other]/5.1: "If sizeof...(T) is zero ..."
+template <>
+struct common_reference<> {};
+
+// N4950 [meta.trans.other]/5.2: "...if sizeof...(T) is one ..."
+template <class _Ty>
+struct common_reference<_Ty> {
+    using type = _Ty;
+};
+
+// N4950 [meta.trans.other]/5.3: "...if sizeof...(T) is two..."
+
+// N4950 [meta.trans.other]/5.3.4: "if common_type_t<T1, T2> is well-formed..."
+// N4950 [meta.trans.other]/5.3.5: "Otherwise, there shall be no member type."
+template <class _Ty1, class _Ty2>
+struct _Common_reference2C : common_type<_Ty1, _Ty2> {};
+
+// N4950 [meta.trans.other]/5.3.3: "if COND_RES(T1, T2) is well-formed..."
+template <class _Ty1, class _Ty2>
+    requires requires { typename _Cond_res<_Ty1, _Ty2>; }
+struct _Common_reference2C<_Ty1, _Ty2> {
+    using type = _Cond_res<_Ty1, _Ty2>;
+};
+
+// N4950 [meta.trans.other]/5.3.2: "if basic_common_reference<[...]>::type is well-formed..."
+template <class _Ty1, class _Ty2>
+using _Basic_specialization = basic_common_reference<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>,
+    _Add_qualifiers<_Ty1>::template _Apply, _Add_qualifiers<_Ty2>::template _Apply>::type;
+
+template <class _Ty1, class _Ty2>
+struct _Common_reference2B : _Common_reference2C<_Ty1, _Ty2> {};
+
+template <class _Ty1, class _Ty2>
+    requires requires { typename _Basic_specialization<_Ty1, _Ty2>; }
+struct _Common_reference2B<_Ty1, _Ty2> {
+    using type = _Basic_specialization<_Ty1, _Ty2>;
+};
+
+// N4950 [meta.trans.other]/5.3.1: "Let R be COMMON-REF(T1, T2). If T1 and T2 are reference types, R is well-formed, and
+// is_convertible_v<add_pointer_t<T1>, add_pointer_t<R>> && is_convertible_v<add_pointer_t<T2>, add_pointer_t<R>> is
+// true, then the member typedef type denotes R."
+template <class _Ty1, class _Ty2>
+struct _Common_reference2A : _Common_reference2B<_Ty1, _Ty2> {};
+
+template <class _Ty1, class _Ty2>
+    requires is_lvalue_reference_v<_Cond_res<_Copy_cv<_Ty1, _Ty2>&, _Copy_cv<_Ty2, _Ty1>&>>
+using _LL_common_ref = _Cond_res<_Copy_cv<_Ty1, _Ty2>&, _Copy_cv<_Ty2, _Ty1>&>;
+
+template <class _Ty1, class _Ty2>
+struct _Common_reference2AX {};
+
+template <class _Ty1, class _Ty2>
+    requires requires { typename _LL_common_ref<_Ty1, _Ty2>; }
+struct _Common_reference2AX<_Ty1&, _Ty2&> {
+    using type = _LL_common_ref<_Ty1, _Ty2>; // "both lvalues" case from N4950 [meta.trans.other]/2.5
+};
+
+template <class _Ty1, class _Ty2>
+    requires is_convertible_v<_Ty1&&, _LL_common_ref<const _Ty1, _Ty2>>
+struct _Common_reference2AX<_Ty1&&, _Ty2&> {
+    using type = _LL_common_ref<const _Ty1, _Ty2>; // "rvalue and lvalue" case from N4950 [meta.trans.other]/2.7
+};
+
+template <class _Ty1, class _Ty2>
+    requires is_convertible_v<_Ty2&&, _LL_common_ref<const _Ty2, _Ty1>>
+struct _Common_reference2AX<_Ty1&, _Ty2&&> {
+    using type = _LL_common_ref<const _Ty2, _Ty1>; // "lvalue and rvalue" case from N4950 [meta.trans.other]/2.8
+};
+
+template <class _Ty1, class _Ty2>
+using _RR_common_ref = remove_reference_t<_LL_common_ref<_Ty1, _Ty2>>&&;
+
+template <class _Ty1, class _Ty2>
+    requires is_convertible_v<_Ty1&&, _RR_common_ref<_Ty1, _Ty2>>
+          && is_convertible_v<_Ty2&&, _RR_common_ref<_Ty1, _Ty2>>
+struct _Common_reference2AX<_Ty1&&, _Ty2&&> {
+    using type = _RR_common_ref<_Ty1, _Ty2>; // "both rvalues" case from N4950 [meta.trans.other]/2.6
+};
+
+template <class _Ty1, class _Ty2>
+using _Common_ref_2AX_t = _Common_reference2AX<_Ty1, _Ty2>::type;
+
+template <class _Ty1, class _Ty2>
+    requires is_convertible_v<add_pointer_t<_Ty1>, add_pointer_t<_Common_ref_2AX_t<_Ty1, _Ty2>>>
+          && is_convertible_v<add_pointer_t<_Ty2>, add_pointer_t<_Common_ref_2AX_t<_Ty1, _Ty2>>>
+struct _Common_reference2A<_Ty1, _Ty2> {
+    using type = _Common_ref_2AX_t<_Ty1, _Ty2>;
+};
+
+template <class _Ty1, class _Ty2>
+struct common_reference<_Ty1, _Ty2> : _Common_reference2A<_Ty1, _Ty2> {};
+
+// N4950 [meta.trans.other]/5.4: "if sizeof...(T) is greater than two..."
+template <class _Ty1, class _Ty2, class _Ty3, class... _Rest>
+struct common_reference<_Ty1, _Ty2, _Ty3, _Rest...> {};
+template <class _Ty1, class _Ty2, class _Ty3, class... _Rest>
+    requires requires { typename common_reference_t<_Ty1, _Ty2>; }
+struct common_reference<_Ty1, _Ty2, _Ty3, _Rest...> : common_reference<common_reference_t<_Ty1, _Ty2>, _Ty3, _Rest...> {
+};
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS type_identity {
+    using type = _Ty;
+};
+_EXPORT_STD template <class _Ty>
+using type_identity_t = type_identity<_Ty>::type;
+#endif // _HAS_CXX20
+
+template <class _Type, template <class...> class _Template>
+constexpr bool _Is_specialization_v = false; // true if and only if _Type is a specialization of _Template
+template <template <class...> class _Template, class... _Types>
+constexpr bool _Is_specialization_v<_Template<_Types...>, _Template> = true;
+
+template <class _Type, template <class...> class _Template>
+struct _Is_specialization : bool_constant<_Is_specialization_v<_Type, _Template>> {};
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr _Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept {
+    return static_cast<_Ty&&>(_Arg);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept {
+    static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call");
+    return static_cast<_Ty&&>(_Arg);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept {
+    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr //
+    conditional_t<!is_nothrow_move_constructible_v<_Ty> && is_copy_constructible_v<_Ty>, const _Ty&, _Ty&&>
+    move_if_noexcept(_Ty& _Arg) noexcept {
+    return _STD move(_Arg);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty* addressof(_Ty& _Val) noexcept {
+    return __builtin_addressof(_Val);
+}
+
+_EXPORT_STD template <class _Ty>
+const _Ty* addressof(const _Ty&&) = delete;
+
+#pragma warning(push)
+#pragma warning(disable : 5215) // '%s' a function parameter with a volatile qualified type is deprecated in C++20
+#pragma warning(disable : 5216) // '%s' a volatile qualified return type is deprecated in C++20
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-volatile"
+#endif // defined(__clang__)
+
+template <class _Ty>
+_NODISCARD _Ty _Fake_copy_init(_Ty) noexcept;
+// _Fake_copy_init<T>(E):
+// (1) has type T [decay_t<decltype((E))> if T is deduced],
+// (2) is well-formed if and only if E is implicitly convertible to T and T is destructible, and
+// (3) is non-throwing if and only if both conversion from decltype((E)) to T and destruction of T are non-throwing.
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+#pragma warning(pop)
+
+_EXPORT_STD template <class _Ty>
+class reference_wrapper;
+
+// std::invoke isn't constexpr in C++17, and normally implementers are forbidden from "strengthening" constexpr
+// (N4950 [constexpr.functions]/1), yet both std::apply and std::visit are required to be constexpr and have
+// invoke-like behavior. As a result, we've chosen to apply the part of P1065R2 resolving LWG-2894 as a defect report.
+
+enum class _Invoker_strategy {
+    _Functor,
+    _Pmf_object,
+    _Pmf_refwrap,
+    _Pmf_pointer,
+    _Pmd_object,
+    _Pmd_refwrap,
+    _Pmd_pointer
+};
+
+struct _Invoker_functor {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Functor;
+
+    template <class _Callable, class... _Types>
+    static constexpr auto _Call(_Callable&& _Obj, _Types&&... _Args)
+        noexcept(noexcept(static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...)))
+            -> decltype(static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...)) {
+        return static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...);
+    }
+};
+
+struct _Invoker_pmf_object {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_object;
+
+    template <class _Decayed, class _Ty1, class... _Types2>
+    static constexpr auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2)
+        noexcept(noexcept((static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
+            -> decltype((static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
+        return (static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...);
+    }
+};
+
+struct _Invoker_pmf_refwrap {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_refwrap;
+
+    template <class _Decayed, class _Refwrap, class... _Types2>
+    static constexpr auto _Call(_Decayed _Pmf, _Refwrap _Rw, _Types2&&... _Args2)
+        noexcept(noexcept((_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
+            -> decltype((_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
+        return (_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...);
+    }
+};
+
+struct _Invoker_pmf_pointer {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_pointer;
+
+    template <class _Decayed, class _Ty1, class... _Types2>
+    static constexpr auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2)
+        noexcept(noexcept(((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
+            -> decltype(((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
+        return ((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...);
+    }
+};
+
+struct _Invoker_pmd_object {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_object;
+
+    template <class _Decayed, class _Ty1>
+    static constexpr auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) noexcept -> decltype(static_cast<_Ty1&&>(_Arg1).*_Pmd) {
+        return static_cast<_Ty1&&>(_Arg1).*_Pmd;
+    }
+};
+
+struct _Invoker_pmd_refwrap {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_refwrap;
+
+    template <class _Decayed, class _Refwrap>
+    static constexpr auto _Call(_Decayed _Pmd, _Refwrap _Rw) noexcept -> decltype(_Rw.get().*_Pmd) {
+        return _Rw.get().*_Pmd;
+    }
+};
+
+struct _Invoker_pmd_pointer {
+    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_pointer;
+
+    template <class _Decayed, class _Ty1>
+    static constexpr auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) noexcept(noexcept((*static_cast<_Ty1&&>(_Arg1)).*_Pmd))
+        -> decltype((*static_cast<_Ty1&&>(_Arg1)).*_Pmd) {
+        return (*static_cast<_Ty1&&>(_Arg1)).*_Pmd;
+    }
+};
+
+template <class _Callable, class _Ty1, class _Removed_cvref = _Remove_cvref_t<_Callable>,
+    bool _Is_pmf = is_member_function_pointer_v<_Removed_cvref>,
+    bool _Is_pmd = is_member_object_pointer_v<_Removed_cvref>>
+struct _Invoker1;
+
+template <class _Callable, class _Ty1, class _Removed_cvref>
+struct _Invoker1<_Callable, _Ty1, _Removed_cvref, true, false>
+    : conditional_t<is_same_v<typename _Is_memfunptr<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>
+                        || is_base_of_v<typename _Is_memfunptr<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>,
+          _Invoker_pmf_object,
+          conditional_t<_Is_specialization_v<_Remove_cvref_t<_Ty1>, reference_wrapper>, _Invoker_pmf_refwrap,
+              _Invoker_pmf_pointer>> {}; // pointer to member function
+
+template <class _Callable, class _Ty1, class _Removed_cvref>
+struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, true>
+    : conditional_t<
+          is_same_v<typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>
+              || is_base_of_v<typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, _Remove_cvref_t<_Ty1>>,
+          _Invoker_pmd_object,
+          conditional_t<_Is_specialization_v<_Remove_cvref_t<_Ty1>, reference_wrapper>, _Invoker_pmd_refwrap,
+              _Invoker_pmd_pointer>> {}; // pointer to member data
+
+template <class _Callable, class _Ty1, class _Removed_cvref>
+struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, false> : _Invoker_functor {};
+
+_EXPORT_STD template <class _Callable>
+constexpr auto invoke(_Callable&& _Obj) noexcept(noexcept(static_cast<_Callable&&>(_Obj)()))
+    -> decltype(static_cast<_Callable&&>(_Obj)()) {
+    return static_cast<_Callable&&>(_Obj)();
+}
+
+_EXPORT_STD template <class _Callable, class _Ty1, class... _Types2>
+constexpr auto invoke(_Callable&& _Obj, _Ty1&& _Arg1, _Types2&&... _Args2)
+    noexcept(noexcept(_Invoker1<_Callable, _Ty1>::_Call(
+        static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)))
+        -> decltype(_Invoker1<_Callable, _Ty1>::_Call(
+            static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)) {
+    constexpr auto _Strat = _Invoker1<_Callable, _Ty1>::_Strategy;
+    if constexpr (_Strat == _Invoker_strategy::_Functor) {
+        return static_cast<_Callable&&>(_Obj)(static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...);
+    } else if constexpr (_Strat == _Invoker_strategy::_Pmf_object) {
+        return (static_cast<_Ty1&&>(_Arg1).*_Obj)(static_cast<_Types2&&>(_Args2)...);
+    } else if constexpr (_Strat == _Invoker_strategy::_Pmf_refwrap) {
+        return (_Arg1.get().*_Obj)(static_cast<_Types2&&>(_Args2)...);
+    } else if constexpr (_Strat == _Invoker_strategy::_Pmf_pointer) {
+        return ((*static_cast<_Ty1&&>(_Arg1)).*_Obj)(static_cast<_Types2&&>(_Args2)...);
+    } else if constexpr (_Strat == _Invoker_strategy::_Pmd_object) {
+        return static_cast<_Ty1&&>(_Arg1).*_Obj;
+    } else if constexpr (_Strat == _Invoker_strategy::_Pmd_refwrap) {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1956799
+        return _Arg1.get().*_Obj;
+#else // ^^^ no workaround / workaround vvv
+        auto& _Ref = _Arg1.get();
+        return _Ref.*_Obj;
+#endif // ^^^ workaround ^^^
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(_Strat == _Invoker_strategy::_Pmd_pointer);
+        return (*static_cast<_Ty1&&>(_Arg1)).*_Obj;
+    }
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4242) // '%s': conversion from '%s' to '%s', possible loss of data (/Wall)
+#pragma warning(disable : 4244) // '%s': conversion from '%s' to '%s', possible loss of data (Yes, duplicated message.)
+#pragma warning(disable : 4365) // '%s': conversion from '%s' to '%s', signed/unsigned mismatch (/Wall)
+
+template <class _From, class _To, bool = is_convertible_v<_From, _To>, bool = is_void_v<_To>>
+constexpr bool _Is_nothrow_convertible_v = noexcept(_STD _Fake_copy_init<_To>(_STD declval<_From>()));
+
+#pragma warning(pop)
+
+template <class _From, class _To, bool _IsVoid>
+constexpr bool _Is_nothrow_convertible_v<_From, _To, false, _IsVoid> = false;
+
+template <class _From, class _To>
+constexpr bool _Is_nothrow_convertible_v<_From, _To, true, true> = true;
+
+template <class _From, class _To>
+struct _Is_nothrow_convertible : bool_constant<_Is_nothrow_convertible_v<_From, _To>> {
+    // determine whether _From is nothrow-convertible to _To
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _From, class _To>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_convertible_v = _Is_nothrow_convertible_v<_From, _To>;
+
+_EXPORT_STD template <class _From, class _To>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_convertible
+    : bool_constant<_Is_nothrow_convertible_v<_From, _To>> {};
+#endif // _HAS_CXX20
+
+template <class _From, class _To, class = void>
+struct _Invoke_convertible : false_type {};
+
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+template <class _To, class _From>
+using _Not_reference_converts_from_temporary = bool_constant<!reference_converts_from_temporary_v<_To, _From>>;
+#else // ^^^ no workaround / workaround vvv
+template <class _To, class _From>
+using _Not_reference_converts_from_temporary = true_type;
+#endif // ^^^ workaround ^^^
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class _To, class _From>
+using _Not_reference_converts_from_temporary = true_type;
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+template <class _From, class _To>
+struct _Invoke_convertible<_From, _To, void_t<decltype(_STD _Fake_copy_init<_To>(_STD _Returns_exactly<_From>()))>>
+    : _Not_reference_converts_from_temporary<_To, _From> {};
+
+template <class _From, class _To>
+struct _Invoke_nothrow_convertible
+    : bool_constant<noexcept(_STD _Fake_copy_init<_To>(_STD _Returns_exactly<_From>()))> {};
+
+template <class _Result, bool _Nothrow>
+struct _Invoke_traits_common {
+    using type                  = _Result;
+    using _Is_invocable         = true_type;
+    using _Is_nothrow_invocable = bool_constant<_Nothrow>;
+    template <class _Rx>
+    using _Is_invocable_r = bool_constant<disjunction_v<is_void<_Rx>, _Invoke_convertible<type, _Rx>>>;
+    template <class _Rx>
+    using _Is_nothrow_invocable_r = bool_constant<conjunction_v<_Is_nothrow_invocable,
+        disjunction<is_void<_Rx>,
+            conjunction<_Invoke_convertible<type, _Rx>, _Invoke_nothrow_convertible<type, _Rx>>>>>;
+};
+
+template <class _Void, class _Callable>
+struct _Invoke_traits_zero {
+    // selected when _Callable isn't callable with zero _Args
+    using _Is_invocable         = false_type;
+    using _Is_nothrow_invocable = false_type;
+    template <class _Rx>
+    using _Is_invocable_r = false_type;
+    template <class _Rx>
+    using _Is_nothrow_invocable_r = false_type;
+};
+
+template <class _Callable>
+using _Decltype_invoke_zero = decltype(_STD declval<_Callable>()());
+
+template <class _Callable>
+struct _Invoke_traits_zero<void_t<_Decltype_invoke_zero<_Callable>>, _Callable>
+    : _Invoke_traits_common<_Decltype_invoke_zero<_Callable>, noexcept(_STD declval<_Callable>()())> {};
+
+template <class _Void, class... _Types>
+struct _Invoke_traits_nonzero {
+    // selected when _Callable isn't callable with nonzero _Args
+    using _Is_invocable         = false_type;
+    using _Is_nothrow_invocable = false_type;
+    template <class _Rx>
+    using _Is_invocable_r = false_type;
+    template <class _Rx>
+    using _Is_nothrow_invocable_r = false_type;
+};
+
+template <class _Callable, class _Ty1, class... _Types2>
+using _Decltype_invoke_nonzero = decltype(_Invoker1<_Callable, _Ty1>::_Call(
+    _STD declval<_Callable>(), _STD declval<_Ty1>(), _STD declval<_Types2>()...));
+
+template <class _Callable, class _Ty1, class... _Types2>
+struct _Invoke_traits_nonzero<void_t<_Decltype_invoke_nonzero<_Callable, _Ty1, _Types2...>>, _Callable, _Ty1,
+    _Types2...> : _Invoke_traits_common<_Decltype_invoke_nonzero<_Callable, _Ty1, _Types2...>,
+                      noexcept(_Invoker1<_Callable, _Ty1>::_Call(
+                          _STD declval<_Callable>(), _STD declval<_Ty1>(), _STD declval<_Types2>()...))> {};
+
+template <class _Callable, class... _Args>
+using _Select_invoke_traits = conditional_t<sizeof...(_Args) == 0, _Invoke_traits_zero<void, _Callable>,
+    _Invoke_traits_nonzero<void, _Callable, _Args...>>;
+
+#if _HAS_DEPRECATED_RESULT_OF
+_EXPORT_STD template <class _Fty>
+struct _CXX17_DEPRECATE_RESULT_OF _NO_SPECIALIZATIONS_OF_TYPE_TRAITS result_of { // explain usage
+    static_assert(false, "result_of<CallableType> is invalid; use "
+                         "result_of<CallableType(zero or more argument types)> instead.");
+};
+
+#define _RESULT_OF(CALL_OPT, X1, X2, X3)                                                                    \
+    template <class _Callable, class... _Args>                                                              \
+    struct _CXX17_DEPRECATE_RESULT_OF result_of<_Callable CALL_OPT(_Args...)>                               \
+        : _Select_invoke_traits<_Callable, _Args...> { /* template to determine result of call operation */ \
+    };
+
+_NON_MEMBER_CALL(_RESULT_OF, X1, X2, X3)
+#undef _RESULT_OF
+
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <class _Ty>
+using result_of_t _CXX17_DEPRECATE_RESULT_OF = typename result_of<_Ty>::type;
+_STL_RESTORE_DEPRECATED_WARNING
+#endif // _HAS_DEPRECATED_RESULT_OF
+
+template <class _Callable, class... _Args>
+using _Invoke_result_t = typename _Select_invoke_traits<_Callable, _Args...>::type;
+
+template <class _Rx, class _Callable, class... _Args>
+using _Is_invocable_r_ = typename _Select_invoke_traits<_Callable, _Args...>::template _Is_invocable_r<_Rx>;
+
+template <class _Rx, class _Callable, class... _Args>
+struct _Is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
+    // determines whether _Callable is callable with _Args and return type _Rx
+};
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Callable, class... _Args>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS invoke_result : _Select_invoke_traits<_Callable, _Args...> {
+    // determine the result type of invoking _Callable with _Args
+};
+
+_EXPORT_STD template <class _Callable, class... _Args>
+using invoke_result_t = typename _Select_invoke_traits<_Callable, _Args...>::type;
+
+_EXPORT_STD template <class _Callable, class... _Args>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_invocable {
+    // determines whether _Callable is callable with _Args
+};
+
+_EXPORT_STD template <class _Callable, class... _Args>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_invocable_v =
+    _Select_invoke_traits<_Callable, _Args...>::_Is_invocable::value;
+
+_EXPORT_STD template <class _Callable, class... _Args>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_invocable
+    : _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable {
+    // determines whether _Callable is nothrow-callable with _Args
+};
+
+_EXPORT_STD template <class _Callable, class... _Args>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_invocable_v =
+    _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable::value;
+
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
+    // determines whether _Callable is callable with _Args and return type _Rx
+};
+
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_invocable_r_v = _Is_invocable_r_<_Rx, _Callable, _Args...>::value;
+
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_invocable_r
+    : _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx> {
+    // determines whether _Callable is nothrow-callable with _Args and return type _Rx
+};
+
+_EXPORT_STD template <class _Rx, class _Callable, class... _Args>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_invocable_r_v =
+    _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx>::value;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_layout_compatible : bool_constant<__is_layout_compatible(_Ty1, _Ty2)> {};
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_layout_compatible_v = __is_layout_compatible(_Ty1, _Ty2);
+
+_EXPORT_STD template <class _Base, class _Derived>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_pointer_interconvertible_base_of
+    : bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)> {};
+
+_EXPORT_STD template <class _Base, class _Derived>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_pointer_interconvertible_base_of_v =
+    __is_pointer_interconvertible_base_of(_Base, _Derived);
+
+#ifndef __clang__ // TRANSITION, LLVM-48860
+_EXPORT_STD template <class _ClassTy, class _MemberTy>
+_NODISCARD _NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_pointer_interconvertible_with_class(
+    _MemberTy _ClassTy::* _Pm) noexcept {
+    return __is_pointer_interconvertible_with_class(_ClassTy, _Pm);
+}
+
+_EXPORT_STD template <class _ClassTy1, class _ClassTy2, class _MemberTy1, class _MemberTy2>
+_NODISCARD _NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_corresponding_member(
+    _MemberTy1 _ClassTy1::* _Pm1, _MemberTy2 _ClassTy2::* _Pm2) noexcept {
+    return __is_corresponding_member(_ClassTy1, _ClassTy2, _Pm1, _Pm2);
+}
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX20
+
+template <class _Ty>
+struct _Function_args {}; // determine whether _Ty is a function
+
+#define _FUNCTION_ARGS(CALL_OPT, CV_OPT, REF_OPT, NOEXCEPT_OPT)                                           \
+    template <class _Ret, class... _Types>                                                                \
+    struct _Function_args<_Ret CALL_OPT(_Types...) CV_OPT REF_OPT NOEXCEPT_OPT> : _Arg_types<_Types...> { \
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;                                 \
+    };
+
+_NON_MEMBER_CALL_CV_REF_NOEXCEPT(_FUNCTION_ARGS)
+#undef _FUNCTION_ARGS
+
+#define _FUNCTION_ARGS_ELLIPSIS(CV_REF_NOEXCEPT_OPT)                                                            \
+    template <class _Ret, class... _Types>                                                                      \
+    struct _Function_args<_Ret(_Types..., ...) CV_REF_NOEXCEPT_OPT> { /* no calling conventions for ellipsis */ \
+        using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ret;                                       \
+    };
+
+_CLASS_DEFINE_CV_REF_NOEXCEPT(_FUNCTION_ARGS_ELLIPSIS)
+#undef _FUNCTION_ARGS_ELLIPSIS
+
+template <class _Ty, class = void>
+struct _Weak_result_type {}; // default definition
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Weak_result_type<_Ty, void_t<typename _Ty::result_type>> { // defined if _Ty::result_type exists
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = typename _Ty::result_type;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class = void>
+struct _Weak_argument_type : _Weak_result_type<_Ty> {}; // default definition
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Weak_argument_type<_Ty, void_t<typename _Ty::argument_type>> : _Weak_result_type<_Ty> {
+    // defined if _Ty::argument_type exists
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = typename _Ty::argument_type;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class = void>
+struct _Weak_binary_args : _Weak_argument_type<_Ty> {}; // default definition
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Weak_binary_args<_Ty, void_t<typename _Ty::first_argument_type,
+                                  typename _Ty::second_argument_type>>
+    : _Weak_argument_type<_Ty> { // defined if both types exist
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = typename _Ty::first_argument_type;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = typename _Ty::second_argument_type;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty>
+using _Weak_types = conditional_t<is_function_v<remove_pointer_t<_Ty>>, _Function_args<remove_pointer_t<_Ty>>,
+    conditional_t<is_member_function_pointer_v<_Ty>, _Is_memfunptr<remove_cv_t<_Ty>>, _Weak_binary_args<_Ty>>>;
+
+template <class _Ty>
+void _Refwrap_ctor_fun(_Identity_t<_Ty&>) noexcept; // not defined
+template <class _Ty>
+void _Refwrap_ctor_fun(_Identity_t<_Ty&&>) = delete;
+
+template <class _Ty, class _Uty, class = void>
+struct _Refwrap_has_ctor_from : false_type {};
+
+template <class _Ty, class _Uty>
+struct _Refwrap_has_ctor_from<_Ty, _Uty, void_t<decltype(_STD _Refwrap_ctor_fun<_Ty>(_STD declval<_Uty>()))>>
+    : true_type {}; // _STD _Refwrap_ctor_fun is qualified: avoid ADL, handle incomplete types
+
+_EXPORT_STD template <class _Ty>
+class reference_wrapper
+#if !_HAS_CXX20
+    : public _Weak_types<_Ty>
+#endif // !_HAS_CXX20
+{
+public:
+    static_assert(is_object_v<_Ty> || is_function_v<_Ty>,
+        "reference_wrapper<T> requires T to be an object type or a function type.");
+
+    using type = _Ty;
+
+    template <class _Uty, enable_if_t<conjunction_v<negation<is_same<_Remove_cvref_t<_Uty>, reference_wrapper>>,
+                                          _Refwrap_has_ctor_from<_Ty, _Uty>>,
+                              int> = 0>
+    _CONSTEXPR20 reference_wrapper(_Uty&& _Val) noexcept(
+        noexcept(_STD _Refwrap_ctor_fun<_Ty>(_STD declval<_Uty>()))) { // qualified: avoid ADL, handle incomplete types
+        _Ty& _Ref = static_cast<_Uty&&>(_Val);
+        _Ptr      = _STD addressof(_Ref);
+    }
+
+    _CONSTEXPR20 operator _Ty&() const noexcept {
+        return *_Ptr;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& get() const noexcept {
+        return *_Ptr;
+    }
+
+private:
+    _Ty* _Ptr{};
+
+public:
+    template <class... _Types>
+    _CONSTEXPR20 auto operator()(_Types&&... _Args) const
+        noexcept(noexcept(_STD invoke(*_Ptr, static_cast<_Types&&>(_Args)...)))
+            -> decltype(_STD invoke(*_Ptr, static_cast<_Types&&>(_Args)...)) {
+        return _STD invoke(*_Ptr, static_cast<_Types&&>(_Args)...);
+    }
+};
+
+#if _HAS_CXX17
+template <class _Ty>
+reference_wrapper(_Ty&) -> reference_wrapper<_Ty>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 reference_wrapper<_Ty> ref(_Ty& _Val) noexcept {
+    return reference_wrapper<_Ty>(_Val);
+}
+
+_EXPORT_STD template <class _Ty>
+void ref(const _Ty&&) = delete;
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 reference_wrapper<_Ty> ref(reference_wrapper<_Ty> _Val) noexcept {
+    return _Val;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 reference_wrapper<const _Ty> cref(const _Ty& _Val) noexcept {
+    return reference_wrapper<const _Ty>(_Val);
+}
+
+_EXPORT_STD template <class _Ty>
+void cref(const _Ty&&) = delete;
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _CONSTEXPR20 reference_wrapper<const _Ty> cref(reference_wrapper<_Ty> _Val) noexcept {
+    return _Val;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS unwrap_reference {
+    using type = _Ty;
+};
+template <class _Ty>
+struct unwrap_reference<reference_wrapper<_Ty>> {
+    using type = _Ty&;
+};
+_EXPORT_STD template <class _Ty>
+using unwrap_reference_t = unwrap_reference<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+using unwrap_ref_decay_t = unwrap_reference_t<decay_t<_Ty>>;
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS unwrap_ref_decay {
+    using type = unwrap_ref_decay_t<_Ty>;
+};
+#endif // _HAS_CXX20
+
+template <class _Ty>
+struct _Is_swappable;
+
+template <class _Ty>
+struct _Is_nothrow_swappable;
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> = 0>
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+template <class _Ty, int _Enabled = 0>
+#endif // ^^^ !_HAS_CXX17 ^^^
+_CONSTEXPR20 void swap(_Ty&, _Ty&) noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>);
+
+_EXPORT_STD template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> = 0>
+_CONSTEXPR20 void swap(_Ty (&)[_Size], _Ty (&)[_Size]) noexcept(_Is_nothrow_swappable<_Ty>::value);
+
+template <class _Ty1, class _Ty2, class = void>
+struct _Swappable_with_helper : false_type {}; // swap(declval<_Ty1>(), declval<_Ty2>()) is not valid
+
+template <class _Ty1, class _Ty2>
+struct _Swappable_with_helper<_Ty1, _Ty2, void_t<decltype(swap(_STD declval<_Ty1>(), _STD declval<_Ty2>()))>>
+    : true_type {}; // swap(declval<_Ty1>(), declval<_Ty2>()) is valid
+
+template <class _Ty1, class _Ty2>
+struct _Is_swappable_with
+    : bool_constant<conjunction_v<_Swappable_with_helper<_Ty1, _Ty2>, _Swappable_with_helper<_Ty2, _Ty1>>> {
+    // Determine if expressions with type and value category _Ty1 and _Ty2 can be swapped (and vice versa)
+};
+
+template <class _Ty>
+struct _Is_swappable : _Is_swappable_with<add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<_Ty>>::type {
+    // Determine if _Ty lvalues satisfy is_swappable_with
+};
+
+template <class _Ty1, class _Ty2>
+struct _Swap_cannot_throw : bool_constant<noexcept(swap(_STD declval<_Ty1>(), _STD declval<_Ty2>()))
+                                          && noexcept(swap(_STD declval<_Ty2>(), _STD declval<_Ty1>()))> {
+    // Determine if expressions with type and value category _Ty1 and _Ty2
+    // (presumed to satisfy is_swappable_with) can be swapped without emitting exceptions
+};
+
+template <class _Ty1, class _Ty2>
+struct _Is_nothrow_swappable_with
+    : bool_constant<conjunction_v<_Is_swappable_with<_Ty1, _Ty2>, _Swap_cannot_throw<_Ty1, _Ty2>>> {
+    // Determine if expressions with type and value category _Ty1 and _Ty2
+    // satisfy is_swappable_with, and can be swapped without emitting exceptions
+};
+
+template <class _Ty>
+struct _Is_nothrow_swappable
+    : _Is_nothrow_swappable_with<add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<_Ty>>::type {
+    // Determine if _Ty lvalues satisfy is_nothrow_swappable_with
+};
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_swappable_with : _Is_swappable_with<_Ty1, _Ty2>::type {
+    // Determine if expressions with type and value category _Ty1 and _Ty2
+    // can be swapped (and vice versa)
+};
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_swappable_with_v =
+    conjunction_v<_Swappable_with_helper<_Ty1, _Ty2>, _Swappable_with_helper<_Ty2, _Ty1>>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_swappable : _Is_swappable<_Ty>::type {
+    // Determine if _Ty lvalues satisfy is_swappable_with
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_swappable_v = _Is_swappable<_Ty>::value;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_swappable_with : _Is_nothrow_swappable_with<_Ty1, _Ty2>::type {
+    // Determine if expressions with type and value category _Ty1 and _Ty2
+    // satisfy is_swappable_with, and can be swapped without emitting exceptions
+};
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_swappable_with_v =
+    _Is_nothrow_swappable_with<_Ty1, _Ty2>::value;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_nothrow_swappable : _Is_nothrow_swappable<_Ty>::type {
+    // Determine if _Ty lvalues satisfy is_nothrow_swappable_with
+};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_nothrow_swappable_v = _Is_nothrow_swappable<_Ty>::value;
+#endif // _HAS_CXX17
+
+namespace _Has_ADL_swap_detail {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+    void swap() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+    void swap();
+#endif // ^^^ workaround ^^^
+
+    template <class, class = void>
+    struct _Has_ADL_swap : false_type {};
+    template <class _Ty>
+    struct _Has_ADL_swap<_Ty, void_t<decltype(swap(_STD declval<_Ty&>(), _STD declval<_Ty&>()))>> : true_type {};
+} // namespace _Has_ADL_swap_detail
+using _Has_ADL_swap_detail::_Has_ADL_swap;
+
+template <class _Ty>
+constexpr bool _Is_trivially_swappable_v = conjunction_v<is_trivially_destructible<_Ty>,
+    is_trivially_move_constructible<_Ty>, is_trivially_move_assignable<_Ty>, negation<_Has_ADL_swap<_Ty>>>;
+
+#ifdef __cpp_lib_byte
+template <>
+inline constexpr bool _Is_trivially_swappable_v<byte> = true;
+#endif // defined(__cpp_lib_byte)
+
+template <class _Ty>
+struct _Is_trivially_swappable : bool_constant<_Is_trivially_swappable_v<_Ty>> {
+    // true_type if and only if it is valid to swap two _Ty lvalues by exchanging object representations.
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _From, class _To>
+concept convertible_to = __is_convertible_to(_From, _To) && requires { static_cast<_To>(_STD declval<_From>()); };
+
+template <class _RefWrap, class _Ty, class _RefWrapQ, class _TyQ>
+concept _Ref_wrap_common_reference_exists_with = _Is_specialization_v<_RefWrap, reference_wrapper> && requires {
+    typename common_reference_t<typename _RefWrap::type&, _TyQ>;
+} && convertible_to<_RefWrapQ, common_reference_t<typename _RefWrap::type&, _TyQ>>;
+
+template <class _RefWrap, class _Ty, template <class> class _RefWrapQual, template <class> class _TyQual>
+    requires (_Ref_wrap_common_reference_exists_with<_RefWrap, _Ty, _RefWrapQual<_RefWrap>, _TyQual<_Ty>>
+              && !_Ref_wrap_common_reference_exists_with<_Ty, _RefWrap, _TyQual<_Ty>, _RefWrapQual<_RefWrap>>)
+struct basic_common_reference<_RefWrap, _Ty, _RefWrapQual, _TyQual> {
+    using type = common_reference_t<typename _RefWrap::type&, _TyQual<_Ty>>;
+};
+
+template <class _Ty, class _RefWrap, template <class> class _TyQual, template <class> class _RefWrapQual>
+    requires (_Ref_wrap_common_reference_exists_with<_RefWrap, _Ty, _RefWrapQual<_RefWrap>, _TyQual<_Ty>>
+              && !_Ref_wrap_common_reference_exists_with<_Ty, _RefWrap, _TyQual<_Ty>, _RefWrapQual<_RefWrap>>)
+struct basic_common_reference<_Ty, _RefWrap, _TyQual, _RefWrapQual> {
+    using type = common_reference_t<typename _RefWrap::type&, _TyQual<_Ty>>;
+};
+#endif // _HAS_CXX20
+
+#define _BITMASK_OPS(_MAYBE_EXPORT, _BITMASK)                                                         \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator&(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator|(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator^(_BITMASK _Left, _BITMASK _Right) noexcept { \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right));       \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator&=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left & _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator|=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left | _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT constexpr _BITMASK& operator^=(_BITMASK& _Left, _BITMASK _Right) noexcept {         \
+        return _Left = _Left ^ _Right;                                                                \
+    }                                                                                                 \
+                                                                                                      \
+    _MAYBE_EXPORT _NODISCARD constexpr _BITMASK operator~(_BITMASK _Left) noexcept {                  \
+        using _IntTy = _STD underlying_type_t<_BITMASK>;                                              \
+        return static_cast<_BITMASK>(~static_cast<_IntTy>(_Left));                                    \
+    }
+
+template <class _Bitmask>
+_NODISCARD constexpr bool _Bitmask_includes_any(_Bitmask _Left, _Bitmask _Elements) noexcept {
+    return (_Left & _Elements) != _Bitmask{};
+}
+
+template <class _Bitmask>
+_NODISCARD constexpr bool _Bitmask_includes_all(_Bitmask _Left, _Bitmask _Elements) noexcept {
+    return (_Left & _Elements) == _Elements;
+}
+
+// These FNV-1a utility functions are extremely performance sensitive,
+// check examples like that in VSO-653642 before making changes.
+#ifdef _WIN64
+_INLINE_VAR constexpr size_t _FNV_offset_basis = 14695981039346656037ULL;
+_INLINE_VAR constexpr size_t _FNV_prime        = 1099511628211ULL;
+#else // ^^^ 64-bit / 32-bit vvv
+_INLINE_VAR constexpr size_t _FNV_offset_basis = 2166136261U;
+_INLINE_VAR constexpr size_t _FNV_prime        = 16777619U;
+#endif // ^^^ 32-bit ^^^
+
+_NODISCARD inline size_t _Fnv1a_append_bytes(size_t _Val, const unsigned char* const _First,
+    const size_t _Count) noexcept { // accumulate range [_First, _First + _Count) into partial FNV-1a hash _Val
+    for (size_t _Idx = 0; _Idx < _Count; ++_Idx) {
+        _Val ^= static_cast<size_t>(_First[_Idx]);
+        _Val *= _FNV_prime;
+    }
+
+    return _Val;
+}
+
+template <class _Ty>
+_NODISCARD size_t _Fnv1a_append_range(const size_t _Val, const _Ty* const _First,
+    const _Ty* const _Last) noexcept { // accumulate range [_First, _Last) into partial FNV-1a hash _Val
+    static_assert(is_trivially_copyable_v<_Ty>, "Only trivially copyable types can be directly hashed.");
+    const auto _Firstb = reinterpret_cast<const unsigned char*>(_First);
+    const auto _Lastb  = reinterpret_cast<const unsigned char*>(_Last);
+    return _Fnv1a_append_bytes(_Val, _Firstb, static_cast<size_t>(_Lastb - _Firstb));
+}
+
+template <class _Kty>
+_NODISCARD size_t _Fnv1a_append_value(
+    const size_t _Val, const _Kty& _Keyval) noexcept { // accumulate _Keyval into partial FNV-1a hash _Val
+    static_assert(is_trivially_copyable_v<_Kty>, "Only trivially copyable types can be directly hashed.");
+    return _Fnv1a_append_bytes(_Val, &reinterpret_cast<const unsigned char&>(_Keyval), sizeof(_Kty));
+}
+
+template <class _Kty>
+_NODISCARD size_t _Hash_representation(const _Kty& _Keyval) noexcept { // bitwise hashes the representation of a key
+    return _Fnv1a_append_value(_FNV_offset_basis, _Keyval);
+}
+
+template <class _Kty>
+_NODISCARD size_t _Hash_array_representation(
+    const _Kty* const _First, const size_t _Count) noexcept { // bitwise hashes the representation of an array
+    static_assert(is_trivially_copyable_v<_Kty>, "Only trivially copyable types can be directly hashed.");
+    return _Fnv1a_append_bytes(
+        _FNV_offset_basis, reinterpret_cast<const unsigned char*>(_First), _Count * sizeof(_Kty));
+}
+
+_EXPORT_STD template <class _Kty>
+struct hash;
+
+template <class _Kty, bool _Enabled>
+struct _Conditionally_enabled_hash { // conditionally enabled hash base
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Kty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(const _Kty& _Keyval)
+        noexcept(noexcept(hash<_Kty>::_Do_hash(_Keyval))) /* strengthened */ {
+        return hash<_Kty>::_Do_hash(_Keyval);
+    }
+};
+
+template <class _Kty>
+struct _Conditionally_enabled_hash<_Kty, false> { // conditionally disabled hash base
+    _Conditionally_enabled_hash()                                              = delete;
+    _Conditionally_enabled_hash(const _Conditionally_enabled_hash&)            = delete;
+    _Conditionally_enabled_hash(_Conditionally_enabled_hash&&)                 = delete;
+    _Conditionally_enabled_hash& operator=(const _Conditionally_enabled_hash&) = delete;
+    _Conditionally_enabled_hash& operator=(_Conditionally_enabled_hash&&)      = delete;
+};
+
+_EXPORT_STD template <class _Kty>
+struct hash : _Conditionally_enabled_hash<_Kty, !is_const_v<_Kty> && !is_volatile_v<_Kty>
+                                                    && (is_enum_v<_Kty> || is_integral_v<_Kty> || is_pointer_v<_Kty>)> {
+    // hash functor primary template (handles enums, integrals, and pointers)
+    static size_t _Do_hash(const _Kty& _Keyval) noexcept {
+        return _Hash_representation(_Keyval);
+    }
+};
+
+template <>
+struct hash<float> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = float;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD static size_t operator()(const float _Keyval) noexcept {
+        return _Hash_representation(_Keyval == 0.0F ? 0.0F : _Keyval); // map -0 to 0
+    }
+};
+
+template <>
+struct hash<double> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = double;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD static size_t operator()(const double _Keyval) noexcept {
+        return _Hash_representation(_Keyval == 0.0 ? 0.0 : _Keyval); // map -0 to 0
+    }
+};
+
+template <>
+struct hash<long double> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = long double;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD static size_t operator()(const long double _Keyval) noexcept {
+        return _Hash_representation(_Keyval == 0.0L ? 0.0L : _Keyval); // map -0 to 0
+    }
+};
+
+template <>
+struct hash<nullptr_t> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = nullptr_t;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+    _NODISCARD static size_t operator()(nullptr_t) noexcept {
+        void* _Null{};
+        return _Hash_representation(_Null);
+    }
+};
+
+template <class _Kty, class = void>
+struct _Is_nothrow_hashable : false_type {}; // tests if std::hash can hash _Kty with noexcept
+
+template <class _Kty>
+struct _Is_nothrow_hashable<_Kty, void_t<decltype(hash<_Kty>{}(_STD declval<const _Kty&>()))>>
+    : bool_constant<noexcept(hash<_Kty>{}(_STD declval<const _Kty&>()))> {};
+
+_EXPORT_STD template <class _Ty = void>
+struct less {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left < _Right))) /* strengthened */ {
+        return _Left < _Right;
+    }
+};
+
+template <>
+struct less<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+// vvvvvvvvvv DERIVED FROM corecrt_internal_fltintrn.h vvvvvvvvvv
+
+template <class _FloatingType>
+struct _Floating_type_traits;
+
+template <>
+struct _Floating_type_traits<float> {
+    static constexpr int32_t _Mantissa_bits           = 24; // FLT_MANT_DIG
+    static constexpr int32_t _Exponent_bits           = 8; // sizeof(float) * CHAR_BIT - FLT_MANT_DIG
+    static constexpr int32_t _Maximum_binary_exponent = 127; // FLT_MAX_EXP - 1
+    static constexpr int32_t _Minimum_binary_exponent = -126; // FLT_MIN_EXP - 1
+    static constexpr int32_t _Exponent_bias           = 127;
+    static constexpr int32_t _Sign_shift              = 31; // _Exponent_bits + _Mantissa_bits - 1
+    static constexpr int32_t _Exponent_shift          = 23; // _Mantissa_bits - 1
+
+    using _Uint_type = uint32_t;
+
+    static constexpr uint32_t _Exponent_mask             = 0x000000FFu; // (1u << _Exponent_bits) - 1
+    static constexpr uint32_t _Normal_mantissa_mask      = 0x00FFFFFFu; // (1u << _Mantissa_bits) - 1
+    static constexpr uint32_t _Denormal_mantissa_mask    = 0x007FFFFFu; // (1u << (_Mantissa_bits - 1)) - 1
+    static constexpr uint32_t _Special_nan_mantissa_mask = 0x00400000u; // 1u << (_Mantissa_bits - 2)
+    static constexpr uint32_t _Shifted_sign_mask         = 0x80000000u; // 1u << _Sign_shift
+    static constexpr uint32_t _Shifted_exponent_mask     = 0x7F800000u; // _Exponent_mask << _Exponent_shift
+
+    static constexpr float _Minimum_value = 0x1.000000p-126f; // FLT_MIN
+    static constexpr float _Maximum_value = 0x1.FFFFFEp+127f; // FLT_MAX
+};
+
+template <>
+struct _Floating_type_traits<double> {
+    static constexpr int32_t _Mantissa_bits           = 53; // DBL_MANT_DIG
+    static constexpr int32_t _Exponent_bits           = 11; // sizeof(double) * CHAR_BIT - DBL_MANT_DIG
+    static constexpr int32_t _Maximum_binary_exponent = 1023; // DBL_MAX_EXP - 1
+    static constexpr int32_t _Minimum_binary_exponent = -1022; // DBL_MIN_EXP - 1
+    static constexpr int32_t _Exponent_bias           = 1023;
+    static constexpr int32_t _Sign_shift              = 63; // _Exponent_bits + _Mantissa_bits - 1
+    static constexpr int32_t _Exponent_shift          = 52; // _Mantissa_bits - 1
+
+    using _Uint_type = uint64_t;
+
+    static constexpr uint64_t _Exponent_mask             = 0x00000000000007FFu; // (1ULL << _Exponent_bits) - 1
+    static constexpr uint64_t _Normal_mantissa_mask      = 0x001FFFFFFFFFFFFFu; // (1ULL << _Mantissa_bits) - 1
+    static constexpr uint64_t _Denormal_mantissa_mask    = 0x000FFFFFFFFFFFFFu; // (1ULL << (_Mantissa_bits - 1)) - 1
+    static constexpr uint64_t _Special_nan_mantissa_mask = 0x0008000000000000u; // 1ULL << (_Mantissa_bits - 2)
+    static constexpr uint64_t _Shifted_sign_mask         = 0x8000000000000000u; // 1ULL << _Sign_shift
+    static constexpr uint64_t _Shifted_exponent_mask     = 0x7FF0000000000000u; // _Exponent_mask << _Exponent_shift
+
+    static constexpr double _Minimum_value = 0x1.0000000000000p-1022; // DBL_MIN
+    static constexpr double _Maximum_value = 0x1.FFFFFFFFFFFFFp+1023; // DBL_MAX
+};
+
+template <>
+struct _Floating_type_traits<long double> : _Floating_type_traits<double> {};
+
+// ^^^^^^^^^^ DERIVED FROM corecrt_internal_fltintrn.h ^^^^^^^^^^
+
+template <class _To, class _From,
+    enable_if_t<conjunction_v<bool_constant<sizeof(_To) == sizeof(_From)>, is_trivially_copyable<_To>,
+                    is_trivially_copyable<_From>>,
+        int> = 0>
+_NODISCARD constexpr _To _Bit_cast(const _From& _Val) noexcept {
+    return __builtin_bit_cast(_To, _Val);
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr auto _Float_abs_bits(const _Ty& _Xx) noexcept {
+    using _Traits    = _Floating_type_traits<_Ty>;
+    using _Uint_type = typename _Traits::_Uint_type;
+    const auto _Bits = _Bit_cast<_Uint_type>(_Xx);
+    return _Bits & ~_Traits::_Shifted_sign_mask;
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr _Ty _Float_abs(const _Ty _Xx) noexcept { // constexpr floating-point abs()
+    return _Bit_cast<_Ty>(_Float_abs_bits(_Xx));
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr bool _Is_nan(const _Ty _Xx) noexcept { // constexpr isnan()
+    using _Traits = _Floating_type_traits<_Ty>;
+    return _Float_abs_bits(_Xx) > _Traits::_Shifted_exponent_mask;
+}
+
+template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
+_NODISCARD constexpr bool _Is_finite(const _Ty _Xx) noexcept { // constexpr isfinite()
+    using _Traits = _Floating_type_traits<_Ty>;
+    return _Float_abs_bits(_Xx) < _Traits::_Shifted_exponent_mask;
+}
+
+template <bool _IsConst, class _Ty>
+using _Maybe_const = conditional_t<_IsConst, const _Ty, _Ty>;
+
+template <class _Ty, size_t _Size>
+void _Swap_trivial_arrays(_Ty (&_Left)[_Size], _Ty (&_Right)[_Size]) noexcept {
+    // Swap arrays using temporary buffers of 64 bytes, followed by the tail.
+    // In optimized builds, the stack usage optimizes away, and vector registers are used.
+    // The 64-byte size has desirable properties:
+    // * Big enough to engage AVX-512.
+    // * Small enough to be handled by SSE2 (using eight registers).
+    // * Avoids excessive stack consumption for non-optimized builds.
+    auto _Left_ptr  = reinterpret_cast<unsigned char*>(&_Left);
+    auto _Right_ptr = reinterpret_cast<unsigned char*>(&_Right);
+
+    constexpr size_t _Part_size_bytes = 64;
+    constexpr size_t _Size_bytes      = _Size * sizeof(_Ty);
+    constexpr size_t _Size_tail       = _Size_bytes % _Part_size_bytes;
+    constexpr size_t _Size_parts      = _Size_bytes - _Size_tail;
+
+    if constexpr (_Size_parts != 0) {
+        const auto _Stop = _Left_ptr + _Size_parts;
+        do {
+            struct _Buffer_type {
+                unsigned char _Data[_Part_size_bytes];
+            };
+
+            _STL_INTERNAL_STATIC_ASSERT(sizeof(_Buffer_type) == _Part_size_bytes); // assume no padding
+
+            const _Buffer_type _Buffer                   = *reinterpret_cast<const _Buffer_type*>(_Left_ptr);
+            *reinterpret_cast<_Buffer_type*>(_Left_ptr)  = *reinterpret_cast<const _Buffer_type*>(_Right_ptr);
+            *reinterpret_cast<_Buffer_type*>(_Right_ptr) = _Buffer;
+            _Left_ptr += _Part_size_bytes;
+            _Right_ptr += _Part_size_bytes;
+        } while (_Left_ptr != _Stop);
+    }
+
+    if constexpr (_Size_tail != 0) {
+        struct _Last_buffer_type {
+            unsigned char _Data[_Size_tail];
+        };
+
+        _STL_INTERNAL_STATIC_ASSERT(sizeof(_Last_buffer_type) == _Size_tail); // assume no padding
+
+        const _Last_buffer_type _Last_buffer              = *reinterpret_cast<const _Last_buffer_type*>(_Left_ptr);
+        *reinterpret_cast<_Last_buffer_type*>(_Left_ptr)  = *reinterpret_cast<const _Last_buffer_type*>(_Right_ptr);
+        *reinterpret_cast<_Last_buffer_type*>(_Right_ptr) = _Last_buffer;
+    }
+}
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("known_semantics")
+#pragma pop_macro("intrinsic")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _TYPE_TRAITS_
diff --git a/msvc-stl/stl/inc/typeindex b/msvc-stl/stl/inc/typeindex
new file mode 100644
index 0000000..053a15f
--- /dev/null
+++ b/msvc-stl/stl/inc/typeindex
@@ -0,0 +1,95 @@
+// typeindex standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _TYPEINDEX_
+#define _TYPEINDEX_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <typeinfo>
+
+#if _HAS_CXX20
+#include <compare>
+#include <cstring>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD class type_index { // wraps a typeinfo for indexing
+public:
+    type_index(const type_info& _Tinfo) noexcept : _Tptr(&_Tinfo) {}
+
+    _NODISCARD size_t hash_code() const noexcept {
+        return _Tptr->hash_code();
+    }
+
+    _NODISCARD const char* name() const noexcept {
+        return _Tptr->name();
+    }
+
+    _NODISCARD bool operator==(const type_index& _Right) const noexcept {
+        return *_Tptr == *_Right._Tptr;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD strong_ordering operator<=>(const type_index& _Right) const noexcept {
+        // TRANSITION, DevCom-10326599, should rely on a stable interface
+        if (_Tptr == _Right._Tptr) {
+            return strong_ordering::equal;
+        }
+
+#pragma push_macro("raw_name") // TRANSITION, GH-2195
+#undef raw_name
+        return _CSTD strcmp(_Tptr->raw_name() + 1, _Right._Tptr->raw_name() + 1) <=> 0;
+#pragma pop_macro("raw_name")
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const type_index& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD bool operator<(const type_index& _Right) const noexcept {
+        return _Tptr->before(*_Right._Tptr);
+    }
+
+    _NODISCARD bool operator>=(const type_index& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+
+    _NODISCARD bool operator>(const type_index& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const type_index& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+private:
+    const type_info* _Tptr;
+};
+
+template <>
+struct hash<type_index> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = type_index;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(const type_index& _Keyval) noexcept {
+        return _Keyval.hash_code();
+    }
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _TYPEINDEX_
diff --git a/msvc-stl/stl/inc/typeinfo b/msvc-stl/stl/inc/typeinfo
new file mode 100644
index 0000000..35e1304
--- /dev/null
+++ b/msvc-stl/stl/inc/typeinfo
@@ -0,0 +1,73 @@
+// typeinfo standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _TYPEINFO_
+#define _TYPEINFO_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <exception>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#pragma warning(disable : 4275) // non dll-interface class 'X' used as base for dll-interface class 'Y'
+
+#pragma push_macro("raw_name") // TRANSITION, GH-2195
+#undef raw_name
+#include <vcruntime_typeinfo.h>
+#pragma pop_macro("raw_name")
+
+_STD_BEGIN
+
+// size in pointers of std::function and std::any (roughly 3 pointers larger than std::string when building debug)
+_INLINE_VAR constexpr int _Small_object_num_ptrs = 6 + 16 / sizeof(void*);
+
+#if !_HAS_EXCEPTIONS
+_EXPORT_STD class _NODISCARD bad_cast : public exception { // base of all bad cast exceptions
+public:
+    bad_cast(const char* _Message = "bad cast") noexcept : exception(_Message) {}
+
+    ~bad_cast() noexcept override {}
+
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+};
+
+_EXPORT_STD class _NODISCARD bad_typeid : public exception { // base of all bad typeid exceptions
+public:
+    bad_typeid(const char* _Message = "bad typeid") noexcept : exception(_Message) {}
+
+    ~bad_typeid() noexcept override {}
+
+protected:
+    void _Doraise() const override { // perform class-specific exception handling
+        _RAISE(*this);
+    }
+};
+
+class _NODISCARD __non_rtti_object : public bad_typeid { // report a non-RTTI object
+public:
+    __non_rtti_object(const char* _Message) : bad_typeid(_Message) {}
+};
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+
+[[noreturn]] inline void _Throw_bad_cast() {
+    _THROW(bad_cast{});
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma pack(pop)
+#pragma warning(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _TYPEINFO_
diff --git a/msvc-stl/stl/inc/unordered_map b/msvc-stl/stl/inc/unordered_map
new file mode 100644
index 0000000..3bc3850
--- /dev/null
+++ b/msvc-stl/stl/inc/unordered_map
@@ -0,0 +1,932 @@
+// unordered_map standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _UNORDERED_MAP_
+#define _UNORDERED_MAP_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xhash>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Kty, // key type
+    class _Ty, // mapped type
+    class _Tr, // comparator predicate type
+    class _Alloc, // actual allocator type (should be value allocator)
+    bool _Mfl> // true if multiple equivalent keys are permitted
+class _Umap_traits : public _Tr { // traits required to make _Hash behave like a map
+public:
+    using key_type            = _Kty;
+    using value_type          = pair<const _Kty, _Ty>;
+    using _Mutable_value_type = pair<_Kty, _Ty>;
+    using key_compare         = _Tr;
+    using allocator_type      = _Alloc;
+#if _HAS_CXX17
+    using node_type = _Node_handle<_List_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
+        _Node_handle_map_base, _Kty, _Ty>;
+#endif // _HAS_CXX17
+
+    static constexpr bool _Multi = _Mfl;
+
+    template <class... _Args>
+    using _In_place_key_extractor = _In_place_key_extract_map<_Kty, _Args...>;
+
+    _Umap_traits() = default;
+
+    explicit _Umap_traits(const _Tr& _Traits) noexcept(is_nothrow_copy_constructible_v<_Tr>) : _Tr(_Traits) {}
+
+    template <class _Ty1, class _Ty2>
+    static const _Kty& _Kfn(const pair<_Ty1, _Ty2>& _Val) noexcept { // extract key from element value
+        return _Val.first;
+    }
+};
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<pair<const _Kty, _Ty>>>
+class unordered_map : public _Hash<_Umap_traits<_Kty, _Ty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false>> {
+    // hash table of {key, mapped} values, unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("unordered_map<Key, Value, Hasher, Eq, Allocator>", "pair<const Key, Value>"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+private:
+    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
+    using _Mybase        = _Hash<_Umap_traits<_Kty, _Ty, _Mytraits, _Alloc, false>>;
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+    using _Nodeptr       = typename _Mybase::_Nodeptr;
+    using _Key_compare   = typename _Mybase::_Key_compare;
+
+public:
+    using hasher      = _Hasher;
+    using key_type    = _Kty;
+    using mapped_type = _Ty;
+    using key_equal   = _Keyeq;
+
+    using value_type      = pair<const _Kty, _Ty>;
+    using allocator_type  = typename _Mybase::allocator_type;
+    using size_type       = typename _Mybase::size_type;
+    using difference_type = typename _Mybase::difference_type;
+    using pointer         = typename _Mybase::pointer;
+    using const_pointer   = typename _Mybase::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using iterator        = typename _Mybase::iterator;
+    using const_iterator  = typename _Mybase::const_iterator;
+
+    using local_iterator       = typename _Mybase::iterator;
+    using const_local_iterator = typename _Mybase::const_iterator;
+
+#if _HAS_CXX17
+    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
+#endif // _HAS_CXX17
+
+    unordered_map() : _Mybase(_Key_compare(), allocator_type()) {}
+
+    explicit unordered_map(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}
+
+    unordered_map(const unordered_map& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    unordered_map(const unordered_map& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit unordered_map(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_map(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_map(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    unordered_map& operator=(const unordered_map& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    unordered_map(unordered_map&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    unordered_map(unordered_map&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    unordered_map& operator=(unordered_map&& _Right)
+        noexcept(_Alnode_traits::is_always_equal::value
+                 && is_nothrow_move_assignable_v<_Hasher> && is_nothrow_move_assignable_v<_Keyeq>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    mapped_type& operator[](key_type&& _Keyval) {
+        return this->_Try_emplace(_STD move(_Keyval)).first->_Myval.second;
+    }
+
+    void swap(unordered_map& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    using _Mybase::insert;
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    pair<iterator, bool> insert(_Valty&& _Val) {
+        return this->emplace(_STD forward<_Valty>(_Val));
+    }
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(const_iterator _Where, _Valty&& _Val) {
+        return this->emplace_hint(_Where, _STD forward<_Valty>(_Val));
+    }
+
+    template <class... _Mappedty>
+    pair<iterator, bool> try_emplace(const key_type& _Keyval, _Mappedty&&... _Mapval) {
+        const auto _Result = this->_Try_emplace(_Keyval, _STD forward<_Mappedty>(_Mapval)...);
+        return {this->_List._Make_iter(_Result.first), _Result.second};
+    }
+
+    template <class... _Mappedty>
+    pair<iterator, bool> try_emplace(key_type&& _Keyval, _Mappedty&&... _Mapval) {
+        const auto _Result = this->_Try_emplace(_STD move(_Keyval), _STD forward<_Mappedty>(_Mapval)...);
+        return {this->_List._Make_iter(_Result.first), _Result.second};
+    }
+
+    template <class... _Mappedty>
+    iterator try_emplace(const const_iterator _Hint, const key_type& _Keyval, _Mappedty&&... _Mapval) {
+        return this->_List._Make_iter(
+            this->_Try_emplace_hint(_Hint._Ptr, _Keyval, _STD forward<_Mappedty>(_Mapval)...));
+    }
+
+    template <class... _Mappedty>
+    iterator try_emplace(const const_iterator _Hint, key_type&& _Keyval, _Mappedty&&... _Mapval) {
+        return this->_List._Make_iter(
+            this->_Try_emplace_hint(_Hint._Ptr, _STD move(_Keyval), _STD forward<_Mappedty>(_Mapval)...));
+    }
+
+private:
+    template <class _Keyty, class _Mappedty>
+    pair<iterator, bool> _Insert_or_assign(_Keyty&& _Keyval_arg, _Mappedty&& _Mapval) {
+        const auto& _Keyval   = _Keyval_arg;
+        const size_t _Hashval = this->_Traitsobj(_Keyval);
+        auto _Target          = this->_Find_last(_Keyval, _Hashval);
+        if (_Target._Duplicate) {
+            _Target._Duplicate->_Myval.second = _STD forward<_Mappedty>(_Mapval);
+            return {this->_List._Make_iter(_Target._Duplicate), false};
+        }
+
+        this->_Check_max_size();
+        // invalidates _Keyval:
+        _List_node_emplace_op2<_Alnode> _Newnode(
+            this->_Getal(), _STD forward<_Keyty>(_Keyval_arg), _STD forward<_Mappedty>(_Mapval));
+        if (this->_Check_rehash_required_1()) {
+            this->_Rehash_for_1();
+            _Target = this->_Find_last(_Newnode._Ptr->_Myval.first, _Hashval);
+        }
+
+        return {this->_List._Make_iter(
+                    this->_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())),
+            true};
+    }
+
+    template <class _Keyty, class _Mappedty>
+    iterator _Insert_or_assign(const _Nodeptr _Hint, _Keyty&& _Keyval_arg, _Mappedty&& _Mapval) {
+        const auto& _Keyval   = _Keyval_arg;
+        const size_t _Hashval = this->_Traitsobj(_Keyval);
+        auto _Target          = this->_Find_hint(_Hint, _Keyval, _Hashval);
+        if (_Target._Duplicate) {
+            _Target._Duplicate->_Myval.second = _STD forward<_Mappedty>(_Mapval);
+            return this->_List._Make_iter(_Target._Duplicate);
+        }
+
+        this->_Check_max_size();
+        // invalidates _Keyval:
+        _List_node_emplace_op2<_Alnode> _Newnode(
+            this->_Getal(), _STD forward<_Keyty>(_Keyval_arg), _STD forward<_Mappedty>(_Mapval));
+        if (this->_Check_rehash_required_1()) {
+            this->_Rehash_for_1();
+            _Target = this->_Find_hint(_Hint, _Newnode._Ptr->_Myval.first, _Hashval);
+        }
+
+        return this->_List._Make_iter(
+            this->_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+    }
+
+public:
+    template <class _Mappedty>
+    pair<iterator, bool> insert_or_assign(const key_type& _Keyval, _Mappedty&& _Mapval) {
+        return _Insert_or_assign(_Keyval, _STD forward<_Mappedty>(_Mapval));
+    }
+
+    template <class _Mappedty>
+    pair<iterator, bool> insert_or_assign(key_type&& _Keyval, _Mappedty&& _Mapval) {
+        return _Insert_or_assign(_STD move(_Keyval), _STD forward<_Mappedty>(_Mapval));
+    }
+
+    template <class _Mappedty>
+    iterator insert_or_assign(const_iterator _Hint, const key_type& _Keyval, _Mappedty&& _Mapval) {
+        return _Insert_or_assign(_Hint._Ptr, _Keyval, _STD forward<_Mappedty>(_Mapval));
+    }
+
+    template <class _Mappedty>
+    iterator insert_or_assign(const_iterator _Hint, key_type&& _Keyval, _Mappedty&& _Mapval) {
+        return _Insert_or_assign(_Hint._Ptr, _STD move(_Keyval), _STD forward<_Mappedty>(_Mapval));
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
+        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_map& operator=(initializer_list<value_type> _Ilist) {
+        _Mybase::clear();
+        insert(_Ilist);
+        return *this;
+    }
+
+    _NODISCARD hasher hash_function() const {
+        return _Mybase::_Traitsobj._Mypair._Get_first();
+    }
+
+    _NODISCARD key_equal key_eq() const {
+        return _Mybase::_Traitsobj._Mypair._Myval2._Get_first();
+    }
+
+    mapped_type& operator[](const key_type& _Keyval) {
+        return this->_Try_emplace(_Keyval).first->_Myval.second;
+    }
+
+    _NODISCARD mapped_type& at(const key_type& _Keyval) {
+        const auto _Target = this->_Find_last(_Keyval, this->_Traitsobj(_Keyval));
+        if (_Target._Duplicate) {
+            return _Target._Duplicate->_Myval.second;
+        }
+
+        _Xout_of_range("invalid unordered_map<K, T> key");
+    }
+
+    _NODISCARD const mapped_type& at(const key_type& _Keyval) const {
+        const auto _Target = this->_Find_last(_Keyval, this->_Traitsobj(_Keyval));
+        if (_Target._Duplicate) {
+            return _Target._Duplicate->_Myval.second;
+        }
+
+        _Xout_of_range("invalid unordered_map<K, T> key");
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Hasher = hash<_Guide_key_t<_Iter>>, class _Keyeq = equal_to<_Guide_key_t<_Iter>>,
+    class _Alloc = allocator<_Guide_pair_t<_Iter>>,
+    enable_if_t<
+        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
+        int> = 0>
+unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(), _Alloc = _Alloc())
+    -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<pair<const _Kty, _Ty>>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(_Iter, _Iter, _Alloc) -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>,
+    hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_map<_Guide_key_t<_Iter>,
+    _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_map(initializer_list<pair<_Kty, _Ty>>, _Alloc)
+    -> unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_map<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_Range_key_type<_Rng>>,
+    _Not_allocator_for_container _Keyeq = equal_to<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Alloc     = allocator<_Range_to_alloc_type<_Rng>>>
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_map<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_map(from_range_t, _Rng&&, _Alloc) -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher, _Allocator_for_container _Alloc>
+unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+void swap(unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
+    unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator==(const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return _Hash_equal(_Left, _Right);
+}
+
+#if !_HAS_CXX20
+template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator!=(const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<pair<const _Kty, _Ty>>>
+class unordered_multimap : public _Hash<_Umap_traits<_Kty, _Ty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true>> {
+    // hash table of {key, mapped} values, non-unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE(
+            "unordered_multimap<Key, Value, Hasher, Eq, Allocator>", "pair<const Key, Value>"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+private:
+    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
+    using _Mybase        = _Hash<_Umap_traits<_Kty, _Ty, _Mytraits, _Alloc, true>>;
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+    using _Key_compare   = typename _Mybase::_Key_compare;
+
+public:
+    using hasher      = _Hasher;
+    using key_type    = _Kty;
+    using mapped_type = _Ty;
+    using key_equal   = _Keyeq;
+
+    using value_type      = pair<const _Kty, _Ty>;
+    using allocator_type  = typename _Mybase::allocator_type;
+    using size_type       = typename _Mybase::size_type;
+    using difference_type = typename _Mybase::difference_type;
+    using pointer         = typename _Mybase::pointer;
+    using const_pointer   = typename _Mybase::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using iterator        = typename _Mybase::iterator;
+    using const_iterator  = typename _Mybase::const_iterator;
+
+    using local_iterator       = typename _Mybase::iterator;
+    using const_local_iterator = typename _Mybase::const_iterator;
+
+    unordered_multimap() : _Mybase(_Key_compare(), allocator_type()) {} // construct empty map from defaults
+
+    explicit unordered_multimap(const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {} // construct empty map from defaults, allocator
+
+    unordered_multimap(const unordered_multimap& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    unordered_multimap(const unordered_multimap& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit unordered_multimap(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(
+        from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multimap(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    unordered_multimap& operator=(const unordered_multimap& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    unordered_multimap(unordered_multimap&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    unordered_multimap(unordered_multimap&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    unordered_multimap& operator=(unordered_multimap&& _Right)
+        noexcept(_Alnode_traits::is_always_equal::value
+                 && is_nothrow_move_assignable_v<_Hasher> && is_nothrow_move_assignable_v<_Keyeq>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    void swap(unordered_multimap& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    using _Mybase::insert;
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(_Valty&& _Val) {
+        return this->emplace(_STD forward<_Valty>(_Val));
+    }
+
+    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
+    iterator insert(const_iterator _Where, _Valty&& _Val) {
+        return this->emplace_hint(_Where, _STD forward<_Valty>(_Val));
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets)
+        : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
+        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        insert(_Ilist);
+    }
+
+    unordered_multimap& operator=(initializer_list<value_type> _Ilist) {
+        _Mybase::clear();
+        insert(_Ilist);
+        return *this;
+    }
+
+    _NODISCARD hasher hash_function() const {
+        return _Mybase::_Traitsobj._Mypair._Get_first();
+    }
+
+    _NODISCARD key_equal key_eq() const {
+        return _Mybase::_Traitsobj._Mypair._Myval2._Get_first();
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Hasher = hash<_Guide_key_t<_Iter>>, class _Keyeq = equal_to<_Guide_key_t<_Iter>>,
+    class _Alloc = allocator<_Guide_pair_t<_Iter>>,
+    enable_if_t<
+        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
+        int> = 0>
+unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<pair<const _Kty, _Ty>>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(),
+    _Keyeq = _Keyeq(), _Alloc = _Alloc()) -> unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(_Iter, _Iter, _Alloc) -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>,
+    hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_multimap<_Guide_key_t<_Iter>,
+    _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Alloc)
+    -> unordered_multimap<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multimap<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Ty, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multimap<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_Range_key_type<_Rng>>,
+    _Not_allocator_for_container _Keyeq = equal_to<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Alloc     = allocator<_Range_to_alloc_type<_Rng>>>
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, hash<_Range_key_type<_Rng>>,
+        equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_multimap(from_range_t, _Rng&&, _Alloc) -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    hash<_Range_key_type<_Rng>>, equal_to<_Range_key_type<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher, _Allocator_for_container _Alloc>
+unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, equal_to<_Range_key_type<_Rng>>,
+        _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+void swap(unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
+    unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator==(const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return _Hash_equal(_Left, _Right);
+}
+
+#if !_HAS_CXX20
+template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator!=(const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    using unordered_map = _STD unordered_map<_Kty, _Ty, _Hasher, _Keyeq, polymorphic_allocator<pair<const _Kty, _Ty>>>;
+
+    _EXPORT_STD template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    using unordered_multimap =
+        _STD unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, polymorphic_allocator<pair<const _Kty, _Ty>>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _UNORDERED_MAP_
diff --git a/msvc-stl/stl/inc/unordered_set b/msvc-stl/stl/inc/unordered_set
new file mode 100644
index 0000000..89c33f9
--- /dev/null
+++ b/msvc-stl/stl/inc/unordered_set
@@ -0,0 +1,759 @@
+// unordered_set standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _UNORDERED_SET_
+#define _UNORDERED_SET_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xhash>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Kty, // key type (same as value type)
+    class _Tr, // comparator predicate type
+    class _Alloc, // actual allocator type (should be value allocator)
+    bool _Mfl> // true if multiple equivalent keys are permitted
+class _Uset_traits : public _Tr { // traits required to make _Hash behave like a set
+public:
+    using key_type            = _Kty;
+    using value_type          = _Kty;
+    using _Mutable_value_type = _Kty;
+    using key_compare         = _Tr;
+    using allocator_type      = _Alloc;
+#if _HAS_CXX17
+    using node_type = _Node_handle<_List_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
+        _Node_handle_set_base, _Kty>;
+#endif // _HAS_CXX17
+
+    static constexpr bool _Multi = _Mfl;
+
+    template <class... _Args>
+    using _In_place_key_extractor = _In_place_key_extract_set<_Kty, _Args...>;
+
+    _Uset_traits() = default;
+
+    explicit _Uset_traits(const _Tr& _Traits) noexcept(is_nothrow_copy_constructible_v<_Tr>) : _Tr(_Traits) {}
+
+    static const _Kty& _Kfn(const value_type& _Val) noexcept {
+        return _Val;
+    }
+};
+
+_EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<_Kty>>
+class unordered_set : public _Hash<_Uset_traits<_Kty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false>> {
+    // hash table of key-values, unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Kty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("unordered_set<T, Hasher, Eq, Allocator>", "T"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+private:
+    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
+    using _Mybase        = _Hash<_Uset_traits<_Kty, _Mytraits, _Alloc, false>>;
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+    using _Key_compare   = typename _Mybase::_Key_compare;
+
+public:
+    using hasher    = _Hasher;
+    using key_type  = _Kty;
+    using key_equal = _Keyeq;
+
+    using value_type      = typename _Mybase::value_type;
+    using allocator_type  = typename _Mybase::allocator_type;
+    using size_type       = typename _Mybase::size_type;
+    using difference_type = typename _Mybase::difference_type;
+    using pointer         = typename _Mybase::pointer;
+    using const_pointer   = typename _Mybase::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using iterator        = typename _Mybase::iterator;
+    using const_iterator  = typename _Mybase::const_iterator;
+
+    using local_iterator       = typename _Mybase::iterator;
+    using const_local_iterator = typename _Mybase::const_iterator;
+
+#if _HAS_CXX17
+    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
+#endif // _HAS_CXX17
+
+    unordered_set() : _Mybase(_Key_compare(), allocator_type()) {}
+
+    explicit unordered_set(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}
+
+    unordered_set(const unordered_set& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    unordered_set(const unordered_set& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit unordered_set(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_set(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_set(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    unordered_set& operator=(const unordered_set& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    unordered_set(unordered_set&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    unordered_set(unordered_set&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+    unordered_set& operator=(unordered_set&& _Right)
+        noexcept(_Alnode_traits::is_always_equal::value
+                 && is_nothrow_move_assignable_v<_Hasher> && is_nothrow_move_assignable_v<_Keyeq>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    void swap(unordered_set& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
+        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_set& operator=(initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist);
+        return *this;
+    }
+
+    _NODISCARD hasher hash_function() const {
+        return this->_Traitsobj._Mypair._Get_first();
+    }
+
+    _NODISCARD key_equal key_eq() const {
+        return this->_Traitsobj._Mypair._Myval2._Get_first();
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Hasher = hash<_Iter_value_t<_Iter>>, class _Keyeq = equal_to<_Iter_value_t<_Iter>>,
+    class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<
+        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
+        int> = 0>
+unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(), _Alloc = _Alloc())
+    -> unordered_set<_Iter_value_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_set<_Iter_value_t<_Iter>, hash<_Iter_value_t<_Iter>>, equal_to<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_set<_Iter_value_t<_Iter>, _Hasher, equal_to<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_set<_Kty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_set<_Kty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_RANGES range_value_t<_Rng>>,
+    _Not_allocator_for_container _Keyeq = equal_to<_RANGES range_value_t<_Rng>>,
+    _Allocator_for_container _Alloc     = allocator<_RANGES range_value_t<_Rng>>>
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_set<_RANGES range_value_t<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_set<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_set(from_range_t, _Rng&&, _Alloc) -> unordered_set<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher, _Allocator_for_container _Alloc>
+unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_set<_RANGES range_value_t<_Rng>, _Hasher, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+void swap(unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left, unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right)
+    noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
+    unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator==(const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return _Hash_equal(_Left, _Right);
+}
+
+#if !_HAS_CXX20
+template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator!=(const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
+    class _Alloc = allocator<_Kty>>
+class unordered_multiset : public _Hash<_Uset_traits<_Kty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true>> {
+    // hash table of key-values, non-unique keys
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Kty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("unordered_multiset<T, Hasher, Eq, Allocator>", "T"));
+    static_assert(is_object_v<_Kty>, "The C++ Standard forbids containers of non-object types "
+                                     "because of [container.requirements].");
+
+private:
+    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
+    using _Mybase        = _Hash<_Uset_traits<_Kty, _Mytraits, _Alloc, true>>;
+    using _Alnode        = typename _Mybase::_Alnode;
+    using _Alnode_traits = typename _Mybase::_Alnode_traits;
+    using _Key_compare   = typename _Mybase::_Key_compare;
+
+public:
+    using hasher    = _Hasher;
+    using key_type  = _Kty;
+    using key_equal = _Keyeq;
+
+    using value_type      = typename _Mybase::value_type;
+    using allocator_type  = typename _Mybase::allocator_type;
+    using size_type       = typename _Mybase::size_type;
+    using difference_type = typename _Mybase::difference_type;
+    using pointer         = typename _Mybase::pointer;
+    using const_pointer   = typename _Mybase::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+    using iterator        = typename _Mybase::iterator;
+    using const_iterator  = typename _Mybase::const_iterator;
+
+    unordered_multiset() : _Mybase(_Key_compare(), allocator_type()) {}
+
+    explicit unordered_multiset(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}
+
+    unordered_multiset(const unordered_multiset& _Right)
+        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}
+
+    unordered_multiset(const unordered_multiset& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}
+
+    explicit unordered_multiset(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+    }
+
+    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    template <class _Iter>
+    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_First, _Last);
+    }
+
+    unordered_multiset& operator=(const unordered_multiset& _Right) {
+        _Mybase::operator=(_Right);
+        return *this;
+    }
+
+    unordered_multiset(unordered_multiset&& _Right) : _Mybase(_STD move(_Right)) {}
+
+    unordered_multiset(unordered_multiset&& _Right, const allocator_type& _Al) : _Mybase(_STD move(_Right), _Al) {}
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range) : _Mybase(_Key_compare(), allocator_type()) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(
+        from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    unordered_multiset(from_range_t, _Rng&& _Range, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
+        const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        _Mybase::rehash(_Buckets);
+        this->_Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    unordered_multiset& operator=(unordered_multiset&& _Right)
+        noexcept(_Alnode_traits::is_always_equal::value
+                 && is_nothrow_move_assignable_v<_Hasher> && is_nothrow_move_assignable_v<_Keyeq>) {
+        _Mybase::operator=(_STD move(_Right));
+        return *this;
+    }
+
+    void swap(unordered_multiset& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
+        _Mybase::swap(_Right);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets)
+        : _Mybase(_Key_compare(), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
+        : _Mybase(_Key_compare(), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
+        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(
+        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
+        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
+        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
+        this->rehash(_Buckets);
+        this->insert(_Ilist);
+    }
+
+    unordered_multiset& operator=(initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist);
+        return *this;
+    }
+
+    _NODISCARD hasher hash_function() const {
+        return this->_Traitsobj._Mypair._Get_first();
+    }
+
+    _NODISCARD key_equal key_eq() const {
+        return this->_Traitsobj._Mypair._Myval2._Get_first();
+    }
+
+    using _Mybase::_Unchecked_begin;
+    using _Mybase::_Unchecked_end;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Hasher = hash<_Iter_value_t<_Iter>>, class _Keyeq = equal_to<_Iter_value_t<_Iter>>,
+    class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<
+        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
+        int> = 0>
+unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multiset<_Iter_value_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>;
+
+template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multiset<_Iter_value_t<_Iter>, hash<_Iter_value_t<_Iter>>, equal_to<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Iter, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multiset<_Iter_value_t<_Iter>, _Hasher, equal_to<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multiset<_Kty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
+
+template <class _Kty, class _Hasher, class _Alloc,
+    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
+unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multiset<_Kty, _Hasher, equal_to<_Kty>, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_RANGES range_value_t<_Rng>>,
+    _Not_allocator_for_container _Keyeq = equal_to<_RANGES range_value_t<_Rng>>,
+    _Allocator_for_container _Alloc     = allocator<_RANGES range_value_t<_Rng>>>
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
+    _Alloc = _Alloc()) -> unordered_multiset<_RANGES range_value_t<_Rng>, _Hasher, _Keyeq, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Alloc)
+    -> unordered_multiset<_RANGES range_value_t<_Rng>, hash<_RANGES range_value_t<_Rng>>,
+        equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
+unordered_multiset(from_range_t, _Rng&&, _Alloc) -> unordered_multiset<_RANGES range_value_t<_Rng>,
+    hash<_RANGES range_value_t<_Rng>>, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+
+template <_RANGES input_range _Rng, _Hasher_for_container _Hasher, _Allocator_for_container _Alloc>
+unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
+    -> unordered_multiset<_RANGES range_value_t<_Rng>, _Hasher, equal_to<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+void swap(unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
+unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
+    unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_nodes_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator==(const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return _Hash_equal(_Left, _Right);
+}
+
+#if !_HAS_CXX20
+template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
+_NODISCARD bool operator!=(const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
+    const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    using unordered_set = _STD unordered_set<_Kty, _Hasher, _Keyeq, polymorphic_allocator<_Kty>>;
+
+    _EXPORT_STD template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
+    using unordered_multiset = _STD unordered_multiset<_Kty, _Hasher, _Keyeq, polymorphic_allocator<_Kty>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _UNORDERED_SET_
diff --git a/msvc-stl/stl/inc/use_ansi.h b/msvc-stl/stl/inc/use_ansi.h
new file mode 100644
index 0000000..d08a6b6
--- /dev/null
+++ b/msvc-stl/stl/inc/use_ansi.h
@@ -0,0 +1,57 @@
+// use_ansi.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _USE_ANSI_CPP
+#define _USE_ANSI_CPP
+
+#ifdef _CRTBLD
+#define _CRT_NOPRAGMA_LIBS
+#else
+#undef _CRT_NOPRAGMA_LIBS
+#endif
+
+#ifndef _CRT_NOPRAGMA_LIBS
+
+#ifndef _M_CEE_PURE
+
+#undef _DEBUG_AFFIX
+#undef _IDL_AFFIX
+#undef _IDL_DEFAULT
+#undef _LIB_STEM
+
+#ifdef _DEBUG
+#define _DEBUG_AFFIX "d"
+#define _IDL_DEFAULT 2
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _DEBUG_AFFIX ""
+#define _IDL_DEFAULT 0
+#endif // ^^^ !defined(_DEBUG) ^^^
+
+#if defined(_DLL) && !defined(_STATIC_CPPLIB)
+#define _LIB_STEM "msvcprt"
+#else // ^^^ defined(_DLL) && !defined(_STATIC_CPPLIB) / !defined(_DLL) || defined(_STATIC_CPPLIB) vvv
+#define _LIB_STEM "libcpmt"
+
+#if _ITERATOR_DEBUG_LEVEL != _IDL_DEFAULT
+#define _IDL_AFFIX _STL_STRINGIZE(_ITERATOR_DEBUG_LEVEL)
+#endif // _ITERATOR_DEBUG_LEVEL != _IDL_DEFAULT
+#endif // ^^^ !defined(_DLL) || defined(_STATIC_CPPLIB) ^^^
+
+#ifndef _IDL_AFFIX
+#define _IDL_AFFIX ""
+#endif
+
+#pragma comment(lib, _LIB_STEM _DEBUG_AFFIX _IDL_AFFIX)
+
+#undef _DEBUG_AFFIX
+#undef _IDL_AFFIX
+#undef _IDL_DEFAULT
+#undef _LIB_STEM
+
+#endif // !defined(_M_CEE_PURE)
+
+#endif // !defined(_CRT_NOPRAGMA_LIBS)
+
+#endif // _USE_ANSI_CPP
diff --git a/msvc-stl/stl/inc/utility b/msvc-stl/stl/inc/utility
new file mode 100644
index 0000000..29e4cd6
--- /dev/null
+++ b/msvc-stl/stl/inc/utility
@@ -0,0 +1,1085 @@
+// utility standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _UTILITY_
+#define _UTILITY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_doom_core.hpp>
+#include <initializer_list>
+#include <type_traits>
+
+#if _HAS_CXX20
+#include <compare>
+#include <concepts>
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+#include <cstdlib>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("intrinsic")
+#pragma push_macro("known_semantics")
+#pragma push_macro("lifetimebound")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef intrinsic
+#undef known_semantics
+#undef lifetimebound
+#undef no_specializations
+
+_STD_BEGIN
+_EXPORT_STD template <class _Ty, _Ty... _Vals>
+struct integer_sequence { // sequence of integer parameters
+    static_assert(is_integral_v<_Ty>, "integer_sequence<T, I...> requires T to be an integral type.");
+
+    using value_type = _Ty;
+
+    _NODISCARD static constexpr size_t size() noexcept {
+        return sizeof...(_Vals);
+    }
+};
+
+_EXPORT_STD template <class _Ty, _Ty _Size>
+using make_integer_sequence = __make_integer_seq<integer_sequence, _Ty, _Size>;
+
+_EXPORT_STD template <size_t... _Vals>
+using index_sequence = integer_sequence<size_t, _Vals...>;
+
+_EXPORT_STD template <size_t _Size>
+using make_index_sequence = make_integer_sequence<size_t, _Size>;
+
+_EXPORT_STD template <class... _Types>
+using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr const _Ty&(max) (const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND,
+    _Pr _Pred) noexcept(noexcept(_Pred(_Left, _Right))) /* strengthened */ {
+    // return larger of _Left and _Right
+    return _Pred(_Left, _Right) ? _Right : _Left;
+}
+
+#pragma warning(push)
+#pragma warning(disable : 28285) // (syntax error in SAL annotation, occurs when _Ty is not an integral type)
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Post_equal_to_(_Left < _Right ? _Right : _Left) constexpr const _Ty& //
+    (max) (const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND)
+        noexcept(noexcept(_Left < _Right)) /* strengthened */ {
+    // return larger of _Left and _Right
+    return _Left < _Right ? _Right : _Left;
+}
+#pragma warning(pop)
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr _Ty(max)(initializer_list<_Ty>, _Pr); // implemented in <algorithm>
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty(max)(initializer_list<_Ty>); // implemented in <algorithm>
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr const _Ty&(min) (const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND,
+    _Pr _Pred) noexcept(noexcept(_Pred(_Right, _Left))) /* strengthened */ {
+    // return smaller of _Left and _Right
+    return _Pred(_Right, _Left) ? _Right : _Left;
+}
+
+#pragma warning(push)
+#pragma warning(disable : 28285) // (syntax error in SAL annotation, occurs when _Ty is not an integral type)
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Post_equal_to_(_Right < _Left ? _Right : _Left) constexpr const _Ty& //
+    (min) (const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND)
+        noexcept(noexcept(_Right < _Left)) /* strengthened */ {
+    // return smaller of _Left and _Right
+    return _Right < _Left ? _Right : _Left;
+}
+#pragma warning(pop)
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr _Ty(min)(initializer_list<_Ty>, _Pr); // implemented in <algorithm>
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty(min)(initializer_list<_Ty>); // implemented in <algorithm>
+
+_EXPORT_STD template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> /* = 0 */>
+_CONSTEXPR20 void swap(_Ty (&_Left)[_Size], _Ty (&_Right)[_Size]) noexcept(_Is_nothrow_swappable<_Ty>::value) {
+    if (&_Left == &_Right) {
+        return; // Handle self-swap as a no-op; see LWG-4165
+    }
+
+    if constexpr (_Is_trivially_swappable_v<_Ty>) {
+        if (!_STD _Is_constant_evaluated()) {
+            _STD _Swap_trivial_arrays(_Left, _Right);
+            return;
+        }
+    }
+
+    _Ty* _First1 = _Left;
+    _Ty* _Last1  = _First1 + _Size;
+    _Ty* _First2 = _Right;
+    for (; _First1 != _Last1; ++_First1, ++_First2) {
+        swap(*_First1, *_First2); // intentional ADL
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> /* = 0 */>
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+template <class _Ty, int _Enabled /* = 0 */>
+#endif // ^^^ !_HAS_CXX17 ^^^
+_CONSTEXPR20 void swap(_Ty& _Left, _Ty& _Right)
+    noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>) {
+    _Ty _Tmp = _STD move(_Left);
+    _Left    = _STD move(_Right);
+    _Right   = _STD move(_Tmp);
+}
+
+_EXPORT_STD struct piecewise_construct_t { // tag type for pair tuple arguments
+    explicit piecewise_construct_t() = default;
+};
+
+_EXPORT_STD _INLINE_VAR constexpr piecewise_construct_t piecewise_construct{};
+
+struct _Ignore { // struct that ignores assignments
+    template <class _Ty>
+    constexpr const _Ignore& operator=(const _Ty&) const noexcept {
+        // do nothing
+        return *this;
+    }
+};
+
+_EXPORT_STD _INLINE_VAR constexpr _Ignore ignore{};
+
+_EXPORT_STD template <class... _Types>
+class _NO_SPECIALIZATIONS_CITING("N5014 [tuple.tuple.general]/1") tuple;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct pair;
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+class array;
+
+_EXPORT_STD template <class _Tuple>
+struct tuple_size;
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr size_t tuple_size_v = tuple_size<_Ty>::value;
+
+_EXPORT_STD template <size_t _Index, class _Tuple>
+struct tuple_element;
+
+_EXPORT_STD template <size_t _Index, class _Tuple>
+using tuple_element_t = typename tuple_element<_Index, _Tuple>::type;
+
+template <size_t _Index, class... _Types>
+_NODISCARD constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Index, class... _Types>
+_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty& get(array<_Ty, _Size>& _Arr) noexcept;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr const _Ty& get(const array<_Ty, _Size>& _Arr) noexcept;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty&& get(array<_Ty, _Size>&& _Arr) noexcept;
+
+_EXPORT_STD template <size_t _Idx, class _Ty, size_t _Size>
+_NODISCARD constexpr const _Ty&& get(const array<_Ty, _Size>&& _Arr) noexcept;
+
+#if _HAS_CXX20
+template <class _Ty1, class _Ty2>
+concept _Different_from = !same_as<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>>;
+
+template <class>
+constexpr bool _Is_subrange_v = false;
+
+#if _HAS_CXX23
+template <class>
+constexpr bool _Tuple_like_non_subrange_impl = false;
+
+template <class... _Types>
+constexpr bool _Tuple_like_non_subrange_impl<tuple<_Types...>> = true;
+
+template <class _Ty1, class _Ty2>
+constexpr bool _Tuple_like_non_subrange_impl<pair<_Ty1, _Ty2>> = true;
+
+template <class _Ty, size_t _Size>
+constexpr bool _Tuple_like_non_subrange_impl<array<_Ty, _Size>> = true;
+
+template <class _Ty>
+concept _Tuple_like_non_subrange = _Tuple_like_non_subrange_impl<remove_cvref_t<_Ty>>;
+
+template <class _Ty>
+concept _Tuple_like = _Tuple_like_non_subrange<_Ty> || _Is_subrange_v<remove_cvref_t<_Ty>>;
+
+template <class _Ty>
+concept _Pair_like_non_subrange = _Tuple_like_non_subrange<_Ty> && tuple_size_v<remove_cvref_t<_Ty>> == 2;
+
+#ifdef __EDG__ // TRANSITION, VSO-1900279
+template <class _PairLike, class _Ty1, class _Ty2>
+concept _Can_construct_from_pair_like =
+    _Pair_like_non_subrange<_PairLike> && is_constructible_v<_Ty1, decltype(_STD get<0>(_STD declval<_PairLike>()))>
+    && is_constructible_v<_Ty2, decltype(_STD get<1>(_STD declval<_PairLike>()))>;
+#endif // ^^^ workaround ^^^
+#endif // _HAS_CXX23
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct pair { // store a pair of values
+    using first_type  = _Ty1;
+    using second_type = _Ty2;
+
+    template <class _Uty1 = _Ty1, class _Uty2 = _Ty2,
+        enable_if_t<conjunction_v<is_default_constructible<_Uty1>, is_default_constructible<_Uty2>>, int> = 0>
+    constexpr explicit(
+        !conjunction_v<_Is_implicitly_default_constructible<_Uty1>, _Is_implicitly_default_constructible<_Uty2>>) pair()
+        noexcept(is_nothrow_default_constructible_v<_Uty1> && is_nothrow_default_constructible_v<_Uty2>) // strengthened
+        : first(), second() {}
+
+    template <class _Uty1 = _Ty1, class _Uty2 = _Ty2,
+        enable_if_t<conjunction_v<is_copy_constructible<_Uty1>, is_copy_constructible<_Uty2>>, int> = 0>
+    constexpr explicit(!conjunction_v<is_convertible<const _Uty1&, _Uty1>, is_convertible<const _Uty2&, _Uty2>>)
+        pair(const _Ty1& _Val1, const _Ty2& _Val2)
+            noexcept(is_nothrow_copy_constructible_v<_Uty1> && is_nothrow_copy_constructible_v<_Uty2>) // strengthened
+        : first(_Val1), second(_Val2) {}
+
+#if _HAS_CXX23
+    template <class _Other1 = _Ty1, class _Other2 = _Ty2,
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    template <class _Other1, class _Other2,
+#endif // ^^^ !_HAS_CXX23 ^^^
+        enable_if_t<conjunction_v<is_constructible<_Ty1, _Other1>, is_constructible<_Ty2, _Other2>>, int> = 0>
+    constexpr explicit(!conjunction_v<is_convertible<_Other1, _Ty1>, is_convertible<_Other2, _Ty2>>)
+        pair(_Other1&& _Val1, _Other2&& _Val2) noexcept(
+            is_nothrow_constructible_v<_Ty1, _Other1> && is_nothrow_constructible_v<_Ty2, _Other2>) // strengthened
+        : first(_STD forward<_Other1>(_Val1)), second(_STD forward<_Other2>(_Val2)) {
+    }
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Other1 = _Ty1, class _Other2 = _Ty2,
+        enable_if_t<conjunction_v<is_constructible<_Ty1, _Other1>, is_constructible<_Ty2, _Other2>>, int> = 0>
+        requires reference_constructs_from_temporary_v<_Ty1, _Other1&&>
+                  || reference_constructs_from_temporary_v<_Ty2, _Other2&&>
+    explicit(!conjunction_v<is_convertible<_Other1, _Ty1>, is_convertible<_Other2, _Ty2>>)
+        pair(_Other1&&, _Other2&&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    pair(const pair&) = default;
+    pair(pair&&)      = default;
+
+#if _HAS_CXX23
+    template <class _Other1, class _Other2>
+        requires is_constructible_v<_Ty1, _Other1&> && is_constructible_v<_Ty2, _Other2&>
+    constexpr explicit(!conjunction_v<is_convertible<_Other1&, _Ty1>, is_convertible<_Other2&, _Ty2>>)
+        pair(pair<_Other1, _Other2>& _Right) noexcept(
+            is_nothrow_constructible_v<_Ty1, _Other1&> && is_nothrow_constructible_v<_Ty2, _Other2&>) // strengthened
+        : first(_Right.first), second(_Right.second) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Other1, class _Other2>
+        requires is_constructible_v<_Ty1, _Other1&> && is_constructible_v<_Ty2, _Other2&>
+                  && (reference_constructs_from_temporary_v<_Ty1, _Other1&>
+                      || reference_constructs_from_temporary_v<_Ty2, _Other2&>)
+    explicit(!conjunction_v<is_convertible<_Other1&, _Ty1>, is_convertible<_Other2&, _Ty2>>)
+        pair(pair<_Other1, _Other2>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<is_constructible<_Ty1, const _Other1&>, is_constructible<_Ty2, const _Other2&>>,
+            int> = 0>
+    constexpr explicit(!conjunction_v<is_convertible<const _Other1&, _Ty1>, is_convertible<const _Other2&, _Ty2>>)
+        pair(const pair<_Other1, _Other2>& _Right)
+            noexcept(is_nothrow_constructible_v<_Ty1, const _Other1&>
+                     && is_nothrow_constructible_v<_Ty2, const _Other2&>) // strengthened
+        : first(_Right.first), second(_Right.second) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<is_constructible<_Ty1, const _Other1&>, is_constructible<_Ty2, const _Other2&>>,
+            int> = 0>
+        requires reference_constructs_from_temporary_v<_Ty1, const _Other1&>
+                  || reference_constructs_from_temporary_v<_Ty2, const _Other2&>
+    explicit(!conjunction_v<is_convertible<const _Other1&, _Ty1>, is_convertible<const _Other2&, _Ty2>>)
+        pair(const pair<_Other1, _Other2>&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<is_constructible<_Ty1, _Other1>, is_constructible<_Ty2, _Other2>>, int> = 0>
+    constexpr explicit(!conjunction_v<is_convertible<_Other1, _Ty1>, is_convertible<_Other2, _Ty2>>)
+        pair(pair<_Other1, _Other2>&& _Right) noexcept(
+            is_nothrow_constructible_v<_Ty1, _Other1> && is_nothrow_constructible_v<_Ty2, _Other2>) // strengthened
+        : first(_STD forward<_Other1>(_Right.first)), second(_STD forward<_Other2>(_Right.second)) {}
+#if _HAS_CXX23
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<is_constructible<_Ty1, _Other1>, is_constructible<_Ty2, _Other2>>, int> = 0>
+        requires reference_constructs_from_temporary_v<_Ty1, _Other1&&>
+                  || reference_constructs_from_temporary_v<_Ty2, _Other2&&>
+    explicit(!conjunction_v<is_convertible<_Other1, _Ty1>, is_convertible<_Other2, _Ty2>>)
+        pair(pair<_Other1, _Other2>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+    template <class _Other1, class _Other2>
+        requires is_constructible_v<_Ty1, const _Other1> && is_constructible_v<_Ty2, const _Other2>
+    constexpr explicit(!conjunction_v<is_convertible<const _Other1, _Ty1>, is_convertible<const _Other2, _Ty2>>)
+        pair(const pair<_Other1, _Other2>&& _Right)
+            noexcept(is_nothrow_constructible_v<_Ty1, const _Other1>
+                     && is_nothrow_constructible_v<_Ty2, const _Other2>) // strengthened
+        : first(_STD forward<const _Other1>(_Right.first)), second(_STD forward<const _Other2>(_Right.second)) {}
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <class _Other1, class _Other2>
+        requires is_constructible_v<_Ty1, const _Other1> && is_constructible_v<_Ty2, const _Other2>
+                  && (reference_constructs_from_temporary_v<_Ty1, const _Other1 &&>
+                      || reference_constructs_from_temporary_v<_Ty2, const _Other2 &&>)
+    explicit(!conjunction_v<is_convertible<const _Other1, _Ty1>, is_convertible<const _Other2, _Ty2>>)
+        pair(const pair<_Other1, _Other2>&&) = delete;
+#endif // ^^^ no workaround ^^^
+
+#ifdef __EDG__ // TRANSITION, VSO-1900279
+    template <class _Other, enable_if_t<_Can_construct_from_pair_like<_Other, _Ty1, _Ty2>, int> = 0>
+#else // ^^^ workaround / no workaround vvv
+    template <_Pair_like_non_subrange _Other>
+        requires conjunction_v<is_constructible<_Ty1, decltype(_STD get<0>(_STD declval<_Other>()))>,
+                     is_constructible<_Ty2, decltype(_STD get<1>(_STD declval<_Other>()))>>
+#endif // ^^^ no workaround ^^^
+    constexpr explicit(!conjunction_v<is_convertible<decltype(_STD get<0>(_STD declval<_Other>())), _Ty1>,
+        is_convertible<decltype(_STD get<1>(_STD declval<_Other>())), _Ty2>>) pair(_Other&& _Right)
+        noexcept(is_nothrow_constructible_v<_Ty1, decltype(_STD get<0>(_STD declval<_Other>()))>
+                 && is_nothrow_constructible_v<_Ty2, decltype(_STD get<1>(_STD declval<_Other>()))>) // strengthened
+        : first(_STD get<0>(_STD forward<_Other>(_Right))), second(_STD get<1>(_STD forward<_Other>(_Right))) {
+    }
+#ifdef __cpp_lib_reference_from_temporary // TRANSITION
+    template <_Pair_like_non_subrange _Other>
+        requires conjunction_v<is_constructible<_Ty1, decltype(_STD get<0>(_STD declval<_Other>()))>,
+                     is_constructible<_Ty2, decltype(_STD get<1>(_STD declval<_Other>()))>>
+                  && (reference_constructs_from_temporary_v<_Ty1, decltype(_STD get<0>(_STD declval<_Other>()))>
+                      || reference_constructs_from_temporary_v<_Ty2, decltype(_STD get<1>(_STD declval<_Other>()))>)
+    explicit(!conjunction_v<is_convertible<decltype(_STD get<0>(_STD declval<_Other>())), _Ty1>,
+        is_convertible<decltype(_STD get<1>(_STD declval<_Other>())), _Ty2>>) pair(_Other&&) = delete;
+#endif // ^^^ no workaround ^^^
+#endif // _HAS_CXX23
+
+    template <class... _Types1, class... _Types2>
+    _CONSTEXPR20 pair(piecewise_construct_t, tuple<_Types1...> _Val1, tuple<_Types2...> _Val2)
+        : pair(_Val1, _Val2, index_sequence_for<_Types1...>{}, index_sequence_for<_Types2...>{}) {}
+
+    pair& operator=(const volatile pair&) = delete;
+
+    template <class _Myself = pair,
+        enable_if_t<conjunction_v<_Is_copy_assignable_no_precondition_check<typename _Myself::first_type>,
+                        _Is_copy_assignable_no_precondition_check<typename _Myself::second_type>>,
+            int>            = 0>
+    _CONSTEXPR20 pair& operator=(_Identity_t<const _Myself&> _Right)
+        noexcept(conjunction_v<is_nothrow_copy_assignable<_Ty1>, is_nothrow_copy_assignable<_Ty2>>) /* strengthened */ {
+        first  = _Right.first;
+        second = _Right.second;
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Myself = pair>
+        requires _Is_copy_assignable_unchecked_v<const typename _Myself::first_type>
+              && _Is_copy_assignable_unchecked_v<const typename _Myself::second_type>
+    constexpr const pair& operator=(_Identity_t<const _Myself&> _Right) const
+        noexcept(conjunction_v<is_nothrow_copy_assignable<const _Ty1>,
+            is_nothrow_copy_assignable<const _Ty2>>) /* strengthened */ {
+        first  = _Right.first;
+        second = _Right.second;
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _Myself = pair,
+        enable_if_t<conjunction_v<_Is_move_assignable_no_precondition_check<typename _Myself::first_type>,
+                        _Is_move_assignable_no_precondition_check<typename _Myself::second_type>>,
+            int>            = 0>
+    _CONSTEXPR20 pair& operator=(_Identity_t<_Myself&&> _Right)
+        noexcept(conjunction_v<is_nothrow_move_assignable<_Ty1>, is_nothrow_move_assignable<_Ty2>>) /* strengthened */ {
+        first  = _STD forward<_Ty1>(_Right.first);
+        second = _STD forward<_Ty2>(_Right.second);
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Myself = pair>
+        requires _Is_assignable_no_precondition_check<const typename _Myself::first_type&, _Ty1>::value
+              && _Is_assignable_no_precondition_check<const typename _Myself::second_type&, _Ty2>::value
+    constexpr const pair& operator=(_Identity_t<_Myself&&> _Right) const
+        noexcept(conjunction_v<is_nothrow_assignable<const _Ty1&, _Ty1>,
+            is_nothrow_assignable<const _Ty2&, _Ty2>>) /* strengthened */ {
+        first  = _STD forward<_Ty1>(_Right.first);
+        second = _STD forward<_Ty2>(_Right.second);
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<negation<is_same<pair, pair<_Other1, _Other2>>>, is_assignable<_Ty1&, const _Other1&>,
+                        is_assignable<_Ty2&, const _Other2&>>,
+            int> = 0>
+    _CONSTEXPR20 pair& operator=(const pair<_Other1, _Other2>& _Right)
+        noexcept(is_nothrow_assignable_v<_Ty1&, const _Other1&>
+                 && is_nothrow_assignable_v<_Ty2&, const _Other2&>) /* strengthened */ {
+        first  = _Right.first;
+        second = _Right.second;
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Other1, class _Other2>
+        requires (!is_same_v<pair, pair<_Other1, _Other2>>)
+              && is_assignable_v<const _Ty1&, const _Other1&> && is_assignable_v<const _Ty2&, const _Other2&>
+    constexpr const pair& operator=(const pair<_Other1, _Other2>& _Right) const
+        noexcept(is_nothrow_assignable_v<const _Ty1&, const _Other1&>
+                 && is_nothrow_assignable_v<const _Ty2&, const _Other2&>) /* strengthened */ {
+        first  = _Right.first;
+        second = _Right.second;
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    template <class _Other1, class _Other2,
+        enable_if_t<conjunction_v<negation<is_same<pair, pair<_Other1, _Other2>>>, is_assignable<_Ty1&, _Other1>,
+                        is_assignable<_Ty2&, _Other2>>,
+            int> = 0>
+    _CONSTEXPR20 pair& operator=(pair<_Other1, _Other2>&& _Right) noexcept(
+        is_nothrow_assignable_v<_Ty1&, _Other1> && is_nothrow_assignable_v<_Ty2&, _Other2>) /* strengthened */ {
+        first  = _STD forward<_Other1>(_Right.first);
+        second = _STD forward<_Other2>(_Right.second);
+        return *this;
+    }
+
+#if _HAS_CXX23
+    template <class _Other1, class _Other2>
+        requires (!is_same_v<pair, pair<_Other1, _Other2>>)
+              && is_assignable_v<const _Ty1&, _Other1> && is_assignable_v<const _Ty2&, _Other2>
+    constexpr const pair& operator=(pair<_Other1, _Other2>&& _Right) const
+        noexcept(is_nothrow_assignable_v<const _Ty1&, _Other1>
+                 && is_nothrow_assignable_v<const _Ty2&, _Other2>) /* strengthened */ {
+        first  = _STD forward<_Other1>(_Right.first);
+        second = _STD forward<_Other2>(_Right.second);
+        return *this;
+    }
+
+    template <_Pair_like_non_subrange _Other>
+        requires _Different_from<_Other, pair> && is_assignable_v<_Ty1&, decltype(_STD get<0>(_STD declval<_Other>()))>
+              && is_assignable_v<_Ty2&, decltype(_STD get<1>(_STD declval<_Other>()))>
+    constexpr pair& operator=(_Other&& _Right)
+        noexcept(is_nothrow_assignable_v<_Ty1&, decltype(_STD get<0>(_STD declval<_Other>()))>
+                 && is_nothrow_assignable_v<_Ty2&, decltype(_STD get<1>(_STD declval<_Other>()))>) /* strengthened */ {
+        first  = _STD get<0>(_STD forward<_Other>(_Right));
+        second = _STD get<1>(_STD forward<_Other>(_Right));
+        return *this;
+    }
+
+    template <_Pair_like_non_subrange _Other>
+        requires _Different_from<_Other, pair>
+              && is_assignable_v<const _Ty1&, decltype(_STD get<0>(_STD declval<_Other>()))>
+              && is_assignable_v<const _Ty2&, decltype(_STD get<1>(_STD declval<_Other>()))>
+    constexpr const pair& operator=(_Other&& _Right) const noexcept(
+        is_nothrow_assignable_v<const _Ty1&, decltype(_STD get<0>(_STD declval<_Other>()))>
+        && is_nothrow_assignable_v<const _Ty2&, decltype(_STD get<1>(_STD declval<_Other>()))>) /* strengthened */ {
+        first  = _STD get<0>(_STD forward<_Other>(_Right));
+        second = _STD get<1>(_STD forward<_Other>(_Right));
+        return *this;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void swap(pair& _Right)
+        noexcept(_Is_nothrow_swappable<_Ty1>::value && _Is_nothrow_swappable<_Ty2>::value) {
+        using _STD swap;
+        swap(first, _Right.first); // intentional ADL
+        swap(second, _Right.second); // intentional ADL
+    }
+
+#if _HAS_CXX23
+    template <int = 0> // see GH-3013
+    constexpr void swap(const pair& _Right) const
+        noexcept(is_nothrow_swappable_v<const _Ty1> && is_nothrow_swappable_v<const _Ty2>) {
+        using _STD swap;
+        swap(first, _Right.first); // intentional ADL
+        swap(second, _Right.second); // intentional ADL
+    }
+#endif // _HAS_CXX23
+
+    _Ty1 first; // the first stored value
+    _Ty2 second; // the second stored value
+
+private:
+    template <class _Tuple1, class _Tuple2, size_t... _Indices1, size_t... _Indices2>
+    constexpr pair(_Tuple1& _Val1, _Tuple2& _Val2, index_sequence<_Indices1...>, index_sequence<_Indices2...>)
+        : first(_STD _Tuple_get<_Indices1>(_STD move(_Val1))...),
+          second(_STD _Tuple_get<_Indices2>(_STD move(_Val2))...) {}
+};
+
+#if _HAS_CXX17
+template <class _Ty1, class _Ty2>
+pair(_Ty1, _Ty2) -> pair<_Ty1, _Ty2>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty1, class _Ty2,
+    enable_if_t<_Is_swappable<_Ty1>::value && _Is_swappable<_Ty2>::value, int> = 0>
+_CONSTEXPR20 void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ty1, class _Ty2>
+    requires is_swappable<const _Ty1>::value && is_swappable<const _Ty2>::value // TRANSITION, /permissive needs ::value
+constexpr void swap(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right)
+    noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator==(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return _Left.first == _Right.first && _Left.second == _Right.second;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr common_comparison_category_t<_Synth_three_way_result<_Ty1, _Uty1>,
+    _Synth_three_way_result<_Ty2, _Uty2>> operator<=>(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    if (auto _Result = _Synth_three_way{}(_Left.first, _Right.first); _Result != 0) {
+        return _Result;
+    }
+    return _Synth_three_way{}(_Left.second, _Right.second);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator!=(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return !(_Left == _Right);
+}
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator<(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return _Left.first < _Right.first || (!(_Right.first < _Left.first) && _Left.second < _Right.second);
+}
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator>(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator<=(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+_NODISCARD constexpr bool operator>=(const pair<_Ty1, _Ty2>& _Left, const pair<_Uty1, _Uty2>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX23
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2, template <class> class _TQual,
+    template <class> class _UQual>
+    requires requires {
+        typename pair<common_reference_t<_TQual<_Ty1>, _UQual<_Uty1>>, common_reference_t<_TQual<_Ty2>, _UQual<_Uty2>>>;
+    }
+struct basic_common_reference<pair<_Ty1, _Ty2>, pair<_Uty1, _Uty2>, _TQual, _UQual> {
+    using type = pair<common_reference_t<_TQual<_Ty1>, _UQual<_Uty1>>, common_reference_t<_TQual<_Ty2>, _UQual<_Uty2>>>;
+};
+
+template <class _Ty1, class _Ty2, class _Uty1, class _Uty2>
+    requires requires { typename pair<common_type_t<_Ty1, _Uty1>, common_type_t<_Ty2, _Uty2>>; }
+struct common_type<pair<_Ty1, _Ty2>, pair<_Uty1, _Uty2>> {
+    using type = pair<common_type_t<_Ty1, _Uty1>, common_type_t<_Ty2, _Uty2>>;
+};
+#endif // _HAS_CXX23
+
+template <class _Ty>
+struct _Unrefwrap_helper { // leave unchanged if not a reference_wrapper
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct _Unrefwrap_helper<reference_wrapper<_Ty>> { // make a reference from a reference_wrapper
+    using type = _Ty&;
+};
+
+// decay, then unwrap a reference_wrapper
+template <class _Ty>
+using _Unrefwrap_t = typename _Unrefwrap_helper<decay_t<_Ty>>::type;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>> make_pair(_Ty1&& _Val1, _Ty2&& _Val2)
+    noexcept(is_nothrow_constructible_v<_Unrefwrap_t<_Ty1>, _Ty1>
+             && is_nothrow_constructible_v<_Unrefwrap_t<_Ty2>, _Ty2>) /* strengthened */ {
+    // return pair composed from arguments
+    using _Mypair = pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>>;
+    return _Mypair(_STD forward<_Ty1>(_Val1), _STD forward<_Ty2>(_Val2));
+}
+
+namespace _CXX20_DEPRECATE_REL_OPS rel_ops {
+    _EXPORT_STD template <class _Ty>
+    _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator!=(const _Ty& _Left, const _Ty& _Right) {
+        return !(_Left == _Right);
+    }
+
+    _EXPORT_STD template <class _Ty>
+    _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator>(const _Ty& _Left, const _Ty& _Right) {
+        return _Right < _Left;
+    }
+
+    _EXPORT_STD template <class _Ty>
+    _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator<=(const _Ty& _Left, const _Ty& _Right) {
+        return !(_Right < _Left);
+    }
+
+    _EXPORT_STD template <class _Ty>
+    _CXX20_DEPRECATE_REL_OPS _NODISCARD bool operator>=(const _Ty& _Left, const _Ty& _Right) {
+        return !(_Left < _Right);
+    }
+} // namespace _CXX20_DEPRECATE_REL_OPS rel_ops
+
+template <class _Tuple, class = void>
+struct _Tuple_size_sfinae {}; // selected when tuple_size<_Tuple>::value isn't well-formed
+
+template <class _Tuple>
+struct _Tuple_size_sfinae<_Tuple, void_t<decltype(tuple_size<_Tuple>::value)>>
+    : integral_constant<size_t, tuple_size<_Tuple>::value> {}; // selected when tuple_size<_Tuple>::value is well-formed
+
+template <class _Tuple>
+struct tuple_size<const _Tuple> : _Tuple_size_sfinae<_Tuple> {}; // ignore cv
+
+template <class _Tuple>
+struct _CXX20_DEPRECATE_VOLATILE tuple_size<volatile _Tuple> : _Tuple_size_sfinae<_Tuple> {}; // ignore cv
+
+template <class _Tuple>
+struct _CXX20_DEPRECATE_VOLATILE tuple_size<const volatile _Tuple> : _Tuple_size_sfinae<_Tuple> {}; // ignore cv
+
+template <size_t _Index, class _Tuple>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, const _Tuple> : tuple_element<_Index, _Tuple> {
+    using _Mybase = tuple_element<_Index, _Tuple>;
+    using type    = add_const_t<typename _Mybase::type>;
+};
+
+template <size_t _Index, class _Tuple>
+struct _CXX20_DEPRECATE_VOLATILE _MSVC_KNOWN_SEMANTICS
+    tuple_element<_Index, volatile _Tuple> : tuple_element<_Index, _Tuple> {
+    using _Mybase = tuple_element<_Index, _Tuple>;
+    using type    = add_volatile_t<typename _Mybase::type>;
+};
+
+template <size_t _Index, class _Tuple>
+struct _CXX20_DEPRECATE_VOLATILE _MSVC_KNOWN_SEMANTICS
+    tuple_element<_Index, const volatile _Tuple> : tuple_element<_Index, _Tuple> {
+    using _Mybase = tuple_element<_Index, _Tuple>;
+    using type    = add_cv_t<typename _Mybase::type>;
+};
+
+template <class _Ty, size_t _Size>
+struct tuple_size<array<_Ty, _Size>> : integral_constant<size_t, _Size> {}; // size of array
+
+template <size_t _Idx, class _Ty, size_t _Size>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Idx, array<_Ty, _Size>> {
+    static_assert(_Idx < _Size, "array index out of bounds");
+
+    using type = _Ty;
+};
+
+template <class... _Types>
+struct tuple_size<tuple<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {}; // size of tuple
+
+template <size_t _Index>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, tuple<>> { // enforce bounds checking
+    static_assert(false, "tuple index out of bounds");
+};
+
+template <class _This, class... _Rest>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<0, tuple<_This, _Rest...>> { // select first element
+    using type = _This;
+    // MSVC assumes the meaning of _Ttype; remove or rename, but do not change semantics
+    using _Ttype = tuple<_This, _Rest...>;
+};
+
+template <size_t _Index, class _This, class... _Rest>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, tuple<_This, _Rest...>>
+    : tuple_element<_Index - 1, tuple<_Rest...>> {}; // recursive tuple_element definition
+
+template <class _Ty1, class _Ty2>
+struct tuple_size<pair<_Ty1, _Ty2>> : integral_constant<size_t, 2> {}; // size of pair
+
+template <size_t _Idx, class _Ty1, class _Ty2>
+struct _MSVC_KNOWN_SEMANTICS tuple_element<_Idx, pair<_Ty1, _Ty2>> {
+    static_assert(_Idx < 2, "pair index out of bounds");
+
+    using type = conditional_t<_Idx == 0, _Ty1, _Ty2>;
+};
+
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
+_NODISCARD constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get reference to element at _Idx in pair _Pr
+    if constexpr (_Idx == 0) {
+        return _Pr.first;
+    } else {
+        return _Pr.second;
+    }
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr _Ty1& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get reference to element _Ty1 in pair _Pr
+    return _Pr.first;
+}
+
+_EXPORT_STD template <class _Ty2, class _Ty1>
+_NODISCARD constexpr _Ty2& get(pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get reference to element _Ty2 in pair _Pr
+    return _Pr.second;
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
+_NODISCARD constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get const reference to element at _Idx in pair _Pr
+    if constexpr (_Idx == 0) {
+        return _Pr.first;
+    } else {
+        return _Pr.second;
+    }
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr const _Ty1& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get const reference to element _Ty1 in pair _Pr
+    return _Pr.first;
+}
+
+_EXPORT_STD template <class _Ty2, class _Ty1>
+_NODISCARD constexpr const _Ty2& get(const pair<_Ty1, _Ty2>& _Pr) noexcept {
+    // get const reference to element _Ty2 in pair _Pr
+    return _Pr.second;
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
+_NODISCARD constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get rvalue reference to element at _Idx in pair _Pr
+    if constexpr (_Idx == 0) {
+        return _STD forward<_Ty1>(_Pr.first);
+    } else {
+        return _STD forward<_Ty2>(_Pr.second);
+    }
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr _Ty1&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get rvalue reference to element _Ty1 in pair _Pr
+    return _STD forward<_Ty1>(_Pr.first);
+}
+
+_EXPORT_STD template <class _Ty2, class _Ty1>
+_NODISCARD constexpr _Ty2&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get rvalue reference to element _Ty2 in pair _Pr
+    return _STD forward<_Ty2>(_Pr.second);
+}
+
+_EXPORT_STD template <size_t _Idx, class _Ty1, class _Ty2>
+_NODISCARD constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get const rvalue reference to element at _Idx in pair _Pr
+    if constexpr (_Idx == 0) {
+        return _STD forward<const _Ty1>(_Pr.first);
+    } else {
+        return _STD forward<const _Ty2>(_Pr.second);
+    }
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr const _Ty1&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get const rvalue reference to element _Ty1 in pair _Pr
+    return _STD forward<const _Ty1>(_Pr.first);
+}
+
+_EXPORT_STD template <class _Ty2, class _Ty1>
+_NODISCARD constexpr const _Ty2&& get(const pair<_Ty1, _Ty2>&& _Pr) noexcept {
+    // get const rvalue reference to element _Ty2 in pair _Pr
+    return _STD forward<const _Ty2>(_Pr.second);
+}
+
+_EXPORT_STD template <class _Ty, class _Other = _Ty>
+_CONSTEXPR20 _Ty exchange(_Ty& _Val, _Other&& _New_val)
+    noexcept(conjunction_v<is_nothrow_move_constructible<_Ty>, is_nothrow_assignable<_Ty&, _Other>>) {
+    // assign _New_val to _Val, return previous _Val
+    _Ty _Old_val = static_cast<_Ty&&>(_Val);
+    _Val         = static_cast<_Other&&>(_New_val);
+    return _Old_val;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _MSVC_INTRINSIC constexpr add_const_t<_Ty>& as_const(_Ty& _Val) noexcept { // view _Val through const lenses
+    return _Val;
+}
+
+_EXPORT_STD template <class _Ty>
+void as_const(const _Ty&&) = delete;
+
+#if _HAS_CXX17
+_EXPORT_STD struct in_place_t { // tag used to select a constructor which initializes a contained object in place
+    explicit in_place_t() = default;
+};
+_EXPORT_STD inline constexpr in_place_t in_place{};
+
+_EXPORT_STD template <class>
+struct in_place_type_t { // tag that selects a type to construct in place
+    explicit in_place_type_t() = default;
+};
+_EXPORT_STD template <class _Ty>
+constexpr in_place_type_t<_Ty> in_place_type{};
+
+_EXPORT_STD template <size_t>
+struct in_place_index_t { // tag that selects the index of a type to construct in place
+    explicit in_place_index_t() = default;
+};
+_EXPORT_STD template <size_t _Idx>
+constexpr in_place_index_t<_Idx> in_place_index{};
+#endif // _HAS_CXX17
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_nonbool_integral<_Ty1> && _Is_nonbool_integral<_Ty2>); // allows character types
+    if constexpr (is_signed_v<_Ty1> == is_signed_v<_Ty2>) {
+        return _Left == _Right;
+    } else if constexpr (is_signed_v<_Ty2>) {
+        return _Left == static_cast<make_unsigned_t<_Ty2>>(_Right) && _Right >= 0;
+    } else {
+        return static_cast<make_unsigned_t<_Ty1>>(_Left) == _Right && _Left >= 0;
+    }
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_not_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    return !_STD _Cmp_equal(_Left, _Right);
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_less(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_nonbool_integral<_Ty1> && _Is_nonbool_integral<_Ty2>); // allows character types
+    if constexpr (is_signed_v<_Ty1> == is_signed_v<_Ty2>) {
+        return _Left < _Right;
+    } else if constexpr (is_signed_v<_Ty2>) {
+        return _Right > 0 && _Left < static_cast<make_unsigned_t<_Ty2>>(_Right);
+    } else {
+        return _Left < 0 || static_cast<make_unsigned_t<_Ty1>>(_Left) < _Right;
+    }
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_greater(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    return _STD _Cmp_less(_Right, _Left);
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_less_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    return !_STD _Cmp_less(_Right, _Left);
+}
+
+template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Cmp_greater_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    return !_STD _Cmp_less(_Left, _Right);
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty _Min_limit() noexcept { // same as (numeric_limits<_Ty>::min)(), less throughput cost
+    _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_Ty>); // doesn't attempt to handle all types
+    if constexpr (is_signed_v<_Ty>) {
+        constexpr auto _Unsigned_max = static_cast<make_unsigned_t<_Ty>>(-1);
+        return static_cast<_Ty>((_Unsigned_max >> 1) + 1); // well-defined, N4950 [conv.integral]/3
+    } else {
+        return 0;
+    }
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty _Max_limit() noexcept { // same as (numeric_limits<_Ty>::max)(), less throughput cost
+    _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_Ty>); // doesn't attempt to handle all types
+    if constexpr (is_signed_v<_Ty>) {
+        constexpr auto _Unsigned_max = static_cast<make_unsigned_t<_Ty>>(-1);
+        return static_cast<_Ty>(_Unsigned_max >> 1);
+    } else {
+        return static_cast<_Ty>(-1);
+    }
+}
+
+template <class _Rx, class _Ty>
+_NODISCARD constexpr bool _In_range(const _Ty _Value) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_nonbool_integral<_Rx> && _Is_nonbool_integral<_Ty>); // allows character types
+
+    constexpr auto _Ty_min = _Min_limit<_Ty>();
+    constexpr auto _Rx_min = _Min_limit<_Rx>();
+
+    if constexpr (_STD _Cmp_less(_Ty_min, _Rx_min)) {
+        if (_Value < _Ty{_Rx_min}) {
+            return false;
+        }
+    }
+
+    constexpr auto _Ty_max = _Max_limit<_Ty>();
+    constexpr auto _Rx_max = _Max_limit<_Rx>();
+
+    if constexpr (_STD _Cmp_greater(_Ty_max, _Rx_max)) {
+        if (_Value > _Ty{_Rx_max}) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+#if _HAS_CXX20
+template <class _Ty>
+constexpr bool _Is_standard_integer = _Is_any_of_v<_Ty, signed char, short, int, long, long long, unsigned char,
+    unsigned short, unsigned int, unsigned long, unsigned long long>;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_equal(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_not_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_not_equal(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_less(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_less(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_greater(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_greater(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_less_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_less_equal(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NODISCARD constexpr bool cmp_greater_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
+    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _Cmp_greater_equal(_Left, _Right);
+}
+
+_EXPORT_STD template <class _Rx, class _Ty>
+_NODISCARD constexpr bool in_range(const _Ty _Value) noexcept {
+    static_assert(_Is_standard_integer<_Rx> && _Is_standard_integer<_Ty>,
+        "The integer comparison functions only accept standard and extended integer types.");
+    return _STD _In_range<_Rx>(_Value);
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ty> // TRANSITION, VSO-2253317: should be _MSVC_INTRINSIC
+_NODISCARD constexpr underlying_type_t<_Ty> to_underlying(_Ty _Value) noexcept {
+    return static_cast<underlying_type_t<_Ty>>(_Value);
+}
+
+_EXPORT_STD [[noreturn]] __forceinline void unreachable() noexcept /* strengthened */ {
+#ifdef _DEBUG
+    _MSVC_STL_DOOM_FUNCTION("std::unreachable() called");
+#endif // defined(_DEBUG)
+    _STL_UNREACHABLE;
+}
+
+template <class _Ty, class _Uty,
+    class _Tmp = _Maybe_const<is_const_v<remove_reference_t<_Ty>>, remove_reference_t<_Uty>>>
+using _Forward_like_t = conditional_t<is_rvalue_reference_v<_Ty&&>, _Tmp&&, _Tmp&>;
+
+_EXPORT_STD template <class _Ty, class _Uty>
+_NODISCARD _MSVC_INTRINSIC constexpr _Forward_like_t<_Ty, _Uty> forward_like(_Uty&& _Ux) noexcept {
+    return static_cast<_Forward_like_t<_Ty, _Uty>>(_Ux);
+}
+#endif // _HAS_CXX23
+
+#if _HAS_CXX17
+_EXPORT_STD struct monostate {};
+
+_EXPORT_STD _NODISCARD constexpr bool operator==(monostate, monostate) noexcept {
+    return true;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
+    return strong_ordering::equal;
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+_NODISCARD constexpr bool operator!=(monostate, monostate) noexcept {
+    return false;
+}
+_NODISCARD constexpr bool operator<(monostate, monostate) noexcept {
+    return false;
+}
+_NODISCARD constexpr bool operator>(monostate, monostate) noexcept {
+    return false;
+}
+_NODISCARD constexpr bool operator<=(monostate, monostate) noexcept {
+    return true;
+}
+_NODISCARD constexpr bool operator>=(monostate, monostate) noexcept {
+    return true;
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <>
+struct hash<monostate> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = monostate;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(monostate) noexcept {
+        return 1729; // Arbitrary value
+    }
+};
+#endif // _HAS_CXX17
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("lifetimebound")
+#pragma pop_macro("known_semantics")
+#pragma pop_macro("intrinsic")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _UTILITY_
diff --git a/msvc-stl/stl/inc/valarray b/msvc-stl/stl/inc/valarray
new file mode 100644
index 0000000..73a6a0e
--- /dev/null
+++ b/msvc-stl/stl/inc/valarray
@@ -0,0 +1,2114 @@
+// valarray standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _VALARRAY_
+#define _VALARRAY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cmath>
+#include <xmemory>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD class gslice;
+_EXPORT_STD class slice;
+
+_EXPORT_STD template <class _Ty>
+class gslice_array;
+_EXPORT_STD template <class _Ty>
+class indirect_array;
+_EXPORT_STD template <class _Ty>
+class mask_array;
+_EXPORT_STD template <class _Ty>
+class slice_array;
+_EXPORT_STD template <class _Ty>
+class valarray;
+
+template <class _Ty>
+_Ty* _Allocate_for_op_delete(size_t _Count) {
+    // allocates space for _Count objects of type _Ty
+    if (_Count == 0) {
+        return nullptr;
+    }
+
+    const size_t _Bytes = _Get_size_of_n<sizeof(_Ty)>(_Count);
+#ifdef __cpp_aligned_new
+    constexpr bool _Extended_alignment = alignof(_Ty) > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
+    if constexpr (_Extended_alignment) {
+        return static_cast<_Ty*>(::operator new(_Bytes, align_val_t{alignof(_Ty)}));
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+        return static_cast<_Ty*>(::operator new(_Bytes));
+    }
+}
+
+using _Boolarray = valarray<bool>;
+using _Sizarray  = valarray<size_t>;
+
+_EXPORT_STD template <class _Ty>
+class valarray { // store array with various indexing options
+public:
+    friend _Tidy_deallocate_guard<valarray>;
+
+    using value_type     = _Ty;
+    using iterator       = _Ty*;
+    using const_iterator = const _Ty*;
+
+    valarray() = default; // construct empty valarray
+
+    explicit valarray(size_t _Count) { // construct with _Count * _Ty()
+        _Grow(_Count);
+    }
+
+    valarray(const _Ty& _Val, size_t _Count) { // construct with _Count * _Val
+        _Grow(_Count, _STD addressof(_Val));
+    }
+
+    valarray(const _Ty* _Ptr, size_t _Count) { // construct with [_Ptr, _Ptr + _Count)
+        _Grow(_Count, _Ptr, 1);
+    }
+
+    valarray(const valarray& _Right) {
+        _Grow(_Right.size(), _Right._Myptr, 1);
+    }
+
+    valarray(const slice_array<_Ty>& _Slicearr) {
+        *this = _Slicearr;
+    }
+
+    valarray(const gslice_array<_Ty>& _Gslicearr) {
+        *this = _Gslicearr;
+    }
+
+    valarray(const mask_array<_Ty>& _Maskarr) {
+        *this = _Maskarr;
+    }
+
+    valarray(const indirect_array<_Ty>& _Indarr) {
+        *this = _Indarr;
+    }
+
+    valarray(valarray&& _Right) noexcept
+        : _Myptr(_STD exchange(_Right._Myptr, nullptr)), _Mysize(_STD exchange(_Right._Mysize, size_t{})) {}
+
+    valarray& operator=(valarray&& _Right) noexcept {
+        if (this != _STD addressof(_Right)) { // clear this and steal from _Right
+            _Tidy_deallocate();
+            _Myptr  = _STD exchange(_Right._Myptr, nullptr);
+            _Mysize = _STD exchange(_Right._Mysize, size_t{});
+        }
+        return *this;
+    }
+
+    valarray(initializer_list<_Ty> _Ilist) {
+        _Grow(_Ilist.size(), _Ilist.begin(), 1);
+    }
+
+    valarray& operator=(initializer_list<_Ty> _Ilist) {
+        _Assign(_Ilist.size(), _Ilist.begin());
+        return *this;
+    }
+
+    void swap(valarray& _Right) noexcept {
+        if (this != _STD addressof(_Right)) {
+            _STD swap(_Myptr, _Right._Myptr);
+            _STD swap(_Mysize, _Right._Mysize);
+        }
+    }
+
+    ~valarray() noexcept {
+        _Tidy_deallocate();
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        const auto _Tombstone{reinterpret_cast<_Ty*>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+        _Myptr = _Tombstone;
+
+        // _Tidy_deallocate() sets _Mysize to 0, so we don't need to set it here.
+        _STL_INTERNAL_CHECK(_Mysize == 0);
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    }
+
+    valarray& operator=(const valarray& _Right) {
+        if (this != _STD addressof(_Right)) {
+            _Assign(_Right.size(), _Right._Myptr);
+        }
+
+        return *this;
+    }
+
+    valarray& operator=(const _Ty& _Val) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] = _Val;
+        }
+        return *this;
+    }
+
+    void resize(size_t _Newsize) { // determine new length, filling with _Ty() elements
+        _Tidy_deallocate();
+        _Grow(_Newsize);
+    }
+
+    void resize(size_t _Newsize, _Ty _Val) { // determine new length, filling with _Val elements
+        _Tidy_deallocate();
+        _Grow(_Newsize, _STD addressof(_Val), 0);
+    }
+
+    valarray& operator=(const slice_array<_Ty>& _Slicearr); // defined below
+
+    valarray& operator=(const gslice_array<_Ty>& _Gslicearr); // defined below
+
+    valarray& operator=(const mask_array<_Ty>& _Maskarr); // defined below
+
+    valarray& operator=(const indirect_array<_Ty>& _Indarr); // defined below
+
+    _NODISCARD valarray operator+() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = +_Myptr[_Idx];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray operator-() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = -_Myptr[_Idx];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray operator~() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = ~_Myptr[_Idx];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD _Boolarray operator!() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<bool> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = !_Myptr[_Idx];
+        }
+        return _Ans;
+    }
+
+    valarray& operator*=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] *= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator/=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] /= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator%=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] %= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator+=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] += _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator-=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] -= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator^=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] ^= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator&=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] &= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator|=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] |= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator<<=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] <<= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator>>=(const _Ty& _Right) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] >>= _Right;
+        }
+        return *this;
+    }
+
+    valarray& operator*=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] *= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator/=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] /= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator%=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] %= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator+=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] += _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator-=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] -= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator^=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] ^= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator|=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] |= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator&=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] &= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator<<=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] <<= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    valarray& operator>>=(const valarray& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mysize == _Right._Mysize, "valarrays of different lengths");
+#endif
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Idx] >>= _Right[_Idx];
+        }
+        return *this;
+    }
+
+    _NODISCARD size_t size() const noexcept /* strengthened */ {
+        return _Mysize;
+    }
+
+    _NODISCARD iterator begin() noexcept /* strengthened */ {
+        return _Myptr;
+    }
+
+    _NODISCARD const_iterator begin() const noexcept /* strengthened */ {
+        return _Myptr;
+    }
+
+    _NODISCARD iterator end() noexcept /* strengthened */ {
+        return _Myptr + _Mysize;
+    }
+
+    _NODISCARD const_iterator end() const noexcept /* strengthened */ {
+        return _Myptr + _Mysize;
+    }
+
+    _NODISCARD const _Ty& operator[](size_t _Off) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VALARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off < _Mysize, "valarray subscript out of range");
+#endif
+
+        return _Myptr[_Off];
+    }
+
+    _NODISCARD _Ty& operator[](size_t _Off) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VALARRAY || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off < _Mysize, "valarray subscript out of range");
+#endif
+
+        return _Myptr[_Off];
+    }
+
+    _NODISCARD valarray operator[](slice _Slicearr) const; // defined below
+
+    _NODISCARD slice_array<_Ty> operator[](slice _Slicearr) noexcept /* strengthened */; // defined below
+
+    _NODISCARD valarray operator[](const gslice& _Gslicearr) const; // defined below
+
+    _NODISCARD gslice_array<_Ty> operator[](const gslice& _Gslicearr); // defined below
+
+    _NODISCARD valarray operator[](const _Boolarray& _Boolarr) const; // defined below
+
+    _NODISCARD mask_array<_Ty> operator[](const _Boolarray& _Boolarr); // defined below
+
+    _NODISCARD valarray operator[](const _Sizarray& _Indarr) const; // defined below
+
+    _NODISCARD indirect_array<_Ty> operator[](const _Sizarray& _Indarr); // defined below
+
+    _NODISCARD _Ty sum() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        _Ty _Sum           = _Myptr[0];
+        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+            _Sum += _Myptr[_Idx];
+        }
+
+        return _Sum;
+    }
+
+    _NODISCARD _Ty(min)() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        _Ty _Min           = _Myptr[0];
+        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+            if (_Myptr[_Idx] < _Min) {
+                _Min = _Myptr[_Idx];
+            }
+        }
+
+        return _Min;
+    }
+
+    _NODISCARD _Ty(max)() const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        _Ty _Max           = _Myptr[0];
+        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+            if (_Max < _Myptr[_Idx]) {
+                _Max = _Myptr[_Idx];
+            }
+        }
+
+        return _Max;
+    }
+
+    _NODISCARD valarray shift(int _Count) const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        size_t _Min = 0;
+        size_t _Max = _Size;
+        if (_Count < 0) {
+            const size_t _Skip = static_cast<size_t>(-_Count);
+            _Min += _Skip;
+        } else {
+            const size_t _Skip = static_cast<size_t>(_Count);
+            if (_Skip < _Size) {
+                _Max -= _Skip;
+            } else {
+                _Max = 0;
+            }
+        }
+        for (size_t _Idx = _Min; _Idx < _Max; ++_Idx) {
+            _Ans[_Idx] = _Myptr[_Idx + _Count];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray cshift(int _Count) const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        if (_Size != 0) {
+            if (_Count < 0) { // right shift
+                if (_Size < size_t{0} - _Count) {
+                    _Count = static_cast<int>(_Size - (size_t{0} - _Count - _Size) % _Size);
+                } else {
+                    _Count = static_cast<int>(_Size + _Count);
+                }
+            } else if (_Size <= static_cast<size_t>(_Count)) {
+                _Count %= _Size;
+            }
+        }
+
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] =
+                _Size - _Idx <= static_cast<size_t>(_Count) ? _Myptr[_Idx - _Size + _Count] : _Myptr[_Idx + _Count];
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray apply(_Ty _Func(_Ty)) const {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = _Func(_Myptr[_Idx]);
+        }
+        return _Ans;
+    }
+
+    _NODISCARD valarray apply(_Ty _Func(const _Ty&)) const {
+        // return valarray transformed by _Func, nonmutable argument
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        valarray<_Ty> _Ans(_Size);
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans[_Idx] = _Func(_Myptr[_Idx]);
+        }
+        return _Ans;
+    }
+
+private:
+    void _Grow(size_t _Newsize) { // allocate space for _Count elements and fill with default values
+        if (0 < _Newsize) { // worth doing, allocate
+            _Myptr = _Allocate_for_op_delete<_Ty>(_Newsize);
+            _Tidy_deallocate_guard<valarray> _Guard{this};
+            for (size_t _Idx = 0; _Idx < _Newsize; ++_Idx) {
+                _STD _Construct_in_place(_Myptr[_Idx]);
+            }
+
+            _Guard._Target = nullptr;
+            _Mysize        = _Newsize;
+        }
+    }
+
+    void _Grow(size_t _Newsize, const _Ty* _Ptr, size_t _Inc = 0) {
+        // allocate space for _Count elements and fill with *_Ptr
+        if (0 < _Newsize) { // worth doing, allocate
+            _Myptr = _Allocate_for_op_delete<_Ty>(_Newsize);
+            _Tidy_deallocate_guard<valarray> _Guard{this};
+            for (size_t _Idx = 0; _Idx < _Newsize; ++_Idx, _Ptr += _Inc) {
+                _STD _Construct_in_place(_Myptr[_Idx], *_Ptr);
+            }
+
+            _Guard._Target = nullptr;
+            _Mysize        = _Newsize;
+        }
+    }
+
+    void _Tidy_deallocate() noexcept {
+        if (_Myptr) { // destroy elements
+            _STD _Destroy_range(_Myptr, _Myptr + _Mysize);
+#ifdef __cpp_aligned_new
+            constexpr bool _Extended_alignment = alignof(_Ty) > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
+            if constexpr (_Extended_alignment) {
+                ::operator delete(static_cast<void*>(_Myptr), align_val_t{alignof(_Ty)});
+            } else
+#endif // defined(__cpp_aligned_new)
+            {
+                ::operator delete(static_cast<void*>(_Myptr));
+            }
+        }
+
+        _Mysize = 0;
+        _Myptr  = nullptr;
+    }
+
+    void _Assign(size_t _Newsize, const _Ty* _Ptr) {
+        const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+        if (_Size == _Newsize) {
+            for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+                _Myptr[_Idx] = _Ptr[_Idx];
+            }
+        } else { // resize and copy
+            _Tidy_deallocate();
+            _Grow(_Newsize, _Ptr, 1);
+        }
+    }
+
+    _Ty* _Myptr    = nullptr; // current storage reserved for array
+    size_t _Mysize = 0; // current length of sequence
+};
+
+#if _HAS_CXX17
+template <class _Ty, size_t _Nx>
+valarray(const _Ty (&)[_Nx], size_t) -> valarray<_Ty>;
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty>
+void swap(valarray<_Ty>& _Left, valarray<_Ty>& _Right) noexcept {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] * _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator*(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left * _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator/(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] / _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator/(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left / _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator%(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] % _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator%(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left % _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator+(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] + _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator+(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left + _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator-(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] - _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator-(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left - _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator^(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] ^ _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator^(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left ^ _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator&(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] & _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator&(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left & _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator|(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] | _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator|(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left | _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] << _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator<<(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left << _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] >> _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator>>(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left >> _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator&&(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] && _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator&&(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left && _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator||(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] || _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator||(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left || _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] * _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator/(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] / _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator%(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] % _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator+(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] + _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator-(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] - _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator^(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] ^ _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator&(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] & _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator|(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] | _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] << _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] >> _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator&&(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] && _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator||(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] || _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator==(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] == _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator==(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left == _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator==(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] == _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator!=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] != _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator!=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left != _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator!=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] != _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] < _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left < _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] < _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] > _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left > _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] > _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] <= _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left <= _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator<=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] <= _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] >= _Right;
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left >= _Right[_Idx];
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD _Boolarray operator>=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _STL_VERIFY(_Left.size() == _Right.size(), "valarrays of different lengths");
+#endif
+    const size_t _Size = _Left.size();
+    valarray<bool> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = _Left[_Idx] >= _Right[_Idx];
+    }
+    return _Ans;
+}
+
+// [valarray.transcend] Transcendentals
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> abs(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = abs(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> acos(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = acos(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> asin(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = asin(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> atan(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = atan(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> atan2(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = atan2(_Left[_Idx], _Right[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> atan2(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = atan2(_Left[_Idx], _Right); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> atan2(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = atan2(_Left, _Right[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> cos(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = cos(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> cosh(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = cosh(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> exp(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = exp(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> log(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = log(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> log10(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = log10(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> pow(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = pow(_Left[_Idx], _Right[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> pow(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = pow(_Left[_Idx], _Right); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> pow(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
+    const size_t _Size = _Right.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = pow(_Left, _Right[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> sin(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = sin(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> sinh(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = sinh(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> sqrt(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = sqrt(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> tan(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = tan(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD valarray<_Ty> tanh(const valarray<_Ty>& _Left) {
+    const size_t _Size = _Left.size();
+    valarray<_Ty> _Ans(_Size);
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Ans[_Idx] = tanh(_Left[_Idx]); // intentional ADL, N4950 [valarray.transcend]/1
+    }
+    return _Ans;
+}
+
+_EXPORT_STD class slice { // define a slice of a valarray
+public:
+    slice() = default;
+
+    slice(size_t _Off, size_t _Count, size_t _Inc) noexcept // strengthened
+        : _Start(_Off), _Len(_Count), _Stride(_Inc) {}
+
+    _NODISCARD size_t start() const noexcept /* strengthened */ {
+        return _Start;
+    }
+
+    _NODISCARD size_t size() const noexcept /* strengthened */ {
+        return _Len;
+    }
+
+    _NODISCARD size_t stride() const noexcept /* strengthened */ {
+        return _Stride;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend bool operator==(const slice& _Left, const slice& _Right) noexcept /* strengthened */ {
+        return _Left.start() == _Right.start() && _Left.size() == _Right.size() && _Left.stride() == _Right.stride();
+    }
+#endif // _HAS_CXX20
+
+protected:
+    size_t _Start  = 0; // the starting offset
+    size_t _Len    = 0; // the number of elements
+    size_t _Stride = 0; // the distance between elements
+};
+
+_EXPORT_STD template <class _Ty>
+class slice_array : public slice { // define a slice of a valarray
+public:
+    using value_type = _Ty;
+
+    void operator=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] = _Right[_Idx];
+        }
+    }
+
+    void operator=(const _Ty& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] = _Right;
+        }
+    }
+
+    void operator*=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] *= _Right[_Idx];
+        }
+    }
+
+    void operator/=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] /= _Right[_Idx];
+        }
+    }
+
+    void operator%=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] %= _Right[_Idx];
+        }
+    }
+
+    void operator+=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] += _Right[_Idx];
+        }
+    }
+
+    void operator-=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] -= _Right[_Idx];
+        }
+    }
+
+    void operator^=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] ^= _Right[_Idx];
+        }
+    }
+
+    void operator&=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] &= _Right[_Idx];
+        }
+    }
+
+    void operator|=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] |= _Right[_Idx];
+        }
+    }
+
+    void operator<<=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] <<= _Right[_Idx];
+        }
+    }
+
+    void operator>>=(const valarray<_Ty>& _Right) const {
+        size_t _Off = _Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
+            _Myptr[_Off] >>= _Right[_Idx];
+        }
+    }
+
+    _Ty& _Data(size_t _Idx) const noexcept {
+        return _Myptr[_Idx];
+    }
+
+    slice_array() = delete;
+
+    slice_array(const slice_array&) = default;
+
+    const slice_array& operator=(const slice_array& _Right) const noexcept /* strengthened */ {
+        size_t _Dst_off = _Start;
+        size_t _Src_off = _Right._Start;
+        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Dst_off += _Stride, _Src_off += _Right._Stride) {
+            _Myptr[_Dst_off] = _Right._Myptr[_Src_off];
+        }
+        return *this;
+    }
+
+private:
+    friend valarray<_Ty>;
+
+    slice_array(const slice& _Slice, _Ty* _Pdata) noexcept : slice(_Slice), _Myptr(_Pdata) {}
+
+    _Ty* _Myptr; // pointer to valarray contents
+};
+
+_EXPORT_STD class gslice { // define a generalized (multidimensional) slice of a valarray
+public:
+    gslice() = default; // construct with all zeros
+
+    gslice(size_t _Off, const _Sizarray& _Lenarr, const _Sizarray& _Incarr)
+        : _Start(_Off), _Len(_Lenarr), _Stride(_Incarr) {}
+
+    _NODISCARD size_t start() const noexcept /* strengthened */ {
+        return _Start;
+    }
+
+    _NODISCARD _Sizarray size() const {
+        return _Len;
+    }
+
+    _NODISCARD _Sizarray stride() const {
+        return _Stride;
+    }
+
+    size_t _Nslice() const noexcept {
+        return _Len.size();
+    }
+
+    size_t _Off(_Sizarray& _Indexarr) const noexcept {
+        size_t _Idx;
+        size_t _Ans        = _Start;
+        const size_t _Size = _Indexarr.size();
+        for (_Idx = 0; _Idx < _Size; ++_Idx) {
+            _Ans += _Indexarr[_Idx] * _Stride[_Idx]; // compute offset
+        }
+
+        while (0 < _Idx) {
+            --_Idx;
+            if (++_Indexarr[_Idx] < _Len[_Idx]) {
+                break; // increment done, quit
+            } else {
+                _Indexarr[_Idx] = 0; // carry to more-significant index
+            }
+        }
+
+        return _Ans;
+    }
+
+    _NODISCARD size_t _Totlen() const noexcept {
+        const size_t _Size = _Len.size();
+        if (_Size == 0) {
+            return 0;
+        }
+
+        size_t _Count = _Len[0];
+        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
+            _Count *= _Len[_Idx];
+        }
+
+        return _Count;
+    }
+
+private:
+    size_t _Start = 0; // the starting offset
+    _Sizarray _Len; // array of numbers of elements
+    _Sizarray _Stride; // array of distances between elements
+};
+
+_EXPORT_STD template <class _Ty>
+class gslice_array : public gslice { // define a generalized slice of a valarray
+public:
+    using value_type = _Ty;
+
+    void operator=(const valarray<_Ty>& _Right) const {
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] = _Right[_Idx];
+        }
+    }
+
+    void operator=(const _Ty& _Right) const {
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] = _Right;
+        }
+    }
+
+    void operator*=(const valarray<_Ty>& _Right) const { // multiply generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] *= _Right[_Idx];
+        }
+    }
+
+    void operator/=(const valarray<_Ty>& _Right) const { // divide generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] /= _Right[_Idx];
+        }
+    }
+
+    void operator%=(const valarray<_Ty>& _Right) const { // remainder generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] %= _Right[_Idx];
+        }
+    }
+
+    void operator+=(const valarray<_Ty>& _Right) const { // add valarray to generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] += _Right[_Idx];
+        }
+    }
+
+    void operator-=(const valarray<_Ty>& _Right) const { // subtract valarray from generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] -= _Right[_Idx];
+        }
+    }
+
+    void operator^=(const valarray<_Ty>& _Right) const { // XOR valarray into generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] ^= _Right[_Idx];
+        }
+    }
+
+    void operator&=(const valarray<_Ty>& _Right) const { // AND valarray into generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] &= _Right[_Idx];
+        }
+    }
+
+    void operator|=(const valarray<_Ty>& _Right) const { // OR valarray into generalized slice
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] |= _Right[_Idx];
+        }
+    }
+
+    void operator<<=(const valarray<_Ty>& _Right) const { // left shift generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] <<= _Right[_Idx];
+        }
+    }
+
+    void operator>>=(const valarray<_Ty>& _Right) const { // right shift generalized slice by valarray
+        _Sizarray _Indexarray(size_t{0}, _Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Indexarray)] >>= _Right[_Idx];
+        }
+    }
+
+    _NODISCARD _Ty& _Data(size_t _Idx) const noexcept {
+        return _Myptr[_Idx];
+    }
+
+    gslice_array() = delete;
+
+    gslice_array(const gslice_array&) = default;
+
+    const gslice_array& operator=(const gslice_array& _Right) const {
+        _Sizarray _Dst_indexarray(size_t{0}, _Nslice());
+        _Sizarray _Src_indexarray(size_t{0}, _Right._Nslice());
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Off(_Dst_indexarray)] = _Right._Myptr[_Right._Off(_Src_indexarray)];
+        }
+        return *this;
+    }
+
+private:
+    friend valarray<_Ty>;
+
+    gslice_array(const gslice& _Gslice, _Ty* _Ptr) : gslice(_Gslice), _Myptr(_Ptr) {}
+
+    _Ty* _Myptr; // pointer to valarray contents
+};
+
+_EXPORT_STD template <class _Ty>
+class mask_array { // define a subset of a valarray with an array of mask bits
+public:
+    using value_type = _Ty;
+
+    void operator=(const valarray<_Ty>& _Right) const {
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] = _Right[_Idx];
+        }
+    }
+
+    void operator=(const _Ty& _Right) const {
+        const size_t _Size = _Mybool.size();
+        for (size_t _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off)) {
+            _Myptr[_Off] = _Right;
+        }
+    }
+
+    void operator*=(const valarray<_Ty>& _Right) const { // multiply masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] *= _Right[_Idx];
+        }
+    }
+
+    void operator/=(const valarray<_Ty>& _Right) const { // divide masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] /= _Right[_Idx];
+        }
+    }
+
+    void operator%=(const valarray<_Ty>& _Right) const { // remainder masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] %= _Right[_Idx];
+        }
+    }
+
+    void operator+=(const valarray<_Ty>& _Right) const { // add valarray to masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] += _Right[_Idx];
+        }
+    }
+
+    void operator-=(const valarray<_Ty>& _Right) const { // subtract valarray from masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] -= _Right[_Idx];
+        }
+    }
+
+    void operator^=(const valarray<_Ty>& _Right) const { // XOR valarray into masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] ^= _Right[_Idx];
+        }
+    }
+
+    void operator&=(const valarray<_Ty>& _Right) const { // OR valarray into masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] &= _Right[_Idx];
+        }
+    }
+
+    void operator|=(const valarray<_Ty>& _Right) const { // OR valarray into masked array
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] |= _Right[_Idx];
+        }
+    }
+
+    void operator<<=(const valarray<_Ty>& _Right) const { // left shift masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] <<= _Right[_Idx];
+        }
+    }
+
+    void operator>>=(const valarray<_Ty>& _Right) const { // right shift masked array by valarray
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
+            _Myptr[_Off] >>= _Right[_Idx];
+        }
+    }
+
+    _NODISCARD _Ty& _Data(size_t _Idx) const noexcept {
+        return _Myptr[_Idx];
+    }
+
+    _NODISCARD bool _Mask(size_t _Idx) const noexcept {
+        return _Mybool[_Idx];
+    }
+
+    _NODISCARD size_t _Start_off() const noexcept {
+        size_t _Off        = 0;
+        const size_t _Size = _Mybool.size();
+        while (_Off < _Size && !_Mybool[_Off]) {
+            ++_Off;
+        }
+        return _Off;
+    }
+
+    _NODISCARD size_t _Next_off(size_t _Off) const noexcept {
+        const size_t _Size = _Mybool.size();
+        do {
+            ++_Off;
+        } while (_Off < _Size && !_Mybool[_Off]);
+        return _Off;
+    }
+
+    _NODISCARD size_t _Totlen() const noexcept {
+        size_t _Count      = 0;
+        const size_t _Size = _Mybool.size();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            if (_Mybool[_Idx]) {
+                ++_Count;
+            }
+        }
+
+        return _Count;
+    }
+
+    mask_array() = delete;
+
+    mask_array(const mask_array&) = default;
+
+    const mask_array& operator=(const mask_array& _Right) const noexcept /* strengthened */ {
+        const size_t _Size = _Mybool.size();
+        size_t _Dst_off    = _Start_off();
+        size_t _Src_off    = _Right._Start_off();
+        for (; _Dst_off < _Size; _Src_off = _Right._Next_off(_Src_off), _Dst_off = _Next_off(_Dst_off)) {
+            _Myptr[_Dst_off] = _Right._Myptr[_Src_off];
+        }
+        return *this;
+    }
+
+private:
+    friend valarray<_Ty>;
+
+    mask_array(const _Boolarray& _Maskarr, _Ty* _Pdata) : _Mybool(_Maskarr), _Myptr(_Pdata) {}
+
+    _Boolarray _Mybool; // array of mask bits
+    _Ty* _Myptr; // pointer to valarray contents
+};
+
+_EXPORT_STD template <class _Ty>
+class indirect_array { // define a subset of a valarray with an array of indexes
+public:
+    using value_type = _Ty;
+
+    void operator=(const valarray<_Ty>& _Right) const {
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] = _Right[_Idx];
+        }
+    }
+
+    void operator=(const _Ty& _Right) const {
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] = _Right;
+        }
+    }
+
+    void operator*=(const valarray<_Ty>& _Right) const { // multiply indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] *= _Right[_Idx];
+        }
+    }
+
+    void operator/=(const valarray<_Ty>& _Right) const { // divide indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] /= _Right[_Idx];
+        }
+    }
+
+    void operator%=(const valarray<_Ty>& _Right) const { // remainder indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] %= _Right[_Idx];
+        }
+    }
+
+    void operator+=(const valarray<_Ty>& _Right) const { // add valarray to indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] += _Right[_Idx];
+        }
+    }
+
+    void operator-=(const valarray<_Ty>& _Right) const { // subtract valarray from indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] -= _Right[_Idx];
+        }
+    }
+
+    void operator^=(const valarray<_Ty>& _Right) const { // XOR valarray into indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] ^= _Right[_Idx];
+        }
+    }
+
+    void operator&=(const valarray<_Ty>& _Right) const { // AND valarray into indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] &= _Right[_Idx];
+        }
+    }
+
+    void operator|=(const valarray<_Ty>& _Right) const { // OR valarray into indirect array
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] |= _Right[_Idx];
+        }
+    }
+
+    void operator<<=(const valarray<_Ty>& _Right) const { // left shift indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] <<= _Right[_Idx];
+        }
+    }
+
+    void operator>>=(const valarray<_Ty>& _Right) const { // right shift indirect array by valarray
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] >>= _Right[_Idx];
+        }
+    }
+
+    _NODISCARD _Ty& _Data(size_t _Idx) const noexcept {
+        return _Myptr[_Idx];
+    }
+
+    _NODISCARD size_t _Indir(size_t _Idx) const noexcept {
+        return _Myindarr[_Idx];
+    }
+
+    _NODISCARD size_t _Totlen() const noexcept {
+        return _Myindarr.size();
+    }
+
+    indirect_array() = delete;
+
+    indirect_array(const indirect_array&) = default;
+
+    const indirect_array& operator=(const indirect_array& _Right) const noexcept /* strengthened */ {
+        const size_t _Size = _Totlen();
+        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+            _Myptr[_Indir(_Idx)] = _Right._Myptr[_Right._Indir(_Idx)];
+        }
+        return *this;
+    }
+
+private:
+    friend valarray<_Ty>;
+
+    indirect_array(const _Sizarray& _Indarr, _Ty* _Ptr) : _Myindarr(_Indarr), _Myptr(_Ptr) {}
+
+    _Sizarray _Myindarr; // array of indirect indexes
+    _Ty* _Myptr; // pointer to valarray contents
+};
+
+template <class _Ty>
+valarray<_Ty>& valarray<_Ty>::operator=(const slice_array<_Ty>& _Slicearr) {
+    _Tidy_deallocate();
+    _Grow(_Slicearr.size(), _STD addressof(_Slicearr._Data(_Slicearr.start())), _Slicearr.stride());
+    return *this;
+}
+
+template <class _Ty>
+_NODISCARD valarray<_Ty> valarray<_Ty>::operator[](slice _Slice) const {
+    return valarray<_Ty>(slice_array<_Ty>(_Slice, _Myptr));
+}
+
+template <class _Ty>
+_NODISCARD slice_array<_Ty> valarray<_Ty>::operator[](slice _Slice) noexcept /* strengthened */ {
+    return slice_array<_Ty>(_Slice, _Myptr);
+}
+
+template <class _Ty>
+valarray<_Ty>& valarray<_Ty>::operator=(const gslice_array<_Ty>& _Gslicearr) {
+    _Tidy_deallocate();
+    _Grow(_Gslicearr._Totlen());
+    _Sizarray _Indexarray(size_t{0}, _Gslicearr._Nslice());
+    const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Myptr[_Idx] = _Gslicearr._Data(_Gslicearr._Off(_Indexarray));
+    }
+    return *this;
+}
+
+template <class _Ty>
+_NODISCARD valarray<_Ty> valarray<_Ty>::operator[](const gslice& _Gslice) const {
+    return valarray<_Ty>(gslice_array<_Ty>(_Gslice, _Myptr));
+}
+
+template <class _Ty>
+_NODISCARD gslice_array<_Ty> valarray<_Ty>::operator[](const gslice& _Gslicearr) {
+    return gslice_array<_Ty>(_Gslicearr, _Myptr);
+}
+
+template <class _Ty>
+valarray<_Ty>& valarray<_Ty>::operator=(const mask_array<_Ty>& _Maskarr) {
+    _Tidy_deallocate();
+    _Grow(_Maskarr._Totlen());
+    size_t _Count = 0;
+
+    const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+    for (size_t _Idx = 0; _Idx < _Size; ++_Count) {
+        if (_Maskarr._Mask(_Count)) {
+            _Myptr[_Idx++] = _Maskarr._Data(_Count);
+        }
+    }
+
+    return *this;
+}
+
+template <class _Ty>
+_NODISCARD valarray<_Ty> valarray<_Ty>::operator[](const _Boolarray& _Boolarr) const {
+    return valarray<_Ty>(mask_array<_Ty>(_Boolarr, _Myptr));
+}
+
+template <class _Ty>
+_NODISCARD mask_array<_Ty> valarray<_Ty>::operator[](const _Boolarray& _Boolarr) {
+    return mask_array<_Ty>(_Boolarr, _Myptr);
+}
+
+template <class _Ty>
+valarray<_Ty>& valarray<_Ty>::operator=(const indirect_array<_Ty>& _Indarr) {
+    _Tidy_deallocate();
+    _Grow(_Indarr._Totlen());
+    const size_t _Size = _Mysize; // eliminating indirection helps vectorization
+    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
+        _Myptr[_Idx] = _Indarr._Data(_Indarr._Indir(_Idx));
+    }
+    return *this;
+}
+
+template <class _Ty>
+_NODISCARD valarray<_Ty> valarray<_Ty>::operator[](const _Sizarray& _Indarr) const {
+    return valarray<_Ty>(indirect_array<_Ty>(_Indarr, _Myptr));
+}
+
+template <class _Ty>
+_NODISCARD indirect_array<_Ty> valarray<_Ty>::operator[](const _Sizarray& _Indarr) {
+    return indirect_array<_Ty>(_Indarr, _Myptr);
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _VALARRAY_
diff --git a/msvc-stl/stl/inc/variant b/msvc-stl/stl/inc/variant
new file mode 100644
index 0000000..8948643
--- /dev/null
+++ b/msvc-stl/stl/inc/variant
@@ -0,0 +1,1701 @@
+// variant standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _VARIANT_
+#define _VARIANT_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+_EMIT_STL_WARNING(STL4038, "The contents of <variant> are available only with C++17 or later.");
+#else // ^^^ !_HAS_CXX17 / _HAS_CXX17 vvv
+#if _HAS_CXX20
+#include <compare>
+#endif // _HAS_CXX20
+#include <exception>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+#include <xsmf_control.h>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+_STD_BEGIN
+
+template <class...>
+struct _Meta_list; // a sequence of types (not defined)
+
+template <class _List>
+struct _Meta_front_;
+template <class _List>
+using _Meta_front =
+    // extract the first type in a sequence (head of list)
+    typename _Meta_front_<_List>::type;
+
+template <template <class...> class _List, class _First, class... _Rest>
+struct _Meta_front_<_List<_First, _Rest...>> {
+    using type = _First;
+};
+
+template <class _List>
+struct _Meta_pop_front_;
+template <class _List>
+using _Meta_pop_front =
+    // subsequence including all but the first type (tail of list)
+    typename _Meta_pop_front_<_List>::type;
+
+template <template <class...> class _List, class _First, class... _Rest>
+struct _Meta_pop_front_<_List<_First, _Rest...>> {
+    using type = _List<_Rest...>;
+};
+
+template <class _List, class _Ty>
+struct _Meta_push_front_;
+template <class _List, class _Ty>
+using _Meta_push_front =
+    // prepend a new type onto a sequence
+    typename _Meta_push_front_<_List, _Ty>::type;
+
+template <template <class...> class _List, class... _Types, class _Ty>
+struct _Meta_push_front_<_List<_Types...>, _Ty> {
+    using type = _List<_Ty, _Types...>;
+};
+
+template <class _Void, template <class...> class _Fn, class... _Args>
+struct _Meta_quote_helper_;
+template <template <class...> class _Fn, class... _Args>
+struct _Meta_quote_helper_<void_t<_Fn<_Args...>>, _Fn, _Args...> {
+    using type = _Fn<_Args...>;
+};
+template <template <class...> class _Fn>
+struct _Meta_quote { // encapsulate a template into a meta-callable type
+    template <class... _Types>
+    using _Invoke = typename _Meta_quote_helper_<void, _Fn, _Types...>::type;
+};
+
+template <class _Fn, class... _Args>
+using _Meta_invoke = // invoke meta-callable _Fn with _Args
+    typename _Fn::template _Invoke<_Args...>;
+
+template <class _Fn, class... _Args>
+struct _Meta_bind_back { // construct a meta-callable that passes its arguments and _Args to _Fn
+    template <class... _Types>
+    using _Invoke = _Meta_invoke<_Fn, _Types..., _Args...>;
+};
+
+template <class _Fn, class _List>
+struct _Meta_apply_;
+template <class _Fn, class _List>
+using _Meta_apply =
+    // unpack _List into the parameters of meta-callable _Fn
+    typename _Meta_apply_<_Fn, _List>::type;
+
+template <class _Fn, template <class...> class _List, class... _Types>
+struct _Meta_apply_<_Fn, _List<_Types...>> {
+    // invoke meta-callable _Fn with the parameters of a template specialization
+    using type = _Meta_invoke<_Fn, _Types...>;
+};
+
+template <class _Fn, class _Ty, _Ty... _Idxs>
+struct _Meta_apply_<_Fn, integer_sequence<_Ty, _Idxs...>> {
+    // invoke meta-callable _Fn with the elements of an integer_sequence
+    using type = _Meta_invoke<_Fn, integral_constant<_Ty, _Idxs>...>;
+};
+
+template <class _Fn, class _List>
+struct _Meta_transform_;
+template <class _Fn, class _List>
+using _Meta_transform =
+    // transform sequence of _Types... into sequence of _Fn<_Types...>
+    typename _Meta_transform_<_Fn, _List>::type;
+
+template <template <class...> class _List, class _Fn, class... _Types>
+struct _Meta_transform_<_Fn, _List<_Types...>> {
+    using type = _List<_Meta_invoke<_Fn, _Types>...>;
+};
+
+template <class, class, template <class...> class>
+struct _Meta_repeat_n_c_;
+template <size_t _Count, class _Ty, template <class...> class _Continue>
+using _Meta_repeat_n_c =
+    // construct a sequence consisting of repetitions of _Ty
+    typename _Meta_repeat_n_c_<_Ty, make_index_sequence<_Count>, _Continue>::type;
+
+template <class _Ty, size_t>
+using _Meta_repeat_first_helper = _Ty;
+
+template <class _Ty, size_t... _Idxs, template <class...> class _Continue>
+struct _Meta_repeat_n_c_<_Ty, index_sequence<_Idxs...>, _Continue> {
+    using type = _Continue<_Meta_repeat_first_helper<_Ty, _Idxs>...>;
+};
+
+template <class _List, size_t _Idx, class = void>
+struct _Meta_at_;
+template <class _List, size_t _Idx>
+using _Meta_at_c =
+    // Extract the _Idx-th type from _List
+    typename _Meta_at_<_List, _Idx>::type;
+
+#ifdef __clang__
+template <template <class...> class _List, class... _Types, size_t _Idx>
+struct _Meta_at_<_List<_Types...>, _Idx, void_t<__type_pack_element<_Idx, _Types...>>> {
+    using type = __type_pack_element<_Idx, _Types...>;
+};
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+template <class... _VoidPtrs>
+struct _Meta_at_impl {
+    template <class _Ty, class... _Types>
+    static _Ty _Eval(_VoidPtrs..., _Ty*, _Types*...); // undefined
+};
+
+template <class _Ty>
+constexpr _Identity<_Ty>* _Type_as_pointer() {
+    return nullptr;
+}
+
+template <template <class...> class _List, class... _Types, size_t _Idx>
+struct _Meta_at_<_List<_Types...>, _Idx, enable_if_t<(_Idx < sizeof...(_Types))>> {
+    using type =
+        typename decltype(_Meta_repeat_n_c<_Idx, void*, _Meta_at_impl>::_Eval(_Type_as_pointer<_Types>()...))::type;
+};
+#endif // ^^^ !defined(__clang__) ^^^
+
+template <class>
+struct _Meta_as_list_;
+template <class _Ty>
+using _Meta_as_list =
+    // convert _Ty to a _Meta_list
+    typename _Meta_as_list_<_Ty>::type;
+
+template <template <class...> class _List, class... _Types>
+struct _Meta_as_list_<_List<_Types...>> {
+    // convert the parameters of an arbitrary template specialization to a _Meta_list of types
+    using type = _Meta_list<_Types...>;
+};
+
+template <class _Ty, _Ty... _Idxs>
+struct _Meta_as_list_<integer_sequence<_Ty, _Idxs...>> {
+    // convert an integer_sequence to a _Meta_list of integral_constants
+    using type = _Meta_list<integral_constant<_Ty, _Idxs>...>;
+};
+
+template <class _List>
+struct _Meta_as_integer_sequence_;
+template <class _List>
+using _Meta_as_integer_sequence =
+    // convert a list of integral_constants to an integer_sequence
+    typename _Meta_as_integer_sequence_<_List>::type;
+
+template <template <class...> class _List, class _Ty, _Ty... _Idxs>
+struct _Meta_as_integer_sequence_<_List<integral_constant<_Ty, _Idxs>...>> {
+    using type = integer_sequence<_Ty, _Idxs...>;
+};
+
+template <class...>
+struct _Meta_concat_;
+template <class... _Types>
+using _Meta_concat =
+    // merge several lists into one
+    typename _Meta_concat_<_Types...>::type;
+
+template <template <class...> class _List>
+struct _Meta_concat_<_List<>> {
+    using type = _List<>;
+};
+
+template <template <class...> class _List, class... _Items1>
+struct _Meta_concat_<_List<_Items1...>> {
+    using type = _List<_Items1...>;
+};
+
+template <template <class...> class _List, class... _Items1, class... _Items2>
+struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>> {
+    using type = _List<_Items1..., _Items2...>;
+};
+
+template <template <class...> class _List, class... _Items1, class... _Items2, class... _Items3>
+struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>, _List<_Items3...>> {
+    using type = _List<_Items1..., _Items2..., _Items3...>;
+};
+
+template <template <class...> class _List, class... _Items1, class... _Items2, class... _Items3, class... _Rest>
+struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>, _List<_Items3...>, _Rest...> {
+    using type = _Meta_concat<_List<_Items1..., _Items2..., _Items3...>, _Rest...>;
+};
+
+template <class _ListOfLists>
+using _Meta_join =
+    // transform a list of lists of elements into a single list containing those elements
+    _Meta_apply<_Meta_quote<_Meta_concat>, _ListOfLists>;
+
+template <class>
+struct _Meta_cartesian_product_;
+template <class _ListOfLists>
+using _Meta_cartesian_product =
+    // find the n-ary Cartesian Product of the lists in the input list
+    typename _Meta_cartesian_product_<_ListOfLists>::type;
+
+template <template <class...> class _List>
+struct _Meta_cartesian_product_<_List<>> {
+    using type = _List<>;
+};
+
+template <template <class...> class _List1, template <class...> class _List2, class... _Items>
+struct _Meta_cartesian_product_<_List1<_List2<_Items...>>> {
+    using type = _List1<_List2<_Items>...>;
+};
+
+template <template <class...> class _List1, class... _Items, template <class...> class _List2, class... _Lists>
+struct _Meta_cartesian_product_<_List1<_List2<_Items...>, _Lists...>> {
+    using type = _Meta_join<_List1<_Meta_transform<_Meta_bind_back<_Meta_quote<_Meta_push_front>, _Items>,
+        _Meta_cartesian_product<_List1<_Lists...>>>...>>;
+};
+
+#define _STL_STAMP4(n, x) \
+    x(n);                 \
+    x(n + 1);             \
+    x(n + 2);             \
+    x(n + 3)
+#define _STL_STAMP16(n, x) \
+    _STL_STAMP4(n, x);     \
+    _STL_STAMP4(n + 4, x); \
+    _STL_STAMP4(n + 8, x); \
+    _STL_STAMP4(n + 12, x)
+#define _STL_STAMP64(n, x)   \
+    _STL_STAMP16(n, x);      \
+    _STL_STAMP16(n + 16, x); \
+    _STL_STAMP16(n + 32, x); \
+    _STL_STAMP16(n + 48, x)
+#define _STL_STAMP256(n, x)   \
+    _STL_STAMP64(n, x);       \
+    _STL_STAMP64(n + 64, x);  \
+    _STL_STAMP64(n + 128, x); \
+    _STL_STAMP64(n + 192, x)
+
+#define _STL_STAMP(n, x) x(_STL_STAMP##n, n)
+
+_EXPORT_STD template <class... _Types>
+class _NO_SPECIALIZATIONS_CITING("N5014 [variant.variant.general]/4") variant;
+
+_EXPORT_STD template <class _Ty>
+struct variant_size; // undefined
+template <class _Ty>
+struct variant_size<const _Ty> : variant_size<_Ty>::type {};
+template <class _Ty>
+struct _CXX20_DEPRECATE_VOLATILE variant_size<volatile _Ty> : variant_size<_Ty>::type {};
+template <class _Ty>
+struct _CXX20_DEPRECATE_VOLATILE variant_size<const volatile _Ty> : variant_size<_Ty>::type {};
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr size_t variant_size_v = variant_size<_Ty>::value;
+
+template <class... _Types>
+struct variant_size<variant<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {};
+
+_EXPORT_STD template <size_t _Idx, class _Ty>
+struct variant_alternative; // undefined
+_EXPORT_STD template <size_t _Idx, class _Ty>
+using variant_alternative_t = typename variant_alternative<_Idx, _Ty>::type;
+template <size_t _Idx, class _Ty>
+struct variant_alternative<_Idx, const _Ty> {
+    using type = add_const_t<variant_alternative_t<_Idx, _Ty>>;
+};
+template <size_t _Idx, class _Ty>
+struct _CXX20_DEPRECATE_VOLATILE variant_alternative<_Idx, volatile _Ty> {
+    using type = add_volatile_t<variant_alternative_t<_Idx, _Ty>>;
+};
+template <size_t _Idx, class _Ty>
+struct _CXX20_DEPRECATE_VOLATILE variant_alternative<_Idx, const volatile _Ty> {
+    using type = add_cv_t<variant_alternative_t<_Idx, _Ty>>;
+};
+template <size_t _Idx, class... _Types>
+struct variant_alternative<_Idx, variant<_Types...>> {
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+
+#ifdef __clang__
+    using type = __type_pack_element<_Idx, _Types...>;
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+    using type = _Meta_at_c<variant<_Types...>, _Idx>;
+#endif // ^^^ !defined(__clang__) ^^^
+};
+
+_EXPORT_STD inline constexpr size_t variant_npos = _Meta_npos;
+
+template <bool _TrivialDestruction, class... _Types>
+class _Variant_storage_ {}; // empty storage (empty "_Types" case)
+
+template <class... _Types>
+using _Variant_storage = _Variant_storage_<conjunction_v<is_trivially_destructible<_Types>...>, _Types...>;
+
+template <class _First, class... _Rest>
+class _Variant_storage_<true, _First, _Rest...> { // Storage for variant alternatives (trivially destructible case)
+public:
+    static constexpr size_t _Size = 1 + sizeof...(_Rest);
+    union {
+        remove_cv_t<_First> _Head;
+        _Variant_storage<_Rest...> _Tail;
+    };
+
+    _CONSTEXPR20 _Variant_storage_() noexcept {} // no initialization (no active member)
+
+    template <class... _Types>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_First, _Types...>)
+        : _Head(static_cast<_Types&&>(_Args)...) {} // initialize _Head with _Args...
+
+    template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
+        : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} // initialize _Tail (recurse)
+
+    _NODISCARD constexpr _First& _Get() & noexcept {
+        return _Head;
+    }
+    _NODISCARD constexpr const _First& _Get() const& noexcept {
+        return _Head;
+    }
+    _NODISCARD constexpr _First&& _Get() && noexcept {
+        return _STD move(_Head);
+    }
+    _NODISCARD constexpr const _First&& _Get() const&& noexcept {
+        return _STD move(_Head);
+    }
+};
+
+template <class _First, class... _Rest>
+class _Variant_storage_<false, _First, _Rest...> { // Storage for variant alternatives (non-trivially destructible case)
+public:
+    static constexpr size_t _Size = 1 + sizeof...(_Rest);
+    union {
+        remove_cv_t<_First> _Head;
+        _Variant_storage<_Rest...> _Tail;
+    };
+
+    _CONSTEXPR20 ~_Variant_storage_()
+#ifndef __clang__ // TRANSITION, LLVM-59854
+        noexcept
+#endif // ^^^ no workaround ^^^
+    {
+        // explicitly non-trivial destructor (which would otherwise be defined as deleted
+        // since the class has a variant member with a non-trivial destructor)
+    }
+
+    _CONSTEXPR20 _Variant_storage_() noexcept {} // no initialization (no active member)
+
+    template <class... _Types>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_First, _Types...>)
+        : _Head(static_cast<_Types&&>(_Args)...) {} // initialize _Head with _Args...
+
+    template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
+        : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} // initialize _Tail (recurse)
+
+    _Variant_storage_(_Variant_storage_&&)                 = default;
+    _Variant_storage_(const _Variant_storage_&)            = default;
+    _Variant_storage_& operator=(_Variant_storage_&&)      = default;
+    _Variant_storage_& operator=(const _Variant_storage_&) = default;
+
+    _NODISCARD constexpr _First& _Get() & noexcept {
+        return _Head;
+    }
+    _NODISCARD constexpr const _First& _Get() const& noexcept {
+        return _Head;
+    }
+    _NODISCARD constexpr _First&& _Get() && noexcept {
+        return _STD move(_Head);
+    }
+    _NODISCARD constexpr const _First&& _Get() const&& noexcept {
+        return _STD move(_Head);
+    }
+};
+
+#ifdef __cplusplus_winrt // TRANSITION, VSO-586813
+// C++/CX is unable to store hats in unions. We instead store them inside a
+// wrapper to enable minimal hats-in-variants support.
+template <class _Ty>
+struct _Variant_item {
+    remove_cv_t<_Ty> _Item;
+
+    template <class... _Types>
+    constexpr _Variant_item(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>)
+        : _Item(static_cast<_Types&&>(_Args)...) {}
+};
+
+template <class _First, class... _Rest>
+class _Variant_storage_<false, _First ^, _Rest...> { // Storage for variant alternatives (^ case)
+public:
+    static constexpr size_t _Size = 1 + sizeof...(_Rest);
+    union {
+        _Variant_item<_First ^> _Head;
+        _Variant_storage<_Rest...> _Tail;
+    };
+
+    _CONSTEXPR20 ~_Variant_storage_() noexcept {
+        // explicitly non-trivial destructor (which would otherwise be defined as deleted
+        // since the class has a variant member with a non-trivial destructor)
+    }
+
+    _CONSTEXPR20 _Variant_storage_() noexcept {} // no initialization (no active member)
+
+    template <class... _Types>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_First ^, _Types...>)
+        : _Head(static_cast<_Types&&>(_Args)...) {} // initialize _Head with _Args...
+
+    template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
+    constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
+        : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} // initialize _Tail (recurse)
+
+    _Variant_storage_(_Variant_storage_&&)                 = default;
+    _Variant_storage_(const _Variant_storage_&)            = default;
+    _Variant_storage_& operator=(_Variant_storage_&&)      = default;
+    _Variant_storage_& operator=(const _Variant_storage_&) = default;
+
+    _NODISCARD constexpr _First ^ &_Get() & noexcept {
+        return _Head._Item;
+    }
+    _NODISCARD constexpr _First ^ const& _Get() const& noexcept {
+        return _Head._Item;
+    }
+    _NODISCARD constexpr _First ^ &&_Get() && noexcept {
+        return _STD move(_Head)._Item;
+    }
+    _NODISCARD constexpr _First ^ const&& _Get() const&& noexcept {
+        return _STD move(_Head)._Item;
+    }
+};
+#endif // ^^^ workaround ^^^
+
+template <size_t _Idx, class _Storage>
+_NODISCARD constexpr decltype(auto) _Variant_raw_get(_Storage&& _Obj) noexcept {
+    // access the _Idx-th element of a _Variant_storage
+    if constexpr (_Idx == 0) {
+        return static_cast<_Storage&&>(_Obj)._Get();
+    } else if constexpr (_Idx == 1) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Get();
+    } else if constexpr (_Idx == 2) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Get();
+    } else if constexpr (_Idx == 3) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx == 4) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx == 5) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx == 6) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx == 7) {
+        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Get();
+    } else if constexpr (_Idx < 16) {
+        return _STD _Variant_raw_get<_Idx - 8>(
+            static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
+    } else if constexpr (_Idx < 32) {
+        return _STD _Variant_raw_get<_Idx - 16>(static_cast<_Storage&&>(_Obj)
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
+    } else if constexpr (_Idx < 64) {
+        return _STD _Variant_raw_get<_Idx - 32>(static_cast<_Storage&&>(_Obj)
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
+    } else { // _Idx >= 64
+        return _STD _Variant_raw_get<_Idx - 64>(static_cast<_Storage&&>(_Obj)
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
+                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
+    }
+}
+
+template <class _Ty, size_t _Tag>
+struct _Tagged { // aggregate a runtime value and a compile-time tag value
+    static constexpr size_t _Idx = _Tag;
+    _Ty _Val;
+};
+
+template <class _Storage, size_t _Idx>
+using _Variant_tagged_ref_t = _Tagged<decltype(_STD _Variant_raw_get<_Idx>(_STD declval<_Storage>()))&&, _Idx>;
+
+template <class _Fn, class _Storage>
+using _Variant_raw_visit_t = decltype(_STD declval<_Fn>()(_STD declval<_Variant_tagged_ref_t<_Storage, 0>>()));
+
+template <size_t _Idx, class _Fn, class _Storage>
+_NODISCARD constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit_dispatch(_Fn&& _Func, _Storage&& _Var)
+    noexcept(is_nothrow_invocable_v<_Fn, _Variant_tagged_ref_t<_Storage, _Idx>>) {
+    // call _Func with the _Idx-th element in _Storage (tagged with _Idx)
+    return static_cast<_Fn&&>(_Func)(
+        _Variant_tagged_ref_t<_Storage, _Idx>{_STD _Variant_raw_get<_Idx>(static_cast<_Storage&&>(_Var))});
+}
+
+template <class _Fn, class _Storage>
+_NODISCARD constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit_valueless(_Fn&& _Func, _Storage&& _Obj)
+    noexcept(is_nothrow_invocable_v<_Fn, _Tagged<_Storage&&, variant_npos>>) {
+    // call _Func with _Storage (tagged with variant_npos)
+    return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)});
+}
+
+template <class _Fn, class _Storage, class _Indices = make_index_sequence<remove_reference_t<_Storage>::_Size>>
+constexpr bool _Variant_raw_visit_noexcept = false;
+
+template <class _Fn, class _Storage, size_t... _Idxs>
+constexpr bool _Variant_raw_visit_noexcept<_Fn, _Storage, index_sequence<_Idxs...>> =
+    conjunction_v<is_nothrow_invocable<_Fn, _Tagged<_Storage&&, variant_npos>>,
+        is_nothrow_invocable<_Fn, _Variant_tagged_ref_t<_Storage, _Idxs>>...>;
+
+template <class _Fn, class _Storage,
+    class _Indices = make_index_sequence<remove_reference_t<_Storage>::_Size>>
+struct _Variant_raw_dispatch_table1; // undefined
+
+template <class _Fn, class _Storage, size_t... _Idxs>
+struct _Variant_raw_dispatch_table1<_Fn, _Storage, index_sequence<_Idxs...>> {
+    // map from canonical index to visitation target
+    using _Dispatch_t = _Variant_raw_visit_t<_Fn, _Storage> (*)(_Fn&&, _Storage&&)
+        noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>);
+    static constexpr _Dispatch_t _Array[] = {
+        &_STD _Variant_raw_visit_valueless<_Fn, _Storage>, &_STD _Variant_raw_visit_dispatch<_Idxs, _Fn, _Storage>...};
+};
+
+template <int _Strategy>
+struct _Variant_raw_visit1;
+
+template <>
+struct _Variant_raw_visit1<-1> { // Fallback case for variants too large for any of the following "switch" strategies
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(size_t _Idx, _Fn&& _Func, _Storage&& _Obj)
+        noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with many states
+        constexpr size_t _Size = remove_reference_t<_Storage>::_Size;
+        static_assert(_Size > 256);
+        constexpr auto& _Array = _Variant_raw_dispatch_table1<_Fn, _Storage>::_Array;
+        return _Array[_Idx](static_cast<_Fn&&>(_Func), static_cast<_Storage&&>(_Obj));
+    }
+};
+
+#define _STL_CASE(n)                                                                                              \
+    case (n) + 1:                                                                                                 \
+        if constexpr ((n) < _Size) {                                                                              \
+            return static_cast<_Fn&&>(_Func)(                                                                     \
+                _Variant_tagged_ref_t<_Storage, (n)>{_STD _Variant_raw_get<(n)>(static_cast<_Storage&&>(_Obj))}); \
+        }                                                                                                         \
+        _STL_UNREACHABLE;                                                                                         \
+        [[fallthrough]]
+
+#define _STL_VISIT_STAMP(stamper, n)                                                                        \
+    constexpr size_t _Size = remove_reference_t<_Storage>::_Size;                                           \
+    static_assert(((n) == 4 || _Size > (n) / 4) && _Size <= (n));                                           \
+    switch (_Idx) {                                                                                         \
+    case 0:                                                                                                 \
+        return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)}); \
+                                                                                                            \
+        stamper(0, _STL_CASE);                                                                              \
+    default:                                                                                                \
+        _STL_UNREACHABLE;                                                                                   \
+    }
+
+template <>
+struct _Variant_raw_visit1<1> {
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(size_t _Idx, _Fn&& _Func, _Storage&& _Obj)
+        noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with at most 4^1 states
+        _STL_STAMP(4, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Variant_raw_visit1<2> {
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(size_t _Idx, _Fn&& _Func, _Storage&& _Obj)
+        noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with at most 4^2 states
+        _STL_STAMP(16, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Variant_raw_visit1<3> {
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(size_t _Idx, _Fn&& _Func, _Storage&& _Obj)
+        noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with at most 4^3 states
+        _STL_STAMP(64, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Variant_raw_visit1<4> {
+    template <class _Fn, class _Storage>
+    _NODISCARD static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(size_t _Idx, _Fn&& _Func, _Storage&& _Obj)
+        noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+        // dispatch a visitor for a _Variant_storage with at most 4^4 states
+        _STL_STAMP(256, _STL_VISIT_STAMP);
+    }
+};
+
+#undef _STL_VISIT_STAMP
+#undef _STL_CASE
+
+template <class _Storage, class _Fn>
+_NODISCARD constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit(size_t _Idx, _Storage&& _Obj, _Fn&& _Func)
+    noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
+    // Call _Func with _Storage if _Idx is variant_npos, and otherwise the _Idx-th element in _Storage.
+    // pre: _Idx + 1 <= remove_reference_t<_Storage>::_Size
+    constexpr size_t _Size  = remove_reference_t<_Storage>::_Size;
+    constexpr int _Strategy = _Size <= 4 ? 1 : _Size <= 16 ? 2 : _Size <= 64 ? 3 : _Size <= 256 ? 4 : -1;
+    ++_Idx; // bias index by +1 to map {variant_npos} U [0, _Size) to the contiguous range [0, _Size]
+    return _Variant_raw_visit1<_Strategy>::_Visit(_Idx, static_cast<_Fn&&>(_Func), static_cast<_Storage&&>(_Obj));
+}
+
+template <class...>
+class _Variant_base;
+
+inline constexpr size_t _Schar_max_as_size = static_cast<unsigned char>(-1) / 2;
+inline constexpr size_t _Short_max_as_size = static_cast<unsigned short>(-1) / 2;
+
+template <size_t _Count>
+using _Variant_index_t = // signed so that conversion of -1 to size_t can cheaply sign extend
+    conditional_t<(_Count < _Schar_max_as_size), signed char, conditional_t<(_Count < _Short_max_as_size), short, int>>;
+
+template <class... _Types>
+struct _Variant_construct_visitor { // visitor that constructs the same alternative in a target _Variant_base as is
+                                    // currently active in a source _Variant_base from the source's contained value
+    _Variant_base<_Types...>& _Self;
+
+    template <class _Ty, size_t _Idx>
+    _CONSTEXPR20 void operator()(_Tagged<_Ty, _Idx> _Source) const noexcept(
+        disjunction_v<bool_constant<_Idx == variant_npos>, is_nothrow_constructible<remove_reference_t<_Ty>, _Ty>>) {
+        // initialize _Idx-th item in _Self from _Source
+        _STL_INTERNAL_CHECK(_Self.valueless_by_exception());
+        if constexpr (_Idx != variant_npos) {
+            _STD _Construct_in_place(
+                _Self._Storage(), integral_constant<size_t, _Idx>{}, static_cast<_Ty&&>(_Source._Val));
+            _Self._Set_index(_Idx);
+        }
+    }
+};
+
+template <class _Target, class... _Types>
+constexpr bool _Variant_should_directly_construct_v =
+    disjunction_v<is_nothrow_constructible<_Target, _Types...>, negation<is_nothrow_move_constructible<_Target>>>;
+
+template <class... _Types>
+struct _Variant_assign_visitor { // visitor that implements assignment for variants with non-trivial alternatives
+    _Variant_base<_Types...>& _Self;
+
+    template <class _Ty, size_t _Idx>
+    _CONSTEXPR20 void operator()(_Tagged<_Ty, _Idx> _Source) const
+        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
+            conjunction<is_nothrow_assignable<_Remove_cvref_t<_Ty>&, _Ty>,
+                is_nothrow_constructible<_Remove_cvref_t<_Ty>, _Ty>>>) {
+        // assign the _Idx-th alternative of _Self from _Source
+        if constexpr (_Idx == variant_npos) { // assign from valueless _Source
+            _Self._Reset();
+        } else {
+            if (_Self._Which == _Idx) { // same alternative: assign directly
+                auto& _Target = _STD _Variant_raw_get<_Idx>(_Self._Storage());
+                _Target       = static_cast<_Ty&&>(_Source._Val);
+            } else { // different alternative
+                if constexpr (is_lvalue_reference_v<_Ty>) { // RHS is an lvalue: copy
+                    if constexpr (_Variant_should_directly_construct_v<_Remove_cvref_t<_Ty>, _Ty>) {
+                        // copy is nothrow or move throws; construct in place
+                        _Self._Reset();
+                        _STD _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, _Source._Val);
+                    } else { // copy throws and move does not; move from a temporary copy
+                        auto _Temp(_Source._Val);
+                        _Self._Reset();
+                        _STD _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, _STD move(_Temp));
+                    }
+                } else { // RHS is an rvalue: move
+                    _Self._Reset();
+                    _STD _Construct_in_place(
+                        _Self._Storage(), integral_constant<size_t, _Idx>{}, static_cast<_Ty&&>(_Source._Val));
+                }
+
+                _Self._Set_index(_Idx);
+            }
+        }
+    }
+};
+
+template <class... _Types> // Associate an integral discriminator with a _Variant_storage
+class _Variant_base : private _Variant_storage<_Types...> {
+public:
+    using _Index_t                       = _Variant_index_t<sizeof...(_Types)>;
+    static constexpr auto _Invalid_index = static_cast<_Index_t>(-1);
+    _Index_t _Which;
+
+    using _Storage_t = _Variant_storage<_Types...>;
+    _NODISCARD constexpr _Storage_t& _Storage() & noexcept { // access this variant's storage
+        return *this;
+    }
+    _NODISCARD constexpr const _Storage_t& _Storage() const& noexcept { // access this variant's storage
+        return *this;
+    }
+    _NODISCARD constexpr _Storage_t&& _Storage() && noexcept { // access this variant's storage
+        return _STD move(*this);
+    }
+    _NODISCARD constexpr const _Storage_t&& _Storage() const&& noexcept { // access this variant's storage
+        return _STD move(*this);
+    }
+
+    // initialize to the value-less state
+    _CONSTEXPR20 _Variant_base() noexcept : _Storage_t{}, _Which{_Invalid_index} {}
+
+    template <size_t _Idx, class... _UTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant<_Types...>, _Idx>, _UTypes...>, int> = 0>
+    constexpr explicit _Variant_base(in_place_index_t<_Idx>, _UTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Meta_at_c<variant<_Types...>, _Idx>, _UTypes...>)
+        : _Storage_t(integral_constant<size_t, _Idx>{}, static_cast<_UTypes&&>(_Args)...),
+          _Which{static_cast<_Index_t>(_Idx)} { // initialize alternative _Idx from _Args...
+    }
+
+    // For the trivially destructible case, we can't add a destructor for _MSVC_STL_DESTRUCTOR_TOMBSTONES, due to
+    // N5001 [variant.dtor]/2: "Remarks: If is_trivially_destructible_v<Ti> is true for all Ti,
+    // then this destructor is trivial."
+
+    _NODISCARD constexpr bool valueless_by_exception() const noexcept { // does this variant NOT hold a value?
+        return _Which < 0;
+    }
+    _NODISCARD constexpr size_t index() const noexcept {
+        // index of the contained alternative or variant_npos if valueless_by_exception
+        return static_cast<size_t>(_Which);
+    }
+    _CONSTEXPR20 void _Set_index(const size_t _Idx) noexcept {
+        // record _Idx as the active alternative
+        // pre: the active alternative of *this is _Idx
+        _Which = static_cast<_Index_t>(_Idx);
+    }
+
+    template <size_t _Idx>
+    _CONSTEXPR20 void _Destroy() noexcept {
+        // destroy the contained value
+        // pre: _Idx == index()
+        using _Indexed_value_type = remove_cv_t<_Meta_at_c<variant<_Types...>, _Idx>>;
+        if constexpr (_Idx != variant_npos && !is_trivially_destructible_v<_Indexed_value_type>) {
+            _STD _Variant_raw_get<_Idx>(_Storage()).~_Indexed_value_type();
+        }
+    }
+
+    _CONSTEXPR20 void _Destroy() noexcept { // destroy the contained value, if any
+        if constexpr (!conjunction_v<is_trivially_destructible<_Types>...>) {
+            _STD _Variant_raw_visit(index(), _Storage(), [](auto _Ref) static noexcept {
+                if constexpr (decltype(_Ref)::_Idx != variant_npos) {
+                    using _Indexed_value_type = _Remove_cvref_t<decltype(_Ref._Val)>;
+                    _Ref._Val.~_Indexed_value_type();
+                }
+            });
+        }
+    }
+
+    _CONSTEXPR20 void _Reset() noexcept { // transition to the valueless_by_exception state
+        _Destroy();
+        _Set_index(variant_npos);
+    }
+
+    template <size_t _Idx>
+    _CONSTEXPR20 void _Reset() noexcept {
+        // transition to the valueless_by_exception state
+        // pre: _Idx == index()
+        if constexpr (_Idx != variant_npos) {
+            _Destroy<_Idx>();
+            _Set_index(variant_npos);
+        }
+    }
+
+    _CONSTEXPR20 void _Construct_from(const _Variant_base& _That)
+        noexcept(conjunction_v<is_nothrow_copy_constructible<_Types>...>) {
+        // copy _That's contained value into *this
+        // pre: valueless_by_exception()
+        _STD _Variant_raw_visit(_That.index(), _That._Storage(), _Variant_construct_visitor<_Types...>{*this});
+    }
+
+    _CONSTEXPR20 void _Construct_from(_Variant_base&& _That)
+        noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...>) {
+        // move _That's contained value into *this
+        // pre: valueless_by_exception()
+        _STD _Variant_raw_visit(
+            _That.index(), _STD move(_That)._Storage(), _Variant_construct_visitor<_Types...>{*this});
+    }
+
+    _CONSTEXPR20 void _Assign_from(const _Variant_base& _That)
+        noexcept(conjunction_v<is_nothrow_copy_constructible<_Types>..., is_nothrow_copy_assignable<_Types>...>) {
+        // copy assign _That's contained value (if any) into *this
+        _STD _Variant_raw_visit(_That.index(), _That._Storage(), _Variant_assign_visitor<_Types...>{*this});
+    }
+
+    _CONSTEXPR20 void _Assign_from(_Variant_base&& _That)
+        noexcept(conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_move_assignable<_Types>...>) {
+        // move assign _That's contained value (if any) into *this
+        _STD _Variant_raw_visit(_That.index(), _STD move(_That)._Storage(), _Variant_assign_visitor<_Types...>{*this});
+    }
+};
+
+template <class... _Types>
+struct _Variant_destroy_layer_ : _Variant_base<_Types...> { // destruction behavior facade (non-trivial case)
+    using _Variant_base<_Types...>::_Variant_base;
+
+    _CONSTEXPR20 ~_Variant_destroy_layer_() noexcept { // Destroy contained value, if any
+        this->_Destroy();
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        // For the non-trivially destructible case, we can set the variant to be valueless.
+        // We don't attempt to scribble over the bytes of the object's storage because that could be expensive
+        // and we don't know whether the object has an invalid representation, much less what it could be.
+        this->_Set_index(variant_npos);
+#endif
+    }
+
+    _Variant_destroy_layer_()                                          = default;
+    _Variant_destroy_layer_(const _Variant_destroy_layer_&)            = default;
+    _Variant_destroy_layer_(_Variant_destroy_layer_&&)                 = default;
+    _Variant_destroy_layer_& operator=(const _Variant_destroy_layer_&) = default;
+    _Variant_destroy_layer_& operator=(_Variant_destroy_layer_&&)      = default;
+};
+
+template <class... _Types>
+using _Variant_destroy_layer = conditional_t<conjunction_v<is_trivially_destructible<_Types>...>,
+    _Variant_base<_Types...>, _Variant_destroy_layer_<_Types...>>;
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-volatile"
+#else // ^^^ Clang / not Clang vvv
+#pragma warning(push)
+#pragma warning(disable : 4242) // '%s': conversion from '%s' to '%s', possible loss of data
+#pragma warning(disable : 4244) // '%s': conversion from '%s' to '%s', possible loss of data (Yes, duplicated message.)
+#pragma warning(disable : 4365) // '%s': conversion from '%s' to '%s', signed/unsigned mismatch
+#pragma warning(disable : 5215) // '%s' a function parameter with volatile qualified type is deprecated in C++20
+#endif // ^^^ not Clang ^^^
+
+// build Ti x[] = {std::forward<T>(t)};
+template <size_t _Idx, class _TargetType>
+auto _Construct_array(_TargetType (&&)[1]) -> _Meta_list<integral_constant<size_t, _Idx>, _TargetType>;
+
+template <size_t _Idx, class _TargetType, class _InitializerType>
+using _Variant_type_resolver = decltype(_STD _Construct_array<_Idx, _TargetType>({_STD declval<_InitializerType>()}));
+
+template <size_t _Idx, class _TargetType>
+struct _Variant_init_single_overload {
+    template <class _InitializerType>
+    auto operator()(_TargetType, _InitializerType&&) -> _Variant_type_resolver<_Idx, _TargetType, _InitializerType>;
+};
+
+template <class _Indices, class... _Types>
+struct _Variant_init_overload_set_;
+
+template <size_t... _Indices, class... _Types>
+struct _Variant_init_overload_set_<index_sequence<_Indices...>, _Types...>
+    : _Variant_init_single_overload<_Indices, _Types>... {
+    using _Variant_init_single_overload<_Indices, _Types>::operator()...;
+};
+
+template <class... _Types>
+using _Variant_init_overload_set = _Variant_init_overload_set_<index_sequence_for<_Types...>, _Types...>;
+
+template <class _Enable, class _Ty, class... _Types>
+struct _Variant_init_helper {}; // failure case (has no member "type")
+
+template <class _Ty, class... _Types>
+struct _Variant_init_helper<
+    void_t<decltype(_Variant_init_overload_set<_Types...>{}(_STD declval<_Ty>(), _STD declval<_Ty>()))>, _Ty,
+    _Types...> {
+    // perform overload resolution to determine the unique alternative that should be initialized in
+    // variant<_Types...> from an argument expression with type and value category _Ty
+    using type = decltype(_Variant_init_overload_set<_Types...>{}(_STD declval<_Ty>(), _STD declval<_Ty>()));
+};
+
+template <class _Ty, class... _Types> // extract the type from _Variant_init_helper
+using _Variant_init_type = _Meta_front<_Meta_pop_front<typename _Variant_init_helper<void, _Ty, _Types...>::type>>;
+
+template <class _Ty, class... _Types> // extract the index from _Variant_init_helper
+using _Variant_init_index = _Meta_front<typename _Variant_init_helper<void, _Ty, _Types...>::type>;
+#ifdef __clang__
+#pragma clang diagnostic pop
+#else // ^^^ Clang / not Clang vvv
+#pragma warning(pop)
+#endif // ^^^ not Clang ^^^
+
+template <class>
+constexpr bool _Is_in_place_index_specialization = false;
+template <size_t _Idx>
+constexpr bool _Is_in_place_index_specialization<in_place_index_t<_Idx>> = true;
+
+_EXPORT_STD template <class... _Types>
+class _NO_SPECIALIZATIONS_CITING("N5014 [variant.variant.general]/4") variant
+    : private _SMF_control<_Variant_destroy_layer<_Types...>, _Types...> { // discriminated union
+public:
+    static_assert(conjunction_v<is_object<_Types>..., negation<is_array<_Types>>..., is_destructible<_Types>...>,
+        "variant<Types...> requires all of the Types to meet the Cpp17Destructible requirements "
+        "(N4950 [variant.variant.general]/2).");
+    static_assert(sizeof...(_Types) > 0,
+        "variant<> (with no template arguments) may not be instantiated (N4950 [variant.variant.general]/3).");
+    using _Mybase = _SMF_control<_Variant_destroy_layer<_Types...>, _Types...>;
+
+    template <class _First = _Meta_front<variant>, enable_if_t<is_default_constructible_v<_First>, int> = 0>
+    constexpr variant() noexcept(is_nothrow_default_constructible_v<_First>)
+        : _Mybase(in_place_index<0>) {} // value-initialize alternative 0
+
+    template <class _Ty,
+        enable_if_t<sizeof...(_Types) != 0 && !is_same_v<_Remove_cvref_t<_Ty>, variant>
+                        && !_Is_specialization_v<_Remove_cvref_t<_Ty>, in_place_type_t>
+                        && !_Is_in_place_index_specialization<_Remove_cvref_t<_Ty>>,
+            int> = 0,
+        // These enable_if_t constraints are distinct to enable short-circuiting and avoid
+        // substitution into _Variant_init_type when the first constraint is not satisfied.
+        enable_if_t<is_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>, int> = 0>
+    constexpr variant(_Ty&& _Obj) noexcept(is_nothrow_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>)
+        : _Mybase(in_place_index<_Variant_init_index<_Ty, _Types...>::value>, static_cast<_Ty&&>(_Obj)) {
+        // initialize to the type selected by passing _Obj to the overload set f(Types)...
+    }
+
+    template <class _Ty, class... _UTypes, class _Idx = _Meta_find_unique_index<variant, _Ty>,
+        enable_if_t<_Idx::value != _Meta_npos && is_constructible_v<_Ty, _UTypes...>, int> = 0>
+    constexpr explicit variant(in_place_type_t<_Ty>, _UTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, _UTypes...>) // strengthened
+        : _Mybase(in_place_index<_Idx::value>, static_cast<_UTypes&&>(_Args)...) {
+        // initialize alternative _Ty from _Args...
+    }
+    template <class _Ty, class _Elem, class... _UTypes, class _Idx = _Meta_find_unique_index<variant, _Ty>,
+        enable_if_t<_Idx::value != _Meta_npos && is_constructible_v<_Ty, initializer_list<_Elem>&, _UTypes...>, int> =
+            0>
+    constexpr explicit variant(in_place_type_t<_Ty>, initializer_list<_Elem> _Ilist, _UTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _UTypes...>) // strengthened
+        : _Mybase(in_place_index<_Idx::value>, _Ilist, static_cast<_UTypes&&>(_Args)...) {
+        // initialize alternative _Ty from _Ilist and _Args...
+    }
+
+    template <size_t _Idx, class... _UTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, _UTypes...>, int> = 0>
+    constexpr explicit variant(in_place_index_t<_Idx>, _UTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _UTypes...>) // strengthened
+        : _Mybase(in_place_index<_Idx>, static_cast<_UTypes&&>(_Args)...) {
+        // initialize alternative _Idx from _Args...
+    }
+    template <size_t _Idx, class _Elem, class... _UTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _UTypes...>, int> = 0>
+    constexpr explicit variant(in_place_index_t<_Idx>, initializer_list<_Elem> _Ilist, _UTypes&&... _Args)
+        noexcept(is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _UTypes...>) // strengthened
+        : _Mybase(in_place_index<_Idx>, _Ilist, static_cast<_UTypes&&>(_Args)...) {
+        // initialize alternative _Idx from _Ilist and _Args...
+    }
+
+    template <class _Ty, enable_if_t<!is_same_v<_Remove_cvref_t<_Ty>, variant>, int> = 0,
+        // These enable_if_t constraints are distinct to enable short-circuiting and avoid
+        // substitution into _Variant_init_type when the first constraint is not satisfied.
+        enable_if_t<is_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>
+                        && is_assignable_v<_Variant_init_type<_Ty, _Types...>&, _Ty>,
+            int> = 0>
+    _CONSTEXPR20 variant& operator=(_Ty&& _Obj)
+        noexcept(is_nothrow_assignable_v<_Variant_init_type<_Ty, _Types...>&, _Ty>
+                 && is_nothrow_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>) {
+        // assign/emplace the alternative chosen by overload resolution of _Obj with f(_Types)...
+        constexpr size_t _TargetIdx = _Variant_init_index<_Ty, _Types...>::value;
+        if (index() == _TargetIdx) {
+            auto& _Target = _STD _Variant_raw_get<_TargetIdx>(_Storage());
+            _Target       = static_cast<_Ty&&>(_Obj);
+        } else {
+            using _TargetTy = _Variant_init_type<_Ty, _Types...>;
+            if constexpr (_Variant_should_directly_construct_v<_TargetTy, _Ty>) {
+                this->_Reset();
+                _Emplace_valueless<_TargetIdx>(static_cast<_Ty&&>(_Obj));
+            } else {
+                _TargetTy _Temp(static_cast<_Ty&&>(_Obj));
+                this->_Reset();
+                _Emplace_valueless<_TargetIdx>(_STD move(_Temp));
+            }
+        }
+
+        return *this;
+    }
+
+    using _Mybase::_Storage;
+
+    template <class _Ty, class... _ArgTypes, size_t _Idx = _Meta_find_unique_index<variant, _Ty>::value,
+        enable_if_t<_Idx != _Meta_npos && is_constructible_v<_Ty, _ArgTypes...>, int> = 0>
+    _CONSTEXPR20 _Ty& emplace(_ArgTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, _ArgTypes...>) /* strengthened */ {
+        // emplace alternative _Ty from _Args...
+        this->_Reset();
+        return _Emplace_valueless<_Idx>(static_cast<_ArgTypes&&>(_Args)...);
+    }
+    template <class _Ty, class _Elem, class... _ArgTypes, size_t _Idx = _Meta_find_unique_index<variant, _Ty>::value,
+        enable_if_t<_Idx != _Meta_npos && is_constructible_v<_Ty, initializer_list<_Elem>&, _ArgTypes...>, int> = 0>
+    _CONSTEXPR20 _Ty& emplace(initializer_list<_Elem> _Ilist, _ArgTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _ArgTypes...>) /* strengthened */ {
+        // emplace alternative _Ty from _Ilist and _Args...
+        this->_Reset();
+        return _Emplace_valueless<_Idx>(_Ilist, static_cast<_ArgTypes&&>(_Args)...);
+    }
+
+    template <size_t _Idx, class... _ArgTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>, int> = 0>
+    _CONSTEXPR20 _Meta_at_c<variant, _Idx>& emplace(_ArgTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>) /* strengthened */ {
+        // emplace alternative _Idx from _Args...
+        this->_Reset();
+        return _Emplace_valueless<_Idx>(static_cast<_ArgTypes&&>(_Args)...);
+    }
+    template <size_t _Idx, class _Elem, class... _ArgTypes,
+        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _ArgTypes...>, int> = 0>
+    _CONSTEXPR20 _Meta_at_c<variant, _Idx>& emplace(initializer_list<_Elem> _Ilist, _ArgTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&,
+            _ArgTypes...>) /* strengthened */ {
+        // emplace alternative _Idx from _Ilist and _Args...
+        this->_Reset();
+        return _Emplace_valueless<_Idx>(_Ilist, static_cast<_ArgTypes&&>(_Args)...);
+    }
+
+    using _Mybase::index;
+    using _Mybase::valueless_by_exception;
+
+#ifdef __clang__ // TRANSITION, LLVM-35450
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-lambda-capture"
+#endif // ^^^ workaround ^^^
+    _CONSTEXPR20 void swap(variant& _That)
+        noexcept(conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
+        // exchange the contained values if *this and _That hold the same alternative, otherwise exchange the values of
+        // the variants themselves
+        static_assert(conjunction_v<is_move_constructible<_Types>...>,
+            "variant<Types...>::swap requires all of the Types... to be move constructible. (N4950 [variant.swap]/1)");
+        static_assert(disjunction_v<negation<is_move_constructible<_Types>>..., conjunction<is_swappable<_Types>...>>,
+            "variant<Types...>::swap requires all of the Types... to be swappable. (N4950 [variant.swap]/2)");
+        if constexpr (conjunction_v<_Is_trivially_swappable<_Types>...>) {
+            using _BaseTy = _Variant_base<_Types...>;
+            _STD swap(static_cast<_BaseTy&>(*this), static_cast<_BaseTy&>(_That));
+        } else if constexpr (sizeof...(_Types) < 32) {
+            // Limit the size of variants that use this quadratic code size implementation of swap.
+            _STD _Variant_raw_visit(index(), _Storage(),
+                [this, &_That](auto _My_ref) noexcept(
+                    conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
+                    _STD _Variant_raw_visit(_That.index(), _That._Storage(),
+                        [this, &_That, _My_ref](auto _That_ref) noexcept(
+                            conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
+                            constexpr size_t _That_idx = decltype(_That_ref)::_Idx;
+                            constexpr size_t _My_idx   = decltype(_My_ref)::_Idx;
+                            if constexpr (_My_idx == _That_idx) { // Same alternatives...
+                                if constexpr (_My_idx != variant_npos) { // ...and not valueless, swap directly
+                                    using _STD swap;
+                                    swap(_My_ref._Val, _That_ref._Val); // intentional ADL
+                                }
+                            } else if constexpr (_My_idx == variant_npos) { // *this is valueless, _That is not
+                                this->_Emplace_valueless<_That_idx>(_STD move(_That_ref._Val));
+                                _That.template _Reset<_That_idx>();
+                            } else if constexpr (_That_idx == variant_npos) { // _That is valueless, *this is not
+                                _That._Emplace_valueless<_My_idx>(_STD move(_My_ref._Val));
+                                this->template _Reset<_My_idx>();
+                            } else { // different non-valueless alternatives
+                                auto _Tmp = _STD move(_My_ref._Val);
+                                this->template _Reset<_My_idx>();
+                                this->_Emplace_valueless<_That_idx>(_STD move(_That_ref._Val));
+                                _That.template _Reset<_That_idx>();
+                                _That._Emplace_valueless<_My_idx>(_STD move(_Tmp));
+                            }
+                        });
+                });
+        } else {
+            if (this->_Which == _That._Which) {
+                _STD _Variant_raw_visit(static_cast<size_t>(this->_Which), _That._Storage(),
+                    [this](auto _Ref) noexcept(conjunction_v<is_nothrow_swappable<_Types>...>) {
+                        constexpr size_t _Idx = decltype(_Ref)::_Idx;
+                        if constexpr (_Idx != variant_npos) {
+                            using _STD swap;
+                            swap(_Variant_raw_get<_Idx>(this->_Storage()), _Ref._Val); // intentional ADL
+                        }
+                    });
+            } else {
+                variant _Tmp = _STD move(*this);
+                this->_Emplace_from(_STD move(_That));
+                _That._Emplace_from(_STD move(_Tmp));
+            }
+        }
+    }
+#ifdef __clang__ // TRANSITION, LLVM-35450
+#pragma clang diagnostic pop
+#endif // ^^^ workaround ^^^
+
+private:
+    template <size_t _Idx, class... _ArgTypes>
+    _CONSTEXPR20 _Meta_at_c<variant, _Idx>& _Emplace_valueless(_ArgTypes&&... _Args)
+        noexcept(is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>) {
+        // initialize alternative _Idx from _Args...
+        _STL_INTERNAL_CHECK(valueless_by_exception());
+        _STD _Construct_in_place(_Storage(), integral_constant<size_t, _Idx>{}, static_cast<_ArgTypes&&>(_Args)...);
+        this->_Set_index(_Idx);
+        return _STD _Variant_raw_get<_Idx>(_Storage());
+    }
+
+    _CONSTEXPR20 void _Emplace_from(variant&& _That) noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...>) {
+        // steal the contained value from _That
+        this->_Reset();
+        _STD _Variant_raw_visit(_That.index(), _That._Storage(),
+            [this](auto _Ref) noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...>) {
+                constexpr size_t _Idx = decltype(_Ref)::_Idx;
+                if constexpr (_Idx != variant_npos) {
+                    this->_Emplace_valueless<_Idx>(_STD move(_Ref._Val));
+                }
+            });
+    }
+};
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr bool holds_alternative(const variant<_Types...>& _Var) noexcept {
+    // true iff _Var holds alternative _Ty
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx != _Meta_npos) {
+        return _Var.index() == _Idx;
+    } else {
+        static_assert(false, "holds_alternative<T>(const variant<Types...>&) requires T to occur exactly "
+                             "once in Types. (N4971 [variant.get]/1)");
+    }
+}
+
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
+    // access the contained value of _Var if its _Idx-th alternative is active
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    if (_Var.index() == _Idx) {
+        return _STD _Variant_raw_get<_Idx>(_Var._Storage());
+    }
+
+    _STD _Throw_bad_variant_access();
+}
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
+    // access the contained value of _Var if its _Idx-th alternative is active
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    if (_Var.index() == _Idx) {
+        return _STD _Variant_raw_get<_Idx>(_STD move(_Var)._Storage());
+    }
+
+    _STD _Throw_bad_variant_access();
+}
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
+    // access the contained value of _Var if its _Idx-th alternative is active
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    if (_Var.index() == _Idx) {
+        return _STD _Variant_raw_get<_Idx>(_Var._Storage());
+    }
+
+    _STD _Throw_bad_variant_access();
+}
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
+    // access the contained value of _Var if its _Idx-th alternative is active
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    if (_Var.index() == _Idx) {
+        return _STD _Variant_raw_get<_Idx>(_STD move(_Var)._Storage());
+    }
+
+    _STD _Throw_bad_variant_access();
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
+    // access the contained value of _Var if its alternative _Ty is active
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_Var);
+    } else {
+        static_assert(false, "get<T>(variant<Types...>&) "
+                             "requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
+}
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
+    // access the contained value of _Var if its alternative _Ty is active
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_STD move(_Var));
+    } else {
+        static_assert(false, "get<T>(variant<Types...>&&) "
+                             "requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
+}
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
+    // access the contained value of _Var if its alternative _Ty is active
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_Var);
+    } else {
+        static_assert(false, "get<T>(const variant<Types...>&) "
+                             "requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
+}
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
+    // access the contained value of _Var if its alternative _Ty is active
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_STD move(_Var));
+    } else {
+        static_assert(false, "get<T>(const variant<Types...>&&) "
+                             "requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
+}
+
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr auto get_if(variant<_Types...>* _Ptr) noexcept {
+    // get the address of *_Ptr's contained value if it holds alternative _Idx
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    return _Ptr && _Ptr->index() == _Idx ? _STD addressof(_STD _Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
+}
+_EXPORT_STD template <size_t _Idx, class... _Types>
+_NODISCARD constexpr auto get_if(const variant<_Types...>* _Ptr) noexcept {
+    // get the address of *_Ptr's contained value if it holds alternative _Idx
+    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
+    return _Ptr && _Ptr->index() == _Idx ? _STD addressof(_STD _Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
+}
+
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr add_pointer_t<_Ty> get_if(variant<_Types...>* _Ptr) noexcept {
+    // get the address of *_Ptr's contained value if it holds alternative _Ty
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx != _Meta_npos) {
+        return _STD get_if<_Idx>(_Ptr);
+    } else {
+        static_assert(false,
+            "get_if<T>(variant<Types...> *) requires T to occur exactly once in Types. (N4971 [variant.get]/12)");
+    }
+}
+_EXPORT_STD template <class _Ty, class... _Types>
+_NODISCARD constexpr add_pointer_t<const _Ty> get_if(const variant<_Types...>* _Ptr) noexcept {
+    // get the address of *_Ptr's contained value if it holds alternative _Ty
+    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
+    if constexpr (_Idx != _Meta_npos) {
+        return _STD get_if<_Idx>(_Ptr);
+    } else {
+        static_assert(false,
+            "get_if<T>(const variant<Types...> *) requires T to occur exactly once in Types. (N4971 [variant.get]/12)");
+    }
+}
+
+template <class _Op, class _Result, class... _Types>
+struct _Variant_relop_visitor2 { // evaluate _Op with the contained value of two variants that hold the same alternative
+    const _Variant_storage<_Types...>& _Left;
+
+    template <class _Ty, size_t _Idx>
+    _NODISCARD constexpr _Result operator()(_Tagged<const _Ty&, _Idx> _Right) const
+        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
+            is_nothrow_invocable_r<_Result, _Op, const _Ty&, const _Ty&>>) {
+        // determine the relationship between the stored values of _Left and _Right
+        // pre: _Left.index() == _Idx && _Right.index() == _Idx
+        if constexpr (_Idx != variant_npos) {
+            return _Op{}(_STD _Variant_raw_get<_Idx>(_Left), _Right._Val);
+        } else { // return whatever _Op returns for equal values
+            return _Op{}(0, 0);
+        }
+    }
+};
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator==(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, equal_to<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if the arguments are both valueless or contain equal values
+    using _Visitor            = _Variant_relop_visitor2<equal_to<>, bool, _Types...>;
+    const size_t _Right_index = _Right.index();
+    return _Left.index() == _Right_index
+        && _STD _Variant_raw_visit(_Right_index, _Right._Storage(), _Visitor{_Left._Storage()});
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator!=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, not_equal_to<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if the arguments have different active alternatives or contain unequal values
+    using _Visitor            = _Variant_relop_visitor2<not_equal_to<>, bool, _Types...>;
+    const size_t _Right_index = _Right.index();
+    return _Left.index() != _Right_index
+        || _STD _Variant_raw_visit(_Right_index, _Right._Storage(), _Visitor{_Left._Storage()});
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator<(const variant<_Types...>& _Left, const variant<_Types...>& _Right)
+    noexcept(conjunction_v<is_nothrow_invocable_r<bool, less<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if _Left has a lesser index(), or equal index() and lesser
+    // contained value than _Right
+    using _Visitor             = _Variant_relop_visitor2<less<>, bool, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    return _Left_offset < _Right_offset
+        || (_Left_offset == _Right_offset
+            && _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator>(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, greater<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if _Left has a greater index(), or equal index() and
+    // greater contained value than _Right
+    using _Visitor             = _Variant_relop_visitor2<greater<>, bool, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    return _Left_offset > _Right_offset
+        || (_Left_offset == _Right_offset
+            && _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator<=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, less_equal<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if _Left's index() is less than _Right's, or equal and
+    // _Left contains a value less than or equal to _Right
+    using _Visitor             = _Variant_relop_visitor2<less_equal<>, bool, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    return _Left_offset < _Right_offset
+        || (_Left_offset == _Right_offset
+            && _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
+}
+
+_EXPORT_STD template <class... _Types>
+_NODISCARD constexpr bool operator>=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
+    conjunction_v<is_nothrow_invocable_r<bool, greater_equal<>, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine if _Left's index() is greater than _Right's, or equal and
+    // _Left contains a value greater than or equal to _Right
+    using _Visitor             = _Variant_relop_visitor2<greater_equal<>, bool, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    return _Left_offset > _Right_offset
+        || (_Left_offset == _Right_offset
+            && _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class... _Types>
+    requires (three_way_comparable<_Types> && ...)
+_NODISCARD constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...> operator<=>(
+    const variant<_Types...>& _Left, const variant<_Types...>& _Right)
+    noexcept(conjunction_v<is_nothrow_invocable_r<common_comparison_category_t<compare_three_way_result_t<_Types>...>,
+            compare_three_way, const _Types&, const _Types&>...>) /* strengthened */ {
+    // determine the three-way comparison of _Left's and _Right's index, if equal
+    // return the three-way comparison of the contained values of _Left and _Right
+    using _Visitor             = _Variant_relop_visitor2<compare_three_way,
+        common_comparison_category_t<compare_three_way_result_t<_Types>...>, _Types...>;
+    const size_t _Left_offset  = _Left.index() + 1;
+    const size_t _Right_offset = _Right.index() + 1;
+    const auto _Offset_order   = _Left_offset <=> _Right_offset;
+    return _Offset_order != 0
+             ? _Offset_order
+             : _STD _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()});
+}
+#endif // _HAS_CXX20
+
+template <class... _Variants>
+constexpr size_t _Variant_total_states =
+    (size_t{1} * ... * (variant_size_v<_Variants> + 1)); // +1 to account for the valueless state
+
+_NODISCARD constexpr size_t _Variant_visit_index1(const size_t _Acc) noexcept {
+    return _Acc;
+}
+template <class _FirstTy, class... _RestTys>
+_NODISCARD constexpr size_t _Variant_visit_index1(
+    size_t _Acc, const _FirstTy& _First, const _RestTys&... _Rest) noexcept {
+    // calculate a canonical index from the biased indices of the variants _First and _Rest...
+    _Acc += (_First.index() + 1) * _Variant_total_states<_RestTys...>;
+    return _STD _Variant_visit_index1(_Acc, _Rest...);
+}
+
+template <class _Callable, class... _Types>
+using _Variant_visit_result_t =
+    decltype(_STD invoke(_STD declval<_Callable>(), _STD _Variant_raw_get<0>(_STD declval<_Types>()._Storage())...));
+
+template <class>
+struct _Variant_dispatcher;
+
+template <size_t... _Is>
+struct _Variant_dispatcher<index_sequence<_Is...>> {
+    template <class _Ret, class _Callable, class... _Types, bool _Any_valueless = ((_Is == 0) || ...)>
+    _NODISCARD static constexpr _Ret _Dispatch2(_Callable&& _Obj, _Types&&... _Args) {
+        if constexpr (_Any_valueless) {
+            _STD _Throw_bad_variant_access();
+        }
+#if _HAS_CXX20
+        else if constexpr (is_void_v<_Ret>) {
+            static_cast<void>(_STD invoke(static_cast<_Callable&&>(_Obj),
+                _STD _Variant_raw_get<_Is - 1>(static_cast<_Types&&>(_Args)._Storage())...));
+        }
+#endif // _HAS_CXX20
+        else {
+            return _STD invoke(static_cast<_Callable&&>(_Obj),
+                _STD _Variant_raw_get<_Is - 1>(static_cast<_Types&&>(_Args)._Storage())...);
+        }
+    }
+};
+
+template <class _Ret, class _Ordinals, class _Callable, class _Variants>
+struct _Variant_dispatch_table; // undefined
+
+template <class _Ret, class... _Ordinals, class _Callable, class... _Variants>
+struct _Variant_dispatch_table<_Ret, _Meta_list<_Ordinals...>, _Callable, _Meta_list<_Variants...>> {
+    // map from canonical index to visitation target
+    using _Dispatch_t                     = _Ret (*)(_Callable&&, _Variants&&...);
+    static constexpr _Dispatch_t _Array[] = {
+        &_Variant_dispatcher<_Ordinals>::template _Dispatch2<_Ret, _Callable, _Variants...>...};
+};
+
+template <int _Strategy>
+struct _Visit_strategy;
+
+template <>
+struct _Visit_strategy<-1> {
+    // Fallback strategy for visitations with too many total states for the following "switch" strategies.
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(
+        size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) { // dispatch a visitation with many potential states
+        constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>;
+        static_assert(_Size > 256);
+        constexpr auto& _Array =
+            _Variant_dispatch_table<_Ret, _ListOfIndexVectors, _Callable, _Meta_list<_Variants...>>::_Array;
+        return _Array[_Idx](static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
+    }
+};
+
+template <>
+struct _Visit_strategy<0> {
+    template <class _Ret, class, class _Callable>
+    static constexpr _Ret _Visit2(size_t, _Callable&& _Obj) { // dispatch a visitation with 4^0 potential states
+        if constexpr (is_void_v<_Ret>) {
+            return static_cast<void>(static_cast<_Callable&&>(_Obj)());
+        } else {
+            return static_cast<_Callable&&>(_Obj)();
+        }
+    }
+};
+
+#define _STL_CASE(n)                                                                                  \
+    case (n):                                                                                         \
+        if constexpr ((n) < _Size) {                                                                  \
+            using _Indices = _Meta_at_c<_ListOfIndexVectors, (n)>;                                    \
+            return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( \
+                static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);                  \
+        }                                                                                             \
+        _STL_UNREACHABLE;                                                                             \
+        [[fallthrough]]
+
+#define _STL_VISIT_STAMP(stamper, n)                                               \
+    constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>; \
+    static_assert(_Size > (n) / 4 && _Size <= (n));                                \
+    switch (_Idx) {                                                                \
+        stamper(0, _STL_CASE);                                                     \
+    default:                                                                       \
+        _STL_UNREACHABLE;                                                          \
+    }
+
+template <>
+struct _Visit_strategy<1> {
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) {
+        // dispatch a visitation with 4^1 potential states
+        _STL_STAMP(4, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Visit_strategy<2> {
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) {
+        // dispatch a visitation with 4^2 potential states
+        _STL_STAMP(16, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Visit_strategy<3> {
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) {
+        // dispatch a visitation with 4^3 potential states
+        _STL_STAMP(64, _STL_VISIT_STAMP);
+    }
+};
+
+template <>
+struct _Visit_strategy<4> {
+    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+    static constexpr _Ret _Visit2(size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) {
+        // dispatch a visitation with 4^4 potential states
+        _STL_STAMP(256, _STL_VISIT_STAMP);
+    }
+};
+
+#undef _STL_VISIT_STAMP
+#undef _STL_CASE
+
+template <class... _Types>
+variant<_Types...>& _As_variant_impl(variant<_Types...>&);
+template <class... _Types>
+const variant<_Types...>& _As_variant_impl(const variant<_Types...>&);
+template <class... _Types>
+variant<_Types...>&& _As_variant_impl(variant<_Types...>&&);
+template <class... _Types>
+const variant<_Types...>&& _As_variant_impl(const variant<_Types...>&&);
+template <class _Ty>
+using _As_variant = // Deduce variant specialization from a derived type
+    decltype(_STD _As_variant_impl(_STD declval<_Ty>()));
+
+template <size_t _Size, class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
+constexpr _Ret _Visit_impl(_Callable&& _Obj, _Variants&&... _Args) {
+    constexpr int _Strategy = _Size == 1   ? 0
+                            : _Size <= 4   ? 1
+                            : _Size <= 16  ? 2
+                            : _Size <= 64  ? 3
+                            : _Size <= 256 ? 4
+                                           : -1;
+    return _Visit_strategy<_Strategy>::template _Visit2<_Ret, _ListOfIndexVectors>(
+        _STD _Variant_visit_index1(0, static_cast<_As_variant<_Variants>&>(_Args)...), static_cast<_Callable&&>(_Obj),
+        static_cast<_As_variant<_Variants>&&>(_Args)...);
+}
+
+template <class _Expected, class _Callable, class _ArgList, class... _Variants>
+constexpr bool _Variant_all_visit_results_same = false;
+
+template <class _Expected, class _Callable, class... _Args>
+constexpr bool _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>> =
+    is_same_v<decltype(_STD invoke(_STD declval<_Callable>(), _STD declval<_Args>()...)), _Expected>;
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&, _Rest...> =
+        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., _Types&>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&, _Rest...> =
+        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types&>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&&, _Rest...> =
+        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., _Types>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&&, _Rest...> =
+        (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);
+
+_EXPORT_STD template <class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
+constexpr _Variant_visit_result_t<_Callable, _As_variant<_Variants>...> visit(_Callable&& _Obj, _Variants&&... _Args) {
+    // Invoke _Obj with the contained values of _Args...
+    constexpr auto _Size = _Variant_total_states<_Remove_cvref_t<_As_variant<_Variants>>...>;
+    using _ListOfIndexLists =
+        _Meta_list<_Meta_as_list<make_index_sequence<1 + variant_size_v<_Remove_cvref_t<_As_variant<_Variants>>>>>...>;
+    using _ListOfIndexVectors =
+        _Meta_transform<_Meta_quote<_Meta_as_integer_sequence>, _Meta_cartesian_product<_ListOfIndexLists>>;
+    using _Ret = _Variant_visit_result_t<_Callable, _As_variant<_Variants>...>;
+    static_assert(_Variant_all_visit_results_same<_Ret, _Callable, _Meta_list<>, _As_variant<_Variants>...>,
+        "visit() requires the result of all potential invocations to have the same type and value category "
+        "(N4950 [variant.visit]/5).");
+
+    return _STD _Visit_impl<_Size, _Ret, _ListOfIndexVectors>(
+        static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
+}
+
+#if _HAS_CXX20
+template <class _Expected, class _Callable, class _ArgList, class... _Variants>
+constexpr bool _Variant_all_visit_results_convertible = false;
+
+template <class _Expected, class _Callable, class... _Args>
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>> =
+    _Invoke_convertible<decltype(_STD invoke(_STD declval<_Callable>(), _STD declval<_Args>()...)), _Expected>::value;
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&, _Rest...> =
+        (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., _Types&>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
+    const variant<_Types...>&, _Rest...> =
+    (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types&>, _Rest...>
+        && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool
+    _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&&, _Rest...> =
+        (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., _Types>, _Rest...> && ...);
+
+template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
+    const variant<_Types...>&&, _Rest...> =
+    (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);
+
+_EXPORT_STD template <class _Ret, class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
+constexpr _Ret visit(_Callable&& _Obj, _Variants&&... _Args) {
+    constexpr auto _Size = _Variant_total_states<_Remove_cvref_t<_As_variant<_Variants>>...>;
+    using _ListOfIndexLists =
+        _Meta_list<_Meta_as_list<make_index_sequence<1 + variant_size_v<_Remove_cvref_t<_As_variant<_Variants>>>>>...>;
+    using _ListOfIndexVectors =
+        _Meta_transform<_Meta_quote<_Meta_as_integer_sequence>, _Meta_cartesian_product<_ListOfIndexLists>>;
+    if constexpr (!is_void_v<_Ret>) {
+        static_assert(_Variant_all_visit_results_convertible<_Ret, _Callable, _Meta_list<>, _As_variant<_Variants>...>,
+            "visit<R>() requires the result of all potential invocations to be implicitly convertible to R "
+            "(N4950 [variant.visit]/5).");
+    }
+
+    return _STD _Visit_impl<_Size, _Ret, _ListOfIndexVectors>(
+        static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class... _Types,
+    enable_if_t<conjunction_v<is_move_constructible<_Types>..., is_swappable<_Types>...>, int> = 0>
+_CONSTEXPR20 void swap(variant<_Types...>& _Left, variant<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
+    _Left.swap(_Right);
+}
+
+struct _Variant_hash_visitor { // visitation function for hashing variants
+    template <class _Ty, size_t _Idx>
+    _NODISCARD static size_t operator()(_Tagged<const _Ty&, _Idx> _Obj)
+        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
+            is_nothrow_invocable<hash<_Ty>, const _Ty&>>) { // hash contained value _Obj
+        if constexpr (_Idx == variant_npos) { // hash a valueless variant
+            return 0;
+        } else { // hash the contained value
+            return hash<_Ty>{}(_Obj._Val);
+        }
+    }
+};
+
+template <class... _Types>
+struct hash<variant<_Types...>> : _Conditionally_enabled_hash<variant<_Types...>,
+                                      conjunction_v<is_default_constructible<hash<remove_const_t<_Types>>>...>> {
+    _NODISCARD static size_t _Do_hash(const variant<_Types...>& _Var)
+        noexcept(conjunction_v<_Is_nothrow_hashable<remove_const_t<_Types>>...>) {
+        // called from the CRTP base to hash _Var iff the hash is enabled
+        return _STD _Variant_raw_visit(_Var.index(), _Var._Storage(), _Variant_hash_visitor{});
+    }
+};
+
+_STD_END
+
+#undef _STL_STAMP
+#undef _STL_STAMP256
+#undef _STL_STAMP64
+#undef _STL_STAMP16
+#undef _STL_STAMP4
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX17 ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _VARIANT_
diff --git a/msvc-stl/stl/inc/vector b/msvc-stl/stl/inc/vector
new file mode 100644
index 0000000..5ba44ed
--- /dev/null
+++ b/msvc-stl/stl/inc/vector
@@ -0,0 +1,4199 @@
+// vector standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _VECTOR_
+#define _VECTOR_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_bit_utils.hpp>
+#include <__msvc_sanitizer_annotate_container.hpp>
+#include <xmemory>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+#include <__msvc_formatter.hpp>
+#endif // _HAS_CXX23
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Myvec>
+class _Vector_const_iterator : public _Iterator_base {
+public:
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Myvec::value_type;
+    using difference_type   = typename _Myvec::difference_type;
+    using pointer           = typename _Myvec::const_pointer;
+    using reference         = const value_type&;
+
+    using _Tptr    = typename _Myvec::pointer;
+    using _Myvec_t = _Myvec; // helper for expression evaluator
+
+    _CONSTEXPR20 _Vector_const_iterator() noexcept : _Ptr() {}
+
+    _CONSTEXPR20 _Vector_const_iterator(_Tptr _Parg, const _Container_base* _Pvector) noexcept : _Ptr(_Parg) {
+        this->_Adopt(_Pvector);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Ptr, "can't dereference value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't dereference invalidated vector iterator");
+        _STL_VERIFY(
+            _Mycont->_Myfirst <= _Ptr && _Ptr < _Mycont->_Mylast, "can't dereference out of range vector iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return *_Ptr;
+    }
+
+    _NODISCARD _CONSTEXPR20 pointer operator->() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Ptr, "can't dereference value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't dereference invalidated vector iterator");
+        _STL_VERIFY(
+            _Mycont->_Myfirst <= _Ptr && _Ptr < _Mycont->_Mylast, "can't dereference out of range vector iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Ptr;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Ptr, "can't increment value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't increment invalidated vector iterator");
+        _STL_VERIFY(_Ptr < _Mycont->_Mylast, "can't increment vector iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        ++_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator operator++(int) noexcept {
+        _Vector_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Ptr, "can't decrement value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't decrement invalidated vector iterator");
+        _STL_VERIFY(_Mycont->_Myfirst < _Ptr, "can't decrement vector iterator before begin");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        --_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator operator--(int) noexcept {
+        _Vector_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 void _Verify_offset(const difference_type _Off) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Off;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(_Off == 0 || _Ptr, "cannot seek value-initialized vector iterator");
+        _STL_VERIFY(_Off == 0 || _Mycont, "cannot seek invalidated vector iterator");
+        if (_Off < 0) {
+            _STL_VERIFY(_Off >= _Mycont->_Myfirst - _Ptr, "cannot seek vector iterator before begin");
+        }
+
+        if (_Off > 0) {
+            _STL_VERIFY(_Off <= _Mycont->_Mylast - _Ptr, "cannot seek vector iterator after end");
+        }
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator& operator+=(const difference_type _Off) noexcept {
+        _Verify_offset(_Off);
+        _Ptr += _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vector_const_iterator operator+(const difference_type _Off) const noexcept {
+        _Vector_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _Vector_const_iterator operator+(
+        const difference_type _Off, _Vector_const_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR20 _Vector_const_iterator& operator-=(const difference_type _Off) noexcept {
+        return *this += -_Off;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vector_const_iterator operator-(const difference_type _Off) const noexcept {
+        _Vector_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 difference_type operator-(const _Vector_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return static_cast<difference_type>(_Ptr - _Right._Ptr);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD _CONSTEXPR20 bool operator==(const _Vector_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Ptr == _Right._Ptr;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _Vector_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _STD _Unfancy_maybe_null(_Ptr) <=> _STD _Unfancy_maybe_null(_Right._Ptr);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const _Vector_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const _Vector_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Ptr < _Right._Ptr;
+    }
+
+    _NODISCARD bool operator>(const _Vector_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const _Vector_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD bool operator>=(const _Vector_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR20 void _Compat(const _Vector_const_iterator& _Right) const noexcept {
+        // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Right;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "vector iterators incompatible");
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+    friend _CONSTEXPR20 void _Verify_range(
+        const _Vector_const_iterator& _First, const _Vector_const_iterator& _Last) noexcept {
+        _STL_VERIFY(_First._Getcont() == _Last._Getcont(), "vector iterators in range are from different containers");
+        _STL_VERIFY(_First._Ptr <= _Last._Ptr, "vector iterator range transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+    using _Prevent_inheriting_unwrap = _Vector_const_iterator;
+
+    _NODISCARD _CONSTEXPR20 const value_type* _Unwrapped() const noexcept {
+        return _STD _Unfancy_maybe_null(_Ptr);
+    }
+
+    _CONSTEXPR20 void _Seek_to(const value_type* _It) noexcept {
+        _Ptr = _STD _Refancy_maybe_null<_Tptr>(const_cast<value_type*>(_It));
+    }
+
+    _Tptr _Ptr; // pointer to element in vector
+};
+
+#if _HAS_CXX20
+template <class _Myvec>
+struct pointer_traits<_Vector_const_iterator<_Myvec>> {
+    using pointer         = _Vector_const_iterator<_Myvec>;
+    using element_type    = const pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        // A value-initialized iterator is in the domain of to_address. An invalidated end iterator for a vector with
+        // capacity() of 0 is not. This function cannot distinguish those two cases, so it incorrectly does not diagnose
+        // the latter. In practice, this isn't a significant problem since to_address returns nullptr for such an
+        // iterator.
+        const auto _Mycont = static_cast<const _Myvec*>(_Iter._Getcont());
+        if (_Mycont) {
+            _STL_VERIFY(_Mycont->_Myfirst <= _Iter._Ptr && _Iter._Ptr <= _Mycont->_Mylast,
+                "can't convert out-of-range vector iterator to pointer");
+        } else {
+            _STL_VERIFY(!_Iter._Ptr, "can't convert invalid vector iterator to pointer");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _STD to_address(_Iter._Ptr);
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Myvec>
+class _Vector_iterator : public _Vector_const_iterator<_Myvec> {
+public:
+    using _Mybase = _Vector_const_iterator<_Myvec>;
+
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Myvec::value_type;
+    using difference_type   = typename _Myvec::difference_type;
+    using pointer           = typename _Myvec::pointer;
+    using reference         = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD _CONSTEXPR20 pointer operator->() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Mycont = static_cast<const _Myvec*>(this->_Getcont());
+        _STL_VERIFY(this->_Ptr, "can't dereference value-initialized vector iterator");
+        _STL_VERIFY(_Mycont, "can't dereference invalidated vector iterator");
+        _STL_VERIFY(_Mycont->_Myfirst <= this->_Ptr && this->_Ptr < _Mycont->_Mylast,
+            "can't dereference out of range vector iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return this->_Ptr;
+    }
+
+    _CONSTEXPR20 _Vector_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vector_iterator operator++(int) noexcept {
+        _Vector_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vector_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vector_iterator operator--(int) noexcept {
+        _Vector_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vector_iterator& operator+=(const difference_type _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vector_iterator operator+(const difference_type _Off) const noexcept {
+        _Vector_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _Vector_iterator operator+(
+        const difference_type _Off, _Vector_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR20 _Vector_iterator& operator-=(const difference_type _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    using _Mybase::operator-;
+
+    _NODISCARD _CONSTEXPR20 _Vector_iterator operator-(const difference_type _Off) const noexcept {
+        _Vector_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return const_cast<reference>(_Mybase::operator[](_Off));
+    }
+
+    using _Prevent_inheriting_unwrap = _Vector_iterator;
+
+    _NODISCARD _CONSTEXPR20 value_type* _Unwrapped() const noexcept {
+        return _STD _Unfancy_maybe_null(this->_Ptr);
+    }
+};
+
+#if _HAS_CXX20
+template <class _Myvec>
+struct pointer_traits<_Vector_iterator<_Myvec>> {
+    using pointer         = _Vector_iterator<_Myvec>;
+    using element_type    = pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        // A value-initialized iterator is in the domain of to_address. An invalidated end iterator for a vector with
+        // capacity() of 0 is not. This function cannot distinguish those two cases, so it incorrectly does not diagnose
+        // the latter. In practice, this isn't a significant problem since to_address returns nullptr for such an
+        // iterator.
+        const auto _Mycont = static_cast<const _Myvec*>(_Iter._Getcont());
+        if (_Mycont) {
+            _STL_VERIFY(_Mycont->_Myfirst <= _Iter._Ptr && _Iter._Ptr <= _Mycont->_Mylast,
+                "can't convert out-of-range vector iterator to pointer");
+        } else {
+            _STL_VERIFY(!_Iter._Ptr, "can't convert invalid vector iterator to pointer");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _STD to_address(_Iter._Ptr);
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer>
+struct _Vec_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+};
+
+struct _Value_init_tag { // tag to request value-initialization
+    explicit _Value_init_tag() = default;
+};
+
+template <class _Val_types>
+class _Vector_val : public _Container_base {
+public:
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    _CONSTEXPR20 _Vector_val() noexcept : _Myfirst(), _Mylast(), _Myend() {}
+
+    _CONSTEXPR20 _Vector_val(pointer _First, pointer _Last, pointer _End) noexcept
+        : _Myfirst(_First), _Mylast(_Last), _Myend(_End) {}
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    _CONSTEXPR20 ~_Vector_val() noexcept {
+        if constexpr (is_pointer_v<pointer>) {
+            if (!_STD _Is_constant_evaluated()) {
+                const auto _Tombstone{reinterpret_cast<pointer>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+                _Myfirst = _Tombstone;
+                _Mylast  = _Tombstone;
+                _Myend   = _Tombstone;
+            }
+        }
+    }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+
+    _CONSTEXPR20 void _Swap_val(_Vector_val& _Right) noexcept {
+        this->_Swap_proxy_and_iterators(_Right);
+        swap(_Myfirst, _Right._Myfirst); // intentional ADL
+        swap(_Mylast, _Right._Mylast); // intentional ADL
+        swap(_Myend, _Right._Myend); // intentional ADL
+    }
+
+    _CONSTEXPR20 void _Take_contents(_Vector_val& _Right) noexcept {
+        this->_Swap_proxy_and_iterators(_Right);
+        _Myfirst = _Right._Myfirst;
+        _Mylast  = _Right._Mylast;
+        _Myend   = _Right._Myend;
+
+        _Right._Myfirst = nullptr;
+        _Right._Mylast  = nullptr;
+        _Right._Myend   = nullptr;
+    }
+
+    pointer _Myfirst; // pointer to beginning of array
+    pointer _Mylast; // pointer to current end of sequence
+    pointer _Myend; // pointer to end of array
+};
+
+template <class _Alloc>
+struct _NODISCARD _Allocation_guard {
+    _Alloc& _Al;
+    _Alloc_ptr_t<_Alloc> _Ptr;
+    _Alloc_size_t<_Alloc> _Size;
+
+    _Allocation_guard& operator=(const _Allocation_guard&) = delete;
+    _Allocation_guard& operator=(_Allocation_guard&&)      = delete;
+
+    _CONSTEXPR20 ~_Allocation_guard() noexcept {
+        if (_Ptr) {
+            _Al.deallocate(_Ptr, _Size);
+        }
+    }
+};
+
+_EXPORT_STD template <class _Ty, class _Alloc = allocator<_Ty>>
+class vector { // varying size array of values
+private:
+    template <class>
+    friend class _Vb_val;
+    friend _Tidy_guard<vector>;
+
+    using _Alty        = _Rebind_alloc_t<_Alloc, _Ty>;
+    using _Alty_traits = allocator_traits<_Alty>;
+
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Ty, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("vector<T, Allocator>", "T"));
+    static_assert(is_object_v<_Ty>, "The C++ Standard forbids containers of non-object types "
+                                    "because of [container.requirements].");
+
+    using value_type      = _Ty;
+    using allocator_type  = _Alloc;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = _Ty&;
+    using const_reference = const _Ty&;
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+
+private:
+#ifdef _INSERT_VECTOR_ANNOTATION
+    _CONSTEXPR20 void _Create_annotation() const noexcept {
+        // Annotates the shadow memory of the valid range
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Myend, _My_data._Mylast);
+    }
+
+    _CONSTEXPR20 void _Remove_annotation() const noexcept {
+        // Removes the shadow memory annotation of the range
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Mylast, _My_data._Myend);
+    }
+
+    _CONSTEXPR20 void _Modify_annotation(const difference_type _Count) const noexcept {
+        // Extends/shrinks the annotated range by _Count
+        if (_Count == 0) { // nothing to do
+            // This also avoids calling _Apply_annotation() with null pointers
+            // when the vector has zero capacity, see GH-2464.
+            return;
+        }
+
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Mylast, _My_data._Mylast + _Count);
+    }
+
+    static _CONSTEXPR20 void _Apply_annotation(
+        pointer _First_, pointer _End_, pointer _Old_last_, pointer _New_last_) noexcept {
+        _STL_INTERNAL_CHECK(_First_ != nullptr);
+        _STL_INTERNAL_CHECK(_End_ != nullptr);
+        _STL_INTERNAL_CHECK(_Old_last_ != nullptr);
+        _STL_INTERNAL_CHECK(_New_last_ != nullptr);
+
+        if constexpr (!_Disable_ASan_container_annotations_for_allocator<allocator_type>) {
+#if _HAS_CXX20
+            if (_STD is_constant_evaluated()) {
+                return;
+            }
+#endif // _HAS_CXX20
+
+            if (!_Asan_vector_should_annotate) {
+                return;
+            }
+
+            const void* const _First    = _STD _Unfancy(_First_);
+            const void* const _End      = _STD _Unfancy(_End_);
+            const void* const _Old_last = _STD _Unfancy(_Old_last_);
+            const void* const _New_last = _STD _Unfancy(_New_last_);
+            if constexpr ((_Container_allocation_minimum_asan_alignment<vector>) >= _Asan_granularity) {
+                // old state:
+                //   [_First, _Old_last) valid
+                //   [_Old_last, _End) poison
+                // new state:
+                //   [_First, _New_last) valid
+                //   [_New_last, asan_aligned_after(_End)) poison
+                _CSTD __sanitizer_annotate_contiguous_container(
+                    _First, _STD _Get_asan_aligned_after(_End), _Old_last, _New_last);
+            } else {
+                const auto _Aligned = _STD _Get_asan_aligned_first_end(_First, _End);
+                if (_Aligned._First == _Aligned._End) {
+                    // The buffer does not end at least one shadow memory section; nothing to do.
+                    return;
+                }
+
+                const void* const _Old_fixed = _Aligned._Clamp_to_end(_Old_last);
+                const void* const _New_fixed = _Aligned._Clamp_to_end(_New_last);
+
+                // old state:
+                //   [_Aligned._First, _Old_fixed) valid
+                //   [_Old_fixed, _Aligned._End) poison
+                //   [_Aligned._End, _End) valid
+                // new state:
+                //   [_Aligned._First, _New_fixed) valid
+                //   [_New_fixed, _Aligned._End) poison
+                //   [_Aligned._End, _End) valid
+                _CSTD __sanitizer_annotate_contiguous_container(_Aligned._First, _Aligned._End, _Old_fixed, _New_fixed);
+            }
+        }
+    }
+
+    class _NODISCARD _Asan_extend_guard {
+    public:
+        _Asan_extend_guard(const _Asan_extend_guard&)            = delete;
+        _Asan_extend_guard& operator=(const _Asan_extend_guard&) = delete;
+
+        constexpr explicit _Asan_extend_guard(vector* _Myvec_, size_type _Target_size_) noexcept
+            : _Myvec(_Myvec_), _Target_size(_Target_size_) {
+            _STL_INTERNAL_CHECK(_Myvec != nullptr);
+            auto& _My_data = _Myvec->_Mypair._Myval2;
+            _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Mylast, _My_data._Myfirst + _Target_size);
+        }
+
+        _CONSTEXPR20 ~_Asan_extend_guard() {
+            if (!_Myvec) { // Operation succeeded, no modification to the shadow memory required.
+                return;
+            }
+
+            // Shrinks the shadow memory to the current size of the vector.
+            auto& _My_data = _Myvec->_Mypair._Myval2;
+            _Apply_annotation(_My_data._Myfirst, _My_data._Myend, _My_data._Myfirst + _Target_size, _My_data._Mylast);
+        }
+
+        _CONSTEXPR20 void _Release() noexcept {
+            _Myvec = nullptr;
+        }
+
+    private:
+        vector* _Myvec;
+        size_type _Target_size;
+    };
+
+    class _NODISCARD _Asan_create_guard {
+    public:
+        _Asan_create_guard(const _Asan_create_guard&)            = delete;
+        _Asan_create_guard& operator=(const _Asan_create_guard&) = delete;
+
+        constexpr explicit _Asan_create_guard(const vector& _Myvec_) noexcept : _Myvec(_Myvec_) {}
+
+        _CONSTEXPR20 ~_Asan_create_guard() {
+            _Myvec._Create_annotation();
+        }
+
+    private:
+        const vector& _Myvec;
+    };
+
+#define _ASAN_VECTOR_MODIFY(n)       _Modify_annotation((n))
+#define _ASAN_VECTOR_REMOVE          _Remove_annotation()
+#define _ASAN_VECTOR_CREATE          _Create_annotation()
+#define _ASAN_VECTOR_CREATE_GUARD    _Asan_create_guard _Annotator(*this)
+#define _ASAN_VECTOR_EXTEND_GUARD(n) _Asan_extend_guard _Annotator(this, (n))
+#define _ASAN_VECTOR_RELEASE_GUARD   _Annotator._Release()
+#else // ^^^ defined(_INSERT_VECTOR_ANNOTATION) / !defined(_INSERT_VECTOR_ANNOTATION) vvv
+#define _ASAN_VECTOR_MODIFY(n)
+#define _ASAN_VECTOR_REMOVE
+#define _ASAN_VECTOR_CREATE
+#define _ASAN_VECTOR_CREATE_GUARD
+#define _ASAN_VECTOR_EXTEND_GUARD(n)
+#define _ASAN_VECTOR_RELEASE_GUARD
+#endif // ^^^ !defined(_INSERT_VECTOR_ANNOTATION) ^^^
+
+    using _Scary_val = _Vector_val<conditional_t<_Is_simple_alloc_v<_Alty>, _Simple_types<_Ty>,
+        _Vec_iter_types<_Ty, size_type, difference_type, pointer, const_pointer>>>;
+
+    struct _NODISCARD _Reallocation_guard2 {
+        _Alty& _Al;
+        pointer _New_begin;
+        size_type _New_capacity;
+        pointer _Constructed_first;
+        pointer _Constructed_last;
+
+        _Reallocation_guard2& operator=(const _Reallocation_guard2&) = delete;
+        _Reallocation_guard2& operator=(_Reallocation_guard2&&)      = delete;
+
+        _CONSTEXPR20 ~_Reallocation_guard2() noexcept {
+            if (_New_begin != nullptr) {
+                _STD _Destroy_range(_Constructed_first, _Constructed_last, _Al);
+                _Al.deallocate(_New_begin, _New_capacity);
+            }
+        }
+    };
+
+    struct _NODISCARD _Vaporization_guard { // vaporize the detached piece
+        vector* _Target;
+        pointer _Vaporized_first;
+        pointer _Vaporized_last;
+        pointer _Destroyed_first;
+
+        _Vaporization_guard& operator=(const _Vaporization_guard&) = delete;
+        _Vaporization_guard& operator=(_Vaporization_guard&&)      = delete;
+
+        ~_Vaporization_guard() noexcept {
+            if (_Target != nullptr) {
+                auto& _Al     = _Target->_Getal();
+                auto& _Mylast = _Target->_Mypair._Myval2._Mylast;
+
+                _Target->_Orphan_range(_Vaporized_first, _Vaporized_last);
+                _STD _Destroy_range(_Destroyed_first, _Mylast, _Al);
+                _Mylast = _Vaporized_first;
+            }
+        }
+    };
+
+public:
+    using iterator               = _Vector_iterator<_Scary_val>;
+    using const_iterator         = _Vector_const_iterator<_Scary_val>;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    _CONSTEXPR20 vector() noexcept(is_nothrow_default_constructible_v<_Alty>) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 explicit vector(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 explicit vector(_CRT_GUARDOVERFLOW const size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_n(_Count);
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    _CONSTEXPR20 vector(_CRT_GUARDOVERFLOW const size_type _Count, const _Ty& _Val, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_n(_Count, _Val);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 vector(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst = _STD _Get_unwrapped(_First);
+        auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Construct_n(_Count, _STD move(_UFirst), _STD move(_ULast));
+#if _HAS_CXX20
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _STD _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Construct_n(_Count, _STD move(_UFirst), _STD move(_ULast));
+#endif // _HAS_CXX20
+        } else {
+            auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+            _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+            _Tidy_guard<vector> _Guard{this};
+
+            _Append_uncounted_range(_STD move(_UFirst), _STD move(_ULast));
+
+            _Guard._Target = nullptr;
+            _Proxy._Release();
+        }
+    }
+
+    _CONSTEXPR20 vector(initializer_list<_Ty> _Ilist, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_n(_Convert_size<size_type>(_Ilist.size()), _Ilist.begin(), _Ilist.end());
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr vector(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Construct_n(_Count, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        } else {
+            auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+            _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
+            _Tidy_guard<vector> _Guard{this};
+
+            _Append_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+
+            _Guard._Target = nullptr;
+            _Proxy._Release();
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 vector(const vector& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
+        const auto& _Right_data = _Right._Mypair._Myval2;
+        const auto _Count       = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
+        _Construct_n(_Count, _Right_data._Myfirst, _Right_data._Mylast);
+    }
+
+    _CONSTEXPR20 vector(const vector& _Right, const _Identity_t<_Alloc>& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        const auto& _Right_data = _Right._Mypair._Myval2;
+        const auto _Count       = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
+        _Construct_n(_Count, _Right_data._Myfirst, _Right_data._Mylast);
+    }
+
+    _CONSTEXPR20 vector(vector&& _Right) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal()),
+              _STD exchange(_Right._Mypair._Myval2._Myfirst, nullptr),
+              _STD exchange(_Right._Mypair._Myval2._Mylast, nullptr),
+              _STD exchange(_Right._Mypair._Myval2._Myend, nullptr)) {
+        _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+        _Mypair._Myval2._Swap_proxy_and_iterators(_Right._Mypair._Myval2);
+    }
+
+    _CONSTEXPR20 vector(vector&& _Right, const _Identity_t<_Alloc>& _Al_)
+        noexcept(_Alty_traits::is_always_equal::value) // strengthened
+        : _Mypair(_One_then_variadic_args_t{}, _Al_) {
+        _Alty& _Al        = _Getal();
+        auto _Alproxy     = _STD _Get_proxy_allocator(_Al);
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
+
+        if constexpr (!_Alty_traits::is_always_equal::value) {
+            if (_Al != _Right._Getal()) {
+                const auto _Count = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
+                if (_Count != 0) {
+                    _Buy_raw(_Count);
+                    _Tidy_guard<vector> _Guard{this};
+                    _My_data._Mylast =
+                        _Uninitialized_move(_Right_data._Myfirst, _Right_data._Mylast, _My_data._Myfirst, _Al);
+
+                    _ASAN_VECTOR_CREATE;
+                    _Guard._Target = nullptr;
+                }
+                _Proxy._Release();
+                return;
+            }
+        }
+
+        _My_data._Take_contents(_Right_data);
+        _Proxy._Release();
+    }
+
+    _CONSTEXPR20 vector& operator=(vector&& _Right)
+        noexcept(_Choose_pocma_v<_Alty> != _Pocma_values::_No_propagate_allocators) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        _Alty& _Al                = _Getal();
+        _Alty& _Right_al          = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alty>;
+        if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                _Move_assign_unequal_alloc(_Right);
+                return *this;
+            }
+        }
+
+        _Tidy();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                // intentionally slams into noexcept on OOM, TRANSITION, VSO-466800
+                _Mypair._Myval2._Reload_proxy(_STD _Get_proxy_allocator(_Al), _STD _Get_proxy_allocator(_Right_al));
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        _Pocma(_Al, _Right_al);
+        _Mypair._Myval2._Take_contents(_Right._Mypair._Myval2);
+        return *this;
+    }
+
+    _CONSTEXPR20 ~vector() noexcept {
+        _Tidy();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Delete_plain_internal(_Alproxy, _STD exchange(_Mypair._Myval2._Myproxy, nullptr));
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+private:
+    template <class... _Valty>
+    _CONSTEXPR20 _Ty& _Emplace_one_at_back(_Valty&&... _Val) {
+        // insert by perfectly forwarding into element at end, provide strong guarantee
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        if (_Mylast != _My_data._Myend) {
+            return _Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...);
+        }
+
+        return *_Emplace_reallocate(_Mylast, _STD forward<_Valty>(_Val)...);
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 _Ty& _Emplace_back_with_unused_capacity(_Valty&&... _Val) {
+        // insert by perfectly forwarding into element at end, provide strong guarantee
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+        _STL_INTERNAL_CHECK(_Mylast != _My_data._Myend); // check that we have unused capacity
+        if constexpr (conjunction_v<is_nothrow_constructible<_Ty, _Valty...>,
+                          _Uses_default_construct<_Alloc, _Ty*, _Valty...>>) {
+            _ASAN_VECTOR_MODIFY(1);
+            _STD _Construct_in_place(*_Mylast, _STD forward<_Valty>(_Val)...);
+        } else {
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Mylast - _My_data._Myfirst) + 1);
+            _Alty_traits::construct(_Getal(), _Unfancy(_Mylast), _STD forward<_Valty>(_Val)...);
+            _ASAN_VECTOR_RELEASE_GUARD;
+        }
+
+        _Orphan_range(_Mylast, _Mylast);
+        _Ty& _Result = *_Mylast;
+        ++_Mylast;
+
+        return _Result;
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 pointer _Emplace_reallocate(const pointer _Whereptr, _Valty&&... _Val) {
+        // reallocate and insert by perfectly forwarding _Val at _Whereptr
+        _Alty& _Al        = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        _STL_INTERNAL_CHECK(_Mylast == _My_data._Myend); // check that we have no unused capacity
+
+        const auto _Whereoff = _Whereptr - _Myfirst;
+        const auto _Oldsize  = static_cast<size_type>(_Mylast - _Myfirst);
+
+        if (_Oldsize == max_size()) {
+            _Xlength();
+        }
+
+        const size_type _Newsize = _Oldsize + 1;
+        size_type _Newcapacity   = _Calculate_growth(_Newsize);
+
+        const pointer _Newvec           = _STD _Allocate_at_least_helper(_Al, _Newcapacity);
+        const pointer _Constructed_last = _Newvec + static_cast<_Iter_diff_t<pointer>>(_Whereoff + 1);
+
+        _Reallocation_guard2 _Guard{_Al, _Newvec, _Newcapacity, _Constructed_last, _Constructed_last};
+        auto& _Constructed_first = _Guard._Constructed_first;
+
+        _Alty_traits::construct(_Al, _STD _Unfancy(_Newvec + _Whereoff), _STD forward<_Valty>(_Val)...);
+        _Constructed_first = _Newvec + _Whereoff;
+
+        if (_Whereptr == _Mylast) { // at back, provide strong guarantee
+            if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                _STD _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
+            } else {
+                _STD _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
+            }
+        } else { // provide basic guarantee
+            _STD _Uninitialized_move(_Myfirst, _Whereptr, _Newvec, _Al);
+            _Constructed_first = _Newvec;
+            _STD _Uninitialized_move(
+                _Whereptr, _Mylast, _Newvec + static_cast<_Iter_diff_t<pointer>>(_Whereoff + 1), _Al);
+        }
+
+        _Guard._New_begin = nullptr;
+        _Change_array(_Newvec, _Newsize, _Newcapacity);
+        return _Newvec + _Whereoff;
+    }
+
+public:
+    template <class... _Valty>
+    _CONSTEXPR20 _CONTAINER_EMPLACE_RETURN emplace_back(_Valty&&... _Val) {
+        // insert by perfectly forwarding into element at end, provide strong guarantee
+        _Ty& _Result = _Emplace_one_at_back(_STD forward<_Valty>(_Val)...);
+#if _HAS_CXX17
+        return _Result;
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+        (void) _Result;
+#endif // ^^^ !_HAS_CXX17 ^^^
+    }
+
+    _CONSTEXPR20 void push_back(const _Ty& _Val) { // insert element at end, provide strong guarantee
+        _Emplace_one_at_back(_Val);
+    }
+
+    _CONSTEXPR20 void push_back(_Ty&& _Val) {
+        // insert by moving into element at end, provide strong guarantee
+        _Emplace_one_at_back(_STD move(_Val));
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Append_uncounted_range(_Iter _First, const _Sent _Last) {
+        // insert range [_First, _Last) at end
+
+        // For one-at-back, provide strong guarantee.
+        // Otherwise, provide basic guarantee (despite N4950 [vector.modifiers]/2).
+        // Performance note: except for one-at-back, _Emplace_one_at_back()'s strong guarantee is unnecessary here.
+
+        for (; _First != _Last; ++_First) {
+            _Emplace_one_at_back(*_First);
+        }
+    }
+
+#if _HAS_CXX23
+    template <class _Iter>
+    _CONSTEXPR20 void _Append_counted_range(_Iter _First, const size_type _Count) {
+        // insert counted range _First + [0, _Count) at end
+        auto& _Al        = _Getal();
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        const pointer _Oldfirst     = _My_data._Myfirst;
+        const pointer _Oldlast      = _Mylast;
+        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
+
+        if (_Count == 0) { // nothing to do, avoid invalidating iterators
+        } else if (_Count > _Unused_capacity) { // reallocate
+            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);
+
+            if (_Count > max_size() - _Oldsize) {
+                _Xlength();
+            }
+
+            const size_type _Newsize = _Oldsize + _Count;
+            size_type _Newcapacity   = _Calculate_growth(_Newsize);
+
+            const pointer _Newvec           = _Allocate_at_least_helper(_Al, _Newcapacity);
+            const pointer _Constructed_last = _Newvec + _Oldsize + _Count;
+
+            _Reallocation_guard2 _Guard{_Al, _Newvec, _Newcapacity, _Constructed_last, _Constructed_last};
+            auto& _Constructed_first = _Guard._Constructed_first;
+
+            _Uninitialized_copy_n(_STD move(_First), _Count, _Newvec + _Oldsize, _Al);
+            _Constructed_first = _Newvec + _Oldsize;
+
+            if (_Count == 1) { // one at back, provide strong guarantee
+                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                    _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+                } else {
+                    _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
+                }
+            } else { // provide basic guarantee
+                _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+            }
+
+            _Guard._New_begin = nullptr;
+            _Change_array(_Newvec, _Newsize, _Newcapacity);
+        } else { // Provide the strong guarantee.
+                 // Performance note: except for one-at-back, the strong guarantee is unnecessary here.
+
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _Oldfirst) + _Count);
+            _Mylast = _Uninitialized_copy_n(_STD move(_First), _Count, _Oldlast, _Al);
+            _ASAN_VECTOR_RELEASE_GUARD;
+
+            _Orphan_range(_Oldlast, _Oldlast);
+        }
+    }
+#endif // _HAS_CXX23
+
+public:
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr void append_range(_Rng&& _Range) {
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Append_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Append_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    template <class... _Valty>
+    _CONSTEXPR20 iterator emplace(const_iterator _Where, _Valty&&... _Val) {
+        // insert by perfectly forwarding _Val at _Where
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldlast  = _My_data._Mylast;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _My_data._Myfirst && _Oldlast >= _Whereptr,
+            "vector emplace iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Oldlast != _My_data._Myend) {
+            if (_Whereptr == _Oldlast) { // at back, provide strong guarantee
+                _Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...);
+            } else {
+                auto& _Al = _Getal();
+                _Alloc_temporary2<_Alty> _Obj(_Al, _STD forward<_Valty>(_Val)...); // handle aliasing
+                // after constructing _Obj, provide basic guarantee
+                _Orphan_range(_Whereptr, _Oldlast);
+                _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _My_data._Myfirst) + 1);
+                _Alty_traits::construct(_Al, _Unfancy(_Oldlast), _STD move(_Oldlast[-1]));
+                _ASAN_VECTOR_RELEASE_GUARD;
+                ++_My_data._Mylast;
+                _Move_backward_unchecked(_Whereptr, _Oldlast - 1, _Oldlast);
+                *_Whereptr = _STD move(_Obj._Get_value());
+            }
+
+            return _Make_iterator(_Whereptr);
+        }
+
+        return _Make_iterator(_Emplace_reallocate(_Whereptr, _STD forward<_Valty>(_Val)...));
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, const _Ty& _Val) { // insert _Val at _Where
+        return emplace(_Where, _Val);
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _Ty&& _Val) { // insert by moving _Val at _Where
+        return emplace(_Where, _STD move(_Val));
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW const size_type _Count, const _Ty& _Val) {
+        // insert _Count * _Val at _Where
+        const pointer _Whereptr = _Where._Ptr;
+
+        auto& _Al        = _Getal();
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        const pointer _Oldfirst = _My_data._Myfirst;
+        const pointer _Oldlast  = _Mylast;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _Oldlast >= _Whereptr,
+            "vector insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto _Whereoff        = static_cast<size_type>(_Whereptr - _Oldfirst);
+        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
+        const bool _One_at_back     = _Count == 1 && _Whereptr == _Oldlast;
+        if (_Count == 0) { // nothing to do, avoid invalidating iterators
+        } else if (_Count > _Unused_capacity) { // reallocate
+            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);
+
+            if (_Count > max_size() - _Oldsize) {
+                _Xlength();
+            }
+
+            const size_type _Newsize = _Oldsize + _Count;
+            size_type _Newcapacity   = _Calculate_growth(_Newsize);
+
+            const pointer _Newvec           = _Allocate_at_least_helper(_Al, _Newcapacity);
+            const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
+
+            _Reallocation_guard2 _Guard{_Al, _Newvec, _Newcapacity, _Constructed_last, _Constructed_last};
+            auto& _Constructed_first = _Guard._Constructed_first;
+
+            _Uninitialized_fill_n(_Newvec + _Whereoff, _Count, _Val, _Al);
+            _Constructed_first = _Newvec + _Whereoff;
+
+            if (_One_at_back) { // provide strong guarantee
+                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                    _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+                } else {
+                    _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
+                }
+            } else { // provide basic guarantee
+                _Uninitialized_move(_Oldfirst, _Whereptr, _Newvec, _Al);
+                _Constructed_first = _Newvec;
+                _Uninitialized_move(_Whereptr, _Oldlast, _Newvec + _Whereoff + _Count, _Al);
+            }
+
+            _Guard._New_begin = nullptr;
+            _Change_array(_Newvec, _Newsize, _Newcapacity);
+        } else if (_One_at_back) { // provide strong guarantee
+            _Emplace_back_with_unused_capacity(_Val);
+        } else { // provide basic guarantee
+            const _Alloc_temporary2<_Alty> _Tmp_storage(_Al, _Val); // handle aliasing
+            const auto& _Tmp              = _Tmp_storage._Get_value();
+            const auto _Affected_elements = static_cast<size_type>(_Oldlast - _Whereptr);
+            _Orphan_range(_Whereptr, _Oldlast);
+
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _My_data._Myfirst) + _Count);
+            if (_Count > _Affected_elements) { // new stuff spills off end
+                _Mylast = _Uninitialized_fill_n(_Oldlast, _Count - _Affected_elements, _Tmp, _Al);
+                _Mylast = _Uninitialized_move(_Whereptr, _Oldlast, _Mylast, _Al);
+                _STD fill(_Whereptr, _Oldlast, _Tmp);
+            } else { // new stuff can all be assigned
+                _Mylast = _Uninitialized_move(_Oldlast - _Count, _Oldlast, _Oldlast, _Al);
+                _Move_backward_unchecked(_Whereptr, _Oldlast - _Count, _Oldlast);
+                _STD fill_n(_Whereptr, _Count, _Tmp);
+            }
+            _ASAN_VECTOR_RELEASE_GUARD;
+        }
+
+        return _Make_iterator_offset(_Whereoff);
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Insert_uncounted_range(const_iterator _Where, _Iter _First, _Sent _Last) {
+        // insert range [_First, _Last) at _Where
+        if (_First == _Last) {
+            return; // nothing to do, avoid invalidating iterators
+        }
+
+        auto& _My_data       = _Mypair._Myval2;
+        pointer& _Myfirst    = _My_data._Myfirst;
+        pointer& _Mylast     = _My_data._Mylast;
+        const auto _Whereoff = static_cast<size_type>(_Where._Ptr - _Myfirst);
+        const auto _Oldsize  = static_cast<size_type>(_Mylast - _Myfirst);
+
+        _Append_uncounted_range(_STD move(_First), _STD move(_Last));
+
+        _Orphan_range(_Myfirst + _Whereoff, _Myfirst + _Oldsize);
+
+        _STD rotate(_Myfirst + _Whereoff, _Myfirst + _Oldsize, _Mylast);
+    }
+
+    template <class _Iter>
+    _CONSTEXPR20 void _Insert_counted_range(const_iterator _Where, _Iter _First, const size_type _Count) {
+        // insert counted range _First + [0, _Count) at _Where
+        const pointer _Whereptr = _Where._Ptr;
+
+        auto& _Al        = _Getal();
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+        const pointer _Oldfirst     = _My_data._Myfirst;
+        const pointer _Oldlast      = _Mylast;
+        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
+
+        if (_Count == 0) { // nothing to do, avoid invalidating iterators
+        } else if (_Count > _Unused_capacity) { // reallocate
+            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);
+
+            if (_Count > max_size() - _Oldsize) {
+                _Xlength();
+            }
+
+            const size_type _Newsize = _Oldsize + _Count;
+            size_type _Newcapacity   = _Calculate_growth(_Newsize);
+
+            const pointer _Newvec           = _STD _Allocate_at_least_helper(_Al, _Newcapacity);
+            const auto _Whereoff            = static_cast<size_type>(_Whereptr - _Oldfirst);
+            const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
+
+            _Reallocation_guard2 _Guard{_Al, _Newvec, _Newcapacity, _Constructed_last, _Constructed_last};
+            auto& _Constructed_first = _Guard._Constructed_first;
+
+            _STD _Uninitialized_copy_n(_STD move(_First), _Count, _Newvec + _Whereoff, _Al);
+            _Constructed_first = _Newvec + _Whereoff;
+
+            if (_Count == 1 && _Whereptr == _Oldlast) { // one at back, provide strong guarantee
+                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+                    _STD _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
+                } else {
+                    _STD _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
+                }
+            } else { // provide basic guarantee
+                _STD _Uninitialized_move(_Oldfirst, _Whereptr, _Newvec, _Al);
+                _Constructed_first = _Newvec;
+                _STD _Uninitialized_move(_Whereptr, _Oldlast, _Newvec + _Whereoff + _Count, _Al);
+            }
+
+            _Guard._New_begin = nullptr;
+            _Change_array(_Newvec, _Newsize, _Newcapacity);
+        } else { // Attempt to provide the strong guarantee for EmplaceConstructible failure.
+                 // If we encounter copy/move construction/assignment failure, provide the basic guarantee.
+                 // (For one-at-back, this provides the strong guarantee.)
+
+            const auto _Affected_elements = static_cast<size_type>(_Oldlast - _Whereptr);
+
+            _ASAN_VECTOR_EXTEND_GUARD(static_cast<size_type>(_Oldlast - _Oldfirst) + _Count);
+            if (_Count < _Affected_elements) { // some affected elements must be assigned
+                _Mylast = _STD _Uninitialized_move(_Oldlast - _Count, _Oldlast, _Oldlast, _Al);
+                _STD _Move_backward_unchecked(_Whereptr, _Oldlast - _Count, _Oldlast);
+                _STD _Destroy_range(_Whereptr, _Whereptr + _Count, _Al);
+
+                _TRY_BEGIN
+                _STD _Uninitialized_copy_n(_STD move(_First), _Count, _Whereptr, _Al);
+                _CATCH_ALL
+                // glue the broken pieces back together
+
+                _Vaporization_guard _Guard{this, _Whereptr, _Oldlast, _Whereptr + _Count};
+                _STD _Uninitialized_move(_Whereptr + _Count, _Whereptr + 2 * _Count, _Whereptr, _Al);
+                _Guard._Target = nullptr;
+
+                _STD _Move_unchecked(_Whereptr + 2 * _Count, _Mylast, _Whereptr + _Count);
+                _STD _Destroy_range(_Oldlast, _Mylast, _Al);
+                _Mylast = _Oldlast;
+                _RERAISE;
+                _CATCH_END
+            } else { // affected elements don't overlap before/after
+                const pointer _Relocated = _Whereptr + _Count;
+                _Mylast                  = _STD _Uninitialized_move(_Whereptr, _Oldlast, _Relocated, _Al);
+                _STD _Destroy_range(_Whereptr, _Oldlast, _Al);
+
+                _TRY_BEGIN
+                _STD _Uninitialized_copy_n(_STD move(_First), _Count, _Whereptr, _Al);
+                _CATCH_ALL
+                // glue the broken pieces back together
+
+                _Vaporization_guard _Guard{this, _Whereptr, _Oldlast, _Relocated};
+                _STD _Uninitialized_move(_Relocated, _Mylast, _Whereptr, _Al);
+                _Guard._Target = nullptr;
+
+                _STD _Destroy_range(_Relocated, _Mylast, _Al);
+                _Mylast = _Oldlast;
+                _RERAISE;
+                _CATCH_END
+            }
+
+            _Orphan_range(_Whereptr, _Oldlast);
+            _ASAN_VECTOR_RELEASE_GUARD;
+        }
+    }
+
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldfirst = _My_data._Myfirst;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr,
+            "vector insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst         = _STD _Get_unwrapped(_First);
+        auto _ULast          = _STD _Get_unwrapped(_Last);
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Insert_counted_range(_Where, _UFirst, _Count);
+#if _HAS_CXX20
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _STD _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Insert_counted_range(_Where, _UFirst, _Count);
+#endif // _HAS_CXX20
+        } else {
+            _Insert_uncounted_range(_Where, _UFirst, _ULast);
+        }
+        return _Make_iterator_offset(_Whereoff);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldfirst = _My_data._Myfirst;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr,
+            "vector insert_range iterator out-of-range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Insert_counted_range(_Where, _RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Insert_uncounted_range(_Where, _RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+        return _Make_iterator_offset(_Whereoff);
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        const pointer _Oldfirst = _My_data._Myfirst;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _Oldfirst && _My_data._Mylast >= _Whereptr,
+            "vector insert iterator out-of-range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
+
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Insert_counted_range(_Where, _Ilist.begin(), _Count);
+        return _Make_iterator_offset(_Whereoff);
+    }
+
+    _CONSTEXPR20 void assign(_CRT_GUARDOVERFLOW const size_type _Newsize, const _Ty& _Val) {
+        // assign _Newsize * _Val
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            const auto _Valptr = _STD addressof(_Val);
+            _STL_VERIFY(!(_Unfancy(_Myfirst) <= _Valptr && _Valptr < _Unfancy(_Mylast)),
+                "assignment value cannot be a reference into the container");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        constexpr bool _Nothrow_construct =
+            conjunction_v<is_nothrow_copy_constructible<_Ty>, _Uses_default_construct<_Alloc, _Ty*, const _Ty&>>;
+
+        _My_data._Orphan_all();
+        const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
+        if (_Newsize > _Oldcapacity) { // reallocate
+            _Clear_and_reserve_geometric(_Newsize);
+            if constexpr (_Nothrow_construct) {
+                _Mylast = _Uninitialized_fill_n(_Myfirst, _Newsize, _Val, _Al);
+                _ASAN_VECTOR_CREATE;
+            } else {
+                _ASAN_VECTOR_CREATE_GUARD;
+                _Mylast = _Uninitialized_fill_n(_Myfirst, _Newsize, _Val, _Al);
+            }
+
+            return;
+        }
+
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize > _Oldsize) {
+            _STD fill(_Myfirst, _Mylast, _Val);
+            if constexpr (_Nothrow_construct) {
+                _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+                _Mylast = _Uninitialized_fill_n(_Mylast, _Newsize - _Oldsize, _Val, _Al);
+            } else {
+                _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
+                _Mylast = _Uninitialized_fill_n(_Mylast, _Newsize - _Oldsize, _Val, _Al);
+                _ASAN_VECTOR_RELEASE_GUARD;
+            }
+        } else {
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _STD fill(_Myfirst, _Newlast, _Val);
+            _Destroy_range(_Newlast, _Mylast, _Al);
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+            _Mylast = _Newlast;
+        }
+    }
+
+private:
+    template <class _Iter, class _Sent>
+    _CONSTEXPR20 void _Assign_uncounted_range(_Iter _First, _Sent _Last) {
+        // assign unknown number of elements from [_First, _Last)
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        _My_data._Orphan_all();
+
+        pointer _Next = _Myfirst;
+        for (; _First != _Last && _Next != _Mylast; ++_First, (void) ++_Next) {
+            *_Next = *_First;
+        }
+
+        // Code size optimization: we've exhausted only the source, only the dest, or both.
+        // If we've exhausted only the source: we Trim, then Append does nothing.
+        // If we've exhausted only the dest: Trim does nothing, then we Append.
+        // If we've exhausted both: Trim does nothing, then Append does nothing.
+
+        // Trim.
+        _Destroy_range(_Next, _Mylast, _Getal());
+        _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Next - _Mylast)); // negative when destroying elements
+        _Mylast = _Next;
+
+        _Append_uncounted_range(_STD move(_First), _STD move(_Last));
+    }
+
+    template <class _Iter>
+    _CONSTEXPR20 void _Assign_counted_range(_Iter _First, const size_type _Newsize) {
+        // assign elements from counted range _First + [0, _Newsize)
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+        constexpr bool _Nothrow_construct = conjunction_v<is_nothrow_constructible<_Ty, _Iter_ref_t<_Iter>>,
+            _Uses_default_construct<_Alloc, _Ty*, _Iter_ref_t<_Iter>>>;
+
+        _My_data._Orphan_all();
+        const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
+        if (_Newsize > _Oldcapacity) {
+            _Clear_and_reserve_geometric(_Newsize);
+            if constexpr (_Nothrow_construct) {
+                _Mylast = _STD _Uninitialized_copy_n(_STD move(_First), _Newsize, _Myfirst, _Al);
+                _ASAN_VECTOR_CREATE;
+            } else {
+                _ASAN_VECTOR_CREATE_GUARD;
+                _Mylast = _STD _Uninitialized_copy_n(_STD move(_First), _Newsize, _Myfirst, _Al);
+            }
+            return;
+        }
+
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize > _Oldsize) {
+            bool _Copied = false;
+            if constexpr (_Iter_copy_cat<_Iter, pointer>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+                if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+                {
+                    _Copy_memmove_n(_First, static_cast<size_t>(_Oldsize), _Myfirst);
+                    _First += _Oldsize;
+                    _Copied = true;
+                }
+            }
+
+            if (!_Copied) {
+                for (auto _Mid = _Myfirst; _Mid != _Mylast; ++_Mid, (void) ++_First) {
+                    *_Mid = *_First;
+                }
+            }
+
+            if constexpr (_Nothrow_construct) {
+                _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+                _Mylast = _STD _Uninitialized_copy_n(_STD move(_First), _Newsize - _Oldsize, _Mylast, _Al);
+            } else {
+                _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
+                _Mylast = _STD _Uninitialized_copy_n(_STD move(_First), _Newsize - _Oldsize, _Mylast, _Al);
+                _ASAN_VECTOR_RELEASE_GUARD;
+            }
+        } else {
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _STD _Copy_n_unchecked4(_STD move(_First), _Newsize, _Myfirst);
+            _STD _Destroy_range(_Newlast, _Mylast, _Al);
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+            _Mylast = _Newlast;
+        }
+    }
+
+public:
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 void assign(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst = _STD _Get_unwrapped(_First);
+        auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_UFirst, _Count);
+#if _HAS_CXX20
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _STD _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_UFirst, _Count);
+#endif // _HAS_CXX20
+        } else {
+            _Assign_uncounted_range(_UFirst, _ULast);
+        }
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Ty> _Rng>
+    constexpr void assign_range(_Rng&& _Range) {
+        static_assert(assignable_from<_Ty&, _RANGES range_reference_t<_Rng>>,
+            "Elements must be assignable from the range's reference type (N4993 [sequence.reqmts]/60).");
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void assign(const initializer_list<_Ty> _Ilist) {
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Assign_counted_range(_Ilist.begin(), _Count);
+    }
+
+    _CONSTEXPR20 vector& operator=(const vector& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al       = _Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alty>) {
+            if (_Al != _Right_al) {
+                _Tidy();
+                _Mypair._Myval2._Reload_proxy(_STD _Get_proxy_allocator(_Al), _STD _Get_proxy_allocator(_Right_al));
+            }
+        }
+
+        _Pocca(_Al, _Right_al);
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _Assign_counted_range(_Right_data._Myfirst, static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst));
+
+        return *this;
+    }
+
+    _CONSTEXPR20 vector& operator=(initializer_list<_Ty> _Ilist) {
+        const auto _Count = _Convert_size<size_type>(_Ilist.size());
+        _Assign_counted_range(_Ilist.begin(), _Count);
+        return *this;
+    }
+
+private:
+    template <class _Ty2>
+    _CONSTEXPR20 void _Resize_reallocate(const size_type _Newsize, const _Ty2& _Val) {
+        if (_Newsize > max_size()) {
+            _Xlength();
+        }
+
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        const auto _Oldsize    = static_cast<size_type>(_Mylast - _Myfirst);
+        size_type _Newcapacity = _Calculate_growth(_Newsize);
+
+        const pointer _Newvec         = _Allocate_at_least_helper(_Al, _Newcapacity);
+        const pointer _Appended_first = _Newvec + _Oldsize;
+
+        _Reallocation_guard2 _Guard{_Al, _Newvec, _Newcapacity, _Appended_first, _Appended_first};
+        auto& _Appended_last = _Guard._Constructed_last;
+
+        if constexpr (is_same_v<_Ty2, _Ty>) {
+            _Appended_last = _Uninitialized_fill_n(_Appended_first, _Newsize - _Oldsize, _Val, _Al);
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty2, _Value_init_tag>);
+            _Appended_last = _Uninitialized_value_construct_n(_Appended_first, _Newsize - _Oldsize, _Al);
+        }
+
+        if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+            _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
+        } else {
+            _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
+        }
+
+        _Guard._New_begin = nullptr;
+        _Change_array(_Newvec, _Newsize, _Newcapacity);
+    }
+
+    template <class _Ty2>
+    _CONSTEXPR20 void _Resize(const size_type _Newsize, const _Ty2& _Val) {
+        // trim or append elements, provide strong guarantee
+        auto& _Al           = _Getal();
+        auto& _My_data      = _Mypair._Myval2;
+        pointer& _Myfirst   = _My_data._Myfirst;
+        pointer& _Mylast    = _My_data._Mylast;
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize < _Oldsize) { // trim
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _Orphan_range(_Newlast, _Mylast);
+            _Destroy_range(_Newlast, _Mylast, _Al);
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+            _Mylast = _Newlast;
+            return;
+        }
+
+        if (_Newsize > _Oldsize) { // append
+            const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
+            if (_Newsize > _Oldcapacity) { // reallocate
+                _Resize_reallocate(_Newsize, _Val);
+                return;
+            }
+
+            _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
+            const pointer _Oldlast = _Mylast;
+            if constexpr (is_same_v<_Ty2, _Ty>) {
+                _Mylast = _Uninitialized_fill_n(_Oldlast, _Newsize - _Oldsize, _Val, _Al);
+            } else {
+                _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty2, _Value_init_tag>);
+                _Mylast = _Uninitialized_value_construct_n(_Oldlast, _Newsize - _Oldsize, _Al);
+            }
+            _ASAN_VECTOR_RELEASE_GUARD;
+            _Orphan_range(_Oldlast, _Oldlast);
+        }
+
+        // if _Newsize == _Oldsize, do nothing; avoid invalidating iterators
+    }
+
+public:
+    _CONSTEXPR20 void resize(_CRT_GUARDOVERFLOW const size_type _Newsize) {
+        // trim or append value-initialized elements, provide strong guarantee
+        _Resize(_Newsize, _Value_init_tag{});
+    }
+
+    _CONSTEXPR20 void resize(_CRT_GUARDOVERFLOW const size_type _Newsize, const _Ty& _Val) {
+        // trim or append copies of _Val, provide strong guarantee
+        _Resize(_Newsize, _Val);
+    }
+
+private:
+    enum class _Reallocation_policy { _At_least, _Exactly };
+
+    template <_Reallocation_policy _Policy>
+    _CONSTEXPR20 void _Reallocate(size_type& _Newcapacity) {
+        // set capacity to _Newcapacity (without geometric growth), provide strong guarantee
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        const auto _Size = static_cast<size_type>(_Mylast - _Myfirst);
+
+        pointer _Newvec;
+        if constexpr (_Policy == _Reallocation_policy::_At_least) {
+            _Newvec = _Allocate_at_least_helper(_Al, _Newcapacity);
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(_Policy == _Reallocation_policy::_Exactly);
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-11060638
+            _Newvec = _Al.allocate(_Newcapacity) + decltype(pointer{} - pointer{}){0};
+#else // ^^^ workaround / no workaround vvv
+            _Newvec = _Al.allocate(_Newcapacity);
+#endif // ^^^ no workaround ^^^
+        }
+
+        _Allocation_guard<_Alty> _Guard{_Al, _Newvec, _Newcapacity};
+
+        if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
+            _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
+        } else {
+            _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
+        }
+
+        _Guard._Ptr = nullptr;
+        _Change_array(_Newvec, _Size, _Newcapacity);
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0 && defined(_ENABLE_STL_INTERNAL_CHECK)
+    void _Check_all_orphaned_locked() const noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        auto& _My_data = _Mypair._Myval2;
+        _STL_INTERNAL_CHECK(!_My_data._Myproxy->_Myfirstiter);
+    }
+
+    _CONSTEXPR20 void _Check_all_orphaned() const noexcept {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            auto& _My_data = _Mypair._Myval2;
+            _STL_INTERNAL_CHECK(!_My_data._Myproxy->_Myfirstiter);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Check_all_orphaned_locked();
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0 && defined(_ENABLE_STL_INTERNAL_CHECK)
+
+    _CONSTEXPR20 void _Clear_and_reserve_geometric(const size_type _Newsize) {
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+#if _ITERATOR_DEBUG_LEVEL != 0 && defined(_ENABLE_STL_INTERNAL_CHECK)
+        _STL_INTERNAL_CHECK(_Newsize != 0);
+        _Check_all_orphaned();
+#endif // _ITERATOR_DEBUG_LEVEL != 0 && defined(_ENABLE_STL_INTERNAL_CHECK)
+
+        if (_Newsize > max_size()) {
+            _Xlength();
+        }
+
+        const size_type _Newcapacity = _Calculate_growth(_Newsize);
+
+        if (_Myfirst) { // destroy and deallocate old array
+            _Destroy_range(_Myfirst, _Mylast, _Al);
+            _ASAN_VECTOR_REMOVE;
+            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
+
+            _Myfirst = nullptr;
+            _Mylast  = nullptr;
+            _Myend   = nullptr;
+        }
+
+        _Buy_raw(_Newcapacity);
+    }
+
+public:
+    _CONSTEXPR20 void reserve(_CRT_GUARDOVERFLOW size_type _Newcapacity) {
+        // increase capacity to _Newcapacity (without geometric growth), provide strong guarantee
+        if (_Newcapacity > capacity()) { // something to do (reserve() never shrinks)
+            if (_Newcapacity > max_size()) {
+                _Xlength();
+            }
+
+            _Reallocate<_Reallocation_policy::_At_least>(_Newcapacity);
+        }
+    }
+
+    _CONSTEXPR20 void shrink_to_fit() { // reduce capacity to size, provide strong guarantee
+        auto& _My_data         = _Mypair._Myval2;
+        const pointer _Oldlast = _My_data._Mylast;
+        if (_Oldlast != _My_data._Myend) { // something to do
+            const pointer _Oldfirst = _My_data._Myfirst;
+            if (_Oldfirst == _Oldlast) {
+                _Tidy();
+            } else {
+                size_type _Newcapacity = static_cast<size_type>(_Oldlast - _Oldfirst);
+                _Reallocate<_Reallocation_policy::_Exactly>(_Newcapacity);
+            }
+        }
+    }
+
+    _CONSTEXPR20 void pop_back() noexcept /* strengthened */ {
+        auto& _My_data   = _Mypair._Myval2;
+        pointer& _Mylast = _My_data._Mylast;
+
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_My_data._Myfirst != _Mylast, "pop_back() called on empty vector");
+#endif
+
+        _Orphan_range(_Mylast - 1, _Mylast);
+        _Alty_traits::destroy(_Getal(), _Unfancy(_Mylast - 1));
+        _ASAN_VECTOR_MODIFY(-1);
+        --_Mylast;
+    }
+
+    _CONSTEXPR20 iterator erase(const_iterator _Where)
+        noexcept(is_nothrow_move_assignable_v<value_type>) /* strengthened */ {
+        const pointer _Whereptr = _Where._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        pointer& _Mylast        = _My_data._Mylast;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(
+            _Where._Getcont() == _STD addressof(_My_data) && _Whereptr >= _My_data._Myfirst && _Mylast > _Whereptr,
+            "vector erase iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Orphan_range(_Whereptr, _Mylast);
+        _STD _Move_unchecked(_Whereptr + 1, _Mylast, _Whereptr);
+        _Alty_traits::destroy(_Getal(), _Unfancy(_Mylast - 1));
+        _ASAN_VECTOR_MODIFY(-1);
+        --_Mylast;
+        return iterator(_Whereptr, _STD addressof(_My_data));
+    }
+
+    _CONSTEXPR20 iterator erase(const_iterator _First, const_iterator _Last)
+        noexcept(is_nothrow_move_assignable_v<value_type>) /* strengthened */ {
+        const pointer _Firstptr = _First._Ptr;
+        const pointer _Lastptr  = _Last._Ptr;
+        auto& _My_data          = _Mypair._Myval2;
+        pointer& _Mylast        = _My_data._Mylast;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_My_data) && _Last._Getcont() == _STD addressof(_My_data)
+                        && _Firstptr >= _My_data._Myfirst && _Lastptr >= _Firstptr && _Mylast >= _Lastptr,
+            "vector erase iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Firstptr != _Lastptr) { // something to do, invalidate iterators
+            _Orphan_range(_Firstptr, _Mylast);
+
+            const pointer _Newlast = _STD _Move_unchecked(_Lastptr, _Mylast, _Firstptr);
+            _Destroy_range(_Newlast, _Mylast, _Getal());
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newlast - _Mylast)); // negative when destroying elements
+            _Mylast = _Newlast;
+        }
+
+        return iterator(_Firstptr, _STD addressof(_My_data));
+    }
+
+    _CONSTEXPR20 void clear() noexcept { // erase all
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        if (_Myfirst == _Mylast) { // already empty, nothing to do
+            // This is an optimization for debug mode: we can avoid taking the debug lock to invalidate iterators.
+            // Note that when clearing an empty vector, this will preserve past-the-end iterators, which is allowed by
+            // N4950 [sequence.reqmts]/54 "a.clear() [...] may invalidate the past-the-end iterator".
+            return;
+        }
+
+        _My_data._Orphan_all();
+        _Destroy_range(_Myfirst, _Mylast, _Getal());
+        _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Myfirst - _Mylast)); // negative when destroying elements
+        _Mylast = _Myfirst;
+    }
+
+    _CONSTEXPR20 void swap(vector& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+            _Mypair._Myval2._Swap_val(_Right._Mypair._Myval2);
+        }
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty* data() noexcept {
+        return _STD _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty* data() const noexcept {
+        return _STD _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator begin() noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return iterator(_My_data._Myfirst, _STD addressof(_My_data));
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator begin() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return const_iterator(_My_data._Myfirst, _STD addressof(_My_data));
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator end() noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return iterator(_My_data._Mylast, _STD addressof(_My_data));
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator end() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return const_iterator(_My_data._Mylast, _STD addressof(_My_data));
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty* _Unchecked_begin() noexcept {
+        return _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty* _Unchecked_begin() const noexcept {
+        return _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty* _Unchecked_end() noexcept {
+        return _Unfancy_maybe_null(_Mypair._Myval2._Mylast);
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty* _Unchecked_end() const noexcept {
+        return _Unfancy_maybe_null(_Mypair._Myval2._Mylast);
+    }
+
+    _NODISCARD_EMPTY_MEMBER _CONSTEXPR20 bool empty() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return _My_data._Myfirst == _My_data._Mylast;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type size() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type max_size() const noexcept {
+        constexpr auto _Diff_max = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        return (_STD min) (_Diff_max, _Alty_traits::max_size(_Getal()));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type capacity() const noexcept {
+        auto& _My_data = _Mypair._Myval2;
+        return static_cast<size_type>(_My_data._Myend - _My_data._Myfirst);
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& operator[](const size_type _Pos) noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(
+            _Pos < static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst), "vector subscript out of range");
+#endif
+
+        return _My_data._Myfirst[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty& operator[](const size_type _Pos) const noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(
+            _Pos < static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst), "vector subscript out of range");
+#endif
+
+        return _My_data._Myfirst[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& at(const size_type _Pos) {
+        auto& _My_data = _Mypair._Myval2;
+        if (static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst) <= _Pos) {
+            _Xrange();
+        }
+
+        return _My_data._Myfirst[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty& at(const size_type _Pos) const {
+        auto& _My_data = _Mypair._Myval2;
+        if (static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst) <= _Pos) {
+            _Xrange();
+        }
+
+        return _My_data._Myfirst[_Pos];
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& front() noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_My_data._Myfirst != _My_data._Mylast, "front() called on empty vector");
+#endif
+
+        return *_My_data._Myfirst;
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty& front() const noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_My_data._Myfirst != _My_data._Mylast, "front() called on empty vector");
+#endif
+
+        return *_My_data._Myfirst;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ty& back() noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_My_data._Myfirst != _My_data._Mylast, "back() called on empty vector");
+#endif
+
+        return _My_data._Mylast[-1];
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Ty& back() const noexcept /* strengthened */ {
+        auto& _My_data = _Mypair._Myval2;
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_My_data._Myfirst != _My_data._Mylast, "back() called on empty vector");
+#endif
+
+        return _My_data._Mylast[-1];
+    }
+
+    _NODISCARD _CONSTEXPR20 allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+private:
+    _CONSTEXPR20 size_type _Calculate_growth(const size_type _Newsize) const {
+        // given _Oldcapacity and _Newsize, calculate geometric growth
+        const size_type _Oldcapacity = capacity();
+        const auto _Max              = max_size();
+
+        if (_Oldcapacity > _Max - _Oldcapacity / 2) {
+            return _Max; // geometric growth would overflow
+        }
+
+        const size_type _Geometric = _Oldcapacity + _Oldcapacity / 2;
+
+        if (_Geometric < _Newsize) {
+            return _Newsize; // geometric growth would be insufficient
+        }
+
+        return _Geometric; // geometric growth is sufficient
+    }
+
+    _CONSTEXPR20 void _Buy_raw(size_type _Newcapacity) {
+        // allocate array with _Newcapacity elements
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+        _STL_INTERNAL_CHECK(!_Myfirst && !_Mylast && !_Myend); // check that *this is tidy
+        _STL_INTERNAL_CHECK(0 < _Newcapacity && _Newcapacity <= max_size());
+
+        const pointer _Newvec = _STD _Allocate_at_least_helper(_Getal(), _Newcapacity);
+        _Myfirst              = _Newvec;
+        _Mylast               = _Newvec;
+        _Myend                = _Newvec + _Newcapacity;
+    }
+
+    _CONSTEXPR20 void _Buy_nonzero(const size_type _Newcapacity) {
+        // allocate array with _Newcapacity elements
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+        _STL_INTERNAL_CHECK(!_Myfirst && !_Mylast && !_Myend); // check that *this is tidy
+        _STL_INTERNAL_CHECK(0 < _Newcapacity);
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+        if (_Newcapacity > max_size()) {
+            _Xlength();
+        }
+
+        _Buy_raw(_Newcapacity);
+    }
+
+    _CONSTEXPR20 void _Change_array(
+        const pointer _Newvec, const size_type _Newsize, const size_type _Newcapacity) noexcept {
+        // orphan all iterators, discard old array, acquire new array
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+        _My_data._Orphan_all();
+
+        if (_Myfirst) { // destroy and deallocate old array
+            _STD _Destroy_range(_Myfirst, _Mylast, _Al);
+            _ASAN_VECTOR_REMOVE;
+            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
+        }
+
+        _Myfirst = _Newvec;
+        _Mylast  = _Newvec + static_cast<_Iter_diff_t<pointer>>(_Newsize);
+        _Myend   = _Newvec + static_cast<_Iter_diff_t<pointer>>(_Newcapacity);
+        _ASAN_VECTOR_CREATE;
+    }
+
+    _CONSTEXPR20 void _Tidy() noexcept { // free all storage
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+        pointer& _Myend   = _My_data._Myend;
+
+        _My_data._Orphan_all();
+
+        if (_Myfirst) { // destroy and deallocate old array
+            _STD _Destroy_range(_Myfirst, _Mylast, _Al);
+            _ASAN_VECTOR_REMOVE;
+            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
+
+            _Myfirst = nullptr;
+            _Mylast  = nullptr;
+            _Myend   = nullptr;
+        }
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 void _Construct_n(_CRT_GUARDOVERFLOW const size_type _Count, _Valty&&... _Val) {
+        // Dispatches between the three sized constructions.
+        // 1-arg -> value-construction, e.g. vector(5)
+        // 2-arg -> fill, e.g. vector(5, "meow")
+        // 3-arg -> sized range construction, e.g. vector{"Hello", "Fluffy", "World"}
+        auto& _Al      = _Getal();
+        auto _Alproxy  = _STD _Get_proxy_allocator(_Al);
+        auto& _My_data = _Mypair._Myval2;
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
+        if (_Count != 0) {
+            _Buy_nonzero(_Count);
+            _Tidy_guard<vector> _Guard{this};
+            if constexpr (sizeof...(_Val) == 0) {
+                _My_data._Mylast = _STD _Uninitialized_value_construct_n(_My_data._Myfirst, _Count, _Al);
+            } else if constexpr (sizeof...(_Val) == 1) {
+                _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Valty..., const _Ty&>);
+                _My_data._Mylast = _STD _Uninitialized_fill_n(_My_data._Myfirst, _Count, _Val..., _Al);
+            } else if constexpr (sizeof...(_Val) == 2) {
+                _My_data._Mylast = _STD _Uninitialized_copy(_STD forward<_Valty>(_Val)..., _My_data._Myfirst, _Al);
+            } else {
+                static_assert(false, "unexpected number of arguments");
+            }
+            _ASAN_VECTOR_CREATE;
+            _Guard._Target = nullptr;
+        }
+
+        _Proxy._Release();
+    }
+
+    _CONSTEXPR20 void _Move_assign_unequal_alloc(vector& _Right) {
+        auto& _Al         = _Getal();
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+
+        const pointer _First = _Right_data._Myfirst;
+        const pointer _Last  = _Right_data._Mylast;
+        const auto _Newsize  = static_cast<size_type>(_Last - _First);
+
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
+
+        constexpr bool _Nothrow_construct =
+            conjunction_v<is_nothrow_move_constructible<_Ty>, _Uses_default_construct<_Alloc, _Ty*, _Ty>>;
+
+        _My_data._Orphan_all();
+        const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
+        if (_Newsize > _Oldcapacity) {
+            _Clear_and_reserve_geometric(_Newsize);
+            if constexpr (_Nothrow_construct) {
+                _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
+                _ASAN_VECTOR_CREATE;
+            } else {
+                _ASAN_VECTOR_CREATE_GUARD;
+                _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
+            }
+
+            return;
+        }
+
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize > _Oldsize) {
+            const pointer _Mid = _First + _Oldsize;
+            _STD _Move_unchecked(_First, _Mid, _Myfirst);
+
+            if constexpr (_Nothrow_construct) {
+                _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+                _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
+            } else {
+                _ASAN_VECTOR_EXTEND_GUARD(_Newsize);
+                _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
+                _ASAN_VECTOR_RELEASE_GUARD;
+            }
+        } else {
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _STD _Move_unchecked(_First, _Last, _Myfirst);
+            _Destroy_range(_Newlast, _Mylast, _Al);
+            _ASAN_VECTOR_MODIFY(static_cast<difference_type>(_Newsize - _Oldsize));
+            _Mylast = _Newlast;
+        }
+    }
+
+    [[noreturn]] static void _Xlength() {
+        _Xlength_error("vector too long");
+    }
+
+    [[noreturn]] static void _Xrange() {
+        _Xout_of_range("invalid vector subscript");
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    _CONSTEXPR20 void _Orphan_range_unlocked(pointer _First, pointer _Last) const {
+        _Iterator_base12** _Pnext = &_Mypair._Myval2._Myproxy->_Myfirstiter;
+        while (*_Pnext) {
+            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
+            const auto _Temp     = *_Pnext;
+            if (_Pnextptr < _First || _Last < _Pnextptr) { // skip the iterator
+                _Pnext = &_Temp->_Mynextiter;
+            } else { // orphan the iterator
+                _Temp->_Myproxy = nullptr;
+                *_Pnext         = _Temp->_Mynextiter;
+            }
+        }
+    }
+
+    void _Orphan_range_locked(pointer _First, pointer _Last) const {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_range_unlocked(_First, _Last);
+    }
+
+    _CONSTEXPR20 void _Orphan_range(pointer _First, pointer _Last) const {
+        // orphan iterators within specified (inclusive) range
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Orphan_range_unlocked(_First, _Last);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Orphan_range_locked(_First, _Last);
+        }
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+    _CONSTEXPR20 void _Orphan_range(pointer, pointer) const {}
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+
+    _NODISCARD _CONSTEXPR20 _Alty& _Getal() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Alty& _Getal() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator _Make_iterator(const pointer _Ptr) noexcept {
+        return iterator(_Ptr, _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator _Make_iterator_offset(const size_type _Offset) noexcept {
+        // return the iterator begin() + _Offset without a debugging check
+        auto& _My_data = _Mypair._Myval2;
+        return iterator(_My_data._Myfirst + _Offset, _STD addressof(_My_data));
+    }
+
+    _Compressed_pair<_Alty, _Scary_val> _Mypair;
+};
+
+#if _HAS_CXX17
+template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+vector(_Iter, _Iter, _Alloc = _Alloc()) -> vector<_Iter_value_t<_Iter>, _Alloc>;
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+vector(from_range_t, _Rng&&, _Alloc = _Alloc()) -> vector<_RANGES range_value_t<_Rng>, _Alloc>;
+#endif // _HAS_CXX23
+
+template <class _Alloc>
+class vector<bool, _Alloc>;
+
+using _Vbase = unsigned int; // word type for vector<bool> representation
+
+_INLINE_VAR constexpr int _VBITS = 8 * sizeof(_Vbase); // at least CHAR_BITS bits per word
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator==(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    if (_Left.size() != _Right.size()) {
+        return false;
+    }
+
+    if constexpr (is_same_v<_Ty, bool>) {
+        return _STD equal(
+            _Left._Myvec._Unchecked_begin(), _Left._Myvec._Unchecked_end(), _Right._Myvec._Unchecked_begin());
+    } else {
+        return _STD equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
+    }
+}
+
+#if !_HAS_CXX20
+template <class _Ty, class _Alloc>
+_NODISCARD bool operator!=(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+// Optimize vector<bool> lexicographical comparisons.
+
+// There are several endianness/ordering issues to consider here.
+// * Machine endianness is irrelevant. (That affects how an unsigned int is stored
+//   as a sequence of bytes. While all of our supported architectures are little-endian,
+//   that's irrelevant as long as we avoid reinterpreting unsigned int as a sequence of bytes.)
+// * Appending bits to vector<bool> eventually appends words to its underlying storage.
+//   For example, vb[10] is stored within vb._Myvec[0], while vb[100] is stored within vb._Myvec[3].
+//   This allows us to translate lexicographical comparisons from theoretical bits to physical words.
+// * Unsigned integers are written and compared as big-endian (most significant bit first).
+//   For example, 0x10u > 0x07u.
+// * However, vector<bool> packs bits into words as little-endian (least significant bit first).
+//   For example, vector<bool>{false, true, true, true} stores 0b0000'0000'0000'0000'0000'0000'0000'1110u.
+// We could bit-reverse words before comparing, but we just need to find the least significant bit that differs.
+
+template <class _Ret>
+struct _Vbase_compare_three_way {
+    _NODISCARD static constexpr _Ret operator()(const _Vbase _Left, const _Vbase _Right) noexcept {
+        const _Vbase _Differing_bits = _Left ^ _Right;
+
+        if (_Differing_bits == 0) { // improves _Countr_zero codegen below
+#if _HAS_CXX20
+            return strong_ordering::equal;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            return 0;
+#endif // ^^^ !_HAS_CXX20 ^^^
+        }
+
+        const int _Bit_index = _Countr_zero(_Differing_bits); // number of least significant bits that match
+        _STL_INTERNAL_CHECK(_Bit_index < _VBITS); // because we return early for equality
+
+        const _Vbase _Mask = _Vbase{1} << _Bit_index; // selects the least significant bit that differs
+
+        // Instead of comparing (_Left & _Mask) to (_Right & _Mask), we know that exactly one side will be zero.
+#if _HAS_CXX20
+        return (_Left & _Mask) == 0 ? strong_ordering::less : strong_ordering::greater;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        return (_Left & _Mask) == 0 ? -1 : 1;
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc>
+_NODISCARD constexpr _Synth_three_way_result<_Ty> operator<=>(
+    const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    if constexpr (is_same_v<_Ty, bool>) {
+        // This optimization works because vector<bool> "trims" its underlying storage by zeroing out unused bits.
+        const auto _Min_word_size = (_STD min) (_Left._Myvec.size(), _Right._Myvec.size());
+        const auto _Left_words    = _Left._Myvec._Unchecked_begin();
+        const auto _Right_words   = _Right._Myvec._Unchecked_begin();
+
+        using _Comp = _Vbase_compare_three_way<strong_ordering>;
+
+        const strong_ordering _Word_comparison = _STD lexicographical_compare_three_way(
+            _Left_words, _Left_words + _Min_word_size, _Right_words, _Right_words + _Min_word_size, _Comp{});
+
+        if (_Word_comparison != 0) {
+            return _Word_comparison;
+        }
+
+        return _Left.size() <=> _Right.size();
+    } else {
+        return _STD lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
+            _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
+    }
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator<(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    if constexpr (is_same_v<_Ty, bool>) {
+        // This optimization works because vector<bool> "trims" its underlying storage by zeroing out unused bits.
+        auto _First = _Left._Myvec._Unchecked_begin();
+        auto _Other = _Right._Myvec._Unchecked_begin();
+
+        const auto _Last = _First + (_STD min) (_Left._Myvec.size(), _Right._Myvec.size());
+
+        for (; _First != _Last; ++_First, (void) ++_Other) {
+            using _Comp        = _Vbase_compare_three_way<signed char>;
+            const auto _Result = _Comp{}(*_First, *_Other);
+
+            if (_Result < 0) {
+                return true;
+            } else if (_Result > 0) {
+                return false;
+            }
+        }
+
+        return _Left.size() < _Right.size();
+    } else {
+        return _STD lexicographical_compare(
+            _Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin(), _Right._Unchecked_end());
+    }
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator>(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    return _Right < _Left;
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator<=(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    return !(_Right < _Left);
+}
+
+template <class _Ty, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator>=(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Ty, class _Alloc>
+_CONSTEXPR20 void swap(vector<_Ty, _Alloc>& _Left, vector<_Ty, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class _Alloc, class _Uty>
+constexpr vector<_Ty, _Alloc>::size_type erase(vector<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
+    return _STD _Erase_remove(_Cont, _Val);
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class _Pr>
+constexpr vector<_Ty, _Alloc>::size_type erase_if(vector<_Ty, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+template <class _Alloc0>
+struct _Wrap_alloc { // TRANSITION, ABI compat, preserves symbol names of vector<bool>::iterator
+    using _Alloc = _Alloc0;
+};
+
+template <class _Alvbase_wrapped>
+class _Vb_iter_base : public _Iterator_base {
+    // store information common to reference and iterators
+public:
+    using _Alvbase         = typename _Alvbase_wrapped::_Alloc;
+    using _Size_type       = typename allocator_traits<_Alvbase>::size_type;
+    using _Difference_type = typename allocator_traits<_Alvbase>::difference_type;
+    using _Mycont          = vector<bool, _Rebind_alloc_t<_Alvbase, bool>>;
+
+    static constexpr _Difference_type _VBITS_DIFF = _VBITS;
+
+    _CONSTEXPR20 _Vb_iter_base() = default;
+
+    _CONSTEXPR20 _Vb_iter_base(const _Vbase* _Ptr, _Size_type _Off, const _Container_base* _Mypvbool) noexcept
+        : _Myptr(_Ptr), _Myoff(_Off) {
+        this->_Adopt(_Mypvbool);
+    }
+
+    _CONSTEXPR20 void _Advance(_Size_type _Off) noexcept {
+        _Myoff += _Off;
+        _Myptr += _Myoff / _VBITS;
+        _Myoff %= _VBITS;
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+    _CONSTEXPR20 _Difference_type _Total_off(const _Mycont* _Cont) const noexcept {
+        return static_cast<_Difference_type>(_VBITS_DIFF * (_Myptr - _Cont->_Myvec.data()) + _Myoff);
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+    const _Vbase* _Myptr = nullptr;
+    _Size_type _Myoff    = 0;
+};
+
+template <class _Alvbase_wrapped>
+class _Vb_reference : public _Vb_iter_base<_Alvbase_wrapped> {
+    // reference to a bit within a base word
+private:
+    using _Mybase          = _Vb_iter_base<_Alvbase_wrapped>;
+    using _Mycont          = typename _Mybase::_Mycont;
+    using _Difference_type = typename _Mybase::_Difference_type;
+
+public:
+    _CONSTEXPR20 _Vb_reference(const _Vb_reference&) noexcept = default;
+
+    _CONSTEXPR20 _Vb_reference(const _Mybase& _Right) noexcept
+        : _Mybase(_Right._Myptr, _Right._Myoff, _Right._Getcont()) {}
+
+    _CONSTEXPR20 _Vb_reference& operator=(const _Vb_reference& _Right) noexcept {
+        return *this = static_cast<bool>(_Right);
+    }
+
+    _CONSTEXPR20 _Vb_reference& operator=(bool _Val) noexcept {
+        if (_Val) {
+            *const_cast<_Vbase*>(_Getptr()) |= _Mask();
+        } else {
+            *const_cast<_Vbase*>(_Getptr()) &= ~_Mask();
+        }
+
+        return *this;
+    }
+
+    _CONSTEXPR20 const _Vb_reference& operator=(bool _Val) const noexcept {
+        if (_Val) {
+            *const_cast<_Vbase*>(_Getptr()) |= _Mask();
+        } else {
+            *const_cast<_Vbase*>(_Getptr()) &= ~_Mask();
+        }
+
+        return *this;
+    }
+
+    _CONSTEXPR20 void flip() noexcept {
+        *const_cast<_Vbase*>(_Getptr()) ^= _Mask();
+    }
+
+    _CONSTEXPR20 operator bool() const noexcept {
+        return (*_Getptr() & _Mask()) != 0;
+    }
+
+    _CONSTEXPR20 const _Vbase* _Getptr() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot dereference value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) <= static_cast<_Difference_type>(_Cont->_Mysize),
+            "vector<bool> iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return this->_Myptr;
+    }
+
+    friend _CONSTEXPR20 void swap(_Vb_reference _Left, _Vb_reference _Right) noexcept {
+        bool _Val = _Left; // NOT _STD swap
+        _Left     = _Right;
+        _Right    = _Val;
+    }
+
+    friend _CONSTEXPR20 void swap(_Vb_reference _Left, bool& _Right) noexcept {
+        bool _Val = _Left; // NOT _STD swap
+        _Left     = _Right;
+        _Right    = _Val;
+    }
+
+    friend _CONSTEXPR20 void swap(bool& _Left, _Vb_reference _Right) noexcept {
+        swap(_Right, _Left);
+    }
+
+protected:
+    _CONSTEXPR20 _Vbase _Mask() const noexcept {
+        return static_cast<_Vbase>(1) << this->_Myoff;
+    }
+};
+
+template <class _Alvbase_wrapped>
+class _Vb_const_iterator : public _Vb_iter_base<_Alvbase_wrapped> {
+public:
+    using _Mybase         = _Vb_iter_base<_Alvbase_wrapped>;
+    using _Mycont         = typename _Mybase::_Mycont;
+    using _Size_type      = typename _Mybase::_Size_type;
+    using _Reft           = _Vb_reference<_Alvbase_wrapped>;
+    using const_reference = bool;
+
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = bool;
+    using difference_type   = typename _Mybase::_Difference_type;
+    using pointer           = const_reference*;
+    using reference         = const_reference;
+
+    _CONSTEXPR20 _Vb_const_iterator() = default;
+
+    _CONSTEXPR20 _Vb_const_iterator(const _Vbase* _Ptr, const _Container_base* _Mypvbool) noexcept
+        : _Mybase(_Ptr, 0, _Mypvbool) {}
+
+    _NODISCARD _CONSTEXPR20 const_reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot dereference value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) < static_cast<difference_type>(_Cont->_Mysize),
+            "vector<bool> iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Reft(*this);
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator& operator++() noexcept {
+        _Inc();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator operator++(int) noexcept {
+        _Vb_const_iterator _Tmp = *this;
+        _Inc();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator& operator--() noexcept {
+        _Dec();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator operator--(int) noexcept {
+        _Vb_const_iterator _Tmp = *this;
+        _Dec();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator& operator+=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if (_Off != 0) {
+            const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+            _STL_VERIFY(_Cont, "cannot seek value-initialized vector<bool> iterator");
+            const auto _Start_offset = this->_Total_off(_Cont);
+            if (_Off < 0) {
+                _STL_VERIFY(-_Start_offset <= _Off, "cannot seek vector<bool> iterator before begin");
+            } else if (0 < _Off) {
+                _STL_VERIFY(_Off <= static_cast<difference_type>(_Cont->_Mysize - _Start_offset),
+                    "cannot seek vector<bool> iterator after end");
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        if (_Off < 0 && this->_Myoff < 0 - static_cast<_Size_type>(_Off)) { // add negative increment
+            this->_Myoff += static_cast<_Size_type>(_Off);
+            this->_Myptr -= 1 + (static_cast<_Size_type>(-1) - this->_Myoff) / _VBITS;
+            this->_Myoff %= _VBITS;
+        } else { // add non-negative increment
+            this->_Myoff += static_cast<_Size_type>(_Off);
+            this->_Myptr += this->_Myoff / _VBITS;
+            this->_Myoff %= _VBITS;
+        }
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vb_const_iterator operator+(const difference_type _Off) const noexcept {
+        _Vb_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _Vb_const_iterator operator+(
+        const difference_type _Off, _Vb_const_iterator _Right) noexcept {
+        _Right += _Off;
+        return _Right;
+    }
+
+    _CONSTEXPR20 _Vb_const_iterator& operator-=(const difference_type _Off) noexcept {
+        return *this += -_Off;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vb_const_iterator operator-(const difference_type _Off) const noexcept {
+        _Vb_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 difference_type operator-(const _Vb_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return static_cast<difference_type>(_Mybase::_VBITS_DIFF * (this->_Myptr - _Right._Myptr))
+             + static_cast<difference_type>(this->_Myoff) - static_cast<difference_type>(_Right._Myoff);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD _CONSTEXPR20 bool operator==(const _Vb_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return this->_Myptr == _Right._Myptr && this->_Myoff == _Right._Myoff;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _Vb_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        if (const auto _CmpResult = this->_Myptr <=> _Right._Myptr; _CmpResult != 0) {
+            return _CmpResult;
+        }
+        return this->_Myoff <=> _Right._Myoff;
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const _Vb_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const _Vb_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return this->_Myptr < _Right._Myptr || (this->_Myptr == _Right._Myptr && this->_Myoff < _Right._Myoff);
+    }
+
+    _NODISCARD bool operator>(const _Vb_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const _Vb_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD bool operator>=(const _Vb_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR20 void _Compat(const _Vb_const_iterator& _Right) const noexcept {
+        // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL == 0
+        (void) _Right;
+#else
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "vector<bool> iterators incompatible");
+#endif
+    }
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+    using _Prevent_inheriting_unwrap = _Vb_const_iterator;
+
+    friend _CONSTEXPR20 void _Verify_range(const _Vb_const_iterator& _First, const _Vb_const_iterator& _Last) noexcept {
+        // note _Compat check inside <=
+        _STL_VERIFY(_First <= _Last, "vector<bool> iterator range transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+    _CONSTEXPR20 void _Dec() noexcept { // decrement bit position
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot decrement value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) > 0, "cannot decrement vector<bool> begin iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        if (this->_Myoff != 0) {
+            --this->_Myoff;
+        } else { // move to previous word
+            this->_Myoff = _VBITS - 1;
+            --this->_Myptr;
+        }
+    }
+
+    _CONSTEXPR20 void _Inc() noexcept { // increment bit position
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot increment value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) < static_cast<difference_type>(_Cont->_Mysize),
+            "cannot increment vector<bool> end iterator");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        if (this->_Myoff < _VBITS - 1) {
+            ++this->_Myoff;
+        } else { // move to next word
+            this->_Myoff = 0;
+            ++this->_Myptr;
+        }
+    }
+};
+
+template <class _Alvbase_wrapped>
+class _Vb_iterator : public _Vb_const_iterator<_Alvbase_wrapped> {
+public:
+    using _Mybase = _Vb_const_iterator<_Alvbase_wrapped>;
+    using _Mycont = typename _Mybase::_Mycont;
+
+    using _Reft           = _Vb_reference<_Alvbase_wrapped>;
+    using const_reference = bool;
+
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = bool;
+    using difference_type   = typename _Mybase::difference_type;
+    using pointer           = _Reft*;
+    using reference         = _Reft;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Cont = static_cast<const _Mycont*>(this->_Getcont());
+        _STL_VERIFY(_Cont, "cannot dereference value-initialized vector<bool> iterator");
+        _STL_VERIFY(this->_Total_off(_Cont) < static_cast<difference_type>(_Cont->_Mysize),
+            "vector<bool> iterator not dereferenceable");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        return _Reft(*this);
+    }
+
+    _CONSTEXPR20 _Vb_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vb_iterator operator++(int) noexcept {
+        _Vb_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vb_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _CONSTEXPR20 _Vb_iterator operator--(int) noexcept {
+        _Vb_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _Vb_iterator& operator+=(const difference_type _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _Vb_iterator operator+(const difference_type _Off) const noexcept {
+        _Vb_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _Vb_iterator operator+(const difference_type _Off, _Vb_iterator _Right) noexcept {
+        _Right += _Off;
+        return _Right;
+    }
+
+    _CONSTEXPR20 _Vb_iterator& operator-=(const difference_type _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    using _Mybase::operator-;
+
+    _NODISCARD _CONSTEXPR20 _Vb_iterator operator-(const difference_type _Off) const noexcept {
+        _Vb_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    using _Prevent_inheriting_unwrap = _Vb_iterator;
+};
+
+template <class _Alloc>
+class _Vb_val : public _Container_base {
+public:
+    using _Alvbase         = _Rebind_alloc_t<_Alloc, _Vbase>;
+    using _Alvbase_traits  = allocator_traits<_Alvbase>;
+    using _Vectype         = vector<_Vbase, _Alvbase>;
+    using _Alvbase_wrapped = _Wrap_alloc<_Alvbase>;
+    using size_type        = typename _Alvbase_traits::size_type;
+
+    _CONSTEXPR20 _Vb_val() noexcept(is_nothrow_default_constructible_v<_Vectype>) : _Myvec(), _Mysize(0) {
+        this->_Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(const _Alloc& _Al) noexcept : _Myvec(static_cast<_Alvbase>(_Al)), _Mysize(0) {
+        this->_Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(size_type _Count, const bool& _Val)
+        : _Myvec(_Nw(_Count), static_cast<_Vbase>(_Val ? -1 : 0)), _Mysize(0) {
+        this->_Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(size_type _Count, const bool& _Val, const _Alloc& _Al)
+        : _Myvec(_Nw(_Count), static_cast<_Vbase>(_Val ? -1 : 0), static_cast<_Alvbase>(_Al)), _Mysize(0) {
+        this->_Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(const _Vb_val& _Right) : _Myvec(_Right._Myvec), _Mysize(_Right._Mysize) {
+        this->_Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(const _Vb_val& _Right, const _Alloc& _Al)
+        : _Myvec(_Right._Myvec, static_cast<_Alvbase>(_Al)), _Mysize(_Right._Mysize) {
+        this->_Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(_Vb_val&& _Right) noexcept(is_nothrow_move_constructible_v<_Vectype>)
+        : _Myvec(_STD move(_Right._Myvec)), _Mysize(_STD exchange(_Right._Mysize, size_type{0})) {
+        this->_Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 _Vb_val(_Vb_val&& _Right, const _Alloc& _Al)
+        noexcept(is_nothrow_constructible_v<_Vectype, _Vectype, _Alvbase>)
+        : _Myvec(_STD move(_Right._Myvec), static_cast<_Alvbase>(_Al)), _Mysize(_Right._Mysize) {
+        if (_Right._Myvec.empty()) {
+            // we took _Right's buffer, so zero out size
+            _Right._Mysize = 0;
+        }
+
+        this->_Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+    }
+
+    _CONSTEXPR20 ~_Vb_val() noexcept {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        this->_Orphan_all();
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Delete_plain_internal(_Alproxy, _STD exchange(this->_Myproxy, nullptr));
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        // Destroying _Myvec will store tombstones in its pointers, setting its apparent size to 0.
+        // We should also set our _Mysize to 0 for consistency, allowing precondition hardening to detect UB earlier.
+        _Mysize = 0;
+#endif
+    }
+
+    _CONSTEXPR20 _Alvbase& _Getal() noexcept {
+        return _Myvec._Getal();
+    }
+
+    _CONSTEXPR20 const _Alvbase& _Getal() const noexcept {
+        return _Myvec._Getal();
+    }
+
+    static _CONSTEXPR20 size_type _Nw(size_type _Count) noexcept {
+        return (_Count + _VBITS - 1) / _VBITS;
+    }
+
+    _CONSTEXPR20 void _Emplace_back_unchecked(const _Vbase _Val) noexcept {
+        _STL_INTERNAL_CHECK(_Myvec.size() < _Myvec.capacity());
+        _Myvec._Emplace_back_with_unused_capacity(_Val);
+    }
+
+    _Vectype _Myvec; // base vector of words
+    size_type _Mysize; // current length of sequence
+};
+
+template <class _Alloc>
+class vector<bool, _Alloc> : public _Vb_val<_Alloc> {
+public:
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<bool, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("vector<bool, Allocator>", "bool"));
+
+    using _Mybase          = _Vb_val<_Alloc>;
+    using _Alvbase_wrapped = typename _Mybase::_Alvbase_wrapped;
+    using _Alvbase         = typename _Mybase::_Alvbase;
+    using _Alvbase_traits  = typename _Mybase::_Alvbase_traits;
+
+    using size_type       = typename _Alvbase_traits::size_type;
+    using difference_type = typename _Alvbase_traits::difference_type;
+    using allocator_type  = _Alloc;
+
+    using reference       = _Vb_reference<_Alvbase_wrapped>;
+    using const_reference = bool;
+    using value_type      = bool;
+
+    using _Reft          = reference;
+    using iterator       = _Vb_iterator<_Alvbase_wrapped>;
+    using const_iterator = _Vb_const_iterator<_Alvbase_wrapped>;
+
+    using pointer                = iterator;
+    using const_pointer          = const_iterator;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    enum { _EEN_VBITS = _VBITS }; // helper for expression evaluator
+
+    _CONSTEXPR20 vector() noexcept(is_nothrow_default_constructible_v<_Alloc>) : _Mybase(_Alloc()) {}
+
+    _CONSTEXPR20 explicit vector(const _Alloc& _Al) noexcept : _Mybase(_Al) {}
+
+    _CONSTEXPR20 explicit vector(_CRT_GUARDOVERFLOW size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mybase(_Count, false, _Al) {
+        _Trim(_Count);
+    }
+
+    _CONSTEXPR20 vector(_CRT_GUARDOVERFLOW size_type _Count, const bool& _Val, const _Alloc& _Al = _Alloc())
+        : _Mybase(_Count, _Val, _Al) {
+        _Trim(_Count);
+    }
+
+    _CONSTEXPR20 vector(const vector& _Right) : _Mybase(_Right) {}
+
+    _CONSTEXPR20 vector(const vector& _Right, const _Identity_t<_Alloc>& _Al) : _Mybase(_Right, _Al) {}
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 vector(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc()) : _Mybase(_Al) {
+        insert(begin(), _First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr vector(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc()) : _Mybase(_Al) {
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 vector(vector&& _Right) noexcept : _Mybase(_STD move(_Right)) {
+        this->_Swap_proxy_and_iterators(_Right);
+    }
+
+    _CONSTEXPR20 vector(vector&& _Right, const _Identity_t<_Alloc>& _Al)
+        noexcept(is_nothrow_constructible_v<_Mybase, _Mybase, const _Alloc&>) // strengthened
+        : _Mybase(_STD move(_Right), _Al) {
+        if constexpr (!_Alvbase_traits::is_always_equal::value) {
+            if (this->_Getal() != _Right._Getal()) {
+                return;
+            }
+        }
+
+        this->_Swap_proxy_and_iterators(_Right);
+    }
+
+    _CONSTEXPR20 vector& operator=(vector&& _Right)
+        noexcept(_Choose_pocma_v<_Alvbase> != _Pocma_values::_No_propagate_allocators) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+        this->_Myvec  = _STD move(_Right._Myvec);
+        this->_Mysize = _STD exchange(_Right._Mysize, size_type{0});
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        this->_Orphan_all();
+        auto& _Al                 = this->_Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alvbase>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            using _Alproxy_type = _Rebind_alloc_t<_Alvbase, _Container_proxy>;
+            if (_Al != _Right_al) { // reload proxy
+                // intentionally slams into noexcept on OOM, TRANSITION, VSO-466800
+                _Alproxy_type _Oldal(_Al);
+                _Alproxy_type _Right_proxy_al(_Right_al);
+                _Container_proxy_ptr<_Alvbase> _Proxy(_Right_proxy_al, _Leave_proxy_unbound{});
+                this->_Myvec  = _STD move(_Right._Myvec);
+                this->_Mysize = _STD exchange(_Right._Mysize, size_type{0});
+                _Proxy._Bind(_Oldal, this);
+                this->_Swap_proxy_and_iterators(_Right);
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            this->_Myvec  = _STD move(_Right._Myvec);
+            this->_Mysize = _Right._Mysize;
+            if (_Right._Myvec.empty()) {
+                // we took _Right's buffer, so zero out size
+                _Right._Mysize = 0;
+            }
+
+            if (_Al == _Right_al) {
+                this->_Swap_proxy_and_iterators(_Right);
+            }
+            return *this;
+        }
+
+        this->_Myvec  = _STD move(_Right._Myvec);
+        this->_Mysize = _STD exchange(_Right._Mysize, size_type{0});
+        this->_Swap_proxy_and_iterators(_Right);
+
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+        return *this;
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 _CONTAINER_EMPLACE_RETURN emplace_back(_Valty&&... _Val) {
+        bool _Tmp(_STD forward<_Valty>(_Val)...);
+        push_back(_Tmp);
+
+#if _HAS_CXX17
+        return back();
+#endif // _HAS_CXX17
+    }
+
+    template <class... _Valty>
+    _CONSTEXPR20 iterator emplace(const_iterator _Where, _Valty&&... _Val) {
+        bool _Tmp(_STD forward<_Valty>(_Val)...);
+        return insert(_Where, _Tmp);
+    }
+
+    _CONSTEXPR20 vector(initializer_list<bool> _Ilist, const _Alloc& _Al = allocator_type()) : _Mybase(0, false, _Al) {
+        insert(begin(), _Ilist.begin(), _Ilist.end());
+    }
+
+    _CONSTEXPR20 vector& operator=(initializer_list<bool> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+
+    _CONSTEXPR20 void assign(initializer_list<bool> _Ilist) {
+        assign(_Ilist.begin(), _Ilist.end());
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, initializer_list<bool> _Ilist) {
+        return insert(_Where, _Ilist.begin(), _Ilist.end());
+    }
+
+    _CONSTEXPR20 ~vector() noexcept {}
+
+    _CONSTEXPR20 vector& operator=(const vector& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+        this->_Myvec  = _Right._Myvec;
+        this->_Mysize = _Right._Mysize;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL != 0 vvv
+        this->_Orphan_all();
+        auto& _Al       = this->_Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alvbase>) {
+            if (_Al != _Right_al) {
+                // reload proxy
+                using _Alproxy_type = _Rebind_alloc_t<_Alvbase, _Container_proxy>;
+                _Alproxy_type _Oldal(_Al);
+                _Alproxy_type _Right_proxy_al(_Right_al);
+                _Container_proxy_ptr<_Alvbase> _Proxy(_Right_proxy_al, _Leave_proxy_unbound{});
+                this->_Myvec  = _Right._Myvec;
+                this->_Mysize = _Right._Mysize;
+                _Proxy._Bind(_Oldal, this);
+                return *this;
+            }
+        }
+
+        this->_Myvec  = _Right._Myvec;
+        this->_Mysize = _Right._Mysize;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 0 ^^^
+
+        return *this;
+    }
+
+    _CONSTEXPR20 void reserve(_CRT_GUARDOVERFLOW size_type _Count) {
+        this->_Myvec.reserve(this->_Nw(_Count));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type capacity() const noexcept {
+        return this->_Myvec.capacity() * _VBITS;
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator begin() noexcept {
+        return iterator(this->_Myvec.data(), this);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator begin() const noexcept {
+        return const_iterator(this->_Myvec.data(), this);
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator end() noexcept {
+        return begin() + static_cast<difference_type>(this->_Mysize);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator end() const noexcept {
+        return begin() + static_cast<difference_type>(this->_Mysize);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator _Unchecked_begin() noexcept {
+        return iterator(this->_Myvec.data(), this);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator _Unchecked_begin() const noexcept {
+        return const_iterator(this->_Myvec.data(), this);
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator _Unchecked_end() noexcept {
+        return _Unchecked_begin() + static_cast<difference_type>(this->_Mysize);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator _Unchecked_end() const noexcept {
+        return _Unchecked_begin() + static_cast<difference_type>(this->_Mysize);
+    }
+
+    _CONSTEXPR20 void shrink_to_fit() {
+        if (this->_Myvec.capacity() != this->_Myvec.size()) {
+            this->_Orphan_all();
+            this->_Myvec.shrink_to_fit();
+        }
+    }
+
+    _CONSTEXPR20 iterator _Make_iter(const_iterator _Where) noexcept {
+        iterator _Tmp = begin();
+        if (0 < this->_Mysize) {
+            _Tmp += _Where - begin();
+        }
+
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _CONSTEXPR20 void resize(_CRT_GUARDOVERFLOW size_type _Newsize, bool _Val = false) {
+        if (size() < _Newsize) {
+            _Insert_n(end(), _Newsize - size(), _Val);
+        } else if (_Newsize < size()) {
+            erase(begin() + static_cast<difference_type>(_Newsize), end());
+        }
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type size() const noexcept {
+        return this->_Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type max_size() const noexcept {
+        constexpr auto _Diff_max  = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        const size_type _Ints_max = this->_Myvec.max_size();
+
+        const bool _Would_overflow = _Ints_max > _Diff_max / _VBITS;
+        if (_Would_overflow) { // max_size bound by difference_type limits
+            return _Diff_max;
+        }
+
+#pragma warning(push)
+#pragma warning(disable : 26450) // TRANSITION, VSO-2565428
+        // max_size bound by underlying storage limits
+        return static_cast<size_type>(_Ints_max * _VBITS);
+#pragma warning(pop)
+    }
+
+    _NODISCARD_EMPTY_MEMBER _CONSTEXPR20 bool empty() const noexcept {
+        return this->_Mysize == 0;
+    }
+
+    _NODISCARD _CONSTEXPR20 allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(this->_Myvec.get_allocator());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference at(size_type _Off) const {
+        if (size() <= _Off) {
+            _Xran();
+        }
+
+        return (*this)[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 reference at(size_type _Off) {
+        if (size() <= _Off) {
+            _Xran();
+        }
+
+        return (*this)[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference operator[](size_type _Off) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off < this->_Mysize, "vector<bool> subscript out of range");
+#endif
+
+        const_iterator _It = begin();
+        _It._Advance(_Off);
+        return *_It;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](size_type _Off) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off < this->_Mysize, "vector<bool> subscript out of range");
+#endif
+
+        iterator _It = begin();
+        _It._Advance(_Off);
+        return *_It;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Mysize != 0, "front() called on empty vector<bool>");
+#endif
+
+        return *begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference front() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Mysize != 0, "front() called on empty vector<bool>");
+#endif
+
+        return *begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 reference back() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Mysize != 0, "back() called on empty vector<bool>");
+#endif
+
+        return *(end() - 1);
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference back() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Mysize != 0, "back() called on empty vector<bool>");
+#endif
+
+        return *(end() - 1);
+    }
+
+    _CONSTEXPR20 void push_back(const bool& _Val) {
+        insert(end(), _Val);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr void append_range(_Rng&& _Range) {
+        insert_range(end(), _STD forward<_Rng>(_Range));
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void pop_back() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_VECTOR || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(this->_Mysize != 0, "pop_back() called on empty vector<bool>");
+#endif
+
+        erase(end() - 1);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 void assign(_Iter _First, _Iter _Last) {
+        clear();
+        insert(begin(), _First, _Last);
+    }
+
+#if _HAS_CXX23
+    template <class _Iter>
+    constexpr void _Assign_counted_range(_Iter _First, const size_type _Count) {
+        _STL_INTERNAL_CHECK(this->_Myvec.empty());
+        this->_Myvec.reserve(this->_Nw(_Count));
+        _Vbase _Accum = 0;
+        _Vbase _Mask  = 1;
+        for (size_type _Idx = 0; _Idx < _Count; ++_Idx) {
+            const bool _Tmp = *_First;
+            ++_First;
+            _Accum |= _Tmp ? _Mask : _Vbase{0};
+            if ((_Mask <<= 1) == 0) {
+                this->_Emplace_back_unchecked(_Accum);
+                _Accum = 0;
+                _Mask  = 1;
+            }
+        }
+
+        if (_Count % _VBITS != 0) {
+            this->_Emplace_back_unchecked(_Accum);
+        }
+        this->_Mysize = _Count;
+    }
+
+    template <class _Iter, class _Sent>
+    constexpr void _Assign_uncounted_range(_Iter _First, const _Sent _Last) {
+        _STL_INTERNAL_CHECK(this->_Myvec.empty());
+        size_type _Count = 0;
+        _Vbase _Accum    = 0;
+        _Vbase _Mask     = 1;
+        for (; _First != _Last; ++_Count) {
+            const bool _Tmp = *_First;
+            ++_First;
+            _Accum |= _Tmp ? _Mask : _Vbase{0};
+            if ((_Mask <<= 1) == 0) {
+                this->_Myvec.push_back(_Accum);
+                _Accum = 0;
+                _Mask  = 1;
+            }
+        }
+
+        if (_Count % _VBITS != 0) {
+            this->_Myvec.push_back(_Accum);
+        }
+        this->_Mysize = _Count;
+    }
+
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr void assign_range(_Rng&& _Range) {
+        static_assert(assignable_from<bool&, _RANGES range_reference_t<_Rng>>,
+            "Elements must be assignable from the range's reference type (N4993 [sequence.reqmts]/60).");
+        clear();
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            _Assign_counted_range(_RANGES _Ubegin(_Range), _Count);
+        } else {
+            _Assign_uncounted_range(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 void assign(_CRT_GUARDOVERFLOW size_type _Count, const bool& _Val) {
+        clear();
+        _Insert_n(begin(), _Count, _Val);
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, const bool& _Val) {
+        return _Insert_n(_Where, size_type{1}, _Val);
+    }
+
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW size_type _Count, const bool& _Val) {
+        return _Insert_n(_Where, _Count, _Val);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
+        const difference_type _Saved_offset = _Where - begin();
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst      = _STD _Get_unwrapped(_First);
+        const auto _ULast = _STD _Get_unwrapped(_Last);
+
+        if constexpr (_Is_cpp17_fwd_iter_v<_Iter>) {
+            const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            _STD _Copy_unchecked(_UFirst, _ULast, begin() + _Off);
+#if _HAS_CXX20
+        } else if constexpr (forward_iterator<_Iter>) {
+            const auto _Length = _STD _To_unsigned_like(_RANGES distance(_UFirst, _ULast));
+            const auto _Count  = _STD _Convert_size<size_type>(_Length);
+            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            _STD _Copy_unchecked(_UFirst, _ULast, begin() + _Off);
+#endif // _HAS_CXX20
+        } else {
+            const auto _Old_size = this->_Mysize;
+            for (; _UFirst != _ULast; ++_UFirst) {
+                emplace_back(*_UFirst);
+            }
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _Orphan_range(static_cast<size_type>(_Saved_offset), _Old_size);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            _STD rotate(begin() + _Saved_offset, begin() + static_cast<difference_type>(_Old_size), end());
+        }
+
+        return begin() + _Saved_offset;
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<bool> _Rng>
+    constexpr iterator insert_range(const_iterator _Where, _Rng&& _Range) {
+        const difference_type _Old_off = _Where - begin();
+
+        if constexpr (_RANGES forward_range<_Rng> || _RANGES sized_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            const auto _Off    = static_cast<difference_type>(_Insert_x(_Where, _Count));
+            _Copy_n_unchecked4(_RANGES _Ubegin(_Range), _Count, begin() + _Off);
+        } else {
+            auto _UFirst         = _RANGES _Ubegin(_Range);
+            const auto _ULast    = _RANGES _Uend(_Range);
+            const auto _Old_size = this->_Mysize;
+            for (; _UFirst != _ULast; ++_UFirst) {
+                emplace_back(*_UFirst);
+            }
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _Orphan_range(static_cast<size_type>(_Old_off), _Old_size);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            _STD rotate(begin() + _Old_off, begin() + static_cast<difference_type>(_Old_size), end());
+        }
+
+        return begin() + _Old_off;
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 iterator erase(const_iterator _Where_arg) noexcept /* strengthened */ {
+        iterator _Where      = _Make_iter(_Where_arg);
+        difference_type _Off = _Where - begin();
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(end() > _Where, "vector<bool> erase iterator outside range");
+#endif
+
+        _STD copy(_Next_iter(_Where), end(), _Where);
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Orphan_range(static_cast<size_type>(_Off), this->_Mysize);
+#endif
+
+        _Trim(this->_Mysize - 1);
+        return begin() + _Off;
+    }
+
+    _CONSTEXPR20 iterator erase(const_iterator _First_arg, const_iterator _Last_arg) noexcept /* strengthened */ {
+        iterator _First      = _Make_iter(_First_arg);
+        iterator _Last       = _Make_iter(_Last_arg);
+        difference_type _Off = _First - begin();
+
+        if (_First != _Last) { // worth doing, copy down over hole
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _STL_VERIFY(_Last >= _First && end() >= _Last, "vector<bool> erase iterator outside range");
+#endif
+
+            iterator _Next      = _STD copy(_Last, end(), _First);
+            const auto _Newsize = static_cast<size_type>(_Next - begin());
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _Orphan_range(_Newsize, this->_Mysize);
+#endif
+
+            _Trim(_Newsize);
+        }
+        return begin() + _Off;
+    }
+
+    _CONSTEXPR20 void clear() noexcept {
+        this->_Orphan_all();
+        this->_Myvec.clear();
+        this->_Mysize = 0;
+    }
+
+    _CONSTEXPR20 void flip() noexcept { // toggle all elements
+        for (auto& _Elem : this->_Myvec) {
+            _Elem = ~_Elem;
+        }
+
+        _Trim(this->_Mysize);
+    }
+
+    _CONSTEXPR20 void swap(vector& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            this->_Swap_proxy_and_iterators(_Right);
+            this->_Myvec.swap(_Right._Myvec);
+            _STD swap(this->_Mysize, _Right._Mysize);
+        }
+    }
+
+    _DEPRECATE_VECTOR_BOOL_STATIC_REFERENCE_SWAP
+    static _CONSTEXPR20 void swap(reference _Left, reference _Right) noexcept {
+        bool _Val = _Left; // NOT _STD swap
+        _Left     = _Right;
+        _Right    = _Val;
+    }
+
+    friend hash<vector<bool, _Alloc>>;
+
+    _CONSTEXPR20 iterator _Insert_n(const_iterator _Where, size_type _Count, const bool& _Val) {
+        size_type _Off     = _Insert_x(_Where, _Count);
+        const auto _Result = begin() + static_cast<difference_type>(_Off);
+        _STD fill_n(_Result, _Count, _Val);
+        return _Result;
+    }
+
+    _CONSTEXPR20 size_type _Insert_x(const_iterator _Where, size_type _Count) {
+        const difference_type _Off = _Where - begin();
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(end() >= _Where, "vector<bool> insert iterator outside range");
+        const bool _Realloc = capacity() - size() < _Count;
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        if (_Count != 0) {
+            if (max_size() - size() < _Count) {
+                _Xlen(); // result too long
+            }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _Orphan_range(static_cast<size_type>(_Realloc ? 0 : _Off), this->_Mysize);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            this->_Myvec.resize(this->_Nw(size() + _Count), 0);
+            if (empty()) {
+                this->_Mysize += _Count;
+            } else { // make room and copy down suffix
+                iterator _Oldend = end();
+                this->_Mysize += _Count;
+                _STD copy_backward(begin() + _Off, _Oldend, end());
+            }
+        }
+
+        return static_cast<size_type>(_Off);
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    _CONSTEXPR20 void _Orphan_range_unlocked(size_type _Offlo, size_type _Offhi) const {
+        const auto _Base = this->_Myvec.data();
+
+        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
+        while (*_Pnext) { // test offset from beginning of vector
+            const auto& _Pnextiter = static_cast<typename const_iterator::_Mybase&>(**_Pnext);
+            const auto _Temp       = *_Pnext;
+            if (!_Pnextiter._Myptr) { // orphan the iterator
+                _Temp->_Myproxy = nullptr;
+                *_Pnext         = _Temp->_Mynextiter;
+                continue;
+            }
+            const auto _Off =
+                static_cast<size_type>(const_iterator::_VBITS_DIFF * (_Pnextiter._Myptr - _Base)) + _Pnextiter._Myoff;
+            if (_Off < _Offlo || _Offhi < _Off) {
+                _Pnext = &_Temp->_Mynextiter;
+            } else { // orphan the iterator
+                _Temp->_Myproxy = nullptr;
+                *_Pnext         = _Temp->_Mynextiter;
+            }
+        }
+    }
+
+    void _Orphan_range_locked(size_type _Offlo, size_type _Offhi) const {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_range_unlocked(_Offlo, _Offhi);
+    }
+
+    _CONSTEXPR20 void _Orphan_range(size_type _Offlo, size_type _Offhi) const {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Orphan_range_unlocked(_Offlo, _Offhi);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Orphan_range_locked(_Offlo, _Offhi);
+        }
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    _CONSTEXPR20 void _Trim(size_type _Size) {
+        if (max_size() < _Size) {
+            _Xlen(); // result too long
+        }
+
+        const size_type _Words = this->_Nw(_Size);
+        if (_Words < this->_Myvec.size()) {
+            this->_Myvec.erase(this->_Myvec.begin() + static_cast<difference_type>(_Words), this->_Myvec.end());
+        }
+
+        this->_Mysize = _Size;
+        _Size %= _VBITS;
+        if (0 < _Size) {
+            this->_Myvec[_Words - 1] &= (static_cast<_Vbase>(1) << _Size) - 1;
+        }
+    }
+
+    [[noreturn]] static void _Xlen() {
+        _Xlength_error("vector<bool> too long");
+    }
+
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid vector<bool> subscript");
+    }
+};
+
+template <class _Alloc>
+struct hash<vector<bool, _Alloc>> {
+    using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = vector<bool, _Alloc>;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
+
+    _NODISCARD static size_t operator()(const vector<bool, _Alloc>& _Keyval) noexcept {
+        return _Hash_array_representation(_Keyval._Myvec.data(), _Keyval._Myvec.size());
+    }
+};
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Ty>
+    using vector = _STD vector<_Ty, polymorphic_allocator<_Ty>>;
+} // namespace pmr
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+// Per LWG-3997, `_CharT` in library-provided `formatter` specializations is
+// constrained to character types supported by `format`.
+template <class _Ty, _Format_supported_charT _CharT>
+    requires _Is_specialization_v<_Ty, _Vb_reference>
+struct formatter<_Ty, _CharT> {
+private:
+    formatter<bool, _CharT> _Underlying;
+
+public:
+    template <class _ParseContext>
+    constexpr _ParseContext::iterator parse(_ParseContext& _Ctx) {
+        return _Underlying.parse(_Ctx);
+    }
+
+    template <class _FormatContext>
+    _FormatContext::iterator format(const _Ty& _Ref, _FormatContext& _Ctx) const {
+        return _Underlying.format(_Ref, _Ctx);
+    }
+};
+
+template <class _Ty>
+    requires _Is_specialization_v<_Ty, _Vb_reference>
+constexpr bool enable_nonlocking_formatter_optimization<_Ty> = true;
+#endif // _HAS_CXX23
+
+template <class _Alloc, bool _RequiresMutable>
+constexpr bool _Is_vb_iterator<_Vb_iterator<_Alloc>, _RequiresMutable> = true;
+
+template <class _Alloc>
+constexpr bool _Is_vb_iterator<_Vb_const_iterator<_Alloc>, false> = true;
+
+template <class _VbIt>
+_CONSTEXPR20 void _Fill_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
+    // Set [_First, _Last) to _Val
+    if (_First == _Last) {
+        return;
+    }
+
+    _Vbase* _VbFirst      = const_cast<_Vbase*>(_First._Myptr);
+    _Vbase* const _VbLast = const_cast<_Vbase*>(_Last._Myptr);
+
+    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
+    const auto _FirstDestMask   = ~_FirstSourceMask;
+    const auto _FillVal         = static_cast<_Vbase>(_Val ? -1 : 0);
+
+    if (_VbFirst == _VbLast) {
+        // We already excluded _First == _Last, so here _Last._Myoff > 0 and the shift is safe
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _LastDestMask   = ~_LastSourceMask;
+        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
+        const auto _DestMask       = _FirstDestMask | _LastDestMask;
+        *_VbFirst                  = (*_VbFirst & _DestMask) | (_FillVal & _SourceMask);
+        return;
+    }
+
+    *_VbFirst = (*_VbFirst & _FirstDestMask) | (_FillVal & _FirstSourceMask);
+    ++_VbFirst;
+
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        for (; _VbFirst != _VbLast; ++_VbFirst) {
+            *_VbFirst = _FillVal;
+        }
+    } else
+#endif // _HAS_CXX20
+    {
+        const auto _VbFirst_ch = reinterpret_cast<const unsigned char*>(_VbFirst);
+        const auto _VbLast_ch  = reinterpret_cast<const unsigned char*>(_VbLast);
+        const auto _Count_ch   = static_cast<size_t>(_VbLast_ch - _VbFirst_ch);
+        const auto _ValChar    = static_cast<unsigned char>(_Val ? -1 : 0);
+        _CSTD memset(_VbFirst, _ValChar, _Count_ch);
+        _VbFirst = _VbLast;
+    }
+
+    if (_Last._Myoff != 0) {
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _LastDestMask   = ~_LastSourceMask;
+        *_VbFirst                  = (*_VbFirst & _LastDestMask) | (_FillVal & _LastSourceMask);
+    }
+}
+
+template <class _VbIt>
+_NODISCARD _CONSTEXPR20 _VbIt _Find_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
+    // Find _Val in [_First, _Last)
+    if (_First == _Last) {
+        return _First;
+    }
+
+    const _Vbase* _VbFirst      = _First._Myptr;
+    const _Vbase* const _VbLast = _Last._Myptr;
+
+    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
+
+    if (_VbFirst == _VbLast) {
+        // We already excluded _First == _Last, so here _Last._Myoff > 0 and the shift is safe
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
+        const auto _SelectVal      = (_Val ? *_VbFirst : ~*_VbFirst) & _SourceMask;
+        const auto _Count          = _Countr_zero(_SelectVal);
+        if (_Count == _VBITS) {
+            return _Last;
+        } else {
+            return _First + static_cast<_Iter_diff_t<_VbIt>>(_Count - _First._Myoff);
+        }
+    }
+
+    const auto _FirstVal   = (_Val ? *_VbFirst : ~*_VbFirst) & _FirstSourceMask;
+    const auto _FirstCount = _Countr_zero(_FirstVal);
+    if (_FirstCount != _VBITS) {
+        return _First + static_cast<_Iter_diff_t<_VbIt>>(_FirstCount - _First._Myoff);
+    }
+    ++_VbFirst;
+
+    auto _TotalCount = static_cast<_Iter_diff_t<_VbIt>>(_VBITS - _First._Myoff);
+    for (; _VbFirst != _VbLast; ++_VbFirst, _TotalCount += _VBITS) {
+        const auto _SelectVal = _Val ? *_VbFirst : ~*_VbFirst;
+        const auto _Count     = _Countr_zero(_SelectVal);
+        if (_Count != _VBITS) {
+            return _First + static_cast<_Iter_diff_t<_VbIt>>(_TotalCount + _Count);
+        }
+    }
+
+    if (_Last._Myoff != 0) {
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _LastVal        = (_Val ? *_VbFirst : ~*_VbFirst) & _LastSourceMask;
+        const auto _Count          = _Countr_zero(_LastVal);
+        if (_Count != _VBITS) {
+            return _First + static_cast<_Iter_diff_t<_VbIt>>(_TotalCount + _Count);
+        }
+    }
+
+    return _Last;
+}
+
+template <class _VbIt>
+_NODISCARD _CONSTEXPR20 _Iter_diff_t<_VbIt> _Count_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
+    if (_First == _Last) {
+        return 0;
+    }
+
+    const _Vbase* _VbFirst      = _First._Myptr;
+    const _Vbase* const _VbLast = _Last._Myptr;
+
+    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
+
+    if (_VbFirst == _VbLast) {
+        // We already excluded _First == _Last, so here _Last._Myoff > 0 and the shift is safe
+        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
+        const auto _SelectVal      = (_Val ? *_VbFirst : ~*_VbFirst) & _SourceMask;
+        return _Popcount(_SelectVal);
+    }
+
+    return _Select_popcount_impl<_Vbase>(
+        [_Last, _Val, _VbFirst, _VbLast, _FirstSourceMask](auto _Popcount_impl) mutable noexcept {
+            const auto _FirstVal       = (_Val ? *_VbFirst : ~*_VbFirst) & _FirstSourceMask;
+            _Iter_diff_t<_VbIt> _Count = _Popcount_impl(_FirstVal);
+            ++_VbFirst;
+
+            const auto _Bits                = static_cast<_Iter_diff_t<_VbIt>>(_VbLast - _VbFirst) * _VBITS;
+            _Iter_diff_t<_VbIt> _Count_ones = 0;
+
+            for (; _VbFirst != _VbLast; ++_VbFirst) {
+                _Count_ones += _Popcount_impl(*_VbFirst);
+            }
+
+            _Count += _Val ? _Count_ones : _Bits - _Count_ones;
+
+            if (_Last._Myoff != 0) {
+                const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
+                const auto _LastVal        = (_Val ? *_VbFirst : ~*_VbFirst) & _LastSourceMask;
+                _Count += _Popcount_impl(_LastVal);
+            }
+
+            return _Count;
+        });
+}
+
+template <class _VbIt, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_vbool(_VbIt _First, _VbIt _Last, _OutIt _Dest) {
+    // copy [_First, _Last) to [_Dest, ...)
+    if (_First == _Last) {
+        return _Dest;
+    }
+
+    auto _VbFirst       = _First._Myptr;
+    const auto _VbLast  = _Last._Myptr;
+    auto _VbDest        = const_cast<_Vbase*>(_Dest._Myptr);
+    const auto _DestEnd = _Dest + (_Last - _First);
+
+    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
+    const auto _FirstDestMask   = _Dest._Myoff == 0 ? 0 : (static_cast<_Vbase>(-1) >> (_VBITS - _Dest._Myoff));
+    const auto _LastSourceMask  = _Last._Myoff == 0 ? 0 : (static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff));
+    const auto _LastDestMask    = static_cast<_Vbase>(-1) << _DestEnd._Myoff;
+
+    const bool _IsSingleBlockSource = _VbFirst == _VbLast;
+    const bool _IsSingleBlockDest   = _VbDest == _DestEnd._Myptr - (_DestEnd._Myoff == 0 ? 1 : 0);
+    const bool _IsRightShift        = _Dest._Myoff < _First._Myoff;
+    if (_IsSingleBlockSource) {
+        // We already excluded _First == _Last, so here _Last._Myoff > 0 and the shift is safe
+        const auto _SourceMask  = _FirstSourceMask & _LastSourceMask;
+        const auto _SourceShift = _IsRightShift ? _First._Myoff - _Dest._Myoff : _Dest._Myoff - _First._Myoff;
+        const auto _SourceVal   = _IsRightShift ? (*_VbFirst & _SourceMask) >> _SourceShift //
+                                                : (*_VbFirst & _SourceMask) << _SourceShift;
+        if (_IsSingleBlockDest) {
+            const auto _DestMask = _FirstDestMask | (_DestEnd._Myoff == 0 ? 0 : _LastDestMask);
+            *_VbDest             = (*_VbDest & _DestMask) | _SourceVal;
+        } else {
+            *_VbDest = (*_VbDest & _FirstDestMask) | _SourceVal;
+            ++_VbDest;
+
+            const auto _LastShift     = _Last._Myoff - _DestEnd._Myoff;
+            const auto _LastSourceVal = (*_VbFirst & _SourceMask) >> _LastShift;
+            *_VbDest                  = (*_VbDest & _LastDestMask) | _LastSourceVal;
+        }
+
+        return _DestEnd;
+    } else if (_IsSingleBlockDest) {
+        const auto _SourceShift = _IsRightShift ? _First._Myoff - _Dest._Myoff : _Dest._Myoff - _First._Myoff;
+        const auto _SourceVal   = _IsRightShift ? (*_VbFirst & _FirstSourceMask) >> _SourceShift
+                                                : (*_VbFirst & _FirstSourceMask) << _SourceShift;
+
+        const auto _DestMask = _FirstDestMask | (_DestEnd._Myoff == 0 ? 0 : _LastDestMask);
+        if (_Last._Myoff != 0) {
+            const auto _LastShift     = _DestEnd._Myoff != 0 ? _DestEnd._Myoff - _Last._Myoff : _VBITS - _Last._Myoff;
+            const auto _LastSourceVal = (*_VbLast & _LastSourceMask) << _LastShift;
+            *_VbDest                  = (*_VbDest & _DestMask) | _SourceVal | _LastSourceVal;
+        } else {
+            *_VbDest = (*_VbDest & _DestMask) | _SourceVal;
+        }
+
+        return _DestEnd;
+    }
+
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        if (_Dest._Myoff == _First._Myoff) {
+            const auto _FirstSourceVal = *_VbFirst & _FirstSourceMask;
+            *_VbDest                   = (*_VbDest & _FirstDestMask) | _FirstSourceVal;
+
+            ++_VbFirst;
+            ++_VbDest;
+            for (; _VbFirst != _VbLast; ++_VbFirst, ++_VbDest) {
+                *_VbDest = *_VbFirst;
+            }
+
+            if (_Last._Myoff != 0) {
+                const auto _LastSourceVal = *_VbFirst & _LastSourceMask;
+                *_VbDest                  = (*_VbDest & _LastDestMask) | _LastSourceVal;
+            }
+
+            return _DestEnd;
+        }
+    } else
+#endif // _HAS_CXX20
+    {
+        // If _First and _Dest have matching unsigned char alignment, use memmove
+        const auto _UnalignedFirstBits = _First._Myoff & _Vbase{7};
+        const auto _UnalignedDestBits  = _Dest._Myoff & _Vbase{7};
+        if (_UnalignedFirstBits == _UnalignedDestBits) {
+            const auto _UnalignedLastBits = _Last._Myoff & _Vbase{7};
+
+            auto _VbFirst_ch =
+                reinterpret_cast<const unsigned char*>(_VbFirst) + (_First._Myoff - _UnalignedFirstBits) / 8;
+            const auto _VbLast_ch =
+                reinterpret_cast<const unsigned char*>(_VbLast) + (_Last._Myoff - _UnalignedLastBits) / 8;
+            auto _VbDest_ch = reinterpret_cast<unsigned char*>(_VbDest) + (_Dest._Myoff - _UnalignedDestBits) / 8;
+
+            // Copy bits until the next unsigned char alignment
+            if (_UnalignedFirstBits != 0) {
+                const auto _SourceBitMask = static_cast<unsigned char>(UCHAR_MAX << _UnalignedFirstBits);
+                const auto _DestBitMask   = static_cast<unsigned char>(UCHAR_MAX >> (8 - _UnalignedFirstBits));
+                *_VbDest_ch =
+                    static_cast<unsigned char>((*_VbDest_ch & _DestBitMask) | (*_VbFirst_ch & _SourceBitMask));
+                ++_VbFirst_ch;
+                ++_VbDest_ch;
+            }
+
+            _VbDest_ch = _Copy_unchecked(_VbFirst_ch, _VbLast_ch, _VbDest_ch);
+
+            // Copy remaining last bits
+            if (_UnalignedLastBits != 0) {
+                const auto _SourceBitMask = static_cast<unsigned char>(UCHAR_MAX >> (8 - _UnalignedLastBits));
+                const auto _DestBitMask   = static_cast<unsigned char>(UCHAR_MAX << _UnalignedLastBits);
+                *_VbDest_ch = static_cast<unsigned char>((*_VbDest_ch & _DestBitMask) | (*_VbLast_ch & _SourceBitMask));
+            }
+
+            return _DestEnd;
+        }
+    }
+
+    // Unaligned _VbFirst and _VbLast require a two step copy with carry
+    if (_IsRightShift) {
+        const auto _SourceShift = _First._Myoff - _Dest._Myoff;
+        const auto _CarryShift  = _VBITS - _SourceShift;
+        const auto _CarryMask   = static_cast<_Vbase>(-1) >> _SourceShift;
+        const auto _DestMask    = ~_CarryMask;
+
+        const auto _FirstSourceVal = (*_VbFirst & _FirstSourceMask) >> _SourceShift;
+        *_VbDest                   = (*_VbDest & _FirstDestMask) | _FirstSourceVal;
+
+        ++_VbFirst;
+        for (; _VbFirst != _VbLast; ++_VbFirst) {
+            const auto _CarryVal = *_VbFirst << _CarryShift;
+            *_VbDest             = (*_VbDest & _CarryMask) | _CarryVal;
+
+            ++_VbDest;
+            const auto _SourceVal = *_VbFirst >> _SourceShift;
+            *_VbDest              = (*_VbDest & _DestMask) | _SourceVal;
+        }
+
+        if (_Last._Myoff != 0) {
+            const auto _CarryVal = (*_VbFirst & _LastSourceMask) << _CarryShift;
+            if (_Last._Myoff >= _SourceShift) {
+                *_VbDest = (*_VbDest & _CarryMask) | _CarryVal;
+
+                // We have more bits remaining than the final block has left
+                if (_Last._Myoff != _SourceShift) {
+                    ++_VbDest;
+                    const auto _SourceVal = (*_VbFirst & _LastSourceMask) >> _SourceShift;
+                    *_VbDest              = (*_VbDest & _LastDestMask) | _SourceVal;
+                }
+            } else {
+                // There are not enough bits to fill the final block so we need to mask both ends
+                const auto _FinalMask = _CarryMask | _LastDestMask;
+                *_VbDest              = (*_VbDest & _FinalMask) | _CarryVal;
+            }
+        }
+    } else {
+        const auto _SourceShift = _Dest._Myoff - _First._Myoff;
+        const auto _CarryShift  = _VBITS - _SourceShift;
+
+        const auto _FirstSourceVal = (*_VbFirst & _FirstSourceMask) << _SourceShift;
+        *_VbDest                   = (*_VbDest & _FirstDestMask) | _FirstSourceVal;
+        auto _CarryVal             = *_VbFirst >> _CarryShift;
+
+        ++_VbFirst;
+        ++_VbDest;
+        for (; _VbFirst != _VbLast; ++_VbFirst, ++_VbDest) {
+            const auto _SourceVal = *_VbFirst << _SourceShift;
+            *_VbDest              = _CarryVal | _SourceVal;
+            _CarryVal             = *_VbFirst >> _CarryShift;
+        }
+
+        if (_Last._Myoff >= _CarryShift) {
+            const auto _SourceVal = *_VbFirst << _SourceShift;
+            *_VbDest              = _CarryVal | _SourceVal;
+            _CarryVal             = *_VbFirst >> _CarryShift;
+
+            // We have more bits remaining than the final block has left
+            if (_Last._Myoff != _CarryShift) {
+                ++_VbDest;
+                const auto _LastCarryMask = ~_LastDestMask;
+                *_VbDest                  = (*_VbDest & _LastDestMask) | (_CarryVal & _LastCarryMask);
+            }
+        } else if (_Last._Myoff != 0) {
+            // There are not enough bits to fill the final block so we need to mask both ends
+            const auto _LastSourceVal = (*_VbFirst & _LastSourceMask) << _SourceShift;
+            *_VbDest                  = (*_VbDest & _LastDestMask) | _CarryVal | _LastSourceVal;
+        } else {
+            // No new bits, just copy the carry
+            *_VbDest = (*_VbDest & _LastDestMask) | _CarryVal;
+        }
+    }
+
+    return _DestEnd;
+}
+
+template <class _VbIt, class _OutIt, class _Mapped_fn>
+_CONSTEXPR20 _OutIt _Transform_vbool_aligned(
+    const _VbIt _First, const _VbIt _Last, _OutIt _Dest, const _Mapped_fn _Mapped_func) {
+    auto _First_ptr      = _First._Myptr;
+    const auto _Last_ptr = _Last._Myptr;
+    auto _Dest_ptr       = const_cast<_Vbase*>(_Dest._Myptr);
+
+    for (; _First_ptr != _Last_ptr; ++_First_ptr, ++_Dest_ptr) {
+        *_Dest_ptr = _Mapped_func(*_First_ptr);
+    }
+
+    if (_Last._Myoff != 0) {
+        const _Vbase _Mask = (_Vbase{1} << _Last._Myoff) - 1;
+        *_Dest_ptr         = (*_Dest_ptr & ~_Mask) | (_Mapped_func(*_First_ptr) & _Mask);
+        _Dest._Myoff       = _Last._Myoff;
+    }
+
+    _Dest._Myptr = _Dest_ptr;
+    return _Dest;
+}
+
+template <class _VbIt1, class _VbIt2, class _OutIt, class _Mapped_fn>
+_CONSTEXPR20 _OutIt _Transform_vbool_aligned(
+    const _VbIt1 _First1, const _VbIt1 _Last1, const _VbIt2 _First2, _OutIt _Dest, const _Mapped_fn _Mapped_func) {
+    auto _First1_ptr      = _First1._Myptr;
+    auto _First2_ptr      = _First2._Myptr;
+    const auto _Last1_ptr = _Last1._Myptr;
+    auto _Dest_ptr        = const_cast<_Vbase*>(_Dest._Myptr);
+
+    for (; _First1_ptr != _Last1_ptr; ++_First1_ptr, ++_First2_ptr, ++_Dest_ptr) {
+        *_Dest_ptr = _Mapped_func(*_First1_ptr, *_First2_ptr);
+    }
+
+    if (_Last1._Myoff != 0) {
+        const _Vbase _Mask = (_Vbase{1} << _Last1._Myoff) - 1;
+        *_Dest_ptr         = (*_Dest_ptr & ~_Mask) | (_Mapped_func(*_First1_ptr, *_First2_ptr) & _Mask);
+        _Dest._Myoff       = _Last1._Myoff;
+    }
+
+    _Dest._Myptr = _Dest_ptr;
+    return _Dest;
+}
+
+struct _All_of_vbool_traits {
+    static constexpr bool _Default_result = true;
+
+    static _CONSTEXPR20 bool _Check(const _Vbase _Value) {
+        return _Value != ~_Vbase{0};
+    }
+
+    static _CONSTEXPR20 bool _Check(const _Vbase _Value, const _Vbase _Mask) {
+        return (_Value & _Mask) != _Mask;
+    }
+};
+
+struct _Any_of_vbool_traits_base {
+    static _CONSTEXPR20 bool _Check(const _Vbase _Value) {
+        return _Value != 0;
+    }
+
+    static _CONSTEXPR20 bool _Check(const _Vbase _Value, const _Vbase _Mask) {
+        return (_Value & _Mask) != 0;
+    }
+};
+
+struct _Any_of_vbool_traits : _Any_of_vbool_traits_base {
+    static constexpr bool _Default_result = false;
+};
+
+struct _None_of_vbool_traits : _Any_of_vbool_traits_base {
+    static constexpr bool _Default_result = true;
+};
+
+template <class _Traits, class _VbIt, class _Mapped_fn>
+_NODISCARD _CONSTEXPR20 bool _Meow_of_vbool(const _VbIt _First, const _VbIt _Last, const _Mapped_fn _Mapped_func) {
+    constexpr bool _Early_result = !_Traits::_Default_result;
+    auto _First_ptr              = _First._Myptr;
+    const auto _Last_ptr         = _Last._Myptr;
+
+    if (_First_ptr == _Last_ptr) {
+        if (_First._Myoff == _Last._Myoff) { // empty, can't read the word
+            return _Traits::_Default_result;
+        }
+
+        const _Vbase _Mask = (_Vbase{1} << _Last._Myoff) - (_Vbase{1} << _First._Myoff); // handle partial single word
+        if (_Traits::_Check(_Mapped_func(*_First_ptr), _Mask)) {
+            return _Early_result;
+        }
+        return _Traits::_Default_result;
+    }
+
+    if (_First._Myoff != 0) { // if we have a partial first word, handle it
+        const _Vbase _Mask = static_cast<_Vbase>(-1) << _First._Myoff;
+        if (_Traits::_Check(_Mapped_func(*_First_ptr), _Mask)) {
+            return _Early_result;
+        }
+
+        ++_First_ptr;
+    }
+
+    for (; _First_ptr != _Last_ptr; ++_First_ptr) { // handle full words
+        if (_Traits::_Check(_Mapped_func(*_First_ptr))) {
+            return _Early_result;
+        }
+    }
+
+    if (_Last._Myoff != 0) { // if we have a partial last word, handle it
+        const _Vbase _Mask = (_Vbase{1} << _Last._Myoff) - 1;
+        if (_Traits::_Check(_Mapped_func(*_First_ptr), _Mask)) {
+            return _Early_result;
+        }
+    }
+
+    return _Traits::_Default_result;
+}
+
+#undef _ASAN_VECTOR_MODIFY
+#undef _ASAN_VECTOR_REMOVE
+#undef _ASAN_VECTOR_CREATE
+#undef _ASAN_VECTOR_CREATE_GUARD
+#undef _ASAN_VECTOR_EXTEND_GUARD
+#undef _ASAN_VECTOR_RELEASE_GUARD
+#undef _INSERT_VECTOR_ANNOTATION
+
+#if _HAS_CXX23
+// This <flat_map> and <flat_set> machinery is here because <vector> is the leaf-most header included by both of them.
+
+_EXPORT_STD struct sorted_unique_t {
+    explicit sorted_unique_t() = default;
+};
+_EXPORT_STD inline constexpr sorted_unique_t sorted_unique{};
+
+_EXPORT_STD struct sorted_equivalent_t {
+    explicit sorted_equivalent_t() = default;
+};
+_EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
+
+template <class>
+constexpr bool _Is_vector_bool = false;
+template <class _Alloc>
+constexpr bool _Is_vector_bool<vector<bool, _Alloc>> = true;
+
+template <class _Ty, class _Alloc>
+constexpr bool _Has_guaranteed_push_back<vector<_Ty, _Alloc>> = !is_same_v<_Ty, bool>;
+
+template <class _Ty, class _Alloc>
+constexpr bool _Has_guaranteed_append_range<vector<_Ty, _Alloc>> = !is_same_v<_Ty, bool>;
+
+template <class _Alloc, class... _Containers>
+concept _Usable_allocator_for = (uses_allocator_v<_Containers, _Alloc> && ...);
+
+template <class _Compare, class _KeyContainer>
+concept _Valid_compare_for_container = _Not_allocator_for_container<_Compare>
+                                    && is_invocable_v<const _Compare&, const typename _KeyContainer::value_type&,
+                                        const typename _KeyContainer::value_type&>;
+#endif // ^^^ _HAS_CXX23 ^^^
+
+template <class _Ty>
+struct _NODISCARD _Clear_guard {
+    _Ty* _Target;
+
+    _Clear_guard& operator=(const _Clear_guard&) = delete;
+    _Clear_guard& operator=(_Clear_guard&&)      = delete;
+
+    ~_Clear_guard() {
+        if (_Target) {
+            _Target->clear();
+        }
+    }
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _VECTOR_
diff --git a/msvc-stl/stl/inc/version b/msvc-stl/stl/inc/version
new file mode 100644
index 0000000..fb45f31
--- /dev/null
+++ b/msvc-stl/stl/inc/version
@@ -0,0 +1,9 @@
+// version standard header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _STD_VERSION_HEADER_
+#define _STD_VERSION_HEADER_
+#include <yvals_core.h>
+#endif // _STD_VERSION_HEADER_
diff --git a/msvc-stl/stl/inc/xatomic.h b/msvc-stl/stl/inc/xatomic.h
new file mode 100644
index 0000000..5767aeb
--- /dev/null
+++ b/msvc-stl/stl/inc/xatomic.h
@@ -0,0 +1,128 @@
+// xatomic.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XATOMIC_H
+#define _XATOMIC_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <type_traits>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#define _CONCATX(x, y) x##y
+#define _CONCAT(x, y)  _CONCATX(x, y)
+
+// Interlocked intrinsic mapping for _nf/_acq/_rel
+#if defined(_M_CEE_PURE) || (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) \
+    || (defined(_M_X64) && !defined(_M_ARM64EC))
+#define _INTRIN_RELAXED(x) x
+#define _INTRIN_ACQUIRE(x) x
+#define _INTRIN_RELEASE(x) x
+#define _INTRIN_ACQ_REL(x) x
+#ifdef _M_CEE_PURE
+#define _YIELD_PROCESSOR()
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#define _YIELD_PROCESSOR() _mm_pause()
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+#elif defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _INTRIN_RELAXED(x) _CONCAT(x, _nf)
+#define _INTRIN_ACQUIRE(x) _CONCAT(x, _acq)
+#define _INTRIN_RELEASE(x) _CONCAT(x, _rel)
+// We don't have interlocked intrinsics for acquire-release ordering, even on
+// ARM64, so fall back to sequentially consistent.
+#define _INTRIN_ACQ_REL(x) x
+#define _YIELD_PROCESSOR() __yield()
+
+#else // ^^^ ARM64/ARM64EC/HYBRID_X86_ARM64 / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+
+#define _MT_INCR(x) _INTRIN_RELAXED(_InterlockedIncrement)(reinterpret_cast<volatile long*>(&x))
+#define _MT_DECR(x) _INTRIN_ACQ_REL(_InterlockedDecrement)(reinterpret_cast<volatile long*>(&x))
+
+// The following macros are SHARED with vcruntime and any updates should be mirrored.
+// Also: if any macros are added they should be #undefed in vcruntime as well.
+#define _Compiler_barrier() _STL_DISABLE_DEPRECATED_WARNING _ReadWriteBarrier() _STL_RESTORE_DEPRECATED_WARNING
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _Memory_barrier()              __dmb(0xB) // inner shared data memory barrier
+#define _Compiler_or_memory_barrier()  _Memory_barrier()
+#define _Memory_load_acquire_barrier() __dmb(0x9) // inner shared data memory load barrier
+#elif defined(_M_IX86) || defined(_M_X64)
+// x86/x64 hardware only emits memory barriers inside _Interlocked intrinsics
+#define _Compiler_or_memory_barrier() _Compiler_barrier()
+#else // ^^^ x86/x64 / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+
+_STD_BEGIN
+
+#if _HAS_CXX20
+_EXPORT_STD enum class memory_order : int {
+    relaxed,
+    consume,
+    acquire,
+    release,
+    acq_rel,
+    seq_cst,
+
+    // LWG-3268
+    memory_order_relaxed = relaxed,
+    memory_order_consume = consume,
+    memory_order_acquire = acquire,
+    memory_order_release = release,
+    memory_order_acq_rel = acq_rel,
+    memory_order_seq_cst = seq_cst
+};
+_EXPORT_STD inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
+_EXPORT_STD inline constexpr memory_order memory_order_consume = memory_order::consume;
+_EXPORT_STD inline constexpr memory_order memory_order_acquire = memory_order::acquire;
+_EXPORT_STD inline constexpr memory_order memory_order_release = memory_order::release;
+_EXPORT_STD inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
+_EXPORT_STD inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+enum memory_order {
+    memory_order_relaxed,
+    memory_order_consume,
+    memory_order_acquire,
+    memory_order_release,
+    memory_order_acq_rel,
+    memory_order_seq_cst
+};
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+using _Atomic_counter_t = unsigned long;
+
+template <class _Integral, class _Ty>
+_NODISCARD volatile _Integral* _Atomic_address_as(_Ty& _Source) noexcept {
+    // gets a pointer to the argument as an integral type (to pass to intrinsics)
+    static_assert(is_integral_v<_Integral>, "Tried to reinterpret memory as non-integral");
+    return &reinterpret_cast<volatile _Integral&>(_Source);
+}
+
+template <class _Integral, class _Ty>
+_NODISCARD const volatile _Integral* _Atomic_address_as(const _Ty& _Source) noexcept {
+    // gets a pointer to the argument as an integral type (to pass to intrinsics)
+    static_assert(is_integral_v<_Integral>, "Tried to reinterpret memory as non-integral");
+    return &reinterpret_cast<const volatile _Integral&>(_Source);
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XATOMIC_H
diff --git a/msvc-stl/stl/inc/xatomic_wait.h b/msvc-stl/stl/inc/xatomic_wait.h
new file mode 100644
index 0000000..0f67e66
--- /dev/null
+++ b/msvc-stl/stl/inc/xatomic_wait.h
@@ -0,0 +1,50 @@
+// xatomic_wait.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XATOMIC_WAIT_H
+#define _XATOMIC_WAIT_H
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdlib>
+#include <xatomic.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+inline constexpr unsigned long __std_atomic_wait_no_timeout = 0xFFFF'FFFF; // Pass as partial timeout
+
+// Support for atomic waits.
+// The "direct" functions are used when the underlying infrastructure can use WaitOnAddress directly; that is, _Size is
+// 1, 2, 4, or 8. The contract is the same as the WaitOnAddress function from the Windows SDK.
+int __stdcall __std_atomic_wait_direct(
+    const void* _Storage, void* _Comparand, size_t _Size, unsigned long _Remaining_timeout) noexcept;
+void __stdcall __std_atomic_notify_one_direct(const void* _Storage) noexcept;
+void __stdcall __std_atomic_notify_all_direct(const void* _Storage) noexcept;
+
+// The "indirect" functions are used when the size is not 1, 2, 4, or 8; these notionally wait on another value which is
+// of one of those sizes whose value changes upon notify, hence "indirect". (As of 2020-07-24, this always uses the
+// fallback SRWLOCK and CONDITION_VARIABLE implementation but that is not contractual.)
+using _Atomic_wait_indirect_equal_callback_t = bool(__stdcall*)(
+    const void* _Storage, void* _Comparand, size_t _Size, void* _Param) _NOEXCEPT_FNPTR;
+
+int __stdcall __std_atomic_wait_indirect(const void* _Storage, void* _Comparand, size_t _Size, void* _Param,
+    _Atomic_wait_indirect_equal_callback_t _Are_equal, unsigned long _Remaining_timeout) noexcept;
+void __stdcall __std_atomic_notify_one_indirect(const void* _Storage) noexcept;
+void __stdcall __std_atomic_notify_all_indirect(const void* _Storage) noexcept;
+
+} // extern "C"
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XATOMIC_WAIT_H
diff --git a/msvc-stl/stl/inc/xbit_ops.h b/msvc-stl/stl/inc/xbit_ops.h
new file mode 100644
index 0000000..e1ce38f
--- /dev/null
+++ b/msvc-stl/stl/inc/xbit_ops.h
@@ -0,0 +1,97 @@
+// xbit_ops.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XBIT_OPS_H
+#define _XBIT_OPS_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdint>
+
+#include _STL_INTRIN_HEADER
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+_NODISCARD inline unsigned long _Floor_of_log_2(size_t _Value) noexcept { // returns floor(log_2(_Value))
+    _Value |= size_t{1}; // avoid undefined answer from _BitScanReverse for 0
+    unsigned long _Result;
+
+#ifdef _M_CEE_PURE
+#ifdef _WIN64
+    _Result = 63;
+#else // ^^^ 64-bit / 32-bit vvv
+    _Result = 31;
+#endif // ^^^ 32-bit ^^^
+
+    while ((size_t{1} << _Result) > _Value) {
+        --_Result;
+    }
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#ifdef _WIN64
+    // CodeQL [SM02313] _Result is always initialized: the code above guarantees that _Value is non-zero.
+    _BitScanReverse64(&_Result, _Value);
+#else // ^^^ 64-bit / 32-bit vvv
+    // CodeQL [SM02313] _Result is always initialized: the code above guarantees that _Value is non-zero.
+    _BitScanReverse(&_Result, _Value);
+#endif // ^^^ 32-bit ^^^
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    return _Result;
+}
+
+_NODISCARD inline unsigned long _Ceiling_of_log_2(const size_t _Value) noexcept { // returns ceil(log_2(_Value))
+                                                                                  // pre: _Value > 1
+    return 1 + _Floor_of_log_2(_Value - 1);
+}
+
+_NODISCARD inline uint32_t _Bit_scan_reverse(const uint32_t _Value) noexcept {
+    unsigned long _Index; // Intentionally uninitialized for better codegen
+
+    if (_BitScanReverse(&_Index, _Value)) {
+        return _Index + 1;
+    }
+
+    return 0;
+}
+
+_NODISCARD inline uint32_t _Bit_scan_reverse(const uint64_t _Value) noexcept {
+    unsigned long _Index; // Intentionally uninitialized for better codegen
+
+#ifdef _WIN64
+    if (_BitScanReverse64(&_Index, _Value)) {
+        return _Index + 1;
+    }
+#else // ^^^ 64-bit / 32-bit vvv
+    uint32_t _Ui32 = static_cast<uint32_t>(_Value >> 32);
+
+    if (_BitScanReverse(&_Index, _Ui32)) {
+        return _Index + 1 + 32;
+    }
+
+    _Ui32 = static_cast<uint32_t>(_Value);
+
+    if (_BitScanReverse(&_Index, _Ui32)) {
+        return _Index + 1;
+    }
+#endif // ^^^ 32-bit ^^^
+
+    return 0;
+}
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XBIT_OPS_H
diff --git a/msvc-stl/stl/inc/xcall_once.h b/msvc-stl/stl/inc/xcall_once.h
new file mode 100644
index 0000000..17d32e4
--- /dev/null
+++ b/msvc-stl/stl/inc/xcall_once.h
@@ -0,0 +1,117 @@
+// xcall_once.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XCALL_ONCE_H
+#define _XCALL_ONCE_H
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdlib>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD struct once_flag { // opaque data structure for call_once()
+    constexpr once_flag() noexcept : _Opaque(nullptr) {}
+
+    once_flag(const once_flag&)            = delete;
+    once_flag& operator=(const once_flag&) = delete;
+
+    void* _Opaque;
+};
+
+template <class _Ty>
+union _Immortalizer_impl { // constructs _Ty, never destroys
+    constexpr _Immortalizer_impl() noexcept : _Storage{} {}
+    _Immortalizer_impl(const _Immortalizer_impl&)            = delete;
+    _Immortalizer_impl& operator=(const _Immortalizer_impl&) = delete;
+    ~_Immortalizer_impl() {
+        // do nothing
+    }
+
+    _Ty _Storage;
+};
+
+#if defined(_M_CEE) || defined(_M_ARM64EC) || defined(_M_HYBRID) \
+    || defined(__clang__) // TRANSITION, avoid /ALTERNATENAME for Clang, see GH-5224
+#define _WINDOWS_API              __stdcall
+#define _RENAME_WINDOWS_API(_Api) _Api##_clr
+#else // ^^^ use forwarders / use /ALTERNATENAME vvv
+#define _WINDOWS_API              __declspec(dllimport) __stdcall
+#define _RENAME_WINDOWS_API(_Api) _Api
+#endif // ^^^ use /ALTERNATENAME ^^^
+
+// WINBASEAPI
+// BOOL
+// WINAPI
+// InitOnceBeginInitialize(
+//     _Inout_ LPINIT_ONCE lpInitOnce,
+//     _In_ DWORD dwFlags,
+//     _Out_ PBOOL fPending,
+//     _Outptr_opt_result_maybenull_ LPVOID* lpContext
+//     );
+extern "C" _NODISCARD int _WINDOWS_API _RENAME_WINDOWS_API(__std_init_once_begin_initialize)(
+    void** _LpInitOnce, unsigned long _DwFlags, int* _FPending, void** _LpContext) noexcept;
+
+// WINBASEAPI
+// BOOL
+// WINAPI
+// InitOnceComplete(
+//     _Inout_ LPINIT_ONCE lpInitOnce,
+//     _In_ DWORD dwFlags,
+//     _In_opt_ LPVOID lpContext
+//     );
+extern "C" _NODISCARD int _WINDOWS_API _RENAME_WINDOWS_API(__std_init_once_complete)(
+    void** _LpInitOnce, unsigned long _DwFlags, void* _LpContext) noexcept;
+
+extern "C" [[noreturn]] void __stdcall __std_init_once_link_alternate_names_and_abort() noexcept;
+
+// #define RTL_RUN_ONCE_INIT_FAILED    0x00000004UL
+// #define INIT_ONCE_INIT_FAILED       RTL_RUN_ONCE_INIT_FAILED
+_INLINE_VAR constexpr unsigned long _Init_once_init_failed = 0x4UL;
+
+struct _Init_once_completer {
+    once_flag& _Once;
+    unsigned long _DwFlags;
+    ~_Init_once_completer() {
+        if (!_RENAME_WINDOWS_API(__std_init_once_complete)(&_Once._Opaque, _DwFlags, nullptr)) {
+            __std_init_once_link_alternate_names_and_abort();
+        }
+    }
+};
+
+_EXPORT_STD template <class _Fn, class... _Args>
+void(call_once)(once_flag& _Once, _Fn&& _Fx, _Args&&... _Ax)
+    noexcept(noexcept(_STD invoke(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...))) /* strengthened */ {
+    // call _Fx(_Ax...) once
+    // parentheses against common "#define call_once(flag,func) pthread_once(flag,func)"
+    int _Pending;
+    if (!_RENAME_WINDOWS_API(__std_init_once_begin_initialize)(&_Once._Opaque, 0, &_Pending, nullptr)) {
+        _STL_REPORT_ERROR("InitOnceBeginInitialize() failed");
+    }
+
+    if (_Pending != 0) {
+        _Init_once_completer _Op{_Once, _Init_once_init_failed};
+        _STD invoke(_STD forward<_Fn>(_Fx), _STD forward<_Args>(_Ax)...);
+        _Op._DwFlags = 0;
+    }
+}
+
+#undef _WINDOWS_API
+#undef _RENAME_WINDOWS_API
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCALL_ONCE_H
diff --git a/msvc-stl/stl/inc/xcharconv.h b/msvc-stl/stl/inc/xcharconv.h
new file mode 100644
index 0000000..7140f48
--- /dev/null
+++ b/msvc-stl/stl/inc/xcharconv.h
@@ -0,0 +1,52 @@
+// xcharconv.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XCHARCONV_H
+#define _XCHARCONV_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error The contents of <charconv> are only available with C++17. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX17
+
+#include <cstdint>
+#include <type_traits>
+#include <xerrc.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD enum class chars_format {
+    scientific = 0b001,
+    fixed      = 0b010,
+    hex        = 0b100,
+    general    = fixed | scientific,
+};
+
+_BITMASK_OPS(_EXPORT_STD, chars_format)
+
+_EXPORT_STD struct to_chars_result {
+    char* ptr;
+    errc ec;
+#if _HAS_CXX20
+    _NODISCARD friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
+#endif // _HAS_CXX20
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCHARCONV_H
diff --git a/msvc-stl/stl/inc/xcharconv_ryu.h b/msvc-stl/stl/inc/xcharconv_ryu.h
new file mode 100644
index 0000000..011500b
--- /dev/null
+++ b/msvc-stl/stl/inc/xcharconv_ryu.h
@@ -0,0 +1,2421 @@
+// xcharconv_ryu.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception AND BSL-1.0
+
+
+// Copyright 2018 Ulf Adams
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// 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.
+
+
+#ifndef _XCHARCONV_RYU_H
+#define _XCHARCONV_RYU_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error The contents of <charconv> are only available with C++17. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX17
+
+#include <cstring>
+#include <type_traits>
+#include <utility>
+#include <xcharconv.h>
+#include <xcharconv_ryu_tables.h>
+#include <xutility>
+
+#if defined(_M_X64) || defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+#define _HAS_CHARCONV_INTRINSICS 1
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+#define _HAS_CHARCONV_INTRINSICS 0
+#endif // ^^^ intrinsics unavailable ^^^
+
+#if _HAS_CHARCONV_INTRINSICS
+#include _STL_INTRIN_HEADER // for _umul128(), __umulh(), and __shiftright128()
+#endif // ^^^ intrinsics available ^^^
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+// https://github.com/ulfjack/ryu/tree/59661c3/ryu
+// (Keep the cgmanifest.json commitHash in sync.)
+
+// clang-format off: avoid diverging from external code
+
+// vvvvvvvvvv DERIVED FROM common.h vvvvvvvvvv
+
+_NODISCARD inline uint32_t __decimalLength9(const uint32_t __v) {
+  // Function precondition: __v is not a 10-digit number.
+  // (f2s: 9 digits are sufficient for round-tripping.)
+  // (d2fixed: We print 9-digit blocks.)
+  _STL_INTERNAL_CHECK(__v < 1000000000);
+  if (__v >= 100000000) { return 9; }
+  if (__v >= 10000000) { return 8; }
+  if (__v >= 1000000) { return 7; }
+  if (__v >= 100000) { return 6; }
+  if (__v >= 10000) { return 5; }
+  if (__v >= 1000) { return 4; }
+  if (__v >= 100) { return 3; }
+  if (__v >= 10) { return 2; }
+  return 1;
+}
+
+// Returns __e == 0 ? 1 : ceil(log_2(5^__e)).
+_NODISCARD inline int32_t __pow5bits(const int32_t __e) {
+  // This approximation works up to the point that the multiplication overflows at __e = 3529.
+  // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater
+  // than 2^9297.
+  _STL_INTERNAL_CHECK(__e >= 0);
+  _STL_INTERNAL_CHECK(__e <= 3528);
+  return static_cast<int32_t>(((static_cast<uint32_t>(__e) * 1217359) >> 19) + 1);
+}
+
+// Returns floor(log_10(2^__e)).
+_NODISCARD inline uint32_t __log10Pow2(const int32_t __e) {
+  // The first value this approximation fails for is 2^1651 which is just greater than 10^297.
+  _STL_INTERNAL_CHECK(__e >= 0);
+  _STL_INTERNAL_CHECK(__e <= 1650);
+  return (static_cast<uint32_t>(__e) * 78913) >> 18;
+}
+
+// Returns floor(log_10(5^__e)).
+_NODISCARD inline uint32_t __log10Pow5(const int32_t __e) {
+  // The first value this approximation fails for is 5^2621 which is just greater than 10^1832.
+  _STL_INTERNAL_CHECK(__e >= 0);
+  _STL_INTERNAL_CHECK(__e <= 2620);
+  return (static_cast<uint32_t>(__e) * 732923) >> 20;
+}
+
+_NODISCARD inline uint32_t __float_to_bits(const float __f) {
+  uint32_t __bits = 0;
+  _CSTD memcpy(&__bits, &__f, sizeof(float));
+  return __bits;
+}
+
+_NODISCARD inline uint64_t __double_to_bits(const double __d) {
+  uint64_t __bits = 0;
+  _CSTD memcpy(&__bits, &__d, sizeof(double));
+  return __bits;
+}
+
+// ^^^^^^^^^^ DERIVED FROM common.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2s.h vvvvvvvvvv
+
+inline constexpr int __DOUBLE_MANTISSA_BITS = 52;
+inline constexpr int __DOUBLE_BIAS = 1023;
+
+inline constexpr int __DOUBLE_POW5_INV_BITCOUNT = 122;
+inline constexpr int __DOUBLE_POW5_BITCOUNT = 121;
+
+// ^^^^^^^^^^ DERIVED FROM d2s.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2s_intrinsics.h vvvvvvvvvv
+
+#if _HAS_CHARCONV_INTRINSICS
+
+_NODISCARD inline uint64_t __ryu_umul128(const uint64_t __a, const uint64_t __b, uint64_t* const __productHi) {
+#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+  *__productHi = __umulh(__a, __b);
+  return __a * __b;
+#else // ^^^ not native X64 / native X64 vvv
+  return _umul128(__a, __b, __productHi);
+#endif // defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
+}
+
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+
+_NODISCARD __forceinline uint64_t __ryu_umul128(const uint64_t __a, const uint64_t __b, uint64_t* const __productHi) {
+  // TRANSITION, VSO-634761
+  // The casts here help MSVC to avoid calls to the __allmul library function.
+  const uint32_t __aLo = static_cast<uint32_t>(__a);
+  const uint32_t __aHi = static_cast<uint32_t>(__a >> 32);
+  const uint32_t __bLo = static_cast<uint32_t>(__b);
+  const uint32_t __bHi = static_cast<uint32_t>(__b >> 32);
+
+  const uint64_t __b00 = static_cast<uint64_t>(__aLo) * __bLo;
+  const uint64_t __b01 = static_cast<uint64_t>(__aLo) * __bHi;
+  const uint64_t __b10 = static_cast<uint64_t>(__aHi) * __bLo;
+  const uint64_t __b11 = static_cast<uint64_t>(__aHi) * __bHi;
+
+  const uint32_t __b00Lo = static_cast<uint32_t>(__b00);
+  const uint32_t __b00Hi = static_cast<uint32_t>(__b00 >> 32);
+
+  const uint64_t __mid1 = __b10 + __b00Hi;
+  const uint32_t __mid1Lo = static_cast<uint32_t>(__mid1);
+  const uint32_t __mid1Hi = static_cast<uint32_t>(__mid1 >> 32);
+
+  const uint64_t __mid2 = __b01 + __mid1Lo;
+  const uint32_t __mid2Lo = static_cast<uint32_t>(__mid2);
+  const uint32_t __mid2Hi = static_cast<uint32_t>(__mid2 >> 32);
+
+  const uint64_t __pHi = __b11 + __mid1Hi + __mid2Hi;
+  const uint64_t __pLo = (static_cast<uint64_t>(__mid2Lo) << 32) | __b00Lo;
+
+  *__productHi = __pHi;
+  return __pLo;
+}
+
+#endif // ^^^ intrinsics unavailable ^^^
+
+_NODISCARD inline uint64_t __ryu_shiftright128(const uint64_t __lo, const uint64_t __hi, const uint32_t __dist) {
+  // In the current implementation, the shift value is always < 64.
+  // If larger shift values are ever required, this function will need to be adjusted.
+  _STL_INTERNAL_CHECK(__dist < 64);
+
+#if defined(_M_X64) && !defined(_M_ARM64EC)
+  return __shiftright128(__lo, __hi, static_cast<unsigned char>(__dist));
+#else // ^^^ __shiftright128 intrinsic available / __shiftright128 intrinsic unavailable vvv
+  if (__dist == 0) {
+    return __lo;
+  }
+
+  return (__hi << (64 - __dist)) | (__lo >> __dist);
+#endif // ^^^ __shiftright128 intrinsic unavailable ^^^
+}
+
+
+#ifndef _WIN64
+
+#if !defined(_M_HYBRID_X86_ARM64)
+// Returns the high 64 bits of the 128-bit product of __a and __b.
+_NODISCARD inline uint64_t __umulh(const uint64_t __a, const uint64_t __b) {
+  // Reuse the __ryu_umul128 implementation.
+  // Optimizers will likely eliminate the instructions used to compute the
+  // low part of the product.
+  uint64_t __hi;
+  (void) __ryu_umul128(__a, __b, &__hi);
+  return __hi;
+}
+#endif // ^^^ !defined(_M_HYBRID_X86_ARM64) ^^^
+
+// On 32-bit platforms, compilers typically generate calls to library
+// functions for 64-bit divisions, even if the divisor is a constant.
+//
+// TRANSITION, LLVM-37932
+//
+// The functions here perform division-by-constant using multiplications
+// in the same way as 64-bit compilers would do.
+//
+// NB:
+// The multipliers and shift values are the ones generated by clang x64
+// for expressions like x/5, x/10, etc.
+
+_NODISCARD inline uint64_t __div5(const uint64_t __x) {
+  return __umulh(__x, 0xCCCCCCCCCCCCCCCDu) >> 2;
+}
+
+_NODISCARD inline uint64_t __div10(const uint64_t __x) {
+  return __umulh(__x, 0xCCCCCCCCCCCCCCCDu) >> 3;
+}
+
+_NODISCARD inline uint64_t __div100(const uint64_t __x) {
+  return __umulh(__x >> 2, 0x28F5C28F5C28F5C3u) >> 2;
+}
+
+_NODISCARD inline uint64_t __div1e8(const uint64_t __x) {
+  return __umulh(__x, 0xABCC77118461CEFDu) >> 26;
+}
+
+_NODISCARD inline uint64_t __div1e9(const uint64_t __x) {
+  return __umulh(__x >> 9, 0x44B82FA09B5A53u) >> 11;
+}
+
+_NODISCARD inline uint32_t __mod1e9(const uint64_t __x) {
+  // Avoid 64-bit math as much as possible.
+  // Returning static_cast<uint32_t>(__x - 1000000000 * __div1e9(__x)) would
+  // perform 32x64-bit multiplication and 64-bit subtraction.
+  // __x and 1000000000 * __div1e9(__x) are guaranteed to differ by
+  // less than 10^9, so their highest 32 bits must be identical,
+  // so we can truncate both sides to uint32_t before subtracting.
+  // We can also simplify static_cast<uint32_t>(1000000000 * __div1e9(__x)).
+  // We can truncate before multiplying instead of after, as multiplying
+  // the highest 32 bits of __div1e9(__x) can't affect the lowest 32 bits.
+  return static_cast<uint32_t>(__x) - 1000000000 * static_cast<uint32_t>(__div1e9(__x));
+}
+
+#else // ^^^ 32-bit / 64-bit vvv
+
+_NODISCARD inline uint64_t __div5(const uint64_t __x) {
+  return __x / 5;
+}
+
+_NODISCARD inline uint64_t __div10(const uint64_t __x) {
+  return __x / 10;
+}
+
+_NODISCARD inline uint64_t __div100(const uint64_t __x) {
+  return __x / 100;
+}
+
+_NODISCARD inline uint64_t __div1e8(const uint64_t __x) {
+  return __x / 100000000;
+}
+
+_NODISCARD inline uint64_t __div1e9(const uint64_t __x) {
+  return __x / 1000000000;
+}
+
+_NODISCARD inline uint32_t __mod1e9(const uint64_t __x) {
+  return static_cast<uint32_t>(__x - 1000000000 * __div1e9(__x));
+}
+
+#endif // ^^^ 64-bit ^^^
+
+_NODISCARD inline uint32_t __pow5Factor(uint64_t __value) {
+  uint32_t __count = 0;
+  for (;;) {
+    _STL_INTERNAL_CHECK(__value != 0);
+    const uint64_t __q = __div5(__value);
+    const uint32_t __r = static_cast<uint32_t>(__value) - 5 * static_cast<uint32_t>(__q);
+    if (__r != 0) {
+      break;
+    }
+    __value = __q;
+    ++__count;
+  }
+  return __count;
+}
+
+// Returns true if __value is divisible by 5^__p.
+_NODISCARD inline bool __multipleOfPowerOf5(const uint64_t __value, const uint32_t __p) {
+  // I tried a case distinction on __p, but there was no performance difference.
+  return __pow5Factor(__value) >= __p;
+}
+
+// Returns true if __value is divisible by 2^__p.
+_NODISCARD inline bool __multipleOfPowerOf2(const uint64_t __value, const uint32_t __p) {
+  _STL_INTERNAL_CHECK(__value != 0);
+  _STL_INTERNAL_CHECK(__p < 64);
+  // return __builtin_ctzll(__value) >= __p;
+  return (__value & ((1ull << __p) - 1)) == 0;
+}
+
+// ^^^^^^^^^^ DERIVED FROM d2s_intrinsics.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2fixed.c vvvvvvvvvv
+
+inline constexpr int __POW10_ADDITIONAL_BITS = 120;
+
+#if _HAS_CHARCONV_INTRINSICS
+// Returns the low 64 bits of the high 128 bits of the 256-bit product of a and b.
+_NODISCARD inline uint64_t __umul256_hi128_lo64(
+  const uint64_t __aHi, const uint64_t __aLo, const uint64_t __bHi, const uint64_t __bLo) {
+  uint64_t __b00Hi;
+  const uint64_t __b00Lo = __ryu_umul128(__aLo, __bLo, &__b00Hi);
+  uint64_t __b01Hi;
+  const uint64_t __b01Lo = __ryu_umul128(__aLo, __bHi, &__b01Hi);
+  uint64_t __b10Hi;
+  const uint64_t __b10Lo = __ryu_umul128(__aHi, __bLo, &__b10Hi);
+  uint64_t __b11Hi;
+  const uint64_t __b11Lo = __ryu_umul128(__aHi, __bHi, &__b11Hi);
+  (void) __b00Lo; // unused
+  (void) __b11Hi; // unused
+  const uint64_t __temp1Lo = __b10Lo + __b00Hi;
+  const uint64_t __temp1Hi = __b10Hi + (__temp1Lo < __b10Lo);
+  const uint64_t __temp2Lo = __b01Lo + __temp1Lo;
+  const uint64_t __temp2Hi = __b01Hi + (__temp2Lo < __b01Lo);
+  return __b11Lo + __temp1Hi + __temp2Hi;
+}
+
+_NODISCARD inline uint32_t __uint128_mod1e9(const uint64_t __vHi, const uint64_t __vLo) {
+  // After multiplying, we're going to shift right by 29, then truncate to uint32_t.
+  // This means that we need only 29 + 32 = 61 bits, so we can truncate to uint64_t before shifting.
+  const uint64_t __multiplied = __umul256_hi128_lo64(__vHi, __vLo, 0x89705F4136B4A597u, 0x31680A88F8953031u);
+
+  // For uint32_t truncation, see the __mod1e9() comment in d2s_intrinsics.h.
+  const uint32_t __shifted = static_cast<uint32_t>(__multiplied >> 29);
+
+  return static_cast<uint32_t>(__vLo) - 1000000000 * __shifted;
+}
+#endif // ^^^ intrinsics available ^^^
+
+_NODISCARD inline uint32_t __mulShift_mod1e9(const uint64_t __m, const uint64_t* const __mul, const int32_t __j) {
+  uint64_t __high0;                                               // 64
+  const uint64_t __low0 = __ryu_umul128(__m, __mul[0], &__high0); // 0
+  uint64_t __high1;                                               // 128
+  const uint64_t __low1 = __ryu_umul128(__m, __mul[1], &__high1); // 64
+  uint64_t __high2;                                               // 192
+  const uint64_t __low2 = __ryu_umul128(__m, __mul[2], &__high2); // 128
+  const uint64_t __s0low = __low0;                  // 0
+  (void) __s0low; // unused
+  const uint64_t __s0high = __low1 + __high0;       // 64
+  const uint32_t __c1 = __s0high < __low1;
+  const uint64_t __s1low = __low2 + __high1 + __c1; // 128
+  const uint32_t __c2 = __s1low < __low2; // __high1 + __c1 can't overflow, so compare against __low2
+  const uint64_t __s1high = __high2 + __c2;         // 192
+  _STL_INTERNAL_CHECK(__j >= 128);
+  _STL_INTERNAL_CHECK(__j <= 180);
+#if _HAS_CHARCONV_INTRINSICS
+  const uint32_t __dist = static_cast<uint32_t>(__j - 128); // __dist: [0, 52]
+  const uint64_t __shiftedhigh = __s1high >> __dist;
+  const uint64_t __shiftedlow = __ryu_shiftright128(__s1low, __s1high, __dist);
+  return __uint128_mod1e9(__shiftedhigh, __shiftedlow);
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+  if (__j < 160) { // __j: [128, 160)
+    const uint64_t __r0 = __mod1e9(__s1high);
+    const uint64_t __r1 = __mod1e9((__r0 << 32) | (__s1low >> 32));
+    const uint64_t __r2 = ((__r1 << 32) | (__s1low & 0xffffffff));
+    return __mod1e9(__r2 >> (__j - 128));
+  } else { // __j: [160, 192)
+    const uint64_t __r0 = __mod1e9(__s1high);
+    const uint64_t __r1 = ((__r0 << 32) | (__s1low >> 32));
+    return __mod1e9(__r1 >> (__j - 160));
+  }
+#endif // ^^^ intrinsics unavailable ^^^
+}
+
+#define _WIDEN(_TYPE, _CHAR) static_cast<_TYPE>(is_same_v<_TYPE, char> ? _CHAR : L##_CHAR)
+
+template <class _CharT>
+void __append_n_digits(const uint32_t __olength, uint32_t __digits, _CharT* const __result) {
+  uint32_t __i = 0;
+  while (__digits >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = __digits - 10000 * (__digits / 10000);
+#else
+    const uint32_t __c = __digits % 10000;
+#endif
+    __digits /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 4, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    __i += 4;
+  }
+  if (__digits >= 100) {
+    const uint32_t __c = (__digits % 100) << 1;
+    __digits /= 100;
+    _CSTD memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    __i += 2;
+  }
+  if (__digits >= 10) {
+    const uint32_t __c = __digits << 1;
+    _CSTD memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+  } else {
+    __result[0] = static_cast<_CharT>(_WIDEN(_CharT, '0') + __digits);
+  }
+}
+
+inline void __append_d_digits(const uint32_t __olength, uint32_t __digits, char* const __result) {
+  uint32_t __i = 0;
+  while (__digits >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = __digits - 10000 * (__digits / 10000);
+#else
+    const uint32_t __c = __digits % 10000;
+#endif
+    __digits /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + __olength + 1 - __i - 2, __DIGIT_TABLE<char> + __c0, 2);
+    _CSTD memcpy(__result + __olength + 1 - __i - 4, __DIGIT_TABLE<char> + __c1, 2);
+    __i += 4;
+  }
+  if (__digits >= 100) {
+    const uint32_t __c = (__digits % 100) << 1;
+    __digits /= 100;
+    _CSTD memcpy(__result + __olength + 1 - __i - 2, __DIGIT_TABLE<char> + __c, 2);
+    __i += 2;
+  }
+  if (__digits >= 10) {
+    const uint32_t __c = __digits << 1;
+    __result[2] = __DIGIT_TABLE<char>[__c + 1];
+    __result[1] = '.';
+    __result[0] = __DIGIT_TABLE<char>[__c];
+  } else {
+    __result[1] = '.';
+    __result[0] = static_cast<char>('0' + __digits);
+  }
+}
+
+template <class _CharT>
+void __append_c_digits(const uint32_t __count, uint32_t __digits, _CharT* const __result) {
+  uint32_t __i = 0;
+  for (; __i < __count - 1; __i += 2) {
+    const uint32_t __c = (__digits % 100) << 1;
+    __digits /= 100;
+    _CSTD memcpy(__result + __count - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+  }
+  if (__i < __count) {
+    const _CharT __c = static_cast<_CharT>(_WIDEN(_CharT, '0') + (__digits % 10));
+    __result[__count - __i - 1] = __c;
+  }
+}
+
+template <class _CharT>
+void __append_nine_digits(uint32_t __digits, _CharT* const __result) {
+  if (__digits == 0) {
+    _STD fill_n(__result, 9, _WIDEN(_CharT, '0'));
+    return;
+  }
+
+  for (uint32_t __i = 0; __i < 5; __i += 4) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = __digits - 10000 * (__digits / 10000);
+#else
+    const uint32_t __c = __digits % 10000;
+#endif
+    __digits /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + 7 - __i, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + 5 - __i, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+  }
+  __result[0] = static_cast<_CharT>(_WIDEN(_CharT, '0') + __digits);
+}
+
+_NODISCARD inline uint32_t __indexForExponent(const uint32_t __e) {
+  return (__e + 15) / 16;
+}
+
+_NODISCARD inline uint32_t __pow10BitsForIndex(const uint32_t __idx) {
+  return 16 * __idx + __POW10_ADDITIONAL_BITS;
+}
+
+_NODISCARD inline uint32_t __lengthForIndex(const uint32_t __idx) {
+  // +1 for ceil, +16 for mantissa, +8 to round up when dividing by 9
+  return (__log10Pow2(16 * static_cast<int32_t>(__idx)) + 1 + 16 + 8) / 9;
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __d2fixed_buffered_n(_CharT* _First, _CharT* const _Last, const double __d,
+  const uint32_t __precision) {
+  _CharT* const _Original_first = _First;
+
+  const uint64_t __bits = __double_to_bits(__d);
+
+  // Case distinction; exit early for the easy cases.
+  if (__bits == 0) {
+    const int32_t _Total_zero_length = 1 // leading zero
+      + static_cast<int32_t>(__precision != 0) // possible decimal point
+      + static_cast<int32_t>(__precision); // zeroes after decimal point
+
+    if (_Last - _First < _Total_zero_length) {
+      return { _Last, errc::value_too_large };
+    }
+
+    *_First++ = _WIDEN(_CharT, '0');
+    if (__precision > 0) {
+      *_First++ = _WIDEN(_CharT, '.');
+      _STD fill_n(_First, __precision, _WIDEN(_CharT, '0'));
+      _First += __precision;
+    }
+    return { _First, errc{} };
+  }
+
+  // Decode __bits into mantissa and exponent.
+  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
+  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);
+
+  int32_t __e2;
+  uint64_t __m2;
+  if (__ieeeExponent == 0) {
+    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+    __m2 = __ieeeMantissa;
+  } else {
+    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
+  }
+
+  bool __nonzero = false;
+  if (__e2 >= -52) {
+    const uint32_t __idx = __e2 < 0 ? 0 : __indexForExponent(static_cast<uint32_t>(__e2));
+    const uint32_t __p10bits = __pow10BitsForIndex(__idx);
+    const int32_t __len = static_cast<int32_t>(__lengthForIndex(__idx));
+    for (int32_t __i = __len - 1; __i >= 0; --__i) {
+      const uint32_t __j = __p10bits - __e2;
+      // Temporary: __j is usually around 128, and by shifting a bit, we push it to 128 or above, which is
+      // a slightly faster code path in __mulShift_mod1e9. Instead, we can just increase the multipliers.
+      const uint32_t __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT[__POW10_OFFSET[__idx] + __i],
+        static_cast<int32_t>(__j + 8));
+      if (__nonzero) {
+        if (_Last - _First < 9) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_nine_digits(__digits, _First);
+        _First += 9;
+      } else if (__digits != 0) {
+        const uint32_t __olength = __decimalLength9(__digits);
+        if (_Last - _First < static_cast<ptrdiff_t>(__olength)) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_n_digits(__olength, __digits, _First);
+        _First += __olength;
+        __nonzero = true;
+      }
+    }
+  }
+  if (!__nonzero) {
+    if (_First == _Last) {
+      return { _Last, errc::value_too_large };
+    }
+    *_First++ = _WIDEN(_CharT, '0');
+  }
+  if (__precision > 0) {
+    if (_First == _Last) {
+      return { _Last, errc::value_too_large };
+    }
+    *_First++ = _WIDEN(_CharT, '.');
+  }
+  if (__e2 < 0) {
+    const int32_t __idx = -__e2 / 16;
+    const uint32_t __blocks = __precision / 9 + 1;
+    // 0 = don't round up; 1 = round up unconditionally; 2 = round up if odd.
+    int __roundUp = 0;
+    uint32_t __i = 0;
+    if (__blocks <= __MIN_BLOCK_2[__idx]) {
+      __i = __blocks;
+      if (_Last - _First < static_cast<ptrdiff_t>(__precision)) {
+        return { _Last, errc::value_too_large };
+      }
+      _STD fill_n(_First, __precision, _WIDEN(_CharT, '0'));
+      _First += __precision;
+    } else if (__i < __MIN_BLOCK_2[__idx]) {
+      __i = __MIN_BLOCK_2[__idx];
+      if (_Last - _First < static_cast<ptrdiff_t>(9 * __i)) {
+        return { _Last, errc::value_too_large };
+      }
+      _STD fill_n(_First, 9 * __i, _WIDEN(_CharT, '0'));
+      _First += 9 * __i;
+    }
+    for (; __i < __blocks; ++__i) {
+      const int32_t __j = __ADDITIONAL_BITS_2 + (-__e2 - 16 * __idx);
+      const uint32_t __p = __POW10_OFFSET_2[__idx] + __i - __MIN_BLOCK_2[__idx];
+      if (__p >= __POW10_OFFSET_2[__idx + 1]) {
+        // If the remaining digits are all 0, then we might as well use memset.
+        // No rounding required in this case.
+        const uint32_t __fill = __precision - 9 * __i;
+        if (_Last - _First < static_cast<ptrdiff_t>(__fill)) {
+          return { _Last, errc::value_too_large };
+        }
+        _STD fill_n(_First, __fill, _WIDEN(_CharT, '0'));
+        _First += __fill;
+        break;
+      }
+      // Temporary: __j is usually around 128, and by shifting a bit, we push it to 128 or above, which is
+      // a slightly faster code path in __mulShift_mod1e9. Instead, we can just increase the multipliers.
+      uint32_t __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT_2[__p], __j + 8);
+      if (__i < __blocks - 1) {
+        if (_Last - _First < 9) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_nine_digits(__digits, _First);
+        _First += 9;
+      } else {
+        const uint32_t __maximum = __precision - 9 * __i;
+        uint32_t __lastDigit = 0;
+        for (uint32_t __k = 0; __k < 9 - __maximum; ++__k) {
+          __lastDigit = __digits % 10;
+          __digits /= 10;
+        }
+        if (__lastDigit != 5) {
+          __roundUp = __lastDigit > 5;
+        } else {
+          // Is m * 10^(additionalDigits + 1) / 2^(-__e2) integer?
+          const int32_t __requiredTwos = -__e2 - static_cast<int32_t>(__precision) - 1;
+          const bool __trailingZeros = __requiredTwos <= 0
+            || (__requiredTwos < 60 && __multipleOfPowerOf2(__m2, static_cast<uint32_t>(__requiredTwos)));
+          __roundUp = __trailingZeros ? 2 : 1;
+        }
+        if (__maximum > 0) {
+          if (_Last - _First < static_cast<ptrdiff_t>(__maximum)) {
+            return { _Last, errc::value_too_large };
+          }
+          __append_c_digits(__maximum, __digits, _First);
+          _First += __maximum;
+        }
+        break;
+      }
+    }
+    if (__roundUp != 0) {
+      _CharT* _Round = _First;
+      _CharT* _Dot = _Last;
+      while (true) {
+        if (_Round == _Original_first) {
+          _Round[0] = _WIDEN(_CharT, '1');
+          if (_Dot != _Last) {
+            _Dot[0] = _WIDEN(_CharT, '0');
+            _Dot[1] = _WIDEN(_CharT, '.');
+          }
+          if (_First == _Last) {
+            return { _Last, errc::value_too_large };
+          }
+          *_First++ = _WIDEN(_CharT, '0');
+          break;
+        }
+        --_Round;
+        const _CharT __c = _Round[0];
+        if (__c == _WIDEN(_CharT, '.')) {
+          _Dot = _Round;
+        } else if (__c == _WIDEN(_CharT, '9')) {
+          _Round[0] = _WIDEN(_CharT, '0');
+          __roundUp = 1;
+        } else {
+          if (__roundUp == 1 || __c % 2 != 0) {
+            _Round[0] = static_cast<_CharT>(__c + 1);
+          }
+          break;
+        }
+      }
+    }
+  } else {
+    if (_Last - _First < static_cast<ptrdiff_t>(__precision)) {
+      return { _Last, errc::value_too_large };
+    }
+    _STD fill_n(_First, __precision, _WIDEN(_CharT, '0'));
+    _First += __precision;
+  }
+  return { _First, errc{} };
+}
+
+_NODISCARD inline to_chars_result __d2exp_buffered_n(char* _First, char* const _Last, const double __d,
+  uint32_t __precision) {
+  char* const _Original_first = _First;
+
+  const uint64_t __bits = __double_to_bits(__d);
+
+  // Case distinction; exit early for the easy cases.
+  if (__bits == 0) {
+    const int32_t _Total_zero_length = 1 // leading zero
+      + static_cast<int32_t>(__precision != 0) // possible decimal point
+      + static_cast<int32_t>(__precision) // zeroes after decimal point
+      + 4; // "e+00"
+    if (_Last - _First < _Total_zero_length) {
+      return { _Last, errc::value_too_large };
+    }
+    *_First++ = '0';
+    if (__precision > 0) {
+      *_First++ = '.';
+      _CSTD memset(_First, '0', __precision);
+      _First += __precision;
+    }
+    _CSTD memcpy(_First, "e+00", 4);
+    _First += 4;
+    return { _First, errc{} };
+  }
+
+  // Decode __bits into mantissa and exponent.
+  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
+  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);
+
+  int32_t __e2;
+  uint64_t __m2;
+  if (__ieeeExponent == 0) {
+    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+    __m2 = __ieeeMantissa;
+  } else {
+    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
+  }
+
+  const bool __printDecimalPoint = __precision > 0;
+  ++__precision;
+  uint32_t __digits = 0;
+  uint32_t __printedDigits = 0;
+  uint32_t __availableDigits = 0;
+  int32_t __exp = 0;
+  if (__e2 >= -52) {
+    const uint32_t __idx = __e2 < 0 ? 0 : __indexForExponent(static_cast<uint32_t>(__e2));
+    const uint32_t __p10bits = __pow10BitsForIndex(__idx);
+    const int32_t __len = static_cast<int32_t>(__lengthForIndex(__idx));
+    for (int32_t __i = __len - 1; __i >= 0; --__i) {
+      const uint32_t __j = __p10bits - __e2;
+      // Temporary: __j is usually around 128, and by shifting a bit, we push it to 128 or above, which is
+      // a slightly faster code path in __mulShift_mod1e9. Instead, we can just increase the multipliers.
+      __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT[__POW10_OFFSET[__idx] + __i],
+        static_cast<int32_t>(__j + 8));
+      if (__printedDigits != 0) {
+        if (__printedDigits + 9 > __precision) {
+          __availableDigits = 9;
+          break;
+        }
+        if (_Last - _First < 9) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_nine_digits(__digits, _First);
+        _First += 9;
+        __printedDigits += 9;
+      } else if (__digits != 0) {
+        __availableDigits = __decimalLength9(__digits);
+        __exp = __i * 9 + static_cast<int32_t>(__availableDigits) - 1;
+        if (__availableDigits > __precision) {
+          break;
+        }
+        if (__printDecimalPoint) {
+          if (_Last - _First < static_cast<ptrdiff_t>(__availableDigits + 1)) {
+            return { _Last, errc::value_too_large };
+          }
+          __append_d_digits(__availableDigits, __digits, _First);
+          _First += __availableDigits + 1; // +1 for decimal point
+        } else {
+          if (_First == _Last) {
+            return { _Last, errc::value_too_large };
+          }
+          *_First++ = static_cast<char>('0' + __digits);
+        }
+        __printedDigits = __availableDigits;
+        __availableDigits = 0;
+      }
+    }
+  }
+
+  if (__e2 < 0 && __availableDigits == 0) {
+    const int32_t __idx = -__e2 / 16;
+    for (int32_t __i = __MIN_BLOCK_2[__idx]; __i < 200; ++__i) {
+      const int32_t __j = __ADDITIONAL_BITS_2 + (-__e2 - 16 * __idx);
+      const uint32_t __p = __POW10_OFFSET_2[__idx] + static_cast<uint32_t>(__i) - __MIN_BLOCK_2[__idx];
+      // Temporary: __j is usually around 128, and by shifting a bit, we push it to 128 or above, which is
+      // a slightly faster code path in __mulShift_mod1e9. Instead, we can just increase the multipliers.
+      __digits = (__p >= __POW10_OFFSET_2[__idx + 1]) ? 0 : __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT_2[__p], __j + 8);
+      if (__printedDigits != 0) {
+        if (__printedDigits + 9 > __precision) {
+          __availableDigits = 9;
+          break;
+        }
+        if (_Last - _First < 9) {
+          return { _Last, errc::value_too_large };
+        }
+        __append_nine_digits(__digits, _First);
+        _First += 9;
+        __printedDigits += 9;
+      } else if (__digits != 0) {
+        __availableDigits = __decimalLength9(__digits);
+        __exp = -(__i + 1) * 9 + static_cast<int32_t>(__availableDigits) - 1;
+        if (__availableDigits > __precision) {
+          break;
+        }
+        if (__printDecimalPoint) {
+          if (_Last - _First < static_cast<ptrdiff_t>(__availableDigits + 1)) {
+            return { _Last, errc::value_too_large };
+          }
+          __append_d_digits(__availableDigits, __digits, _First);
+          _First += __availableDigits + 1; // +1 for decimal point
+        } else {
+          if (_First == _Last) {
+            return { _Last, errc::value_too_large };
+          }
+          *_First++ = static_cast<char>('0' + __digits);
+        }
+        __printedDigits = __availableDigits;
+        __availableDigits = 0;
+      }
+    }
+  }
+
+  const uint32_t __maximum = __precision - __printedDigits;
+  if (__availableDigits == 0) {
+    __digits = 0;
+  }
+  uint32_t __lastDigit = 0;
+  if (__availableDigits > __maximum) {
+    for (uint32_t __k = 0; __k < __availableDigits - __maximum; ++__k) {
+      __lastDigit = __digits % 10;
+      __digits /= 10;
+    }
+  }
+  // 0 = don't round up; 1 = round up unconditionally; 2 = round up if odd.
+  int __roundUp = 0;
+  if (__lastDigit != 5) {
+    __roundUp = __lastDigit > 5;
+  } else {
+    // Is m * 2^__e2 * 10^(__precision + 1 - __exp) integer?
+    // __precision was already increased by 1, so we don't need to write + 1 here.
+    const int32_t __rexp = static_cast<int32_t>(__precision) - __exp;
+    const int32_t __requiredTwos = -__e2 - __rexp;
+    bool __trailingZeros = __requiredTwos <= 0
+      || (__requiredTwos < 60 && __multipleOfPowerOf2(__m2, static_cast<uint32_t>(__requiredTwos)));
+    if (__rexp < 0) {
+      const int32_t __requiredFives = -__rexp;
+      __trailingZeros = __trailingZeros && __multipleOfPowerOf5(__m2, static_cast<uint32_t>(__requiredFives));
+    }
+    __roundUp = __trailingZeros ? 2 : 1;
+  }
+  if (__printedDigits != 0) {
+    if (_Last - _First < static_cast<ptrdiff_t>(__maximum)) {
+      return { _Last, errc::value_too_large };
+    }
+    if (__digits == 0) {
+      _CSTD memset(_First, '0', __maximum);
+    } else {
+      __append_c_digits(__maximum, __digits, _First);
+    }
+    _First += __maximum;
+  } else {
+    if (__printDecimalPoint) {
+      if (_Last - _First < static_cast<ptrdiff_t>(__maximum + 1)) {
+        return { _Last, errc::value_too_large };
+      }
+      __append_d_digits(__maximum, __digits, _First);
+      _First += __maximum + 1; // +1 for decimal point
+    } else {
+      if (_First == _Last) {
+        return { _Last, errc::value_too_large };
+      }
+      *_First++ = static_cast<char>('0' + __digits);
+    }
+  }
+  if (__roundUp != 0) {
+    char* _Round = _First;
+    while (true) {
+      if (_Round == _Original_first) {
+        _Round[0] = '1';
+        ++__exp;
+        break;
+      }
+      --_Round;
+      const char __c = _Round[0];
+      if (__c == '.') {
+        // Keep going.
+      } else if (__c == '9') {
+        _Round[0] = '0';
+        __roundUp = 1;
+      } else {
+        if (__roundUp == 1 || __c % 2 != 0) {
+          _Round[0] = static_cast<char>(__c + 1);
+        }
+        break;
+      }
+    }
+  }
+
+  char _Sign_character;
+
+  if (__exp < 0) {
+    _Sign_character = '-';
+    __exp = -__exp;
+  } else {
+    _Sign_character = '+';
+  }
+
+  const int _Exponent_part_length = __exp >= 100
+    ? 5 // "e+NNN"
+    : 4; // "e+NN"
+
+  if (_Last - _First < _Exponent_part_length) {
+    return { _Last, errc::value_too_large };
+  }
+
+  *_First++ = 'e';
+  *_First++ = _Sign_character;
+
+  if (__exp >= 100) {
+    const int32_t __c = __exp % 10;
+    _CSTD memcpy(_First, __DIGIT_TABLE<char> + 2 * (__exp / 10), 2);
+    _First[2] = static_cast<char>('0' + __c);
+    _First += 3;
+  } else {
+    _CSTD memcpy(_First, __DIGIT_TABLE<char> + 2 * __exp, 2);
+    _First += 2;
+  }
+
+  return { _First, errc{} };
+}
+
+// ^^^^^^^^^^ DERIVED FROM d2fixed.c ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM f2s.c vvvvvvvvvv
+
+inline constexpr int __FLOAT_MANTISSA_BITS = 23;
+inline constexpr int __FLOAT_BIAS = 127;
+
+// This table is generated by PrintFloatLookupTable.
+inline constexpr int __FLOAT_POW5_INV_BITCOUNT = 59;
+inline constexpr uint64_t __FLOAT_POW5_INV_SPLIT[31] = {
+  576460752303423489u, 461168601842738791u, 368934881474191033u, 295147905179352826u,
+  472236648286964522u, 377789318629571618u, 302231454903657294u, 483570327845851670u,
+  386856262276681336u, 309485009821345069u, 495176015714152110u, 396140812571321688u,
+  316912650057057351u, 507060240091291761u, 405648192073033409u, 324518553658426727u,
+  519229685853482763u, 415383748682786211u, 332306998946228969u, 531691198313966350u,
+  425352958651173080u, 340282366920938464u, 544451787073501542u, 435561429658801234u,
+  348449143727040987u, 557518629963265579u, 446014903970612463u, 356811923176489971u,
+  570899077082383953u, 456719261665907162u, 365375409332725730u
+};
+inline constexpr int __FLOAT_POW5_BITCOUNT = 61;
+inline constexpr uint64_t __FLOAT_POW5_SPLIT[47] = {
+  1152921504606846976u, 1441151880758558720u, 1801439850948198400u, 2251799813685248000u,
+  1407374883553280000u, 1759218604441600000u, 2199023255552000000u, 1374389534720000000u,
+  1717986918400000000u, 2147483648000000000u, 1342177280000000000u, 1677721600000000000u,
+  2097152000000000000u, 1310720000000000000u, 1638400000000000000u, 2048000000000000000u,
+  1280000000000000000u, 1600000000000000000u, 2000000000000000000u, 1250000000000000000u,
+  1562500000000000000u, 1953125000000000000u, 1220703125000000000u, 1525878906250000000u,
+  1907348632812500000u, 1192092895507812500u, 1490116119384765625u, 1862645149230957031u,
+  1164153218269348144u, 1455191522836685180u, 1818989403545856475u, 2273736754432320594u,
+  1421085471520200371u, 1776356839400250464u, 2220446049250313080u, 1387778780781445675u,
+  1734723475976807094u, 2168404344971008868u, 1355252715606880542u, 1694065894508600678u,
+  2117582368135750847u, 1323488980084844279u, 1654361225106055349u, 2067951531382569187u,
+  1292469707114105741u, 1615587133892632177u, 2019483917365790221u
+};
+
+_NODISCARD inline uint32_t __pow5Factor(uint32_t __value) {
+  uint32_t __count = 0;
+  for (;;) {
+    _STL_INTERNAL_CHECK(__value != 0);
+    const uint32_t __q = __value / 5;
+    const uint32_t __r = __value % 5;
+    if (__r != 0) {
+      break;
+    }
+    __value = __q;
+    ++__count;
+  }
+  return __count;
+}
+
+// Returns true if __value is divisible by 5^__p.
+_NODISCARD inline bool __multipleOfPowerOf5(const uint32_t __value, const uint32_t __p) {
+  return __pow5Factor(__value) >= __p;
+}
+
+// Returns true if __value is divisible by 2^__p.
+_NODISCARD inline bool __multipleOfPowerOf2(const uint32_t __value, const uint32_t __p) {
+  _STL_INTERNAL_CHECK(__value != 0);
+  _STL_INTERNAL_CHECK(__p < 32);
+  // return __builtin_ctz(__value) >= __p;
+  return (__value & ((1u << __p) - 1)) == 0;
+}
+
+_NODISCARD inline uint32_t __mulShift(const uint32_t __m, const uint64_t __factor, const int32_t __shift) {
+  _STL_INTERNAL_CHECK(__shift > 32);
+
+  // The casts here help MSVC to avoid calls to the __allmul library
+  // function.
+  const uint32_t __factorLo = static_cast<uint32_t>(__factor);
+  const uint32_t __factorHi = static_cast<uint32_t>(__factor >> 32);
+  const uint64_t __bits0 = static_cast<uint64_t>(__m) * __factorLo;
+  const uint64_t __bits1 = static_cast<uint64_t>(__m) * __factorHi;
+
+#ifndef _WIN64
+  // On 32-bit platforms we can avoid a 64-bit shift-right since we only
+  // need the upper 32 bits of the result and the shift value is > 32.
+  const uint32_t __bits0Hi = static_cast<uint32_t>(__bits0 >> 32);
+  uint32_t __bits1Lo = static_cast<uint32_t>(__bits1);
+  uint32_t __bits1Hi = static_cast<uint32_t>(__bits1 >> 32);
+  __bits1Lo += __bits0Hi;
+  __bits1Hi += (__bits1Lo < __bits0Hi);
+  const int32_t __s = __shift - 32;
+  return (__bits1Hi << (32 - __s)) | (__bits1Lo >> __s);
+#else // ^^^ 32-bit / 64-bit vvv
+  const uint64_t __sum = (__bits0 >> 32) + __bits1;
+  const uint64_t __shiftedSum = __sum >> (__shift - 32);
+  _STL_INTERNAL_CHECK(__shiftedSum <= UINT32_MAX);
+  return static_cast<uint32_t>(__shiftedSum);
+#endif // ^^^ 64-bit ^^^
+}
+
+_NODISCARD inline uint32_t __mulPow5InvDivPow2(const uint32_t __m, const uint32_t __q, const int32_t __j) {
+  return __mulShift(__m, __FLOAT_POW5_INV_SPLIT[__q], __j);
+}
+
+_NODISCARD inline uint32_t __mulPow5divPow2(const uint32_t __m, const uint32_t __i, const int32_t __j) {
+  return __mulShift(__m, __FLOAT_POW5_SPLIT[__i], __j);
+}
+
+// A floating decimal representing m * 10^e.
+struct __floating_decimal_32 {
+  uint32_t __mantissa;
+  int32_t __exponent;
+};
+
+_NODISCARD inline __floating_decimal_32 __f2d(const uint32_t __ieeeMantissa, const uint32_t __ieeeExponent) {
+  int32_t __e2;
+  uint32_t __m2;
+  if (__ieeeExponent == 0) {
+    // We subtract 2 so that the bounds computation has 2 additional bits.
+    __e2 = 1 - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS - 2;
+    __m2 = __ieeeMantissa;
+  } else {
+    __e2 = static_cast<int32_t>(__ieeeExponent) - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS - 2;
+    __m2 = (1u << __FLOAT_MANTISSA_BITS) | __ieeeMantissa;
+  }
+  const bool __even = (__m2 & 1) == 0;
+  const bool __acceptBounds = __even;
+
+  // Step 2: Determine the interval of valid decimal representations.
+  const uint32_t __mv = 4 * __m2;
+  const uint32_t __mp = 4 * __m2 + 2;
+  // Implicit bool -> int conversion. True is 1, false is 0.
+  const uint32_t __mmShift = __ieeeMantissa != 0 || __ieeeExponent <= 1;
+  const uint32_t __mm = 4 * __m2 - 1 - __mmShift;
+
+  // Step 3: Convert to a decimal power base using 64-bit arithmetic.
+  uint32_t __vr, __vp, __vm;
+  int32_t __e10;
+  bool __vmIsTrailingZeros = false;
+  bool __vrIsTrailingZeros = false;
+  uint8_t __lastRemovedDigit = 0;
+  if (__e2 >= 0) {
+    const uint32_t __q = __log10Pow2(__e2);
+    __e10 = static_cast<int32_t>(__q);
+    const int32_t __k = __FLOAT_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q)) - 1;
+    const int32_t __i = -__e2 + static_cast<int32_t>(__q) + __k;
+    __vr = __mulPow5InvDivPow2(__mv, __q, __i);
+    __vp = __mulPow5InvDivPow2(__mp, __q, __i);
+    __vm = __mulPow5InvDivPow2(__mm, __q, __i);
+    if (__q != 0 && (__vp - 1) / 10 <= __vm / 10) {
+      // We need to know one removed digit even if we are not going to loop below. We could use
+      // __q = X - 1 above, except that would require 33 bits for the result, and we've found that
+      // 32-bit arithmetic is faster even on 64-bit machines.
+      const int32_t __l = __FLOAT_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q - 1)) - 1;
+      __lastRemovedDigit = static_cast<uint8_t>(__mulPow5InvDivPow2(__mv, __q - 1,
+        -__e2 + static_cast<int32_t>(__q) - 1 + __l) % 10);
+    }
+    if (__q <= 9) {
+      // The largest power of 5 that fits in 24 bits is 5^10, but __q <= 9 seems to be safe as well.
+      // Only one of __mp, __mv, and __mm can be a multiple of 5, if any.
+      if (__mv % 5 == 0) {
+        __vrIsTrailingZeros = __multipleOfPowerOf5(__mv, __q);
+      } else if (__acceptBounds) {
+        __vmIsTrailingZeros = __multipleOfPowerOf5(__mm, __q);
+      } else {
+        __vp -= __multipleOfPowerOf5(__mp, __q);
+      }
+    }
+  } else {
+    const uint32_t __q = __log10Pow5(-__e2);
+    __e10 = static_cast<int32_t>(__q) + __e2;
+    const int32_t __i = -__e2 - static_cast<int32_t>(__q);
+    const int32_t __k = __pow5bits(__i) - __FLOAT_POW5_BITCOUNT;
+    int32_t __j = static_cast<int32_t>(__q) - __k;
+    __vr = __mulPow5divPow2(__mv, static_cast<uint32_t>(__i), __j);
+    __vp = __mulPow5divPow2(__mp, static_cast<uint32_t>(__i), __j);
+    __vm = __mulPow5divPow2(__mm, static_cast<uint32_t>(__i), __j);
+    if (__q != 0 && (__vp - 1) / 10 <= __vm / 10) {
+      __j = static_cast<int32_t>(__q) - 1 - (__pow5bits(__i + 1) - __FLOAT_POW5_BITCOUNT);
+      __lastRemovedDigit = static_cast<uint8_t>(__mulPow5divPow2(__mv, static_cast<uint32_t>(__i + 1), __j) % 10);
+    }
+    if (__q <= 1) {
+      // {__vr,__vp,__vm} is trailing zeros if {__mv,__mp,__mm} has at least __q trailing 0 bits.
+      // __mv = 4 * __m2, so it always has at least two trailing 0 bits.
+      __vrIsTrailingZeros = true;
+      if (__acceptBounds) {
+        // __mm = __mv - 1 - __mmShift, so it has 1 trailing 0 bit iff __mmShift == 1.
+        __vmIsTrailingZeros = __mmShift == 1;
+      } else {
+        // __mp = __mv + 2, so it always has at least one trailing 0 bit.
+        --__vp;
+      }
+    } else if (__q < 31) { // TRANSITION(ulfjack): Use a tighter bound here.
+      __vrIsTrailingZeros = __multipleOfPowerOf2(__mv, __q - 1);
+    }
+  }
+
+  // Step 4: Find the shortest decimal representation in the interval of valid representations.
+  int32_t __removed = 0;
+  uint32_t _Output;
+  if (__vmIsTrailingZeros || __vrIsTrailingZeros) {
+    // General case, which happens rarely (~4.0%).
+    while (__vp / 10 > __vm / 10) {
+#ifdef __clang__ // TRANSITION, LLVM-23106
+      __vmIsTrailingZeros &= __vm - (__vm / 10) * 10 == 0;
+#else
+      __vmIsTrailingZeros &= __vm % 10 == 0;
+#endif
+      __vrIsTrailingZeros &= __lastRemovedDigit == 0;
+      __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
+      __vr /= 10;
+      __vp /= 10;
+      __vm /= 10;
+      ++__removed;
+    }
+    if (__vmIsTrailingZeros) {
+      while (__vm % 10 == 0) {
+        __vrIsTrailingZeros &= __lastRemovedDigit == 0;
+        __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
+        __vr /= 10;
+        __vp /= 10;
+        __vm /= 10;
+        ++__removed;
+      }
+    }
+    if (__vrIsTrailingZeros && __lastRemovedDigit == 5 && __vr % 2 == 0) {
+      // Round even if the exact number is .....50..0.
+      __lastRemovedDigit = 4;
+    }
+    // We need to take __vr + 1 if __vr is outside bounds or we need to round up.
+    _Output = __vr + ((__vr == __vm && (!__acceptBounds || !__vmIsTrailingZeros)) || __lastRemovedDigit >= 5);
+  } else {
+    // Specialized for the common case (~96.0%). Percentages below are relative to this.
+    // Loop iterations below (approximately):
+    // 0: 13.6%, 1: 70.7%, 2: 14.1%, 3: 1.39%, 4: 0.14%, 5+: 0.01%
+    while (__vp / 10 > __vm / 10) {
+      __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
+      __vr /= 10;
+      __vp /= 10;
+      __vm /= 10;
+      ++__removed;
+    }
+    // We need to take __vr + 1 if __vr is outside bounds or we need to round up.
+    _Output = __vr + (__vr == __vm || __lastRemovedDigit >= 5);
+  }
+  const int32_t __exp = __e10 + __removed;
+
+  __floating_decimal_32 __fd;
+  __fd.__exponent = __exp;
+  __fd.__mantissa = _Output;
+  return __fd;
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> _Large_integer_to_chars(_CharT* const _First, _CharT* const _Last,
+  const uint32_t _Mantissa2, const int32_t _Exponent2) {
+
+  // Print the integer _Mantissa2 * 2^_Exponent2 exactly.
+
+  // For nonzero integers, _Exponent2 >= -23. (The minimum value occurs when _Mantissa2 * 2^_Exponent2 is 1.
+  // In that case, _Mantissa2 is the implicit 1 bit followed by 23 zeros, so _Exponent2 is -23 to shift away
+  // the zeros.) The dense range of exactly representable integers has negative or zero exponents
+  // (as positive exponents make the range non-dense). For that dense range, Ryu will always be used:
+  // every digit is necessary to uniquely identify the value, so Ryu must print them all.
+
+  // Positive exponents are the non-dense range of exactly representable integers.
+  // This contains all of the values for which Ryu can't be used (and a few Ryu-friendly values).
+
+  // Performance note: Long division appears to be faster than losslessly widening float to double and calling
+  // __d2fixed_buffered_n(). If __f2fixed_buffered_n() is implemented, it might be faster than long division.
+
+  _STL_INTERNAL_CHECK(_Exponent2 > 0);
+  _STL_INTERNAL_CHECK(_Exponent2 <= 104); // because __ieeeExponent <= 254
+
+  // Manually represent _Mantissa2 * 2^_Exponent2 as a large integer. _Mantissa2 is always 24 bits
+  // (due to the implicit bit), while _Exponent2 indicates a shift of at most 104 bits.
+  // 24 + 104 equals 128 equals 4 * 32, so we need exactly 4 32-bit elements.
+  // We use a little-endian representation, visualized like this:
+
+  // << left shift <<
+  // most significant
+  // _Data[3] _Data[2] _Data[1] _Data[0]
+  //                   least significant
+  //                   >> right shift >>
+
+  constexpr uint32_t _Data_size = 4;
+  uint32_t _Data[_Data_size]{};
+
+  // _Maxidx is the index of the most significant nonzero element.
+  uint32_t _Maxidx = ((24 + static_cast<uint32_t>(_Exponent2) + 31) / 32) - 1;
+  _STL_INTERNAL_CHECK(_Maxidx < _Data_size);
+
+  const uint32_t _Bit_shift = static_cast<uint32_t>(_Exponent2) % 32;
+  if (_Bit_shift <= 8) { // _Mantissa2's 24 bits don't cross an element boundary
+    _Data[_Maxidx] = _Mantissa2 << _Bit_shift;
+  } else { // _Mantissa2's 24 bits cross an element boundary
+    _Data[_Maxidx - 1] = _Mantissa2 << _Bit_shift;
+    _Data[_Maxidx] = _Mantissa2 >> (32 - _Bit_shift);
+  }
+
+  // If Ryu hasn't determined the total output length, we need to buffer the digits generated from right to left
+  // by long division. The largest possible float is: 340'282346638'528859811'704183484'516925440
+  uint32_t _Blocks[4];
+  int32_t _Filled_blocks = 0;
+  // From left to right, we're going to print:
+  // _Data[0] will be [1, 10] digits.
+  // Then if _Filled_blocks > 0:
+  // _Blocks[_Filled_blocks - 1], ..., _Blocks[0] will be 0-filled 9-digit blocks.
+
+  if (_Maxidx != 0) { // If the integer is actually large, perform long division.
+                      // Otherwise, skip to printing _Data[0].
+    for (;;) {
+      // Loop invariant: _Maxidx != 0 (i.e. the integer is actually large)
+
+      const uint32_t _Most_significant_elem = _Data[_Maxidx];
+      const uint32_t _Initial_remainder = _Most_significant_elem % 1000000000;
+      const uint32_t _Initial_quotient = _Most_significant_elem / 1000000000;
+      _Data[_Maxidx] = _Initial_quotient;
+      uint64_t _Remainder = _Initial_remainder;
+
+      // Process less significant elements.
+      uint32_t _Idx = _Maxidx;
+      do {
+        --_Idx; // Initially, _Remainder is at most 10^9 - 1.
+
+        // Now, _Remainder is at most (10^9 - 1) * 2^32 + 2^32 - 1, simplified to 10^9 * 2^32 - 1.
+        _Remainder = (_Remainder << 32) | _Data[_Idx];
+
+        // floor((10^9 * 2^32 - 1) / 10^9) == 2^32 - 1, so uint32_t _Quotient is lossless.
+        const uint32_t _Quotient = static_cast<uint32_t>(__div1e9(_Remainder));
+
+        // _Remainder is at most 10^9 - 1 again.
+        // For uint32_t truncation, see the __mod1e9() comment in d2s_intrinsics.h.
+        _Remainder = static_cast<uint32_t>(_Remainder) - 1000000000u * _Quotient;
+
+        _Data[_Idx] = _Quotient;
+      } while (_Idx != 0);
+
+      // Store a 0-filled 9-digit block.
+      _Blocks[_Filled_blocks++] = static_cast<uint32_t>(_Remainder);
+
+      if (_Initial_quotient == 0) { // Is the large integer shrinking?
+        --_Maxidx; // log2(10^9) is 29.9, so we can't shrink by more than one element.
+        if (_Maxidx == 0) {
+          break; // We've finished long division. Now we need to print _Data[0].
+        }
+      }
+    }
+  }
+
+  _STL_INTERNAL_CHECK(_Data[0] != 0);
+  for (uint32_t _Idx = 1; _Idx < _Data_size; ++_Idx) {
+    _STL_INTERNAL_CHECK(_Data[_Idx] == 0);
+  }
+
+  const uint32_t _Data_olength = _Data[0] >= 1000000000 ? 10 : __decimalLength9(_Data[0]);
+  const uint32_t _Total_fixed_length = _Data_olength + 9 * _Filled_blocks;
+
+  if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
+    return { _Last, errc::value_too_large };
+  }
+
+  _CharT* _Result = _First;
+
+  // Print _Data[0]. While it's up to 10 digits,
+  // which is more than Ryu generates, the code below can handle this.
+  __append_n_digits(_Data_olength, _Data[0], _Result);
+  _Result += _Data_olength;
+
+  // Print 0-filled 9-digit blocks.
+  for (int32_t _Idx = _Filled_blocks - 1; _Idx >= 0; --_Idx) {
+    __append_nine_digits(_Blocks[_Idx], _Result);
+    _Result += 9;
+  }
+
+  return { _Result, errc{} };
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __to_chars(_CharT* const _First, _CharT* const _Last, const __floating_decimal_32 __v,
+  chars_format _Fmt, const uint32_t __ieeeMantissa, const uint32_t __ieeeExponent) {
+  // Step 5: Print the decimal representation.
+  uint32_t _Output = __v.__mantissa;
+  const int32_t _Ryu_exponent = __v.__exponent;
+  const uint32_t __olength = __decimalLength9(_Output);
+  int32_t _Scientific_exponent = _Ryu_exponent + static_cast<int32_t>(__olength) - 1;
+
+  if (_Fmt == chars_format{}) {
+    int32_t _Lower;
+    int32_t _Upper;
+
+    if (__olength == 1) {
+      // Value | Fixed   | Scientific
+      // 1e-3  | "0.001" | "1e-03"
+      // 1e4   | "10000" | "1e+04"
+      _Lower = -3;
+      _Upper = 4;
+    } else {
+      // Value   | Fixed       | Scientific
+      // 1234e-7 | "0.0001234" | "1.234e-04"
+      // 1234e5  | "123400000" | "1.234e+08"
+      _Lower = -static_cast<int32_t>(__olength + 3);
+      _Upper = 5;
+    }
+
+    if (_Lower <= _Ryu_exponent && _Ryu_exponent <= _Upper) {
+      _Fmt = chars_format::fixed;
+    } else {
+      _Fmt = chars_format::scientific;
+    }
+  } else if (_Fmt == chars_format::general) {
+    // C11 7.21.6.1 "The fprintf function"/8:
+    // "Let P equal [...] 6 if the precision is omitted [...].
+    // Then, if a conversion with style E would have an exponent of X:
+    // - if P > X >= -4, the conversion is with style f [...].
+    // - otherwise, the conversion is with style e [...]."
+    if (-4 <= _Scientific_exponent && _Scientific_exponent < 6) {
+      _Fmt = chars_format::fixed;
+    } else {
+      _Fmt = chars_format::scientific;
+    }
+  }
+
+  if (_Fmt == chars_format::fixed) {
+    // Example: _Output == 1729, __olength == 4
+
+    // _Ryu_exponent | Printed  | _Whole_digits | _Total_fixed_length  | Notes
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //             2 | 172900   |  6            | _Whole_digits        | Ryu can't be used for printing
+    //             1 | 17290    |  5            | (sometimes adjusted) | when the trimmed digits are nonzero.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //             0 | 1729     |  4            | _Whole_digits        | Unified length cases.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //            -1 | 172.9    |  3            | __olength + 1        | This case can't happen for
+    //            -2 | 17.29    |  2            |                      | __olength == 1, but no additional
+    //            -3 | 1.729    |  1            |                      | code is needed to avoid it.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //            -4 | 0.1729   |  0            | 2 - _Ryu_exponent    | C11 7.21.6.1 "The fprintf function"/8:
+    //            -5 | 0.01729  | -1            |                      | "If a decimal-point character appears,
+    //            -6 | 0.001729 | -2            |                      | at least one digit appears before it."
+
+    const int32_t _Whole_digits = static_cast<int32_t>(__olength) + _Ryu_exponent;
+
+    uint32_t _Total_fixed_length;
+    if (_Ryu_exponent >= 0) { // cases "172900" and "1729"
+      _Total_fixed_length = static_cast<uint32_t>(_Whole_digits);
+      if (_Output == 1) {
+        // Rounding can affect the number of digits.
+        // For example, 1e11f is exactly "99999997952" which is 11 digits instead of 12.
+        // We can use a lookup table to detect this and adjust the total length.
+        static constexpr uint8_t _Adjustment[39] = {
+          0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,1,1,1,0,0,1,1,0,1,0,1,1,0,0,1,0,1,1,0,1,1,1 };
+        _Total_fixed_length -= _Adjustment[_Ryu_exponent];
+        // _Whole_digits doesn't need to be adjusted because these cases won't refer to it later.
+      }
+    } else if (_Whole_digits > 0) { // case "17.29"
+      _Total_fixed_length = __olength + 1;
+    } else { // case "0.001729"
+      _Total_fixed_length = static_cast<uint32_t>(2 - _Ryu_exponent);
+    }
+
+    if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
+      return { _Last, errc::value_too_large };
+    }
+
+    _CharT* _Mid;
+    if (_Ryu_exponent > 0) { // case "172900"
+      bool _Can_use_ryu;
+
+      if (_Ryu_exponent > 10) { // 10^10 is the largest power of 10 that's exactly representable as a float.
+        _Can_use_ryu = false;
+      } else {
+        // Ryu generated X: __v.__mantissa * 10^_Ryu_exponent
+        // __v.__mantissa == 2^_Trailing_zero_bits * (__v.__mantissa >> _Trailing_zero_bits)
+        // 10^_Ryu_exponent == 2^_Ryu_exponent * 5^_Ryu_exponent
+
+        // _Trailing_zero_bits is [0, 29] (aside: because 2^29 is the largest power of 2
+        // with 9 decimal digits, which is float's round-trip limit.)
+        // _Ryu_exponent is [1, 10].
+        // Normalization adds [2, 23] (aside: at least 2 because the pre-normalized mantissa is at least 5).
+        // This adds up to [3, 62], which is well below float's maximum binary exponent 127.
+
+        // Therefore, we just need to consider (__v.__mantissa >> _Trailing_zero_bits) * 5^_Ryu_exponent.
+
+        // If that product would exceed 24 bits, then X can't be exactly represented as a float.
+        // (That's not a problem for round-tripping, because X is close enough to the original float,
+        // but X isn't mathematically equal to the original float.) This requires a high-precision fallback.
+
+        // If the product is 24 bits or smaller, then X can be exactly represented as a float (and we don't
+        // need to re-synthesize it; the original float must have been X, because Ryu wouldn't produce the
+        // same output for two different floats X and Y). This allows Ryu's output to be used (zero-filled).
+
+        // (2^24 - 1) / 5^0 (for indexing), (2^24 - 1) / 5^1, ..., (2^24 - 1) / 5^10
+        static constexpr uint32_t _Max_shifted_mantissa[11] = {
+          16777215, 3355443, 671088, 134217, 26843, 5368, 1073, 214, 42, 8, 1 };
+
+        unsigned long _Trailing_zero_bits;
+        (void) _BitScanForward(&_Trailing_zero_bits, __v.__mantissa); // __v.__mantissa is guaranteed nonzero
+        const uint32_t _Shifted_mantissa = __v.__mantissa >> _Trailing_zero_bits;
+        _Can_use_ryu = _Shifted_mantissa <= _Max_shifted_mantissa[_Ryu_exponent];
+      }
+
+      if (!_Can_use_ryu) {
+        const uint32_t _Mantissa2 = __ieeeMantissa | (1u << __FLOAT_MANTISSA_BITS); // restore implicit bit
+        const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
+          - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS; // bias and normalization
+
+        // Performance note: We've already called Ryu, so this will redundantly perform buffering and bounds checking.
+        return _Large_integer_to_chars(_First, _Last, _Mantissa2, _Exponent2);
+      }
+
+      // _Can_use_ryu
+      // Print the decimal digits, left-aligned within [_First, _First + _Total_fixed_length).
+      _Mid = _First + __olength;
+    } else { // cases "1729", "17.29", and "0.001729"
+      // Print the decimal digits, right-aligned within [_First, _First + _Total_fixed_length).
+      _Mid = _First + _Total_fixed_length;
+    }
+
+    while (_Output >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+      const uint32_t __c = _Output - 10000 * (_Output / 10000);
+#else
+      const uint32_t __c = _Output % 10000;
+#endif
+      _Output /= 10000;
+      const uint32_t __c0 = (__c % 100) << 1;
+      const uint32_t __c1 = (__c / 100) << 1;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    }
+    if (_Output >= 100) {
+      const uint32_t __c = (_Output % 100) << 1;
+      _Output /= 100;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    }
+    if (_Output >= 10) {
+      const uint32_t __c = _Output << 1;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    } else {
+      *--_Mid = static_cast<_CharT>(_WIDEN(_CharT, '0') + _Output);
+    }
+
+    if (_Ryu_exponent > 0) { // case "172900" with _Can_use_ryu
+      // Performance note: it might be more efficient to do this immediately after setting _Mid.
+      _STD fill_n(_First + __olength, _Ryu_exponent, _WIDEN(_CharT, '0'));
+    } else if (_Ryu_exponent == 0) { // case "1729"
+      // Done!
+    } else if (_Whole_digits > 0) { // case "17.29"
+      // Performance note: moving digits might not be optimal.
+      _CSTD memmove(_First, _First + 1, static_cast<size_t>(_Whole_digits) * sizeof(_CharT));
+      _First[_Whole_digits] = _WIDEN(_CharT, '.');
+    } else { // case "0.001729"
+      // Performance note: a larger memset() followed by overwriting '.' might be more efficient.
+      _First[0] = _WIDEN(_CharT, '0');
+      _First[1] = _WIDEN(_CharT, '.');
+      _STD fill_n(_First + 2, -_Whole_digits, _WIDEN(_CharT, '0'));
+    }
+
+    return { _First + _Total_fixed_length, errc{} };
+  }
+
+  const uint32_t _Total_scientific_length =
+    __olength + (__olength > 1) + 4; // digits + possible decimal point + scientific exponent
+  if (_Last - _First < static_cast<ptrdiff_t>(_Total_scientific_length)) {
+    return { _Last, errc::value_too_large };
+  }
+  _CharT* const __result = _First;
+
+  // Print the decimal digits.
+  uint32_t __i = 0;
+  while (_Output >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = _Output - 10000 * (_Output / 10000);
+#else
+    const uint32_t __c = _Output % 10000;
+#endif
+    _Output /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    __i += 4;
+  }
+  if (_Output >= 100) {
+    const uint32_t __c = (_Output % 100) << 1;
+    _Output /= 100;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    __i += 2;
+  }
+  if (_Output >= 10) {
+    const uint32_t __c = _Output << 1;
+    // We can't use memcpy here: the decimal dot goes between these two digits.
+    __result[2] = __DIGIT_TABLE<_CharT>[__c + 1];
+    __result[0] = __DIGIT_TABLE<_CharT>[__c];
+  } else {
+    __result[0] = static_cast<_CharT>(_WIDEN(_CharT, '0') + _Output);
+  }
+
+  // Print decimal point if needed.
+  uint32_t __index;
+  if (__olength > 1) {
+    __result[1] = _WIDEN(_CharT, '.');
+    __index = __olength + 1;
+  } else {
+    __index = 1;
+  }
+
+  // Print the exponent.
+  __result[__index++] = _WIDEN(_CharT, 'e');
+  if (_Scientific_exponent < 0) {
+    __result[__index++] = _WIDEN(_CharT, '-');
+    _Scientific_exponent = -_Scientific_exponent;
+  } else {
+    __result[__index++] = _WIDEN(_CharT, '+');
+  }
+
+  _CSTD memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * _Scientific_exponent, 2 * sizeof(_CharT));
+  __index += 2;
+
+  return { _First + _Total_scientific_length, errc{} };
+}
+
+_NODISCARD inline to_chars_result _Convert_to_chars_result(const pair<char*, errc>& _Pair) {
+    return {_Pair.first, _Pair.second};
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __f2s_buffered_n(_CharT* const _First, _CharT* const _Last, const float __f,
+  const chars_format _Fmt) {
+
+  // Step 1: Decode the floating-point number, and unify normalized and subnormal cases.
+  const uint32_t __bits = __float_to_bits(__f);
+
+  // Case distinction; exit early for the easy cases.
+  if (__bits == 0) {
+    if (_Fmt == chars_format::scientific) {
+      if (_Last - _First < 5) {
+        return { _Last, errc::value_too_large };
+      }
+
+      if constexpr (is_same_v<_CharT, char>) {
+        _CSTD memcpy(_First, "0e+00", 5);
+      } else {
+        _CSTD memcpy(_First, L"0e+00", 5 * sizeof(wchar_t));
+      }
+
+      return { _First + 5, errc{} };
+    }
+
+    // Print "0" for chars_format::fixed, chars_format::general, and chars_format{}.
+    if (_First == _Last) {
+      return { _Last, errc::value_too_large };
+    }
+
+    *_First = _WIDEN(_CharT, '0');
+
+    return { _First + 1, errc{} };
+  }
+
+  // Decode __bits into mantissa and exponent.
+  const uint32_t __ieeeMantissa = __bits & ((1u << __FLOAT_MANTISSA_BITS) - 1);
+  const uint32_t __ieeeExponent = __bits >> __FLOAT_MANTISSA_BITS;
+
+  // When _Fmt == chars_format::fixed and the floating-point number is a large integer,
+  // it's faster to skip Ryu and immediately print the integer exactly.
+  if (_Fmt == chars_format::fixed) {
+    const uint32_t _Mantissa2 = __ieeeMantissa | (1u << __FLOAT_MANTISSA_BITS); // restore implicit bit
+    const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
+      - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS; // bias and normalization
+
+    // Normal values are equal to _Mantissa2 * 2^_Exponent2.
+    // (Subnormals are different, but they'll be rejected by the _Exponent2 test here, so they can be ignored.)
+
+    if (_Exponent2 > 0) {
+      return _Large_integer_to_chars(_First, _Last, _Mantissa2, _Exponent2);
+    }
+  }
+
+  const __floating_decimal_32 __v = __f2d(__ieeeMantissa, __ieeeExponent);
+  return __to_chars(_First, _Last, __v, _Fmt, __ieeeMantissa, __ieeeExponent);
+}
+
+// ^^^^^^^^^^ DERIVED FROM f2s.c ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2s.c vvvvvvvvvv
+
+// We need a 64x128-bit multiplication and a subsequent 128-bit shift.
+// Multiplication:
+//   The 64-bit factor is variable and passed in, the 128-bit factor comes
+//   from a lookup table. We know that the 64-bit factor only has 55
+//   significant bits (i.e., the 9 topmost bits are zeros). The 128-bit
+//   factor only has 124 significant bits (i.e., the 4 topmost bits are
+//   zeros).
+// Shift:
+//   In principle, the multiplication result requires 55 + 124 = 179 bits to
+//   represent. However, we then shift this value to the right by __j, which is
+//   at least __j >= 115, so the result is guaranteed to fit into 179 - 115 = 64
+//   bits. This means that we only need the topmost 64 significant bits of
+//   the 64x128-bit multiplication.
+//
+// There are several ways to do this:
+// 1. Best case: the compiler exposes a 128-bit type.
+//    We perform two 64x64-bit multiplications, add the higher 64 bits of the
+//    lower result to the higher result, and shift by __j - 64 bits.
+//
+//    We explicitly cast from 64-bit to 128-bit, so the compiler can tell
+//    that these are only 64-bit inputs, and can map these to the best
+//    possible sequence of assembly instructions.
+//    x64 machines happen to have matching assembly instructions for
+//    64x64-bit multiplications and 128-bit shifts.
+//
+// 2. Second best case: the compiler exposes intrinsics for the x64 assembly
+//    instructions mentioned in 1.
+//
+// 3. We only have 64x64 bit instructions that return the lower 64 bits of
+//    the result, i.e., we have to use plain C.
+//    Our inputs are less than the full width, so we have three options:
+//    a. Ignore this fact and just implement the intrinsics manually.
+//    b. Split both into 31-bit pieces, which guarantees no internal overflow,
+//       but requires extra work upfront (unless we change the lookup table).
+//    c. Split only the first factor into 31-bit pieces, which also guarantees
+//       no internal overflow, but requires extra work since the intermediate
+//       results are not perfectly aligned.
+#if _HAS_CHARCONV_INTRINSICS
+
+_NODISCARD inline uint64_t __mulShift(const uint64_t __m, const uint64_t* const __mul, const int32_t __j) {
+  // __m is maximum 55 bits
+  uint64_t __high1;                                               // 128
+  const uint64_t __low1 = __ryu_umul128(__m, __mul[1], &__high1); // 64
+  uint64_t __high0;                                               // 64
+  (void) __ryu_umul128(__m, __mul[0], &__high0);                  // 0
+  const uint64_t __sum = __high0 + __low1;
+  if (__sum < __high0) {
+    ++__high1; // overflow into __high1
+  }
+  return __ryu_shiftright128(__sum, __high1, static_cast<uint32_t>(__j - 64));
+}
+
+_NODISCARD inline uint64_t __mulShiftAll(const uint64_t __m, const uint64_t* const __mul, const int32_t __j,
+  uint64_t* const __vp, uint64_t* const __vm, const uint32_t __mmShift) {
+  *__vp = __mulShift(4 * __m + 2, __mul, __j);
+  *__vm = __mulShift(4 * __m - 1 - __mmShift, __mul, __j);
+  return __mulShift(4 * __m, __mul, __j);
+}
+
+#else // ^^^ intrinsics available / intrinsics unavailable vvv
+
+_NODISCARD __forceinline uint64_t __mulShiftAll(uint64_t __m, const uint64_t* const __mul, const int32_t __j,
+  uint64_t* const __vp, uint64_t* const __vm, const uint32_t __mmShift) { // TRANSITION, VSO-634761
+  __m <<= 1;
+  // __m is maximum 55 bits
+  uint64_t __tmp;
+  const uint64_t __lo = __ryu_umul128(__m, __mul[0], &__tmp);
+  uint64_t __hi;
+  const uint64_t __mid = __tmp + __ryu_umul128(__m, __mul[1], &__hi);
+  __hi += __mid < __tmp; // overflow into __hi
+
+  const uint64_t __lo2 = __lo + __mul[0];
+  const uint64_t __mid2 = __mid + __mul[1] + (__lo2 < __lo);
+  const uint64_t __hi2 = __hi + (__mid2 < __mid);
+  *__vp = __ryu_shiftright128(__mid2, __hi2, static_cast<uint32_t>(__j - 64 - 1));
+
+  if (__mmShift == 1) {
+    const uint64_t __lo3 = __lo - __mul[0];
+    const uint64_t __mid3 = __mid - __mul[1] - (__lo3 > __lo);
+    const uint64_t __hi3 = __hi - (__mid3 > __mid);
+    *__vm = __ryu_shiftright128(__mid3, __hi3, static_cast<uint32_t>(__j - 64 - 1));
+  } else {
+    const uint64_t __lo3 = __lo + __lo;
+    const uint64_t __mid3 = __mid + __mid + (__lo3 < __lo);
+    const uint64_t __hi3 = __hi + __hi + (__mid3 < __mid);
+    const uint64_t __lo4 = __lo3 - __mul[0];
+    const uint64_t __mid4 = __mid3 - __mul[1] - (__lo4 > __lo3);
+    const uint64_t __hi4 = __hi3 - (__mid4 > __mid3);
+    *__vm = __ryu_shiftright128(__mid4, __hi4, static_cast<uint32_t>(__j - 64));
+  }
+
+  return __ryu_shiftright128(__mid, __hi, static_cast<uint32_t>(__j - 64 - 1));
+}
+
+#endif // ^^^ intrinsics unavailable ^^^
+
+_NODISCARD inline uint32_t __decimalLength17(const uint64_t __v) {
+  // This is slightly faster than a loop.
+  // The average output length is 16.38 digits, so we check high-to-low.
+  // Function precondition: __v is not an 18, 19, or 20-digit number.
+  // (17 digits are sufficient for round-tripping.)
+  _STL_INTERNAL_CHECK(__v < 100000000000000000u);
+  if (__v >= 10000000000000000u) { return 17; }
+  if (__v >= 1000000000000000u) { return 16; }
+  if (__v >= 100000000000000u) { return 15; }
+  if (__v >= 10000000000000u) { return 14; }
+  if (__v >= 1000000000000u) { return 13; }
+  if (__v >= 100000000000u) { return 12; }
+  if (__v >= 10000000000u) { return 11; }
+  if (__v >= 1000000000u) { return 10; }
+  if (__v >= 100000000u) { return 9; }
+  if (__v >= 10000000u) { return 8; }
+  if (__v >= 1000000u) { return 7; }
+  if (__v >= 100000u) { return 6; }
+  if (__v >= 10000u) { return 5; }
+  if (__v >= 1000u) { return 4; }
+  if (__v >= 100u) { return 3; }
+  if (__v >= 10u) { return 2; }
+  return 1;
+}
+
+// A floating decimal representing m * 10^e.
+struct __floating_decimal_64 {
+  uint64_t __mantissa;
+  int32_t __exponent;
+};
+
+_NODISCARD inline __floating_decimal_64 __d2d(const uint64_t __ieeeMantissa, const uint32_t __ieeeExponent) {
+  int32_t __e2;
+  uint64_t __m2;
+  if (__ieeeExponent == 0) {
+    // We subtract 2 so that the bounds computation has 2 additional bits.
+    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS - 2;
+    __m2 = __ieeeMantissa;
+  } else {
+    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS - 2;
+    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
+  }
+  const bool __even = (__m2 & 1) == 0;
+  const bool __acceptBounds = __even;
+
+  // Step 2: Determine the interval of valid decimal representations.
+  const uint64_t __mv = 4 * __m2;
+  // Implicit bool -> int conversion. True is 1, false is 0.
+  const uint32_t __mmShift = __ieeeMantissa != 0 || __ieeeExponent <= 1;
+  // We would compute __mp and __mm like this:
+  // uint64_t __mp = 4 * __m2 + 2;
+  // uint64_t __mm = __mv - 1 - __mmShift;
+
+  // Step 3: Convert to a decimal power base using 128-bit arithmetic.
+  uint64_t __vr, __vp, __vm;
+  int32_t __e10;
+  bool __vmIsTrailingZeros = false;
+  bool __vrIsTrailingZeros = false;
+  if (__e2 >= 0) {
+    // I tried special-casing __q == 0, but there was no effect on performance.
+    // This expression is slightly faster than max(0, __log10Pow2(__e2) - 1).
+    const uint32_t __q = __log10Pow2(__e2) - (__e2 > 3);
+    __e10 = static_cast<int32_t>(__q);
+    const int32_t __k = __DOUBLE_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q)) - 1;
+    const int32_t __i = -__e2 + static_cast<int32_t>(__q) + __k;
+    __vr = __mulShiftAll(__m2, __DOUBLE_POW5_INV_SPLIT[__q], __i, &__vp, &__vm, __mmShift);
+    if (__q <= 21) {
+      // This should use __q <= 22, but I think 21 is also safe. Smaller values
+      // may still be safe, but it's more difficult to reason about them.
+      // Only one of __mp, __mv, and __mm can be a multiple of 5, if any.
+      const uint32_t __mvMod5 = static_cast<uint32_t>(__mv) - 5 * static_cast<uint32_t>(__div5(__mv));
+      if (__mvMod5 == 0) {
+        __vrIsTrailingZeros = __multipleOfPowerOf5(__mv, __q);
+      } else if (__acceptBounds) {
+        // Same as min(__e2 + (~__mm & 1), __pow5Factor(__mm)) >= __q
+        // <=> __e2 + (~__mm & 1) >= __q && __pow5Factor(__mm) >= __q
+        // <=> true && __pow5Factor(__mm) >= __q, since __e2 >= __q.
+        __vmIsTrailingZeros = __multipleOfPowerOf5(__mv - 1 - __mmShift, __q);
+      } else {
+        // Same as min(__e2 + 1, __pow5Factor(__mp)) >= __q.
+        __vp -= __multipleOfPowerOf5(__mv + 2, __q);
+      }
+    }
+  } else {
+    // This expression is slightly faster than max(0, __log10Pow5(-__e2) - 1).
+    const uint32_t __q = __log10Pow5(-__e2) - (-__e2 > 1);
+    __e10 = static_cast<int32_t>(__q) + __e2;
+    const int32_t __i = -__e2 - static_cast<int32_t>(__q);
+    const int32_t __k = __pow5bits(__i) - __DOUBLE_POW5_BITCOUNT;
+    const int32_t __j = static_cast<int32_t>(__q) - __k;
+    __vr = __mulShiftAll(__m2, __DOUBLE_POW5_SPLIT[__i], __j, &__vp, &__vm, __mmShift);
+    if (__q <= 1) {
+      // {__vr,__vp,__vm} is trailing zeros if {__mv,__mp,__mm} has at least __q trailing 0 bits.
+      // __mv = 4 * __m2, so it always has at least two trailing 0 bits.
+      __vrIsTrailingZeros = true;
+      if (__acceptBounds) {
+        // __mm = __mv - 1 - __mmShift, so it has 1 trailing 0 bit iff __mmShift == 1.
+        __vmIsTrailingZeros = __mmShift == 1;
+      } else {
+        // __mp = __mv + 2, so it always has at least one trailing 0 bit.
+        --__vp;
+      }
+    } else if (__q < 63) { // TRANSITION(ulfjack): Use a tighter bound here.
+      // We need to compute min(ntz(__mv), __pow5Factor(__mv) - __e2) >= __q - 1
+      // <=> ntz(__mv) >= __q - 1 && __pow5Factor(__mv) - __e2 >= __q - 1
+      // <=> ntz(__mv) >= __q - 1 (__e2 is negative and -__e2 >= __q)
+      // <=> (__mv & ((1 << (__q - 1)) - 1)) == 0
+      // We also need to make sure that the left shift does not overflow.
+      __vrIsTrailingZeros = __multipleOfPowerOf2(__mv, __q - 1);
+    }
+  }
+
+  // Step 4: Find the shortest decimal representation in the interval of valid representations.
+  int32_t __removed = 0;
+  uint8_t __lastRemovedDigit = 0;
+  uint64_t _Output;
+  // On average, we remove ~2 digits.
+  if (__vmIsTrailingZeros || __vrIsTrailingZeros) {
+    // General case, which happens rarely (~0.7%).
+    for (;;) {
+      const uint64_t __vpDiv10 = __div10(__vp);
+      const uint64_t __vmDiv10 = __div10(__vm);
+      if (__vpDiv10 <= __vmDiv10) {
+        break;
+      }
+      const uint32_t __vmMod10 = static_cast<uint32_t>(__vm) - 10 * static_cast<uint32_t>(__vmDiv10);
+      const uint64_t __vrDiv10 = __div10(__vr);
+      const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
+      __vmIsTrailingZeros &= __vmMod10 == 0;
+      __vrIsTrailingZeros &= __lastRemovedDigit == 0;
+      __lastRemovedDigit = static_cast<uint8_t>(__vrMod10);
+      __vr = __vrDiv10;
+      __vp = __vpDiv10;
+      __vm = __vmDiv10;
+      ++__removed;
+    }
+    if (__vmIsTrailingZeros) {
+      for (;;) {
+        const uint64_t __vmDiv10 = __div10(__vm);
+        const uint32_t __vmMod10 = static_cast<uint32_t>(__vm) - 10 * static_cast<uint32_t>(__vmDiv10);
+        if (__vmMod10 != 0) {
+          break;
+        }
+        const uint64_t __vpDiv10 = __div10(__vp);
+        const uint64_t __vrDiv10 = __div10(__vr);
+        const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
+        __vrIsTrailingZeros &= __lastRemovedDigit == 0;
+        __lastRemovedDigit = static_cast<uint8_t>(__vrMod10);
+        __vr = __vrDiv10;
+        __vp = __vpDiv10;
+        __vm = __vmDiv10;
+        ++__removed;
+      }
+    }
+    if (__vrIsTrailingZeros && __lastRemovedDigit == 5 && __vr % 2 == 0) {
+      // Round even if the exact number is .....50..0.
+      __lastRemovedDigit = 4;
+    }
+    // We need to take __vr + 1 if __vr is outside bounds or we need to round up.
+    _Output = __vr + ((__vr == __vm && (!__acceptBounds || !__vmIsTrailingZeros)) || __lastRemovedDigit >= 5);
+  } else {
+    // Specialized for the common case (~99.3%). Percentages below are relative to this.
+    bool __roundUp = false;
+    const uint64_t __vpDiv100 = __div100(__vp);
+    const uint64_t __vmDiv100 = __div100(__vm);
+    if (__vpDiv100 > __vmDiv100) { // Optimization: remove two digits at a time (~86.2%).
+      const uint64_t __vrDiv100 = __div100(__vr);
+      const uint32_t __vrMod100 = static_cast<uint32_t>(__vr) - 100 * static_cast<uint32_t>(__vrDiv100);
+      __roundUp = __vrMod100 >= 50;
+      __vr = __vrDiv100;
+      __vp = __vpDiv100;
+      __vm = __vmDiv100;
+      __removed += 2;
+    }
+    // Loop iterations below (approximately), without optimization above:
+    // 0: 0.03%, 1: 13.8%, 2: 70.6%, 3: 14.0%, 4: 1.40%, 5: 0.14%, 6+: 0.02%
+    // Loop iterations below (approximately), with optimization above:
+    // 0: 70.6%, 1: 27.8%, 2: 1.40%, 3: 0.14%, 4+: 0.02%
+    for (;;) {
+      const uint64_t __vpDiv10 = __div10(__vp);
+      const uint64_t __vmDiv10 = __div10(__vm);
+      if (__vpDiv10 <= __vmDiv10) {
+        break;
+      }
+      const uint64_t __vrDiv10 = __div10(__vr);
+      const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
+      __roundUp = __vrMod10 >= 5;
+      __vr = __vrDiv10;
+      __vp = __vpDiv10;
+      __vm = __vmDiv10;
+      ++__removed;
+    }
+    // We need to take __vr + 1 if __vr is outside bounds or we need to round up.
+    _Output = __vr + (__vr == __vm || __roundUp);
+  }
+  const int32_t __exp = __e10 + __removed;
+
+  __floating_decimal_64 __fd;
+  __fd.__exponent = __exp;
+  __fd.__mantissa = _Output;
+  return __fd;
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __to_chars(_CharT* const _First, _CharT* const _Last, const __floating_decimal_64 __v,
+  chars_format _Fmt, const double __f) {
+  // Step 5: Print the decimal representation.
+  uint64_t _Output = __v.__mantissa;
+  const int32_t _Ryu_exponent = __v.__exponent;
+  const uint32_t __olength = __decimalLength17(_Output);
+  int32_t _Scientific_exponent = _Ryu_exponent + static_cast<int32_t>(__olength) - 1;
+
+  if (_Fmt == chars_format{}) {
+    int32_t _Lower;
+    int32_t _Upper;
+
+    if (__olength == 1) {
+      // Value | Fixed   | Scientific
+      // 1e-3  | "0.001" | "1e-03"
+      // 1e4   | "10000" | "1e+04"
+      _Lower = -3;
+      _Upper = 4;
+    } else {
+      // Value   | Fixed       | Scientific
+      // 1234e-7 | "0.0001234" | "1.234e-04"
+      // 1234e5  | "123400000" | "1.234e+08"
+      _Lower = -static_cast<int32_t>(__olength + 3);
+      _Upper = 5;
+    }
+
+    if (_Lower <= _Ryu_exponent && _Ryu_exponent <= _Upper) {
+      _Fmt = chars_format::fixed;
+    } else {
+      _Fmt = chars_format::scientific;
+    }
+  } else if (_Fmt == chars_format::general) {
+    // C11 7.21.6.1 "The fprintf function"/8:
+    // "Let P equal [...] 6 if the precision is omitted [...].
+    // Then, if a conversion with style E would have an exponent of X:
+    // - if P > X >= -4, the conversion is with style f [...].
+    // - otherwise, the conversion is with style e [...]."
+    if (-4 <= _Scientific_exponent && _Scientific_exponent < 6) {
+      _Fmt = chars_format::fixed;
+    } else {
+      _Fmt = chars_format::scientific;
+    }
+  }
+
+  if (_Fmt == chars_format::fixed) {
+    // Example: _Output == 1729, __olength == 4
+
+    // _Ryu_exponent | Printed  | _Whole_digits | _Total_fixed_length  | Notes
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //             2 | 172900   |  6            | _Whole_digits        | Ryu can't be used for printing
+    //             1 | 17290    |  5            | (sometimes adjusted) | when the trimmed digits are nonzero.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //             0 | 1729     |  4            | _Whole_digits        | Unified length cases.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //            -1 | 172.9    |  3            | __olength + 1        | This case can't happen for
+    //            -2 | 17.29    |  2            |                      | __olength == 1, but no additional
+    //            -3 | 1.729    |  1            |                      | code is needed to avoid it.
+    // --------------|----------|---------------|----------------------|---------------------------------------
+    //            -4 | 0.1729   |  0            | 2 - _Ryu_exponent    | C11 7.21.6.1 "The fprintf function"/8:
+    //            -5 | 0.01729  | -1            |                      | "If a decimal-point character appears,
+    //            -6 | 0.001729 | -2            |                      | at least one digit appears before it."
+
+    const int32_t _Whole_digits = static_cast<int32_t>(__olength) + _Ryu_exponent;
+
+    uint32_t _Total_fixed_length;
+    if (_Ryu_exponent >= 0) { // cases "172900" and "1729"
+      _Total_fixed_length = static_cast<uint32_t>(_Whole_digits);
+      if (_Output == 1) {
+        // Rounding can affect the number of digits.
+        // For example, 1e23 is exactly "99999999999999991611392" which is 23 digits instead of 24.
+        // We can use a lookup table to detect this and adjust the total length.
+        static constexpr uint8_t _Adjustment[309] = {
+          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,
+          1,1,0,0,1,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,1,0,1,0,1,1,0,0,0,0,1,1,1,
+          1,0,0,0,0,0,0,0,1,1,0,1,1,0,0,1,0,1,0,1,0,1,1,0,0,0,0,0,1,1,1,0,0,1,1,1,1,1,0,1,0,1,1,0,1,
+          1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,1,0,0,1,1,1,1,0,0,1,1,0,1,1,0,1,1,0,1,0,0,0,1,0,0,0,1,
+          0,1,0,1,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,0,1,1,1,0,0,0,1,0,1,1,1,1,1,1,0,1,0,1,1,0,0,0,1,
+          1,1,0,1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,1,0,0,1,1,1,0,0,0,1,0,1,0,0,0,0,0,1,1,0,
+          0,1,0,1,1,1,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,1,0,1,0,0,0,0,0,1,1,0,1,0 };
+        _Total_fixed_length -= _Adjustment[_Ryu_exponent];
+        // _Whole_digits doesn't need to be adjusted because these cases won't refer to it later.
+      }
+    } else if (_Whole_digits > 0) { // case "17.29"
+      _Total_fixed_length = __olength + 1;
+    } else { // case "0.001729"
+      _Total_fixed_length = static_cast<uint32_t>(2 - _Ryu_exponent);
+    }
+
+    if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
+      return { _Last, errc::value_too_large };
+    }
+
+    _CharT* _Mid;
+    if (_Ryu_exponent > 0) { // case "172900"
+      bool _Can_use_ryu;
+
+      if (_Ryu_exponent > 22) { // 10^22 is the largest power of 10 that's exactly representable as a double.
+        _Can_use_ryu = false;
+      } else {
+        // Ryu generated X: __v.__mantissa * 10^_Ryu_exponent
+        // __v.__mantissa == 2^_Trailing_zero_bits * (__v.__mantissa >> _Trailing_zero_bits)
+        // 10^_Ryu_exponent == 2^_Ryu_exponent * 5^_Ryu_exponent
+
+        // _Trailing_zero_bits is [0, 56] (aside: because 2^56 is the largest power of 2
+        // with 17 decimal digits, which is double's round-trip limit.)
+        // _Ryu_exponent is [1, 22].
+        // Normalization adds [2, 52] (aside: at least 2 because the pre-normalized mantissa is at least 5).
+        // This adds up to [3, 130], which is well below double's maximum binary exponent 1023.
+
+        // Therefore, we just need to consider (__v.__mantissa >> _Trailing_zero_bits) * 5^_Ryu_exponent.
+
+        // If that product would exceed 53 bits, then X can't be exactly represented as a double.
+        // (That's not a problem for round-tripping, because X is close enough to the original double,
+        // but X isn't mathematically equal to the original double.) This requires a high-precision fallback.
+
+        // If the product is 53 bits or smaller, then X can be exactly represented as a double (and we don't
+        // need to re-synthesize it; the original double must have been X, because Ryu wouldn't produce the
+        // same output for two different doubles X and Y). This allows Ryu's output to be used (zero-filled).
+
+        // (2^53 - 1) / 5^0 (for indexing), (2^53 - 1) / 5^1, ..., (2^53 - 1) / 5^22
+        static constexpr uint64_t _Max_shifted_mantissa[23] = {
+          9007199254740991u, 1801439850948198u, 360287970189639u, 72057594037927u, 14411518807585u,
+          2882303761517u, 576460752303u, 115292150460u, 23058430092u, 4611686018u, 922337203u, 184467440u,
+          36893488u, 7378697u, 1475739u, 295147u, 59029u, 11805u, 2361u, 472u, 94u, 18u, 3u };
+
+        unsigned long _Trailing_zero_bits;
+#ifdef _WIN64
+        (void) _BitScanForward64(&_Trailing_zero_bits, __v.__mantissa); // __v.__mantissa is guaranteed nonzero
+#else // ^^^ 64-bit / 32-bit vvv
+        const uint32_t _Low_mantissa = static_cast<uint32_t>(__v.__mantissa);
+        if (_Low_mantissa != 0) {
+          (void) _BitScanForward(&_Trailing_zero_bits, _Low_mantissa);
+        } else {
+          const uint32_t _High_mantissa = static_cast<uint32_t>(__v.__mantissa >> 32); // nonzero here
+          (void) _BitScanForward(&_Trailing_zero_bits, _High_mantissa);
+          _Trailing_zero_bits += 32;
+        }
+#endif // ^^^ 32-bit ^^^
+        const uint64_t _Shifted_mantissa = __v.__mantissa >> _Trailing_zero_bits;
+        _Can_use_ryu = _Shifted_mantissa <= _Max_shifted_mantissa[_Ryu_exponent];
+      }
+
+      if (!_Can_use_ryu) {
+        // Print the integer exactly.
+        // Performance note: This will redundantly perform bounds checking.
+        // Performance note: This will redundantly decompose the IEEE representation.
+        return __d2fixed_buffered_n(_First, _Last, __f, 0);
+      }
+
+      // _Can_use_ryu
+      // Print the decimal digits, left-aligned within [_First, _First + _Total_fixed_length).
+      _Mid = _First + __olength;
+    } else { // cases "1729", "17.29", and "0.001729"
+      // Print the decimal digits, right-aligned within [_First, _First + _Total_fixed_length).
+      _Mid = _First + _Total_fixed_length;
+    }
+
+    // We prefer 32-bit operations, even on 64-bit platforms.
+    // We have at most 17 digits, and uint32_t can store 9 digits.
+    // If _Output doesn't fit into uint32_t, we cut off 8 digits,
+    // so the rest will fit into uint32_t.
+    if ((_Output >> 32) != 0) {
+      // Expensive 64-bit division.
+      const uint64_t __q = __div1e8(_Output);
+      uint32_t __output2 = static_cast<uint32_t>(_Output - 100000000 * __q);
+      _Output = __q;
+
+      const uint32_t __c = __output2 % 10000;
+      __output2 /= 10000;
+      const uint32_t __d = __output2 % 10000;
+      const uint32_t __c0 = (__c % 100) << 1;
+      const uint32_t __c1 = (__c / 100) << 1;
+      const uint32_t __d0 = (__d % 100) << 1;
+      const uint32_t __d1 = (__d / 100) << 1;
+
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __d0, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __d1, 2 * sizeof(_CharT));
+    }
+    uint32_t __output2 = static_cast<uint32_t>(_Output);
+    while (__output2 >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+      const uint32_t __c = __output2 - 10000 * (__output2 / 10000);
+#else
+      const uint32_t __c = __output2 % 10000;
+#endif
+      __output2 /= 10000;
+      const uint32_t __c0 = (__c % 100) << 1;
+      const uint32_t __c1 = (__c / 100) << 1;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    }
+    if (__output2 >= 100) {
+      const uint32_t __c = (__output2 % 100) << 1;
+      __output2 /= 100;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    }
+    if (__output2 >= 10) {
+      const uint32_t __c = __output2 << 1;
+      _CSTD memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    } else {
+      *--_Mid = static_cast<_CharT>(_WIDEN(_CharT, '0') + __output2);
+    }
+
+    if (_Ryu_exponent > 0) { // case "172900" with _Can_use_ryu
+      // Performance note: it might be more efficient to do this immediately after setting _Mid.
+      _STD fill_n(_First + __olength, _Ryu_exponent, _WIDEN(_CharT, '0'));
+    } else if (_Ryu_exponent == 0) { // case "1729"
+      // Done!
+    } else if (_Whole_digits > 0) { // case "17.29"
+      // Performance note: moving digits might not be optimal.
+      _CSTD memmove(_First, _First + 1, static_cast<size_t>(_Whole_digits) * sizeof(_CharT));
+      _First[_Whole_digits] = _WIDEN(_CharT, '.');
+    } else { // case "0.001729"
+      // Performance note: a larger memset() followed by overwriting '.' might be more efficient.
+      _First[0] = _WIDEN(_CharT, '0');
+      _First[1] = _WIDEN(_CharT, '.');
+      _STD fill_n(_First + 2, -_Whole_digits, _WIDEN(_CharT, '0'));
+    }
+
+    return { _First + _Total_fixed_length, errc{} };
+  }
+
+  const uint32_t _Total_scientific_length = __olength + (__olength > 1) // digits + possible decimal point
+    + (-100 < _Scientific_exponent && _Scientific_exponent < 100 ? 4 : 5); // + scientific exponent
+  if (_Last - _First < static_cast<ptrdiff_t>(_Total_scientific_length)) {
+    return { _Last, errc::value_too_large };
+  }
+  _CharT* const __result = _First;
+
+  // Print the decimal digits.
+  uint32_t __i = 0;
+  // We prefer 32-bit operations, even on 64-bit platforms.
+  // We have at most 17 digits, and uint32_t can store 9 digits.
+  // If _Output doesn't fit into uint32_t, we cut off 8 digits,
+  // so the rest will fit into uint32_t.
+  if ((_Output >> 32) != 0) {
+    // Expensive 64-bit division.
+    const uint64_t __q = __div1e8(_Output);
+    uint32_t __output2 = static_cast<uint32_t>(_Output) - 100000000 * static_cast<uint32_t>(__q);
+    _Output = __q;
+
+    const uint32_t __c = __output2 % 10000;
+    __output2 /= 10000;
+    const uint32_t __d = __output2 % 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    const uint32_t __d0 = (__d % 100) << 1;
+    const uint32_t __d1 = (__d / 100) << 1;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 5, __DIGIT_TABLE<_CharT> + __d0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 7, __DIGIT_TABLE<_CharT> + __d1, 2 * sizeof(_CharT));
+    __i += 8;
+  }
+  uint32_t __output2 = static_cast<uint32_t>(_Output);
+  while (__output2 >= 10000) {
+#ifdef __clang__ // TRANSITION, LLVM-38217
+    const uint32_t __c = __output2 - 10000 * (__output2 / 10000);
+#else
+    const uint32_t __c = __output2 % 10000;
+#endif
+    __output2 /= 10000;
+    const uint32_t __c0 = (__c % 100) << 1;
+    const uint32_t __c1 = (__c / 100) << 1;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
+    _CSTD memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
+    __i += 4;
+  }
+  if (__output2 >= 100) {
+    const uint32_t __c = (__output2 % 100) << 1;
+    __output2 /= 100;
+    _CSTD memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
+    __i += 2;
+  }
+  if (__output2 >= 10) {
+    const uint32_t __c = __output2 << 1;
+    // We can't use memcpy here: the decimal dot goes between these two digits.
+    __result[2] = __DIGIT_TABLE<_CharT>[__c + 1];
+    __result[0] = __DIGIT_TABLE<_CharT>[__c];
+  } else {
+    __result[0] = static_cast<_CharT>(_WIDEN(_CharT, '0') + __output2);
+  }
+
+  // Print decimal point if needed.
+  uint32_t __index;
+  if (__olength > 1) {
+    __result[1] = _WIDEN(_CharT, '.');
+    __index = __olength + 1;
+  } else {
+    __index = 1;
+  }
+
+  // Print the exponent.
+  __result[__index++] = _WIDEN(_CharT, 'e');
+  if (_Scientific_exponent < 0) {
+    __result[__index++] = _WIDEN(_CharT, '-');
+    _Scientific_exponent = -_Scientific_exponent;
+  } else {
+    __result[__index++] = _WIDEN(_CharT, '+');
+  }
+
+  if (_Scientific_exponent >= 100) {
+    const int32_t __c = _Scientific_exponent % 10;
+    _CSTD memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * (_Scientific_exponent / 10), 2 * sizeof(_CharT));
+    __result[__index + 2] = static_cast<_CharT>(_WIDEN(_CharT, '0') + __c);
+    __index += 3;
+  } else {
+    _CSTD memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * _Scientific_exponent, 2 * sizeof(_CharT));
+    __index += 2;
+  }
+
+  return { _First + _Total_scientific_length, errc{} };
+}
+
+_NODISCARD inline bool __d2d_small_int(const uint64_t __ieeeMantissa, const uint32_t __ieeeExponent,
+  __floating_decimal_64* const __v) {
+  const uint64_t __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
+  const int32_t __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
+
+  if (__e2 > 0) {
+    // f = __m2 * 2^__e2 >= 2^53 is an integer.
+    // Ignore this case for now.
+    return false;
+  }
+
+  if (__e2 < -52) {
+    // f < 1.
+    return false;
+  }
+
+  // Since 2^52 <= __m2 < 2^53 and 0 <= -__e2 <= 52: 1 <= f = __m2 / 2^-__e2 < 2^53.
+  // Test if the lower -__e2 bits of the significand are 0, i.e. whether the fraction is 0.
+  const uint64_t __mask = (1ull << -__e2) - 1;
+  const uint64_t __fraction = __m2 & __mask;
+  if (__fraction != 0) {
+    return false;
+  }
+
+  // f is an integer in the range [1, 2^53).
+  // Note: __mantissa might contain trailing (decimal) 0's.
+  // Note: since 2^53 < 10^16, there is no need to adjust __decimalLength17().
+  __v->__mantissa = __m2 >> -__e2;
+  __v->__exponent = 0;
+  return true;
+}
+
+template <class _CharT>
+_NODISCARD pair<_CharT*, errc> __d2s_buffered_n(_CharT* const _First, _CharT* const _Last, const double __f,
+  const chars_format _Fmt) {
+
+  // Step 1: Decode the floating-point number, and unify normalized and subnormal cases.
+  const uint64_t __bits = __double_to_bits(__f);
+
+  // Case distinction; exit early for the easy cases.
+  if (__bits == 0) {
+    if (_Fmt == chars_format::scientific) {
+      if (_Last - _First < 5) {
+        return { _Last, errc::value_too_large };
+      }
+
+      if constexpr (is_same_v<_CharT, char>) {
+        _CSTD memcpy(_First, "0e+00", 5);
+      } else {
+        _CSTD memcpy(_First, L"0e+00", 5 * sizeof(wchar_t));
+      }
+
+      return { _First + 5, errc{} };
+    }
+
+    // Print "0" for chars_format::fixed, chars_format::general, and chars_format{}.
+    if (_First == _Last) {
+      return { _Last, errc::value_too_large };
+    }
+
+    *_First = _WIDEN(_CharT, '0');
+
+    return { _First + 1, errc{} };
+  }
+
+  // Decode __bits into mantissa and exponent.
+  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
+  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);
+
+  if (_Fmt == chars_format::fixed) {
+    // const uint64_t _Mantissa2 = __ieeeMantissa | (1ull << __DOUBLE_MANTISSA_BITS); // restore implicit bit
+    const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
+      - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS; // bias and normalization
+
+    // Normal values are equal to _Mantissa2 * 2^_Exponent2.
+    // (Subnormals are different, but they'll be rejected by the _Exponent2 test here, so they can be ignored.)
+
+    // For nonzero integers, _Exponent2 >= -52. (The minimum value occurs when _Mantissa2 * 2^_Exponent2 is 1.
+    // In that case, _Mantissa2 is the implicit 1 bit followed by 52 zeros, so _Exponent2 is -52 to shift away
+    // the zeros.) The dense range of exactly representable integers has negative or zero exponents
+    // (as positive exponents make the range non-dense). For that dense range, Ryu will always be used:
+    // every digit is necessary to uniquely identify the value, so Ryu must print them all.
+
+    // Positive exponents are the non-dense range of exactly representable integers. This contains all of the values
+    // for which Ryu can't be used (and a few Ryu-friendly values). We can save time by detecting positive
+    // exponents here and skipping Ryu. Calling __d2fixed_buffered_n() with precision 0 is valid for all integers
+    // (so it's okay if we call it with a Ryu-friendly value).
+    if (_Exponent2 > 0) {
+      return __d2fixed_buffered_n(_First, _Last, __f, 0);
+    }
+  }
+
+  __floating_decimal_64 __v;
+  const bool __isSmallInt = __d2d_small_int(__ieeeMantissa, __ieeeExponent, &__v);
+  if (__isSmallInt) {
+    // For small integers in the range [1, 2^53), __v.__mantissa might contain trailing (decimal) zeros.
+    // For scientific notation we need to move these zeros into the exponent.
+    // (This is not needed for fixed-point notation, so it might be beneficial to trim
+    // trailing zeros in __to_chars only if needed - once fixed-point notation output is implemented.)
+    for (;;) {
+      const uint64_t __q = __div10(__v.__mantissa);
+      const uint32_t __r = static_cast<uint32_t>(__v.__mantissa) - 10 * static_cast<uint32_t>(__q);
+      if (__r != 0) {
+        break;
+      }
+      __v.__mantissa = __q;
+      ++__v.__exponent;
+    }
+  } else {
+    __v = __d2d(__ieeeMantissa, __ieeeExponent);
+  }
+
+  return __to_chars(_First, _Last, __v, _Fmt, __f);
+}
+
+// ^^^^^^^^^^ DERIVED FROM d2s.c ^^^^^^^^^^
+
+// clang-format on
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_ryu(
+    char* const _First, char* const _Last, const _Floating _Value, const chars_format _Fmt) noexcept {
+    if constexpr (is_same_v<_Floating, float>) {
+        return _Convert_to_chars_result(__f2s_buffered_n(_First, _Last, _Value, _Fmt));
+    } else {
+        return _Convert_to_chars_result(__d2s_buffered_n(_First, _Last, _Value, _Fmt));
+    }
+}
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_scientific_precision(
+    char* const _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
+
+    // C11 7.21.6.1 "The fprintf function"/5:
+    // "A negative precision argument is taken as if the precision were omitted."
+    // /8: "e,E [...] if the precision is missing, it is taken as 6"
+
+    if (_Precision < 0) {
+        _Precision = 6;
+    } else if (_Precision < 1'000'000'000) {
+        // _Precision is ok.
+    } else {
+        // Avoid integer overflow.
+        // (This defensive check is slightly nonconformant; it can be carefully improved in the future.)
+        return {_Last, errc::value_too_large};
+    }
+
+    return __d2exp_buffered_n(_First, _Last, _Value, static_cast<uint32_t>(_Precision));
+}
+
+template <class _Floating>
+_NODISCARD to_chars_result _Floating_to_chars_fixed_precision(
+    char* const _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
+
+    // C11 7.21.6.1 "The fprintf function"/5:
+    // "A negative precision argument is taken as if the precision were omitted."
+    // /8: "f,F [...] If the precision is missing, it is taken as 6"
+
+    if (_Precision < 0) {
+        _Precision = 6;
+    } else if (_Precision < 1'000'000'000) {
+        // _Precision is ok.
+    } else {
+        // Avoid integer overflow.
+        // (This defensive check is slightly nonconformant; it can be carefully improved in the future.)
+        return {_Last, errc::value_too_large};
+    }
+
+    return _Convert_to_chars_result(__d2fixed_buffered_n(_First, _Last, _Value, static_cast<uint32_t>(_Precision)));
+}
+
+_STD_END
+
+#undef _HAS_CHARCONV_INTRINSICS
+#undef _WIDEN
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCHARCONV_RYU_H
diff --git a/msvc-stl/stl/inc/xcharconv_ryu_tables.h b/msvc-stl/stl/inc/xcharconv_ryu_tables.h
new file mode 100644
index 0000000..ad312ce
--- /dev/null
+++ b/msvc-stl/stl/inc/xcharconv_ryu_tables.h
@@ -0,0 +1,157 @@
+// xcharconv_ryu_tables.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception AND BSL-1.0
+
+
+// Copyright 2018 Ulf Adams
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// 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.
+
+
+#ifndef _XCHARCONV_RYU_TABLES_H
+#define _XCHARCONV_RYU_TABLES_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error The contents of <charconv> are only available with C++17. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX17
+
+#include <cstdint>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+// https://github.com/ulfjack/ryu
+// See xcharconv_ryu.h for the exact commit.
+// (Keep the cgmanifest.json commitHash in sync.)
+
+// clang-format off: avoid diverging from external code
+
+// vvvvvvvvvv DERIVED FROM digit_table.h vvvvvvvvvv
+
+// A table of all two-digit numbers. This is used to speed up decimal digit
+// generation by copying pairs of digits into the final output.
+template <class _CharT> constexpr _CharT __DIGIT_TABLE[] = {_CharT{}};
+
+template <> inline constexpr char __DIGIT_TABLE<char>[200] = {
+  '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
+  '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
+  '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
+  '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
+  '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
+  '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
+  '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
+  '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
+  '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
+  '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
+};
+
+template <> inline constexpr wchar_t __DIGIT_TABLE<wchar_t>[200] = {
+  L'0',L'0',L'0',L'1',L'0',L'2',L'0',L'3',L'0',L'4',L'0',L'5',L'0',L'6',L'0',L'7',L'0',L'8',L'0',L'9',
+  L'1',L'0',L'1',L'1',L'1',L'2',L'1',L'3',L'1',L'4',L'1',L'5',L'1',L'6',L'1',L'7',L'1',L'8',L'1',L'9',
+  L'2',L'0',L'2',L'1',L'2',L'2',L'2',L'3',L'2',L'4',L'2',L'5',L'2',L'6',L'2',L'7',L'2',L'8',L'2',L'9',
+  L'3',L'0',L'3',L'1',L'3',L'2',L'3',L'3',L'3',L'4',L'3',L'5',L'3',L'6',L'3',L'7',L'3',L'8',L'3',L'9',
+  L'4',L'0',L'4',L'1',L'4',L'2',L'4',L'3',L'4',L'4',L'4',L'5',L'4',L'6',L'4',L'7',L'4',L'8',L'4',L'9',
+  L'5',L'0',L'5',L'1',L'5',L'2',L'5',L'3',L'5',L'4',L'5',L'5',L'5',L'6',L'5',L'7',L'5',L'8',L'5',L'9',
+  L'6',L'0',L'6',L'1',L'6',L'2',L'6',L'3',L'6',L'4',L'6',L'5',L'6',L'6',L'6',L'7',L'6',L'8',L'6',L'9',
+  L'7',L'0',L'7',L'1',L'7',L'2',L'7',L'3',L'7',L'4',L'7',L'5',L'7',L'6',L'7',L'7',L'7',L'8',L'7',L'9',
+  L'8',L'0',L'8',L'1',L'8',L'2',L'8',L'3',L'8',L'4',L'8',L'5',L'8',L'6',L'8',L'7',L'8',L'8',L'8',L'9',
+  L'9',L'0',L'9',L'1',L'9',L'2',L'9',L'3',L'9',L'4',L'9',L'5',L'9',L'6',L'9',L'7',L'9',L'8',L'9',L'9'
+};
+
+// ^^^^^^^^^^ DERIVED FROM digit_table.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2s_full_table.h vvvvvvvvvv
+
+// These tables are generated by PrintDoubleLookupTable.
+extern const uint64_t __DOUBLE_POW5_INV_SPLIT[292][2];
+
+extern const uint64_t __DOUBLE_POW5_SPLIT[326][2];
+
+// ^^^^^^^^^^ DERIVED FROM d2s_full_table.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2fixed_full_table.h vvvvvvvvvv
+
+inline constexpr int __TABLE_SIZE = 64;
+
+inline constexpr uint16_t __POW10_OFFSET[__TABLE_SIZE] = {
+  0, 2, 5, 8, 12, 16, 21, 26, 32, 39,
+  46, 54, 62, 71, 80, 90, 100, 111, 122, 134,
+  146, 159, 173, 187, 202, 217, 233, 249, 266, 283,
+  301, 319, 338, 357, 377, 397, 418, 440, 462, 485,
+  508, 532, 556, 581, 606, 632, 658, 685, 712, 740,
+  769, 798, 828, 858, 889, 920, 952, 984, 1017, 1050,
+  1084, 1118, 1153, 1188
+};
+
+extern const uint64_t __POW10_SPLIT[1224][3];
+
+inline constexpr int __TABLE_SIZE_2 = 69;
+inline constexpr int __ADDITIONAL_BITS_2 = 120;
+
+inline constexpr uint16_t __POW10_OFFSET_2[__TABLE_SIZE_2] = {
+     0,    2,    6,   12,   20,   29,   40,   52,   66,   80,
+    95,  112,  130,  150,  170,  192,  215,  240,  265,  292,
+   320,  350,  381,  413,  446,  480,  516,  552,  590,  629,
+   670,  712,  755,  799,  845,  892,  940,  989, 1040, 1092,
+  1145, 1199, 1254, 1311, 1369, 1428, 1488, 1550, 1613, 1678,
+  1743, 1810, 1878, 1947, 2017, 2088, 2161, 2235, 2311, 2387,
+  2465, 2544, 2625, 2706, 2789, 2873, 2959, 3046, 3133
+};
+
+inline constexpr uint8_t __MIN_BLOCK_2[__TABLE_SIZE_2] = {
+     0,    0,    0,    0,    0,    0,    1,    1,    2,    3,
+     3,    4,    4,    5,    5,    6,    6,    7,    7,    8,
+     8,    9,    9,   10,   11,   11,   12,   12,   13,   13,
+    14,   14,   15,   15,   16,   16,   17,   17,   18,   19,
+    19,   20,   20,   21,   21,   22,   22,   23,   23,   24,
+    24,   25,   26,   26,   27,   27,   28,   28,   29,   29,
+    30,   30,   31,   31,   32,   32,   33,   34,    0
+};
+
+extern const uint64_t __POW10_SPLIT_2[3133][3];
+
+// ^^^^^^^^^^ DERIVED FROM d2fixed_full_table.h ^^^^^^^^^^
+
+// clang-format on
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCHARCONV_RYU_TABLES_H
diff --git a/msvc-stl/stl/inc/xcharconv_tables.h b/msvc-stl/stl/inc/xcharconv_tables.h
new file mode 100644
index 0000000..0ce4f3d
--- /dev/null
+++ b/msvc-stl/stl/inc/xcharconv_tables.h
@@ -0,0 +1,113 @@
+// xcharconv_tables.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XCHARCONV_TABLES_H
+#define _XCHARCONV_TABLES_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error The contents of <charconv> are only available with C++17. (Also, you should not include this internal header.)
+#endif // !_HAS_CXX17
+
+#include <cstdint>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// For general precision, we can use lookup tables to avoid performing trial formatting.
+
+// For a simple example, imagine counting the number of digits D in an integer, and needing to know
+// whether D is less than 3, equal to 3/4/5/6, or greater than 6. We could use a lookup table:
+// D | Largest integer with D digits
+// 2 |      99
+// 3 |     999
+// 4 |   9'999
+// 5 |  99'999
+// 6 | 999'999
+// 7 | table end
+// Looking up an integer in this table with lower_bound() will work:
+// * Too-small integers, like 7, 70, and 99, will cause lower_bound() to return the D == 2 row. (If all we care
+//   about is whether D is less than 3, then it's okay to smash the D == 1 and D == 2 cases together.)
+// * Integers in [100, 999] will cause lower_bound() to return the D == 3 row, and so forth.
+// * Too-large integers, like 1'000'000 and above, will cause lower_bound() to return the end of the table. If we
+//   compute D from that index, this will be considered D == 7, which will activate any "greater than 6" logic.
+
+// Floating-point is slightly more complicated.
+
+// The ordinary lookup tables are for X within [-5, 38] for float, and [-5, 308] for double.
+// (-5 absorbs too-negative exponents, outside the P > X >= -4 criterion. 38 and 308 are the maximum exponents.)
+// Due to the P > X condition, we can use a subset of the table for X within [-5, P - 1], suitably clamped.
+
+// When P is small, rounding can affect X. For example:
+// For P == 1, the largest double with X == 0 is: 9.4999999999999982236431605997495353221893310546875
+// For P == 2, the largest double with X == 0 is: 9.949999999999999289457264239899814128875732421875
+// For P == 3, the largest double with X == 0 is: 9.9949999999999992184029906638897955417633056640625
+
+// Exponent adjustment is a concern for P within [1, 7] for float, and [1, 15] for double (determined via
+// brute force). While larger values of P still perform rounding, they can't trigger exponent adjustment.
+// This is because only values with repeated '9' digits can undergo exponent adjustment during rounding,
+// and floating-point granularity limits the number of consecutive '9' digits that can appear.
+
+// So, we need special lookup tables for small values of P.
+// These tables have varying lengths due to the P > X >= -4 criterion. For example:
+// For P == 1, need table entries for X: -5, -4, -3, -2, -1, 0
+// For P == 2, need table entries for X: -5, -4, -3, -2, -1, 0, 1
+// For P == 3, need table entries for X: -5, -4, -3, -2, -1, 0, 1, 2
+// For P == 4, need table entries for X: -5, -4, -3, -2, -1, 0, 1, 2, 3
+
+// We can concatenate these tables for compact storage, using triangular numbers to access them.
+// The table for P begins at index (P - 1) * (P + 10) / 2 with length P + 5.
+
+// For both the ordinary and special lookup tables, after an index I is returned by lower_bound(), X is I - 5.
+
+// We need to special-case the floating-point value 0.0, which is considered to have X == 0.
+// Otherwise, the lookup tables would consider it to have a highly negative X.
+
+// Finally, because we're working with positive floating-point values,
+// representation comparisons behave identically to floating-point comparisons.
+
+// The generator is in /tools/scripts/charconv_tables_generate.cpp
+
+_STD_BEGIN
+
+template <class _Floating>
+struct _General_precision_tables_2;
+
+template <>
+struct _General_precision_tables_2<float> {
+    static constexpr int _Max_special_P = 7;
+
+    static const uint32_t _Special_X_table[63];
+
+    static constexpr int _Max_P = 39;
+
+    static const uint32_t _Ordinary_X_table[44];
+};
+
+template <>
+struct _General_precision_tables_2<double> {
+    static constexpr int _Max_special_P = 15;
+
+    static const uint64_t _Special_X_table[195];
+
+    static constexpr int _Max_P = 309;
+
+    static const uint64_t _Ordinary_X_table[314];
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XCHARCONV_TABLES_H
diff --git a/msvc-stl/stl/inc/xerrc.h b/msvc-stl/stl/inc/xerrc.h
new file mode 100644
index 0000000..7bd9001
--- /dev/null
+++ b/msvc-stl/stl/inc/xerrc.h
@@ -0,0 +1,108 @@
+// xerrc.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XERRC_H
+#define _XERRC_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD enum class errc { // names for generic error codes
+    address_family_not_supported                       = 102, // EAFNOSUPPORT
+    address_in_use                                     = 100, // EADDRINUSE
+    address_not_available                              = 101, // EADDRNOTAVAIL
+    already_connected                                  = 113, // EISCONN
+    argument_list_too_long                             = 7, // E2BIG
+    argument_out_of_domain                             = 33, // EDOM
+    bad_address                                        = 14, // EFAULT
+    bad_file_descriptor                                = 9, // EBADF
+    bad_message                                        = 104, // EBADMSG
+    broken_pipe                                        = 32, // EPIPE
+    connection_aborted                                 = 106, // ECONNABORTED
+    connection_already_in_progress                     = 103, // EALREADY
+    connection_refused                                 = 107, // ECONNREFUSED
+    connection_reset                                   = 108, // ECONNRESET
+    cross_device_link                                  = 18, // EXDEV
+    destination_address_required                       = 109, // EDESTADDRREQ
+    device_or_resource_busy                            = 16, // EBUSY
+    directory_not_empty                                = 41, // ENOTEMPTY
+    executable_format_error                            = 8, // ENOEXEC
+    file_exists                                        = 17, // EEXIST
+    file_too_large                                     = 27, // EFBIG
+    filename_too_long                                  = 38, // ENAMETOOLONG
+    function_not_supported                             = 40, // ENOSYS
+    host_unreachable                                   = 110, // EHOSTUNREACH
+    identifier_removed                                 = 111, // EIDRM
+    illegal_byte_sequence                              = 42, // EILSEQ
+    inappropriate_io_control_operation                 = 25, // ENOTTY
+    interrupted                                        = 4, // EINTR
+    invalid_argument                                   = 22, // EINVAL
+    invalid_seek                                       = 29, // ESPIPE
+    io_error                                           = 5, // EIO
+    is_a_directory                                     = 21, // EISDIR
+    message_size                                       = 115, // EMSGSIZE
+    network_down                                       = 116, // ENETDOWN
+    network_reset                                      = 117, // ENETRESET
+    network_unreachable                                = 118, // ENETUNREACH
+    no_buffer_space                                    = 119, // ENOBUFS
+    no_child_process                                   = 10, // ECHILD
+    no_link                                            = 121, // ENOLINK
+    no_lock_available                                  = 39, // ENOLCK
+    no_message_available _CXX23_DEPRECATE_UNIX_STREAMS = 120, // ENODATA
+    no_message                                         = 122, // ENOMSG
+    no_protocol_option                                 = 123, // ENOPROTOOPT
+    no_space_on_device                                 = 28, // ENOSPC
+    no_stream_resources _CXX23_DEPRECATE_UNIX_STREAMS  = 124, // ENOSR
+    no_such_device_or_address                          = 6, // ENXIO
+    no_such_device                                     = 19, // ENODEV
+    no_such_file_or_directory                          = 2, // ENOENT
+    no_such_process                                    = 3, // ESRCH
+    not_a_directory                                    = 20, // ENOTDIR
+    not_a_socket                                       = 128, // ENOTSOCK
+    not_a_stream _CXX23_DEPRECATE_UNIX_STREAMS         = 125, // ENOSTR
+    not_connected                                      = 126, // ENOTCONN
+    not_enough_memory                                  = 12, // ENOMEM
+    not_supported                                      = 129, // ENOTSUP
+    operation_canceled                                 = 105, // ECANCELED
+    operation_in_progress                              = 112, // EINPROGRESS
+    operation_not_permitted                            = 1, // EPERM
+    operation_not_supported                            = 130, // EOPNOTSUPP
+    operation_would_block                              = 140, // EWOULDBLOCK
+    owner_dead                                         = 133, // EOWNERDEAD
+    permission_denied                                  = 13, // EACCES
+    protocol_error                                     = 134, // EPROTO
+    protocol_not_supported                             = 135, // EPROTONOSUPPORT
+    read_only_file_system                              = 30, // EROFS
+    resource_deadlock_would_occur                      = 36, // EDEADLK
+    resource_unavailable_try_again                     = 11, // EAGAIN
+    result_out_of_range                                = 34, // ERANGE
+    state_not_recoverable                              = 127, // ENOTRECOVERABLE
+    stream_timeout _CXX23_DEPRECATE_UNIX_STREAMS       = 137, // ETIME
+    text_file_busy                                     = 139, // ETXTBSY
+    timed_out                                          = 138, // ETIMEDOUT
+    too_many_files_open_in_system                      = 23, // ENFILE
+    too_many_files_open                                = 24, // EMFILE
+    too_many_links                                     = 31, // EMLINK
+    too_many_symbolic_link_levels                      = 114, // ELOOP
+    value_too_large                                    = 132, // EOVERFLOW
+    wrong_protocol_type                                = 136 // EPROTOTYPE
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XERRC_H
diff --git a/msvc-stl/stl/inc/xfacet b/msvc-stl/stl/inc/xfacet
new file mode 100644
index 0000000..0e989a8
--- /dev/null
+++ b/msvc-stl/stl/inc/xfacet
@@ -0,0 +1,45 @@
+// xfacet internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This header is used to compile the import library (via locale0_implib.cpp => locale0.cpp => xfacet).
+// MAJOR LIMITATIONS apply to what can be included here!
+// Before editing this file, read: /docs/import_library.md
+
+#ifndef _XFACET_
+#define _XFACET_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+extern "C++" class _CRTIMP2_PURE_IMPORT _Facet_base { // code for reference counting a facet
+public:
+    virtual __CLR_OR_THIS_CALL ~_Facet_base() noexcept {} // ensure that derived classes can be destroyed properly
+
+    // increment use count
+    virtual void __CLR_OR_THIS_CALL _Incref() noexcept = 0;
+
+    // decrement use count
+    virtual _Facet_base* __CLR_OR_THIS_CALL _Decref() noexcept = 0;
+};
+
+#if defined(_M_CEE)
+void __CLRCALL_OR_CDECL _Facet_Register_m(_Facet_base*);
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+extern "C++" void __CLRCALL_OR_CDECL _Facet_Register(_Facet_base*);
+#endif // ^^^ !defined(_M_CEE) ^^^
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XFACET_
diff --git a/msvc-stl/stl/inc/xfilesystem_abi.h b/msvc-stl/stl/inc/xfilesystem_abi.h
new file mode 100644
index 0000000..7956cfe
--- /dev/null
+++ b/msvc-stl/stl/inc/xfilesystem_abi.h
@@ -0,0 +1,403 @@
+// xfilesystem_abi.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XFILESYSTEM_ABI_H
+#define _XFILESYSTEM_ABI_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <cstdint>
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+inline constexpr size_t __std_fs_max_path      = 260; // #define MAX_PATH          260
+inline constexpr size_t __std_fs_temp_path_max = __std_fs_max_path + 1;
+
+enum class __std_win_error : unsigned long {
+    _Success                   = 0, // #define ERROR_SUCCESS                    0L
+    _Invalid_function          = 1, // #define ERROR_INVALID_FUNCTION           1L
+    _File_not_found            = 2, // #define ERROR_FILE_NOT_FOUND             2L
+    _Path_not_found            = 3, // #define ERROR_PATH_NOT_FOUND             3L
+    _Access_denied             = 5, // #define ERROR_ACCESS_DENIED              5L
+    _Not_enough_memory         = 8, // #define ERROR_NOT_ENOUGH_MEMORY          8L
+    _No_more_files             = 18, // #define ERROR_NO_MORE_FILES              18L
+    _Sharing_violation         = 32, // #define ERROR_SHARING_VIOLATION          32L
+    _Not_supported             = 50, // #define ERROR_NOT_SUPPORTED              50L
+    _Error_bad_netpath         = 53, // #define ERROR_BAD_NETPATH                53L
+    _Error_netname_deleted     = 64, // #define ERROR_NETNAME_DELETED            64L
+    _File_exists               = 80, // #define ERROR_FILE_EXISTS                80L
+    _Invalid_parameter         = 87, // #define ERROR_INVALID_PARAMETER          87L
+    _Insufficient_buffer       = 122, // #define ERROR_INSUFFICIENT_BUFFER        122L
+    _Invalid_name              = 123, // #define ERROR_INVALID_NAME               123L
+    _Directory_not_empty       = 145, // #define ERROR_DIR_NOT_EMPTY              145L
+    _Bad_pathname              = 161, // #define ERROR_BAD_PATHNAME               161L
+    _Already_exists            = 183, // #define ERROR_ALREADY_EXISTS             183L
+    _Filename_exceeds_range    = 206, // #define ERROR_FILENAME_EXCED_RANGE       206L
+    _Directory_name_is_invalid = 267, // #define ERROR_DIRECTORY                  267L
+    _Reparse_tag_invalid       = 4393L, // #define ERROR_REPARSE_TAG_INVALID        4393L
+    _Max                       = ~0UL // sentinel not used by Win32
+};
+
+#pragma warning(push)
+#pragma warning(disable : 4061) // enumerator not explicitly handled by switch label
+_NODISCARD inline bool __std_is_file_not_found(const __std_win_error _Error) noexcept {
+    switch (_Error) {
+    case __std_win_error::_File_not_found:
+    case __std_win_error::_Path_not_found:
+    case __std_win_error::_Error_bad_netpath:
+    case __std_win_error::_Invalid_name:
+    case __std_win_error::_Bad_pathname:
+    case __std_win_error::_Directory_name_is_invalid: // Windows 11 24H2
+    case __std_win_error::_Error_netname_deleted: // Windows 11 24H2
+        return true;
+    default:
+        return false;
+    }
+}
+#pragma warning(pop)
+
+enum class __std_fs_dir_handle : intptr_t { _Invalid = -1 };
+
+enum class __std_fs_file_attr : unsigned long {
+    _Readonly      = 0x00000001, // #define FILE_ATTRIBUTE_READONLY             0x00000001
+    _Hidden        = 0x00000002, // #define FILE_ATTRIBUTE_HIDDEN               0x00000002
+    _System        = 0x00000004, // #define FILE_ATTRIBUTE_SYSTEM               0x00000004
+    _Directory     = 0x00000010, // #define FILE_ATTRIBUTE_DIRECTORY            0x00000010
+    _Archive       = 0x00000020, // #define FILE_ATTRIBUTE_ARCHIVE              0x00000020
+    _Device        = 0x00000040, // #define FILE_ATTRIBUTE_DEVICE               0x00000040
+    _Normal        = 0x00000080, // #define FILE_ATTRIBUTE_NORMAL               0x00000080
+    _Temporary     = 0x00000100, // #define FILE_ATTRIBUTE_TEMPORARY            0x00000100
+    _Sparse_file   = 0x00000200, // #define FILE_ATTRIBUTE_SPARSE_FILE          0x00000200
+    _Reparse_point = 0x00000400, // #define FILE_ATTRIBUTE_REPARSE_POINT        0x00000400
+
+    _Invalid = 0xFFFFFFFF, // #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_file_attr)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+enum class __std_fs_reparse_tag : unsigned long {
+    _None        = 0,
+    _Mount_point = (0xA0000003L), // #define IO_REPARSE_TAG_MOUNT_POINT              (0xA0000003L)
+    _Symlink     = (0xA000000CL), // #define IO_REPARSE_TAG_SYMLINK                  (0xA000000CL)
+};
+
+struct __std_fs_filetime { // typedef struct _FILETIME {
+    unsigned long _Low; //     DWORD dwLowDateTime;
+    unsigned long _High; //     DWORD dwHighDateTime;
+}; // } FILETIME, *PFILETIME, *LPFILETIME;
+
+struct __std_fs_find_data { // typedef struct _WIN32_FIND_DATAW {
+    __std_fs_file_attr _Attributes; //     DWORD dwFileAttributes;
+    __std_fs_filetime _Creation_time; //     FILETIME ftCreationTime;
+    __std_fs_filetime _Last_access_time; //     FILETIME ftLastAccessTime;
+    __std_fs_filetime _Last_write_time; //     FILETIME ftLastWriteTime;
+    unsigned long _File_size_high; //     DWORD nFileSizeHigh;
+    unsigned long _File_size_low; //     DWORD nFileSizeLow;
+
+    // According to https://learn.microsoft.com/windows/win32/api/minwinbase/ns-minwinbase-win32_find_dataw
+    // dwReserved0 specifies the reparse point tag if
+    // (dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
+
+    __std_fs_reparse_tag _Reparse_point_tag; //     DWORD dwReserved0;
+    unsigned long _Reserved1; //     DWORD dwReserved1;
+    wchar_t _File_name[__std_fs_max_path]; //     _Field_z_ WCHAR  cFileName[ MAX_PATH ];
+    wchar_t _Short_file_name[14]; //     _Field_z_ WCHAR  cAlternateFileName[ 14 ];
+}; // } WIN32_FIND_DATAW, ... ;
+
+enum class __std_fs_stats_flags : unsigned long {
+    _None = 0,
+
+    _Follow_symlinks = 0x01, // resolve symlink
+    _Attributes      = 0x02, // read/has attributes
+    _Reparse_tag     = 0x04, // read/has reparse_tag; may not be combined with _Follow_symlinks
+    _File_size       = 0x08, // read/has file size
+    _Link_count      = 0x10, // read/has link count
+    _Last_write_time = 0x20, // read/has last write time
+
+    _All_data = _Attributes | _Reparse_tag | _File_size | _Link_count | _Last_write_time
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_stats_flags)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+struct __std_fs_stats {
+    long long _Last_write_time;
+    unsigned long long _File_size;
+    __std_fs_file_attr _Attributes;
+    __std_fs_reparse_tag _Reparse_point_tag;
+    unsigned long _Link_count;
+    __std_fs_stats_flags _Available; // which fields are available
+
+    _NODISCARD __std_fs_file_attr _Symlink_hint_attributes() const noexcept {
+        if (_STD _Bitmask_includes_any(_Available, __std_fs_stats_flags::_Attributes)) {
+            return _Attributes;
+        }
+
+        return __std_fs_file_attr::_Invalid;
+    }
+};
+
+struct __std_fs_reparse_data_buffer { // typedef struct _REPARSE_DATA_BUFFER
+    unsigned long _Reparse_tag;
+    unsigned short _Reparse_data_length;
+    unsigned short _Reserved;
+    union {
+        struct {
+            unsigned short _Substitute_name_offset;
+            unsigned short _Substitute_name_length;
+            unsigned short _Print_name_offset;
+            unsigned short _Print_name_length;
+            unsigned long _Flags;
+            wchar_t _Path_buffer[1];
+        } _Symbolic_link_reparse_buffer;
+        struct {
+            unsigned short _Substitute_name_offset;
+            unsigned short _Substitute_name_length;
+            unsigned short _Print_name_offset;
+            unsigned short _Print_name_length;
+            wchar_t _Path_buffer[1];
+        } _Mount_point_reparse_buffer;
+        struct {
+            unsigned char _Data_buffer[1];
+        } _Generic_reparse_buffer;
+    };
+};
+
+struct __std_ulong_and_error {
+    unsigned long _Size;
+    __std_win_error _Error;
+};
+
+enum class __std_fs_volume_name_kind : unsigned long {
+    _Dos  = 0, // #define VOLUME_NAME_DOS  0x0
+    _Guid = 1, // #define VOLUME_NAME_GUID 0x1
+    _Nt   = 2, // #define VOLUME_NAME_NT   0x2
+    _None = 4 // #define VOLUME_NAME_NONE 0x4
+};
+
+enum class __std_access_rights : unsigned long {
+    _Delete                = 0x00010000, // #define DELETE                           (0x00010000L)
+    _File_read_attributes  = 0x0080, // #define FILE_READ_ATTRIBUTES      ( 0x0080 )
+    _File_write_attributes = 0x0100, // #define FILE_WRITE_ATTRIBUTES     ( 0x0100 )
+
+    // #define READ_CONTROL          (0x00020000L)
+    // #define STANDARD_RIGHTS_WRITE (READ_CONTROL)
+    // #define FILE_WRITE_DATA       (0x0002)
+    // #define FILE_WRITE_ATTRIBUTES (0x0100)
+    // #define FILE_WRITE_EA         (0x0010)
+    // #define FILE_APPEND_DATA      (0x0004)
+    // #define SYNCHRONIZE           (0x00100000L)
+    // #define FILE_GENERIC_WRITE    (STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES
+    //                                   | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE)
+    _File_generic_write = 0x00120116,
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_access_rights)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+enum class __std_fs_file_flags : unsigned long {
+    _None               = 0,
+    _Backup_semantics   = 0x02000000, // #define FILE_FLAG_BACKUP_SEMANTICS      0x02000000
+    _Open_reparse_point = 0x00200000, // #define FILE_FLAG_OPEN_REPARSE_POINT    0x00200000
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_file_flags)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+enum class __std_fs_file_handle : intptr_t { _Invalid = -1 };
+
+enum class __std_code_page : unsigned int { _Acp = 0, _Utf8 = 65001 };
+
+struct __std_fs_convert_result {
+    int _Len;
+    __std_win_error _Err;
+};
+
+enum class __std_fs_copy_options {
+    _None = 0x0,
+
+    _Existing_mask      = 0xF,
+    _Skip_existing      = 0x1,
+    _Overwrite_existing = 0x2,
+    _Update_existing    = 0x4,
+};
+} // extern "C"
+
+_EXTERN_CXX_WORKAROUND
+_BITMASK_OPS(_EMPTY_ARGUMENT, __std_fs_copy_options)
+_END_EXTERN_CXX_WORKAROUND
+
+extern "C" {
+_NODISCARD __std_ulong_and_error __stdcall __std_fs_get_full_path_name(_In_z_ const wchar_t* _Source,
+    _In_ unsigned long _Target_size, _Out_writes_z_(_Target_size) wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_open_handle(_Out_ __std_fs_file_handle* _Handle,
+    _In_z_ const wchar_t* _File_name, _In_ __std_access_rights _Desired_access,
+    _In_ __std_fs_file_flags _Flags) noexcept;
+
+void __stdcall __std_fs_close_handle(__std_fs_file_handle _Handle) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error __stdcall
+    __std_fs_get_file_attributes_by_handle(
+        _In_ __std_fs_file_handle _Handle, _Out_ unsigned long* _File_attributes) noexcept;
+
+_NODISCARD __std_ulong_and_error __stdcall __std_fs_get_final_path_name_by_handle(_In_ __std_fs_file_handle _Handle,
+    _Out_writes_z_(_Target_size) wchar_t* _Target, _In_ unsigned long _Target_size,
+    _In_ __std_fs_volume_name_kind _Flags) noexcept;
+
+struct __std_fs_copy_file_result {
+    bool _Copied;
+    __std_win_error _Error;
+};
+
+_NODISCARD __std_fs_copy_file_result __stdcall __std_fs_copy_file(
+    _In_z_ const wchar_t* _Source, _In_z_ const wchar_t* _Target, _In_ __std_fs_copy_options _Options) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_directory_iterator_open(_In_z_ const wchar_t* _Path_spec,
+    _Inout_ __std_fs_dir_handle* _Handle, _Out_ __std_fs_find_data* _Results) noexcept;
+
+void __stdcall __std_fs_directory_iterator_close(_In_ __std_fs_dir_handle _Handle) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error __stdcall __std_fs_get_stats(
+    _In_z_ const wchar_t* _Path, __std_fs_stats* _Stats, _In_ __std_fs_stats_flags _Flags,
+    _In_ __std_fs_file_attr _Symlink_attribute_hint = __std_fs_file_attr::_Invalid) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_directory_iterator_advance(
+    _In_ __std_fs_dir_handle _Handle, _Out_ __std_fs_find_data* _Results) noexcept;
+
+_NODISCARD __std_code_page __stdcall __std_fs_code_page() noexcept;
+
+_NODISCARD __std_fs_convert_result __stdcall __std_fs_convert_narrow_to_wide(_In_ __std_code_page _Code_page,
+    _In_reads_(_Input_len) const char* _Input_str, _In_ int _Input_len,
+    _Out_writes_opt_(_Output_len) wchar_t* _Output_str, _In_ int _Output_len) noexcept;
+
+_NODISCARD __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow(_In_ __std_code_page _Code_page,
+    _In_reads_(_Input_len) const wchar_t* _Input_str, _In_ int _Input_len,
+    _Out_writes_opt_(_Output_len) char* _Output_str, _In_ int _Output_len) noexcept;
+
+_NODISCARD __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow_replace_chars(
+    _In_ __std_code_page _Code_page, _In_reads_(_Input_len) const wchar_t* _Input_str, _In_ int _Input_len,
+    _Out_writes_opt_(_Output_len) char* _Output_str, _In_ int _Output_len) noexcept;
+
+struct __std_fs_equivalent_result {
+    bool _Equivalent;
+    __std_win_error _Error;
+};
+
+_NODISCARD __std_fs_equivalent_result __stdcall __std_fs_equivalent(
+    _In_z_ const wchar_t* _Path1, _In_z_ const wchar_t* _Path2) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_set_last_write_time(
+    _In_ long long _Last_write_filetime, _In_z_ const wchar_t* _Path) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_change_permissions(
+    _In_z_ const wchar_t* _Path, _In_ bool _Follow_symlinks, _In_ bool _Readonly) noexcept;
+
+_NODISCARD _Success_(return._Error == __std_win_error::_Success) __std_ulong_and_error __stdcall __std_fs_get_temp_path(
+    _Out_writes_z_(__std_fs_temp_path_max) wchar_t* _Target) noexcept;
+
+_NODISCARD _Success_(return._Error == __std_win_error::_Success) __std_ulong_and_error __stdcall
+    __std_fs_get_current_path(_In_ unsigned long _Target_size, _Out_writes_z_(_Target_size) wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_set_current_path(_In_z_ const wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_create_directory_symbolic_link(
+    _In_z_ const wchar_t* _Symlink_file_name, _In_z_ const wchar_t* _Target_file_name) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_create_hard_link(
+    _In_z_ const wchar_t* _File_name, _In_z_ const wchar_t* _Existing_file_name) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_create_symbolic_link(
+    _In_z_ const wchar_t* _Symlink_file_name, _In_z_ const wchar_t* _Target_file_name) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_read_reparse_data_buffer(_In_ __std_fs_file_handle _Handle,
+    _Out_writes_bytes_(_Buffer_size) void* _Buffer, _In_ unsigned long _Buffer_size) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_write_reparse_data_buffer(
+    _In_ __std_fs_file_handle _Handle, _In_ const __std_fs_reparse_data_buffer* _Buffer) noexcept;
+
+_NODISCARD bool __stdcall __std_fs_is_junction_from_reparse_data_buffer(
+    _In_ const __std_fs_reparse_data_buffer* _Buffer) noexcept;
+
+_NODISCARD _Success_(return == __std_win_error::_Success) __std_win_error __stdcall
+    __std_fs_read_name_from_reparse_data_buffer(
+        _In_ __std_fs_reparse_data_buffer* _Handle, _Out_ wchar_t** _Offset, _Out_ unsigned short* _Length) noexcept;
+
+struct __std_fs_create_directory_result {
+    bool _Created;
+    __std_win_error _Error;
+};
+
+_NODISCARD __std_fs_create_directory_result __stdcall __std_fs_create_directory(
+    _In_z_ const wchar_t* _New_directory) noexcept;
+
+struct __std_fs_remove_result {
+    bool _Removed;
+    __std_win_error _Error;
+};
+
+_NODISCARD __std_fs_remove_result __stdcall __std_fs_remove(_In_z_ const wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_rename(
+    _In_z_ const wchar_t* _Source, _In_z_ const wchar_t* _Target) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_resize_file(_In_z_ const wchar_t* _Target, uintmax_t _New_size) noexcept;
+
+_NODISCARD __std_win_error __stdcall __std_fs_space(_In_z_ const wchar_t* _Target, _Out_ uintmax_t* _Available,
+    _Out_ uintmax_t* _Total_bytes, _Out_ uintmax_t* _Free_bytes) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+struct _Fs_file {
+    __std_fs_file_handle _Raw;
+
+    explicit _Fs_file(void* const _Handle) : _Raw{reinterpret_cast<intptr_t>(_Handle)} {}
+
+    _Fs_file(const wchar_t* const _File_name, const __std_access_rights _Desired_access,
+        const __std_fs_file_flags _Flags, __std_win_error* const _Err) {
+        *_Err = __std_fs_open_handle(&_Raw, _File_name, _Desired_access, _Flags);
+    }
+
+    _Fs_file(const _Fs_file&)            = delete;
+    _Fs_file& operator=(const _Fs_file&) = delete;
+
+    ~_Fs_file() {
+        __std_fs_close_handle(_Raw);
+    }
+
+    _NODISCARD void* _Get() const {
+        return reinterpret_cast<void*>(_Raw);
+    }
+};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XFILESYSTEM_ABI_H
diff --git a/msvc-stl/stl/inc/xhash b/msvc-stl/stl/inc/xhash
new file mode 100644
index 0000000..db6b283
--- /dev/null
+++ b/msvc-stl/stl/inc/xhash
@@ -0,0 +1,1923 @@
+// xhash internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XHASH_
+#define _XHASH_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cmath>
+#include <list>
+#include <tuple>
+#include <vector>
+#include <xbit_ops.h>
+
+#ifdef _LEGACY_CODE_ASSUMES_XHASH_INCLUDES_XSTRING
+#include <cstring>
+#include <cwchar>
+#include <xstring>
+#endif // _LEGACY_CODE_ASSUMES_XHASH_INCLUDES_XSTRING
+
+#if _HAS_CXX17
+#include <xnode_handle.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Kty, class _Hasher, class _Keyeq>
+struct _Uhash_choose_transparency {
+    // transparency selector for non-transparent hashed containers
+    static constexpr bool _Has_transparent_overloads = false;
+};
+
+#if _HAS_CXX20
+template <class _Kty, _Transparent _Hasher, _Transparent _Keyeq>
+struct _Uhash_choose_transparency<_Kty, _Hasher, _Keyeq> {
+    // transparency selector for transparent hashed containers
+    static constexpr bool _Has_transparent_overloads = true;
+
+#if _HAS_CXX23
+    template <class _Container, class _Kx>
+    static constexpr bool _Supports_transparency =
+        !disjunction_v<is_convertible<_Kx, typename _Container::const_iterator>,
+            is_convertible<_Kx, typename _Container::iterator>>;
+#endif // _HAS_CXX23
+};
+#endif // _HAS_CXX20
+
+template <class _Hasher, class _Kty>
+constexpr bool _Nothrow_hash =
+    noexcept(static_cast<size_t>(_STD declval<const _Hasher&>()(_STD declval<const _Kty&>())));
+
+template <class _Kty, class _Hasher, class _Keyeq>
+class _Uhash_compare
+    : public _Uhash_choose_transparency<_Kty, _Hasher, _Keyeq> { // traits class for unordered containers
+public:
+    enum { // parameters for hash table
+        bucket_size = 1 // 0 < bucket_size
+    };
+
+    _Uhash_compare()
+        noexcept(conjunction_v<is_nothrow_default_constructible<_Hasher>, is_nothrow_default_constructible<_Keyeq>>)
+        : _Mypair(_Zero_then_variadic_args_t{}, _Zero_then_variadic_args_t{}, 0.0f) {}
+
+    explicit _Uhash_compare(const _Hasher& _Hasharg)
+        noexcept(conjunction_v<is_nothrow_copy_constructible<_Hasher>, is_nothrow_default_constructible<_Keyeq>>)
+        : _Mypair(_One_then_variadic_args_t{}, _Hasharg, _Zero_then_variadic_args_t{}, 0.0f) {}
+
+    explicit _Uhash_compare(const _Hasher& _Hasharg, const _Keyeq& _Keyeqarg)
+        noexcept(conjunction_v<is_nothrow_copy_constructible<_Hasher>, is_nothrow_copy_constructible<_Keyeq>>)
+        : _Mypair(_One_then_variadic_args_t{}, _Hasharg, _One_then_variadic_args_t{}, _Keyeqarg, 0.0f) {}
+
+    template <class _Keyty>
+    _NODISCARD size_t operator()(const _Keyty& _Keyval) const noexcept(_Nothrow_hash<_Hasher, _Keyty>) {
+        // hash _Keyval to size_t value
+        return static_cast<size_t>(_Mypair._Get_first()(_Keyval));
+    }
+
+    template <class _Keyty1, class _Keyty2>
+    _NODISCARD bool operator()(const _Keyty1& _Keyval1, const _Keyty2& _Keyval2) const
+        noexcept(_Nothrow_compare<_Keyeq, _Keyty1, _Keyty2>) {
+        // test if _Keyval1 NOT equal to _Keyval2
+        return !static_cast<bool>(_Mypair._Myval2._Get_first()(_Keyval1, _Keyval2));
+    }
+
+    _NODISCARD float& _Get_max_bucket_size() noexcept {
+        return _Mypair._Myval2._Myval2;
+    }
+
+    _NODISCARD const float& _Get_max_bucket_size() const noexcept {
+        return _Mypair._Myval2._Myval2;
+    }
+
+    void swap(_Uhash_compare& _Rhs)
+        noexcept(conjunction_v<_Is_nothrow_swappable<_Hasher>, _Is_nothrow_swappable<_Keyeq>>) {
+        using _STD swap;
+        swap(_Mypair._Get_first(), _Rhs._Mypair._Get_first()); // intentional ADL
+        auto& _Lsecond = _Mypair._Myval2;
+        auto& _Rsecond = _Rhs._Mypair._Myval2;
+        swap(_Lsecond._Get_first(), _Rsecond._Get_first()); // intentional ADL
+        _STD swap(_Lsecond._Myval2, _Rsecond._Myval2);
+    }
+
+    _Compressed_pair<_Hasher, _Compressed_pair<_Keyeq, float>> _Mypair;
+};
+
+template <class _Iter, class _Val>
+struct _Reinterpret_move_iter {
+    _Iter _Base;
+
+    using iterator_category = input_iterator_tag;
+    using value_type        = typename iterator_traits<_Iter>::value_type;
+    using difference_type   = typename iterator_traits<_Iter>::difference_type;
+    using reference         = _Val&&;
+    // pointer intentionally omitted
+
+    reference operator*() const {
+        return static_cast<reference>(reinterpret_cast<_Val&>(*_Base));
+    }
+
+    _Reinterpret_move_iter& operator++() {
+        ++_Base;
+        return *this;
+    }
+
+    // post ++ intentionally omitted
+
+    _NODISCARD friend bool operator==(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) {
+        return _Lhs._Base == _Rhs._Base;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD friend bool operator!=(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) {
+        return _Lhs._Base != _Rhs._Base;
+    }
+#endif // !_HAS_CXX20
+};
+
+template <class _Alnode>
+struct _List_head_construct_ptr {
+    using value_type = typename _Alnode::value_type;
+    static_assert(_Is_specialization_v<value_type, _List_node>, "_List_head_construct_ptr allocator not rebound");
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using pointer        = typename _Alnode_traits::pointer;
+    _Alnode& _Al;
+    pointer _Newhead;
+
+    explicit _List_head_construct_ptr(_Alnode& _Al_) : _Al(_Al_), _Newhead(value_type::_Buyheadnode(_Al)) {}
+
+    template <class _Val_types>
+    _List_head_construct_ptr(_Alnode& _Al_, _List_val<_Val_types>& _Mycont)
+        : _Al(_Al_), _Newhead(value_type::_Buyheadnode(_Al)) {
+        _Mycont._Myhead = _Newhead;
+    }
+
+    _List_head_construct_ptr(const _List_head_construct_ptr&)            = delete;
+    _List_head_construct_ptr& operator=(const _List_head_construct_ptr&) = delete;
+
+    _NODISCARD pointer _Release() noexcept {
+        return _STD exchange(_Newhead, nullptr);
+    }
+
+    ~_List_head_construct_ptr() {
+        if (_Newhead) {
+            value_type::_Freenode0(_Al, _Newhead);
+        }
+    }
+};
+
+template <class _Nodeptr>
+struct _Hash_find_last_result {
+    _Nodeptr _Insert_before;
+    _Nodeptr _Duplicate;
+};
+
+template <class _Aliter>
+struct _Hash_vec {
+    // TRANSITION, ABI: "vector" for ABI compatibility that doesn't call allocator::construct
+    using _Aliter_traits    = allocator_traits<_Aliter>;
+    using value_type        = typename _Aliter::value_type;
+    using size_type         = typename _Aliter_traits::size_type;
+    using difference_type   = typename _Aliter_traits::difference_type;
+    using pointer           = typename _Aliter_traits::pointer;
+    using _Aliter_scary_val = _Vector_val<conditional_t<_Is_simple_alloc_v<_Aliter>, _Simple_types<value_type>,
+        _Vec_iter_types<value_type, size_type, difference_type, pointer, typename _Aliter_traits::const_pointer>>>;
+
+    _Hash_vec() : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Mypair._Get_first()));
+    }
+
+    template <class _Any_alloc, enable_if_t<!is_same_v<_Remove_cvref_t<_Any_alloc>, _Hash_vec>, int> = 0>
+    explicit _Hash_vec(_Any_alloc&& _Al) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD forward<_Any_alloc>(_Al)) { // construct empty vector, allocator
+        _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Mypair._Get_first()));
+    }
+
+    _Hash_vec(const _Hash_vec&)            = delete;
+    _Hash_vec& operator=(const _Hash_vec&) = delete;
+
+    _NODISCARD size_type size() const noexcept {
+        return static_cast<size_type>(_Mypair._Myval2._Mylast - _Mypair._Myval2._Myfirst);
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        constexpr auto _Diff_max = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        return (_STD min) (_Diff_max, _Aliter_traits::max_size(_Mypair._Get_first()));
+    }
+
+    _NODISCARD size_type capacity() const noexcept {
+        // This implementation never has capacity() differ from size(), but the previous implementation could.
+        // We need to handle that situation gracefully since we may link to old code (See GH-2774).
+        return static_cast<size_type>(_Mypair._Myval2._Myend - _Mypair._Myval2._Myfirst);
+    }
+
+    void _Assign_grow(const size_type _Cells, const value_type _Val) {
+        // set the elements stored here to _Cells copies of _Val, leaving the value unchanged if an exception is thrown
+        const auto _Oldsize = size();
+        _STL_INTERNAL_CHECK(_Oldsize <= _Cells);
+        auto& _Alvec = _Mypair._Get_first();
+        if (_Oldsize < _Cells) {
+            const auto _Newvec = _Alvec.allocate(_Cells); // throws
+            // nothrow hereafter
+            const auto _Oldcapacity = capacity();
+            if (_Oldcapacity != 0) {
+                _Destroy_range(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast);
+                _Alvec.deallocate(_Mypair._Myval2._Myfirst, _Oldcapacity);
+            }
+
+            _Mypair._Myval2._Myfirst = _Newvec;
+            const auto _Newend       = _Newvec + _Cells;
+            _Mypair._Myval2._Mylast  = _Newend;
+            _Mypair._Myval2._Myend   = _Newend;
+            _STD uninitialized_fill(_Newvec, _Newend, _Val);
+        } else {
+            _STD fill(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast, _Val);
+        }
+    }
+
+    void _Tidy() noexcept {
+        if (_Mypair._Myval2._Myfirst != nullptr) {
+            _Destroy_range(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast);
+            _Mypair._Get_first().deallocate(_Mypair._Myval2._Myfirst, capacity());
+            _Mypair._Myval2._Myfirst = nullptr;
+            _Mypair._Myval2._Mylast  = nullptr;
+            _Mypair._Myval2._Myend   = nullptr;
+        }
+    }
+
+    ~_Hash_vec() {
+        _Tidy();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        auto _Alproxy = _STD _Get_proxy_allocator(_Mypair._Get_first());
+        _Delete_plain_internal(_Alproxy, _STD exchange(_Mypair._Myval2._Myproxy, nullptr));
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    _Compressed_pair<_Aliter, _Aliter_scary_val> _Mypair;
+};
+
+template <class _Traits>
+class _Hash { // hash table -- list with vector of iterators for quick access
+protected:
+    using _Mylist             = list<typename _Traits::value_type, typename _Traits::allocator_type>;
+    using _Alnode             = typename _Mylist::_Alnode;
+    using _Alnode_traits      = typename _Mylist::_Alnode_traits;
+    using _Node               = typename _Mylist::_Node;
+    using _Nodeptr            = typename _Mylist::_Nodeptr;
+    using _Mutable_value_type = typename _Traits::_Mutable_value_type;
+    using _Key_compare        = typename _Traits::key_compare;
+
+public:
+    using key_type = typename _Traits::key_type;
+
+    using value_type      = typename _Mylist::value_type;
+    using allocator_type  = typename _Mylist::allocator_type;
+    using size_type       = typename _Mylist::size_type;
+    using difference_type = typename _Mylist::difference_type;
+    using pointer         = typename _Mylist::pointer;
+    using const_pointer   = typename _Mylist::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using iterator =
+        conditional_t<is_same_v<key_type, value_type>, typename _Mylist::const_iterator, typename _Mylist::iterator>;
+    using const_iterator = typename _Mylist::const_iterator;
+
+    using _Unchecked_iterator       = conditional_t<is_same_v<key_type, value_type>,
+        typename _Mylist::_Unchecked_const_iterator, typename _Mylist::_Unchecked_iterator>;
+    using _Unchecked_const_iterator = typename _Mylist::_Unchecked_const_iterator;
+
+    using _Aliter = _Rebind_alloc_t<_Alnode, _Unchecked_iterator>;
+
+    static constexpr size_type _Bucket_size = _Key_compare::bucket_size;
+    static constexpr size_type _Min_buckets = 8; // must be a positive power of 2
+    static constexpr bool _Multi            = _Traits::_Multi;
+
+    template <class _TraitsT>
+    friend bool _Hash_equal(const _Hash<_TraitsT>& _Left, const _Hash<_TraitsT>& _Right);
+
+protected:
+    _Hash(const _Key_compare& _Parg, const allocator_type& _Al)
+        : _Traitsobj(_Parg), _List(_Al), _Vec(_Al), _Mask(_Min_buckets - 1), _Maxidx(_Min_buckets) {
+        // construct empty hash table
+        _Max_bucket_size() = _Bucket_size;
+        _Vec._Assign_grow(_Min_buckets * 2, _List._Unchecked_end());
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+    template <class _Any_alloc>
+    _Hash(const _Hash& _Right, const _Any_alloc& _Al)
+        : _Traitsobj(_Right._Traitsobj), _List(static_cast<allocator_type>(_Al)), _Vec(_Al), _Mask(_Right._Mask),
+          _Maxidx(_Right._Maxidx) {
+        // construct hash table by copying _Right
+        _Vec._Assign_grow(_Right._Vec.size(), _List._Unchecked_end());
+        _Insert_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+        _Right._Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+    _Hash(_Hash&& _Right)
+        : _Traitsobj(_Right._Traitsobj), _List(_Move_allocator_tag{}, _Right._List._Getal()),
+          _Vec(_STD move(_Right._Vec._Mypair._Get_first())) {
+        _Vec._Assign_grow(_Min_buckets * 2, _Unchecked_end());
+        _List._Swap_val(_Right._List);
+        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
+        _Mask   = _STD exchange(_Right._Mask, _Min_buckets - 1);
+        _Maxidx = _STD exchange(_Right._Maxidx, _Min_buckets);
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+        _Right._Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+private:
+    void _Move_construct_equal_alloc(_Hash& _Right) {
+        _Vec._Assign_grow(_Min_buckets * 2, _Unchecked_end());
+        _List._Swap_val(_Right._List);
+        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
+        _Mask   = _STD exchange(_Right._Mask, _Min_buckets - 1);
+        _Maxidx = _STD exchange(_Right._Maxidx, _Min_buckets);
+    }
+
+public:
+    _Hash(_Hash&& _Right, const allocator_type& _Al) : _Traitsobj(_Right._Traitsobj), _List(_Al), _Vec(_Al) {
+        // construct hash table by moving _Right, allocator
+        if constexpr (_Alnode_traits::is_always_equal::value) {
+            _Move_construct_equal_alloc(_Right);
+        } else if (_List._Getal() == _Right._List._Getal()) {
+            _Move_construct_equal_alloc(_Right);
+        } else {
+            _Maxidx            = _Min_buckets;
+            const auto _Myhead = _List._Mypair._Myval2._Myhead;
+            for (auto& _Val : _Right._List) {
+                _List._Emplace(_Myhead, reinterpret_cast<_Mutable_value_type&&>(_Val));
+            }
+            _Reinsert_with_invalid_vec();
+            _Right.clear();
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+        _Right._Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    ~_Hash() noexcept {
+        // Destroying _List and _Vec will store tombstones in their pointers.
+        // We'll also set _Mask and _Maxidx back to the values used by _Hash's default constructor. Although this
+        // doesn't provide the same benefit as zeroing out size fields, it's consistent with the pattern elsewhere.
+        _Mask   = _Min_buckets - 1;
+        _Maxidx = _Min_buckets;
+    }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+
+private:
+    void _Swap_val(_Hash& _Right) noexcept { // swap contents with equal allocator _Hash _Right
+        _List._Swap_val(_Right._List);
+        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
+        _STD swap(_Mask, _Right._Mask);
+        _STD swap(_Maxidx, _Right._Maxidx);
+    }
+
+    struct _Min_buckets_construct_ptr {
+        using pointer = typename allocator_traits<_Aliter>::pointer;
+        _Aliter& _Al;
+        pointer _Base;
+        _Min_buckets_construct_ptr(_Aliter& _Al_) : _Al(_Al_), _Base(_Al.allocate(_Min_buckets * 2)) {}
+        _Min_buckets_construct_ptr(const _Min_buckets_construct_ptr&) = delete;
+        _NODISCARD pointer _Release(_Unchecked_iterator _Newend) noexcept {
+            _STD uninitialized_fill(_Base, _Base + _Min_buckets * 2, _Newend);
+            return _STD exchange(_Base, nullptr);
+        }
+        ~_Min_buckets_construct_ptr() {
+            if (_Base) {
+                _Al.deallocate(_Base, _Min_buckets * 2);
+            }
+        }
+    };
+
+    void _Pocma_both(_Hash& _Right) {
+        _Pocma(_List._Getal(), _Right._List._Getal());
+        _Pocma(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
+    }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    struct _NODISCARD _Check_container_invariants_guard {
+        const _Hash& _Target;
+
+        explicit _Check_container_invariants_guard(const _Hash& _Target_) : _Target(_Target_) {}
+
+        _Check_container_invariants_guard(const _Check_container_invariants_guard&)            = delete;
+        _Check_container_invariants_guard& operator=(const _Check_container_invariants_guard&) = delete;
+
+        ~_Check_container_invariants_guard() {
+            _Target._Stl_internal_check_container_invariants();
+        }
+    };
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+public:
+    _Hash& operator=(_Hash&& _Right) { // assign by moving _Right
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Check_container_invariants_guard _Check_self{*this};
+        _Check_container_invariants_guard _Check_right{_Right};
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                // allocate all the parts necessary to maintain _Hash invariants using _Right's allocator
+                auto _Alproxy       = _STD _Get_proxy_allocator(_Al);
+                auto _Right_alproxy = _STD _Get_proxy_allocator(_Right_al);
+                _Container_proxy_ptr<_Alnode> _List_proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                _Container_proxy_ptr<_Alnode> _Vec_proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                _List_head_construct_ptr<_Alnode> _Newhead(_Right_al);
+                _Min_buckets_construct_ptr _Buckets(_Right._Vec._Mypair._Get_first());
+
+                // assign the hash/compare ops; we have no control over whether this throws, and if it does we want
+                // to do nothing
+                _Traitsobj = _Right._Traitsobj;
+
+                // nothrow hereafter
+
+                // release any state we are currently owning, and propagate the allocators
+                _List._Tidy();
+                _Vec._Tidy();
+                _Pocma_both(_Right);
+
+                // assign the empty list to _Right._List (except the allocators), and take _Right's _List data
+                auto& _List_data       = _List._Mypair._Myval2;
+                auto& _Right_list_data = _Right._List._Mypair._Myval2;
+                _List_data._Myhead     = _STD exchange(_Right_list_data._Myhead, _Newhead._Release());
+                _List_data._Mysize     = _STD exchange(_Right_list_data._Mysize, size_type{0});
+                _List_proxy._Bind(_Alproxy, _STD addressof(_List_data));
+                _List_data._Swap_proxy_and_iterators(_Right_list_data);
+
+                // assign the _Min_buckets into _Right's _Vec data and take _Right's _Vec data
+                auto& _Vec_data       = _Vec._Mypair._Myval2;
+                auto& _Right_vec_data = _Right._Vec._Mypair._Myval2;
+
+                const auto _Newfirst = _Buckets._Release(_Right._Unchecked_end());
+                const auto _Newlast  = _Newfirst + _Min_buckets * 2;
+
+                _Vec_data._Myfirst = _STD exchange(_Right_vec_data._Myfirst, _Newfirst);
+                _Vec_data._Mylast  = _STD exchange(_Right_vec_data._Mylast, _Newlast);
+                _Vec_data._Myend   = _STD exchange(_Right_vec_data._Myend, _Newlast);
+                _Vec_proxy._Bind(_Alproxy, _STD addressof(_Vec_data));
+                _Vec_data._Swap_proxy_and_iterators(_Right_vec_data);
+
+                // give _Right the default _Mask and _Maxidx values and take its former values
+                _Mask   = _STD exchange(_Right._Mask, _Min_buckets - 1);
+                _Maxidx = _STD exchange(_Right._Maxidx, _Min_buckets);
+
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                _Clear_guard<_Hash> _Guard{this};
+                _Traitsobj     = _Right._Traitsobj;
+                using _Adapter = _Reinterpret_move_iter<typename _Mylist::_Unchecked_iterator, _Mutable_value_type>;
+                _List.template _Assign_cast<_Mutable_value_type&>(
+                    _Adapter{_Right._List._Unchecked_begin()}, _Adapter{_Right._List._Unchecked_end()});
+                _Reinsert_with_invalid_vec();
+                _Guard._Target = nullptr;
+
+                return *this;
+            }
+        }
+
+        clear();
+        _Traitsobj = _Right._Traitsobj;
+        _Pocma_both(_Right);
+        _Swap_val(_Right);
+
+        return *this;
+    }
+
+    template <class... _Valtys>
+    conditional_t<_Multi, iterator, pair<iterator, bool>> emplace(_Valtys&&... _Vals) {
+        // try to insert value_type(_Vals...)
+        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Valtys...>;
+        if constexpr (_Multi) {
+            _Check_max_size();
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+            }
+
+            const auto _Target = _Find_last(_Keyval, _Hashval);
+            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+        } else if constexpr (_In_place_key_extractor::_Extractable) {
+            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            auto _Target        = _Find_last(_Keyval, _Hashval);
+            if (_Target._Duplicate) {
+                return {_List._Make_iter(_Target._Duplicate), false};
+            }
+
+            _Check_max_size();
+            // invalidates _Keyval:
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+            }
+
+            return {
+                _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())), true};
+        } else {
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            auto _Target        = _Find_last(_Keyval, _Hashval);
+            if (_Target._Duplicate) {
+                return {_List._Make_iter(_Target._Duplicate), false};
+            }
+
+            _Check_max_size();
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+            }
+
+            return {
+                _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())), true};
+        }
+    }
+
+    template <class... _Valtys>
+    iterator emplace_hint(const_iterator _Hint, _Valtys&&... _Vals) { // try to insert value_type(_Vals...)
+        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Valtys...>;
+        if constexpr (_Multi) {
+            _Check_max_size();
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+            }
+
+            const auto _Target = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+        } else if constexpr (_In_place_key_extractor::_Extractable) {
+            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            auto _Target        = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+            if (_Target._Duplicate) {
+                return _List._Make_iter(_Target._Duplicate);
+            }
+
+            _Check_max_size();
+            // invalidates _Keyval:
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_hint(_Hint._Ptr, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+            }
+
+            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+        } else {
+            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            const auto _Hashval = _Traitsobj(_Keyval);
+            auto _Target        = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+            if (_Target._Duplicate) {
+                return _List._Make_iter(_Target._Duplicate);
+            }
+
+            _Check_max_size();
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_hint(_Hint._Ptr, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+            }
+
+            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
+        }
+    }
+
+protected:
+    template <class _Keyty, class... _Mappedty>
+    pair<_Nodeptr, bool> _Try_emplace(_Keyty&& _Keyval_arg, _Mappedty&&... _Mapval) {
+        const auto& _Keyval = _Keyval_arg;
+        const auto _Hashval = _Traitsobj(_Keyval);
+        auto _Target        = _Find_last(_Keyval, _Hashval);
+        if (_Target._Duplicate) {
+            return {_Target._Duplicate, false};
+        }
+
+        _Check_max_size();
+        _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), piecewise_construct,
+            _STD forward_as_tuple(_STD forward<_Keyty>(_Keyval_arg)),
+            _STD forward_as_tuple(_STD forward<_Mappedty>(_Mapval)...));
+        if (_Check_rehash_required_1()) {
+            _Rehash_for_1();
+            _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+        }
+
+        return {_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()), true};
+    }
+
+    template <class _Keyty, class... _Mappedty>
+    _Nodeptr _Try_emplace_hint(const _Nodeptr _Hint, _Keyty&& _Keyval_arg, _Mappedty&&... _Mapval) {
+        const auto& _Keyval = _Keyval_arg;
+        const auto _Hashval = _Traitsobj(_Keyval);
+        auto _Target        = _Find_hint(_Hint, _Keyval, _Hashval);
+        if (_Target._Duplicate) {
+            return _Target._Duplicate;
+        }
+
+        _Check_max_size();
+        // might invalidate _Keyval:
+        _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), piecewise_construct,
+            _STD forward_as_tuple(_STD forward<_Keyty>(_Keyval_arg)),
+            _STD forward_as_tuple(_STD forward<_Mappedty>(_Mapval)...));
+        if (_Check_rehash_required_1()) {
+            _Rehash_for_1();
+            _Target = _Find_hint(_Hint, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
+        }
+
+        return _Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release());
+    }
+
+private:
+    void _Pocca_both(const _Hash& _Right) {
+        _Pocca(_List._Getal(), _Right._List._Getal());
+        _Pocca(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
+    }
+
+public:
+    _Hash& operator=(const _Hash& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Check_container_invariants_guard _Check_self{*this};
+        _Check_container_invariants_guard _Check_right{_Right};
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+        if constexpr (_Choose_pocca_v<_Alnode>) {
+            auto& _Al             = _Getal();
+            const auto& _Right_al = _Right._Getal();
+            if (_Al != _Right_al) {
+                auto _Alproxy       = _STD _Get_proxy_allocator(_Al);
+                auto _Right_alproxy = _STD _Get_proxy_allocator(_Right_al);
+                _Container_proxy_ptr<_Alnode> _Vec_proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                _List._Reload_sentinel_and_proxy(_Right._List);
+                _Vec._Tidy();
+                _Pocca_both(_Right);
+                _Vec_proxy._Bind(_Alproxy, _STD addressof(_Vec._Mypair._Myval2));
+
+                _Clear_guard<_Hash> _Guard{this};
+                _Traitsobj = _Right._Traitsobj;
+                _List.template _Assign_cast<_Mutable_value_type&>(
+                    _Right._List._Unchecked_begin(), _Right._List._Unchecked_end());
+                _Reinsert_with_invalid_vec();
+                _Guard._Target = nullptr;
+
+                return *this;
+            }
+        }
+
+        _Clear_guard<_Hash> _Guard{this};
+        _Traitsobj = _Right._Traitsobj;
+        _Pocca_both(_Right);
+        _List.template _Assign_cast<_Mutable_value_type&>(
+            _Right._List._Unchecked_begin(), _Right._List._Unchecked_end());
+        _Reinsert_with_invalid_vec();
+        _Guard._Target = nullptr;
+
+        return *this;
+    }
+
+    _NODISCARD iterator begin() noexcept {
+        return _List.begin();
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        return _List.begin();
+    }
+
+    _NODISCARD iterator end() noexcept {
+        return _List.end();
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        return _List.end();
+    }
+
+    _Unchecked_iterator _Unchecked_begin() noexcept {
+        return _List._Unchecked_begin();
+    }
+
+    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
+        return _List._Unchecked_begin();
+    }
+
+    _Unchecked_iterator _Unchecked_end() noexcept {
+        return _List._Unchecked_end();
+    }
+
+    _Unchecked_const_iterator _Unchecked_end() const noexcept {
+        return _List._Unchecked_end();
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _List.size();
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        return _List.max_size();
+    }
+
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _List.empty();
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_List.get_allocator());
+    }
+
+    using local_iterator       = iterator;
+    using const_local_iterator = const_iterator;
+
+    _NODISCARD size_type bucket_count() const noexcept {
+        return _Maxidx;
+    }
+
+    _NODISCARD size_type max_bucket_count() const noexcept {
+        return _Vec.max_size() >> 1;
+    }
+
+    _NODISCARD size_type bucket(const key_type& _Keyval) const
+        noexcept(_Nothrow_hash<_Traits, key_type>) /* strengthened */ {
+        return _Traitsobj(_Keyval) & _Mask;
+    }
+
+    _NODISCARD size_type bucket_size(size_type _Bucket) const noexcept /* strengthened */ {
+        _Unchecked_iterator _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+        if (_Bucket_lo == _Unchecked_end()) {
+            return 0;
+        }
+
+        return static_cast<size_type>(_STD distance(_Bucket_lo, _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1])) + 1;
+    }
+
+    _NODISCARD local_iterator begin(size_type _Bucket) noexcept /* strengthened */ {
+        return _List._Make_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
+    }
+
+    _NODISCARD const_local_iterator begin(size_type _Bucket) const noexcept /* strengthened */ {
+        return _List._Make_const_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
+    }
+
+    _NODISCARD local_iterator end(size_type _Bucket) noexcept /* strengthened */ {
+        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
+            _Bucket_hi = _Bucket_hi->_Next;
+        }
+
+        return _List._Make_iter(_Bucket_hi);
+    }
+
+    _NODISCARD const_local_iterator end(size_type _Bucket) const noexcept /* strengthened */ {
+        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
+            _Bucket_hi = _Bucket_hi->_Next;
+        }
+
+        return _List._Make_const_iter(_Bucket_hi);
+    }
+
+    _NODISCARD const_local_iterator cbegin(size_type _Bucket) const noexcept /* strengthened */ {
+        return _List._Make_const_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
+    }
+
+    _NODISCARD const_local_iterator cend(size_type _Bucket) const noexcept /* strengthened */ {
+        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
+            _Bucket_hi = _Bucket_hi->_Next;
+        }
+
+        return _List._Make_const_iter(_Bucket_hi);
+    }
+
+    _NODISCARD float load_factor() const noexcept {
+        return static_cast<float>(size()) / static_cast<float>(bucket_count());
+    }
+
+    _NODISCARD float max_load_factor() const noexcept {
+        return _Max_bucket_size();
+    }
+
+    void max_load_factor(float _Newmax) noexcept /* strengthened */ {
+        _STL_ASSERT(!(_CSTD isnan) (_Newmax) && _Newmax > 0, "invalid hash load factor");
+        _Max_bucket_size() = _Newmax;
+    }
+
+    void rehash(size_type _Buckets) { // rebuild table with at least _Buckets buckets
+        // don't violate a.bucket_count() >= a.size() / a.max_load_factor() invariant:
+        _Buckets = (_STD max) (_Min_load_factor_buckets(_List.size()), _Buckets);
+        if (_Buckets <= _Maxidx) { // we already have enough buckets; nothing to do
+            return;
+        }
+
+        _Forced_rehash(_Buckets);
+    }
+
+    void reserve(size_type _Maxcount) { // rebuild table with room for _Maxcount elements
+        rehash(_Min_load_factor_buckets(_Maxcount));
+    }
+
+    conditional_t<_Multi, iterator, pair<iterator, bool>> insert(const value_type& _Val) {
+        return emplace(_Val);
+    }
+
+    conditional_t<_Multi, iterator, pair<iterator, bool>> insert(value_type&& _Val) {
+        return emplace(_STD move(_Val));
+    }
+
+    iterator insert(const_iterator _Hint, const value_type& _Val) {
+        return emplace_hint(_Hint, _Val);
+    }
+
+    iterator insert(const_iterator _Hint, value_type&& _Val) {
+        return emplace_hint(_Hint, _STD move(_Val));
+    }
+
+protected:
+    template <class _Iter, class _Sent>
+    void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
+        for (; _First != _Last; ++_First) {
+            emplace(*_First);
+        }
+    }
+
+public:
+    template <class _Iter>
+    void insert(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Insert_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
+        _Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    void insert(initializer_list<value_type> _Ilist) {
+        _Insert_range_unchecked(_Ilist.begin(), _Ilist.end());
+    }
+
+private:
+    _Nodeptr _Unchecked_erase(_Nodeptr _Plist) noexcept(_Nothrow_hash<_Traits, key_type>) {
+        size_type _Bucket = bucket(_Traits::_Kfn(_Plist->_Myval));
+        _Erase_bucket(_Plist, _Bucket);
+        return _List._Unchecked_erase(_Plist);
+    }
+
+    struct _Range_eraser {
+        _Range_eraser(const _Range_eraser&)            = delete;
+        _Range_eraser& operator=(const _Range_eraser&) = delete;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        // Keep the list nodes around until we have found all those we will erase, for an O(iterators + erasures) update
+        // of the iterator chain.
+        _Range_eraser(_Mylist& _List_, const _Nodeptr _First_) noexcept
+            : _List(_List_), _First(_First_), _Next(_First_) {}
+
+        void _Bump_erased() noexcept {
+            _Next = _Next->_Next;
+        }
+
+        ~_Range_eraser() noexcept {
+            _List._Unchecked_erase(_First, _Next);
+        }
+
+        _Mylist& _List;
+        const _Nodeptr _First;
+        _Nodeptr _Next;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+      // Destroy the nodes as we encounter them to avoid a second traversal of the linked list.
+        _Range_eraser(_Mylist& _List_, const _Nodeptr _First_) noexcept
+            : _List(_List_), _Predecessor(_First_->_Prev), _Next(_First_) {}
+
+        void _Bump_erased() noexcept {
+            const auto _Oldnext = _Next;
+            _Next               = _Oldnext->_Next;
+            _Node::_Freenode(_List._Getal(), _Oldnext);
+            --_List._Mypair._Myval2._Mysize;
+        }
+
+        ~_Range_eraser() noexcept {
+            _Predecessor->_Next = _Next;
+            _Next->_Prev        = _Predecessor;
+        }
+
+        _Mylist& _List;
+        const _Nodeptr _Predecessor;
+        _Nodeptr _Next;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+    };
+
+    _Nodeptr _Unchecked_erase(_Nodeptr _First, const _Nodeptr _Last) noexcept(_Nothrow_hash<_Traits, key_type>) {
+        if (_First == _Last) {
+            return _Last;
+        }
+
+        const auto _End           = _List._Mypair._Myval2._Myhead;
+        const auto _Bucket_bounds = _Vec._Mypair._Myval2._Myfirst;
+        _Range_eraser _Eraser{_List, _First};
+        {
+            // process the first bucket, which is special because here _First might not be the beginning of the bucket
+            const auto _Predecessor = _First->_Prev;
+            const size_type _Bucket = bucket(_Traits::_Kfn(_Eraser._Next->_Myval)); // throws
+            // nothrow hereafter this block
+            _Nodeptr& _Bucket_lo   = _Bucket_bounds[_Bucket << 1]._Ptr;
+            _Nodeptr& _Bucket_hi   = _Bucket_bounds[(_Bucket << 1) + 1]._Ptr;
+            const bool _Update_lo  = _Bucket_lo == _Eraser._Next;
+            const _Nodeptr _Old_hi = _Bucket_hi;
+            for (;;) { // remove elements until we hit the end of the bucket
+                const bool _At_bucket_back = _Eraser._Next == _Old_hi;
+                _Eraser._Bump_erased();
+                if (_At_bucket_back) {
+                    break;
+                }
+
+                if (_Eraser._Next == _Last) {
+                    if (_Update_lo) {
+                        // erased the bucket's prefix
+                        _Bucket_lo = _Eraser._Next;
+                    }
+
+                    return _Last;
+                }
+            }
+
+            if (_Update_lo) {
+                // emptied the bucket
+                _Bucket_lo = _End;
+                _Bucket_hi = _End;
+            } else {
+                _Bucket_hi = _Predecessor;
+            }
+        }
+
+        // hereafter we are always erasing buckets' prefixes
+        while (_Eraser._Next != _Last) {
+            const size_type _Bucket = bucket(_Traits::_Kfn(_Eraser._Next->_Myval)); // throws
+            // nothrow hereafter this block
+            _Nodeptr& _Bucket_lo   = _Bucket_bounds[_Bucket << 1]._Ptr;
+            _Nodeptr& _Bucket_hi   = _Bucket_bounds[(_Bucket << 1) + 1]._Ptr;
+            const _Nodeptr _Old_hi = _Bucket_hi;
+            for (;;) { // remove elements until we hit the end of the bucket
+                const bool _At_bucket_back = _Eraser._Next == _Old_hi;
+                _Eraser._Bump_erased();
+                if (_At_bucket_back) {
+                    break;
+                }
+
+                if (_Eraser._Next == _Last) {
+                    // erased the bucket's prefix
+                    _Bucket_lo = _Eraser._Next;
+                    return _Last;
+                }
+            }
+
+            // emptied the bucket
+            _Bucket_lo = _End;
+            _Bucket_hi = _End;
+        }
+
+        return _Last;
+    }
+
+    template <class _Kx>
+    static constexpr bool _Noexcept_heterogeneous_erasure() {
+        return _Nothrow_hash<_Traits, _Kx>
+            && (!_Multi || (_Nothrow_compare<_Traits, key_type, _Kx> && _Nothrow_compare<_Traits, _Kx, key_type>) );
+    }
+
+    template <class _Keytype>
+    size_type _Erase(const _Keytype& _Keyval) noexcept(_Noexcept_heterogeneous_erasure<_Keytype>()) /* strengthened */ {
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        if constexpr (_Multi) {
+            const auto _Where = _Equal_range(_Keyval, _Hashval);
+            _Unchecked_erase(_Where._First._Ptr, _Where._Last._Ptr);
+            return _Where._Distance;
+        } else {
+            const auto _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
+            if (_Target) {
+                _Erase_bucket(_Target, _Hashval & _Mask);
+                _List._Unchecked_erase(_Target);
+                return 1;
+            }
+
+            return 0;
+        }
+    }
+
+public:
+    template <class _Iter = iterator, enable_if_t<!is_same_v<_Iter, const_iterator>, int> = 0>
+    iterator erase(iterator _Plist) noexcept(_Nothrow_hash<_Traits, key_type>) /* strengthened */ {
+        return _List._Make_iter(_Unchecked_erase(_Plist._Ptr));
+    }
+
+    iterator erase(const_iterator _Plist) noexcept(_Nothrow_hash<_Traits, key_type>) /* strengthened */ {
+        return _List._Make_iter(_Unchecked_erase(_Plist._Ptr));
+    }
+
+    iterator erase(const_iterator _First, const_iterator _Last)
+        noexcept(_Nothrow_hash<_Traits, key_type>) /* strengthened */ {
+        return _List._Make_iter(_Unchecked_erase(_First._Ptr, _Last._Ptr));
+    }
+
+    size_type erase(const key_type& _Keyval) noexcept(noexcept(_Erase(_Keyval))) /* strengthened */ {
+        return _Erase(_Keyval);
+    }
+
+#if _HAS_CXX23
+    template <class _Kx>
+        requires (_Traits::template _Supports_transparency<_Hash, _Kx>)
+    size_type erase(_Kx&& _Keyval) noexcept(noexcept(_Erase(_Keyval))) /* strengthened */ {
+        return _Erase(_Keyval);
+    }
+#endif // _HAS_CXX23
+
+    void clear() noexcept {
+        // TRANSITION, ABI:
+        // LWG-2550 requires implementations to make clear() O(size()), independent of bucket_count().
+        // Unfortunately our current data structure / ABI does not allow achieving this in the general case because:
+        //   (1) Finding the bucket that goes with an element requires running the hash function
+        //   (2) The hash function operator() may throw exceptions, and
+        //   (3) clear() is a noexcept function.
+        // We do comply with LWG-2550 if the hash function is noexcept, or if the container was empty.
+        const auto _Oldsize = _List._Mypair._Myval2._Mysize;
+        if (_Oldsize == 0) {
+            return;
+        }
+
+        if constexpr (_Nothrow_hash<_Traits, key_type>) {
+            // In testing, hash<size_t>{}(size_t{}) takes about 14 times as much time as assigning a pointer, or
+            // ~7-8 times as much as clearing a bucket. Therefore, if we would need to assign over more than 8 times
+            // as many buckets as elements, remove element-by-element.
+            if (bucket_count() / 8 > _Oldsize) {
+                const auto _Head = _List._Mypair._Myval2._Myhead;
+                _Unchecked_erase(_Head->_Next, _Head);
+                return;
+            }
+        }
+
+        // Bulk destroy items and reset buckets
+        _List.clear();
+        _STD fill(_Vec._Mypair._Myval2._Myfirst, _Vec._Mypair._Myval2._Mylast, _Unchecked_end());
+    }
+
+private:
+    template <class _Keyty>
+    _NODISCARD _Nodeptr _Find_first(const _Keyty& _Keyval, const size_t _Hashval) const {
+        // find node pointer to first node matching _Keyval (with hash _Hashval) if it exists; otherwise, end
+        const size_type _Bucket = _Hashval & _Mask;
+        _Nodeptr _Where         = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
+        const _Nodeptr _End     = _List._Mypair._Myval2._Myhead;
+        if (_Where == _End) {
+            return _End;
+        }
+
+        const _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        for (;;) {
+            if (!_Traitsobj(_Traits::_Kfn(_Where->_Myval), _Keyval)) {
+                return _Where;
+            }
+
+            if (_Where == _Bucket_hi) {
+                return _End;
+            }
+
+            _Where = _Where->_Next;
+        }
+    }
+
+    template <class _Keyty>
+    _Nodeptr _Find(const _Keyty& _Keyval, const size_t _Hashval) const {
+        if constexpr (_Traits::_Multi) {
+            return _Find_first(_Keyval, _Hashval);
+        } else {
+            // use _Find_last for unique containers to avoid increase in code size of instantiating _Find_first
+            auto _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
+            if (_Target) {
+                return _Target;
+            }
+
+            return _List._Mypair._Myval2._Myhead;
+        }
+    }
+
+public:
+    _NODISCARD iterator find(const key_type& _Keyval) {
+        return _List._Make_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
+    }
+
+#if _HAS_CXX20
+    template <class _KeyTy>
+        requires _Traits::_Has_transparent_overloads
+    _NODISCARD iterator find(const _KeyTy& _Keyval) {
+        return _List._Make_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
+    }
+#endif // _HAS_CXX20
+
+    _NODISCARD const_iterator find(const key_type& _Keyval) const {
+        return _List._Make_const_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
+    }
+
+#if _HAS_CXX20
+    template <class _KeyTy>
+        requires _Traits::_Has_transparent_overloads
+    _NODISCARD const_iterator find(const _KeyTy& _Keyval) const {
+        return _List._Make_const_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
+    }
+
+    _NODISCARD bool contains(const key_type& _Keyval) const {
+        return static_cast<bool>(_Find_last(_Keyval, _Traitsobj(_Keyval))._Duplicate);
+    }
+
+    template <class _KeyTy>
+        requires _Traits::_Has_transparent_overloads
+    _NODISCARD bool contains(const _KeyTy& _Keyval) const {
+        return static_cast<bool>(_Find_last(_Keyval, _Traitsobj(_Keyval))._Duplicate);
+    }
+#endif // _HAS_CXX20
+
+    _NODISCARD size_type count(const key_type& _Keyval) const {
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        if constexpr (_Multi) {
+            return _Equal_range(_Keyval, _Hashval)._Distance;
+        } else {
+            return static_cast<bool>(_Find_last(_Keyval, _Hashval)._Duplicate);
+        }
+    }
+
+#if _HAS_CXX20
+    template <class _KeyTy>
+        requires _Traits::_Has_transparent_overloads
+    _NODISCARD size_type count(const _KeyTy& _Keyval) const {
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        if constexpr (_Multi) {
+            return _Equal_range(_Keyval, _Hashval)._Distance;
+        } else {
+            return static_cast<bool>(_Find_last(_Keyval, _Hashval)._Duplicate);
+        }
+    }
+#endif // _HAS_CXX20
+
+private:
+    struct _Equal_range_result {
+        _Unchecked_const_iterator _First;
+        _Unchecked_const_iterator _Last;
+        size_type _Distance;
+    };
+
+    template <class _Keyty>
+    _NODISCARD _Equal_range_result _Equal_range(const _Keyty& _Keyval, const size_t _Hashval) const
+        noexcept(_Nothrow_compare<_Traits, key_type, _Keyty> && _Nothrow_compare<_Traits, _Keyty, key_type>) {
+        const size_type _Bucket              = _Hashval & _Mask;
+        _Unchecked_const_iterator _Where     = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+        const _Unchecked_const_iterator _End = _Unchecked_end();
+        if (_Where == _End) {
+            return {_End, _End, 0};
+        }
+
+        const _Unchecked_const_iterator _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
+        for (; _Traitsobj(_Traits::_Kfn(*_Where), _Keyval); ++_Where) {
+            if (_Where == _Bucket_hi) {
+                return {_End, _End, 0};
+            }
+        }
+
+        const _Unchecked_const_iterator _First = _Where;
+        if constexpr (_Multi) {
+            size_type _Distance = 0;
+            for (;;) {
+                ++_Distance;
+
+                const bool _At_bucket_end = _Where == _Bucket_hi;
+                ++_Where;
+                if (_At_bucket_end) {
+                    break;
+                }
+
+                if (_Traitsobj(_Keyval, _Traits::_Kfn(*_Where))) {
+                    break;
+                }
+            }
+
+            return {_First, _Where, _Distance};
+        } else {
+            ++_Where; // found the unique element
+            return {_First, _Where, 1};
+        }
+    }
+
+public:
+    _NODISCARD pair<iterator, iterator> equal_range(const key_type& _Keyval) {
+        const auto _Result = _Equal_range(_Keyval, _Traitsobj(_Keyval));
+        return {_List._Make_iter(_Result._First._Ptr), _List._Make_iter(_Result._Last._Ptr)};
+    }
+
+#if _HAS_CXX20
+    template <class _KeyTy>
+        requires _Traits::_Has_transparent_overloads
+    _NODISCARD pair<iterator, iterator> equal_range(const _KeyTy& _Keyval) {
+        const auto _Result = _Equal_range(_Keyval, _Traitsobj(_Keyval));
+        return {_List._Make_iter(_Result._First._Ptr), _List._Make_iter(_Result._Last._Ptr)};
+    }
+#endif // _HAS_CXX20
+
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Keyval) const {
+        const auto _Result = _Equal_range(_Keyval, _Traitsobj(_Keyval));
+        return {_List._Make_const_iter(_Result._First._Ptr), _List._Make_const_iter(_Result._Last._Ptr)};
+    }
+
+#if _HAS_CXX20
+    template <class _KeyTy>
+        requires _Traits::_Has_transparent_overloads
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _KeyTy& _Keyval) const {
+        const auto _Result = _Equal_range(_Keyval, _Traitsobj(_Keyval));
+        return {_List._Make_const_iter(_Result._First._Ptr), _List._Make_const_iter(_Result._Last._Ptr)};
+    }
+#endif // _HAS_CXX20
+
+    void swap(_Hash& _Right) noexcept(noexcept(_Traitsobj.swap(_Right._Traitsobj))) /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Traitsobj.swap(_Right._Traitsobj);
+            _Pocs(_List._Getal(), _Right._List._Getal());
+            _Pocs(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
+            _Swap_val(_Right);
+        }
+    }
+
+#if _HAS_CXX17
+    using node_type = typename _Traits::node_type;
+
+    node_type extract(const const_iterator _Where) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _List_data = _STD addressof(_List._Mypair._Myval2);
+        _STL_VERIFY(_Where._Getcont() == _List_data, "extract mismatched container");
+        _STL_VERIFY(_Where._Ptr != _List_data->_Myhead, "cannot extract end()");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return node_type::_Make(_Extract(_Where._Unwrapped()), _List._Getal());
+    }
+
+    node_type extract(const key_type& _Keyval) {
+        const auto _Ptr = _Extract(_Keyval);
+        if (!_Ptr) {
+            return node_type{};
+        }
+
+        return node_type::_Make(_Ptr, _List._Getal());
+    }
+
+#if _HAS_CXX23
+    template <class _Kx>
+        requires (_Traits::template _Supports_transparency<_Hash, _Kx>)
+    node_type extract(_Kx&& _Keyval) {
+        const auto _Ptr = _Extract(_Keyval);
+        if (!_Ptr) {
+            return node_type{};
+        }
+
+        return node_type::_Make(_Ptr, _List._Getal());
+    }
+#endif // _HAS_CXX23
+
+    iterator insert(const_iterator _Hint, node_type&& _Handle) {
+        if (_Handle.empty()) {
+            return end();
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_List.get_allocator() == _Handle._Getal(), "node handle allocator incompatible for insert");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto& _Keyval   = _Traits::_Kfn(_Handle._Getptr()->_Myval);
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        auto _Target          = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+        if constexpr (!_Traits::_Multi) {
+            if (_Target._Duplicate) {
+                return _List._Make_iter(_Target._Duplicate);
+            }
+        }
+
+        _Check_max_size();
+        if (_Check_rehash_required_1()) {
+            _Rehash_for_1();
+            _Target = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
+        }
+
+        const auto _Released = _Handle._Release();
+        _Destroy_in_place(_Released->_Next); // TRANSITION, ABI
+        _Destroy_in_place(_Released->_Prev);
+        return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Released));
+    }
+
+    template <class>
+    friend class _Hash;
+
+    template <class _Other_traits>
+    void merge(_Hash<_Other_traits>& _That) { // transfer all nodes from _That into *this
+        static_assert(is_same_v<_Nodeptr, typename _Hash<_Other_traits>::_Nodeptr>,
+            "merge() requires an argument with a compatible node type.");
+
+        static_assert(is_same_v<allocator_type, typename _Hash<_Other_traits>::allocator_type>,
+            "merge() requires an argument with the same allocator type.");
+
+        if constexpr (is_same_v<_Hash, _Hash<_Other_traits>>) {
+            if (this == _STD addressof(_That)) {
+                return;
+            }
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            _STL_VERIFY(_List._Getal() == _That._List._Getal(), "allocator incompatible for merge");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        auto _First      = _That._Unchecked_begin();
+        const auto _Last = _That._Unchecked_end();
+        while (_First != _Last) {
+            const auto _Candidate = _First._Ptr;
+            ++_First;
+            const auto& _Keyval   = _Traits::_Kfn(_Candidate->_Myval);
+            const size_t _Hashval = _Traitsobj(_Keyval);
+            auto _Target          = _Find_last(_Keyval, _Hashval);
+            if constexpr (!_Traits::_Multi) {
+                if (_Target._Duplicate) {
+                    continue;
+                }
+            }
+
+            _Check_max_size();
+            if (_Check_rehash_required_1()) {
+                _Rehash_for_1();
+                _Target = _Find_last(_Keyval, _Hashval);
+            }
+
+            // nothrow hereafter this iteration
+            const auto _Source_bucket = _Hashval & _That._Mask;
+            _That._Erase_bucket(_Candidate, _Source_bucket);
+            _Candidate->_Prev->_Next = _Candidate->_Next;
+            _Candidate->_Next->_Prev = _Candidate->_Prev;
+            --_That._List._Mypair._Myval2._Mysize;
+            _Destroy_in_place(_Candidate->_Next); // TRANSITION, ABI
+            _Destroy_in_place(_Candidate->_Prev);
+#if _ITERATOR_DEBUG_LEVEL == 2
+            _List._Mypair._Myval2._Adopt_unique(_That._List._Mypair._Myval2, _Candidate);
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+            (void) _Insert_new_node_before(_Hashval, _Target._Insert_before, _Candidate);
+        }
+    }
+
+    template <class _Other_traits>
+    void merge(_Hash<_Other_traits>&& _That) { // transfer all nodes from _That into *this
+        static_assert(is_same_v<_Nodeptr, typename _Hash<_Other_traits>::_Nodeptr>,
+            "merge() requires an argument with a compatible node type.");
+
+        static_assert(is_same_v<allocator_type, typename _Hash<_Other_traits>::allocator_type>,
+            "merge() requires an argument with the same allocator type.");
+
+        merge(_That);
+    }
+
+protected:
+    _Nodeptr _Extract(const _Unchecked_const_iterator _Where) {
+        const size_type _Bucket = bucket(_Traits::_Kfn(*_Where));
+        _Erase_bucket(_Where._Ptr, _Bucket);
+        return _List._Mypair._Myval2._Unlinknode(_Where._Ptr);
+    }
+
+    template <class _Kx>
+    _Nodeptr _Extract(const _Kx& _Keyval) {
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        _Nodeptr _Target;
+        if constexpr (_Traits::_Multi) {
+            _Target = _Find_first(_Keyval, _Hashval);
+            if (_Target == _List._Mypair._Myval2._Myhead) {
+                return _Nodeptr{};
+            }
+        } else {
+            _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
+            if (_Target == nullptr) {
+                return _Nodeptr{};
+            }
+        }
+
+        _Erase_bucket(_Target, _Hashval & _Mask);
+        return _List._Mypair._Myval2._Unlinknode(_Target);
+    }
+
+public:
+    conditional_t<_Traits::_Multi, iterator, _Insert_return_type<iterator, node_type>> insert(node_type&& _Handle) {
+        // insert the node (if any) held in _Handle
+        if (_Handle.empty()) {
+            if constexpr (_Traits::_Multi) {
+                return end();
+            } else {
+                return {end(), false, _STD move(_Handle)};
+            }
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_List.get_allocator() == _Handle._Getal(), "node handle allocator incompatible for insert");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto& _Keyval   = _Traits::_Kfn(_Handle._Getptr()->_Myval);
+        const size_t _Hashval = _Traitsobj(_Keyval);
+        auto _Target          = _Find_last(_Keyval, _Hashval);
+        if constexpr (!_Traits::_Multi) {
+            if (_Target._Duplicate) {
+                return {_List._Make_iter(_Target._Duplicate), false, _STD move(_Handle)};
+            }
+        }
+
+        _Check_max_size();
+        if (_Check_rehash_required_1()) {
+            _Rehash_for_1();
+            _Target = _Find_last(_Keyval, _Hashval);
+        }
+
+        const auto _Released = _Handle._Release();
+        _Destroy_in_place(_Released->_Next); // TRANSITION, ABI
+        _Destroy_in_place(_Released->_Prev);
+        const auto _Newnode = _Insert_new_node_before(_Hashval, _Target._Insert_before, _Released);
+        if constexpr (_Traits::_Multi) {
+            return _List._Make_iter(_Newnode);
+        } else {
+            return {_List._Make_iter(_Newnode), true, node_type{}};
+        }
+    }
+#endif // _HAS_CXX17
+
+protected:
+    template <class _Keyty>
+    _NODISCARD _Hash_find_last_result<_Nodeptr> _Find_last(const _Keyty& _Keyval, const size_t _Hashval) const {
+        // find the insertion point for _Keyval and whether an element identical to _Keyval is already in the container
+        const size_type _Bucket = _Hashval & _Mask;
+        _Nodeptr _Where         = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        const _Nodeptr _End     = _List._Mypair._Myval2._Myhead;
+        if (_Where == _End) {
+            return {_End, _Nodeptr{}};
+        }
+
+        const _Nodeptr _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
+        for (;;) {
+            // Search backwards for historical reasons
+            if (!_Traitsobj(_Keyval, _Traits::_Kfn(_Where->_Myval))) {
+                return {_Where->_Next, _Where};
+            }
+
+            if (_Where == _Bucket_lo) {
+                return {_Where, _Nodeptr{}};
+            }
+
+            _Where = _Where->_Prev;
+        }
+    }
+
+    template <class _Keyty>
+    _NODISCARD _Hash_find_last_result<_Nodeptr> _Find_hint(
+        const _Nodeptr _Hint, const _Keyty& _Keyval, const size_t _Hashval) const {
+        // if _Hint points to an element equivalent to _Keyval, returns _Hint; otherwise,
+        // returns _Find_last(_Keyval, _Hashval)
+        if (_Hint != _List._Mypair._Myval2._Myhead && !_Traitsobj(_Traits::_Kfn(_Hint->_Myval), _Keyval)) {
+            return {_Hint->_Next, _Hint};
+        }
+
+        return _Find_last(_Keyval, _Hashval);
+    }
+
+    _Nodeptr _Insert_new_node_before(
+        const size_t _Hashval, const _Nodeptr _Insert_before, const _Nodeptr _Newnode) noexcept {
+        const _Nodeptr _Insert_after = _Insert_before->_Prev;
+        ++_List._Mypair._Myval2._Mysize;
+        _Construct_in_place(_Newnode->_Next, _Insert_before);
+        _Construct_in_place(_Newnode->_Prev, _Insert_after);
+        _Insert_after->_Next  = _Newnode;
+        _Insert_before->_Prev = _Newnode;
+
+        const auto _Head                = _List._Mypair._Myval2._Myhead;
+        const auto _Bucket_array        = _Vec._Mypair._Myval2._Myfirst;
+        const size_type _Bucket         = _Hashval & _Mask;
+        _Unchecked_iterator& _Bucket_lo = _Bucket_array[_Bucket << 1];
+        _Unchecked_iterator& _Bucket_hi = _Bucket_array[(_Bucket << 1) + 1];
+        if (_Bucket_lo._Ptr == _Head) {
+            // bucket is empty, set both
+            _Bucket_lo._Ptr = _Newnode;
+            _Bucket_hi._Ptr = _Newnode;
+        } else if (_Bucket_lo._Ptr == _Insert_before) {
+            // new node is the lowest element in the bucket
+            _Bucket_lo._Ptr = _Newnode;
+        } else if (_Bucket_hi._Ptr == _Insert_after) {
+            // new node is the highest element in the bucket
+            _Bucket_hi._Ptr = _Newnode;
+        }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+        return _Newnode;
+    }
+
+    void _Check_max_size() const {
+        const size_type _Oldsize = _List._Mypair._Myval2._Mysize;
+        if (_Oldsize == _List.max_size()) {
+            _Xlength_error("unordered_map/set too long");
+        }
+    }
+
+    bool _Check_rehash_required_1() const noexcept {
+        const size_type _Oldsize = _List._Mypair._Myval2._Mysize;
+        const auto _Newsize      = _Oldsize + 1;
+        return max_load_factor() < static_cast<float>(_Newsize) / static_cast<float>(bucket_count());
+    }
+
+    void _Rehash_for_1() {
+        const auto _Oldsize = _List._Mypair._Myval2._Mysize;
+        const auto _Newsize = _Oldsize + 1;
+        _Forced_rehash(_Desired_grow_bucket_count(_Newsize));
+    }
+
+    void _Erase_bucket(_Nodeptr _Plist, size_type _Bucket) noexcept {
+        // remove the node _Plist from its bucket
+        _Nodeptr& _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
+        _Nodeptr& _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
+        if (_Bucket_hi == _Plist) {
+            if (_Bucket_lo == _Plist) { // make bucket empty
+                const auto _End = _List._Mypair._Myval2._Myhead;
+
+                _Bucket_lo = _End;
+                _Bucket_hi = _End;
+            } else {
+                _Bucket_hi = _Plist->_Prev; // move end back one element
+            }
+        } else if (_Bucket_lo == _Plist) {
+            _Bucket_lo = _Plist->_Next; // move beginning up one element
+        }
+    }
+
+    _NODISCARD size_type _Min_load_factor_buckets(const size_type _For_size) const noexcept {
+        // returns the minimum number of buckets necessary for the elements in _List
+        return static_cast<size_type>(_CSTD ceilf(static_cast<float>(_For_size) / max_load_factor()));
+    }
+
+    _NODISCARD size_type _Desired_grow_bucket_count(const size_type _For_size) const noexcept {
+        const size_type _Old_buckets = bucket_count();
+        const size_type _Req_buckets = (_STD max) (_Min_buckets, _Min_load_factor_buckets(_For_size));
+        if (_Old_buckets >= _Req_buckets) {
+            // we already have enough buckets so there's no need to change the count
+            return _Old_buckets;
+        }
+
+        if (_Old_buckets < 512 && _Old_buckets * 8 >= _Req_buckets) {
+            // if we are changing the bucket count and have less than 512 buckets, use 8x more buckets
+            return _Old_buckets * 8;
+        }
+
+        // power of 2 invariant means this will result in at least 2*_Old_buckets after round up in _Forced_rehash
+        return _Req_buckets;
+    }
+
+    void _Reinsert_with_invalid_vec() { // insert elements in [begin(), end()), distrusting existing _Vec elements
+        _Forced_rehash(_Desired_grow_bucket_count(_List.size()));
+    }
+
+    void _Forced_rehash(size_type _Buckets) {
+        // Force rehash of elements in _List, distrusting existing bucket assignments in _Vec.
+        // Assumes _Buckets is greater than _Min_buckets, and that changing to that many buckets doesn't violate
+        // load_factor() <= max_load_factor().
+
+        // Don't violate power of 2, fits in half the bucket vector invariant:
+        // (we assume because vector must use single allocations; as a result, its max_size fits in a size_t)
+        const unsigned long _Max_storage_buckets_log2 = _Floor_of_log_2(static_cast<size_t>(_Vec.max_size() >> 1));
+        const auto _Max_storage_buckets               = static_cast<size_type>(1) << _Max_storage_buckets_log2;
+        if (_Buckets > _Max_storage_buckets) {
+            _Xlength_error("invalid hash bucket count");
+        }
+
+        // The above test also means that we won't perform a forbidden full shift when restoring the power of
+        // 2 invariant
+        // this round up to power of 2 in addition to the _Buckets > _Maxidx above means
+        // we'll at least double in size (the next power of 2 above _Maxidx)
+        _Buckets                       = static_cast<size_type>(1) << _Ceiling_of_log_2(static_cast<size_t>(_Buckets));
+        const _Unchecked_iterator _End = _Unchecked_end();
+
+        _Vec._Assign_grow(_Buckets << 1, _End);
+        _Mask   = _Buckets - 1;
+        _Maxidx = _Buckets;
+
+        _Clear_guard<_Hash> _Guard{this};
+
+        _Unchecked_iterator _Inserted = _Unchecked_begin();
+
+        // Remember the next _Inserted value as splices will change _Inserted's position arbitrarily.
+        for (_Unchecked_iterator _Next_inserted = _Inserted; _Inserted != _End; _Inserted = _Next_inserted) {
+            ++_Next_inserted;
+
+            auto& _Inserted_key     = _Traits::_Kfn(*_Inserted);
+            const size_type _Bucket = bucket(_Inserted_key);
+
+            // _Bucket_lo and _Bucket_hi are the *inclusive* range of elements in the bucket, or _Unchecked_end() if
+            // the bucket is empty.
+            _Unchecked_iterator& _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+            _Unchecked_iterator& _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
+
+            if (_Bucket_lo == _End) {
+                // The bucket was empty, set it to the inserted element.
+                _Bucket_lo = _Inserted;
+                _Bucket_hi = _Inserted;
+                continue;
+            }
+
+            // Search the bucket for the insertion location and move element if necessary.
+            _Unchecked_const_iterator _Insert_before = _Bucket_hi;
+            if (!_Traitsobj(_Inserted_key, _Traits::_Kfn(*_Insert_before))) {
+                // The inserted element belongs at the end of the bucket; splice it there and set _Bucket_hi to the
+                // new bucket inclusive end.
+                ++_Insert_before;
+                if (_Insert_before != _Inserted) { // avoid splice on element already in position
+                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
+                }
+
+                _Bucket_hi = _Inserted;
+                continue;
+            }
+
+            // The insertion point isn't *_Bucket_hi, so search [_Bucket_lo, _Bucket_hi) for insertion point; we
+            // go backwards for historical reasons.
+            for (;;) {
+                if (_Bucket_lo == _Insert_before) {
+                    // There are no equivalent keys in the bucket, so insert it at the beginning.
+                    // Element can't be already in position here because _Inserted_key != *_Insert_before
+                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
+                    _Bucket_lo = _Inserted;
+                    break;
+                }
+
+                if (!_Traitsobj(_Inserted_key, _Traits::_Kfn(*--_Insert_before))) {
+                    // Found insertion point, move the element here, bucket bounds are already okay.
+                    ++_Insert_before;
+                    // Element can't be already in position here because all elements we're inserting are after all
+                    // the elements already in buckets, and *_Insert_before isn't the highest element in the bucket.
+                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
+                    break;
+                }
+            }
+        }
+
+        _Guard._Target = nullptr;
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+        _Stl_internal_check_container_invariants();
+#endif // _ENABLE_STL_INTERNAL_CHECK
+    }
+
+    float& _Max_bucket_size() noexcept {
+        return _Traitsobj._Get_max_bucket_size();
+    }
+
+    const float& _Max_bucket_size() const noexcept {
+        return _Traitsobj._Get_max_bucket_size();
+    }
+
+    _Alnode& _Getal() noexcept {
+        return _List._Getal();
+    }
+
+    const _Alnode& _Getal() const noexcept {
+        return _List._Getal();
+    }
+
+    struct _Multi_equal_check_result {
+        bool _Equal_possible = false;
+        _Unchecked_const_iterator _Subsequent_first{}; // only useful if _Equal_possible
+    };
+
+    _NODISCARD _Multi_equal_check_result _Multi_equal_check_equal_range(
+        const _Hash& _Right, _Unchecked_const_iterator _First1) const {
+        // check that an equal_range of elements starting with *_First1 are a permutation of the corresponding
+        // equal_range of elements in _Right
+        auto& _Keyval = _Traits::_Kfn(*_First1);
+        // find the start of the matching run in the other container
+        const size_t _Hashval   = _Right._Traitsobj(_Keyval);
+        const size_type _Bucket = _Hashval & _Right._Mask;
+        auto _First2            = _Right._Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+        if (_First2 == _Right._Unchecked_end()) {
+            // no matching bucket, therefore no matching run
+            return {};
+        }
+
+        const auto _Bucket_hi = _Right._Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
+        for (; _Right._Traitsobj(_Traits::_Kfn(*_First2), _Keyval); ++_First2) {
+            // find first matching element in _Right
+            if (_First2 == _Bucket_hi) {
+                return {};
+            }
+        }
+
+        _Unchecked_const_iterator _Left_stop_at = _Unchecked_end();
+
+        // trim matching prefixes
+        while (*_First1 == *_First2) {
+            // the right equal_range ends at the end of the bucket or on the first nonequal element
+            bool _Right_range_end = _First2 == _Bucket_hi;
+            ++_First2;
+            if (!_Right_range_end) {
+                _Right_range_end = _Right._Traitsobj(_Keyval, _Traits::_Kfn(*_First2));
+            }
+
+            // the left equal_range ends at the end of the container or on the first nonequal element
+            ++_First1;
+            const bool _Left_range_end = _First1 == _Left_stop_at || _Traitsobj(_Keyval, _Traits::_Kfn(*_First1));
+
+            if (_Left_range_end && _Right_range_end) {
+                // the equal_ranges were completely equal
+                return {true, _First1};
+            }
+
+            if (_Left_range_end || _Right_range_end) {
+                // one equal_range is a prefix of the other; not equal
+                return {};
+            }
+        }
+
+        // found a mismatched element, find the end of the equal_ranges and dispatch to _Check_match_counts
+        auto _Last1 = _First1;
+        auto _Last2 = _First2;
+        for (;;) {
+            bool _Right_range_end = _Last2 == _Bucket_hi;
+            ++_Last2;
+            if (!_Right_range_end) {
+                _Right_range_end = _Right._Traitsobj(_Keyval, _Traits::_Kfn(*_Last2));
+            }
+
+            ++_Last1;
+            const bool _Left_range_end = _Last1 == _Left_stop_at || _Traitsobj(_Keyval, _Traits::_Kfn(*_Last1));
+
+            if (_Left_range_end && _Right_range_end) {
+                // equal_ranges had the same length, check for permutation
+                return {_Check_match_counts(_First1, _Last1, _First2, _Last2, equal_to<>{}), _Last1};
+            }
+
+            if (_Left_range_end || _Right_range_end) {
+                // different number of elements in the range, not a permutation
+                return {};
+            }
+        }
+    }
+
+    template <bool _Multi2 = _Traits::_Multi, enable_if_t<_Multi2, int> = 0>
+    _NODISCARD bool _Multi_equal(const _Hash& _Right) const {
+        static_assert(_Traits::_Multi, "This function only works with multi containers");
+        _STL_INTERNAL_CHECK(this->size() == _Right.size());
+        const auto _Last1 = _Unchecked_end();
+        auto _First1      = _Unchecked_begin();
+        while (_First1 != _Last1) {
+            const auto _Result = _Multi_equal_check_equal_range(_Right, _First1);
+            if (!_Result._Equal_possible) {
+                return false;
+            }
+
+            _First1 = _Result._Subsequent_first;
+        }
+
+        return true;
+    }
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+public:
+    void _Stl_internal_check_container_invariants() const noexcept {
+        const size_type _Vecsize = _Vec.size();
+        _STL_INTERNAL_CHECK(_Vec._Mypair._Myval2._Mylast == _Vec._Mypair._Myval2._Myend);
+        _STL_INTERNAL_CHECK(_Vecsize >= _Min_buckets * 2);
+        _STL_INTERNAL_CHECK(_Maxidx == (_Vecsize >> 1));
+        _STL_INTERNAL_CHECK(_Maxidx - 1 == _Mask);
+        _STL_INTERNAL_CHECK(_Maxidx >= _Min_load_factor_buckets(_List.size()));
+        // asserts that bucket count is a power of 2:
+        _STL_INTERNAL_CHECK((static_cast<size_type>(1) << _Floor_of_log_2(_Vecsize)) == _Vecsize);
+        _STL_INTERNAL_CHECK(load_factor() <= max_load_factor());
+        // In the test that counts number of allocator copies, avoid an extra rebind that would incorrectly count as
+        // a copy; otherwise, allow allocators that support only homogeneous compare.
+#ifdef _USE_HETEROGENEOUS_ALLOCATOR_COMPARE_IN_INTERNAL_CHECK
+        _STL_INTERNAL_CHECK(_List._Getal() == _Vec._Mypair._Get_first());
+#else
+        _STL_INTERNAL_CHECK(static_cast<_Aliter>(_List._Getal()) == _Vec._Mypair._Get_first());
+#endif
+#ifdef _STL_INTERNAL_CHECK_EXHAUSTIVE
+        size_type _Elements = 0;
+        const auto _End     = _Unchecked_end();
+        for (size_type _Bucket = 0; _Bucket < _Maxidx; ++_Bucket) {
+            _Unchecked_const_iterator _Where           = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
+            const _Unchecked_const_iterator _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
+            if (_Where != _End) {
+                // check that all the elements in the bucket belong in the bucket:
+                for (;;) {
+                    ++_Elements;
+                    _STL_INTERNAL_CHECK(bucket(_Traits::_Kfn(*_Where)) == _Bucket);
+                    if (_Where == _Bucket_hi) {
+                        break;
+                    }
+
+                    ++_Where;
+                }
+            }
+        }
+
+        _STL_INTERNAL_CHECK(_List.size() == _Elements);
+#endif // _STL_INTERNAL_CHECK_EXHAUSTIVE
+    }
+
+protected:
+#endif // _ENABLE_STL_INTERNAL_CHECK
+
+    _Traits _Traitsobj; // traits to customize behavior
+    _Mylist _List; // list of elements, must initialize before _Vec
+    _Hash_vec<_Aliter> _Vec; // "vector" of list iterators for buckets:
+                             // each bucket is 2 iterators denoting the closed range of elements in the bucket,
+                             // or both iterators set to _Unchecked_end() if the bucket is empty.
+    size_type _Mask; // the key mask
+    size_type _Maxidx; // current maximum key value, must be a power of 2
+};
+
+#if _HAS_CXX17
+// For constraining deduction guides (N4981 [unord.req.general]/248.3)
+#if _HAS_CXX23
+template <class _Hasher>
+concept _Hasher_for_container = !integral<_Hasher> && _Not_allocator_for_container<_Hasher>;
+
+template <class _Hasher>
+using _Is_hasher = bool_constant<_Hasher_for_container<_Hasher>>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class _Hasher>
+using _Is_hasher = negation<disjunction<is_integral<_Hasher>, _Is_allocator<_Hasher>>>;
+#endif // ^^^ !_HAS_CXX23 ^^^
+#endif // _HAS_CXX17
+
+template <class _Traits>
+_NODISCARD bool _Hash_equal(const _Hash<_Traits>& _Left, const _Hash<_Traits>& _Right) {
+    if (_Left.size() != _Right.size()) {
+        return false;
+    }
+
+    if constexpr (_Traits::_Multi) {
+        return _Left._Multi_equal(_Right);
+    } else {
+        for (const auto& _LVal : _Left) {
+            // look for element with equivalent key
+            const auto& _Keyval = _Traits::_Kfn(_LVal);
+            const auto _Next2   = _Right._Find_last(_Keyval, _Right._Traitsobj(_Keyval))._Duplicate;
+            if (!(static_cast<bool>(_Next2) && _LVal == _Next2->_Myval)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XHASH_
diff --git a/msvc-stl/stl/inc/xiosbase b/msvc-stl/stl/inc/xiosbase
new file mode 100644
index 0000000..0d90857
--- /dev/null
+++ b/msvc-stl/stl/inc/xiosbase
@@ -0,0 +1,474 @@
+// xiosbase internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XIOSBASE_
+#define _XIOSBASE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <share.h>
+#include <system_error>
+#include <xlocale>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Dummy>
+class _Iosb { // define templatized bitmask types, instantiate on demand
+public:
+    // constants for formatting options
+    static constexpr int _Fmtmask = 0xffff;
+    static constexpr int _Fmtzero = 0;
+
+    static constexpr int skipws     = 0x0001;
+    static constexpr int unitbuf    = 0x0002;
+    static constexpr int uppercase  = 0x0004;
+    static constexpr int showbase   = 0x0008;
+    static constexpr int showpoint  = 0x0010;
+    static constexpr int showpos    = 0x0020;
+    static constexpr int left       = 0x0040;
+    static constexpr int right      = 0x0080;
+    static constexpr int internal   = 0x0100;
+    static constexpr int dec        = 0x0200;
+    static constexpr int oct        = 0x0400;
+    static constexpr int hex        = 0x0800;
+    static constexpr int scientific = 0x1000;
+    static constexpr int fixed      = 0x2000;
+
+    static constexpr int boolalpha   = 0x4000;
+    static constexpr int adjustfield = left | right | internal;
+    static constexpr int basefield   = dec | oct | hex;
+    static constexpr int floatfield  = scientific | fixed;
+
+    // constants for stream states
+    static constexpr int _Statmask = 0x17;
+
+    static constexpr int goodbit = 0x0;
+    static constexpr int eofbit  = 0x1;
+    static constexpr int failbit = 0x2;
+    static constexpr int badbit  = 0x4;
+
+    static constexpr int in         = 0x01;
+    static constexpr int out        = 0x02;
+    static constexpr int ate        = 0x04;
+    static constexpr int app        = 0x08;
+    static constexpr int trunc      = 0x10;
+    static constexpr int binary     = 0x20;
+    static constexpr int _Nocreate  = 0x40;
+    static constexpr int _Noreplace = 0x80;
+#if _HAS_CXX23
+    static constexpr int noreplace = _Noreplace;
+#endif
+
+    static constexpr int beg = 0;
+    static constexpr int cur = 1;
+    static constexpr int end = 2;
+
+    static constexpr int _Default_open_prot = _SH_DENYNO; // constant for default file opening protection
+};
+
+_EXPORT_STD extern "C++" class _CRTIMP2_PURE_IMPORT ios_base : public _Iosb<int> { // base class for ios
+public:
+    using fmtflags = int;
+    using iostate  = int;
+    using openmode = int;
+    using seekdir  = int;
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    using streamoff = _STD streamoff;
+    using streampos = _STD streampos;
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    enum event { // constants for ios events
+        erase_event,
+        imbue_event,
+        copyfmt_event
+    };
+
+    using event_callback = void(__CLRCALL_OR_CDECL*)(event, ios_base&, int);
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    using io_state  = unsigned int;
+    using open_mode = unsigned int;
+    using seek_dir  = unsigned int;
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    class _NODISCARD failure : public system_error { // base of all iostreams exceptions
+    public:
+        explicit failure(const string& _Message, const error_code& _Errcode = _STD make_error_code(io_errc::stream))
+            : system_error(_Errcode, _Message) {} // construct with message
+
+        explicit failure(const char* _Message, const error_code& _Errcode = _STD make_error_code(io_errc::stream))
+            : system_error(_Errcode, _Message) {} // construct with message
+
+#if !_HAS_EXCEPTIONS
+    protected:
+        void _Doraise() const override { // report the exception
+            _RAISE(*this);
+        }
+#endif // !_HAS_EXCEPTIONS
+    };
+
+    class _CRTIMP2_PURE_IMPORT Init { // controller for standard-stream initialization
+    public:
+        __CLR_OR_THIS_CALL Init() { // initialize standard streams on first construction
+            _Init_ctor(this);
+        }
+
+        __CLR_OR_THIS_CALL ~Init() noexcept { // flush standard streams on last destruction
+            _Init_dtor(this);
+        }
+
+    private:
+        static void __cdecl _Init_ctor(Init*);
+        static void __cdecl _Init_dtor(Init*);
+
+        __PURE_APPDOMAIN_GLOBAL static int _Init_cnt; // net ctor count
+
+        static int& __cdecl _Init_cnt_func();
+    };
+
+    explicit __CLR_OR_THIS_CALL operator bool() const noexcept /* strengthened */ {
+        return !fail();
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL operator!() const noexcept /* strengthened */ {
+        return fail();
+    }
+
+    void __CLR_OR_THIS_CALL clear(iostate _State, bool _Reraise) { // set state, possibly reraise exception
+        _State &= _Statmask;
+        _Mystate             = _State;
+        const auto _Filtered = _State & _Except;
+        if (_Filtered) {
+            if (_Reraise) {
+                _RERAISE;
+            }
+
+            const char* _Msg;
+            if (_Filtered & ios_base::badbit) {
+                _Msg = "ios_base::badbit set";
+            } else if (_Filtered & ios_base::failbit) {
+                _Msg = "ios_base::failbit set";
+            } else {
+                _Msg = "ios_base::eofbit set";
+            }
+
+            _THROW(failure(_Msg));
+        }
+    }
+
+    void __CLR_OR_THIS_CALL clear(iostate _State = goodbit) { // set state to argument
+        clear(_State, false);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL clear(io_state _State) { // set state to argument, old-style
+        clear(static_cast<iostate>(_State));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    _NODISCARD iostate __CLR_OR_THIS_CALL rdstate() const noexcept /* strengthened */ {
+        return _Mystate;
+    }
+
+    void __CLR_OR_THIS_CALL setstate(
+        iostate _State, bool _Exreraise) { // merge in state argument, possibly reraise exception
+        clear(rdstate() | _State, _Exreraise);
+    }
+
+    void __CLR_OR_THIS_CALL setstate(iostate _State) { // merge in state argument
+        clear(rdstate() | _State, false);
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL setstate(io_state _State) { // merge in state argument, old style
+        setstate(static_cast<iostate>(_State));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    _NODISCARD bool __CLR_OR_THIS_CALL good() const noexcept /* strengthened */ {
+        return rdstate() == ios_base::goodbit;
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL eof() const noexcept /* strengthened */ {
+        return rdstate() & ios_base::eofbit;
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL fail() const noexcept /* strengthened */ {
+        return rdstate() & (ios_base::badbit | ios_base::failbit);
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL bad() const noexcept /* strengthened */ {
+        return rdstate() & ios_base::badbit;
+    }
+
+    _NODISCARD iostate __CLR_OR_THIS_CALL exceptions() const noexcept /* strengthened */ {
+        return _Except;
+    }
+
+    void __CLR_OR_THIS_CALL exceptions(iostate _Newexcept) { // set exception mask to argument
+        _Except = _Newexcept & _Statmask;
+        clear(rdstate());
+    }
+
+#if _HAS_OLD_IOSTREAMS_MEMBERS
+    void __CLR_OR_THIS_CALL exceptions(io_state _State) { // set exception mask to argument, old style
+        exceptions(static_cast<iostate>(_State));
+    }
+#endif // _HAS_OLD_IOSTREAMS_MEMBERS
+
+    _NODISCARD fmtflags __CLR_OR_THIS_CALL flags() const noexcept /* strengthened */ {
+        return _Fmtfl;
+    }
+
+    fmtflags __CLR_OR_THIS_CALL flags(fmtflags _Newfmtflags) noexcept /* strengthened */ {
+        // set format flags to argument
+        const fmtflags _Oldfmtflags = _Fmtfl;
+        _Fmtfl                      = _Newfmtflags & _Fmtmask;
+        return _Oldfmtflags;
+    }
+
+    fmtflags __CLR_OR_THIS_CALL setf(fmtflags _Newfmtflags) noexcept /* strengthened */ {
+        // merge in format flags argument
+        const ios_base::fmtflags _Oldfmtflags = _Fmtfl;
+        _Fmtfl |= _Newfmtflags & _Fmtmask;
+        return _Oldfmtflags;
+    }
+
+    fmtflags __CLR_OR_THIS_CALL setf(fmtflags _Newfmtflags, fmtflags _Mask) noexcept /* strengthened */ {
+        // merge in format flags argument under mask argument
+        const ios_base::fmtflags _Oldfmtflags = _Fmtfl;
+        _Fmtfl                                = (_Oldfmtflags & ~_Mask) | (_Newfmtflags & _Mask & _Fmtmask);
+        return _Oldfmtflags;
+    }
+
+    void __CLR_OR_THIS_CALL unsetf(fmtflags _Mask) noexcept /* strengthened */ {
+        // clear format flags under mask argument
+        _Fmtfl &= ~_Mask;
+    }
+
+    _NODISCARD streamsize __CLR_OR_THIS_CALL precision() const noexcept /* strengthened */ {
+        return _Prec;
+    }
+
+    streamsize __CLR_OR_THIS_CALL precision(streamsize _Newprecision) noexcept /* strengthened */ {
+        // set precision to argument
+        const streamsize _Oldprecision = _Prec;
+        _Prec                          = _Newprecision;
+        return _Oldprecision;
+    }
+
+    _NODISCARD streamsize __CLR_OR_THIS_CALL width() const noexcept /* strengthened */ {
+        return _Wide;
+    }
+
+    streamsize __CLR_OR_THIS_CALL width(streamsize _Newwidth) noexcept /* strengthened */ {
+        // set width to argument
+        const streamsize _Oldwidth = _Wide;
+        _Wide                      = _Newwidth;
+        return _Oldwidth;
+    }
+
+    _NODISCARD locale __CLR_OR_THIS_CALL getloc() const noexcept /* strengthened */ { // get locale
+        return *_Ploc;
+    }
+
+    locale __CLR_OR_THIS_CALL imbue(const locale& _Loc) { // set locale to argument
+        locale _Oldlocale = *_Ploc;
+        *_Ploc            = _Loc;
+        _Callfns(imbue_event);
+        return _Oldlocale;
+    }
+
+    _NODISCARD static int __CLRCALL_OR_CDECL xalloc() { // allocate new iword/pword index
+        _BEGIN_LOCK(_LOCK_STREAM) // lock thread to ensure atomicity
+        return _Index++;
+        _END_LOCK()
+    }
+
+    _NODISCARD long& __CLR_OR_THIS_CALL iword(int _Idx) {
+        return _Findarr(_Idx)._Lo;
+    }
+
+    _NODISCARD void*& __CLR_OR_THIS_CALL pword(int _Idx) {
+        return _Findarr(_Idx)._Vp;
+    }
+
+    void __CLR_OR_THIS_CALL register_callback(event_callback _Pfn, int _Idx) {
+        // register event handler
+        _Calls = new _Fnarray(_Idx, _Pfn, _Calls);
+    }
+
+    ios_base& __CLR_OR_THIS_CALL copyfmt(const ios_base& _Other) { // copy format stuff
+        if (this != _STD addressof(_Other)) { // copy all but _Mystate
+            _Tidy();
+            *_Ploc          = *_Other._Ploc;
+            _Fmtfl          = _Other._Fmtfl;
+            _Prec           = _Other._Prec;
+            _Wide           = _Other._Wide;
+            _Iosarray* _Ptr = _Other._Arr;
+
+            for (_Arr = nullptr; _Ptr; _Ptr = _Ptr->_Next) {
+                if (_Ptr->_Lo != 0 || _Ptr->_Vp) { // copy over nonzero array values
+                    iword(_Ptr->_Index) = _Ptr->_Lo;
+                    pword(_Ptr->_Index) = _Ptr->_Vp;
+                }
+            }
+
+            for (_Fnarray* _Pfa = _Other._Calls; _Pfa; _Pfa = _Pfa->_Next) {
+                register_callback(_Pfa->_Pfn, _Pfa->_Index);
+            }
+
+            _Callfns(copyfmt_event); // call callbacks
+            exceptions(_Other._Except); // cause any throw at end
+        }
+        return *this;
+    }
+
+    static bool __CLRCALL_OR_CDECL sync_with_stdio(bool _Newsync = true) {
+        // set C/C++ synchronization flag from argument
+        _BEGIN_LOCK(_LOCK_STREAM) // lock thread to ensure atomicity
+        const bool _Oldsync = _Sync;
+        _Sync               = _Newsync;
+        return _Oldsync;
+        _END_LOCK()
+    }
+
+    void __CLR_OR_THIS_CALL swap(ios_base& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _STD swap(_Mystate, _Right._Mystate);
+            _STD swap(_Except, _Right._Except);
+            _STD swap(_Fmtfl, _Right._Fmtfl);
+            _STD swap(_Prec, _Right._Prec);
+            _STD swap(_Wide, _Right._Wide);
+
+            _STD swap(_Arr, _Right._Arr);
+            _STD swap(_Calls, _Right._Calls);
+            _STD swap(_Ploc, _Right._Ploc);
+        }
+    }
+
+    virtual __CLR_OR_THIS_CALL ~ios_base() noexcept {
+        _Ios_base_dtor(this);
+    }
+
+    static void __CLRCALL_PURE_OR_CDECL _Addstd(ios_base*); // add standard stream
+
+    size_t _Stdstr{0}; // if > 0 index of standard stream to suppress destruction
+
+protected:
+    __CLR_OR_THIS_CALL ios_base() {}
+
+    void __CLR_OR_THIS_CALL _Init() { // initialize a new ios_base
+        _Ploc   = nullptr;
+        _Stdstr = 0;
+        _Except = goodbit;
+        _Fmtfl  = skipws | dec;
+        _Prec   = 6;
+        _Wide   = 0;
+        _Arr    = nullptr;
+        _Calls  = nullptr;
+        clear(goodbit);
+        _Ploc = new locale;
+    }
+
+private:
+    struct _Iosarray : _Crt_new_delete { // list element for open-ended sparse array of longs/pointers
+    public:
+        __CLR_OR_THIS_CALL _Iosarray(int _Idx, _Iosarray* _Link)
+            : _Next(_Link), _Index(_Idx), _Lo(0), _Vp(nullptr) {} // construct node for index _Idx and link it in
+
+        _Iosarray* _Next; // pointer to next node
+        int _Index; // index of this node
+        long _Lo; // stored long value
+        void* _Vp; // stored pointer value
+    };
+
+    struct _Fnarray : _Crt_new_delete { // list element for open-ended sparse array of event handlers
+        __CLR_OR_THIS_CALL _Fnarray(int _Idx, event_callback _Pnew, _Fnarray* _Link)
+            : _Next(_Link), _Index(_Idx), _Pfn(_Pnew) {} // construct node for index _Idx and link it in
+
+        _Fnarray* _Next; // pointer to next node
+        int _Index; // index of this node
+        event_callback _Pfn; // pointer to event handler
+    };
+
+    void __CLR_OR_THIS_CALL _Callfns(event _Ev) { // call all event handlers, reporting event
+        for (_Fnarray* _Pfa = _Calls; _Pfa; _Pfa = _Pfa->_Next) {
+            (*_Pfa->_Pfn)(_Ev, *this, _Pfa->_Index);
+        }
+    }
+
+    _Iosarray& __CLR_OR_THIS_CALL _Findarr(int _Idx) { // locate or make a variable array element
+        _Iosarray* _Ptr1;
+        _Iosarray* _Ptr2;
+
+        for (_Ptr1 = _Arr, _Ptr2 = nullptr; _Ptr1; _Ptr1 = _Ptr1->_Next) {
+            if (_Ptr1->_Index == _Idx) {
+                return *_Ptr1; // found element, return it
+            } else if (!_Ptr2 && _Ptr1->_Lo == 0 && !_Ptr1->_Vp) {
+                _Ptr2 = _Ptr1; // found recycling candidate
+            }
+        }
+
+        if (_Ptr2) { // recycle existing element
+            _Ptr2->_Index = _Idx;
+            return *_Ptr2;
+        }
+
+        _Arr = new _Iosarray(_Idx, _Arr); // make a new element
+        return *_Arr;
+    }
+
+    void __CLR_OR_THIS_CALL _Tidy() noexcept { // discard storage for an ios_base
+        _Callfns(erase_event);
+        _Iosarray* _Ptr1;
+        _Iosarray* _Ptr2;
+
+        for (_Ptr1 = _Arr; _Ptr1; _Ptr1 = _Ptr2) { // delete array element
+            _Ptr2 = _Ptr1->_Next;
+            delete _Ptr1;
+        }
+        _Arr = nullptr;
+
+        _Fnarray* _Pfa1;
+        _Fnarray* _Pfa2;
+        for (_Pfa1 = _Calls; _Pfa1; _Pfa1 = _Pfa2) { // delete callback element
+            _Pfa2 = _Pfa1->_Next;
+            delete _Pfa1;
+        }
+        _Calls = nullptr;
+    }
+
+    iostate _Mystate{}; // stream state
+    iostate _Except{}; // exception mask
+    fmtflags _Fmtfl{}; // format flags
+    streamsize _Prec{}; // field precision
+    streamsize _Wide{}; // field width
+    _Iosarray* _Arr{nullptr}; // pointer to first node of long/pointer array
+    _Fnarray* _Calls{nullptr}; // pointer to first node of call list
+    locale* _Ploc{nullptr}; // pointer to locale
+
+    __PURE_APPDOMAIN_GLOBAL static int _Index;
+    __PURE_APPDOMAIN_GLOBAL static bool _Sync;
+
+    static void __CLRCALL_PURE_OR_CDECL _Ios_base_dtor(ios_base*);
+
+public:
+    ios_base(const ios_base&)            = delete;
+    ios_base& operator=(const ios_base&) = delete;
+};
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XIOSBASE_
diff --git a/msvc-stl/stl/inc/xkeycheck.h b/msvc-stl/stl/inc/xkeycheck.h
new file mode 100644
index 0000000..96a83a5
--- /dev/null
+++ b/msvc-stl/stl/inc/xkeycheck.h
@@ -0,0 +1,587 @@
+// xkeycheck.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XKEYCHECK_H
+#define _XKEYCHECK_H
+
+// xkeycheck.h assumes that it's being included by yvals_core.h in a specific order.
+// Nothing else should include xkeycheck.h.
+
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !defined(_ALLOW_KEYWORD_MACROS) && !defined(__INTELLISENSE__)
+
+// #if defined($KEYWORD)
+// #define $KEYWORD EMIT WARNING C4005
+// #error The C++ Standard Library forbids macroizing the keyword "$KEYWORD". \
+// Enable warning C4005 to find the forbidden define.
+// #endif // $KEYWORD
+
+// *don't* check the "alternative token representations"
+
+// keywords:
+#if defined(alignas)
+#define alignas EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "alignas". \
+Enable warning C4005 to find the forbidden define.
+#endif // alignas
+
+#if defined(alignof)
+#define alignof EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "alignof". \
+Enable warning C4005 to find the forbidden define.
+#endif // alignof
+
+#if defined(asm)
+#define asm EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "asm". \
+Enable warning C4005 to find the forbidden define.
+#endif // asm
+
+#if defined(auto)
+#define auto EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "auto". \
+Enable warning C4005 to find the forbidden define.
+#endif // auto
+
+#if defined(bool)
+#define bool EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "bool". \
+Enable warning C4005 to find the forbidden define.
+#endif // bool
+
+#if defined(break)
+#define break EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "break". \
+Enable warning C4005 to find the forbidden define.
+#endif // break
+
+#if defined(case)
+#define case EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "case". \
+Enable warning C4005 to find the forbidden define.
+#endif // case
+
+#if defined(catch)
+#define catch EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "catch". \
+Enable warning C4005 to find the forbidden define.
+#endif // catch
+
+#if defined(char)
+#define char EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "char". \
+Enable warning C4005 to find the forbidden define.
+#endif // char
+
+#if defined(char8_t) && _HAS_CXX20
+#define char8_t EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "char8_t". \
+Enable warning C4005 to find the forbidden define.
+#endif // char8_t
+
+#if defined(char16_t)
+#define char16_t EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "char16_t". \
+Enable warning C4005 to find the forbidden define.
+#endif // char16_t
+
+#if defined(char32_t)
+#define char32_t EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "char32_t". \
+Enable warning C4005 to find the forbidden define.
+#endif // char32_t
+
+#if defined(class)
+#define class EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "class". \
+Enable warning C4005 to find the forbidden define.
+#endif // class
+
+#if defined(concept) && _HAS_CXX20
+#define concept EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "concept". \
+Enable warning C4005 to find the forbidden define.
+#endif // concept
+
+#if defined(const)
+#define const EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "const". \
+Enable warning C4005 to find the forbidden define.
+#endif // const
+
+#if defined(consteval) && _HAS_CXX20
+#define consteval EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "consteval". \
+Enable warning C4005 to find the forbidden define.
+#endif // consteval
+
+#if defined(constexpr)
+#define constexpr EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "constexpr". \
+Enable warning C4005 to find the forbidden define.
+#endif // constexpr
+
+#if defined(constinit) && _HAS_CXX20
+#define constinit EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "constinit". \
+Enable warning C4005 to find the forbidden define.
+#endif // constinit
+
+#if defined(const_cast)
+#define const_cast EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "const_cast". \
+Enable warning C4005 to find the forbidden define.
+#endif // const_cast
+
+#if defined(continue)
+#define continue EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "continue". \
+Enable warning C4005 to find the forbidden define.
+#endif // continue
+
+#if defined(co_await) && _HAS_CXX20
+#define co_await EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "co_await". \
+Enable warning C4005 to find the forbidden define.
+#endif // co_await
+
+#if defined(co_return) && _HAS_CXX20
+#define co_return EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "co_return". \
+Enable warning C4005 to find the forbidden define.
+#endif // co_return
+
+#if defined(co_yield) && _HAS_CXX20
+#define co_yield EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "co_yield". \
+Enable warning C4005 to find the forbidden define.
+#endif // co_yield
+
+#if defined(decltype)
+#define decltype EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "decltype". \
+Enable warning C4005 to find the forbidden define.
+#endif // decltype
+
+#if defined(default)
+#define default EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "default". \
+Enable warning C4005 to find the forbidden define.
+#endif // default
+
+#if defined(delete)
+#define delete EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "delete". \
+Enable warning C4005 to find the forbidden define.
+#endif // delete
+
+#if defined(do)
+#define do EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "do". \
+Enable warning C4005 to find the forbidden define.
+#endif // do
+
+#if defined(double)
+#define double EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "double". \
+Enable warning C4005 to find the forbidden define.
+#endif // double
+
+#if defined(dynamic_cast)
+#define dynamic_cast EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "dynamic_cast". \
+Enable warning C4005 to find the forbidden define.
+#endif // dynamic_cast
+
+#if defined(else)
+#define else EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "else". \
+Enable warning C4005 to find the forbidden define.
+#endif // else
+
+#if defined(enum)
+#define enum EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "enum". \
+Enable warning C4005 to find the forbidden define.
+#endif // enum
+
+#if defined(explicit)
+#define explicit EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "explicit". \
+Enable warning C4005 to find the forbidden define.
+#endif // explicit
+
+#if defined(export)
+#define export EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "export". \
+Enable warning C4005 to find the forbidden define.
+#endif // export
+
+#if defined(extern)
+#define extern EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "extern". \
+Enable warning C4005 to find the forbidden define.
+#endif // extern
+
+#if defined(false)
+#define false EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "false". \
+Enable warning C4005 to find the forbidden define.
+#endif // false
+
+#if defined(float)
+#define float EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "float". \
+Enable warning C4005 to find the forbidden define.
+#endif // float
+
+#if defined(for)
+#define for EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "for". \
+Enable warning C4005 to find the forbidden define.
+#endif // for
+
+#if defined(friend)
+#define friend EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "friend". \
+Enable warning C4005 to find the forbidden define.
+#endif // friend
+
+#if defined(goto)
+#define goto EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "goto". \
+Enable warning C4005 to find the forbidden define.
+#endif // goto
+
+#if defined(if)
+#define if EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "if". \
+Enable warning C4005 to find the forbidden define.
+#endif // if
+
+#if defined(inline)
+#define inline EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "inline". \
+Enable warning C4005 to find the forbidden define.
+#endif // inline
+
+#if defined(int)
+#define int EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "int". \
+Enable warning C4005 to find the forbidden define.
+#endif // int
+
+#if defined(long)
+#define long EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "long". \
+Enable warning C4005 to find the forbidden define.
+#endif // long
+
+#if defined(mutable)
+#define mutable EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "mutable". \
+Enable warning C4005 to find the forbidden define.
+#endif // mutable
+
+#if defined(namespace)
+#define namespace EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "namespace". \
+Enable warning C4005 to find the forbidden define.
+#endif // namespace
+
+#if defined(new) && defined(_ENFORCE_BAN_OF_MACRO_NEW)
+#define new EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "new", though macroized new is supported on this \
+implementation as a nonstandard extension. Enable warning C4005 to find the forbidden define, or re-enable the \
+extension by removing _ENFORCE_BAN_OF_MACRO_NEW.
+#endif // new
+
+#if defined(noexcept)
+#define noexcept EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "noexcept". \
+Enable warning C4005 to find the forbidden define.
+#endif // noexcept
+
+#if defined(nullptr)
+#define nullptr EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "nullptr". \
+Enable warning C4005 to find the forbidden define.
+#endif // nullptr
+
+#if defined(operator)
+#define operator EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "operator". \
+Enable warning C4005 to find the forbidden define.
+#endif // operator
+
+#if defined(private)
+#define private EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "private". \
+Enable warning C4005 to find the forbidden define.
+#endif // private
+
+#if defined(protected)
+#define protected EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "protected". \
+Enable warning C4005 to find the forbidden define.
+#endif // protected
+
+#if defined(public)
+#define public EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "public". \
+Enable warning C4005 to find the forbidden define.
+#endif // public
+
+#if defined(register)
+#define register EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "register". \
+Enable warning C4005 to find the forbidden define.
+#endif // register
+
+#if defined(reinterpret_cast)
+#define reinterpret_cast EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "reinterpret_cast". \
+Enable warning C4005 to find the forbidden define.
+#endif // reinterpret_cast
+
+#if defined(requires) && _HAS_CXX20
+#define requires EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "requires". \
+Enable warning C4005 to find the forbidden define.
+#endif // requires
+
+#if defined(return)
+#define return EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "return". \
+Enable warning C4005 to find the forbidden define.
+#endif // return
+
+#if defined(short)
+#define short EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "short". \
+Enable warning C4005 to find the forbidden define.
+#endif // short
+
+#if defined(signed)
+#define signed EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "signed". \
+Enable warning C4005 to find the forbidden define.
+#endif // signed
+
+#if defined(sizeof)
+#define sizeof EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "sizeof". \
+Enable warning C4005 to find the forbidden define.
+#endif // sizeof
+
+#if defined(static)
+#define static EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "static". \
+Enable warning C4005 to find the forbidden define.
+#endif // static
+
+#if defined(static_assert)
+#define static_assert EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "static_assert". \
+Enable warning C4005 to find the forbidden define.
+#endif // static_assert
+
+#if defined(static_cast)
+#define static_cast EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "static_cast". \
+Enable warning C4005 to find the forbidden define.
+#endif // static_cast
+
+#if defined(struct)
+#define struct EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "struct". \
+Enable warning C4005 to find the forbidden define.
+#endif // struct
+
+#if defined(switch)
+#define switch EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "switch". \
+Enable warning C4005 to find the forbidden define.
+#endif // switch
+
+#if defined(template)
+#define template EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "template". \
+Enable warning C4005 to find the forbidden define.
+#endif // template
+
+#if defined(this)
+#define this EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "this". \
+Enable warning C4005 to find the forbidden define.
+#endif // this
+
+#if defined(thread_local)
+#define thread_local EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "thread_local". \
+Enable warning C4005 to find the forbidden define.
+#endif // thread_local
+
+#if defined(throw)
+#define throw EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "throw". \
+Enable warning C4005 to find the forbidden define.
+#endif // throw
+
+#if defined(true)
+#define true EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "true". \
+Enable warning C4005 to find the forbidden define.
+#endif // true
+
+#if defined(try)
+#define try EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "try". \
+Enable warning C4005 to find the forbidden define.
+#endif // try
+
+#if defined(typedef)
+#define typedef EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "typedef". \
+Enable warning C4005 to find the forbidden define.
+#endif // typedef
+
+#if defined(typeid)
+#define typeid EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "typeid". \
+Enable warning C4005 to find the forbidden define.
+#endif // typeid
+
+#if defined(typename)
+#define typename EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "typename". \
+Enable warning C4005 to find the forbidden define.
+#endif // typename
+
+#if defined(union)
+#define union EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "union". \
+Enable warning C4005 to find the forbidden define.
+#endif // union
+
+#if defined(unsigned)
+#define unsigned EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "unsigned". \
+Enable warning C4005 to find the forbidden define.
+#endif // unsigned
+
+#if defined(using)
+#define using EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "using". \
+Enable warning C4005 to find the forbidden define.
+#endif // using
+
+#if defined(virtual)
+#define virtual EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "virtual". \
+Enable warning C4005 to find the forbidden define.
+#endif // virtual
+
+#if defined(void)
+#define void EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "void". \
+Enable warning C4005 to find the forbidden define.
+#endif // void
+
+#if defined(volatile)
+#define volatile EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "volatile". \
+Enable warning C4005 to find the forbidden define.
+#endif // volatile
+
+#if defined(wchar_t)
+#define wchar_t EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "wchar_t". \
+Enable warning C4005 to find the forbidden define.
+#endif // wchar_t
+
+#if defined(while)
+#define while EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the keyword "while". \
+Enable warning C4005 to find the forbidden define.
+#endif // while
+
+// contextual keywords (a.k.a. "identifiers with special meaning"):
+#if defined(final)
+#define final EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the contextual keyword "final". \
+Enable warning C4005 to find the forbidden define.
+#endif // final
+
+#if defined(import) && _HAS_CXX20
+#define import EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the contextual keyword "import". \
+Enable warning C4005 to find the forbidden define.
+#endif // import
+
+#if defined(module) && _HAS_CXX20
+#define module EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the contextual keyword "module". \
+Enable warning C4005 to find the forbidden define.
+#endif // module
+
+#if defined(override)
+#define override EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the contextual keyword "override". \
+Enable warning C4005 to find the forbidden define.
+#endif // override
+
+// attribute-tokens:
+#if defined(carries_dependency)
+#define carries_dependency EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "carries_dependency". \
+Enable warning C4005 to find the forbidden define.
+#endif // carries_dependency
+
+#if defined(deprecated)
+#define deprecated EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "deprecated". \
+Enable warning C4005 to find the forbidden define.
+#endif // deprecated
+
+#if defined(fallthrough) && _HAS_CXX17
+#define fallthrough EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "fallthrough". \
+Enable warning C4005 to find the forbidden define.
+#endif // fallthrough
+
+// not checking "likely" because it is commonly defined as a function-like macro
+
+#if defined(maybe_unused) && _HAS_CXX17
+#define maybe_unused EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "maybe_unused". \
+Enable warning C4005 to find the forbidden define.
+#endif // maybe_unused
+
+#if defined(nodiscard) // C++17 attribute-token, also enforced in C++14 mode
+#define nodiscard EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "nodiscard". \
+Enable warning C4005 to find the forbidden define.
+#endif // nodiscard
+
+#if defined(noreturn)
+#define noreturn EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "noreturn". \
+Enable warning C4005 to find the forbidden define.
+#endif // noreturn
+
+#if defined(no_unique_address) && _HAS_CXX20
+#define no_unique_address EMIT WARNING C4005
+#error The C++ Standard Library forbids macroizing the attribute-token "no_unique_address". \
+Enable warning C4005 to find the forbidden define.
+#endif // no_unique_address
+
+// not checking "unlikely" because it is commonly defined as a function-like macro
+
+#endif // !defined(_ALLOW_KEYWORD_MACROS) && !defined(__INTELLISENSE__)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XKEYCHECK_H
diff --git a/msvc-stl/stl/inc/xlocale b/msvc-stl/stl/inc/xlocale
new file mode 100644
index 0000000..3265b2e
--- /dev/null
+++ b/msvc-stl/stl/inc/xlocale
@@ -0,0 +1,3332 @@
+// xlocale internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCALE_
+#define _XLOCALE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <climits>
+#include <cstring>
+#include <memory>
+#include <typeinfo>
+#include <xfacet>
+#include <xlocinfo>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("empty_bases")
+#undef empty_bases
+
+_STD_BEGIN
+template <class _Dummy>
+class _Locbase {}; // TRANSITION, ABI, affects sizeof(locale)
+
+_EXPORT_STD template <class _Elem>
+class collate;
+
+extern "C++" struct _CRTIMP2_PURE_IMPORT _Crt_new_delete { // base class for marking allocations as CRT blocks
+#ifdef _DEBUG
+    void* __CLRCALL_OR_CDECL operator new(size_t _Size) { // replace operator new
+        void* _Ptr = operator new(_Size, nothrow);
+        if (!_Ptr) {
+            _Xbad_alloc();
+        }
+
+        return _Ptr;
+    }
+
+    void* __CLRCALL_OR_CDECL operator new(size_t _Size, const nothrow_t&) noexcept { // replace nothrow operator new
+        return _malloc_dbg(_Size > 0 ? _Size : 1, _CRT_BLOCK, __FILE__, __LINE__);
+    }
+
+    void __CLRCALL_OR_CDECL operator delete(void* _Ptr) noexcept { // replace operator delete
+        _CSTD free(_Ptr);
+    }
+
+    void __CLRCALL_OR_CDECL operator delete(void* _Ptr, const nothrow_t&) noexcept { // replace nothrow operator delete
+        operator delete(_Ptr);
+    }
+
+    void* __CLRCALL_OR_CDECL operator new(size_t, void* _Ptr) noexcept { // imitate True Placement New
+        return _Ptr;
+    }
+
+    void __CLRCALL_OR_CDECL operator delete(void*, void*) noexcept {} // imitate True Placement Delete
+#endif // _DEBUG
+};
+
+_EXPORT_STD extern "C++" class locale : public _Locbase<int>, public _Crt_new_delete {
+public:
+    using category = int;
+
+    static constexpr category collate  = _M_COLLATE;
+    static constexpr category ctype    = _M_CTYPE;
+    static constexpr category monetary = _M_MONETARY;
+    static constexpr category numeric  = _M_NUMERIC;
+    static constexpr category time     = _M_TIME;
+    static constexpr category messages = _M_MESSAGES;
+    static constexpr category all      = _M_ALL;
+    static constexpr category none     = 0;
+
+    class _CRTIMP2_PURE_IMPORT id { // identifier stamp, unique for each distinct kind of facet
+    public:
+#ifdef _CRTBLD // TRANSITION, ABI: preserved for binary compatibility
+        __CLR_OR_THIS_CALL id(size_t _Val = 0) : _Id(_Val) {}
+#else // ^^^ defined(_CRTBLD) / !defined(_CRTBLD) vvv
+        template <int = 0> // TRANSITION, ABI
+        id() noexcept /* strengthened */ {}
+#endif // ^^^ !defined(_CRTBLD) ^^^
+
+        id(const id&)            = delete;
+        id& operator=(const id&) = delete;
+
+        template <int = 0> // TRANSITION, ABI
+        size_t _Get_index() { // get stamp, with lazy allocation
+            if (_Id == 0) { // still zero, allocate stamp
+                _BEGIN_LOCK(_LOCK_LOCALE)
+                if (_Id == 0) {
+                    _Id = static_cast<size_t>(++_Id_cnt);
+                }
+                _END_LOCK()
+            }
+            return _Id;
+        }
+
+#ifdef _CRTBLD // TRANSITION, ABI: preserved for binary compatibility
+        __CLR_OR_THIS_CALL operator size_t() {
+            return _Get_index();
+        }
+#endif // defined(_CRTBLD)
+
+    private:
+        size_t _Id = 0; // the identifier stamp
+
+        __PURE_APPDOMAIN_GLOBAL static int _Id_cnt;
+    };
+
+    struct _Facet_guard;
+
+    class _CRTIMP2_PURE_IMPORT facet : public _Facet_base, public _Crt_new_delete {
+        // base class for all locale facets, performs reference counting
+    private:
+        friend _Facet_guard;
+
+    public:
+        static size_t __CLRCALL_OR_CDECL _Getcat(const facet** = nullptr, const locale* = nullptr) {
+            // get category value, or -1 if no corresponding C category
+            return static_cast<size_t>(-1);
+        }
+
+        void __CLR_OR_THIS_CALL _Incref() noexcept override { // increment use count
+            _MT_INCR(_Myrefs);
+        }
+
+        _Facet_base* __CLR_OR_THIS_CALL _Decref() noexcept override { // decrement use count
+            if (_MT_DECR(_Myrefs) == 0) {
+                return this;
+            }
+
+            return nullptr;
+        }
+
+    private:
+        _Atomic_counter_t _Myrefs; // the reference count
+
+    protected:
+        explicit __CLR_OR_THIS_CALL facet(size_t _Initrefs = 0) noexcept // strengthened
+            : _Myrefs(static_cast<_Atomic_counter_t>(_Initrefs)) // non-atomic initialization
+        {}
+
+        __CLR_OR_THIS_CALL ~facet() noexcept override {}
+
+    public:
+        __CLR_OR_THIS_CALL facet(const facet&)            = delete;
+        facet& __CLR_OR_THIS_CALL operator=(const facet&) = delete;
+    };
+
+    struct _NODISCARD _Facet_guard {
+        facet* _Target;
+        ~_Facet_guard() {
+            if (_Target) {
+                delete _Target->_Decref();
+            }
+        }
+    };
+
+    class _CRTIMP2_PURE_IMPORT _Locimp : public facet { // reference-counted actual implementation of a locale
+    protected:
+        __CLR_OR_THIS_CALL ~_Locimp() noexcept {
+            _Locimp_dtor(this);
+        }
+
+    private:
+        static _Locimp* __CLRCALL_PURE_OR_CDECL _New_Locimp(bool _Transparent = false);
+        static _Locimp* __CLRCALL_PURE_OR_CDECL _New_Locimp(const _Locimp& _Right);
+
+        static void __CLRCALL_PURE_OR_CDECL _Locimp_dtor(_Locimp*);
+        static void __CLRCALL_PURE_OR_CDECL _Locimp_Addfac(_Locimp*, facet*, size_t); // add a facet
+        static void __CLRCALL_PURE_OR_CDECL _Locimp_ctor(_Locimp*, const _Locimp&);
+
+        friend locale;
+
+        __CLR_OR_THIS_CALL _Locimp(bool _Transparent)
+            : locale::facet(1), _Facetvec(nullptr), _Facetcount(0), _Catmask(none), _Xparent(_Transparent), _Name("*") {
+        }
+
+        __CLR_OR_THIS_CALL _Locimp(const _Locimp& _Right)
+            : locale::facet(1), _Facetvec(nullptr), _Facetcount(_Right._Facetcount), _Catmask(_Right._Catmask),
+              _Xparent(_Right._Xparent), _Name(_Right._Name.c_str()) {
+            _Locimp_ctor(this, _Right);
+        }
+
+        void __CLR_OR_THIS_CALL _Addfac(facet* _Pfacet, size_t _Id) { // add a facet
+            _Locimp_Addfac(this, _Pfacet, _Id);
+        }
+
+        static _Locimp* __CLRCALL_OR_CDECL _Makeloc(
+            const _Locinfo&, category, _Locimp*, const locale*); // make essential facets
+
+        static void __CLRCALL_OR_CDECL _Makewloc(
+            const _Locinfo&, category, _Locimp*, const locale*); // make wchar_t facets
+
+#ifdef _CRTBLD
+        static void __CLRCALL_OR_CDECL _Makeushloc(
+            const _Locinfo&, category, _Locimp*, const locale*); // make ushort facets
+#endif // defined(_CRTBLD)
+
+        static void __CLRCALL_OR_CDECL _Makexloc(
+            const _Locinfo&, category, _Locimp*, const locale*); // make remaining facets
+
+        facet** _Facetvec; // pointer to vector of facets
+        size_t _Facetcount; // size of vector of facets
+        category _Catmask; // mask describing implemented categories
+        bool _Xparent; // true if locale is transparent
+        _Yarn<char> _Name; // locale name, or "*" if not known
+
+        __PURE_APPDOMAIN_GLOBAL static _Locimp* _Clocptr;
+
+    public:
+        _Locimp& __CLR_OR_THIS_CALL operator=(const _Locimp&) = delete;
+    };
+
+    template <class _Elem, class _Traits, class _Alloc>
+    bool operator()(
+        const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) const {
+        // compare _Left and _Right strings using collate facet in locale
+        const auto& _Coll_fac = _STD use_facet<_STD collate<_Elem>>(*this);
+
+        const _Elem* const _Left_data  = _Left.data();
+        const _Elem* const _Right_data = _Right.data();
+        return _Coll_fac.compare(_Left_data, _Left_data + _Left.size(), _Right_data, _Right_data + _Right.size()) < 0;
+    }
+
+    template <class _Facet>
+    locale combine(const locale& _Loc) const { // combine two locales
+        _Facet* _Facptr;
+
+        _TRY_BEGIN
+        _Facptr = const_cast<_Facet*>(_STD addressof(_STD use_facet<_Facet>(_Loc)));
+        _CATCH_ALL
+        _Xruntime_error("locale::combine facet missing");
+        _CATCH_END
+
+        _Locimp* _Newimp = _Locimp::_New_Locimp(*_Ptr);
+        _Newimp->_Addfac(_Facptr, _Facet::id._Get_index());
+        _Newimp->_Catmask = none;
+        _Newimp->_Name    = "*";
+        return locale{_Secret_locale_construct_tag{}, _Newimp};
+    }
+
+    template <class _Facet>
+    locale(const locale& _Loc, const _Facet* _Facptr) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
+        if (_Facptr) { // replace facet
+            _Ptr->_Addfac(const_cast<_Facet*>(_Facptr), _Facet::id._Get_index());
+            _Ptr->_Catmask = none;
+            _Ptr->_Name    = "*";
+        }
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 26495) // Variable 'std::locale::_Ptr' is uninitialized.
+                                 // Always initialize a member variable (type.6).
+
+    // We must not explicitly initialize _Ptr here; we rely on it maintaining the value
+    // previously created in its storage. To be precise:
+    // In locale0.cpp, locale::_Init() uses True Placement New at classic_locale's address,
+    // and classic_locale is constructed from the _Noinit enumerator of type _Uninitialized.
+    // The sequencing is highly unusual; the True Placement New happens before the _Uninitialized construction,
+    // so while _Ptr here formally has indeterminate value, we expect it to actually keep the previous value.
+    locale(_Uninitialized) {} // defer construction
+#pragma warning(pop)
+
+    locale(const locale& _Right) noexcept : _Ptr(_Right._Ptr) {
+        _Ptr->_Incref();
+    }
+
+    locale() noexcept : _Ptr(_Init(true)) {}
+
+#if !defined(MRTDLL) || !defined(_CRTBLD)
+    locale(const locale& _Loc, const locale& _Other, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
+        // construct a locale by copying named facets
+        if (_Cat != none) { // worth adding, do it
+            _STL_ASSERT((_Cat & all) == _Cat, "the bitmask value specifying category must be valid");
+            _Facet_guard _Guard{_Ptr};
+            _BEGIN_LOCINFO(_Lobj)
+            _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, &_Other);
+            _Lobj._Addcats(_Loc._Ptr->_Catmask, _Loc.name().c_str());
+            _Lobj._Addcats(_Other._Ptr->_Catmask, _Other.name().c_str());
+            _Ptr->_Catmask = _Loc._Ptr->_Catmask | _Other._Ptr->_Catmask;
+            _Ptr->_Name    = _Lobj._Getname();
+            _END_LOCINFO()
+            _Guard._Target = nullptr;
+        }
+    }
+
+private:
+    void _Construct(const string& _Str, category _Cat) {
+        _STL_ASSERT((_Cat & all) == _Cat, "the bitmask value specifying category must be valid");
+        // construct a locale with named facets
+        bool _Bad = false;
+        _Init();
+        if (_Cat != none) { // worth adding, do it
+            _Facet_guard _Guard{_Ptr};
+            _BEGIN_LOCINFO(_Lobj(_Cat, _Str.c_str()))
+            if (_Badname(_Lobj)) {
+                _Bad = true;
+            } else { // name okay, build the locale
+                _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, nullptr);
+                _Ptr->_Catmask = _Cat;
+                _Ptr->_Name    = _Str.c_str();
+            }
+            _END_LOCINFO()
+            _Guard._Target = nullptr;
+        }
+
+        if (_Bad) { // Don't throw within _BEGIN_LOCINFO if we can avoid it
+            delete _Ptr->_Decref();
+            _Xruntime_error("bad locale name");
+        }
+    }
+
+public:
+    explicit locale(const char* _Locname, category _Cat = all) : _Ptr(_Locimp::_New_Locimp()) {
+        // construct a locale with named facets
+        // _Locname might have been returned from setlocale().
+        // Therefore, _Construct() takes const string&.
+        if (_Locname) {
+            _Construct(_Locname, _Cat);
+            return;
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    locale(const locale& _Loc, const char* _Locname, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
+        // construct a locale by copying, replacing named facets
+        // _Locname might have been returned from setlocale().
+        // Therefore, _Construct() takes const string&.
+        if (_Locname) {
+            _Construct(_Locname, _Cat);
+            return;
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    explicit locale(const string& _Str, category _Cat = all) : _Ptr(_Locimp::_New_Locimp()) {
+        // construct a locale with named facets
+        _Construct(_Str, _Cat);
+    }
+
+    locale(const locale& _Loc, const string& _Str, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
+        // construct a locale by copying, replacing named facets
+        _Construct(_Str, _Cat);
+    }
+#endif // !MRTDLL || !_CRTBLD
+
+    ~locale() noexcept {
+        if (_Ptr) {
+            delete _Ptr->_Decref();
+        }
+    }
+
+    const locale& operator=(const locale& _Right) noexcept {
+        if (_Ptr != _Right._Ptr) { // different implementation, point at new one
+            delete _Ptr->_Decref();
+            _Ptr = _Right._Ptr;
+            _Ptr->_Incref();
+        }
+        return *this;
+    }
+
+    string name() const {
+        return _Ptr ? _Ptr->_Name.c_str() : string{};
+    }
+
+    _Ret_z_ const char* _C_str() const noexcept {
+        return _Ptr ? _Ptr->_Name.c_str() : "";
+    }
+
+    const facet* _Getfacet(size_t _Id) const { // look up a facet in locale object
+        const facet* _Facptr = _Id < _Ptr->_Facetcount ? _Ptr->_Facetvec[_Id] : nullptr; // null if id off end
+        if (_Facptr || !_Ptr->_Xparent) {
+            return _Facptr; // found facet or not transparent
+        }
+
+        // look in current locale
+        locale::_Locimp* _Ptr0 = _Getgloballocale();
+        if (_Id < _Ptr0->_Facetcount) {
+            return _Ptr0->_Facetvec[_Id]; // get from current locale
+        }
+
+        return nullptr; // no entry in current locale
+    }
+
+    _NODISCARD bool operator==(const locale& _Loc) const noexcept /* strengthened */ { // compare locales for equality
+        return _Ptr == _Loc._Ptr || (_CSTD strcmp(_C_str(), "*") != 0 && _CSTD strcmp(_C_str(), _Loc._C_str()) == 0);
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const locale& _Right) const noexcept /* strengthened */ {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    static _MRTIMP2_PURE const locale& __CLRCALL_PURE_OR_CDECL classic(); // classic "C" locale
+
+    static _MRTIMP2_PURE locale __CLRCALL_PURE_OR_CDECL global(const locale&); // current locale
+
+#ifdef _CRTBLD
+    // TRANSITION, ABI: non-Standard locale::empty() is preserved for binary compatibility
+    static _MRTIMP2_PURE locale __CLRCALL_PURE_OR_CDECL empty();
+#endif // ^^^ defined(_CRTBLD) ^^^
+
+private:
+    struct _Secret_locale_construct_tag {
+        explicit _Secret_locale_construct_tag() = default;
+    };
+
+    explicit locale(_Secret_locale_construct_tag, _Locimp* _Ptrimp) : _Ptr(_Ptrimp) {}
+
+    static _MRTIMP2_PURE _Locimp* __CLRCALL_PURE_OR_CDECL _Init(bool _Do_incref = false); // initialize locale
+    static _MRTIMP2_PURE _Locimp* __CLRCALL_PURE_OR_CDECL _Getgloballocale();
+    static _MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Setgloballocale(void*);
+
+    bool _Badname(const _Locinfo& _Lobj) { // test if name is "*"
+        return _CSTD strcmp(_Lobj._Getname(), "*") == 0;
+    }
+
+    _Locimp* _Ptr; // pointer to locale implementation object
+};
+
+template <class _Facet>
+struct _Facetptr { // store pointer to lazy facet for use_facet
+    __PURE_APPDOMAIN_GLOBAL static const locale::facet* _Psave;
+};
+
+template <class _Facet>
+__PURE_APPDOMAIN_GLOBAL const locale::facet* _Facetptr<_Facet>::_Psave = nullptr;
+
+_EXPORT_STD template <class _Facet>
+const _Facet& __CRTDECL use_facet(const locale& _Loc) { // get facet reference from locale
+    _BEGIN_LOCK(_LOCK_LOCALE) // the thread lock, make get atomic
+    const locale::facet* _Psave = _Facetptr<_Facet>::_Psave; // static pointer to lazy facet
+
+    const size_t _Id         = _Facet::id._Get_index();
+    const locale::facet* _Pf = _Loc._Getfacet(_Id);
+
+    if (!_Pf) {
+        if (_Psave) {
+            _Pf = _Psave; // lazy facet already allocated
+        } else if (_Facet::_Getcat(&_Psave, &_Loc) == static_cast<size_t>(-1)) {
+#if _HAS_EXCEPTIONS
+            _Throw_bad_cast(); // lazy disallowed
+#else
+            _STL_REPORT_ERROR("lazy facet disallowed");
+#endif
+        } else { // queue up lazy facet for destruction
+            auto _Pfmod = const_cast<locale::facet*>(_Psave);
+            unique_ptr<_Facet_base> _Psave_guard(static_cast<_Facet_base*>(_Pfmod));
+
+#if defined(_M_CEE)
+            _Facet_Register_m(_Pfmod);
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+            _Facet_Register(_Pfmod);
+#endif // ^^^ !defined(_M_CEE) ^^^
+
+            _Pfmod->_Incref();
+            _Facetptr<_Facet>::_Psave = _Psave;
+            _Pf                       = _Psave;
+
+            (void) _Psave_guard.release();
+        }
+    }
+
+    return static_cast<const _Facet&>(*_Pf); // should be dynamic_cast
+    _END_LOCK()
+} // end of use_facet body
+
+#ifdef _CRTBLD
+template <class _Elem>
+constexpr bool _Is_wchar_or_crtbld_ushort = _Is_any_of_v<remove_cv_t<_Elem>, wchar_t, unsigned short>;
+#else // ^^^ defined(_CRTBLD) / !defined(_CRTBLD) vvv
+template <class _Elem>
+constexpr bool _Is_wchar_or_crtbld_ushort = is_same_v<remove_cv_t<_Elem>, wchar_t>;
+#endif // ^^^ !defined(_CRTBLD) ^^^
+
+template <class _Elem>
+char _Maklocbyte(_Elem _Char, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert _Elem to char using _Cvtvec
+    if constexpr (_Is_wchar_or_crtbld_ushort<_Elem>) {
+        char _Byte       = '\0';
+        mbstate_t _Mbst1 = {};
+        _Wcrtomb(&_Byte, static_cast<wchar_t>(_Char), &_Mbst1, &_Cvt); // no-op cast if _Elem is wchar_t
+        return _Byte;
+    } else {
+        return static_cast<char>(static_cast<unsigned char>(_Char));
+    }
+}
+
+template <class _Elem>
+_Elem _Maklocchr(char _Byte, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert char to _Elem using _Cvtvec
+    if constexpr (_Is_wchar_or_crtbld_ushort<_Elem>) {
+        _Elem _Wc{};
+        mbstate_t _Mbst1 = {};
+        _Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), &_Byte, 1, &_Mbst1, &_Cvt); // no-op cast if _Elem is wchar_t
+        return _Wc;
+    } else {
+        return static_cast<_Elem>(static_cast<unsigned char>(_Byte));
+    }
+}
+
+template <class _Elem>
+_Elem* _Maklocstr(const char* _Ptr, const _Locinfo::_Cvtvec& _Cvt) {
+    // convert C string to _Elem sequence using _Cvtvec
+    if constexpr (_Is_wchar_or_crtbld_ushort<_Elem>) {
+        size_t _Wchars    = 0;
+        const char* _Ptr1 = _Ptr;
+        _Elem _Wc;
+        mbstate_t _Mbst1 = {};
+
+        const size_t _Count1 = _CSTD strlen(_Ptr) + 1;
+        for (size_t _Count = _Count1; 0 < _Count; ++_Wchars) {
+            const int _Bytes = _Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), // no-op cast if _Elem is wchar_t
+                _Ptr1, _Count, &_Mbst1, &_Cvt);
+            if (_Bytes <= 0) {
+                break;
+            }
+            _Count -= _Bytes;
+            _Ptr1 += _Bytes;
+        }
+
+        ++_Wchars; // count terminating nul
+
+        wchar_t* _Ptrdest =
+            static_cast<wchar_t*>(_calloc_dbg(_Wchars, sizeof(wchar_t), _CRT_BLOCK, __FILE__, __LINE__));
+
+        if (!_Ptrdest) {
+            _Xbad_alloc();
+        }
+
+        wchar_t* _Ptrnext = _Ptrdest;
+        mbstate_t _Mbst2  = {};
+
+        for (; 0 < _Wchars; --_Wchars, ++_Ptrnext) {
+            const int _Bytes = _Mbrtowc(_Ptrnext, _Ptr, _Count1, &_Mbst2, &_Cvt);
+            if (_Bytes <= 0) {
+                break;
+            }
+            _Ptr += _Bytes;
+        }
+
+        *_Ptrnext = L'\0';
+
+        return reinterpret_cast<_Elem*>(_Ptrdest); // no-op cast if _Elem is wchar_t
+    } else {
+        size_t _Count = _CSTD strlen(_Ptr) + 1;
+
+        _Elem* _Ptrdest = static_cast<_Elem*>(_calloc_dbg(_Count, sizeof(_Elem), _CRT_BLOCK, __FILE__, __LINE__));
+
+        if (!_Ptrdest) {
+            _Xbad_alloc();
+        }
+
+        for (_Elem* _Ptrnext = _Ptrdest; 0 < _Count; --_Count, ++_Ptrnext, ++_Ptr) {
+            *_Ptrnext = static_cast<_Elem>(static_cast<unsigned char>(*_Ptr));
+        }
+
+        return _Ptrdest;
+    }
+}
+
+_EXPORT_STD extern "C++" class _CRTIMP2_PURE_IMPORT codecvt_base // base class for codecvt
+    : public locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+public:
+    enum { // constants for different parse states
+        ok,
+        partial,
+        error,
+        noconv
+    };
+    using result = int;
+
+    __CLR_OR_THIS_CALL codecvt_base(size_t _Refs = 0) noexcept // strengthened
+        : locale::facet(_Refs) {}
+
+    bool __CLR_OR_THIS_CALL always_noconv() const noexcept {
+        // return true if conversions never change input (from codecvt)
+        return do_always_noconv();
+    }
+
+    int __CLR_OR_THIS_CALL max_length() const noexcept {
+        // return maximum length required for a conversion (from codecvt)
+        return do_max_length();
+    }
+
+    int __CLR_OR_THIS_CALL encoding() const noexcept {
+        return do_encoding();
+    }
+
+    __CLR_OR_THIS_CALL ~codecvt_base() noexcept {}
+
+protected:
+    virtual bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept {
+        // return true if conversions never change input (from codecvt)
+        return false;
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_max_length() const noexcept {
+        // return maximum length required for a conversion (from codecvt)
+        return 1;
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_encoding() const noexcept {
+        return 1; // -1 ==> state dependent, 0 ==> varying length
+    }
+};
+
+template <class _Ty>
+constexpr bool _Is_one_byte_char_like_v = _Is_any_of_v<remove_cv_t<_Ty>, signed char, unsigned char,
+#ifdef __cpp_lib_byte
+    byte,
+#endif // defined(__cpp_lib_byte)
+#ifdef __cpp_char8_t
+    char8_t,
+#endif // defined(__cpp_char8_t)
+    char>;
+
+template <class _Elem, class _Byte>
+constexpr bool _Is_codecvt_do_always_noconv_v =
+    is_same_v<_Byte, _Elem> || (_Is_one_byte_char_like_v<_Byte> && _Is_one_byte_char_like_v<_Elem>);
+
+_EXPORT_STD extern "C++" template <class _Elem, class _Byte, class _Statype>
+class codecvt : public codecvt_base { // facet for converting between _Elem and _Byte sequences
+public:
+    // Explicitly specialized below:
+    // codecvt<wchar_t, char, mbstate_t>
+    // codecvt<unsigned short, char, mbstate_t> (extension)
+    // codecvt<char16_t, char, mbstate_t>
+    // codecvt<char32_t, char, mbstate_t>
+    // codecvt<char16_t, char8_t, mbstate_t>
+    // codecvt<char32_t, char8_t, mbstate_t>
+
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || is_same_v<codecvt, codecvt<char, char, mbstate_t>>,
+        _FACET_SPECIALIZATION_MESSAGE);
+
+    using intern_type = _Elem;
+    using extern_type = _Byte;
+    using state_type  = _Statype;
+
+    result __CLR_OR_THIS_CALL in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
+        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const { // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
+        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const { // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(_Statype& _State, _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count _Elems
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
+        _Init(_Locinfo());
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input (from codecvt)
+        return _Is_codecvt_do_always_noconv_v<_Elem, _Byte>;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_in(_Statype&, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
+        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const { // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        if constexpr (_Is_codecvt_do_always_noconv_v<_Elem, _Byte>) {
+            return noconv; // convert nothing
+        } else {
+            // types differ, copy one for one
+            for (; _Mid1 != _Last1; ++_Mid1, ++_Mid2) {
+                if (_Mid2 == _Last2) {
+                    return partial;
+                }
+                *_Mid2 = static_cast<_Elem>(*_Mid1);
+            }
+
+            return ok;
+        }
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(_Statype&, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
+        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const { // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        if constexpr (_Is_codecvt_do_always_noconv_v<_Elem, _Byte>) {
+            return noconv; // convert nothing
+        } else {
+            // types differ, copy one for one
+            for (; _Mid1 != _Last1; ++_Mid1, ++_Mid2) {
+                if (_Mid2 == _Last2) {
+                    return partial;
+                }
+                *_Mid2 = static_cast<_Byte>(*_Mid1);
+            }
+
+            return ok;
+        }
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const {
+        // generate bytes to return to default shift state
+        _Mid2 = _First2;
+        return noconv; // no termination required
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        _Statype&, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count _Elems
+        // assumes 1:1 conversion
+        const auto _Dist = static_cast<size_t>((_STD min) (_Last1 - _First1, ptrdiff_t{INT_MAX}));
+        return static_cast<int>((_STD min) (_Count, _Dist));
+    }
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _Byte, class _Statype>
+__PURE_APPDOMAIN_GLOBAL locale::id codecvt<_Elem, _Byte, _Statype>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+template <class _CvtTy, class _Byte, class _Statype>
+_NODISCARD int _Codecvt_do_length(
+    const _CvtTy& _Cvt, _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) {
+    // return p - _First1, for the largest value p in [_First1, _Last1] such that _Cvt will successfully convert
+    // [_First1, p) to at most _Count wide characters
+
+    _STL_DISABLE_DEPRECATED_WARNING
+    using _Elem = typename _CvtTy::intern_type;
+    _STL_RESTORE_DEPRECATED_WARNING
+
+    _Adl_verify_range(_First1, _Last1);
+    const auto _Old_first1 = _First1;
+
+    while (_Count > 0 && _First1 != _Last1) { // convert another wide character
+        const _Byte* _Mid1;
+        _Elem* _Mid2;
+        _Elem _Ch;
+
+        // test result of single wide-char conversion
+
+        _STL_DISABLE_DEPRECATED_WARNING
+        const auto _Result = _Cvt._CvtTy::do_in(_State, _First1, _Last1, _Mid1, &_Ch, &_Ch + 1, _Mid2);
+        _STL_RESTORE_DEPRECATED_WARNING
+
+        if (_Result != codecvt_base::ok) {
+            if (_Result == codecvt_base::noconv) {
+                _First1 += (_STD min) (static_cast<size_t>(_Last1 - _First1), _Count);
+            }
+
+            break; // error, noconv, or partial
+        }
+
+        if (_Mid2 == &_Ch + 1) {
+            --_Count; // do_in converted an output character
+        }
+
+        _First1 = _Mid1;
+    }
+
+    return static_cast<int>((_STD min) (_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+}
+
+enum _Codecvt_mode { _Consume_header = 4, _Generate_header = 2 };
+
+extern "C++" {
+
+template <>
+class _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE _CXX20_DEPRECATE_CODECVT_FACETS
+    codecvt<char16_t, char, mbstate_t> : public codecvt_base {
+    // facet for converting between char16_t and UTF-8 byte sequences
+public:
+    using intern_type = char16_t;
+    using extern_type = char;
+    using state_type  = mbstate_t;
+
+    result __CLR_OR_THIS_CALL in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
+        char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1,
+        const char16_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-16 code units
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    _CRT_SATELLITE_CODECVT_IDS_NOIMPORT static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(0x10ffff), _Mode(_Consume_header) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(0x10ffff), _Mode(_Consume_header) {
+        _Init(_Lobj);
+    }
+
+    __CLR_OR_THIS_CALL codecvt(
+        const _Locinfo& _Lobj, unsigned long _Maxcode_arg, _Codecvt_mode _Mode_arg, size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(_Maxcode_arg), _Mode(_Mode_arg) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            _STL_DISABLE_DEPRECATED_WARNING
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+            _STL_RESTORE_DEPRECATED_WARNING
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo&) {} // initialize
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t& _State, const char* _First1, const char* _Last1,
+        const char*& _Mid1, char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
+        _Mid1                   = _First1;
+        _Mid2                   = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert a multibyte sequence
+            unsigned char _By = static_cast<unsigned char>(*_Mid1);
+            unsigned long _Ch;
+            int _Nextra;
+            int _Nskip;
+
+            if (*_Pstate > 1) {
+                if (_By < 0x80 || 0xc0 <= _By) {
+                    return codecvt::error; // not continuation byte
+                }
+
+                // deliver second half of two-word value
+                ++_Mid1;
+                *_Mid2++ = static_cast<char16_t>(*_Pstate | (_By & 0x3f));
+                *_Pstate = 1;
+                continue;
+            }
+
+            if (_By < 0x80u) {
+                _Ch     = _By;
+                _Nextra = 0;
+            } else if (_By < 0xc0u) { // 0x80-0xbf not first byte
+                ++_Mid1;
+                return codecvt::error;
+            } else if (_By < 0xe0u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x1f);
+                _Nextra = 1;
+            } else if (_By < 0xf0u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x0f);
+                _Nextra = 2;
+            } else if (_By < 0xf8u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x07);
+                _Nextra = 3;
+            } else {
+                _Ch     = static_cast<unsigned long>(_By & 0x03);
+                _Nextra = _By < 0xfc ? 4 : 5;
+            }
+
+            _Nskip  = _Nextra < 3 ? 0 : 1; // leave a byte for 2nd word
+            _First1 = _Mid1; // roll back point
+
+            if (_Nextra == 0) {
+                ++_Mid1;
+            } else if (_Last1 - _Mid1 < _Nextra + 1 - _Nskip) {
+                break; // not enough input
+            } else {
+                for (++_Mid1; _Nskip < _Nextra; --_Nextra, ++_Mid1) {
+                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
+                        return codecvt::error; // not continuation byte
+                    } else {
+                        _Ch = _Ch << 6 | (_By & 0x3f);
+                    }
+                }
+            }
+
+            if (0 < _Nskip) {
+                _Ch <<= 6; // get last byte on next call
+            }
+
+            if ((_Maxcode < 0x10ffffu ? _Maxcode : 0x10ffffu) < _Ch) {
+                return codecvt::error; // value too large
+            }
+
+            if (0xffffu < _Ch) { // deliver first half of two-word value, save second word
+                unsigned short _Ch0 = static_cast<unsigned short>(0xd800 | (_Ch >> 10) - 0x0040);
+
+                *_Mid2++ = static_cast<char16_t>(_Ch0);
+                *_Pstate = static_cast<unsigned short>(0xdc00 | (_Ch & 0x03ff));
+                continue;
+            }
+
+            if (_Nskip != 0) {
+                if (_Mid1 == _Last1) { // not enough bytes, noncanonical value
+                    _Mid1 = _First1;
+                    break;
+                }
+
+                if ((_By = static_cast<unsigned char>(*_Mid1++)) < 0x80u || 0xc0u <= _By) {
+                    return codecvt::error; // not continuation byte
+                }
+
+                _Ch |= _By & 0x3f; // complete noncanonical value
+            }
+
+            if (*_Pstate == 0u) { // first time, maybe look for and consume header
+                *_Pstate = 1;
+
+                if ((_Mode & _Consume_header) != 0 && _Ch == 0xfeffu) { // drop header and retry
+                    const result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+
+                    if (_Ans == codecvt::partial) { // roll back header determination
+                        *_Pstate = 0;
+                        _Mid1    = _First1;
+                    }
+
+                    return _Ans;
+                }
+            }
+
+            *_Mid2++ = static_cast<char16_t>(_Ch);
+        }
+
+        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1,
+        const char16_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
+        _Mid1                   = _First1;
+        _Mid2                   = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert and put a wide char
+            unsigned long _Ch;
+            const unsigned short _Ch1 = static_cast<unsigned short>(*_Mid1);
+            bool _Save                = false;
+
+            if (1 < *_Pstate) { // get saved MS 11 bits from *_Pstate
+                if (_Ch1 < 0xdc00u || 0xe000u <= _Ch1) {
+                    return codecvt::error; // bad second word
+                }
+
+                _Ch = static_cast<unsigned long>((*_Pstate << 10) | (_Ch1 - 0xdc00));
+            } else if (0xd800u <= _Ch1 && _Ch1 < 0xdc00u) { // get new first word
+                _Ch   = static_cast<unsigned long>((_Ch1 - 0xd800 + 0x0040) << 10);
+                _Save = true; // put only first byte, rest with second word
+            } else {
+                _Ch = _Ch1; // not first word, just put it
+            }
+
+            char _By;
+            int _Nextra;
+
+            if (_Ch < 0x0080u) {
+                _By     = static_cast<char>(_Ch);
+                _Nextra = 0;
+            } else if (_Ch < 0x0800u) {
+                _By     = static_cast<char>(0xc0 | _Ch >> 6);
+                _Nextra = 1;
+            } else if (_Ch < 0x10000u) {
+                _By     = static_cast<char>(0xe0 | _Ch >> 12);
+                _Nextra = 2;
+            } else {
+                _By     = static_cast<char>(0xf0 | _Ch >> 18);
+                _Nextra = 3;
+            }
+
+            int _Nput = _Nextra < 3 ? _Nextra + 1 : _Save ? 1 : 3;
+
+            if (_Last2 - _Mid2 < _Nput) {
+                break; // not enough room, even without header
+            }
+
+            if (*_Pstate == 0u && (_Mode & _Generate_header) != 0) {
+                if (_Last2 - _Mid2 < 3 + _Nput) {
+                    break; // not enough room for header + output
+                }
+
+                // prepend header
+                *_Mid2++ = '\xef';
+                *_Mid2++ = '\xbb';
+                *_Mid2++ = '\xbf';
+            }
+
+            ++_Mid1;
+            if (_Save || _Nextra < 3) { // put first byte of sequence, if not already put
+                *_Mid2++ = _By;
+                --_Nput;
+            }
+
+            for (; 0 < _Nput; --_Nput) {
+                *_Mid2++ = static_cast<char>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
+            }
+
+            *_Pstate = static_cast<unsigned short>(_Save ? _Ch >> 10 : 1);
+        }
+
+        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t& _State, char* _First2, char*, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
+        _Mid2                   = _First2;
+
+        return 1u < *_Pstate ? codecvt::error : codecvt::ok; // fail if trailing first word
+    }
+
+    friend int _Codecvt_do_length<>(const codecvt&, mbstate_t&, const char*, const char*, size_t);
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+
+        if ((_Mode & _Consume_header) != 0) {
+            return 9; // header + max input
+        }
+
+        if ((_Mode & _Generate_header) != 0) {
+            return 7; // header + max output
+        }
+
+        return 6; // 6-byte max input sequence, no 3-byte header
+    }
+
+    int do_encoding() const noexcept override {
+        return 0; // 0 => varying length
+    }
+
+private:
+    unsigned long _Maxcode; // default: 0x10ffff
+    _Codecvt_mode _Mode; // default: _Consume_header
+};
+
+template <>
+class _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE _CXX20_DEPRECATE_CODECVT_FACETS
+    codecvt<char32_t, char, mbstate_t> : public codecvt_base {
+    // facet for converting between char32_t and UTF-8 byte sequences
+public:
+    using intern_type = char32_t;
+    using extern_type = char;
+    using state_type  = mbstate_t;
+
+    result __CLR_OR_THIS_CALL in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
+        char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1,
+        const char32_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-32 code units
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    _CRT_SATELLITE_CODECVT_IDS_NOIMPORT static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(0xffffffff), _Mode(_Consume_header) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(0xffffffff), _Mode(_Consume_header) {
+        _Init(_Lobj);
+    }
+
+    __CLR_OR_THIS_CALL codecvt(
+        const _Locinfo& _Lobj, unsigned long _Maxcode_arg, _Codecvt_mode _Mode_arg, size_t _Refs = 0)
+        : codecvt_base(_Refs), _Maxcode(_Maxcode_arg), _Mode(_Mode_arg) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            _STL_DISABLE_DEPRECATED_WARNING
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+            _STL_RESTORE_DEPRECATED_WARNING
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo&) {} // initialize
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t& _State, const char* _First1, const char* _Last1,
+        const char*& _Mid1, char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        char* _Pstate = reinterpret_cast<char*>(&_State);
+        _Mid1         = _First1;
+        _Mid2         = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert a multibyte sequence
+            unsigned char _By = static_cast<unsigned char>(*_Mid1);
+            unsigned long _Ch;
+            int _Nextra;
+
+            if (_By < 0x80u) {
+                _Ch     = _By;
+                _Nextra = 0;
+            } else if (_By < 0xc0u) { // 0x80-0xbf not first byte
+                ++_Mid1;
+                return codecvt::error;
+            } else if (_By < 0xe0u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x1f);
+                _Nextra = 1;
+            } else if (_By < 0xf0u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x0f);
+                _Nextra = 2;
+            } else if (_By < 0xf8u) {
+                _Ch     = static_cast<unsigned long>(_By & 0x07);
+                _Nextra = 3;
+            } else {
+                _Ch     = static_cast<unsigned long>(_By & 0x03);
+                _Nextra = _By < 0xfc ? 4 : 5;
+            }
+
+            if (_Nextra == 0) {
+                ++_Mid1;
+            } else if (_Last1 - _Mid1 < _Nextra + 1) {
+                break; // not enough input
+            } else {
+                for (++_Mid1; 0 < _Nextra; --_Nextra, ++_Mid1) {
+                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
+                        return codecvt::error; // not continuation byte
+                    } else {
+                        _Ch = _Ch << 6 | (_By & 0x3f);
+                    }
+                }
+            }
+
+            if (*_Pstate == 0) { // first time, maybe look for and consume header
+                *_Pstate = 1;
+
+                if ((_Mode & _Consume_header) != 0 && _Ch == 0xfeffu) { // drop header and retry
+                    const result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+
+                    if (_Ans == codecvt::partial) { // roll back header determination
+                        *_Pstate = 0;
+                        _Mid1    = _First1;
+                    }
+                    return _Ans;
+                }
+            }
+
+            if (_Maxcode < _Ch) {
+                return codecvt::error; // code too large
+            }
+
+            *_Mid2++ = static_cast<char32_t>(_Ch);
+        }
+
+        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1,
+        const char32_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        char* _Pstate = reinterpret_cast<char*>(&_State);
+        _Mid1         = _First1;
+        _Mid2         = _First2;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) { // convert and put a wide char
+            char _By;
+            int _Nextra;
+            unsigned long _Ch = static_cast<unsigned long>(*_Mid1);
+
+            if (_Maxcode < _Ch) {
+                return codecvt::error;
+            }
+
+            if (_Ch < 0x0080u) {
+                _By     = static_cast<char>(_Ch);
+                _Nextra = 0;
+            } else if (_Ch < 0x0800u) {
+                _By     = static_cast<char>(0xc0 | _Ch >> 6);
+                _Nextra = 1;
+            } else if (_Ch < 0x00010000u) {
+                _By     = static_cast<char>(0xe0 | _Ch >> 12);
+                _Nextra = 2;
+            } else if (_Ch < 0x00200000u) {
+                _By     = static_cast<char>(0xf0 | _Ch >> 18);
+                _Nextra = 3;
+            } else if (_Ch < 0x04000000u) {
+                _By     = static_cast<char>(0xf8 | _Ch >> 24);
+                _Nextra = 4;
+            } else {
+                _By     = static_cast<char>(0xfc | (_Ch >> 30 & 0x03));
+                _Nextra = 5;
+            }
+
+            if (*_Pstate == 0) { // first time, maybe generate header
+                *_Pstate = 1;
+                if ((_Mode & _Generate_header) != 0) {
+                    if (_Last2 - _Mid2 < 3 + 1 + _Nextra) {
+                        return codecvt::partial; // not enough room for both
+                    }
+
+                    // prepend header
+                    *_Mid2++ = '\xef';
+                    *_Mid2++ = '\xbb';
+                    *_Mid2++ = '\xbf';
+                }
+            }
+
+            if (_Last2 - _Mid2 < 1 + _Nextra) {
+                break; // not enough room for output
+            }
+
+            ++_Mid1;
+            for (*_Mid2++ = _By; 0 < _Nextra;) {
+                *_Mid2++ = static_cast<char>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
+            }
+        }
+        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t&, char* _First2, char*, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        _Mid2 = _First2;
+        return codecvt::noconv;
+    }
+
+    friend int _Codecvt_do_length<>(const codecvt&, mbstate_t&, const char*, const char*, size_t);
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        return (_Mode & (_Consume_header | _Generate_header)) != 0 ? 9 : 6;
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return (_Mode & (_Consume_header | _Generate_header)) != 0 ? -1
+                                                                   : 0; // -1 => state dependent, 0 => varying length
+    }
+
+private:
+    unsigned long _Maxcode; // default: 0xffffffff
+    _Codecvt_mode _Mode; // default: _Consume_header
+};
+
+#if defined(__cpp_char8_t) && !defined(_M_CEE_PURE)
+template <class _From, class _To>
+struct _NODISCARD _Codecvt_guard {
+    const _From* const& _First1;
+    const _From*& _Mid1;
+    _To* const& _First2;
+    _To*& _Mid2;
+
+    _Codecvt_guard(const _From* const& _First1_, const _From*& _Mid1_, _To* const& _First2_, _To*& _Mid2_)
+        : _First1{_First1_}, _Mid1{_Mid1_}, _First2{_First2_}, _Mid2{_Mid2_} {}
+
+    _Codecvt_guard(const _Codecvt_guard&)            = delete;
+    _Codecvt_guard& operator=(const _Codecvt_guard&) = delete;
+
+    ~_Codecvt_guard() {
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+    }
+};
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt<char16_t, char8_t, mbstate_t> : public codecvt_base {
+    // facet for converting between UTF-16 and UTF-8 sequences
+public:
+    using intern_type = char16_t;
+    using extern_type = char8_t;
+    using state_type  = mbstate_t;
+
+    result in(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, const char8_t*& _Mid1,
+        char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
+        // convert UTF-8 [_First1, _Last1) to UTF-16 [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1, const char16_t*& _Mid1,
+        char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // convert UTF-16 [_First1, _Last1) to UTF-8 [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result unshift(mbstate_t& _State, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int length(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-16 code units
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    _CRT_SATELLITE_CODECVT_IDS static locale::id id;
+
+    explicit codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {} // construct "from current locale"
+    explicit codecvt(const _Locinfo&, size_t _Refs = 0) : codecvt_base(_Refs) {} // construct "from specified locale"
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt;
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override = default;
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t&, const char8_t* _First1, const char8_t* _Last1,
+        const char8_t*& _Mid1, char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
+        // convert UTF-8 [_First1, _Last1) to UTF-16 [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        _Codecvt_guard<char8_t, char16_t> _Guard{_First1, _Mid1, _First2, _Mid2};
+
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            if (_First2 == _Last2) {
+                return partial;
+            }
+
+            char8_t _Lead_byte = *_First1;
+            if (_Lead_byte < 0b1000'0000u) { // single-byte sequence
+                *_First2 = static_cast<char16_t>(_Lead_byte);
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Lead_byte < 0b1110'0000u) {
+                if (_Lead_byte < 0b1100'0000u) { // out-of-sequence trailing byte
+                    return error;
+                }
+
+                // lead byte of 2-byte sequence
+                _Lead_byte &= 0b0001'1111u;
+            } else if (_Lead_byte < 0b1111'0000u) { // lead byte of 3-byte sequence
+                _Lead_byte &= 0b0000'1111u;
+                _Trailing_count = 2;
+            } else if (_Lead_byte < 0b1111'1000u) { // lead byte of 4-byte sequence
+                if (_Last2 - _First2 < 2) { // not enough output for a surrogate pair
+                    return partial;
+                }
+
+                _Lead_byte &= 0b0000'0111u;
+                _Trailing_count = 3;
+            } else { // Invalid UTF-8 code unit
+                return error;
+            }
+
+            if (_Last1 - _First1 < _Trailing_count + 1) { // not enough input
+                return partial;
+            }
+
+            const char8_t* _Peek = _First1;
+            char32_t _Code_point = static_cast<char32_t>(_Lead_byte);
+            do {
+                const char8_t _By = *++_Peek;
+                if ((_By & 0b1100'0000u) != 0b1000'0000u) { // out-of-sequence lead byte
+                    return error;
+                }
+
+                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
+            } while (--_Trailing_count != 0);
+
+            if (_Code_point < 0x10000u) {
+                if (_Code_point >= 0xd800u && _Code_point < 0xe000u) { // invalid code point (surrogate)
+                    return error;
+                }
+                // Output single code unit
+                *_First2 = static_cast<char16_t>(_Code_point);
+            } else if (_Code_point >= 0x110000u) { // Invalid code point (out of range)
+                return error;
+            } else {
+                // Output surrogate pair
+                _Code_point -= 0x10000u;
+                // High surrogate: 0xd800 | <upper ten bits>
+                *_First2 = static_cast<char16_t>(0xd800u | (_Code_point >> 10));
+                // Low surrogate: 0xdc00 | <lower ten bits>
+                *++_First2 = static_cast<char16_t>(0xdc00u | (_Code_point & 0b11'1111'1111u));
+            }
+
+            _First1 = _Peek;
+        }
+
+        return ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t&, const char16_t* _First1, const char16_t* _Last1,
+        const char16_t*& _Mid1, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // convert UTF-16 [_First1, _Last1) to UTF-8 [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        _Codecvt_guard<char16_t, char8_t> _Guard{_First1, _Mid1, _First2, _Mid2};
+
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            if (_First2 == _Last2) { // no more output
+                return partial;
+            }
+
+            char32_t _Code_point = static_cast<char32_t>(*_First1);
+            if (_Code_point < 0x80u) { // encode 1-byte sequence
+                *_First2 = static_cast<char8_t>(_Code_point);
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Code_point < 0x800u) { // encode 2-byte sequence
+                *_First2 = static_cast<char8_t>(0b1100'0000u | (_Code_point >> 6));
+            } else if (_Code_point < 0xd800u || _Code_point >= 0xe000u) { // encode 3-byte sequence
+                *_First2        = static_cast<char8_t>(0b1110'0000u | (_Code_point >> 12));
+                _Trailing_count = 2;
+            } else if (_Code_point < 0xdc00u) { // high surrogate; parse the low surrogate
+                if (_Last1 - _First1 < 2) { // not enough input
+                    return partial;
+                }
+
+                const char16_t _Low_surrogate = *++_First1;
+                if (_Low_surrogate < 0xdc00u || _Low_surrogate >= 0xe000u) { // invalid low surrogate
+                    --_First1;
+                    return error;
+                }
+                _Code_point = 0x10000u + (((_Code_point & 0b11'1111'1111u) << 10) | (_Low_surrogate & 0b11'1111'1111u));
+
+                // encode 4-byte sequence
+                *_First2        = static_cast<char8_t>(0b1111'0000u | (_Code_point >> 18));
+                _Trailing_count = 3;
+            } else { // out-of-sequence low surrogate
+                return error;
+            }
+
+            if (_Last2 - _First2 < _Trailing_count + 1) { // not enough output
+                if (_Trailing_count > 2) { // input was a surrogate pair; revert
+                    --_First1;
+                }
+                return partial;
+            }
+
+            do {
+                --_Trailing_count;
+                *++_First2 = static_cast<char8_t>(0b1000'0000u | ((_Code_point >> (6 * _Trailing_count)) & 0b11'1111u));
+            } while (_Trailing_count != 0);
+        }
+
+        return ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t&, char8_t* _First2, char8_t*, char8_t*& _Mid2) const {
+        // terminate encoding sequence
+        _Mid2 = _First2;
+        return noconv; // no termination necessary
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t&, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-16 code units
+        _Adl_verify_range(_First1, _Last1);
+
+        const auto _Old_first1 = _First1;
+
+        for (; _First1 != _Last1 && _Count > 0u; ++_First1, --_Count) {
+            char32_t _Code_point = static_cast<char32_t>(*_First1);
+            if (_Code_point < 0b1000'0000u) { // single-byte sequence
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Code_point < 0b1110'0000u) {
+                if (_Code_point < 0b1100'0000u) { // out-of-sequence trailing byte
+                    break;
+                }
+
+                // lead byte of 2-byte sequence
+                _Code_point &= 0b0001'1111u;
+            } else if (_Code_point < 0b1111'0000u) { // lead byte of 3-byte sequence
+                _Code_point &= 0b0000'1111u;
+                _Trailing_count = 2;
+            } else if (_Code_point < 0b1111'1000u) { // lead byte of 4-byte sequence
+                if (_Count < 2u) { // not enough output
+                    break;
+                }
+
+                _Code_point &= 0b0000'0111u;
+                _Trailing_count = 3;
+            } else { // Invalid UTF-8 code unit
+                break;
+            }
+
+            if (_Last1 - _First1 < _Trailing_count + 1) { // not enough input
+                break;
+            }
+
+            const char8_t* _Peek = _First1;
+            bool _Done           = false;
+            do {
+                const char8_t _By = *++_Peek;
+                if ((_By & 0b1100'0000u) != 0b1000'0000u) { // out-of-sequence lead byte
+                    _Done = true;
+                    break;
+                }
+
+                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
+            } while (--_Trailing_count != 0);
+
+            if (_Done) {
+                break;
+            }
+
+            if (_Code_point < 0x10000u) { // Output single code unit
+                if (_Code_point >= 0xd800u && _Code_point < 0xe0000u) { // invalid code point (surrogate)
+                    break;
+                }
+            } else if (_Code_point < 0x110000u) { // Output surrogate pair
+                --_Count;
+            } else { // Invalid code point (out of range)
+                break;
+            }
+
+            _First1 = _Peek;
+        }
+
+        return static_cast<int>((_STD min) (_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        return 4; // 4-byte max input sequence
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return 0; // 0 => varying length
+    }
+};
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt<char32_t, char8_t, mbstate_t> : public codecvt_base {
+    // facet for converting between UTF-32 and UTF-8 sequences
+public:
+    using intern_type = char32_t;
+    using extern_type = char8_t;
+    using state_type  = mbstate_t;
+
+    result in(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, const char8_t*& _Mid1,
+        char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
+        // convert UTF-8 [_First1, _Last1) to UTF-32 [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1, const char32_t*& _Mid1,
+        char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // convert UTF-32 [_First1, _Last1) to UTF-8 [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result unshift(mbstate_t& _State, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int length(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-32 code units
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    _CRT_SATELLITE_CODECVT_IDS static locale::id id;
+
+    explicit codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {} // construct "from current locale"
+    explicit codecvt(const _Locinfo&, size_t _Refs = 0) : codecvt_base(_Refs) {} // construct "from specified locale"
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt;
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override = default;
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t&, const char8_t* _First1, const char8_t* _Last1,
+        const char8_t*& _Mid1, char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
+        // convert UTF-8 [_First1, _Last1) to UTF-32 [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        _Codecvt_guard<char8_t, char32_t> _Guard{_First1, _Mid1, _First2, _Mid2};
+
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            if (_First2 == _Last2) {
+                return partial;
+            }
+
+            char8_t _Lead_byte = *_First1;
+            if (_Lead_byte < 0b1000'0000u) { // single-byte sequence
+                *_First2 = static_cast<char32_t>(_Lead_byte);
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Lead_byte < 0b1110'0000u) {
+                if (_Lead_byte < 0b1100'0000u) { // out-of-sequence trailing byte
+                    return partial;
+                }
+
+                // lead byte of 2-byte sequence
+                _Lead_byte &= 0b0001'1111u;
+            } else if (_Lead_byte < 0b1111'0000u) { // lead byte of 3-byte sequence
+                _Lead_byte &= 0b0000'1111u;
+                _Trailing_count = 2;
+            } else if (_Lead_byte < 0b1111'1000u) { // lead byte of 4-byte sequence
+                _Lead_byte &= 0b0000'0111u;
+                _Trailing_count = 3;
+            } else { // invalid UTF-8 code unit
+                return error;
+            }
+
+            if (_Last1 - _First1 < _Trailing_count + 1) { // not enough input
+                return partial;
+            }
+
+            const char8_t* _Peek = _First1;
+            char32_t _Code_point = static_cast<char32_t>(_Lead_byte);
+            do {
+                const char8_t _By = *++_Peek;
+                if ((_By & 0b1100'0000u) != 0b1000'0000u) { // out-of-sequence lead byte
+                    return error;
+                }
+
+                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
+            } while (--_Trailing_count != 0);
+
+            if (_Code_point >= 0xd800u && (_Code_point < 0xe000u || _Code_point >= 0x110000u)) {
+                // invalid code point (surrogate or out of range)
+                return error;
+            }
+
+            _First1  = _Peek;
+            *_First2 = _Code_point;
+        }
+
+        return ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t&, const char32_t* _First1, const char32_t* _Last1,
+        const char32_t*& _Mid1, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
+        // convert UTF-32 [_First1, _Last1) to UTF-8 [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+
+        _Codecvt_guard<char32_t, char8_t> _Guard{_First1, _Mid1, _First2, _Mid2};
+
+        for (; _First1 != _Last1; ++_First1, ++_First2) {
+            if (_First2 == _Last2) { // no more output
+                return partial;
+            }
+
+            const char32_t _Code_point = *_First1;
+            if (_Code_point < 0x80u) { // encode 1-byte sequence
+                *_First2 = static_cast<char8_t>(_Code_point);
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Code_point < 0x800u) { // encode 2-byte sequence
+                *_First2 = static_cast<char8_t>(0b1100'0000u | (_Code_point >> 6));
+            } else if (_Code_point < 0x10000u) { // encode 3-byte sequence
+                if (_Code_point >= 0xd800u && _Code_point < 0xe000u) { // invalid code point (surrogate)
+                    return error;
+                }
+
+                *_First2        = static_cast<char8_t>(0b1110'0000u | (_Code_point >> 12));
+                _Trailing_count = 2;
+            } else if (_Code_point < 0x110000u) { // encode 4-byte sequence
+                *_First2        = static_cast<char8_t>(0b1111'0000u | (_Code_point >> 18));
+                _Trailing_count = 3;
+            } else { // Invalid code point (out of range)
+                return error;
+            }
+
+            if (_Last2 - _First2 < _Trailing_count + 1) { // not enough output
+                return partial;
+            }
+
+            do {
+                --_Trailing_count;
+                *++_First2 = static_cast<char8_t>(0b1000'0000u | ((_Code_point >> (6 * _Trailing_count)) & 0b11'1111u));
+            } while (_Trailing_count != 0);
+        }
+
+        return ok;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t&, char8_t* _First2, char8_t*, char8_t*& _Mid2) const {
+        // terminate encoding sequence
+        _Mid2 = _First2;
+        return noconv; // no termination necessary
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t&, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count UTF-32 code units
+        _Adl_verify_range(_First1, _Last1);
+
+        const auto _Old_first1 = _First1;
+
+        for (; _First1 != _Last1 && _Count > 0u; ++_First1, --_Count) {
+            char32_t _Code_point = static_cast<char32_t>(*_First1);
+            if (_Code_point < 0b1000'0000u) { // single-byte sequence
+                continue;
+            }
+
+            int _Trailing_count = 1;
+            if (_Code_point < 0b1110'0000u) {
+                if (_Code_point < 0b1100'0000u) { // out-of-sequence trailing byte
+                    break;
+                }
+
+                // lead byte of 2-byte sequence
+                _Code_point &= 0b0001'1111u;
+            } else if (_Code_point < 0b1111'0000u) { // lead byte of 3-byte sequence
+                _Code_point &= 0b0000'1111u;
+                _Trailing_count = 2;
+            } else if (_Code_point < 0b1111'1000u) { // lead byte of 4-byte sequence
+                _Code_point &= 0b0000'0111u;
+                _Trailing_count = 3;
+            } else { // invalid UTF-8 code unit
+                break;
+            }
+
+            if (_Last1 - _First1 < _Trailing_count + 1) { // not enough input
+                break;
+            }
+
+            const char8_t* _Peek = _First1;
+            bool _Done           = false;
+            do {
+                const char8_t _By = *++_Peek;
+                if ((_By & 0b1100'0000u) != 0b1000'0000u) { // out-of-sequence lead byte
+                    _Done = true;
+                    break;
+                }
+
+                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
+            } while (--_Trailing_count != 0);
+
+            if (_Done || (_Code_point >= 0xd800u && (_Code_point < 0xe000u || _Code_point >= 0x110000u))) {
+                // invalid code point (surrogate or out of range)
+                break;
+            }
+
+            _First1 = _Peek;
+        }
+
+        return static_cast<int>((_STD min) (_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion
+        return 4;
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return 0; // varying length
+    }
+};
+#endif // defined(__cpp_char8_t) && !defined(_M_CEE_PURE)
+
+template <>
+class _CRTIMP2_PURE_IMPORT codecvt<wchar_t, char, mbstate_t> : public codecvt_base {
+    // facet for converting between wchar_t and char (_Byte) sequences
+public:
+    using intern_type = wchar_t;
+    using extern_type = char;
+    using state_type  = mbstate_t;
+
+    result __CLR_OR_THIS_CALL in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
+        wchar_t* _First2, wchar_t* _Last2, wchar_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(mbstate_t& _State, const wchar_t* _First1, const wchar_t* _Last1,
+        const wchar_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count wide characters
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Cvt = _Lobj._Getcvt();
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t&, const char* _First1, const char* _Last1, const char*& _Mid1,
+        wchar_t* _First2, wchar_t* _Last2, wchar_t*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        mbstate_t _Mystate{};
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        for (;;) {
+            if (_Mid1 == _Last1) {
+                return ok;
+            }
+
+            if (_Mid2 == _Last2) {
+                return partial;
+            }
+
+            int _Bytes = _Mbrtowc(_Mid2, _Mid1, static_cast<size_t>(_Last1 - _Mid1), &_Mystate, &_Cvt);
+            switch (_Bytes) {
+            case -2: // partial conversion
+                return partial;
+
+            case -1: // failed conversion
+                return error;
+
+            case 0: // converted NULL character, TRANSITION, VSO-654347
+                _Bytes = 1;
+                _FALLTHROUGH;
+
+            default: // converted some other character
+                _Mid1 += _Bytes;
+                ++_Mid2;
+                break;
+            }
+        }
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t& _State, const wchar_t* _First1, const wchar_t* _Last1,
+        const wchar_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        int _Bytes;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) {
+            if (MB_LEN_MAX <= _Last2 - _Mid2) {
+                if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1, &_State, &_Cvt)) < 0) {
+                    return error; // locale-specific wcrtomb failed
+                } else {
+                    ++_Mid1;
+                    _Mid2 += _Bytes;
+                }
+            } else { // destination too small, convert into buffer
+                char _Buf[MB_LEN_MAX];
+                mbstate_t _Stsave = _State;
+
+                if ((_Bytes = _Wcrtomb(_Buf, *_Mid1, &_State, &_Cvt)) < 0) {
+                    return error; // locale-specific wcrtomb failed
+                } else if (_Last2 - _Mid2 < _Bytes) { // converted too many, roll back and return previous
+                    _State = _Stsave;
+                    break;
+                } else { // copy converted bytes from buffer
+                    _CSTD memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
+                    ++_Mid1;
+                    _Mid2 += _Bytes;
+                }
+            }
+        }
+
+        return _Mid1 == _Last1 ? ok : partial;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        _Adl_verify_range(_First2, _Last2);
+        _Mid2       = _First2;
+        result _Ans = ok;
+        int _Bytes;
+        char _Buf[MB_LEN_MAX];
+        mbstate_t _Stsave = _State;
+
+        if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0) {
+            _Ans = error; // locale-specific wcrtomb failed
+        } else if (_Last2 - _Mid2 < --_Bytes) { // converted too many, roll back and return
+            _State = _Stsave;
+            _Ans   = partial;
+        } else if (0 < _Bytes) { // copy converted bytes from buffer
+            _CSTD memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
+            _Mid2 += _Bytes;
+        }
+        return _Ans;
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count wide characters
+        _Adl_verify_range(_First1, _Last1);
+        const auto _Old_first1 = _First1;
+
+        for (; _Count > 0u && _First1 != _Last1; --_Count) {
+            wchar_t _Ch;
+            int _Bytes = _Mbrtowc(&_Ch, _First1, static_cast<size_t>(_Last1 - _First1), &_State, &_Cvt);
+            if (_Bytes < 0) { // partial or failed conversion
+                break;
+            }
+
+            if (_Bytes == 0) { // converted NULL character, TRANSITION, VSO-654347
+                _Bytes = 1;
+            }
+
+            // converted _Bytes bytes to a wide character
+            _First1 += _Bytes;
+        }
+
+        return static_cast<int>((_STD min) (_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion (from codecvt)
+        return static_cast<int>(_Cvt._Mbcurmax);
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return _Cvt._Mbcurmax == 1; // 0 => varying length, 1 => fixed length
+    }
+
+private:
+    _Locinfo::_Cvtvec _Cvt; // locale info passed to _Mbrtowc, _Wcrtomb
+};
+
+#if defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+template <>
+class _CRTIMP2_PURE_IMPORT codecvt<unsigned short, char, mbstate_t> : public codecvt_base {
+    // facet for converting between unsigned short and char sequences
+public:
+    using intern_type = unsigned short;
+    using extern_type = char;
+    using state_type  = mbstate_t;
+
+    result __CLR_OR_THIS_CALL in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
+        unsigned short* _First2, unsigned short* _Last2, unsigned short*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL out(mbstate_t& _State, const unsigned short* _First1, const unsigned short* _Last1,
+        const unsigned short*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
+    }
+
+    result __CLR_OR_THIS_CALL unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        return do_unshift(_State, _First2, _Last2, _Mid2);
+    }
+
+    int __CLR_OR_THIS_CALL length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count _Elems
+        return do_length(_State, _First1, _Last1, _Count);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    explicit __CLR_OR_THIS_CALL codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new codecvt(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Cvt = _Lobj._Getcvt();
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_in(mbstate_t&, const char* _First1, const char* _Last1, const char*& _Mid1,
+        unsigned short* _First2, unsigned short* _Last2, unsigned short*& _Mid2) const {
+        // convert bytes [_First1, _Last1) to [_First2, _Last2)
+        mbstate_t _Mystate{};
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        for (;;) {
+            if (_Mid1 == _Last1) {
+                return ok;
+            }
+
+            if (_Mid2 == _Last2) {
+                return partial;
+            }
+
+            int _Bytes = _Mbrtowc(
+                reinterpret_cast<wchar_t*>(_Mid2), _Mid1, static_cast<size_t>(_Last1 - _Mid1), &_Mystate, &_Cvt);
+            switch (_Bytes) {
+            case -2: // partial conversion
+                return partial;
+
+            case -1: // failed conversion
+                return error;
+
+            case 0: // converted NULL character, TRANSITION, VSO-654347
+                _Bytes = 1;
+                _FALLTHROUGH;
+
+            default: // converted some other character
+                _Mid1 += _Bytes;
+                ++_Mid2;
+                break;
+            }
+        }
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_out(mbstate_t& _State, const unsigned short* _First1,
+        const unsigned short* _Last1, const unsigned short*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
+        // convert [_First1, _Last1) to bytes [_First2, _Last2)
+        _Adl_verify_range(_First1, _Last1);
+        _Adl_verify_range(_First2, _Last2);
+        _Mid1 = _First1;
+        _Mid2 = _First2;
+        int _Bytes;
+
+        while (_Mid1 != _Last1 && _Mid2 != _Last2) {
+            if (MB_LEN_MAX <= _Last2 - _Mid2) {
+                if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1, &_State, &_Cvt)) < 0) {
+                    return error; // locale-specific wcrtomb failed
+                } else {
+                    ++_Mid1;
+                    _Mid2 += _Bytes;
+                }
+            } else { // destination too small, convert into buffer
+                char _Buf[MB_LEN_MAX];
+                mbstate_t _Stsave = _State;
+
+                if ((_Bytes = _Wcrtomb(_Buf, *_Mid1, &_State, &_Cvt)) < 0) {
+                    return error; // locale-specific wcrtomb failed
+                } else if (_Last2 - _Mid2 < _Bytes) { // converted too many, roll back and return previous
+                    _State = _Stsave;
+                    break;
+                } else { // copy converted bytes from buffer
+                    _CSTD memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
+                    ++_Mid1;
+                    _Mid2 += _Bytes;
+                }
+            }
+        }
+
+        return _Mid1 == _Last1 ? ok : partial;
+    }
+
+    virtual result __CLR_OR_THIS_CALL do_unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
+        // generate bytes to return to default shift state
+        _Adl_verify_range(_First2, _Last2);
+        _Mid2       = _First2;
+        result _Ans = ok;
+        int _Bytes;
+        char _Buf[MB_LEN_MAX];
+        mbstate_t _Stsave = _State;
+
+        if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0) {
+            _Ans = error; // locale-specific wcrtomb failed
+        } else if (_Last2 - _Mid2 < --_Bytes) { // converted too many, roll back and return
+            _State = _Stsave;
+            _Ans   = partial;
+        } else if (0 < _Bytes) { // copy converted bytes from buffer
+            _CSTD memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
+            _Mid2 += _Bytes;
+        }
+
+        return _Ans;
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_length(
+        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
+        // return p - _First1, for the largest value p in [_First1, _Last1] such that [_First1, p) successfully
+        // converts to at most _Count wide characters
+        _Adl_verify_range(_First1, _Last1);
+        const auto _Old_first1 = _First1;
+
+        for (; _Count > 0u && _First1 != _Last1; --_Count) {
+            wchar_t _Ch;
+            int _Bytes = _Mbrtowc(&_Ch, _First1, static_cast<size_t>(_Last1 - _First1), &_State, &_Cvt);
+            if (_Bytes < 0) { // partial or failed conversion
+                break;
+            }
+
+            if (_Bytes == 0) { // converted NULL character, TRANSITION, VSO-654347
+                _Bytes = 1;
+            }
+
+            // converted _Bytes bytes to a wide character
+            _First1 += _Bytes;
+        }
+
+        return static_cast<int>((_STD min) (_First1 - _Old_first1, ptrdiff_t{INT_MAX}));
+    }
+
+    bool __CLR_OR_THIS_CALL do_always_noconv() const noexcept override {
+        // return true if conversions never change input
+        return false;
+    }
+
+    int __CLR_OR_THIS_CALL do_max_length() const noexcept override {
+        // return maximum length required for a conversion (from codecvt)
+        return static_cast<int>(_Cvt._Mbcurmax);
+    }
+
+    int __CLR_OR_THIS_CALL do_encoding() const noexcept override {
+        // return length of code sequence (from codecvt)
+        return _Cvt._Mbcurmax == 1u; // 0 => varying length, 1 => fixed length
+    }
+
+private:
+    _Locinfo::_Cvtvec _Cvt; // locale info passed to _Mbrtowc, _Wcrtomb
+};
+#endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+
+} // extern "C++"
+
+_EXPORT_STD template <class _Elem, class _Byte, class _Statype>
+class codecvt_byname : public codecvt<_Elem, _Byte, _Statype> {
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS
+                      || _Is_any_of_v<codecvt_byname, codecvt_byname<char, char, mbstate_t>,
+                          codecvt_byname<wchar_t, char, mbstate_t>>,
+        _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_FACETS
+    codecvt_byname<char16_t, char, mbstate_t> : public codecvt<char16_t, char, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_FACETS
+    codecvt_byname<char32_t, char, mbstate_t> : public codecvt<char32_t, char, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+#ifdef __cpp_char8_t
+template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS
+    codecvt_byname<char16_t, char8_t, mbstate_t> : public codecvt<char16_t, char8_t, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS
+    codecvt_byname<char32_t, char8_t, mbstate_t> : public codecvt<char32_t, char8_t, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+#endif // defined(__cpp_char8_t)
+
+_STL_RESTORE_DEPRECATED_WARNING
+
+#define _XA 0x100 // extra alphabetic
+#define _BB _CONTROL // BEL, BS, etc.
+#define _CN _SPACE // CR, FF, HT, NL, VT
+#define _DI _DIGIT // '0'-'9'
+#define _LO _LOWER // 'a'-'z'
+#define _PU _PUNCT // punctuation
+#define _SP _BLANK // space
+#define _UP _UPPER // 'A'-'Z'
+#define _XD _HEX // '0'-'9', 'A'-'F', 'a'-'f'
+
+struct _Ctype_constants_base {
+    using mask = short; // to match <ctype.h>
+
+    // constants for character classifications
+
+    static constexpr mask alnum  = _DI | _LO | _UP | _XA;
+    static constexpr mask alpha  = _LO | _UP | _XA;
+    static constexpr mask cntrl  = _BB;
+    static constexpr mask digit  = _DI;
+    static constexpr mask graph  = _DI | _LO | _PU | _UP | _XA;
+    static constexpr mask lower  = _LO;
+    static constexpr mask print  = _DI | _LO | _PU | _SP | _UP | _XA | _XD;
+    static constexpr mask punct  = _PU;
+    static constexpr mask space  = _CN | _SP;
+    static constexpr mask upper  = _UP;
+    static constexpr mask xdigit = _XD;
+    static constexpr mask blank  = _CN | _SP;
+};
+
+_EXPORT_STD extern "C++" struct _CRTIMP2_PURE_IMPORT __declspec(empty_bases) ctype_base // base for ctype
+    : locale::facet, // TRANSITION, ABI, shouldn't be derived from locale::facet
+      _Ctype_constants_base // TRANSITION, ABI, avoid affecting DLL interface
+{
+    __CLR_OR_THIS_CALL ctype_base(size_t _Refs = 0) noexcept // strengthened
+        : locale::facet(_Refs) {}
+
+    __CLR_OR_THIS_CALL ~ctype_base() noexcept override {}
+};
+
+#undef _XA
+#undef _BB
+#undef _CN
+#undef _DI
+#undef _LO
+#undef _PU
+#undef _SP
+#undef _UP
+#undef _XD
+
+_EXPORT_STD extern "C++" template <class _Elem>
+class ctype : public ctype_base { // facet for classifying elements, converting cases
+public:
+    // ctype<char>, ctype<wchar_t>, and ctype<unsigned short> are explicitly specialized below.
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type = _Elem;
+
+    bool __CLR_OR_THIS_CALL is(mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return do_is(_Maskval, _Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        return do_is(_First, _Last, _Dest);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        return do_scan_is(_Maskval, _First, _Last);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        return do_scan_not(_Maskval, _First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL tolower(_Elem _Ch) const { // convert element to lower case
+        return do_tolower(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL tolower(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        return do_tolower(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL toupper(_Elem _Ch) const { // convert element to upper case
+        return do_toupper(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL toupper(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        return do_toupper(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // widen char
+        return do_widen(_Byte);
+    }
+
+    const char* __CLR_OR_THIS_CALL widen(const char* _First, const char* _Last,
+        _Elem* _Dest) const { // widen chars in [_First, _Last)
+        return do_widen(_First, _Last, _Dest);
+    }
+
+    char __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // narrow element to char
+        return do_narrow(_Ch, _Dflt);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        return do_narrow(_First, _Last, _Dflt, _Dest);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL ctype(size_t _Refs = 0) : ctype_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype() noexcept override {
+        if (_Ctype._Delfl) {
+            _CSTD free(const_cast<short*>(_Ctype._Table));
+        }
+
+        _CSTD free(_Ctype._LocaleName);
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Ctype = _Lobj._Getctype();
+        _Cvt   = _Lobj._Getcvt();
+    }
+
+    virtual bool __CLR_OR_THIS_CALL do_is(
+        mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return (_Ctype._Table[static_cast<unsigned char>(narrow(_Ch))] & _Maskval) != 0;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Ctype._Table[static_cast<unsigned char>(narrow(*_First))];
+        }
+
+        return _First;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && !is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_tolower(_Elem _Ch) const { // convert element to lower case
+        unsigned char _Byte = static_cast<unsigned char>(narrow(_Ch, '\0'));
+        if (_Byte == '\0') {
+            return _Ch;
+        }
+
+        return widen(static_cast<char>(_Tolower(_Byte, &_Ctype)));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_tolower(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) { // convert *_First to lower case
+            unsigned char _Byte = static_cast<unsigned char>(narrow(*_First, '\0'));
+            if (_Byte != '\0') {
+                *_First = (widen(static_cast<char>(_Tolower(_Byte, &_Ctype))));
+            }
+        }
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_toupper(_Elem _Ch) const { // convert element to upper case
+        unsigned char _Byte = static_cast<unsigned char>(narrow(_Ch, '\0'));
+        if (_Byte == '\0') {
+            return _Ch;
+        }
+
+        return widen(static_cast<char>(_Toupper(_Byte, &_Ctype)));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_toupper(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) { // convert *_First to upper case
+            unsigned char _Byte = static_cast<unsigned char>(narrow(*_First, '\0'));
+            if (_Byte != '\0') {
+                *_First = (widen(static_cast<char>(_Toupper(_Byte, &_Ctype))));
+            }
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_widen(char _Byte) const { // widen char
+        return _Maklocchr<_Elem>(_Byte, _Cvt);
+    }
+
+    virtual const char* __CLR_OR_THIS_CALL do_widen(
+        const char* _First, const char* _Last, _Elem* _Dest) const { // widen chars in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Maklocchr<_Elem>(*_First, _Cvt);
+        }
+
+        return _First;
+    }
+
+    char __CLR_OR_THIS_CALL _Donarrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        char _Byte;
+        if (_Ch == _Elem{}) {
+            return '\0';
+        }
+
+        if ((_Byte = _Maklocbyte(_Ch, _Cvt)) == '\0') {
+            return _Dflt;
+        }
+
+        return _Byte;
+    }
+
+    virtual char __CLR_OR_THIS_CALL do_narrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        return _Donarrow(_Ch, _Dflt);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Donarrow(*_First, _Dflt);
+        }
+
+        return _First;
+    }
+
+private:
+    _Locinfo::_Ctypevec _Ctype; // locale info passed to _Tolower, etc.
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem>
+locale::id ctype<_Elem>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+extern "C++" {
+
+template <>
+class _CRTIMP2_PURE_IMPORT ctype<char> : public ctype_base { // facet for classifying char elements, converting cases
+public:
+    using _Elem     = char;
+    using char_type = _Elem;
+
+    bool __CLR_OR_THIS_CALL is(mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return (_Ctype._Table[static_cast<unsigned char>(_Ch)] & _Maskval) != 0;
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Ctype._Table[static_cast<unsigned char>(*_First)];
+        }
+
+        return _First;
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && !is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    _Elem __CLR_OR_THIS_CALL tolower(_Elem _Ch) const { // convert element to lower case
+        return do_tolower(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL tolower(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        return do_tolower(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL toupper(_Elem _Ch) const { // convert element to upper case
+        return do_toupper(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL toupper(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        return do_toupper(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // widen char
+        return do_widen(_Byte);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL widen(const char* _First, const char* _Last,
+        _Elem* _Dest) const { // widen chars in [_First, _Last)
+        return do_widen(_First, _Last, _Dest);
+    }
+
+    _Elem __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // narrow element to char
+        return do_narrow(_Ch, _Dflt);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        return do_narrow(_First, _Last, _Dflt, _Dest);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL ctype(const mask* _Table = nullptr, bool _Deletetable = false,
+        size_t _Refs = 0)
+        : ctype_base(_Refs) { // construct with specified table and delete flag for table
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+
+        _Tidy(); // free existing table, as needed
+        if (_Table) { // replace existing char to mask table
+            _Ctype._Table = _Table;
+            _Ctype._Delfl = _Deletetable ? -1 : 0;
+        } else { // use classic table
+            _Ctype._Table = classic_table();
+            _Ctype._Delfl = 0;
+        }
+    }
+
+    __CLR_OR_THIS_CALL ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+    const mask* __CLR_OR_THIS_CALL table() const noexcept {
+        return _Ctype._Table;
+    }
+
+    static const mask* __CLRCALL_OR_CDECL classic_table() noexcept {
+        return _STD use_facet<ctype>(locale::classic()).table();
+    }
+
+    _PGLOBAL static const size_t table_size = 1 << CHAR_BIT; // size of ctype mapping table, typically 256
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype() noexcept override {
+        _Tidy();
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Ctype = _Lobj._Getctype();
+    }
+
+    void __CLR_OR_THIS_CALL _Tidy() noexcept { // free any allocated storage
+        if (0 < _Ctype._Delfl) {
+            _CSTD free(const_cast<short*>(_Ctype._Table));
+        } else if (_Ctype._Delfl < 0) {
+            delete[] _Ctype._Table;
+        }
+
+        _CSTD free(_Ctype._LocaleName);
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_tolower(_Elem _Ch) const { // convert element to lower case
+        return static_cast<_Elem>(_Tolower(static_cast<unsigned char>(_Ch), &_Ctype));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_tolower(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = static_cast<_Elem>(_Tolower(static_cast<unsigned char>(*_First), &_Ctype));
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_toupper(_Elem _Ch) const { // convert element to upper case
+        return static_cast<_Elem>(_Toupper(static_cast<unsigned char>(_Ch), &_Ctype));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_toupper(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = static_cast<_Elem>(_Toupper(static_cast<unsigned char>(*_First), &_Ctype));
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_widen(char _Byte) const { // widen char
+        return _Byte;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_widen(
+        const char* _First, const char* _Last, _Elem* _Dest) const { // widen chars in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        _CSTD memcpy(_Dest, _First, static_cast<size_t>(_Last - _First));
+        return _Last;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_narrow(_Elem _Ch, char) const { // narrow char
+        return _Ch;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_narrow(const _Elem* _First, const _Elem* _Last, char,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        _Adl_verify_range(_First, _Last);
+        _CSTD memcpy(_Dest, _First, static_cast<size_t>(_Last - _First));
+        return _Last;
+    }
+
+private:
+    _Locinfo::_Ctypevec _Ctype; // information
+};
+
+template <>
+class _CRTIMP2_PURE_IMPORT
+    ctype<wchar_t> : public ctype_base { // facet for classifying wchar_t elements, converting cases
+public:
+    using _Elem     = wchar_t;
+    using char_type = _Elem;
+
+    bool __CLR_OR_THIS_CALL is(mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return do_is(_Maskval, _Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        return do_is(_First, _Last, _Dest);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        return do_scan_is(_Maskval, _First, _Last);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        return do_scan_not(_Maskval, _First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL tolower(_Elem _Ch) const { // convert element to lower case
+        return do_tolower(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL tolower(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        return do_tolower(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL toupper(_Elem _Ch) const { // convert element to upper case
+        return do_toupper(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL toupper(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        return do_toupper(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // widen char
+        return do_widen(_Byte);
+    }
+
+    const char* __CLR_OR_THIS_CALL widen(const char* _First, const char* _Last,
+        _Elem* _Dest) const { // widen chars in [_First, _Last)
+        return do_widen(_First, _Last, _Dest);
+    }
+
+    char __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // narrow element to char
+        return do_narrow(_Ch, _Dflt);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        return do_narrow(_First, _Last, _Dflt, _Dest);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL ctype(size_t _Refs = 0) : ctype_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype() noexcept override {
+        if (_Ctype._Delfl) {
+            _CSTD free(const_cast<short*>(_Ctype._Table));
+        }
+
+        _CSTD free(_Ctype._LocaleName);
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Ctype = _Lobj._Getctype();
+        _Cvt   = _Lobj._Getcvt();
+    }
+
+    virtual bool __CLR_OR_THIS_CALL do_is(
+        mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return (_CSTD _Getwctype(_Ch, &_Ctype) & _Maskval) != 0;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        return _CSTD _Getwctypes(_First, _Last, _Dest, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && !is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_tolower(_Elem _Ch) const { // convert element to lower case
+        return _Towlower(_Ch, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_tolower(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = _Towlower(*_First, &_Ctype);
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_toupper(_Elem _Ch) const { // convert element to upper case
+        return _Towupper(_Ch, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_toupper(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = _Towupper(*_First, &_Ctype);
+        }
+
+        return _First;
+    }
+
+    _Elem __CLR_OR_THIS_CALL _Dowiden(char _Byte) const { // widen char
+        mbstate_t _Mbst = {};
+        wchar_t _Wc;
+        return _Mbrtowc(&_Wc, &_Byte, 1, &_Mbst, &_Cvt) < 0 ? static_cast<wchar_t>(WEOF) : _Wc;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_widen(char _Byte) const { // widen char
+        return _Dowiden(_Byte);
+    }
+
+    virtual const char* __CLR_OR_THIS_CALL do_widen(
+        const char* _First, const char* _Last, _Elem* _Dest) const { // widen chars in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Dowiden(*_First);
+        }
+
+        return _First;
+    }
+
+    char __CLR_OR_THIS_CALL _Donarrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        char _Buf[MB_LEN_MAX];
+        mbstate_t _Mbst = {};
+        return _Wcrtomb(_Buf, _Ch, &_Mbst, &_Cvt) != 1 ? _Dflt : _Buf[0];
+    }
+
+    virtual char __CLR_OR_THIS_CALL do_narrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        return _Donarrow(_Ch, _Dflt);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Donarrow(*_First, _Dflt);
+        }
+
+        return _First;
+    }
+
+private:
+    _Locinfo::_Ctypevec _Ctype; // locale info passed to _Tolower, etc.
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+
+#if defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+template <>
+class _CRTIMP2_PURE_IMPORT
+    ctype<unsigned short> : public ctype_base { // facet for classifying unsigned short elements, converting cases
+public:
+    using _Elem     = unsigned short;
+    using char_type = _Elem;
+
+    bool __CLR_OR_THIS_CALL is(mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return do_is(_Maskval, _Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        return do_is(_First, _Last, _Dest);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        return do_scan_is(_Maskval, _First, _Last);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        return do_scan_not(_Maskval, _First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL tolower(_Elem _Ch) const { // convert element to lower case
+        return do_tolower(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL tolower(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        return do_tolower(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL toupper(_Elem _Ch) const { // convert element to upper case
+        return do_toupper(_Ch);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL toupper(
+        _Elem* _First, const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        return do_toupper(_First, _Last);
+    }
+
+    _Elem __CLR_OR_THIS_CALL widen(char _Byte) const { // widen char
+        return do_widen(_Byte);
+    }
+
+    const char* __CLR_OR_THIS_CALL widen(const char* _First, const char* _Last,
+        _Elem* _Dest) const { // widen chars in [_First, _Last)
+        return do_widen(_First, _Last, _Dest);
+    }
+
+    char __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const { // narrow element to char
+        return do_narrow(_Ch, _Dflt);
+    }
+
+    const _Elem* __CLR_OR_THIS_CALL narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        return do_narrow(_First, _Last, _Dflt, _Dest);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id;
+
+    explicit __CLR_OR_THIS_CALL ctype(size_t _Refs = 0) : ctype_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_CTYPE;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype() noexcept override {
+        if (_Ctype._Delfl) {
+            _CSTD free(const_cast<short*>(_Ctype._Table));
+        }
+
+        _CSTD free(_Ctype._LocaleName);
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Ctype = _Lobj._Getctype();
+        _Cvt   = _Lobj._Getcvt();
+    }
+
+    virtual bool __CLR_OR_THIS_CALL do_is(
+        mask _Maskval, _Elem _Ch) const { // test if element fits any mask classifications
+        return (_CSTD _Getwctype(_Ch, &_Ctype) & _Maskval) != 0;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_is(const _Elem* _First, const _Elem* _Last,
+        mask* _Dest) const { // get mask sequence for elements in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        return reinterpret_cast<const _Elem*>(_CSTD _Getwctypes(
+            reinterpret_cast<const wchar_t*>(_First), reinterpret_cast<const wchar_t*>(_Last), _Dest, &_Ctype));
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_is(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) that fits mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && !is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_scan_not(mask _Maskval, const _Elem* _First,
+        const _Elem* _Last) const { // find first in [_First, _Last) not fitting mask classification
+        _Adl_verify_range(_First, _Last);
+        while (_First != _Last && is(_Maskval, *_First)) {
+            ++_First;
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_tolower(_Elem _Ch) const { // convert element to lower case
+        return _Towlower(_Ch, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_tolower(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to lower case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = _Towlower(*_First, &_Ctype);
+        }
+
+        return _First;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_toupper(_Elem _Ch) const { // convert element to upper case
+        return _Towupper(_Ch, &_Ctype);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_toupper(_Elem* _First,
+        const _Elem* _Last) const { // convert [_First, _Last) in place to upper case
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First) {
+            *_First = _Towupper(*_First, &_Ctype);
+        }
+
+        return _First;
+    }
+
+    _Elem __CLR_OR_THIS_CALL _Dowiden(char _Byte) const { // widen char
+        mbstate_t _Mbst = {};
+        unsigned short _Wc;
+
+        if (_Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), &_Byte, 1, &_Mbst, &_Cvt) < 0) {
+            return static_cast<unsigned short>(WEOF);
+        }
+
+        return _Wc;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_widen(char _Byte) const { // widen char
+        return _Dowiden(_Byte);
+    }
+
+    virtual const char* __CLR_OR_THIS_CALL do_widen(
+        const char* _First, const char* _Last, _Elem* _Dest) const { // widen chars in [_First, _Last)
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Dowiden(*_First);
+        }
+
+        return _First;
+    }
+
+    char __CLR_OR_THIS_CALL _Donarrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        char _Buf[MB_LEN_MAX];
+        mbstate_t _Mbst = {};
+        return _Wcrtomb(_Buf, _Ch, &_Mbst, &_Cvt) != 1 ? _Dflt : _Buf[0];
+    }
+
+    virtual char __CLR_OR_THIS_CALL do_narrow(_Elem _Ch, char _Dflt) const { // narrow element to char
+        return _Donarrow(_Ch, _Dflt);
+    }
+
+    virtual const _Elem* __CLR_OR_THIS_CALL do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
+        char* _Dest) const { // narrow elements in [_First, _Last) to chars
+        _Adl_verify_range(_First, _Last);
+        for (; _First != _Last; ++_First, ++_Dest) {
+            *_Dest = _Donarrow(*_First, _Dflt);
+        }
+
+        return _First;
+    }
+
+private:
+    _Locinfo::_Ctypevec _Ctype; // locale info passed to _Tolower, etc.
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+#endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
+
+} // extern "C++"
+
+_EXPORT_STD template <class _Elem>
+class ctype_byname : public ctype<_Elem> { // ctype for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit __CLR_OR_THIS_CALL ctype_byname(const char* _Locname, size_t _Refs = 0)
+        : ctype<_Elem>(_Locinfo(_Locname), _Refs) {} // construct for named locale
+
+    explicit __CLR_OR_THIS_CALL ctype_byname(const string& _Str, size_t _Refs = 0)
+        : ctype<_Elem>(_Locinfo(_Str.c_str()), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~ctype_byname() noexcept override {}
+};
+
+enum class _Case_sensitive : bool { _Nope, _Yes };
+
+template <class _InIt, class _Elem>
+int _Getloctxt(_InIt& _First, _InIt& _Last, size_t _Numfields, const _Elem* _Ptr, const _Case_sensitive _Matching) {
+    // find field at _Ptr that matches longest in [_First, _Last)
+    for (size_t _Off = 0; _Ptr[_Off] != _Elem{}; ++_Off) {
+        if (_Ptr[_Off] == _Ptr[0]) {
+            ++_Numfields; // add fields with leading mark to initial count
+        }
+    }
+
+    string _Str(_Numfields, '\0'); // one column counter for each field
+    const ctype<_Elem>& _CType = _STD use_facet<ctype<_Elem>>(locale{});
+
+    int _Ans = -2; // no candidates so far
+    for (size_t _Column = 1;; ++_Column, (void) ++_First, _Ans = -1) { // test each element against all viable fields
+        bool _Prefix  = false; // seen at least one valid prefix
+        size_t _Off   = 0; // offset into fields
+        size_t _Field = 0; // current field number
+
+        for (; _Field < _Numfields; ++_Field) { // test element at _Column in field _Field
+            while (_Ptr[_Off] != _Elem{} && _Ptr[_Off] != _Ptr[0]) { // find beginning of field
+                ++_Off;
+            }
+
+            if (_Str[_Field] != '\0') {
+                _Off += _Str[_Field]; // skip tested columns in field
+            } else if (_Ptr[_Off += _Column] == _Ptr[0]
+                       || _Ptr[_Off] == _Elem{}) { // matched all of field, save as possible answer
+                _Str[_Field] = static_cast<char>(_Column < 127 ? _Column : 127); // save skip count if small enough
+                _Ans         = static_cast<int>(_Field); // save answer
+            } else if (_First == _Last
+                       || (_Matching == _Case_sensitive::_Yes
+                               ? _Ptr[_Off] != *_First
+                               : _CType.tolower(_Ptr[_Off]) != _CType.tolower(static_cast<_Elem>(*_First)))) {
+                _Str[_Field] = static_cast<char>(_Column < 127 ? _Column : 127); // no match, just save skip count
+            } else {
+                _Prefix = true; // still a valid prefix
+            }
+        }
+
+        if (!_Prefix || _First == _Last) {
+            break; // no pending prefixes or no input, give up
+        }
+    }
+    return _Ans; // return field number or negative value on failure
+}
+
+#if defined(_DLL_CPPLIB)
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT codecvt<char, char, mbstate_t>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("empty_bases")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCALE_
diff --git a/msvc-stl/stl/inc/xlocbuf b/msvc-stl/stl/inc/xlocbuf
new file mode 100644
index 0000000..a589169
--- /dev/null
+++ b/msvc-stl/stl/inc/xlocbuf
@@ -0,0 +1,507 @@
+// xlocbuf internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCBUF_
+#define _XLOCBUF_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <streambuf>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_STL_DISABLE_DEPRECATED_WARNING
+_EXPORT_STD template <class _Codecvt, class _Elem = wchar_t, class _Traits = char_traits<_Elem>>
+class _CXX17_DEPRECATE_CODECVT_HEADER wbuffer_convert
+    : public basic_streambuf<_Elem, _Traits> { // stream buffer associated with a codecvt facet
+private:
+    enum _Mode { _Unused, _Wrote, _Need, _Got, _Eof };
+    enum { _STRING_INC = 8 };
+
+public:
+    using _Mysb        = streambuf;
+    using _Byte_traits = char_traits<char>;
+
+    using int_type   = typename _Traits::int_type;
+    using pos_type   = typename _Traits::pos_type;
+    using off_type   = typename _Traits::off_type;
+    using state_type = typename _Codecvt::state_type;
+
+    wbuffer_convert() : _State(), _Pcvt(new _Codecvt), _Mystrbuf(nullptr), _Status(_Unused), _Nback(0) {
+        // construct without buffer pointer
+        _Loc = locale{_Loc, _Pcvt};
+    }
+
+    explicit wbuffer_convert(_Mysb* _Strbuf)
+        : _State(), _Pcvt(new _Codecvt), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
+        // construct with byte stream buffer pointer
+        _Loc = locale{_Loc, _Pcvt};
+    }
+
+    wbuffer_convert(_Mysb* _Strbuf, const _Codecvt* _Pcvt_arg)
+        : _State(), _Pcvt(_Pcvt_arg), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
+        // construct with byte stream buffer pointer and codecvt
+        _Loc = locale{_Loc, _Pcvt};
+    }
+
+    wbuffer_convert(_Mysb* _Strbuf, const _Codecvt* _Pcvt_arg, state_type _State_arg)
+        : _State(_State_arg), _Pcvt(_Pcvt_arg), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
+        // construct with byte stream buffer pointer, codecvt, and state
+        _Loc = locale{_Loc, _Pcvt};
+    }
+
+    ~wbuffer_convert() noexcept override {
+        while (_Status == _Wrote) { // put any trailing homing shift
+            if (_Str.size() < _STRING_INC) {
+                _Str.assign(_STRING_INC, '\0');
+            }
+
+            char* _Buf = &_Str[0];
+            char* _Dest;
+            switch (_Pcvt->unshift(_State, _Buf, _Buf + _Str.size(), _Dest)) { // test result of homing conversion
+            case _Codecvt::ok:
+                _Status = _Unused; // homed successfully
+                _FALLTHROUGH;
+
+            case _Codecvt::partial:
+                { // put any generated bytes
+                    ptrdiff_t _Count = _Dest - _Buf;
+                    if (0 < _Count
+                        && _Byte_traits::eq_int_type(
+                            _Byte_traits::eof(), static_cast<_Byte_traits::int_type>(_Mystrbuf->sputn(_Buf, _Count)))) {
+                        return; // write failed
+                    }
+
+                    if (_Status == _Wrote && _Count == 0) {
+                        _Str.append(_STRING_INC, '\0'); // try with more space
+                    }
+
+                    break;
+                }
+
+            case _Codecvt::noconv:
+                return; // nothing to do
+
+            default:
+                return; // conversion failed
+            }
+        }
+    }
+
+    _NODISCARD _Mysb* rdbuf() const {
+        return _Mystrbuf;
+    }
+
+    _Mysb* rdbuf(_Mysb* _Strbuf) { // set byte stream buffer pointer
+        _Mysb* _Oldstrbuf = _Mystrbuf;
+        _Mystrbuf         = _Strbuf;
+        return _Oldstrbuf;
+    }
+
+    _NODISCARD state_type state() const {
+        return _State;
+    }
+
+    wbuffer_convert(const wbuffer_convert&)            = delete;
+    wbuffer_convert& operator=(const wbuffer_convert&) = delete;
+
+protected:
+    int_type overflow(int_type _Meta = _Traits::eof()) override { // put an element to stream
+        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+            return _Traits::not_eof(_Meta); // EOF, return success code
+        } else if (!_Mystrbuf || 0 < _Nback || (_Status != _Unused && _Status != _Wrote)) {
+            return _Traits::eof(); // no buffer or reading, fail
+        } else { // put using codecvt facet
+            const _Elem _Ch = _Traits::to_char_type(_Meta);
+
+            if (_Str.size() < _STRING_INC) {
+                _Str.assign(_STRING_INC, '\0');
+            }
+
+            for (_Status = _Wrote;;) {
+                char* _Buf = &_Str[0];
+                const _Elem* _Src;
+                char* _Dest;
+
+                // test result of converting one element
+                switch (_Pcvt->out(_State, &_Ch, &_Ch + 1, _Src, _Buf, _Buf + _Str.size(), _Dest)) {
+                case _Codecvt::partial:
+                case _Codecvt::ok:
+                    { // converted something, try to put it out
+                        ptrdiff_t _Count = _Dest - _Buf;
+                        if (0 < _Count
+                            && _Byte_traits::eq_int_type(_Byte_traits::eof(),
+                                static_cast<_Byte_traits::int_type>(_Mystrbuf->sputn(_Buf, _Count)))) {
+                            return _Traits::eof(); // write failed
+                        }
+
+                        if (_Src != &_Ch) {
+                            return _Meta; // converted whole element
+                        }
+
+                        if (0 >= _Count) {
+                            if (_Str.size() >= 4 * _STRING_INC) {
+                                return _Traits::eof(); // conversion failed
+                            }
+
+                            _Str.append(_STRING_INC, '\0'); // try with more space
+                        }
+
+                        break;
+                    }
+
+                case _Codecvt::noconv:
+                    if (_Traits::eq_int_type(
+                            _Traits::eof(), static_cast<int_type>(_Mystrbuf->sputn(reinterpret_cast<const char*>(&_Ch),
+                                                static_cast<streamsize>(sizeof(_Elem)))))) {
+                        return _Traits::eof();
+                    }
+
+                    return _Meta; // put native byte order
+
+                default:
+                    return _Traits::eof(); // conversion failed
+                }
+            }
+        }
+    }
+
+    int_type pbackfail(int_type _Meta = _Traits::eof()) override { // put an element back to stream
+        if (_STD size(_Myback) <= _Nback || _Status == _Wrote) {
+            return _Traits::eof(); // nowhere to put back
+        } else { // enough room, put it back
+            if (!_Traits::eq_int_type(_Traits::eof(), _Meta)) {
+                _Myback[_Nback] = _Traits::to_char_type(_Meta);
+            }
+
+            ++_Nback;
+            if (_Status == _Unused) {
+                _Status = _Got;
+            }
+
+            return _Meta;
+        }
+    }
+
+    int_type underflow() override { // get an element from stream, but don't point past it
+        int_type _Meta;
+
+        if (0 >= _Nback) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Get_elem())) {
+                return _Meta; // _Get_elem failed, return EOF
+            }
+
+            _Myback[_Nback++] = _Traits::to_char_type(_Meta);
+        }
+
+        return _Traits::to_int_type(_Myback[_Nback - 1]);
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 6385) // Reading invalid data from 'this->_Myback':
+                                // the readable size is 'X' bytes, but 'Y' bytes may be read.
+    int_type uflow() override { // get an element from stream, point past it
+        int_type _Meta;
+
+        if (0 >= _Nback) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Get_elem())) {
+                return _Meta; // _Get_elem failed, return EOF
+            }
+
+            _Myback[_Nback++] = _Traits::to_char_type(_Meta);
+        }
+
+        return _Traits::to_int_type(_Myback[--_Nback]);
+    }
+#pragma warning(pop)
+
+    pos_type seekoff(off_type, ios_base::seekdir,
+        ios_base::openmode = static_cast<ios_base::openmode>(ios_base::in | ios_base::out)) override {
+        return pos_type{off_type{-1}}; // always fail
+    }
+
+    pos_type seekpos(
+        pos_type, ios_base::openmode = static_cast<ios_base::openmode>(ios_base::in | ios_base::out)) override {
+        return pos_type{off_type{-1}}; // always fail
+    }
+
+private:
+    int_type _Get_elem() { // compose an element from byte stream buffer
+        if (_Mystrbuf && _Status != _Wrote) { // got buffer, haven't written, try to compose an element
+            if (_Status != _Eof) {
+                if (_Str.empty()) {
+                    _Status = _Need;
+                } else {
+                    _Status = _Got;
+                }
+            }
+
+            while (_Status != _Eof) { // get using codecvt facet
+                char* _Buf = &_Str[0];
+                _Elem _Ch;
+                _Elem* _Dest;
+                const char* _Src;
+                int _Meta;
+
+                if (_Status == _Need) {
+                    if (_Byte_traits::eq_int_type(_Byte_traits::eof(), _Meta = _Mystrbuf->sbumpc())) {
+                        _Status = _Eof;
+                    } else {
+                        _Str.push_back(_Byte_traits::to_char_type(_Meta));
+                    }
+                }
+
+                // test result of converting one element
+                switch (_Pcvt->in(_State, _Buf, _Buf + _Str.size(), _Src, &_Ch, &_Ch + 1, _Dest)) {
+                case _Codecvt::partial:
+                case _Codecvt::ok:
+                    _Str.erase(0, static_cast<size_t>(_Src - _Buf)); // discard any used input
+                    if (_Dest != &_Ch) {
+                        return _Traits::to_int_type(_Ch);
+                    }
+
+                    break;
+
+                case _Codecvt::noconv:
+                    if (_Str.size() < sizeof(_Elem)) {
+                        break; // no conversion, but need more chars
+                    }
+
+                    _CSTD memcpy(&_Ch, _Buf, sizeof(_Elem)); // copy raw bytes to element
+                    _Str.erase(0, sizeof(_Elem));
+                    return _Traits::to_int_type(_Ch); // return result
+
+                default:
+                    _Status = _Eof; // conversion failed
+                    break;
+                }
+            }
+        }
+
+        return _Traits::eof();
+    }
+
+    state_type _State; // code conversion state
+    const _Codecvt* _Pcvt; // the codecvt facet
+    _Mysb* _Mystrbuf; // pointer to stream buffer
+    _Mode _Status; // buffer read/write status
+    size_t _Nback; // number of elements in putback buffer
+    _Elem _Myback[8]; // putback buffer
+    string _Str; // unconsumed input bytes
+    locale _Loc; // manages reference to codecvt facet
+};
+
+_EXPORT_STD template <class _Codecvt, class _Elem = wchar_t, class _Walloc = allocator<_Elem>,
+    class _Balloc = allocator<char>>
+class _CXX17_DEPRECATE_CODECVT_HEADER wstring_convert { // converts between _Elem (wide) and char (byte) strings
+private:
+    enum { _BUF_INC = 8, _BUF_MAX = 16 };
+    void _Init(const _Codecvt* _Pcvt_arg = new _Codecvt) { // initialize the object
+        _State = state_type{};
+        _Pcvt  = _Pcvt_arg;
+        _Loc   = locale{_Loc, _Pcvt};
+        _Nconv = 0;
+    }
+
+public:
+    using byte_string = basic_string<char, char_traits<char>, _Balloc>;
+    using wide_string = basic_string<_Elem, char_traits<_Elem>, _Walloc>;
+    using state_type  = typename _Codecvt::state_type;
+    using int_type    = typename wide_string::traits_type::int_type;
+
+    wstring_convert() : _Has_state(false), _Has_berr(false), _Has_werr(false) { // construct with no error strings
+        _Init();
+    }
+
+    explicit wstring_convert(const _Codecvt* _Pcvt_arg)
+        : _Has_state(false), _Has_berr(false), _Has_werr(false) { // construct with no error strings and codecvt
+        _Init(_Pcvt_arg);
+    }
+
+    wstring_convert(const _Codecvt* _Pcvt_arg, state_type _State_arg)
+        : _Has_state(true), _Has_berr(false), _Has_werr(false) { // construct with no error strings, codecvt, and state
+        _Init(_Pcvt_arg);
+        _State = _State_arg;
+    }
+
+    explicit wstring_convert(const byte_string& _Berr_arg)
+        : _Berr(_Berr_arg), _Has_state(false), _Has_berr(true), _Has_werr(false) { // construct with byte error string
+        _Init();
+    }
+
+    wstring_convert(const byte_string& _Berr_arg, const wide_string& _Werr_arg)
+        : _Berr(_Berr_arg), _Werr(_Werr_arg), _Has_state(false), _Has_berr(true),
+          _Has_werr(true) { // construct with byte and wide error strings
+        _Init();
+    }
+
+    virtual ~wstring_convert() noexcept {}
+
+    _NODISCARD size_t converted() const noexcept { // get conversion count
+        return _Nconv;
+    }
+
+    _NODISCARD state_type state() const {
+        return _State;
+    }
+
+    _NODISCARD wide_string from_bytes(char _Byte) { // convert a byte to a wide string
+        return from_bytes(&_Byte, &_Byte + 1);
+    }
+
+    _NODISCARD wide_string from_bytes(const char* _Ptr) { // convert a NTBS to a wide string
+        return from_bytes(_Ptr, _Ptr + _CSTD strlen(_Ptr));
+    }
+
+    _NODISCARD wide_string from_bytes(const byte_string& _Bstr) { // convert a byte string to a wide string
+        const char* _Ptr = _Bstr.c_str();
+        return from_bytes(_Ptr, _Ptr + _Bstr.size());
+    }
+
+    _NODISCARD wide_string from_bytes(
+        const char* _First, const char* _Last) { // convert byte sequence [_First, _Last) to a wide string
+        wide_string _Wbuf;
+        wide_string _Wstr;
+        const char* _First_sav = _First;
+
+        if (!_Has_state) {
+            _State = state_type{}; // reset state if not remembered
+        }
+
+        _Wbuf.append(_BUF_INC, _Elem{});
+        for (_Nconv = 0; _First != _Last; _Nconv = static_cast<size_t>(_First - _First_sav)) {
+            // convert one or more bytes
+            _Elem* _Dest = &_Wbuf[0];
+            _Elem* _Dnext;
+
+            // test result of converting one or more bytes
+            switch (_Pcvt->in(_State, _First, _Last, _First, _Dest, _Dest + _Wbuf.size(), _Dnext)) {
+            case _Codecvt::partial:
+            case _Codecvt::ok:
+                if (_Dest < _Dnext) {
+                    _Wstr.append(_Dest, static_cast<size_t>(_Dnext - _Dest));
+                } else if (_Wbuf.size() < _BUF_MAX) {
+                    _Wbuf.append(_BUF_INC, _Elem{});
+                } else if (_Has_werr) {
+                    return _Werr;
+                } else {
+                    _Throw_range_error("bad conversion");
+                }
+
+                break;
+
+            case _Codecvt::noconv:
+                for (; _First != _Last; ++_First) {
+                    _Wstr.push_back(static_cast<_Elem>(static_cast<unsigned char>(*_First)));
+                }
+
+                break; // no conversion, just copy code values
+
+            default:
+                if (_Has_werr) {
+                    return _Werr;
+                } else {
+                    _Throw_range_error("bad conversion");
+                }
+            }
+        }
+        return _Wstr;
+    }
+
+    _NODISCARD byte_string to_bytes(_Elem _Char) { // convert a wide char to a byte string
+        return to_bytes(&_Char, &_Char + 1);
+    }
+
+    _NODISCARD byte_string to_bytes(const _Elem* _Wptr) { // convert a NTWCS to a byte string
+        const _Elem* _Next = _Wptr;
+        while (*_Next != 0) {
+            ++_Next;
+        }
+
+        return to_bytes(_Wptr, _Next);
+    }
+
+    _NODISCARD byte_string to_bytes(const wide_string& _Wstr) { // convert a wide string to a byte string
+        const _Elem* _Wptr = _Wstr.c_str();
+        return to_bytes(_Wptr, _Wptr + _Wstr.size());
+    }
+
+    _NODISCARD byte_string to_bytes(
+        const _Elem* _First, const _Elem* _Last) { // convert wide sequence [_First, _Last) to a byte string
+        byte_string _Bbuf;
+        byte_string _Bstr;
+        const _Elem* _First_sav = _First;
+
+        if (!_Has_state) {
+            _State = state_type{}; // reset state if not remembered
+        }
+
+        _Bbuf.append(_BUF_INC, '\0');
+        for (_Nconv = 0; _First != _Last; _Nconv = static_cast<size_t>(_First - _First_sav)) {
+            // convert one or more wide chars
+            char* _Dest = &_Bbuf[0];
+            char* _Dnext;
+
+            // test result of converting one or more wide chars
+            switch (_Pcvt->out(_State, _First, _Last, _First, _Dest, _Dest + _Bbuf.size(), _Dnext)) {
+            case _Codecvt::partial:
+            case _Codecvt::ok:
+                if (_Dest < _Dnext) {
+                    _Bstr.append(_Dest, static_cast<size_t>(_Dnext - _Dest));
+                } else if (_Bbuf.size() < _BUF_MAX) {
+                    _Bbuf.append(_BUF_INC, '\0');
+                } else if (_Has_berr) {
+                    return _Berr;
+                } else {
+                    _Throw_range_error("bad conversion");
+                }
+
+                break;
+
+            case _Codecvt::noconv:
+                for (; _First != _Last; ++_First) {
+                    _Bstr.push_back(static_cast<char>(static_cast<int_type>(*_First)));
+                }
+
+                break; // no conversion, just copy code values
+
+            default:
+                if (_Has_berr) {
+                    return _Berr;
+                } else {
+                    _Throw_range_error("bad conversion");
+                }
+            }
+        }
+        return _Bstr;
+    }
+
+    wstring_convert(const wstring_convert&)            = delete;
+    wstring_convert& operator=(const wstring_convert&) = delete;
+
+private:
+    const _Codecvt* _Pcvt; // the codecvt facet
+    locale _Loc; // manages reference to codecvt facet
+    byte_string _Berr;
+    wide_string _Werr;
+    state_type _State; // the remembered state
+    bool _Has_state;
+    bool _Has_berr;
+    bool _Has_werr;
+    size_t _Nconv;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCBUF_
diff --git a/msvc-stl/stl/inc/xlocinfo b/msvc-stl/stl/inc/xlocinfo
new file mode 100644
index 0000000..e71846c
--- /dev/null
+++ b/msvc-stl/stl/inc/xlocinfo
@@ -0,0 +1,411 @@
+// xlocinfo internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCINFO_
+#define _XLOCINFO_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_xlocinfo_types.hpp>
+#include <cctype>
+#include <clocale>
+#include <cstdio> // TRANSITION, VSO-661721
+#include <cstdlib>
+#include <cwchar>
+#include <xstring>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_EXTERN_C_UNLESS_PURE
+
+#define _X_ALL      LC_ALL
+#define _X_COLLATE  LC_COLLATE
+#define _X_CTYPE    LC_CTYPE
+#define _X_MONETARY LC_MONETARY
+#define _X_NUMERIC  LC_NUMERIC
+#define _X_TIME     LC_TIME
+#define _X_MAX      LC_MAX
+#define _X_MESSAGES 6
+#define _NCAT       (_X_MESSAGES + 1) // maximum + 1
+
+#define _CATMASK(n) ((1 << (n)) >> 1)
+#define _M_COLLATE  _CATMASK(_X_COLLATE)
+#define _M_CTYPE    _CATMASK(_X_CTYPE)
+#define _M_MONETARY _CATMASK(_X_MONETARY)
+#define _M_NUMERIC  _CATMASK(_X_NUMERIC)
+#define _M_TIME     _CATMASK(_X_TIME)
+#define _M_MESSAGES _CATMASK(_X_MESSAGES)
+#define _M_ALL      (_CATMASK(_NCAT) - 1)
+
+_CRTIMP2_PURE _Collvec __CLRCALL_PURE_OR_CDECL _Getcoll() noexcept;
+_CRTIMP2_PURE _Ctypevec __CLRCALL_PURE_OR_CDECL _Getctype() noexcept;
+_CRTIMP2_PURE _Cvtvec __CLRCALL_PURE_OR_CDECL _Getcvt() noexcept;
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Getdateorder() noexcept;
+
+#ifdef _M_CEE_PURE
+[System::Runtime::InteropServices::DllImport(_CRT_MSVCP_CURRENT, EntryPoint = "_Mbrtowc",
+    CallingConvention = System::Runtime::InteropServices::CallingConvention::Cdecl)] extern "C" int
+    _Mbrtowc(_Out_opt_ wchar_t*, const char*, size_t, mbstate_t*, const _Cvtvec*) noexcept;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+_MRTIMP2 _Success_(return >= 0) int __cdecl _Mbrtowc(_When_(_Max_multibyte != 0, _Out_) wchar_t*, const char*,
+    size_t _Max_multibyte, mbstate_t*, const _Cvtvec*) noexcept;
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Strcoll(
+    const char*, const char*, const char*, const char*, const _Collvec*) noexcept;
+_CRTIMP2_PURE size_t __CLRCALL_PURE_OR_CDECL _Strxfrm(
+    _Out_writes_(_End1 - _String1) _Post_readable_size_(return) char* _String1, char* _End1,
+    _In_reads_(_End2 - _String2) const char* _String2, const char* _End2, _In_opt_ const _Collvec*) noexcept;
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Tolower(int, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Toupper(int, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE _Success_(return != -1) int __CLRCALL_PURE_OR_CDECL
+    _Wcrtomb(_Out_ char*, wchar_t, mbstate_t*, const _Cvtvec*) noexcept;
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Wcscoll(
+    const wchar_t*, const wchar_t*, const wchar_t*, const wchar_t*, const _Collvec*) noexcept;
+_CRTIMP2_PURE size_t __CLRCALL_PURE_OR_CDECL _Wcsxfrm(
+    _Out_writes_(_End1 - _String1) _Post_readable_size_(return) wchar_t* _String1, wchar_t* _End1,
+    _In_reads_(_End2 - _String2) const wchar_t* _String2, const wchar_t* _End2, _In_opt_ const _Collvec*) noexcept;
+
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Getwctype(wchar_t, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE const wchar_t* __CLRCALL_PURE_OR_CDECL _Getwctypes(
+    const wchar_t*, const wchar_t*, short*, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE wchar_t __CLRCALL_PURE_OR_CDECL _Towlower(wchar_t, const _Ctypevec*) noexcept;
+_CRTIMP2_PURE wchar_t __CLRCALL_PURE_OR_CDECL _Towupper(wchar_t, const _Ctypevec*) noexcept;
+
+_END_EXTERN_C_UNLESS_PURE
+
+extern "C" {
+// These _should_ be explicitly `noexcept` but cannot be made so here because
+// the primary declarations in the C runtime headers are not.
+
+_Success_(return != 0) _Ret_z_ _ACRTIMP char* __cdecl _Getdays();
+
+_Success_(return != 0) _Ret_z_ _ACRTIMP char* __cdecl _Getmonths();
+
+_ACRTIMP void* __cdecl _Gettnames();
+
+_Success_(return > 0) _ACRTIMP size_t __cdecl _Strftime(
+    _Out_writes_z_(_Maxsize) char*, _In_ size_t _Maxsize, _In_z_ const char*, _In_ const tm*, _In_opt_ void*);
+
+_Success_(return != 0) _Ret_z_ _ACRTIMP wchar_t* __cdecl _W_Getdays();
+
+_Success_(return != 0) _Ret_z_ _ACRTIMP wchar_t* __cdecl _W_Getmonths();
+
+_ACRTIMP void* __cdecl _W_Gettnames();
+
+_Success_(return > 0) _ACRTIMP size_t __cdecl _Wcsftime(
+    _Out_writes_z_(_Maxsize) wchar_t*, _In_ size_t _Maxsize, _In_z_ const wchar_t*, _In_ const tm*, _In_opt_ void*);
+} // extern "C"
+
+_STD_BEGIN
+extern "C++" class _CRTIMP2_PURE_IMPORT _Timevec { // smart pointer to information used by _Strftime
+public:
+    explicit __CLR_OR_THIS_CALL _Timevec(void* _Ptr = nullptr) : _Timeptr(_Ptr) {}
+
+    __CLR_OR_THIS_CALL _Timevec(const _Timevec& _Right) : _Timeptr(nullptr) {
+        *this = _Right;
+    }
+
+    __CLR_OR_THIS_CALL ~_Timevec() noexcept {
+        _CSTD free(_Timeptr);
+    }
+
+    _Timevec& __CLR_OR_THIS_CALL operator=(const _Timevec& _Right) { // transfer ownership of _Timeptr from _Right
+        if (this != &_Right) {
+            _CSTD free(_Timeptr);
+            _Timeptr                               = _Right._Timeptr;
+            const_cast<_Timevec&>(_Right)._Timeptr = nullptr; // TRANSITION, ABI, should be movable-only
+        }
+
+        return *this;
+    }
+
+    void* __CLR_OR_THIS_CALL _Getptr() const {
+        return _Timeptr;
+    }
+
+private:
+    void* _Timeptr; // pointer to time information
+};
+
+template <class _Elem>
+_NODISCARD _Elem* _Ntcts_dup_dbg(const _Elem* const _Ptr) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_Elem, char, wchar_t, unsigned short>);
+
+    const size_t _Bytes = (char_traits<_Elem>::length(_Ptr) + 1) * sizeof(_Elem);
+
+#ifdef _DEBUG
+    const auto _Result = static_cast<_Elem*>(_CSTD _malloc_dbg(_Bytes, _CRT_BLOCK, __FILE__, __LINE__));
+#else
+    const auto _Result = static_cast<_Elem*>(_CSTD malloc(_Bytes));
+#endif
+    if (_Result) {
+        _CSTD memcpy(_Result, _Ptr, _Bytes);
+    }
+
+    return _Result;
+}
+
+extern "C++" template <class _Elem>
+class _CRTIMP2_PURE_IMPORT _Yarn { // wrap a NTCTS
+public:
+    __CLR_OR_THIS_CALL _Yarn() noexcept : _Myptr(nullptr), _Nul(0) {}
+
+    __CLR_OR_THIS_CALL _Yarn(const _Yarn& _Right) noexcept : _Myptr(nullptr), _Nul(0) {
+        *this = _Right;
+    }
+
+    __CLR_OR_THIS_CALL _Yarn(const _Elem* _Right) noexcept : _Myptr(nullptr), _Nul(0) {
+        *this = _Right;
+    }
+
+    _Yarn& __CLR_OR_THIS_CALL operator=(const _Yarn& _Right) noexcept {
+        return *this = _Right._Myptr;
+    }
+
+    _Yarn& __CLR_OR_THIS_CALL operator=(const _Elem* _Right) noexcept {
+        if (_Myptr != _Right) { // new value, discard old and copy new
+            _Tidy();
+
+            if (_Right) { // new is not empty, copy it
+                _Myptr = _STD _Ntcts_dup_dbg(_Right);
+            }
+        }
+
+        return *this;
+    }
+
+    template <class _Elem2 = _Elem, enable_if_t<is_same_v<_Elem2, char>, int> = 0>
+    void _From_wide(const wchar_t* const _Right) noexcept {
+        // CodeQL [SM02986] We are intentionally storing `wchar_t*` as `char*` due to ABI, see GH-5781
+        if (reinterpret_cast<wchar_t*>(_Myptr) != _Right) { // new value, discard old and copy new
+            _Tidy();
+
+            if (_Right) { // new is not empty, copy it
+                // CodeQL [SM02986] We are intentionally storing `wchar_t*` as `char*` due to ABI, see GH-5781
+                _Myptr = reinterpret_cast<char*>(_STD _Ntcts_dup_dbg(_Right));
+            }
+        }
+    }
+
+    __CLR_OR_THIS_CALL ~_Yarn() noexcept {
+        _Tidy();
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL empty() const noexcept {
+        return _Myptr == nullptr;
+    }
+
+    _Ret_z_ const _Elem* __CLR_OR_THIS_CALL c_str() const noexcept {
+        return _Myptr ? _Myptr : &_Nul;
+    }
+
+    _NODISCARD bool __CLR_OR_THIS_CALL _Empty() const noexcept {
+        return _Myptr == nullptr;
+    }
+
+    _Ret_z_ const _Elem* __CLR_OR_THIS_CALL _C_str() const noexcept {
+        return _Myptr ? _Myptr : &_Nul;
+    }
+
+private:
+    void __CLR_OR_THIS_CALL _Tidy() noexcept {
+        if (_Myptr) {
+#ifdef _DEBUG
+            _free_dbg(_Myptr, _CRT_BLOCK);
+#else
+            _CSTD free(_Myptr);
+#endif
+        }
+
+        _Myptr = nullptr;
+    }
+
+    _Elem* _Myptr; // pointer to allocated string
+    _Elem _Nul; // nul terminator for unallocated string
+};
+
+extern "C++" class _CRTIMP2_PURE_IMPORT _Locinfo { // summary of all stuff specific to a locale used by standard facets
+public:
+    using _Collvec  = ::_Collvec;
+    using _Ctypevec = ::_Ctypevec;
+    using _Cvtvec   = ::_Cvtvec;
+    using _Timevec  = _STD _Timevec;
+
+    static void __CLRCALL_PURE_OR_CDECL _Locinfo_ctor(_Locinfo*, const char*);
+    static void __CLRCALL_PURE_OR_CDECL _Locinfo_ctor(_Locinfo*, int, const char*);
+    static void __CLRCALL_PURE_OR_CDECL _Locinfo_dtor(_Locinfo*);
+    static _Locinfo& __CLRCALL_PURE_OR_CDECL _Locinfo_Addcats(_Locinfo*, int, const char*);
+
+    __CLR_OR_THIS_CALL _Locinfo(const char* _Pch = "C")
+#ifndef _M_CEE_PURE
+        : _Lock(_LOCK_LOCALE)
+#endif // !defined(_M_CEE_PURE)
+    {
+        if (_Pch) {
+            _Locinfo_ctor(this, _Pch);
+            return;
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    __CLR_OR_THIS_CALL _Locinfo(int _Cat, const char* _Pch)
+#ifndef _M_CEE_PURE
+        : _Lock(_LOCK_LOCALE)
+#endif // !defined(_M_CEE_PURE)
+    {
+        if (_Pch) {
+            _Locinfo_ctor(this, _Cat, _Pch);
+            return;
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    __CLR_OR_THIS_CALL ~_Locinfo() noexcept {
+        _Locinfo_dtor(this);
+    }
+
+    _Locinfo& __CLR_OR_THIS_CALL _Addcats(int _Cat, const char* _Pch) { // add facets matching category mask and NTBS
+        if (_Pch) {
+            return _Locinfo_Addcats(this, _Cat, _Pch);
+        }
+
+        _Xruntime_error("bad locale name");
+    }
+
+    const char* __CLR_OR_THIS_CALL _Getname() const {
+        return _Newlocname._C_str();
+    }
+
+    _Collvec __CLR_OR_THIS_CALL _Getcoll() const {
+        return ::_Getcoll();
+    }
+
+    _Ctypevec __CLR_OR_THIS_CALL _Getctype() const {
+        return ::_Getctype();
+    }
+
+    _Cvtvec __CLR_OR_THIS_CALL _Getcvt() const {
+        return ::_Getcvt();
+    }
+
+    const lconv* __CLR_OR_THIS_CALL _Getlconv() const {
+        return localeconv();
+    }
+
+    _Timevec __CLR_OR_THIS_CALL _Gettnames() const {
+        return _Timevec(::_Gettnames());
+    }
+
+    const char* __CLR_OR_THIS_CALL _Getdays() const {
+        const char* _Ptr = ::_Getdays();
+        if (_Ptr) { // capture names and free allocated C string
+            const_cast<_Locinfo*>(this)->_Days = _Ptr;
+            _CSTD free(const_cast<char*>(_Ptr));
+        }
+
+        return !_Days._Empty() ? _Days._C_str()
+                               : ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:Wednesday"
+                                 ":Thu:Thursday:Fri:Friday:Sat:Saturday";
+    }
+
+    const char* __CLR_OR_THIS_CALL _Getmonths() const {
+        const char* _Ptr = ::_Getmonths();
+        if (_Ptr) { // capture names and free allocated C string
+            const_cast<_Locinfo*>(this)->_Months = _Ptr;
+            _CSTD free(const_cast<char*>(_Ptr));
+        }
+
+        return !_Months._Empty() ? _Months._C_str()
+                                 : ":Jan:January:Feb:February:Mar:March"
+                                   ":Apr:April:May:May:Jun:June"
+                                   ":Jul:July:Aug:August:Sep:September"
+                                   ":Oct:October:Nov:November:Dec:December";
+    }
+
+    const char* __CLR_OR_THIS_CALL _Getfalse() const {
+        return "false";
+    }
+
+    const char* __CLR_OR_THIS_CALL _Gettrue() const {
+        return "true";
+    }
+
+    int __CLR_OR_THIS_CALL _Getdateorder() const {
+        return ::_Getdateorder();
+    }
+
+    _Timevec __CLR_OR_THIS_CALL _W_Gettnames() const {
+        return _Timevec(::_W_Gettnames());
+    }
+
+    const unsigned short* __CLR_OR_THIS_CALL _W_Getdays() const {
+        const wchar_t* _Ptr = ::_W_Getdays();
+        if (_Ptr) { // capture names and free allocated C string
+            const_cast<_Locinfo*>(this)->_W_Days = _Ptr;
+            _CSTD free(const_cast<wchar_t*>(_Ptr));
+        }
+
+        const wchar_t* _Ret;
+
+        if (_W_Days._Empty()) {
+            _Ret = L":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:Wednesday:Thu:Thursday:Fri:Friday:Sat:Saturday";
+        } else {
+            _Ret = _W_Days._C_str();
+        }
+
+        return reinterpret_cast<const unsigned short*>(_Ret);
+    }
+
+    const unsigned short* __CLR_OR_THIS_CALL _W_Getmonths() const {
+        const wchar_t* _Ptr = ::_W_Getmonths();
+        if (_Ptr) { // capture names and free allocated C string
+            const_cast<_Locinfo*>(this)->_W_Months = _Ptr;
+            _CSTD free(const_cast<wchar_t*>(_Ptr));
+        }
+
+        const wchar_t* _Ret;
+
+        if (_W_Months._Empty()) {
+            _Ret = L":Jan:January:Feb:February:Mar:March:Apr:April:May:May:Jun:June"
+                   L":Jul:July:Aug:August:Sep:September:Oct:October:Nov:November:Dec:December";
+        } else {
+            _Ret = _W_Months._C_str();
+        }
+
+        return reinterpret_cast<const unsigned short*>(_Ret);
+    }
+
+    _Locinfo(const _Locinfo&)            = delete;
+    _Locinfo& operator=(const _Locinfo&) = delete;
+
+private:
+#ifdef _M_CEE_PURE
+    _EmptyLockit _Empty_lock; // to maintain same size
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+    _Lockit _Lock; // thread lock, because global locale is altered
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    _Yarn<char> _Days; // weekday names
+    _Yarn<char> _Months; // month names
+    _Yarn<wchar_t> _W_Days; // wide weekday names
+    _Yarn<wchar_t> _W_Months; // wide month names
+    // TRANSITION, ABI, `_Oldlocname._Myptr` is reinterpreted as `wchar_t*`. We should use `_Yarn<wchar_t>`.
+    _Yarn<char> _Oldlocname; // old locale name to revert to on destruction
+    _Yarn<char> _Newlocname; // new locale name for this object
+};
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCINFO_
diff --git a/msvc-stl/stl/inc/xlocmes b/msvc-stl/stl/inc/xlocmes
new file mode 100644
index 0000000..4d161b5
--- /dev/null
+++ b/msvc-stl/stl/inc/xlocmes
@@ -0,0 +1,139 @@
+// xlocmes internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCMES_
+#define _XLOCMES_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xiosbase>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD struct messages_base // base class for messages
+    : locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+    using catalog = int;
+
+    messages_base() noexcept // strengthened
+        : messages_base(0) {}
+    explicit messages_base(size_t _Refs) noexcept : locale::facet(_Refs) {}
+};
+
+_EXPORT_STD template <class _Elem>
+class messages : public messages_base { // facet for obtaining messages from a catalog
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type   = _Elem;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    catalog open(const string& _Catname, const locale& _Loc) const { // open catalog
+        return do_open(_Catname, _Loc);
+    }
+
+    string_type get(catalog _Catval, int _Set, int _Message,
+        const string_type& _Dflt) const { // get message from set in catalog
+        return do_get(_Catval, _Set, _Message, _Dflt);
+    }
+
+    void close(catalog _Catval) const { // close catalog
+        do_close(_Catval);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit messages(size_t _Refs = 0) : messages_base(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    messages(const _Locinfo& _Lobj, size_t _Refs = 0) : messages_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new messages<_Elem>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_MESSAGES;
+    }
+
+protected:
+    messages(const char* _Locname, size_t _Refs = 0) : messages_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ~messages() noexcept override {}
+
+    void _Init(const _Locinfo&) {} // initialize from _Locinfo object (do nothing)
+
+    virtual catalog __CLR_OR_THIS_CALL do_open(const string&, const locale&) const { // open catalog (do nothing)
+        return -1;
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_get(catalog, int, int,
+        const string_type& _Dflt) const { // get message from set in catalog (return default)
+        return _Dflt;
+    }
+
+    virtual void __CLR_OR_THIS_CALL do_close(catalog) const {} // close catalog (do nothing)
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem>
+__PURE_APPDOMAIN_GLOBAL locale::id messages<_Elem>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem>
+class messages_byname : public messages<_Elem> { // messages for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit messages_byname(const char* _Locname, size_t _Refs = 0)
+        : messages<_Elem>(_Locname, _Refs) {} // construct for named locale
+
+    explicit messages_byname(const string& _Str, size_t _Refs = 0)
+        : messages<_Elem>(_Str.c_str(), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~messages_byname() noexcept override {}
+};
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template __PURE_APPDOMAIN_GLOBAL locale::id messages<char>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id messages<wchar_t>::id;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template __PURE_APPDOMAIN_GLOBAL locale::id messages<unsigned short>::id;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCMES_
diff --git a/msvc-stl/stl/inc/xlocmon b/msvc-stl/stl/inc/xlocmon
new file mode 100644
index 0000000..1ef6b30
--- /dev/null
+++ b/msvc-stl/stl/inc/xlocmon
@@ -0,0 +1,934 @@
+// xlocmon internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCMON_
+#define _XLOCMON_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <iterator>
+#include <xlocnum>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+_EXPORT_STD struct money_base // ultimate base class for moneypunct
+    : locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+    enum { // constants for different format codes
+        symbol = '$',
+        sign   = '+',
+        space  = ' ',
+        value  = 'v',
+        none   = 'x'
+    };
+    using part = int;
+
+    struct pattern { // four-part formats for monetary text
+        char field[4];
+    };
+
+    money_base(size_t _Refs = 0) noexcept // strengthened
+        : locale::facet(_Refs) {}
+};
+
+template <class _Elem>
+class _Mpunct : public money_base { // common base class for moneypunct<_Elem, false/true>
+public:
+    friend _Tidy_guard<_Mpunct>;
+
+    using char_type   = _Elem;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    _Elem decimal_point() const {
+        return do_decimal_point();
+    }
+
+    _Elem thousands_sep() const {
+        return do_thousands_sep();
+    }
+
+    string grouping() const {
+        return do_grouping();
+    }
+
+    string_type curr_symbol() const {
+        return do_curr_symbol();
+    }
+
+    string_type positive_sign() const {
+        return do_positive_sign();
+    }
+
+    string_type negative_sign() const {
+        return do_negative_sign();
+    }
+
+    int frac_digits() const {
+        return do_frac_digits();
+    }
+
+    pattern pos_format() const {
+        return do_pos_format();
+    }
+
+    pattern neg_format() const {
+        return do_neg_format();
+    }
+
+    explicit _Mpunct(size_t _Refs, bool _Intl)
+        : money_base(_Refs), _International(_Intl) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    _Mpunct(const _Locinfo& _Lobj, size_t _Refs, bool _Intl, bool _Isdef = false)
+        : money_base(_Refs), _International(_Intl) {
+        _Init(_Lobj, _Isdef);
+    }
+
+protected:
+    _Mpunct(const char* _Locname, size_t _Refs, bool _Intl, bool _Isdef = false)
+        : money_base(_Refs), _International(_Intl) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj, _Isdef);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL ~_Mpunct() noexcept override {
+        _Tidy();
+    }
+
+    void _Init(const _Locinfo& _Lobj, bool _Isdef = false) { // initialize from _Lobj
+        _Cvt              = _Lobj._Getcvt();
+        const lconv* _Ptr = _Lobj._Getlconv();
+
+        _Grouping     = nullptr;
+        _Currencysign = nullptr;
+        _Plussign     = nullptr;
+        _Minussign    = nullptr;
+
+        _Tidy_guard<_Mpunct> _Guard{this};
+        _Grouping = _Maklocstr<char>(_Ptr->mon_grouping, _Cvt);
+        if constexpr (is_same_v<_Elem, wchar_t>) {
+            _Currencysign = _Maklocwcs(_International ? _Ptr->_W_int_curr_symbol : _Ptr->_W_currency_symbol);
+            _Plussign     = _Maklocwcs(4 < static_cast<unsigned int>(_Ptr->p_sign_posn) ? L"" : _Ptr->_W_positive_sign);
+            _Minussign = _Maklocwcs(4 < static_cast<unsigned int>(_Ptr->n_sign_posn) ? L"-" : _Ptr->_W_negative_sign);
+            _Decimalpoint = _Ptr->_W_mon_decimal_point[0];
+            _Kseparator   = _Ptr->_W_mon_thousands_sep[0];
+        } else {
+            _Currencysign = _Maklocstr<_Elem>(_International ? _Ptr->int_curr_symbol : _Ptr->currency_symbol, _Cvt);
+            _Plussign =
+                _Maklocstr<_Elem>(4 < static_cast<unsigned int>(_Ptr->p_sign_posn) ? "" : _Ptr->positive_sign, _Cvt);
+            _Minussign =
+                _Maklocstr<_Elem>(4 < static_cast<unsigned int>(_Ptr->n_sign_posn) ? "-" : _Ptr->negative_sign, _Cvt);
+            _Decimalpoint = _Maklocchr<_Elem>(_Ptr->mon_decimal_point[0], _Cvt);
+            _Kseparator   = _Maklocchr<_Elem>(_Ptr->mon_thousands_sep[0], _Cvt);
+        }
+
+        _Guard._Target = nullptr;
+
+        _Fracdigits = _International ? _Ptr->int_frac_digits : _Ptr->frac_digits;
+        if (_Fracdigits < 0 || CHAR_MAX <= _Fracdigits) {
+            _Fracdigits = 0;
+        }
+
+        _Makpat(_Plusformat, static_cast<unsigned int>(_Ptr->p_sep_by_space),
+            static_cast<unsigned int>(_Ptr->p_cs_precedes), static_cast<unsigned int>(_Ptr->p_sign_posn));
+        _Makpat(_Minusformat, static_cast<unsigned int>(_Ptr->n_sep_by_space),
+            static_cast<unsigned int>(_Ptr->n_cs_precedes), static_cast<unsigned int>(_Ptr->n_sign_posn));
+
+        if (_Isdef) { // apply defaults for required facets
+            _CSTD memcpy(&_Plusformat, "$+xv", 4);
+            _CSTD memcpy(&_Minusformat, "$+xv", 4);
+        }
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_decimal_point() const {
+        return _Decimalpoint;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_thousands_sep() const {
+        return _Kseparator;
+    }
+
+    virtual string __CLR_OR_THIS_CALL do_grouping() const {
+        return string{_Grouping};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_curr_symbol() const {
+        return string_type{_Currencysign};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_positive_sign() const {
+        return string_type{_Plussign};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_negative_sign() const {
+        return string_type{_Minussign};
+    }
+
+    virtual int __CLR_OR_THIS_CALL do_frac_digits() const {
+        return _Fracdigits;
+    }
+
+    virtual pattern __CLR_OR_THIS_CALL do_pos_format() const {
+        return _Plusformat;
+    }
+
+    virtual pattern __CLR_OR_THIS_CALL do_neg_format() const {
+        return _Minusformat;
+    }
+
+private:
+    void _Makpat(pattern& _Pattern, unsigned int _Sepbyspace, unsigned int _Symbolprecedes,
+        unsigned int _Signposition) { // make format pattern from locale information
+
+        const char* _Ptr;
+
+        if (_International || 2 < _Sepbyspace || 1 < _Symbolprecedes || 4 < _Signposition) {
+            // international or bad parameters
+            _Ptr = "$+xv";
+        } else {
+            // clang-format off: preserve column/row/group structure of the string literal
+            _Ptr =
+                "+v$x" "+v$x" "v$+x" "v+$x" "v$+x"
+                "+$vx" "+$vx" "$v+x" "+$vx" "$+vx"
+                "+v $" "+v $" "v $+" "v +$" "v $+"
+                "+$ v" "+$ v" "$ v+" "+$ v" "$+ v"
+                "+xv$" "+ v$" "v$ +" "v+ $" "v$ +"
+                "+x$v" "+ $v" "$v +" "+ $v" "$ +v";
+            // clang-format on
+            _Ptr += _Signposition * 4 // pick even/odd column
+                  + _Symbolprecedes * 20 // pick even/odd row
+                  + _Sepbyspace * 40; // pick first/second/third group
+        }
+
+        _CSTD memcpy(_Pattern.field, _Ptr, sizeof(_Pattern.field));
+    }
+
+    void _Tidy() noexcept { // free all storage
+        _CSTD free(const_cast<char*>(_Grouping));
+        _CSTD free(const_cast<_Elem*>(_Currencysign));
+        _CSTD free(const_cast<_Elem*>(_Plussign));
+        _CSTD free(const_cast<_Elem*>(_Minussign));
+    }
+
+    const char* _Grouping; // grouping string, "" for "C" locale
+    _Elem _Decimalpoint; // decimal point, '\0' for "C" locale
+    _Elem _Kseparator; // thousands separator, '\0' for "C" locale
+    const _Elem* _Currencysign; // currency symbol, "" for "C" locale
+    const _Elem* _Plussign; // plus sign, "" for "C" locale
+    const _Elem* _Minussign; // minus sign, "-" for "C" locale
+    int _Fracdigits; // number of fraction digits, 0 for "C" locale
+    pattern _Plusformat; // positive format, "$+vx" for "C" locale
+    pattern _Minusformat; // negative format, "$+vx" for "C" locale
+    bool _International; // true if international format
+
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+
+_EXPORT_STD template <class _Elem, bool _Intl = false>
+class moneypunct : public _Mpunct<_Elem> { // facet for defining monetary punctuation text
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    _PGLOBAL _CRTIMP2_PURE_IMPORT static const bool intl; // true if international
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit moneypunct(size_t _Refs = 0) : _Mpunct<_Elem>(_Refs, _Intl) {} // construct from current locale
+
+    moneypunct(const _Locinfo& _Lobj, size_t _Refs = 0, bool _Isdef = false)
+        : _Mpunct<_Elem>(_Lobj, _Refs, _Intl, _Isdef) {}
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new moneypunct<_Elem, _Intl>(_Locinfo(_Ploc->_C_str()), 0, true);
+        }
+
+        return _X_MONETARY;
+    }
+
+protected:
+    moneypunct(const char* _Locname, size_t _Refs = 0) : _Mpunct<_Elem>(_Locname, _Refs, _Intl) {}
+
+    __CLR_OR_THIS_CALL ~moneypunct() noexcept override {}
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, bool _Intl>
+_PGLOBAL const bool moneypunct<_Elem, _Intl>::intl = _Intl;
+
+template <class _Elem, bool _Intl>
+__PURE_APPDOMAIN_GLOBAL locale::id moneypunct<_Elem, _Intl>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem, bool _Intl = false>
+class moneypunct_byname : public moneypunct<_Elem, _Intl> { // moneypunct for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit moneypunct_byname(const char* _Locname, size_t _Refs = 0)
+        : moneypunct<_Elem, _Intl>(_Locname, _Refs) {} // construct for named locale
+
+    explicit moneypunct_byname(const string& _Str, size_t _Refs = 0)
+        : moneypunct<_Elem, _Intl>(_Str.c_str(), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~moneypunct_byname() noexcept override {}
+};
+
+_EXPORT_STD template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+class money_get : public locale::facet { // facet for converting text to encoded monetary amounts
+private:
+    using _Mypunct0 = moneypunct<_Elem, false>;
+    using _Mypunct1 = moneypunct<_Elem, true>;
+
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type   = _Elem;
+    using iter_type   = _InIt;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    _InIt get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase, ios_base::iostate& _State,
+        long double& _Val) const { // get long double from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Intl, _Iosbase, _State, _Val);
+    }
+
+    _InIt get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase, ios_base::iostate& _State,
+        string_type& _Val) const { // get string_type from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Intl, _Iosbase, _State, _Val);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit money_get(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    money_get(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new money_get<_Elem, _InIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_MONETARY;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~money_get() noexcept override {}
+
+    void _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase,
+        ios_base::iostate& _State,
+        long double& _Val) const { // get long double from [_First, _Last) into _Val
+        _Elem _Atoms[sizeof("0123456789-")];
+        string _Str = _Getmfld(_First, _Last, _Intl, _Iosbase, _Atoms);
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        if (_Str.empty()) {
+            _State |= ios_base::failbit; // _Getmfld failed
+        } else { // convert to long double
+            const char* _Eb = _Str.c_str();
+            char* _Ep;
+            int _Errno             = 0;
+            const long double _Ans = _Stodx_v3(_Eb, &_Ep, &_Errno); // convert and "widen" double to long double
+
+            if (_Ep == _Eb || _Errno != 0) {
+                _State |= ios_base::failbit;
+            } else {
+                _Val = _Ans; // deliver value
+            }
+        }
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase,
+        ios_base::iostate& _State,
+        string_type& _Val) const { // get string_type from [_First, _Last) into _Val
+        _Elem _Atoms[sizeof("0123456789-")];
+        string _Str = _Getmfld(_First, _Last, _Intl, _Iosbase, _Atoms);
+        size_t _Len = _Str.size();
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        if (_Len == 0) {
+            _State |= ios_base::failbit; // _Getmfld failed
+        } else { // deliver value
+            size_t _Idx = 0;
+            _Val.resize(_Len);
+            if (_Str[0] == '-') {
+                _Val[_Idx++] = _Atoms[10];
+            }
+
+            for (; _Idx < _Len; ++_Idx) {
+                _Val[_Idx] = _Atoms[_Str[_Idx] - '0']; // map digits
+            }
+        }
+        return _First;
+    }
+
+private:
+    string _Getmfld(_InIt& _First, _InIt& _Last, bool _Intl, ios_base& _Iosbase,
+        _Elem (&_Atoms)[12]) const { // get monetary field from [_First, _Last) into string_type
+        _Adl_verify_range(_First, _Last);
+        const _Mpunct<_Elem>* _Ppunct_fac;
+        if (_Intl) {
+            _Ppunct_fac = _STD addressof(_STD use_facet<_Mypunct1>(_Iosbase.getloc())); // international
+        } else {
+            _Ppunct_fac = _STD addressof(_STD use_facet<_Mypunct0>(_Iosbase.getloc())); // local
+        }
+
+        bool _Bad = false;
+        bool _Neg = false;
+        string_type _Sign;
+        const money_base::pattern _Pattern = _Ppunct_fac->neg_format();
+        string _Val;
+        size_t _Idx;
+        static constexpr char _Src[]   = "0123456789-";
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        _Ctype_fac.widen(_STD begin(_Src), _STD end(_Src), _Atoms);
+
+        for (size_t _Off = 0; !_Bad && _Off < 4; ++_Off) {
+            switch (_Pattern.field[_Off]) { // parse a format component
+            case money_base::symbol:
+                { // parse currency symbol
+                    string_type _Symbol = _Ppunct_fac->curr_symbol();
+                    typename string_type::const_iterator _Source;
+
+                    if ((!(_Iosbase.flags() & ios_base::showbase) && _First != _Last && *_First != *_Symbol.c_str())
+                        || (_Off == 3 && _Sign.size() <= 1
+                            && (_First == _Last || *_First != *_Symbol.c_str()))) { // showbase ==> mandatory symbol
+                                                                                    // or
+                                                                                    // currency symbol optional at end
+                        _Symbol.erase();
+                    }
+
+                    _Source = _Symbol.begin();
+                    while (_First != _Last && _Source != _Symbol.end() && *_First == *_Source) {
+                        // still matching currency symbol
+                        ++_Source;
+                        ++_First;
+                    }
+
+                    if (_Source != _Symbol.end()) {
+                        _Bad = true; // currency symbol match failed
+                    }
+                    break;
+                }
+
+            case money_base::sign: // parse sign
+                if (_First != _Last) {
+                    if (0 < _Ppunct_fac->positive_sign().size()
+                        && _Ppunct_fac->positive_sign()[0] == *_First) { // match positive sign
+                        ++_First;
+                        _Sign = _Ppunct_fac->positive_sign();
+                    } else if (0 < _Ppunct_fac->negative_sign().size()
+                               && _Ppunct_fac->negative_sign()[0] == *_First) { // match negative sign
+                        ++_First;
+                        _Sign = _Ppunct_fac->negative_sign();
+                        _Neg  = true;
+                    } else if (0 != _Ppunct_fac->positive_sign().size() && 0 == _Ppunct_fac->negative_sign().size()) {
+                        _Neg = true;
+                    }
+                }
+
+                break; // sign match can't fail
+
+            case money_base::value:
+                { // parse value field
+                    int _Fracdigseen        = 0;
+                    int _Fracdigits         = _Ppunct_fac->frac_digits();
+                    const string _Grouping  = _Ppunct_fac->grouping();
+                    const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Ppunct_fac->thousands_sep();
+
+                    if (_Kseparator == _Elem{} || CHAR_MAX <= static_cast<unsigned char>(*_Grouping.c_str())) {
+                        for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < 10; ++_First) {
+                            _Val += _Src[_Idx]; // no grouping, just gather digits
+                        }
+                    } else { // grouping specified, gather digits and group sizes
+                        string _Groups;
+                        _Groups.push_back('\0');
+                        size_t _Group = 0;
+
+                        for (; _First != _Last; ++_First) {
+                            if ((_Idx = _Find_elem(_Atoms, *_First)) < 10) { // got a digit, add to group size
+                                _Val += _Src[_Idx];
+                                if (_Groups[_Group] != CHAR_MAX) {
+                                    ++_Groups[_Group];
+                                }
+                            } else if (_Groups[_Group] == '\0' || *_First != _Kseparator) {
+                                break; // not a group separator, done
+                            } else { // add a new group to _Groups string
+                                _Groups.push_back('\0');
+                                ++_Group;
+                            }
+                        }
+
+                        if (_Group != 0) { // thousands separators seen
+                            if ('\0' < _Groups[_Group]) {
+                                ++_Group; // add trailing group to group count
+                            } else {
+                                _Bad = true; // trailing separator, fail
+                            }
+                        }
+
+                        for (const char* _Pg = _Grouping.c_str(); !_Bad && 0 < _Group;) {
+                            if (*_Pg == CHAR_MAX) {
+                                break; // end of grouping constraints to check
+                            }
+
+                            if ((0 < --_Group && *_Pg != _Groups[_Group]) || (0 == _Group && *_Pg < _Groups[_Group])) {
+                                _Bad = true; // bad group size, fail
+                            } else if ('\0' < _Pg[1]) {
+                                ++_Pg; // group size okay, advance to next test
+                            }
+                        }
+
+                        if (_Bad) {
+                            break; // bad grouping, give up
+                        }
+                    }
+
+                    const _Elem _Point = _Ppunct_fac->decimal_point();
+                    if (_First != _Last && _Point != _Elem{}
+                        && *_First == _Point) { // seen decimal point, gather fraction digits
+                        while (++_First != _Last && _Fracdigseen < _Fracdigits
+                               && (_Idx = _Find_elem(_Atoms, *_First)) < 10) {
+                            _Val += _Src[_Idx];
+                            ++_Fracdigseen;
+                        }
+
+                        if (_Fracdigseen < _Fracdigits) {
+                            _Bad = true; // short fraction
+                        }
+                    }
+
+                    if (_Val.empty()) {
+                        _Bad = true; // fail if no elements parsed
+                    } else {
+                        for (; _Fracdigseen < _Fracdigits; ++_Fracdigseen) {
+                            _Val += '0'; // pad out fraction with zeros
+                        }
+                    }
+
+                    break;
+                }
+
+            case money_base::space:
+            case money_base::none:
+                { // parse optional space
+                    if (_Off == 3) {
+                        break; // ignore space at end
+                    }
+
+                    bool _Seen = false;
+
+                    for (; _First != _Last && _Ctype_fac.is(ctype_base::space, *_First); ++_First) {
+                        _Seen = true; // skip any space
+                    }
+
+                    if (_Pattern.field[_Off] == money_base::space && !_Seen) {
+                        _Bad = true; // fail if no space seen
+                    }
+
+                    break;
+                }
+
+            default:
+                _STL_ASSERT(false, "Invalid money_base::pattern, see N4981 [locale.moneypunct.general]/1: "
+                                   "In the field member of a pattern object, each value symbol, sign, value, "
+                                   "and either space or none appears exactly once.");
+                break;
+            } // switch
+        }
+
+        if (!_Bad && 1 < _Sign.size()) { // match rest of sign string
+            auto _Source = _Sign.begin();
+
+            while (++_Source != _Sign.end() && _First != _Last && *_First == *_Source) {
+                ++_First;
+            }
+
+            if (_Source != _Sign.end()) {
+                _Bad = true; // rest of sign doesn't match, fail
+            }
+        }
+
+        if (_Bad) {
+            _Val.erase(); // bad input, return empty string
+        } else if (_Neg) {
+            _Val.insert(0, 1, '-'); // minus sign
+        }
+
+        return _Val;
+    }
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _InIt>
+__PURE_APPDOMAIN_GLOBAL locale::id money_get<_Elem, _InIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+class money_put : public locale::facet { // facet for converting encoded monetary amounts to text
+private:
+    using _Mypunct0 = moneypunct<_Elem, false>;
+    using _Mypunct1 = moneypunct<_Elem, true>;
+
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type   = _Elem;
+    using iter_type   = _OutIt;
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+
+    _OutIt put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
+        long double _Val) const { // put long double to _Dest
+        return do_put(_Dest, _Intl, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
+        const string_type& _Val) const { // put string_type to _Dest
+        return do_put(_Dest, _Intl, _Iosbase, _Fill, _Val);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    explicit money_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    money_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new money_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_MONETARY;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~money_put() noexcept override {}
+
+    void _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
+        long double _Val) const { // put long double to _Dest
+        bool _Negative = false;
+        if (_Val < 0) {
+            _Negative = true;
+            _Val      = -_Val;
+        }
+
+        size_t _Exp;
+        for (_Exp = 0; 1e35 <= _Val && _Exp < 5000; _Exp += 10) {
+            _Val /= 1e10; // drop 10 zeros before decimal point
+        }
+
+        char _Buf[40];
+
+        // convert to chars:
+        const int _Count = _CSTD sprintf_s(_Buf, sizeof(_Buf), "%.0Lf", _Val);
+
+        if (_Count < 0) {
+            return _Dest; // bad conversion, give up
+        }
+
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        const _Elem _Elem0             = _Ctype_fac.widen('0');
+
+        string_type _Val2(static_cast<size_t>(_Count), _Elem{});
+        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Val2[0]);
+        _Val2.append(_Exp, _Elem0); // scale by trailing zeros
+        return _Putmfld(_Dest, _Intl, _Iosbase, _Fill, _Negative, _Val2, _Elem0);
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
+        const string_type& _Val) const { // put string_type to _Dest
+        static constexpr char _Src[] = "0123456789-";
+        _Elem _Atoms[sizeof(_Src)];
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        _Ctype_fac.widen(_STD begin(_Src), _STD end(_Src), _Atoms);
+
+        bool _Negative = false;
+        size_t _Idx0   = 0;
+        if (!_Val.empty() && _Val[0] == _Atoms[10]) { // strip off '-'
+            _Negative = true;
+            ++_Idx0;
+        }
+
+        size_t _Size = _Val.size();
+        size_t _Idx  = _Idx0;
+        for (; _Idx < _Size && _Find_elem(_Atoms, _Val[_Idx]) < 10; ++_Idx) { // count digits
+        }
+
+        string_type _Val2(&_Val[_Idx0], _Idx - _Idx0);
+        if (_Val2.empty()) { // replace empty digit string with '0'
+            _Val2.push_back(_Atoms[0]);
+        }
+
+        return _Putmfld(_Dest, _Intl, _Iosbase, _Fill, _Negative, _Val2, _Atoms[0]);
+    }
+
+private:
+    _OutIt _Putmfld(
+        _OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill, bool _Neg, string_type _Val, _Elem _Elem0) const {
+        // put string_type with just digits to _Dest
+        const _Mpunct<_Elem>* _Ppunct_fac;
+        if (_Intl) {
+            _Ppunct_fac = _STD addressof(_STD use_facet<_Mypunct1>(_Iosbase.getloc())); // international
+        } else {
+            _Ppunct_fac = _STD addressof(_STD use_facet<_Mypunct0>(_Iosbase.getloc())); // local
+        }
+
+        const string _Grouping = _Ppunct_fac->grouping();
+        int _Ifracdigits       = _Ppunct_fac->frac_digits();
+        const auto _Fracdigits = static_cast<unsigned int>(_Ifracdigits < 0 ? -_Ifracdigits : _Ifracdigits);
+
+        if (_Val.size() <= _Fracdigits) {
+            _Val.insert(0, _Fracdigits - _Val.size() + 1, _Elem0);
+        } else if (*_Grouping.c_str() != CHAR_MAX && '\0' < *_Grouping.c_str()) {
+            // grouping specified, add thousands separators
+            const _Elem _Kseparator = _Ppunct_fac->thousands_sep();
+            const char* _Pg         = _Grouping.c_str();
+            size_t _Off             = _Val.size() - _Fracdigits; // start of fraction
+
+            while (*_Pg != CHAR_MAX && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Off) {
+                // add a thousands separator, right to left
+                _Val.insert(_Off -= *_Pg, 1, _Kseparator);
+                if ('\0' < _Pg[1]) {
+                    ++_Pg; // not last group, advance
+                }
+            }
+        }
+
+        money_base::pattern _Pattern;
+        string_type _Sign;
+        if (_Neg) { // negative value, choose appropriate format and sign
+            _Pattern = _Ppunct_fac->neg_format();
+            _Sign    = _Ppunct_fac->negative_sign();
+        } else { // positive value, choose appropriate format and sign
+            _Pattern = _Ppunct_fac->pos_format();
+            _Sign    = _Ppunct_fac->positive_sign();
+        }
+
+        string_type _Symbol;
+        if (_Iosbase.flags() & ios_base::showbase) {
+            _Symbol = _Ppunct_fac->curr_symbol(); // showbase ==> show $
+        }
+
+        bool _Intern = false;
+        size_t _Fillcount;
+        size_t _Off;
+        for (_Fillcount = 0, _Off = 0; _Off < 4; ++_Off) {
+            switch (_Pattern.field[_Off]) { // accumulate total length in _Fillcount
+            case money_base::symbol: // count currency symbol size
+                _Fillcount += _Symbol.size();
+                break;
+
+            case money_base::sign: // count sign size
+                _Fillcount += _Sign.size();
+                break;
+
+            case money_base::value: // count value field size
+                _Fillcount += _Val.size() + (0 < _Fracdigits ? 1 : 0)
+                            + (_Val.size() <= _Fracdigits ? _Fracdigits - _Val.size() + 1 : 0);
+                break;
+
+            case money_base::space: // count space size
+                ++_Fillcount; // at least one space
+                _FALLTHROUGH;
+
+            case money_base::none: // count space size
+                if (_Off != 3) {
+                    _Intern = true; // optional internal fill
+                }
+
+                break;
+
+            default:
+                _STL_ASSERT(false, "Invalid money_base::pattern, see N4981 [locale.moneypunct.general]/1: "
+                                   "In the field member of a pattern object, each value symbol, sign, value, "
+                                   "and either space or none appears exactly once.");
+                break;
+            }
+        }
+
+        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Fillcount) {
+            _Fillcount = 0;
+        } else {
+            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Fillcount;
+        }
+
+        ios_base::fmtflags _Afl = _Iosbase.flags() & ios_base::adjustfield;
+        if (_Afl != ios_base::left && (_Afl != ios_base::internal || !_Intern)) { // put leading fill
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+        }
+
+        for (_Off = 0; _Off < 4; ++_Off) {
+            switch (_Pattern.field[_Off]) { // put components as specified by _Pattern
+            case money_base::symbol: // put currency symbol
+                _Dest = _Put(_Dest, _Symbol.begin(), _Symbol.size());
+                break;
+
+            case money_base::sign: // put sign
+                if (0 < _Sign.size()) {
+                    _Dest = _Put(_Dest, _Sign.begin(), 1);
+                }
+
+                break;
+
+            case money_base::value: // put value field
+                if (_Fracdigits == 0) {
+                    _Dest = _Put(_Dest, _Val.begin(), _Val.size()); // no fraction part
+                } else if (_Val.size() <= _Fracdigits) { // put leading zero, all fraction digits
+                    *_Dest++ = _Elem0;
+                    *_Dest++ = _Ppunct_fac->decimal_point();
+                    _Dest    = _Rep(_Dest, _Elem0, _Fracdigits - _Val.size()); // insert zeros
+                    _Dest    = _Put(_Dest, _Val.begin(), _Val.size());
+                } else { // put both integer and fraction parts
+                    _Dest    = _Put(_Dest, _Val.begin(), _Val.size() - _Fracdigits); // put integer part
+                    *_Dest++ = _Ppunct_fac->decimal_point();
+                    _Dest =
+                        _Put(_Dest, _Val.end() - static_cast<ptrdiff_t>(_Fracdigits), _Fracdigits); // put fraction part
+                }
+                break;
+
+            case money_base::space: // put any internal fill
+                _Dest = _Rep(_Dest, _Fill, 1);
+                _FALLTHROUGH;
+
+            case money_base::none: // put any internal fill
+                if (_Afl == ios_base::internal) { // put internal fill
+                    _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+                    _Fillcount = 0;
+                }
+                break;
+
+            default:
+                _STL_ASSERT(false, "Invalid money_base::pattern, see N4981 [locale.moneypunct.general]/1: "
+                                   "In the field member of a pattern object, each value symbol, sign, value, "
+                                   "and either space or none appears exactly once.");
+                break;
+            }
+        }
+
+        if (1 < _Sign.size()) {
+            _Dest = _Put(_Dest, _Sign.begin() + 1, _Sign.size() - 1); // put remainder of sign
+        }
+
+        _Iosbase.width(0);
+        return _Rep(_Dest, _Fill, _Fillcount); // put trailing fill
+    }
+
+    static _OutIt _Put(_OutIt _Dest, typename string_type::const_iterator _Source, size_t _Count) {
+        // put [_Source, _Source + _Count) to _Dest
+        for (; 0 < _Count; --_Count, (void) ++_Dest, ++_Source) {
+            *_Dest = *_Source;
+        }
+
+        return _Dest;
+    }
+
+    static _OutIt _Rep(_OutIt _Dest, _Elem _Ch, size_t _Count) { // put _Count * _Ch to _Dest
+        for (; 0 < _Count; --_Count, (void) ++_Dest) {
+            *_Dest = _Ch;
+        }
+
+        return _Dest;
+    }
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id money_put<_Elem, _OutIt>::id;
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template _PGLOBAL const bool moneypunct<char, true>::intl;
+template _PGLOBAL const bool moneypunct<char, false>::intl;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<char, true>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<char, false>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id money_get<char, istreambuf_iterator<char, char_traits<char>>>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id money_put<char, ostreambuf_iterator<char, char_traits<char>>>::id;
+
+template _PGLOBAL const bool moneypunct<wchar_t, true>::intl;
+template _PGLOBAL const bool moneypunct<wchar_t, false>::intl;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<wchar_t, true>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<wchar_t, false>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>::id;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template _PGLOBAL const bool moneypunct<unsigned short, true>::intl;
+template _PGLOBAL const bool moneypunct<unsigned short, false>::intl;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<unsigned short, true>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id moneypunct<unsigned short, false>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id
+    money_get<unsigned short, istreambuf_iterator<unsigned short, char_traits<unsigned short>>>::id;
+template __PURE_APPDOMAIN_GLOBAL locale::id
+    money_put<unsigned short, ostreambuf_iterator<unsigned short, char_traits<unsigned short>>>::id;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCMON_
diff --git a/msvc-stl/stl/inc/xlocnum b/msvc-stl/stl/inc/xlocnum
new file mode 100644
index 0000000..e479ef4
--- /dev/null
+++ b/msvc-stl/stl/inc/xlocnum
@@ -0,0 +1,1727 @@
+// xlocnum internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCNUM_
+#define _XLOCNUM_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cfloat>
+#include <climits>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <iterator>
+#include <streambuf>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE long __CLRCALL_PURE_OR_CDECL _Stolx(
+    const char*, _Out_opt_ _Deref_post_opt_valid_ char**, int, int*) noexcept;
+_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Stoulx(
+    const char*, _Out_opt_ _Deref_post_opt_valid_ char**, int, int*) noexcept;
+_CRTIMP2_PURE long long __CLRCALL_PURE_OR_CDECL _Stollx(
+    const char*, _Out_opt_ _Deref_post_opt_valid_ char**, int, int*) noexcept;
+_CRTIMP2_PURE unsigned long long __CLRCALL_PURE_OR_CDECL _Stoullx(
+    const char*, _Out_opt_ _Deref_post_opt_valid_ char**, int, int*) noexcept;
+
+_END_EXTERN_C_UNLESS_PURE
+
+_STD_BEGIN
+
+_INLINE_VAR constexpr size_t _Max_int_dig = 32; // integer properties
+
+inline double _Stodx_v3(const char* _Str, char** _Endptr, int* _Perr) noexcept { // convert string to double
+    int& _Errno_ref = errno; // Nonzero cost, pay it once
+    const int _Orig = _Errno_ref;
+
+    _Errno_ref  = 0;
+    double _Val = _CSTD strtod(_Str, _Endptr);
+    *_Perr      = _Errno_ref;
+    _Errno_ref  = _Orig;
+
+    return _Val;
+}
+
+inline float _Stofx_v3(const char* _Str, char** _Endptr, int* _Perr) noexcept { // convert string to float
+    int& _Errno_ref = errno; // Nonzero cost, pay it once
+    const int _Orig = _Errno_ref;
+
+    _Errno_ref = 0;
+    float _Val = _CSTD strtof(_Str, _Endptr);
+    *_Perr     = _Errno_ref;
+    _Errno_ref = _Orig;
+
+    return _Val;
+}
+
+template <class _Elem, size_t _Base_size>
+size_t _Find_elem(const _Elem (&_Base)[_Base_size], const _Elem _Ch) {
+    // lookup _Ch in array storing NUL-terminated string _Base
+    // pre: _Base contains no nulls except for _Base[_Base_size - 1]
+    return static_cast<size_t>(_STD _Find_unchecked(_Base, _Base + (_Base_size - 1), _Ch) - _Base);
+}
+
+inline wchar_t* _Maklocwcs(const wchar_t* _Ptr) { // copy NTWCS to allocated storage
+    const size_t _Count = _CSTD wcslen(_Ptr) + 1;
+
+    wchar_t* _Ptrdest = static_cast<wchar_t*>(_calloc_dbg(_Count, sizeof(wchar_t), _CRT_BLOCK, __FILE__, __LINE__));
+
+    if (!_Ptrdest) {
+        _Xbad_alloc();
+    }
+
+    _CSTD wmemcpy(_Ptrdest, _Ptr, _Count);
+    return _Ptrdest;
+}
+
+_EXPORT_STD template <class _Elem>
+class numpunct : public locale::facet { // facet for defining numeric punctuation text
+private:
+    friend _Tidy_guard<numpunct>;
+
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
+    using char_type   = _Elem;
+
+    __PURE_APPDOMAIN_GLOBAL _CRTIMP2_PURE_IMPORT static locale::id id; // unique facet id
+
+    _Elem decimal_point() const {
+        return do_decimal_point();
+    }
+
+    _Elem thousands_sep() const {
+        return do_thousands_sep();
+    }
+
+    string grouping() const {
+        return do_grouping();
+    }
+
+    string_type falsename() const {
+        return do_falsename();
+    }
+
+    string_type truename() const {
+        return do_truename();
+    }
+
+    explicit numpunct(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        if (_Kseparator == 0) {
+            _Kseparator = _Maklocchr<_Elem>(',', _Lobj._Getcvt()); // NB: differs from "C" locale
+        }
+        _END_LOCINFO()
+    }
+
+    numpunct(const _Locinfo& _Lobj, size_t _Refs = 0, bool _Isdef = false) : locale::facet(_Refs) {
+        _Init(_Lobj, _Isdef);
+    }
+
+    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new numpunct<_Elem>(_Locinfo(_Ploc->_C_str()), 0, true);
+        }
+        return _X_NUMERIC;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~numpunct() noexcept override {
+        _Tidy();
+    }
+
+    numpunct(const char* _Locname, size_t _Refs = 0, bool _Isdef = false) : locale::facet(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj, _Isdef);
+        _END_LOCINFO()
+    }
+
+    void _Init(const _Locinfo& _Lobj, bool _Isdef = false) { // initialize from _Lobj
+        const lconv* _Ptr      = _Lobj._Getlconv();
+        _Locinfo::_Cvtvec _Cvt = _Lobj._Getcvt(); // conversion information
+
+        _Grouping  = nullptr;
+        _Falsename = nullptr;
+        _Truename  = nullptr;
+
+        _Tidy_guard<numpunct> _Guard{this};
+        _Grouping      = _Maklocstr<char>(_Isdef ? "" : _Ptr->grouping, _Cvt);
+        _Falsename     = _Maklocstr<_Elem>(_Lobj._Getfalse(), _Cvt);
+        _Truename      = _Maklocstr<_Elem>(_Lobj._Gettrue(), _Cvt);
+        _Guard._Target = nullptr;
+
+        if (_Isdef) { // apply defaults for required facets
+            _Dp         = _Maklocchr<_Elem>('.', _Cvt);
+            _Kseparator = _Maklocchr<_Elem>(',', _Cvt);
+        } else {
+            if constexpr (is_same_v<_Elem, wchar_t>) {
+                _Dp         = _Ptr->_W_decimal_point[0];
+                _Kseparator = _Ptr->_W_thousands_sep[0];
+            } else {
+                _Dp         = _Maklocchr<_Elem>(_Ptr->decimal_point[0], _Cvt);
+                _Kseparator = _Maklocchr<_Elem>(_Ptr->thousands_sep[0], _Cvt);
+            }
+        }
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_decimal_point() const {
+        return _Dp;
+    }
+
+    virtual _Elem __CLR_OR_THIS_CALL do_thousands_sep() const {
+        return _Kseparator;
+    }
+
+    virtual string __CLR_OR_THIS_CALL do_grouping() const {
+        return string{_Grouping};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_falsename() const {
+        return string_type{_Falsename};
+    }
+
+    virtual string_type __CLR_OR_THIS_CALL do_truename() const {
+        return string_type{_Truename};
+    }
+
+private:
+    void _Tidy() noexcept { // free all storage
+        _CSTD free(const_cast<char*>(_Grouping));
+        _CSTD free(const_cast<_Elem*>(_Falsename));
+        _CSTD free(const_cast<_Elem*>(_Truename));
+    }
+
+    const char* _Grouping; // grouping string, "" for "C" locale
+    _Elem _Dp; // decimal point, '.' for "C" locale
+    _Elem _Kseparator; // thousands separator, '\0' for "C" locale
+    const _Elem* _Falsename; // name for false, "false" for "C" locale
+    const _Elem* _Truename; // name for true, "true" for "C" locale
+};
+
+_EXPORT_STD template <class _Elem>
+class numpunct_byname : public numpunct<_Elem> { // numpunct for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit numpunct_byname(const char* _Locname, size_t _Refs = 0)
+        : numpunct<_Elem>(_Locname, _Refs) {} // construct for named locale
+
+    explicit numpunct_byname(const string& _Str, size_t _Refs = 0)
+        : numpunct<_Elem>(_Str.c_str(), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~numpunct_byname() noexcept override {}
+};
+
+#if !defined(_CRTBLD) || defined(CRTDLL2) || !defined(_DLL) || defined(_M_CEE_PURE) // TRANSITION, VSO-578955
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem>
+__PURE_APPDOMAIN_GLOBAL locale::id numpunct<_Elem>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+#endif // !defined(_CRTBLD) || defined(CRTDLL2) || !defined(_DLL) || defined(_M_CEE_PURE)
+
+struct _Num_get_parse_result {
+    // For integers: negative values mean parsing failure, while the "actual" base (used by _Getifld) is ~_Base.
+    // Otherwise, 0, 8, 10, or 16.
+    // For floating-point numbers: 0 for parsing failure, otherwise 10 or 16.
+    int8_t _Base;
+    bool _Bad_grouping;
+};
+
+_EXPORT_STD extern "C++" template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+class num_get : public locale::facet { // facet for converting text to encoded numbers
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new num_get<_Elem, _InIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_NUMERIC;
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+protected:
+    __CLR_OR_THIS_CALL ~num_get() noexcept override {}
+
+    void _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+public:
+    explicit __CLR_OR_THIS_CALL num_get(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL num_get(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    using char_type = _Elem;
+    using iter_type = _InIt;
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        bool& _Val) const { // get bool from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned short& _Val) const { // get unsigned short from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned int& _Val) const { // get unsigned int from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long& _Val) const { // get long from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned long& _Val) const { // get unsigned long from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long long& _Val) const { // get long long from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned long long& _Val) const { // get unsigned long long from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        float& _Val) const { // get float from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        double& _Val) const { // get double from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long double& _Val) const { // get long double from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        void*& _Val) const { // get void pointer from [_First, _Last) into _Val
+        return do_get(_First, _Last, _Iosbase, _State, _Val);
+    }
+
+protected:
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        bool& _Val) const { // get bool from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        if (_Iosbase.flags() & ios_base::boolalpha) { // get false name or true name
+            const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());
+            basic_string<_Elem> _Str(static_cast<size_t>(1), _Elem{});
+            _Str += _Punct_fac.falsename();
+            _Str.push_back(_Elem{});
+            _Str += _Punct_fac.truename(); // construct "\0false\0true"
+            switch (_Getloctxt(_First, _Last, 2, _Str.c_str(), _Case_sensitive::_Yes)) {
+            case 0:
+                _Val = false;
+                break;
+            case 1:
+                _Val = true;
+                break;
+            default:
+                _Val   = false;
+                _State = ios_base::failbit;
+                break;
+            }
+        } else { // get long value
+            char _Ac[_Max_int_dig];
+            const auto _Parse_result =
+                _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+            if (_Parse_result._Base < 0) {
+                // N4950 [facet.num.get.virtuals]/3.9:
+                //  "zero, if the conversion function does not convert the entire field."
+                _Val   = false;
+                _State = ios_base::failbit;
+            } else {
+                char* _Ep;
+                int _Errno;
+                const long _Ans = _CSTD _Stolx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+                _Val            = _Ans != 0;
+                if (_Ep == _Ac || _Errno != 0 // N5008 [facet.num.get.virtuals]/3
+                    || _Parse_result._Bad_grouping // N5008 [facet.num.get.virtuals]/4
+                    || (_Ans != 0 && _Ans != 1)) { // N5008 [facet.num.get.virtuals]/6
+                    _State = ios_base::failbit;
+                }
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned short& _Val) const { // get unsigned short from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            const bool _Minus   = _Ac[0] == '-';
+            const char* _Digits = _Ac;
+            // C11 7.22.1.4/5: the sequence of characters starting with the first digit
+            // is interpreted as an integer constant according to the rules of 6.4.4.1
+            if (_Minus) { // skip over minus to start with the first digit
+                ++_Digits;
+            }
+
+            char* _Ep;
+            int _Errno;
+            const unsigned long _Tmp = _CSTD _Stoulx(_Digits, &_Ep, _Parse_result._Base, &_Errno); // convert
+            _Val                     = static_cast<unsigned short>(_Tmp);
+            if (_Ep == _Digits || _Errno != 0 || _Tmp > USHRT_MAX) { // N4950 [facet.num.get.virtuals]/3
+                _State = ios_base::failbit;
+                _Val   = USHRT_MAX;
+            } else if (_Minus) { // C11 7.22.1.4/5:  If the subject sequence begins with a minus sign,
+                                 // the value resulting from the conversion is negated (in the return type).
+                _Val = static_cast<unsigned short>(0 - _Val);
+            }
+
+            if (_Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned int& _Val) const { // get unsigned int from [_First, _Last) into _Val
+        static_assert(sizeof(unsigned int) == sizeof(unsigned long),
+            "Bad overflow assumptions due to sizeof(unsigned int) != sizeof(unsigned long)");
+        unsigned long _Tmp;
+        _First = num_get::do_get(_First, _Last, _Iosbase, _State, _Tmp); // avoid virtual call for perf
+        _Val   = _Tmp;
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long& _Val) const { // get long from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            char* _Ep;
+            int _Errno;
+            _Val = _CSTD _Stolx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned long& _Val) const { // get unsigned long from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            char* _Ep;
+            int _Errno;
+            _Val = _CSTD _Stoulx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long long& _Val) const { // get long long from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            char* _Ep;
+            int _Errno;
+            _Val = _CSTD _Stollx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        unsigned long long& _Val) const { // get unsigned long long from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0;
+        } else {
+            int _Errno;
+            char* _Ep;
+            _Val = _CSTD _Stoullx(_Ac, &_Ep, _Parse_result._Base, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+#define _MAX_SIG_DIG_V2 768
+#define _MAX_EXP_DIG    8 // for parsing floating-point numbers
+// Size of char buffer used by num_get::do_get() for float/double/long double
+#define _FLOATING_BUFFER_SIZE (_MAX_EXP_DIG + _MAX_SIG_DIG_V2 + 16)
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        float& _Val) const { // get float from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_FLOATING_BUFFER_SIZE];
+        const auto _Parse_result =
+            _Parse_fp_with_locale(_Ac, _MAX_SIG_DIG_V2, _First, _Last, _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base == 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0.0f;
+        } else {
+            int _Errno;
+            char* _Ep;
+            _Val = _STD _Stofx_v3(_Ac, &_Ep, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        double& _Val) const { // get double from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_FLOATING_BUFFER_SIZE];
+        const auto _Parse_result =
+            _Parse_fp_with_locale(_Ac, _MAX_SIG_DIG_V2, _First, _Last, _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base == 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = 0.0;
+        } else {
+            int _Errno;
+            char* _Ep;
+            _Val = _STD _Stodx_v3(_Ac, &_Ep, &_Errno); // convert
+            if (_Ep == _Ac || _Errno != 0 // N4950 [facet.num.get.virtuals]/3
+                || _Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+#undef _FLOATING_BUFFER_SIZE
+#undef _MAX_EXP_DIG
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        long double& _Val) const { // get long double from [_First, _Last) into _Val
+        // Assumes sizeof(double) == sizeof(long double).
+        // For 80-bit long double (which is not supported by MSVC in general), this will compile
+        // but will not attempt to handle the increased precision at runtime.
+        double _Result;
+        _First = num_get::do_get(_First, _Last, _Iosbase, _State, _Result); // avoid virtual call for perf
+        _Val   = _Result;
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        void*& _Val) const { // get void pointer from [_First, _Last) into _Val
+        _Adl_verify_range(_First, _Last);
+        char _Ac[_Max_int_dig];
+        const auto _Parse_result =
+            _Parse_int_with_locale(_Ac, _First, _Last, ios_base::hex, _Iosbase.getloc()); // gather field
+        if (_Parse_result._Base < 0) { // ditto "fails to convert the entire field"
+            _State = ios_base::failbit;
+            _Val   = nullptr;
+        } else {
+            int _Errno;
+            char* _Ep;
+#ifdef _WIN64
+            _Val = reinterpret_cast<void*>(_CSTD _Stoullx(_Ac, &_Ep, _Parse_result._Base, &_Errno));
+#else // ^^^ 64-bit / 32-bit vvv
+            _Val = reinterpret_cast<void*>(_CSTD _Stoulx(_Ac, &_Ep, _Parse_result._Base, &_Errno));
+#endif // ^^^ 32-bit ^^^
+            if (_Ep == _Ac || _Errno != 0) { // N4950 [facet.num.get.virtuals]/3
+                _State = ios_base::failbit;
+                _Val   = nullptr;
+            }
+
+            if (_Parse_result._Bad_grouping) { // N4950 [facet.num.get.virtuals]/4
+                _State = ios_base::failbit;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+private:
+    template <int = 0> // TRANSITION, ABI
+    static _Num_get_parse_result _Parse_int_with_locale(
+        char* const _Ac, _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield, const locale& _Loc) {
+        // get integer field from [_First, _Last) into _Ac
+        const auto& _Punct_fac  = _STD use_facet<numpunct<_Elem>>(_Loc);
+        const string _Grouping  = _Punct_fac.grouping();
+        const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
+
+        constexpr int _Numget_signoff = 22;
+        constexpr int _Numget_xoff    = 24;
+        static constexpr char _Src[]  = "0123456789ABCDEFabcdef-+Xx";
+        _Elem _Atoms[sizeof(_Src)];
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Loc);
+        _Ctype_fac.widen(_STD begin(_Src), _STD end(_Src), _Atoms);
+
+        bool _Bad_grouping = false;
+
+        // skip leading separators before the sign
+        if (_Kseparator != _Elem{}) {
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+        }
+
+        char* _Ptr = _Ac;
+
+        if (_First != _Last) {
+            if (*_First == _Atoms[_Numget_signoff + 1]) { // gather plus sign
+                *_Ptr++ = '+';
+                ++_First;
+            } else if (*_First == _Atoms[_Numget_signoff]) { // gather minus sign
+                *_Ptr++ = '-';
+                ++_First;
+            }
+        }
+
+        // skip leading separators before digits
+        if (_Kseparator != _Elem{}) {
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+        }
+
+        _Basefield &= ios_base::basefield;
+
+        int8_t _Base;
+        if (_Basefield == ios_base::oct) {
+            _Base = 8;
+        } else if (_Basefield == ios_base::hex) {
+            _Base = 16;
+        } else if (_Basefield == ios_base::_Fmtzero) {
+            _Base = 0;
+        } else {
+            _Base = 10;
+        }
+
+        bool _Seendigit = false; // seen a digit in input
+        bool _Nonzero   = false; // seen a nonzero digit in input
+
+        if (_First != _Last && *_First == _Atoms[0]) { // leading zero, look for 0x, 0X
+            _Seendigit = true;
+            ++_First;
+            if (_First != _Last && (*_First == _Atoms[_Numget_xoff + 1] || *_First == _Atoms[_Numget_xoff])
+                && (_Base == 0 || _Base == 16)) {
+                _Base      = 16;
+                _Seendigit = false;
+                ++_First;
+            } else if (_Base == 0) {
+                _Base = 8;
+            }
+        }
+
+        const auto _Dlen = static_cast<size_t>(_Base == 0 || _Base == 10 ? 10 : _Base == 8 ? 8 : 16 + 6);
+        string _Groups(1, static_cast<char>(_Seendigit)); // Groups are detected in the reversed order of _Groups.
+        size_t _Groups_arr_idx = 0;
+
+        for (char* const _Pe = &_Ac[_Max_int_dig - 1]; _First != _Last; ++_First) { // look for digits and separators
+            size_t _Idx = _STD _Find_elem(_Atoms, *_First);
+            if (_Idx < _Dlen) { // got a digit, characterize it and add to group size
+                *_Ptr = _Src[_Idx];
+                if ((_Nonzero || *_Ptr != '0') && _Ptr < _Pe) {
+                    ++_Ptr;
+                    _Nonzero = true;
+                }
+
+                _Seendigit = true;
+                if (_Groups[_Groups_arr_idx] != CHAR_MAX) {
+                    ++_Groups[_Groups_arr_idx];
+                }
+            } else if (_Kseparator == _Elem{} || *_First != _Kseparator) {
+                break; // not a group separator, done
+            } else if (_Groups[_Groups_arr_idx] == '\0') {
+                _Bad_grouping = true; // adjacent separators, fail
+            } else { // add a new group to _Groups string
+                _Groups.push_back('\0');
+                ++_Groups_arr_idx;
+            }
+        }
+
+        if (_Groups_arr_idx != 0) {
+            if (_Groups[_Groups_arr_idx] > '\0') {
+                ++_Groups_arr_idx; // add trailing group to group count
+            } else {
+                _Bad_grouping = true; // trailing separator, fail
+            }
+        }
+
+        // skip trailing separators
+        if (_Kseparator != _Elem{}) {
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+        }
+
+        const char* _Grouping_iter      = _Grouping.data();
+        const char* const _Grouping_end = _Grouping_iter + _Grouping.size();
+        for (char _Current_grouping_count = '\0'; _Seendigit && !_Bad_grouping && _Groups_arr_idx > 0;) {
+            if (_Grouping_iter != _Grouping_end) { // keep the last value when _Grouping is exhausted
+                _Current_grouping_count = *_Grouping_iter; // if _Grouping is empty, '\0' is used
+                ++_Grouping_iter;
+            }
+
+            --_Groups_arr_idx;
+            if ((_Current_grouping_count > '\0' && _Current_grouping_count != CHAR_MAX)
+                && ((_Groups_arr_idx > 0 && _Groups[_Groups_arr_idx] != _Current_grouping_count)
+                    || (_Groups_arr_idx == 0 && _Groups[_Groups_arr_idx] > _Current_grouping_count))) {
+                _Bad_grouping = true; // bad group size, fail
+            }
+            // group size okay, advance to next test
+        }
+
+        if (!_Seendigit) {
+            return {static_cast<int8_t>(~_Base), false};
+        }
+
+        if (!_Nonzero) {
+            *_Ptr++ = '0'; // zero field, replace stripped zero(s)
+        }
+
+        *_Ptr = '\0';
+        return {_Base, _Bad_grouping};
+    }
+
+    template <int = 0> // TRANSITION, ABI
+    static _Num_get_parse_result _Parse_fp_with_locale(
+        char* const _Ac, const int _Max_sig_dig, _InIt& _First, _InIt& _Last, const locale& _Loc) {
+        // get floating-point field from [_First, _Last) into _Ac
+        char* _Ptr = _Ac;
+
+        constexpr size_t _Offset_dec_digit_end = 10;
+        constexpr size_t _Offset_hex_digit_end = 22;
+        constexpr size_t _Offset_neg_sign      = 22;
+        constexpr size_t _Offset_pos_sign      = 23;
+        constexpr size_t _Offset_upper_x       = 24;
+        constexpr size_t _Offset_lower_x       = 25;
+        constexpr size_t _Offset_upper_p       = 26;
+        constexpr size_t _Offset_lower_p       = 27;
+        constexpr size_t _Offset_upper_e       = 14;
+        constexpr size_t _Offset_lower_e       = 20;
+        static constexpr char _Src[]           = "0123456789ABCDEFabcdef-+XxPp";
+        _Elem _Atoms[sizeof(_Src)];
+        const auto& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Loc);
+        _Ctype_fac.widen(_STD begin(_Src), _STD end(_Src), _Atoms);
+
+        const _Elem _Positive_sign = _Atoms[_Offset_pos_sign];
+        const _Elem _Negative_sign = _Atoms[_Offset_neg_sign];
+        const _Elem _Zero_wc       = _Atoms[0];
+
+        const auto& _Punct_fac  = _STD use_facet<numpunct<_Elem>>(_Loc);
+        const string _Grouping  = _Punct_fac.grouping();
+        const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
+
+        bool _Bad_grouping = false;
+
+        // skip leading separators before the sign
+        if (!_Grouping.empty()) {
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+        }
+
+        if (_First != _Last) {
+            if (*_First == _Positive_sign) { // gather plus sign
+                *_Ptr++ = '+';
+                ++_First;
+            } else if (*_First == _Negative_sign) { // gather minus sign
+                *_Ptr++ = '-';
+                ++_First;
+            }
+        }
+
+        *_Ptr++ = '0'; // backstop carries from sticky bit
+
+        bool _Parse_hex                = false;
+        bool _Seendigit                = false; // seen a digit in input
+        char _Initial_dec_leading_zero = '\0';
+        if (_First != _Last && *_First == _Zero_wc) {
+            ++_First;
+            if (_First == _Last) { // "0" only
+                *_Ptr = '\0';
+                return {10, _Bad_grouping};
+            }
+
+            if (*_First == _Atoms[_Offset_lower_x] || *_First == _Atoms[_Offset_upper_x]) { // 0x or 0X
+                _Parse_hex = true;
+                ++_First; // discard 0x or 0X for further parsing
+                *_Ptr++ = 'x';
+            } else {
+                _Seendigit = true;
+                ++_Initial_dec_leading_zero;
+            }
+        }
+
+        bool _Has_unaccumulated_digits = false;
+        int _Significant               = 0; // number of significant digits
+        ptrdiff_t _Power_of_rep_base   = 0; // power of 10 or 16
+
+        const size_t _Offset_digit_end = _Parse_hex ? _Offset_hex_digit_end : _Offset_dec_digit_end;
+        if (_Grouping.empty()) {
+            for (size_t _Idx; _First != _Last && (_Idx = _STD _Find_elem(_Atoms, *_First)) < _Offset_digit_end;
+                _Seendigit = true, (void) ++_First) {
+                if (_Significant >= _Max_sig_dig) {
+                    ++_Power_of_rep_base; // just scale by 10 or 16
+                    if (_Idx > 0) {
+                        _Has_unaccumulated_digits = true;
+                    }
+                } else if (_Idx != 0 || _Significant != 0) { // save a significant digit
+                    *_Ptr++ = _Src[_Idx];
+                    ++_Significant;
+                }
+            }
+        } else {
+            // skip leading separators before digits
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+
+            string _Groups(1, _Initial_dec_leading_zero); // Groups are detected in the reversed order of _Groups.
+            size_t _Groups_arr_idx = 0;
+
+            for (; _First != _Last; ++_First) {
+                const size_t _Idx = _STD _Find_elem(_Atoms, *_First);
+                if (_Idx < _Offset_digit_end) { // got a digit, add to group size
+                    _Seendigit = true;
+                    if (_Significant >= _Max_sig_dig) {
+                        ++_Power_of_rep_base; // just scale by 10 or 16
+                        if (_Idx > 0) {
+                            _Has_unaccumulated_digits = true;
+                        }
+                    } else if (_Idx != 0 || _Significant != 0) { // save a significant digit
+                        *_Ptr++ = _Src[_Idx];
+                        ++_Significant;
+                    }
+
+                    if (_Groups[_Groups_arr_idx] != CHAR_MAX) {
+                        ++_Groups[_Groups_arr_idx];
+                    }
+                } else if (*_First != _Kseparator) {
+                    break; // not a group separator, done
+                } else if (_Groups[_Groups_arr_idx] == '\0') {
+                    _Bad_grouping = true; // adjacent separators, fail
+                } else { // add a new group to _Groups string
+                    _Groups.push_back('\0');
+                    ++_Groups_arr_idx;
+                }
+            }
+
+            if (_Groups_arr_idx != 0) {
+                if (_Groups[_Groups_arr_idx] > '\0') {
+                    ++_Groups_arr_idx; // add trailing group to group count
+                } else {
+                    _Bad_grouping = true; // trailing separator, fail
+                }
+            }
+
+            // skip trailing separators
+            while (_First != _Last && *_First == _Kseparator) {
+                ++_First;
+                _Bad_grouping = true;
+            }
+
+            const char* _Grouping_iter      = _Grouping.data();
+            const char* const _Grouping_end = _Grouping_iter + _Grouping.size();
+            char _Current_grouping_count    = '\0';
+            while (!_Bad_grouping && _Groups_arr_idx > 0) {
+                if (_Grouping_iter != _Grouping_end) { // keep the last value when _Grouping is exhausted
+                    _Current_grouping_count = *_Grouping_iter; // assign the variable at least once
+                    ++_Grouping_iter;
+                }
+
+                --_Groups_arr_idx;
+                if ((_Current_grouping_count > '\0' && _Current_grouping_count != CHAR_MAX)
+                    && ((_Groups_arr_idx > 0 && _Groups[_Groups_arr_idx] != _Current_grouping_count)
+                        || (_Groups_arr_idx == 0 && _Groups[_Groups_arr_idx] > _Current_grouping_count))) {
+                    _Bad_grouping = true; // bad group size, fail
+                }
+                // group size okay, advance to next test
+            }
+        }
+
+        if (_Parse_hex && _Seendigit && _Significant == 0) {
+            // the condition is true when all of the digits after the 'x' and before the decimal point are zero
+            *_Ptr++ = '0'; // save at least one leading digit for hex
+        }
+
+        const char _Decimal_point = (_CSTD localeconv())->decimal_point[0];
+        if (_First != _Last && *_First == _Punct_fac.decimal_point()) { // add .
+            *_Ptr++ = _Decimal_point;
+            ++_First;
+        }
+
+        if (_Significant == 0) { // 0000. so far
+            for (; _First != _Last && *_First == _Zero_wc; _Seendigit = true, (void) ++_First) {
+                --_Power_of_rep_base; // count leading fraction zeros without storing digits into buffer
+            }
+        }
+
+        for (size_t _Idx; _First != _Last && (_Idx = _STD _Find_elem(_Atoms, *_First)) < _Offset_digit_end;
+            _Seendigit = true, (void) ++_First) {
+            if (_Significant < _Max_sig_dig) { // save a significant fraction digit
+                *_Ptr++ = _Src[_Idx];
+                ++_Significant;
+            } else if (_Idx > 0) {
+                _Has_unaccumulated_digits = true; // just update _Has_unaccumulated_digits
+            }
+        }
+
+        if (_Has_unaccumulated_digits) { // increment last digit in memory of those lost
+            char& _Last_got_digit = _Ptr[-1] == _Decimal_point ? _Ptr[-2] : _Ptr[-1];
+            if (_Last_got_digit == '0' || _Last_got_digit == (_Parse_hex ? '8' : '5')) {
+                ++_Last_got_digit;
+            }
+        }
+
+        const _Elem _Lower_exp_wc = _Atoms[_Parse_hex ? _Offset_lower_p : _Offset_lower_e]; // 'e' for dec, 'p' for hex
+        const _Elem _Upper_exp_wc = _Atoms[_Parse_hex ? _Offset_upper_p : _Offset_upper_e]; // 'E' for dec, 'P' for hex
+
+        bool _Exponent_part_negative = false;
+        ptrdiff_t _Exponent_part     = 0;
+        if (_Seendigit && _First != _Last
+            && (*_First == _Lower_exp_wc || *_First == _Upper_exp_wc)) { // collect exponent
+            ++_First;
+            _Seendigit   = false;
+            _Significant = 0;
+
+            if (_First != _Last) {
+                if (*_First == _Positive_sign) { // gather plus sign
+                    ++_First;
+                } else if (*_First == _Negative_sign) { // gather minus sign
+                    _Exponent_part_negative = true;
+                    ++_First;
+                }
+            }
+
+            for (; _First != _Last && *_First == _Zero_wc; ++_First) { // strip leading zeros
+                _Seendigit = true;
+            }
+
+            for (size_t _Idx; _First != _Last && (_Idx = _STD _Find_elem(_Atoms, *_First)) < _Offset_dec_digit_end;
+                _Seendigit = true, (void) ++_First) {
+                if (_Exponent_part < PTRDIFF_MAX / 10
+                    || (_Exponent_part == PTRDIFF_MAX / 10
+                        && static_cast<ptrdiff_t>(_Idx) <= PTRDIFF_MAX % 10)) { // save a significant exponent digit
+                    _Exponent_part = _Exponent_part * 10 + static_cast<ptrdiff_t>(_Idx);
+                } else {
+                    _Exponent_part = PTRDIFF_MAX; // saturated
+                }
+            }
+
+            if (_Exponent_part_negative) {
+                _Exponent_part = -_Exponent_part;
+            }
+        }
+
+        if (!_Seendigit) {
+            return {0, false};
+        }
+
+        constexpr int _Dec_exp_abs_bound = 1100; // slightly greater than 324 + 768
+        constexpr int _Hex_exp_abs_bound = 4200; // slightly greater than 1074 + 768 * 4
+
+        const ptrdiff_t _Exp_abs_bound     = _Parse_hex ? _Hex_exp_abs_bound : _Dec_exp_abs_bound;
+        const ptrdiff_t _Exp_rep_abs_bound = _Parse_hex ? _Hex_exp_abs_bound / 4 : _Dec_exp_abs_bound;
+
+        // basically _Exponent_part = _STD clamp(-_Exp_abs_bound,
+        //     _Exponent_part + _Parse_hex ? _Power_of_rep_base * 4 : _Power_of_rep_base, _Exp_abs_bound)
+        // but need to defend overflowing
+        for (ptrdiff_t _Power_of_rep_adjusted = _Power_of_rep_base;;) {
+            if (_Exponent_part >= 0 && _Power_of_rep_adjusted >= 0
+                && (_Exponent_part >= _Exp_abs_bound || _Power_of_rep_adjusted >= _Exp_rep_abs_bound)) {
+                _Exponent_part = _Exp_abs_bound;
+                break;
+            } else if (_Exponent_part <= 0 && _Power_of_rep_adjusted <= 0
+                       && (_Exponent_part <= -_Exp_abs_bound || _Power_of_rep_adjusted <= -_Exp_rep_abs_bound)) {
+                _Exponent_part = -_Exp_abs_bound;
+                break;
+            } else if (_STD abs(_Exponent_part) <= _Exp_abs_bound
+                       && _STD abs(_Power_of_rep_adjusted) <= _Exp_rep_abs_bound) {
+                // _Exponent_part and _Power_of_rep_base are of different signedness, both of which are small enough
+                _Exponent_part += _Parse_hex ? _Power_of_rep_adjusted * 4 : _Power_of_rep_adjusted;
+                if (_Exponent_part > _Exp_abs_bound) {
+                    _Exponent_part = _Exp_abs_bound;
+                } else if (_Exponent_part < -_Exp_abs_bound) {
+                    _Exponent_part = -_Exp_abs_bound;
+                }
+                break;
+            } else {
+                // only enters once:
+                // _Exponent_part and _Power_of_rep_base are of different signedness, but at least one is large
+                const ptrdiff_t _Exponent_part_preadjustment_round_up =
+                    _Parse_hex ? (_STD abs(_Exponent_part) - 1) / 4 + 1 : _STD abs(_Exponent_part);
+                const ptrdiff_t _Exp_rep_adjustment =
+                    (_STD min) (_Exponent_part_preadjustment_round_up, _STD abs(_Power_of_rep_base));
+
+                if (_Exponent_part >= 0) {
+                    _Exponent_part -= _Parse_hex ? _Exp_rep_adjustment * 4 : _Exp_rep_adjustment;
+                    _Power_of_rep_adjusted += _Exp_rep_adjustment;
+                } else {
+                    _Exponent_part += _Parse_hex ? _Exp_rep_adjustment * 4 : _Exp_rep_adjustment;
+                    _Power_of_rep_adjusted -= _Exp_rep_adjustment;
+                }
+            }
+        }
+
+        if (_Exponent_part != 0) {
+            *_Ptr++ = _Parse_hex ? 'p' : 'e';
+            if (_Exponent_part < 0) {
+                *_Ptr++ = '-';
+            }
+
+            char* const _Rev_begin = _Ptr;
+            for (ptrdiff_t _Exponent_part_abs = _STD abs(_Exponent_part); _Exponent_part_abs != 0;
+                _Exponent_part_abs /= 10) {
+                *_Ptr++ = static_cast<char>('0' + _Exponent_part_abs % 10);
+            }
+            _STD reverse(_Rev_begin, _Ptr);
+        }
+
+        *_Ptr = '\0';
+        return {static_cast<int8_t>(_Parse_hex ? 16 : 10), _Bad_grouping};
+    }
+
+    // TRANSITION, ABI, unused now, tracked by VSO-591516.
+    int __CLRCALL_OR_CDECL _Getifld(
+        char* _Ac, _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield, const locale& _Loc) const {
+        // get integer field from [_First, _Last) into _Ac
+        static constexpr char _Src[] = "0123456789ABCDEFabcdef-+Xx"; // TRANSITION, ABI, was implicitly dllexported
+        const char* volatile _Ptr    = _Src;
+        (void) _Ptr;
+
+        const auto _Parse_result = _Parse_int_with_locale(_Ac, _First, _Last, _Basefield, _Loc);
+        if (_Parse_result._Base < 0 || _Parse_result._Bad_grouping) { // TRANSITION, ABI, old behavior
+            *_Ac = '\0';
+        }
+        return _Parse_result._Base < 0 ? ~_Parse_result._Base : _Parse_result._Base;
+    }
+
+#define _MAX_SIG_DIG_V1 36 // TRANSITION, ABI
+// TRANSITION, ABI: Sentinel value used by num_get::do_get()
+// to enable correct "V2" behavior in _Getffld() and _Getffldx()
+#define _ENABLE_V2_BEHAVIOR 1000000000
+
+    // TRANSITION, ABI, unused now
+    int __CLRCALL_OR_CDECL _Getffld(char* _Ac, _InIt& _First, _InIt& _Last, ios_base& _Iosbase, int* _Phexexp) const {
+        // get floating-point field from [_First, _Last) into _Ac
+        static constexpr char _Src[] = "0123456789-+Ee"; // TRANSITION, ABI, was implicitly dllexported
+        const char* volatile _Ptr    = &_Src[0];
+        (void) _Ptr;
+        const int _Max_sig_dig   = (*_Phexexp == _ENABLE_V2_BEHAVIOR ? _MAX_SIG_DIG_V2 : _MAX_SIG_DIG_V1);
+        const auto _Parse_result = _Parse_fp_with_locale(_Ac, _Max_sig_dig, _First, _Last, _Iosbase.getloc());
+        if (_Parse_result._Base == 0 || _Parse_result._Bad_grouping) { // TRANSITION, ABI, old behavior
+            *_Ac = '\0';
+        }
+
+        if (_Parse_result._Base == 16) {
+            *_Phexexp = 0; // power of 16 multiplier, unnecessary now
+        }
+        return 0; // power of 10 multiplier, unnecessary now
+    }
+
+    // TRANSITION, ABI, unused now
+    int __CLRCALL_OR_CDECL _Getffldx(char* _Ac, _InIt& _First, _InIt& _Last, ios_base& _Iosbase, int* _Phexexp) const {
+        // get floating-point field from [_First, _Last) into _Ac
+        static constexpr char _Src[] = "0123456789ABCDEFabcdef-+XxPp"; // TRANSITION, ABI, was implicitly dllexported
+        const char* volatile _Ptr    = &_Src[0];
+        (void) _Ptr;
+        const int _Max_sig_dig   = (*_Phexexp == _ENABLE_V2_BEHAVIOR ? _MAX_SIG_DIG_V2 : _MAX_SIG_DIG_V1);
+        const auto _Parse_result = _Parse_fp_with_locale(_Ac, _Max_sig_dig, _First, _Last, _Iosbase.getloc());
+        if (_Parse_result._Base == 0 || _Parse_result._Bad_grouping) { // TRANSITION, ABI, old behavior
+            *_Ac = '\0';
+        }
+
+        if (_Parse_result._Base == 16) {
+            *_Phexexp = 0; // power of 16 multiplier, unnecessary now
+        }
+        return 0; // power of 10 multiplier, unnecessary now
+    }
+
+#undef _ENABLE_V2_BEHAVIOR
+#undef _MAX_SIG_DIG_V1
+#undef _MAX_SIG_DIG_V2
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _InIt>
+__PURE_APPDOMAIN_GLOBAL locale::id num_get<_Elem, _InIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+template <class _Ty>
+int _Float_put_desired_precision(const streamsize _Precision, const ios_base::fmtflags _Float_flags) {
+    // return the effective precision determined by N4950 [facet.num.put.virtuals]/2.1 and printf's rules
+    const bool _Is_hex = _Float_flags == (ios_base::fixed | ios_base::scientific);
+    if (_Is_hex) {
+        // return the number of hexits needed (after the radix point) to represent the floating-point value exactly
+        if constexpr (is_same_v<_Ty, double>) {
+            return ((DBL_MANT_DIG - 1) + 3) / 4;
+        } else if constexpr (is_same_v<_Ty, long double>) {
+            return ((LDBL_MANT_DIG - 1) + 3) / 4;
+        } else {
+            static_assert(false, "unexpected type; shouldn't be float");
+        }
+    }
+
+    if (_Precision > 0) {
+        return static_cast<int>(_Precision);
+    } else if (_Precision == 0) {
+        const bool _Is_default_float = _Float_flags == 0;
+        if (_Is_default_float) {
+            return 1;
+        } else {
+            return 0;
+        }
+    } else {
+        constexpr int _Default_precision = 6;
+        return _Default_precision;
+    }
+}
+
+_EXPORT_STD extern "C++" template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+class num_put : public locale::facet { // facet for converting encoded numbers to text
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new num_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_NUMERIC;
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+protected:
+    __CLR_OR_THIS_CALL ~num_put() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo&) {} // initialize from _Locinfo object
+
+public:
+    explicit __CLR_OR_THIS_CALL num_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL num_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    using char_type = _Elem;
+    using iter_type = _OutIt;
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, bool _Val) const { // put formatted bool to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long _Val) const { // put formatted long to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
+        unsigned long _Val) const { // put formatted unsigned long to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long long _Val) const { // put formatted long long to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
+        unsigned long long _Val) const { // put formatted unsigned long long to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, double _Val) const { // put formatted double to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long double _Val) const { // put formatted long double to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const void* _Val) const { // put formatted void pointer to _Dest
+        return do_put(_Dest, _Iosbase, _Fill, _Val);
+    }
+
+protected:
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, bool _Val) const { // put formatted bool to _Dest
+        if (!(_Iosbase.flags() & ios_base::boolalpha)) {
+            return do_put(_Dest, _Iosbase, _Fill, static_cast<long>(_Val));
+        } else { // put "false" or "true"
+            const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());
+            basic_string<_Elem> _Str;
+            if (_Val) {
+                _Str.assign(_Punct_fac.truename());
+            } else {
+                _Str.assign(_Punct_fac.falsename());
+            }
+
+            size_t _Fillcount;
+            if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Str.size()) {
+                _Fillcount = 0;
+            } else {
+                _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Str.size();
+            }
+
+            if ((_Iosbase.flags() & ios_base::adjustfield) != ios_base::left) { // put leading fill
+                _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+                _Fillcount = 0;
+            }
+            _Dest = _Put(_Dest, _Str.c_str(), _Str.size()); // put field
+            _Iosbase.width(0);
+            return _Rep(_Dest, _Fill, _Fillcount); // put trailing fill
+        }
+    }
+
+#pragma warning(push)
+#pragma warning(disable : 4774) // format string expected in argument N is not a string literal (/Wall)
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long _Val) const { // put formatted long to _Dest
+        char _Buf[2 * _Max_int_dig];
+        char _Fmt[6];
+
+        (void) _Ifmt(_Fmt, "ld", _Iosbase.flags());
+
+        const int _Count = _CSTD sprintf_s(_Buf, sizeof(_Buf), _Fmt, _Val);
+
+        if (_Count < 0) { // It should be impossible for sprintf_s() to fail here.
+            _STL_INTERNAL_CHECK(false); // In STL tests, report an error.
+            return _Dest; // In production, return early to avoid static_cast<size_t> of a negative _Count.
+        }
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf, static_cast<size_t>(_Count));
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
+        unsigned long _Val) const { // put formatted unsigned long to _Dest
+        char _Buf[2 * _Max_int_dig];
+        char _Fmt[6];
+
+        (void) _Ifmt(_Fmt, "lu", _Iosbase.flags());
+
+        const int _Count = _CSTD sprintf_s(_Buf, sizeof(_Buf), _Fmt, _Val);
+
+        if (_Count < 0) { // It should be impossible for sprintf_s() to fail here.
+            _STL_INTERNAL_CHECK(false); // In STL tests, report an error.
+            return _Dest; // In production, return early to avoid static_cast<size_t> of a negative _Count.
+        }
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf, static_cast<size_t>(_Count));
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long long _Val) const { // put formatted long long to _Dest
+        char _Buf[2 * _Max_int_dig];
+        char _Fmt[8];
+
+        (void) _Ifmt(_Fmt, "Ld", _Iosbase.flags());
+
+        const int _Count = _CSTD sprintf_s(_Buf, sizeof(_Buf), _Fmt, _Val);
+
+        if (_Count < 0) { // It should be impossible for sprintf_s() to fail here.
+            _STL_INTERNAL_CHECK(false); // In STL tests, report an error.
+            return _Dest; // In production, return early to avoid static_cast<size_t> of a negative _Count.
+        }
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf, static_cast<size_t>(_Count));
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
+        unsigned long long _Val) const { // put formatted unsigned long long to _Dest
+        char _Buf[2 * _Max_int_dig];
+        char _Fmt[8];
+
+        (void) _Ifmt(_Fmt, "Lu", _Iosbase.flags());
+
+        const int _Count = _CSTD sprintf_s(_Buf, sizeof(_Buf), _Fmt, _Val);
+
+        if (_Count < 0) { // It should be impossible for sprintf_s() to fail here.
+            _STL_INTERNAL_CHECK(false); // In STL tests, report an error.
+            return _Dest; // In production, return early to avoid static_cast<size_t> of a negative _Count.
+        }
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf, static_cast<size_t>(_Count));
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, double _Val) const { // put formatted double to _Dest
+        string _Buf;
+        char _Fmt[8];
+        const auto _Float_flags     = _Iosbase.flags() & ios_base::floatfield;
+        const bool _Is_fixed        = _Float_flags == ios_base::fixed;
+        const bool _Is_hex          = _Float_flags == (ios_base::fixed | ios_base::scientific);
+        const streamsize _Precision = _Is_hex ? -1 : _Iosbase.precision(); // precision setting
+        const int _Desired_precision =
+            _Float_put_desired_precision<double>(_Precision, _Float_flags); // desired precision
+        size_t _Bufsize       = static_cast<size_t>(_Desired_precision);
+        const bool _Is_finite = (_STD isfinite) (_Val);
+        if (_Is_fixed && _Is_finite && 1e10 < _CSTD fabs(_Val)) { // f or F format
+            int _Ptwo = 0;
+            (void) _CSTD frexp(_Val, &_Ptwo);
+            _Bufsize += _CSTD abs(_Ptwo) * 30103L / 100000L;
+        }
+
+        _Buf.resize(_Bufsize + 50); // add fudge factor
+        const auto _Adjusted_flags = // TRANSITION, DevCom-10519861
+            _Is_finite ? _Iosbase.flags() : _Iosbase.flags() & ~ios_base::showpoint;
+
+        (void) _Ffmt(_Fmt, 0, _Adjusted_flags);
+
+        const int _Count = _CSTD sprintf_s(&_Buf[0], _Buf.size(), _Fmt, static_cast<int>(_Precision), _Val);
+
+        if (_Count < 0) { // It should be impossible for sprintf_s() to fail here.
+            _STL_INTERNAL_CHECK(false); // In STL tests, report an error.
+            return _Dest; // In production, return early to avoid static_cast<size_t> of a negative _Count.
+        }
+
+        return _Fput_v3(_Dest, _Iosbase, _Fill, _Buf.c_str(), static_cast<size_t>(_Count), _Is_finite);
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long double _Val) const { // put formatted long double to _Dest
+        string _Buf;
+        char _Fmt[8];
+        const auto _Float_flags     = _Iosbase.flags() & ios_base::floatfield;
+        const bool _Is_fixed        = _Float_flags == ios_base::fixed;
+        const bool _Is_hex          = _Float_flags == (ios_base::fixed | ios_base::scientific);
+        const streamsize _Precision = _Is_hex ? -1 : _Iosbase.precision(); // precision setting
+        const int _Desired_precision =
+            _Float_put_desired_precision<long double>(_Precision, _Float_flags); // desired precision
+        size_t _Bufsize       = static_cast<size_t>(_Desired_precision);
+        const bool _Is_finite = (_STD isfinite) (_Val);
+        if (_Is_fixed && _Is_finite && 1e10 < _CSTD fabsl(_Val)) { // f or F format
+            int _Ptwo = 0;
+            (void) _CSTD frexpl(_Val, &_Ptwo);
+            _Bufsize += _CSTD abs(_Ptwo) * 30103L / 100000L;
+        }
+
+        _Buf.resize(_Bufsize + 50); // add fudge factor
+        const auto _Adjusted_flags = // TRANSITION, DevCom-10519861
+            _Is_finite ? _Iosbase.flags() : _Iosbase.flags() & ~ios_base::showpoint;
+
+        (void) _Ffmt(_Fmt, 'L', _Adjusted_flags);
+
+        const int _Count = _CSTD sprintf_s(&_Buf[0], _Buf.size(), _Fmt, static_cast<int>(_Precision), _Val);
+
+        if (_Count < 0) { // It should be impossible for sprintf_s() to fail here.
+            _STL_INTERNAL_CHECK(false); // In STL tests, report an error.
+            return _Dest; // In production, return early to avoid static_cast<size_t> of a negative _Count.
+        }
+
+        return _Fput_v3(_Dest, _Iosbase, _Fill, _Buf.c_str(), static_cast<size_t>(_Count), _Is_finite);
+    }
+#pragma warning(pop)
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(
+        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const void* _Val) const { // put formatted void pointer to _Dest
+        char _Buf[2 * _Max_int_dig];
+
+        const int _Count = _CSTD sprintf_s(_Buf, sizeof(_Buf), "%p", _Val);
+
+        if (_Count < 0) { // It should be impossible for sprintf_s() to fail here.
+            _STL_INTERNAL_CHECK(false); // In STL tests, report an error.
+            return _Dest; // In production, return early to avoid static_cast<size_t> of a negative _Count.
+        }
+
+        return _Iput(_Dest, _Iosbase, _Fill, _Buf, static_cast<size_t>(_Count));
+    }
+
+private:
+    // TRANSITION, ABI: This always returns _Fmt, which is now ignored.
+    char* __CLRCALL_OR_CDECL _Ffmt(char* _Fmt, char _Spec, ios_base::fmtflags _Flags) const {
+        // generate sprintf format for floating-point
+        char* _Ptr = _Fmt;
+        *_Ptr++    = '%';
+
+        if (_Flags & ios_base::showpos) {
+            *_Ptr++ = '+';
+        }
+
+        if (_Flags & ios_base::showpoint) {
+            *_Ptr++ = '#';
+        }
+
+        *_Ptr++ = '.';
+        *_Ptr++ = '*'; // for precision argument
+        if (_Spec != '\0') {
+            *_Ptr++ = _Spec; // 'L' qualifier for long double only
+        }
+
+        char _Ch; // specifier
+        ios_base::fmtflags _Ffl = _Flags & ios_base::floatfield;
+        if (_Flags & ios_base::uppercase) {
+            if (_Ffl == ios_base::fixed) {
+                _Ch = 'F';
+            } else if (_Ffl == (ios_base::scientific | ios_base::fixed)) {
+                _Ch = 'A';
+            } else if (_Ffl == ios_base::scientific) {
+                _Ch = 'E';
+            } else {
+                _Ch = 'G';
+            }
+        } else {
+            if (_Ffl == ios_base::fixed) {
+                _Ch = 'f';
+            } else if (_Ffl == (ios_base::scientific | ios_base::fixed)) {
+                _Ch = 'a';
+            } else if (_Ffl == ios_base::scientific) {
+                _Ch = 'e';
+            } else {
+                _Ch = 'g';
+            }
+        }
+        *_Ptr++ = _Ch;
+
+        *_Ptr = '\0';
+        return _Fmt;
+    }
+
+    _OutIt __CLRCALL_OR_CDECL _Fput(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const char* _Buf,
+        size_t _Count) const { // TRANSITION, ABI: preserved for binary compatibility
+        return _Fput_v3(_Dest, _Iosbase, _Fill, _Buf, _Count, true);
+    }
+
+    template <int = 0> // TRANSITION, ABI
+    _OutIt _Fput_v3(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const char* _Buf, size_t _Count,
+        bool _Is_finite_val) const { // put formatted floating-point to _Dest
+        auto _Prefix = static_cast<size_t>(0 < _Count && (*_Buf == '+' || *_Buf == '-'));
+        const char* _Exps;
+        if ((_Iosbase.flags() & ios_base::floatfield) != (ios_base::scientific | ios_base::fixed)) {
+            _Exps = "eE";
+        } else { // correct for hexadecimal floating-point
+            _Exps = "pP";
+            if (_Prefix + 2 <= _Count && _Buf[_Prefix] == '0'
+                && (_Buf[_Prefix + 1] == 'x' || _Buf[_Prefix + 1] == 'X')) {
+                _Prefix += 2;
+            }
+        }
+        const size_t _Eoff = _CSTD strcspn(&_Buf[0], _Exps); // find exponent
+        char _Dp[2]        = {"."};
+        _Dp[0]             = (_CSTD localeconv())->decimal_point[0];
+        const size_t _Poff = _CSTD strcspn(&_Buf[0], &_Dp[0]); // find decimal point
+
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        basic_string<_Elem> _Groupstring(_Count, _Elem(0)); // reserve space
+        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Groupstring[0]);
+
+        const auto& _Punct_fac  = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());
+        const string _Grouping  = _Punct_fac.grouping();
+        const _Elem _Kseparator = _Punct_fac.thousands_sep();
+
+        if (_Poff != _Count) {
+            _Groupstring[_Poff] = _Punct_fac.decimal_point();
+        }
+
+        if (_Is_finite_val) {
+            size_t _Off     = _Poff == _Count ? _Eoff : _Poff;
+            const char* _Pg = &_Grouping[0];
+            while (*_Pg != CHAR_MAX && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Off - _Prefix) {
+                // add thousands separator
+                _Groupstring.insert(_Off -= *_Pg, 1, _Kseparator);
+                if ('\0' < _Pg[1]) {
+                    ++_Pg; // not last group, advance
+                }
+            }
+        }
+
+        _Count = _Groupstring.size();
+
+        size_t _Fillcount;
+        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Count) {
+            _Fillcount = 0;
+        } else {
+            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Count;
+        }
+
+        ios_base::fmtflags _Adjustfield = _Iosbase.flags() & ios_base::adjustfield;
+        if (_Adjustfield != ios_base::left && _Adjustfield != ios_base::internal) { // put leading fill
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
+        } else if (_Adjustfield == ios_base::internal) { // put internal fill
+            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+        } else {
+            _Dest = _Put(_Dest, &_Groupstring[0], _Prefix);
+        }
+
+        _Dest = _Put(_Dest, &_Groupstring[_Prefix], _Count - _Prefix);
+        _Iosbase.width(0);
+        return _Rep(_Dest, _Fill, _Fillcount); // put trailing fill
+    }
+
+    // TRANSITION, ABI: This always returns _Fmt, which is now ignored.
+    char* __CLRCALL_OR_CDECL _Ifmt(char* _Fmt, const char* _Spec, ios_base::fmtflags _Flags) const {
+        // generate sprintf format for integer
+        char* _Ptr = _Fmt;
+        *_Ptr++    = '%';
+
+        if (_Flags & ios_base::showpos) {
+            *_Ptr++ = '+';
+        }
+
+        if (_Flags & ios_base::showbase) {
+            *_Ptr++ = '#';
+        }
+
+        if (_Spec[0] != 'L') {
+            *_Ptr++ = _Spec[0]; // qualifier
+        } else { // change L to I64
+            *_Ptr++ = 'I';
+            *_Ptr++ = '6';
+            *_Ptr++ = '4';
+        }
+
+        ios_base::fmtflags _Basefield = _Flags & ios_base::basefield;
+        *_Ptr++                       = _Basefield == ios_base::oct  ? 'o'
+                                      : _Basefield != ios_base::hex  ? _Spec[1] // 'd' or 'u'
+                                      : _Flags & ios_base::uppercase ? 'X'
+                                                                     : 'x';
+        *_Ptr                         = '\0';
+        return _Fmt;
+    }
+
+    _OutIt __CLRCALL_OR_CDECL _Iput(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, char* _Buf,
+        size_t _Count) const { // put formatted integer to _Dest
+        auto _Prefix = static_cast<size_t>(0 < _Count && (*_Buf == '+' || *_Buf == '-'));
+        if ((_Iosbase.flags() & ios_base::basefield) == ios_base::hex && _Prefix + 2 <= _Count && _Buf[_Prefix] == '0'
+            && (_Buf[_Prefix + 1] == 'x' || _Buf[_Prefix + 1] == 'X')) {
+            _Prefix += 2;
+        }
+
+        const ctype<_Elem>& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Iosbase.getloc());
+        basic_string<_Elem> _Groupstring(_Count, _Elem(0)); // reserve space
+        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Groupstring[0]);
+
+        const auto& _Punct_fac = _STD use_facet<numpunct<_Elem>>(_Iosbase.getloc());
+        const string _Grouping = _Punct_fac.grouping();
+        const char* _Pg        = &_Grouping[0];
+        if (*_Pg != CHAR_MAX && '\0' < *_Pg) { // grouping specified, add thousands separators
+            const _Elem _Kseparator = _Punct_fac.thousands_sep();
+            while (*_Pg != CHAR_MAX && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Count - _Prefix) {
+                // insert thousands separator
+                _Count -= *_Pg;
+                _Groupstring.insert(_Count, 1, _Kseparator);
+                if ('\0' < _Pg[1]) {
+                    ++_Pg; // not last group, advance
+                }
+            }
+        }
+
+        _Count = _Groupstring.size();
+
+        size_t _Fillcount;
+        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Count) {
+            _Fillcount = 0;
+        } else {
+            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Count;
+        }
+
+        ios_base::fmtflags _Adjustfield = _Iosbase.flags() & ios_base::adjustfield;
+        if (_Adjustfield != ios_base::left && _Adjustfield != ios_base::internal) { // put leading fill
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
+        } else if (_Adjustfield == ios_base::internal) { // put internal fill
+            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
+            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
+            _Fillcount = 0;
+        } else {
+            _Dest = _Put(_Dest, &_Groupstring[0], _Prefix);
+        }
+
+        _Dest = _Put(_Dest, &_Groupstring[_Prefix], _Count - _Prefix);
+        _Iosbase.width(0);
+        return _Rep(_Dest, _Fill, _Fillcount); // put trailing fill
+    }
+
+    _OutIt __CLRCALL_OR_CDECL _Put(
+        _OutIt _Dest, const _Elem* _Ptr, size_t _Count) const { // put [_Ptr, _Ptr + _Count) to _Dest
+        for (; 0 < _Count; --_Count, (void) ++_Dest, ++_Ptr) {
+            *_Dest = *_Ptr;
+        }
+
+        return _Dest;
+    }
+
+    _OutIt __CLRCALL_OR_CDECL _Rep(_OutIt _Dest, _Elem _Ch, size_t _Count) const { // put _Count * _Ch to _Dest
+        for (; 0 < _Count; --_Count, (void) ++_Dest) {
+            *_Dest = _Ch;
+        }
+
+        return _Dest;
+    }
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id num_put<_Elem, _OutIt>::id;
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<char>::id;
+template class _CRTIMP2_PURE_IMPORT num_get<char, istreambuf_iterator<char, char_traits<char>>>;
+template class _CRTIMP2_PURE_IMPORT num_put<char, ostreambuf_iterator<char, char_traits<char>>>;
+
+template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<wchar_t>::id;
+template class _CRTIMP2_PURE_IMPORT num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
+template class _CRTIMP2_PURE_IMPORT num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template __PURE_APPDOMAIN_GLOBAL locale::id numpunct<unsigned short>::id;
+template class _CRTIMP2_PURE_IMPORT
+    num_get<unsigned short, istreambuf_iterator<unsigned short, char_traits<unsigned short>>>;
+template class _CRTIMP2_PURE_IMPORT
+    num_put<unsigned short, ostreambuf_iterator<unsigned short, char_traits<unsigned short>>>;
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCNUM_
diff --git a/msvc-stl/stl/inc/xloctime b/msvc-stl/stl/inc/xloctime
new file mode 100644
index 0000000..f86e4aa
--- /dev/null
+++ b/msvc-stl/stl/inc/xloctime
@@ -0,0 +1,1279 @@
+// xloctime internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XLOCTIME_
+#define _XLOCTIME_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <ctime>
+#include <iterator>
+#include <xlocnum>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _InIt, class _Elem>
+ios_base::iostate _Getint_v2(_InIt& _First, _InIt& _Last, int _Lo, int _Hi, int& _Val, int& _Digits_read,
+    const ctype<_Elem>& _Ctype_fac) { // get integer in range [_Lo, _Hi] from [_First, _Last)
+    _STL_INTERNAL_CHECK(0 <= _Hi && _Hi <= 9999);
+    const int _Hi_digits = (_Hi <= 9 ? 1 : _Hi <= 99 ? 2 : _Hi <= 999 ? 3 : 4);
+    char _Ac[_Max_int_dig];
+    char* _Ep;
+    char* _Ptr = _Ac;
+    char _Ch;
+
+    _Digits_read = 0;
+
+    while (_First != _Last && _Digits_read < _Hi_digits && _Ctype_fac.is(ctype_base::space, *_First)) {
+        ++_First;
+        ++_Digits_read;
+    }
+
+    if (_First != _Last && _Digits_read < _Hi_digits) {
+        if ((_Ch = _Ctype_fac.narrow(*_First)) == '+') { // copy plus sign
+            *_Ptr++ = '+';
+            ++_First;
+        } else if (_Ch == '-') { // copy minus sign
+            *_Ptr++ = '-';
+            ++_First;
+        }
+    }
+
+    for (; _First != _Last && _Digits_read < _Hi_digits && _Ctype_fac.narrow(*_First) == '0'; ++_First) {
+        ++_Digits_read; // strip leading zeros
+    }
+
+    if (_Digits_read > 0) {
+        *_Ptr++ = '0'; // replace one or more with single zero
+    }
+
+    for (char* const _Pe = &_Ac[_Max_int_dig - 1];
+        _First != _Last && '0' <= (_Ch = _Ctype_fac.narrow(*_First)) && _Ch <= '9' && _Digits_read < _Hi_digits;
+        ++_Digits_read, (void) ++_First) { // copy digits
+        if (_Ptr < _Pe) { // preserve room for the null terminator written below
+            *_Ptr = _Ch;
+            ++_Ptr; // drop trailing digits if already too large
+        }
+    }
+
+    if (_Digits_read == 0) {
+        _Ptr = _Ac;
+    }
+
+    *_Ptr                    = '\0';
+    int _Errno               = 0;
+    const long _Ans          = _CSTD _Stolx(_Ac, &_Ep, 10, &_Errno);
+    ios_base::iostate _State = ios_base::goodbit;
+
+    if (_First == _Last) {
+        _State |= ios_base::eofbit;
+    }
+
+    if (_Ep == _Ac || _Errno != 0 || _Ans < _Lo || _Hi < _Ans) {
+        _State |= ios_base::failbit; // bad conversion
+    } else {
+        _Val = _Ans; // store valid result
+    }
+
+    return _State;
+}
+
+_EXPORT_STD extern "C++" struct _CRTIMP2_PURE_IMPORT time_base // base class for time_get
+    : locale::facet // TRANSITION, ABI, shouldn't be derived from locale::facet
+{
+    enum dateorder { // constants for different orders of date components
+        no_order,
+        dmy,
+        mdy,
+        ymd,
+        ydm
+    };
+
+    __CLR_OR_THIS_CALL time_base(size_t _Refs = 0) noexcept // strengthened
+        : locale::facet(_Refs) {}
+
+    __CLR_OR_THIS_CALL ~time_base() noexcept override {}
+};
+
+_EXPORT_STD extern "C++" template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+class time_get : public time_base { // facet for converting text to encoded times
+private:
+    friend _Tidy_guard<time_get>;
+
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type = _Elem;
+    using iter_type = _InIt;
+    using _Ctype    = ctype<_Elem>;
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    dateorder __CLR_OR_THIS_CALL date_order() const {
+        return do_date_order();
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_time(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get time of day from [_First, _Last) into _Pt
+        return do_get_time(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_date(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get date from [_First, _Last) into _Pt
+        return do_get_date(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_weekday(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get weekday from [_First, _Last) into _Pt
+        return do_get_weekday(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_monthname(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get month from [_First, _Last) into _Pt
+        return do_get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get_year(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt) const { // get year from [_First, _Last) into _Pt
+        return do_get_year(_First, _Last, _Iosbase, _State, _Pt);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
+        char _Specifier, char _Modifier = '\0') const { // get formatted time for _Specifier/_Modifier
+        return do_get(_First, _Last, _Iosbase, _State, _Pt, _Specifier, _Modifier);
+    }
+
+    _InIt __CLR_OR_THIS_CALL get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
+        const _Elem* _Fmtfirst, const _Elem* _Fmtlast) const { // get formatted time for format string
+        _Adl_verify_range(_Fmtfirst, _Fmtlast);
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        _State = ios_base::goodbit;
+
+        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
+            if (_State != ios_base::goodbit) {
+                // N4950 [locale.time.get.members]/8.2
+                // _State is fail, eof, or bad. Do not proceed to the next fields. Return with current _State.
+                break;
+            } else if (_First == _Last) {
+                // N4950 [locale.time.get.members]/8.3
+                _State = ios_base::eofbit | ios_base::failbit;
+                break;
+            } else if (_Ctype_fac.narrow(*_Fmtfirst) != '%') { // match literal element
+                if (_Ctype_fac.is(_Ctype::space, *_Fmtfirst)) {
+                    while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+                        ++_First;
+                    }
+                } else if (_Ctype_fac.tolower(*_First) != _Ctype_fac.tolower(*_Fmtfirst)) { // bad literal match
+                    _State |= ios_base::failbit;
+                    break;
+                } else {
+                    ++_First;
+                }
+            } else if (++_Fmtfirst == _Fmtlast) {
+                // N4950 [locale.time.get.members]/8.4: "If the number of elements in the range [fmt, fmtend) is not
+                // sufficient to unambiguously determine whether the conversion specification is complete and valid,
+                // the function evaluates err = ios_base::failbit."
+                _State = ios_base::failbit;
+                break;
+            } else { // get specifier after %
+                char _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                char _Modifier  = '\0';
+
+                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
+                    if (++_Fmtfirst == _Fmtlast) { // no specifier
+                        _State = ios_base::failbit;
+                        break;
+                    } else { // save both qualifier and specifier
+                        _Modifier  = _Specifier;
+                        _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                    }
+                }
+
+                _First = do_get(_First, _Last, _Iosbase, _State, _Pt, _Specifier, _Modifier); // convert a single field
+            }
+        }
+
+        return _First;
+    }
+
+    explicit __CLR_OR_THIS_CALL time_get(size_t _Refs = 0) : time_base(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL time_get(const _Locinfo& _Lobj, size_t _Refs = 0) : time_base(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new time_get<_Elem, _InIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_TIME;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~time_get() noexcept override {
+        _Tidy();
+    }
+
+    __CLR_OR_THIS_CALL time_get(const char* _Locname, size_t _Refs = 0) : time_base(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    template <class _Elem2>
+    void __CLR_OR_THIS_CALL _Getvals(_Elem2, const _Locinfo& _Lobj) { // get values
+        _Cvt = _Lobj._Getcvt();
+
+        if constexpr (is_same_v<_Elem2, wchar_t>) {
+            _Days = reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getdays())));
+            _Months =
+                reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getmonths())));
+            _Ampm = reinterpret_cast<const _Elem*>(_Maklocwcs(L":AM:am:PM:pm"));
+        } else {
+            _Days   = _Maklocstr<_Elem>(_Lobj._Getdays(), _Cvt);
+            _Months = _Maklocstr<_Elem>(_Lobj._Getmonths(), _Cvt);
+            _Ampm   = _Maklocstr<_Elem>(":AM:am:PM:pm", _Cvt);
+        }
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Days   = nullptr;
+        _Months = nullptr;
+        _Ampm   = nullptr;
+
+        _Tidy_guard<time_get> _Guard{this};
+        _Getvals(_Elem{}, _Lobj);
+        _Dateorder     = static_cast<dateorder>(_Lobj._Getdateorder());
+        _Guard._Target = nullptr;
+    }
+
+    virtual dateorder __CLR_OR_THIS_CALL do_date_order() const {
+        return _Dateorder;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_time(_InIt _First, _InIt _Last, ios_base& _Iosbase,
+        ios_base::iostate& _State, tm* _Pt) const { // get time of day from [_First, _Last) into _Pt
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        _State |= _Getint(_First, _Last, 0, 23, _Pt->tm_hour, _Ctype_fac);
+
+        if (_State != ios_base::goodbit || _Ctype_fac.narrow(*_First) != ':') {
+            _State |= ios_base::failbit; // hour field is bad
+        } else {
+            _State |= _Getint(++_First, _Last, 0, 59, _Pt->tm_min, _Ctype_fac);
+        }
+
+        if (_State != ios_base::goodbit || _Ctype_fac.narrow(*_First) != ':') {
+            _State |= ios_base::failbit; // min field is bad
+        } else {
+            _State |= _Getint(++_First, _Last, 0, 60, _Pt->tm_sec, _Ctype_fac);
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_date(_InIt _First, _InIt _Last, ios_base& _Iosbase,
+        ios_base::iostate& _State, tm* _Pt) const { // get date from [_First, _Last) into _Pt
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        dateorder _Dorder = date_order();
+        if (_Dorder == no_order) {
+            _Dorder = mdy;
+        }
+
+        if (_First != _Last) {
+            if (!_Ctype_fac.is(_Ctype::digit, *_First)) { // begins with month name, assume mdy
+                _First  = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+                _Dorder = mdy;
+            } else if (_Dorder == mdy) { // get month number
+                _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
+                --_Pt->tm_mon;
+            } else if (_Dorder == dmy) {
+                _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
+            } else { // ymd or ydm
+                _First = get_year(_First, _Last, _Iosbase, _State, _Pt);
+            }
+        }
+
+        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+            ++_First; // skip spaces
+        }
+
+        if (_First != _Last) { // skip [:,/]
+            char _Ch = _Ctype_fac.narrow(*_First);
+            if (_Ch == ':' || _Ch == ',' || _Ch == '/') {
+                ++_First;
+            }
+        }
+
+        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+            ++_First; // skip spaces
+        }
+
+        if (_First != _Last) {
+            if (!_Ctype_fac.is(_Ctype::digit, *_First)) {
+                if (_Dorder == mdy) {
+                    _State |= ios_base::failbit; // error, month already seen
+                } else { // month name is second, like it or not
+                    _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+                    if (_Dorder == ydm) {
+                        _Dorder = ymd;
+                    }
+                }
+            } else if (_Dorder == dmy || _Dorder == ymd) { // get month number
+                _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
+                --_Pt->tm_mon;
+            } else {
+                _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
+            }
+        }
+
+        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+            ++_First; // skip spaces
+        }
+
+        if (_First != _Last) { // skip [:,/]
+            char _Ch = _Ctype_fac.narrow(*_First);
+            if (_Ch == ':' || _Ch == ',' || _Ch == '/') {
+                ++_First;
+            }
+        }
+
+        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+            ++_First; // skip spaces
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::failbit; // error, missing component(s)
+        } else if (!_Ctype_fac.is(_Ctype::digit, *_First)) {
+            if (_Dorder != ydm) {
+                _State |= ios_base::failbit; // error, month out of place
+            } else {
+                _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+            }
+        } else if (_Dorder == ydm) { // get month number
+            _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
+            --_Pt->tm_mon;
+        } else if (_Dorder == ymd) {
+            _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
+        } else { // mdy or dmy
+            _First = get_year(_First, _Last, _Iosbase, _State, _Pt);
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_weekday(_InIt _First, _InIt _Last, ios_base&, ios_base::iostate& _State,
+        tm* _Pt) const { // get weekday from [_First, _Last) into _Pt
+        int _Num = _Getloctxt(_First, _Last, 0, _Days, _Case_sensitive::_Nope);
+        if (_Num < 0) {
+            _State |= ios_base::failbit;
+        } else {
+            _Pt->tm_wday = _Num >> 1; // set wday
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_monthname(_InIt _First, _InIt _Last, ios_base&, ios_base::iostate& _State,
+        tm* _Pt) const { // get month from [_First, _Last) into _Pt
+        int _Num = _Getloctxt(_First, _Last, 0, _Months, _Case_sensitive::_Nope);
+
+        if (_Num < 0) {
+            _State |= ios_base::failbit;
+        } else {
+            _Pt->tm_mon = _Num >> 1; // set mon
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get_year(_InIt _First, _InIt _Last, ios_base& _Iosbase,
+        ios_base::iostate& _State, tm* _Pt) const { // get year from [_First, _Last) into _Pt
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        int _Ans = 0;
+        int _Digits_read;
+        ios_base::iostate _Res = _Getint_v2(_First, _Last, 0, 9999, _Ans, _Digits_read, _Ctype_fac);
+
+        _State |= _Res; // pass on eofbit and failbit
+        if (!(_Res & ios_base::failbit)) {
+            if (_Digits_read <= 2) {
+                if (_Ans < 69) {
+                    // CodeQL [SM03231] This is parsing tm_year (years since 1900); leap years are irrelevant.
+                    _Pt->tm_year = _Ans + 100; // [00, 68] parsed as [2000, 2068]
+                } else if (_Ans < 100) {
+                    // CodeQL [SM03231] This is parsing tm_year (years since 1900); leap years are irrelevant.
+                    _Pt->tm_year = _Ans; // [69, 99] parsed as [1969, 1999]
+                }
+            } else {
+                // CodeQL [SM03231] This is parsing tm_year (years since 1900); leap years are irrelevant.
+                _Pt->tm_year = _Ans - 1900; // parsed literally
+            }
+        }
+
+        return _First;
+    }
+
+    virtual _InIt __CLR_OR_THIS_CALL do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
+        tm* _Pt, char _Specifier, char = 0) const { // get formatted time for _Specifier (_Modifier ignored)
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+        int _Ans                 = 0;
+
+        _State = ios_base::goodbit;
+
+        switch (_Specifier) { // process format specifier
+        case 'a':
+        case 'A':
+            _First = get_weekday(_First, _Last, _Iosbase, _State, _Pt);
+            break;
+
+        case 'b':
+        case 'B':
+        case 'h':
+            _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
+            break;
+
+        case 'c':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%a %b %e %T %Y");
+            break;
+
+        case 'C':
+            _State |= _Getint(_First, _Last, 0, 99, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                // CodeQL [SM03231] This is parsing tm_year (years since 1900); leap years are irrelevant.
+                _Pt->tm_year = _Ans * 100 - 1900; // convert to century
+            }
+
+            break;
+
+        case 'd':
+        case 'e':
+            _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
+            break;
+
+        case 'D':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%m / %d / %y");
+            break;
+
+        case 'H':
+            _State |= _Getint(_First, _Last, 0, 23, _Pt->tm_hour, _Ctype_fac);
+            break;
+
+        case 'I':
+            _State |= _Getint(_First, _Last, 1, 12, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                _Pt->tm_hour = _Ans == 12 ? 0 : _Ans;
+            }
+
+            break;
+
+        case 'j':
+            _State |= _Getint(_First, _Last, 1, 366, _Pt->tm_yday, _Ctype_fac);
+            break;
+
+        case 'm':
+            _State |= _Getint(_First, _Last, 1, 12, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                _Pt->tm_mon = _Ans - 1;
+            }
+
+            break;
+
+        case 'M':
+            _State |= _Getint(_First, _Last, 0, 59, _Pt->tm_min, _Ctype_fac);
+            break;
+
+        case 'n':
+        case 't':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, " ");
+            break;
+
+        case 'p':
+            _Ans = _Getloctxt(_First, _Last, 0, ":AM:am:PM:pm", _Case_sensitive::_Nope);
+            if (_Ans < 0) {
+                _State |= ios_base::failbit;
+            } else if (1 < _Ans) {
+                _Pt->tm_hour += 12;
+            }
+
+            break;
+
+        case 'r':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%I : %M : %S %p");
+            break;
+
+        case 'R':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%H : %M");
+            break;
+
+        case 'S':
+            _State |= _Getint(_First, _Last, 0, 60, _Pt->tm_sec, _Ctype_fac);
+            break;
+
+        case 'T':
+        case 'X':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%H : %M : %S");
+            break;
+
+        case 'U':
+            _State |= _Getint(_First, _Last, 0, 53, _Pt->tm_yday, _Ctype_fac);
+            break;
+
+        case 'w':
+            _State |= _Getint(_First, _Last, 0, 6, _Pt->tm_wday, _Ctype_fac);
+            break;
+
+        case 'W':
+            _State |= _Getint(_First, _Last, 0, 53, _Pt->tm_yday, _Ctype_fac);
+            break;
+
+        case 'x':
+            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%m / %d / %y");
+            break;
+
+        case 'y':
+            _State |= _Getint(_First, _Last, 0, 99, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                if (_Ans < 69) {
+                    // CodeQL [SM03231] This is parsing tm_year (years since 1900); leap years are irrelevant.
+                    _Pt->tm_year = _Ans + 100; // [00, 68] parsed as [2000, 2068]
+                } else {
+                    // CodeQL [SM03231] This is parsing tm_year (years since 1900); leap years are irrelevant.
+                    _Pt->tm_year = _Ans; // [69, 99] parsed as [1969, 1999]
+                }
+            }
+
+            break;
+
+        case 'Y':
+            _State |= _Getint(_First, _Last, 0, 9999, _Ans, _Ctype_fac);
+            if (!(_State & ios_base::failbit)) {
+                // CodeQL [SM03231] This is parsing tm_year (years since 1900); leap years are irrelevant.
+                _Pt->tm_year = _Ans - 1900; // parsed literally
+            }
+            break;
+
+        case '%':
+            if (_First == _Last || _Ctype_fac.narrow(*_First) != '%') {
+                _State |= ios_base::failbit;
+            } else {
+                ++_First;
+            }
+            break;
+
+        default:
+            _State |= ios_base::failbit; // unknown specifier
+            break;
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+    _InIt __CLR_OR_THIS_CALL _Getfmt(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
+        const char* _Fmtfirst) const { // get formatted time for format NTBS
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        for (; *_Fmtfirst != '\0'; ++_Fmtfirst) {
+            if (_First == _Last) {
+                _State |= ios_base::failbit;
+                break;
+            } else if (*_Fmtfirst == '%') {
+                _First = do_get(_First, _Last, _Iosbase, _State, _Pt,
+                    *++_Fmtfirst); // convert a single field
+            } else if (*_Fmtfirst == ' ') {
+                while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
+                    ++_First;
+                }
+            } else if (_Ctype_fac.narrow(*_First) != *_Fmtfirst) { // bad literal match
+                _State |= ios_base::failbit;
+                break;
+            } else {
+                ++_First;
+            }
+        }
+
+        if (_First == _Last) {
+            _State |= ios_base::eofbit;
+        }
+
+        return _First;
+    }
+
+private:
+    ios_base::iostate __CLRCALL_OR_CDECL _Getint(_InIt& _First, _InIt& _Last, int _Lo, int _Hi, int& _Val,
+        const _Ctype& _Ctype_fac) const { // get integer in range [_Lo, _Hi] from [_First, _Last)
+        // TRANSITION, ABI
+        int _Digits_read;
+        return _Getint_v2(_First, _Last, _Lo, _Hi, _Val, _Digits_read, _Ctype_fac);
+    }
+
+    void __CLR_OR_THIS_CALL _Tidy() noexcept { // free all storage
+        _CSTD free(const_cast<_Elem*>(_Days));
+        _CSTD free(const_cast<_Elem*>(_Months));
+        _CSTD free(const_cast<_Elem*>(_Ampm));
+    }
+
+    const _Elem* _Days; // ":Sun:Sunday:Mon:Monday..." for example
+    const _Elem* _Months; // "Jan:January:Feb:February..." for example
+    const _Elem* _Ampm; // ":AM:am:PM:pm"
+    dateorder _Dateorder;
+    _Locinfo::_Cvtvec _Cvt; // conversion information
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _InIt>
+__PURE_APPDOMAIN_GLOBAL locale::id time_get<_Elem, _InIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+_EXPORT_STD template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
+class time_get_byname : public time_get<_Elem, _InIt> { // time_get for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit time_get_byname(const char* _Locname, size_t _Refs = 0)
+        : time_get<_Elem, _InIt>(_Locname, _Refs) {} // construct for named locale
+
+    explicit time_get_byname(const string& _Str, size_t _Refs = 0)
+        : time_get<_Elem, _InIt>(_Locinfo(_Str.c_str()), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~time_get_byname() noexcept override {}
+};
+
+// C23 7.29.3.5 "The strftime function"/3
+_INLINE_VAR constexpr char _Valid_strftime_specifiers[] = {'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'F', 'g', 'G',
+    'h', 'H', 'I', 'j', 'm', 'M', 'n', 'p', 'r', 'R', 'S', 't', 'T', 'u', 'U', 'V', 'w', 'W', 'x', 'X', 'y', 'Y', 'z',
+    'Z'};
+
+_NODISCARD constexpr bool _Is_valid_strftime_specifier(const char _Specifier) {
+    for (const auto& _Valid_specifier : _Valid_strftime_specifiers) {
+        if (_Specifier == _Valid_specifier) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_sec(const tm* const _Pt) noexcept {
+    // seconds after the minute - [0, 60] including leap second
+    return _Pt->tm_sec >= 0 && _Pt->tm_sec <= 60;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_min(const tm* const _Pt) noexcept {
+    // minutes after the hour - [0, 59]
+    return _Pt->tm_min >= 0 && _Pt->tm_min <= 59;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_hour(const tm* const _Pt) noexcept {
+    // hours since midnight - [0, 23]
+    return _Pt->tm_hour >= 0 && _Pt->tm_hour <= 23;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_mday(const tm* const _Pt) noexcept {
+    // day of the month - [1, 31]
+    return _Pt->tm_mday >= 1 && _Pt->tm_mday <= 31;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_mon(const tm* const _Pt) noexcept {
+    // months since January - [0, 11]
+    return _Pt->tm_mon >= 0 && _Pt->tm_mon <= 11;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_year(const tm* const _Pt) noexcept {
+    // years since 1900 - UCRT max range is up until 8099
+    return _Pt->tm_year >= -1900 && _Pt->tm_year <= 8099;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_wday(const tm* const _Pt) noexcept {
+    // days since Sunday - [0, 6]
+    return _Pt->tm_wday >= 0 && _Pt->tm_wday <= 6;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_yday(const tm* const _Pt) noexcept {
+    // days since January 1 - [0, 365]
+    return _Pt->tm_yday >= 0 && _Pt->tm_yday <= 365;
+}
+
+_NODISCARD constexpr bool _Is_valid_strftime_tm_data(const char _Specifier, const tm* const _Pt) noexcept {
+    if (!_Pt) {
+        return false;
+    }
+
+    switch (_Specifier) {
+    case 'S':
+        return _Is_valid_strftime_tm_sec(_Pt);
+    case 'M':
+        return _Is_valid_strftime_tm_min(_Pt);
+    case 'H':
+    case 'I':
+    case 'p':
+        return _Is_valid_strftime_tm_hour(_Pt);
+    case 'd':
+    case 'e':
+        return _Is_valid_strftime_tm_mday(_Pt);
+    case 'b':
+    case 'B':
+    case 'm':
+    case 'h':
+        return _Is_valid_strftime_tm_mon(_Pt);
+    case 'C':
+    case 'y':
+    case 'Y':
+        return _Is_valid_strftime_tm_year(_Pt);
+    case 'j':
+        return _Is_valid_strftime_tm_yday(_Pt);
+    case 'a':
+    case 'A':
+    case 'u':
+    case 'w':
+        return _Is_valid_strftime_tm_wday(_Pt);
+    case 'U': // C23 7.29.3.5 "The strftime function"/3 says that %U and %W depend on tm_year,
+    case 'W': // but the UCRT neither uses nor validates it.
+        return _Is_valid_strftime_tm_wday(_Pt) && _Is_valid_strftime_tm_yday(_Pt);
+    case 'R':
+        return _Is_valid_strftime_tm_hour(_Pt) && _Is_valid_strftime_tm_min(_Pt);
+    case 'D':
+    case 'x':
+    case 'F':
+        return _Is_valid_strftime_tm_year(_Pt) && _Is_valid_strftime_tm_mon(_Pt) && _Is_valid_strftime_tm_mday(_Pt);
+    case 'g':
+    case 'G':
+        return _Is_valid_strftime_tm_year(_Pt) && _Is_valid_strftime_tm_wday(_Pt) && _Is_valid_strftime_tm_yday(_Pt);
+    case 'r':
+    case 'X':
+    case 'T':
+        return _Is_valid_strftime_tm_hour(_Pt) && _Is_valid_strftime_tm_min(_Pt) && _Is_valid_strftime_tm_sec(_Pt);
+    case 'c':
+        return _Is_valid_strftime_tm_wday(_Pt) && _Is_valid_strftime_tm_mon(_Pt) && _Is_valid_strftime_tm_mday(_Pt)
+            && _Is_valid_strftime_tm_hour(_Pt) && _Is_valid_strftime_tm_min(_Pt) && _Is_valid_strftime_tm_sec(_Pt)
+            && _Is_valid_strftime_tm_year(_Pt);
+    case 'V': // C23 7.29.3.5 "The strftime function"/3 says that %V depends on tm_year, tm_wday, and tm_yday.
+              // The UCRT uses them without validating them.
+        return true;
+    case 'z': // C23 7.29.3.5 "The strftime function"/3 says that %z and %Z depend on tm_isdst.
+    case 'Z': // The UCRT treats it as a boolean value, so there's no need for validation.
+        return true;
+    case 'n': // newline
+    case 't': // tab
+        return true;
+    default:
+        // We should have handled %% and called _Is_valid_strftime_specifier() before calling this function.
+        _STL_INTERNAL_CHECK(false);
+        return false;
+    }
+}
+
+_EXPORT_STD extern "C++" template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+class time_put : public locale::facet { // facet for converting encoded times to text
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    using char_type = _Elem;
+    using iter_type = _OutIt;
+    using _Ctype    = ctype<_Elem>;
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, const _Elem* _Fmtfirst,
+        const _Elem* _Fmtlast) const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
+            if (_Ctype_fac.narrow(*_Fmtfirst) != '%') {
+                *_Dest++ = *_Fmtfirst; // copy literal element
+            } else if (++_Fmtfirst == _Fmtlast) { // treat trailing % as %%
+                *_Dest++ = _Fmtfirst[-1];
+                break;
+            } else { // get specifier after %
+                char _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                char _Modifier  = '\0';
+                _Elem _Percent  = _Fmtfirst[-1];
+
+                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
+                    if (++_Fmtfirst == _Fmtlast) { // no specifier, copy %[EOQ#] as literal elements
+                        *_Dest++ = _Percent;
+                        *_Dest++ = _Specifier;
+                        break;
+                    }
+
+                    // save both qualifier and specifier
+                    _Modifier  = _Specifier;
+                    _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                }
+
+                if (_Specifier == '%' && _Modifier == '\0') {
+                    // if the specifier is percent and no modifier is set, just append it
+                    *_Dest++ = _Percent;
+                } else if (!_Is_valid_strftime_specifier(_Specifier)) {
+                    // no valid specifier, directly copy as literal elements
+                    *_Dest++ = _Percent;
+                    if (_Modifier != '\0') {
+                        *_Dest++ = _Modifier;
+                    }
+                    *_Dest++ = _Specifier;
+                } else {
+                    if (_Is_valid_strftime_tm_data(_Specifier, _Pt)) {
+                        _Dest = do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier); // convert a single field
+                    } else {
+                        *_Dest++ = _Elem('?');
+                    }
+                }
+            }
+        }
+
+        return _Dest;
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for _Specifier/_Modifier
+        return do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    explicit __CLR_OR_THIS_CALL time_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL time_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new time_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_TIME;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~time_put() noexcept override {}
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Tnames = _Lobj._Gettnames();
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        char _Fmt[5] = "!%x\0"; // '!' for nonzero count, null for modifier
+        size_t _Count;
+        size_t _Num;
+        string _Str;
+
+        if (_Modifier == '\0') {
+            _Fmt[2] = _Specifier;
+        } else { // add both modifier and specifier
+            _Fmt[2] = _Modifier;
+            _Fmt[3] = _Specifier;
+        }
+
+        int& _Errno_ref      = errno; // Nonzero cost, pay it once
+        const int _Old_errno = _Errno_ref;
+
+        for (_Num = 16;; _Num *= 2) { // convert into ever larger string buffer until success
+            _Str.append(_Num, '\0');
+            _Count = _Strftime(&_Str[0], _Str.size(), _Fmt, _Pt, _Tnames._Getptr());
+            if (0 < _Count) {
+                break;
+            } else if (_Errno_ref == EINVAL) {
+                _Iosbase.setstate(ios_base::badbit);
+                return _Dest;
+            }
+        }
+
+        _Errno_ref = _Old_errno;
+        return _STD copy(&_Str[1], &_Str[_Count], _Dest);
+    }
+
+private:
+    _Locinfo::_Timevec _Tnames; // locale-specific stuff for _Strftime
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _Elem, class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id time_put<_Elem, _OutIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+extern "C++" template <class _OutIt>
+class time_put<wchar_t, _OutIt> : public locale::facet { // facet for converting encoded times to wchar_t text
+public:
+    using _Elem     = wchar_t;
+    using char_type = _Elem;
+    using iter_type = _OutIt;
+    using _Ctype    = ctype<_Elem>;
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, const _Elem* _Fmtfirst,
+        const _Elem* _Fmtlast) const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
+            if (_Ctype_fac.narrow(*_Fmtfirst) != '%') {
+                *_Dest++ = *_Fmtfirst; // copy literal element
+            } else if (++_Fmtfirst == _Fmtlast) { // treat trailing % as %%
+                *_Dest++ = _Fmtfirst[-1];
+                break;
+            } else { // get specifier after %
+                _Elem _Raw      = *_Fmtfirst;
+                char _Specifier = _Ctype_fac.narrow(_Raw);
+                char _Modifier  = '\0';
+                _Elem _Percent  = _Fmtfirst[-1];
+
+                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
+                    if (++_Fmtfirst == _Fmtlast) { // no specifier, copy %[EOQ#] as literal elements
+                        *_Dest++ = _Percent;
+                        *_Dest++ = _Raw;
+                        break;
+                    }
+
+                    // save both qualifier and specifier
+                    _Modifier  = _Specifier;
+                    _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                }
+
+                if (_Specifier == '%' && _Modifier == '\0') {
+                    // if the specifier is percent and no modifier is set, just append it
+                    *_Dest++ = _Percent;
+                } else if (!_Is_valid_strftime_specifier(_Specifier)) {
+                    // no valid specifier, directly copy as literal elements
+                    *_Dest++ = _Percent;
+                    if (_Modifier != '\0') {
+                        *_Dest++ = _Raw;
+                    }
+                    *_Dest++ = *_Fmtfirst;
+                } else {
+                    if (_Is_valid_strftime_tm_data(_Specifier, _Pt)) {
+                        _Dest = do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier); // convert a single field
+                    } else {
+                        *_Dest++ = _Elem('?');
+                    }
+                }
+            }
+        }
+
+        return _Dest;
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for _Specifier/_Modifier
+        return do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    explicit __CLR_OR_THIS_CALL time_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL time_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new time_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_TIME;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~time_put() noexcept override {}
+
+    __CLR_OR_THIS_CALL time_put(const char* _Locname, size_t _Refs = 0) : locale::facet(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Tnames = _Lobj._W_Gettnames();
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        wchar_t _Fmt[5] = L"!%x\0"; // ! for nonzero count, null for modifier
+        size_t _Count;
+        size_t _Num;
+        wstring _Str;
+
+        if (_Modifier == '\0') {
+            _Fmt[2] = static_cast<_Elem>(_Specifier); // conversion rule unspecified
+        } else { // add both modifier and specifier
+            _Fmt[2] = static_cast<_Elem>(_Modifier);
+            _Fmt[3] = static_cast<_Elem>(_Specifier);
+        }
+
+        int& _Errno_ref      = errno; // Nonzero cost, pay it once
+        const int _Old_errno = _Errno_ref;
+
+        for (_Num = 16;; _Num *= 2) { // convert into ever larger string buffer until success
+            _Str.append(_Num, '\0');
+            _Count = _Wcsftime(&_Str[0], _Str.size(), _Fmt, _Pt, _Tnames._Getptr());
+            if (0 < _Count) {
+                break;
+            } else if (_Errno_ref == EINVAL) {
+                _Iosbase.setstate(ios_base::badbit);
+                return _Dest;
+            }
+        }
+
+        _Errno_ref = _Old_errno;
+        return _STD copy(&_Str[1], &_Str[_Count], _Dest);
+    }
+
+private:
+    _Locinfo::_Timevec _Tnames; // locale-specific stuff for _Wcsftime
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id time_put<wchar_t, _OutIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+
+#if defined(_CRTBLD)
+
+extern "C++" template <class _OutIt>
+class time_put<unsigned short, _OutIt>
+    : public locale::facet { // facet for converting encoded times to unsigned short text
+public:
+    using _Elem     = unsigned short;
+    using char_type = _Elem;
+    using iter_type = _OutIt;
+    using _Ctype    = ctype<_Elem>;
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, const _Elem* _Fmtfirst,
+        const _Elem* _Fmtlast) const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Iosbase.getloc());
+
+        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
+            if (_Ctype_fac.narrow(*_Fmtfirst) != '%') {
+                *_Dest++ = *_Fmtfirst; // copy literal element
+            } else if (++_Fmtfirst == _Fmtlast) { // treat trailing % as %%
+                *_Dest++ = _Fmtfirst[-1];
+                break;
+            } else { // get specifier after %
+                _Elem _Raw      = *_Fmtfirst;
+                char _Specifier = _Ctype_fac.narrow(_Raw);
+                char _Modifier  = '\0';
+                _Elem _Percent  = _Fmtfirst[-1];
+
+                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
+                    if (++_Fmtfirst == _Fmtlast) { // no specifier, copy %[EOQ#] as literal elements
+                        *_Dest++ = _Percent;
+                        *_Dest++ = _Raw;
+                        break;
+                    }
+
+                    // save both qualifier and specifier
+                    _Modifier  = _Specifier;
+                    _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
+                }
+
+                if (_Specifier == '%' && _Modifier == '\0') {
+                    // if the specifier is percent and no modifier is set, just append it
+                    *_Dest++ = _Percent;
+                } else if (!_Is_valid_strftime_specifier(_Specifier)) {
+                    // no valid specifier, directly copy as literal elements
+                    *_Dest++ = _Percent;
+                    if (_Modifier != '\0') {
+                        *_Dest++ = _Raw;
+                    }
+                    *_Dest++ = *_Fmtfirst;
+                } else {
+                    if (_Is_valid_strftime_tm_data(_Specifier, _Pt)) {
+                        _Dest = do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier); // convert a single field
+                    } else {
+                        *_Dest++ = _Elem('?');
+                    }
+                }
+            }
+        }
+
+        return _Dest;
+    }
+
+    _OutIt __CLR_OR_THIS_CALL put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for _Specifier/_Modifier
+        return do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier);
+    }
+
+    __PURE_APPDOMAIN_GLOBAL static locale::id id; // unique facet id
+
+    explicit __CLR_OR_THIS_CALL time_put(size_t _Refs = 0) : locale::facet(_Refs) { // construct from current locale
+        _BEGIN_LOCINFO(_Lobj)
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    __CLR_OR_THIS_CALL time_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
+        _Init(_Lobj);
+    }
+
+    static size_t __CLRCALL_OR_CDECL _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
+        // return locale category mask and construct standard facet
+        if (_Ppf && !*_Ppf) {
+            *_Ppf = new time_put<_Elem, _OutIt>(_Locinfo(_Ploc->_C_str()));
+        }
+
+        return _X_TIME;
+    }
+
+protected:
+    __CLR_OR_THIS_CALL ~time_put() noexcept override {}
+
+    __CLR_OR_THIS_CALL time_put(const char* _Locname, size_t _Refs = 0) : locale::facet(_Refs) {
+        _BEGIN_LOCINFO(_Lobj(_Locname))
+        _Init(_Lobj);
+        _END_LOCINFO()
+    }
+
+    void __CLR_OR_THIS_CALL _Init(const _Locinfo& _Lobj) { // initialize from _Lobj
+        _Tnames = _Lobj._W_Gettnames();
+    }
+
+    virtual _OutIt __CLR_OR_THIS_CALL do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem, const tm* _Pt, char _Specifier,
+        char _Modifier = '\0') const { // put formatted time from _Pt to _Dest for [_Fmtfirst, _Fmtlast)
+        wchar_t _Fmt[5] = L"!%x\0"; // ! for nonzero count, null for modifier
+        size_t _Count;
+        size_t _Num;
+        wstring _Str;
+
+        if (_Modifier == '\0') {
+            _Fmt[2] = static_cast<_Elem>(_Specifier); // conversion rule unspecified
+        } else { // add both modifier and specifier
+            _Fmt[2] = static_cast<_Elem>(_Modifier);
+            _Fmt[3] = static_cast<_Elem>(_Specifier);
+        }
+
+        int& _Errno_ref      = errno; // Nonzero cost, pay it once
+        const int _Old_errno = _Errno_ref;
+
+        for (_Num = 16;; _Num *= 2) { // convert into ever larger string buffer until success
+            _Str.append(_Num, '\0');
+            _Count = _Wcsftime(&_Str[0], _Str.size(), _Fmt, _Pt, _Tnames._Getptr());
+            if (0 < _Count) {
+                break;
+            } else if (_Errno_ref == EINVAL) {
+                _Iosbase.setstate(ios_base::badbit);
+                return _Dest;
+            }
+        }
+
+        _Errno_ref = _Old_errno;
+        return _STD copy(&_Str[1], &_Str[_Count], _Dest);
+    }
+
+private:
+    _Locinfo::_Timevec _Tnames; // locale-specific stuff for _Wcsftime
+};
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdllimport-static-field-def"
+#endif // defined(__clang__)
+
+template <class _OutIt>
+__PURE_APPDOMAIN_GLOBAL locale::id time_put<unsigned short, _OutIt>::id;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // defined(__clang__)
+#endif // defined(_CRTBLD)
+
+_EXPORT_STD template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
+class time_put_byname : public time_put<_Elem, _OutIt> { // time_put for named locale
+public:
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS || _Is_any_of_v<_Elem, char, wchar_t>, _FACET_SPECIALIZATION_MESSAGE);
+
+    explicit time_put_byname(const char* _Locname, size_t _Refs = 0)
+        : time_put<_Elem, _OutIt>(_Locname, _Refs) {} // construct for named locale
+
+    explicit time_put_byname(const string& _Str, size_t _Refs = 0)
+        : time_put<_Elem, _OutIt>(_Str.c_str(), _Refs) {} // construct for named locale
+
+protected:
+    __CLR_OR_THIS_CALL ~time_put_byname() noexcept override {}
+};
+
+#if defined(_DLL_CPPLIB)
+
+#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+template class _CRTIMP2_PURE_IMPORT time_get<char, istreambuf_iterator<char, char_traits<char>>>;
+template class _CRTIMP2_PURE_IMPORT time_put<char, ostreambuf_iterator<char, char_traits<char>>>;
+template _CRTIMP2_PURE void __CLR_OR_THIS_CALL time_get<char, istreambuf_iterator<char, char_traits<char>>>::_Getvals(
+    wchar_t, const _Locinfo&);
+
+template class _CRTIMP2_PURE_IMPORT time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
+template class _CRTIMP2_PURE_IMPORT time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t>>>;
+template _CRTIMP2_PURE void __CLR_OR_THIS_CALL
+    time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t>>>::_Getvals(wchar_t, const _Locinfo&);
+#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
+
+#ifdef __FORCE_INSTANCE
+template class _CRTIMP2_PURE_IMPORT
+    time_get<unsigned short, istreambuf_iterator<unsigned short, char_traits<unsigned short>>>;
+template class _CRTIMP2_PURE_IMPORT
+    time_put<unsigned short, ostreambuf_iterator<unsigned short, char_traits<unsigned short>>>;
+template _CRTIMP2_PURE void __CLR_OR_THIS_CALL
+    time_get<unsigned short, istreambuf_iterator<unsigned short, char_traits<unsigned short>>>::_Getvals(
+        wchar_t, const _Locinfo&);
+#endif // defined(__FORCE_INSTANCE)
+#endif // defined(_DLL_CPPLIB)
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XLOCTIME_
diff --git a/msvc-stl/stl/inc/xmemory b/msvc-stl/stl/inc/xmemory
new file mode 100644
index 0000000..1640e5d
--- /dev/null
+++ b/msvc-stl/stl/inc/xmemory
@@ -0,0 +1,2866 @@
+// xmemory internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XMEMORY_
+#define _XMEMORY_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <cstdint>
+#include <cstdlib>
+#include <limits> // TRANSITION, see GH-4634: Lots of user code assumes that <xmemory> drags in <limits>
+#include <new>
+#include <xatomic.h>
+#include <xutility>
+
+#if _HAS_CXX20
+#include <tuple>
+#endif // _HAS_CXX20
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef no_specializations
+
+#if _VECTORIZED_REMOVE
+extern "C" {
+void* __stdcall __std_remove_1(void* _First, void* _Last, uint8_t _Val) noexcept;
+void* __stdcall __std_remove_2(void* _First, void* _Last, uint16_t _Val) noexcept;
+void* __stdcall __std_remove_4(void* _First, void* _Last, uint32_t _Val) noexcept;
+void* __stdcall __std_remove_8(void* _First, void* _Last, uint64_t _Val) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+template <class _Ty, class _TVal>
+_Ty* _Remove_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return reinterpret_cast<_Ty*>(::__std_remove_1(_First, _Last, _STD _Find_arg_cast<uint8_t>(_Val)));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return reinterpret_cast<_Ty*>(::__std_remove_2(_First, _Last, _STD _Find_arg_cast<uint16_t>(_Val)));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return reinterpret_cast<_Ty*>(::__std_remove_4(_First, _Last, _STD _Find_arg_cast<uint32_t>(_Val)));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return reinterpret_cast<_Ty*>(::__std_remove_8(_First, _Last, _STD _Find_arg_cast<uint64_t>(_Val)));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+_STD_END
+
+#endif // ^^^ _VECTORIZED_REMOVE ^^^
+
+_STD_BEGIN
+template <class _Ptrty>
+_NODISCARD constexpr auto _Unfancy(_Ptrty _Ptr) noexcept { // converts from a fancy pointer to a plain pointer
+    return _STD addressof(*_Ptr);
+}
+
+template <class _Ty>
+_NODISCARD constexpr _Ty* _Unfancy(_Ty* _Ptr) noexcept { // do nothing for plain pointers
+    return _Ptr;
+}
+
+template <class _Ptrty>
+constexpr auto _Unfancy_maybe_null(_Ptrty _Ptr) noexcept {
+    // converts from a (potentially null) fancy pointer to a plain pointer
+    return _Ptr ? _STD addressof(*_Ptr) : nullptr;
+}
+
+template <class _Ty>
+constexpr _Ty* _Unfancy_maybe_null(_Ty* _Ptr) noexcept { // do nothing for plain pointers
+    return _Ptr;
+}
+
+template <class _Ty>
+struct _NODISCARD _Tidy_guard { // class with destructor that calls _Tidy
+    _Ty* _Target;
+    _CONSTEXPR20 ~_Tidy_guard() {
+        if (_Target) {
+            _Target->_Tidy();
+        }
+    }
+};
+
+template <class _Ty>
+struct _NODISCARD _Tidy_deallocate_guard { // class with destructor that calls _Tidy_deallocate
+    _Ty* _Target;
+    _CONSTEXPR20 ~_Tidy_deallocate_guard() {
+        if (_Target) {
+            _Target->_Tidy_deallocate();
+        }
+    }
+};
+
+template <class _Keycmp, class _Lhs, class _Rhs>
+constexpr bool _Nothrow_compare = noexcept(
+    static_cast<bool>(_STD declval<const _Keycmp&>()(_STD declval<const _Lhs&>(), _STD declval<const _Rhs&>())));
+
+[[noreturn]] inline void _Throw_bad_array_new_length() {
+    _THROW(bad_array_new_length{});
+}
+
+template <size_t _Ty_size>
+_NODISCARD constexpr size_t _Get_size_of_n(const size_t _Count) {
+    constexpr bool _Overflow_is_possible = _Ty_size > 1;
+
+    if constexpr (_Overflow_is_possible) {
+        constexpr size_t _Max_possible = static_cast<size_t>(-1) / _Ty_size;
+        if (_Count > _Max_possible) {
+            _Throw_bad_array_new_length(); // multiply overflow
+        }
+    }
+
+    return _Count * _Ty_size;
+}
+
+template <class _Ty>
+constexpr size_t _New_alignof = (_STD max) (alignof(_Ty), __STDCPP_DEFAULT_NEW_ALIGNMENT__);
+
+#ifdef __clang__ // Clang and MSVC implement P0784R7 differently; see GH-1532
+#define _CLANG_CONSTEXPR20 _CONSTEXPR20
+#else // ^^^ Clang / Other vvv
+#define _CLANG_CONSTEXPR20
+#endif // ^^^ Other ^^^
+
+struct _Default_allocate_traits {
+    __declspec(allocator) static _CLANG_CONSTEXPR20 void* _Allocate(const size_t _Bytes) {
+        return ::operator new(_Bytes);
+    }
+
+#ifdef __cpp_aligned_new
+    __declspec(allocator) static _CLANG_CONSTEXPR20 void* _Allocate_aligned(const size_t _Bytes, const size_t _Align) {
+#if defined(__clang__) && _HAS_CXX20 // Ditto, "Clang and MSVC implement P0784R7 differently"
+        if (_STD is_constant_evaluated()) {
+            return ::operator new(_Bytes);
+        } else
+#endif // ^^^ defined(__clang__) && _HAS_CXX20 ^^^
+        {
+            return ::operator new(_Bytes, align_val_t{_Align});
+        }
+    }
+#endif // defined(__cpp_aligned_new)
+};
+
+#undef _CLANG_CONSTEXPR20
+
+constexpr bool _Is_pow_2(const size_t _Value) noexcept {
+    return _Value != 0 && (_Value & (_Value - 1)) == 0;
+}
+
+#if defined(_M_IX86) || defined(_M_X64)
+_INLINE_VAR constexpr size_t _Big_allocation_threshold = 4096;
+_INLINE_VAR constexpr size_t _Big_allocation_alignment = 32;
+
+// Big allocation alignment should at least match vector register alignment
+_STL_INTERNAL_STATIC_ASSERT(2 * sizeof(void*) <= _Big_allocation_alignment);
+
+// Big allocation alignment must be a power of two
+_STL_INTERNAL_STATIC_ASSERT(_Is_pow_2(_Big_allocation_alignment));
+
+#ifdef _DEBUG
+_INLINE_VAR constexpr size_t _Non_user_size = 2 * sizeof(void*) + _Big_allocation_alignment - 1;
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+_INLINE_VAR constexpr size_t _Non_user_size = sizeof(void*) + _Big_allocation_alignment - 1;
+#endif // ^^^ !defined(_DEBUG) ^^^
+
+#ifdef _WIN64
+_INLINE_VAR constexpr size_t _Big_allocation_sentinel = 0xFAFAFAFAFAFAFAFAULL;
+#else // ^^^ 64-bit / 32-bit vvv
+_INLINE_VAR constexpr size_t _Big_allocation_sentinel = 0xFAFAFAFAUL;
+#endif // ^^^ 32-bit ^^^
+
+template <class _Traits>
+__declspec(allocator) void* _Allocate_manually_vector_aligned(const size_t _Bytes) {
+    // allocate _Bytes manually aligned to at least _Big_allocation_alignment
+    const size_t _Block_size = _Non_user_size + _Bytes;
+    if (_Block_size <= _Bytes) {
+        _Throw_bad_array_new_length(); // add overflow
+    }
+
+    const uintptr_t _Ptr_container = reinterpret_cast<uintptr_t>(_Traits::_Allocate(_Block_size));
+    _STL_VERIFY(_Ptr_container != 0, "invalid argument"); // validate even in release since we're doing p[-1]
+    void* const _Ptr = reinterpret_cast<void*>((_Ptr_container + _Non_user_size) & ~(_Big_allocation_alignment - 1));
+    static_cast<uintptr_t*>(_Ptr)[-1] = _Ptr_container;
+
+#ifdef _DEBUG
+    static_cast<uintptr_t*>(_Ptr)[-2] = _Big_allocation_sentinel;
+#endif // defined(_DEBUG)
+    return _Ptr;
+}
+
+inline void _Adjust_manually_vector_aligned(void*& _Ptr, size_t& _Bytes) {
+    // adjust parameters from _Allocate_manually_vector_aligned to pass to operator delete
+    _Bytes += _Non_user_size;
+
+    const uintptr_t* const _Ptr_user = static_cast<uintptr_t*>(_Ptr);
+    const uintptr_t _Ptr_container   = _Ptr_user[-1];
+
+    // If the following asserts, it likely means that we are performing
+    // an aligned delete on memory coming from an unaligned allocation.
+    _STL_ASSERT(_Ptr_user[-2] == _Big_allocation_sentinel, "invalid argument");
+
+    // Extra paranoia on aligned allocation/deallocation; ensure _Ptr_container is
+    // in range [_Min_back_shift, _Non_user_size]
+#ifdef _DEBUG
+    constexpr uintptr_t _Min_back_shift = 2 * sizeof(void*);
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+    constexpr uintptr_t _Min_back_shift = sizeof(void*);
+#endif // ^^^ !defined(_DEBUG) ^^^
+    const uintptr_t _Back_shift = reinterpret_cast<uintptr_t>(_Ptr) - _Ptr_container;
+    _STL_VERIFY(_Back_shift >= _Min_back_shift && _Back_shift <= _Non_user_size, "invalid argument");
+    _Ptr = reinterpret_cast<void*>(_Ptr_container);
+}
+#endif // defined(_M_IX86) || defined(_M_X64)
+
+template <size_t _Align, class _Traits = _Default_allocate_traits>
+__declspec(allocator) _CONSTEXPR20 void* _Allocate(const size_t _Bytes) {
+    // allocate _Bytes
+    if (_Bytes == 0) {
+        return nullptr;
+    }
+
+#if _HAS_CXX20 // TRANSITION, GH-1532
+    if (_STD is_constant_evaluated()) {
+        return _Traits::_Allocate(_Bytes);
+    }
+#endif // _HAS_CXX20
+
+#ifdef __cpp_aligned_new
+    if constexpr (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        size_t _Passed_align = _Align;
+#if defined(_M_IX86) || defined(_M_X64)
+        if (_Bytes >= _Big_allocation_threshold) {
+            // boost the alignment of big allocations to help autovectorization
+            _Passed_align = (_STD max) (_Align, _Big_allocation_alignment);
+        }
+#endif // defined(_M_IX86) || defined(_M_X64)
+        return _Traits::_Allocate_aligned(_Bytes, _Passed_align);
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+#if defined(_M_IX86) || defined(_M_X64)
+        if (_Bytes >= _Big_allocation_threshold) {
+            // boost the alignment of big allocations to help autovectorization
+            return _Allocate_manually_vector_aligned<_Traits>(_Bytes);
+        }
+#endif // defined(_M_IX86) || defined(_M_X64)
+        return _Traits::_Allocate(_Bytes);
+    }
+}
+
+template <size_t _Align>
+_CONSTEXPR20 void _Deallocate(void* _Ptr, size_t _Bytes) noexcept {
+    // deallocate storage allocated by _Allocate
+#if _HAS_CXX20 // TRANSITION, GH-1532
+    if (_STD is_constant_evaluated()) {
+        ::operator delete(_Ptr);
+        return;
+    }
+#endif // _HAS_CXX20
+
+#ifdef __cpp_aligned_new
+    if constexpr (_Align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        size_t _Passed_align = _Align;
+#if defined(_M_IX86) || defined(_M_X64)
+        if (_Bytes >= _Big_allocation_threshold) {
+            // boost the alignment of big allocations to help autovectorization
+            _Passed_align = (_STD max) (_Align, _Big_allocation_alignment);
+        }
+#endif // defined(_M_IX86) || defined(_M_X64)
+        ::operator delete(_Ptr, _Bytes, align_val_t{_Passed_align});
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+#if defined(_M_IX86) || defined(_M_X64)
+        if (_Bytes >= _Big_allocation_threshold) {
+            // boost the alignment of big allocations to help autovectorization
+            _Adjust_manually_vector_aligned(_Ptr, _Bytes);
+        }
+#endif // defined(_M_IX86) || defined(_M_X64)
+        ::operator delete(_Ptr, _Bytes);
+    }
+}
+
+template <class _Ptr, class _Ty>
+using _Rebind_pointer_t = typename pointer_traits<_Ptr>::template rebind<_Ty>;
+
+template <class _Pointer, enable_if_t<!is_pointer_v<_Pointer>, int> = 0>
+_CONSTEXPR20 _Pointer _Refancy(typename pointer_traits<_Pointer>::element_type* _Ptr) noexcept {
+    return pointer_traits<_Pointer>::pointer_to(*_Ptr);
+}
+
+template <class _Pointer, enable_if_t<is_pointer_v<_Pointer>, int> = 0>
+_CONSTEXPR20 _Pointer _Refancy(_Pointer _Ptr) noexcept {
+    return _Ptr;
+}
+
+template <class _Pointer, enable_if_t<!is_pointer_v<_Pointer>, int> = 0>
+_CONSTEXPR20 _Pointer _Refancy_maybe_null(typename pointer_traits<_Pointer>::element_type* _Ptr) noexcept {
+    return _Ptr == nullptr ? _Pointer() : pointer_traits<_Pointer>::pointer_to(*_Ptr);
+}
+
+template <class _Pointer, enable_if_t<is_pointer_v<_Pointer>, int> = 0>
+_CONSTEXPR20 _Pointer _Refancy_maybe_null(_Pointer _Ptr) noexcept {
+    return _Ptr;
+}
+
+template <class _NoThrowFwdIt, class _NoThrowSentinel>
+_CONSTEXPR20 void _Destroy_range(_NoThrowFwdIt _First, _NoThrowSentinel _Last) noexcept;
+
+template <class _Ty>
+_CONSTEXPR20 void _Destroy_in_place(_Ty& _Obj) noexcept {
+    if constexpr (is_array_v<_Ty>) {
+        _STD _Destroy_range(_Obj, _Obj + extent_v<_Ty>);
+    } else {
+        _Obj.~_Ty();
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _Ty>
+_CONSTEXPR20 void destroy_at(_Ty* const _Location) noexcept /* strengthened */ {
+#if _HAS_CXX20
+    if constexpr (is_array_v<_Ty>) {
+        _STD _Destroy_range(_STD begin(*_Location), _STD end(*_Location));
+    } else
+#endif // _HAS_CXX20
+    {
+        _Location->~_Ty();
+    }
+}
+#endif // _HAS_CXX17
+
+template <class _Ptrty>
+auto _Const_cast(_Ptrty _Ptr) noexcept { // remove constness from a fancy pointer
+    using _Elem       = typename pointer_traits<_Ptrty>::element_type;
+    using _Modifiable = remove_const_t<_Elem>;
+    using _Dest       = typename pointer_traits<_Ptrty>::template rebind<_Modifiable>;
+
+    return pointer_traits<_Dest>::pointer_to(const_cast<_Modifiable&>(*_Ptr));
+}
+
+template <class _Ty>
+auto _Const_cast(_Ty* _Ptr) noexcept {
+    return const_cast<remove_const_t<_Ty>*>(_Ptr);
+}
+
+template <class _Ty, class = void>
+struct _Get_pointer_type {
+    using type = typename _Ty::value_type*;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Get_pointer_type<_Ty, void_t<typename _Ty::pointer>> {
+    using type = typename _Ty::pointer;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class = void>
+struct _Get_const_pointer_type {
+    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
+    using _Valty = typename _Ty::value_type;
+    using type   = typename pointer_traits<_Ptrty>::template rebind<const _Valty>;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Get_const_pointer_type<_Ty, void_t<typename _Ty::const_pointer>> {
+    using type = typename _Ty::const_pointer;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class = void>
+struct _Get_void_pointer_type {
+    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
+    using type   = typename pointer_traits<_Ptrty>::template rebind<void>;
+};
+
+template <class _Ty>
+struct _Get_void_pointer_type<_Ty, void_t<typename _Ty::void_pointer>> {
+    using type = typename _Ty::void_pointer;
+};
+
+template <class _Ty, class = void>
+struct _Get_const_void_pointer_type {
+    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
+    using type   = typename pointer_traits<_Ptrty>::template rebind<const void>;
+};
+
+template <class _Ty>
+struct _Get_const_void_pointer_type<_Ty, void_t<typename _Ty::const_void_pointer>> {
+    using type = typename _Ty::const_void_pointer;
+};
+
+template <class _Ty, class = void>
+struct _Get_difference_type {
+    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
+    using type   = typename pointer_traits<_Ptrty>::difference_type;
+};
+
+template <class _Ty>
+struct _Get_difference_type<_Ty, void_t<typename _Ty::difference_type>> {
+    using type = typename _Ty::difference_type;
+};
+
+template <class _Ty, class = void>
+struct _Get_size_type {
+    using type = make_unsigned_t<typename _Get_difference_type<_Ty>::type>;
+};
+
+template <class _Ty>
+struct _Get_size_type<_Ty, void_t<typename _Ty::size_type>> {
+    using type = typename _Ty::size_type;
+};
+
+template <class _Ty, class = void>
+struct _Get_propagate_on_container_copy {
+    using type = false_type;
+};
+
+template <class _Ty>
+struct _Get_propagate_on_container_copy<_Ty, void_t<typename _Ty::propagate_on_container_copy_assignment>> {
+    using type = typename _Ty::propagate_on_container_copy_assignment;
+};
+
+template <class _Ty, class = void>
+struct _Get_propagate_on_container_move {
+    using type = false_type;
+};
+
+template <class _Ty>
+struct _Get_propagate_on_container_move<_Ty, void_t<typename _Ty::propagate_on_container_move_assignment>> {
+    using type = typename _Ty::propagate_on_container_move_assignment;
+};
+
+template <class _Ty, class = void>
+struct _Get_propagate_on_container_swap {
+    using type = false_type;
+};
+
+template <class _Ty>
+struct _Get_propagate_on_container_swap<_Ty, void_t<typename _Ty::propagate_on_container_swap>> {
+    using type = typename _Ty::propagate_on_container_swap;
+};
+
+template <class _Ty, class = void>
+struct _Get_is_always_equal {
+    using type = bool_constant<is_empty_v<_Ty>>;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty>
+struct _Get_is_always_equal<_Ty, void_t<typename _Ty::is_always_equal>> {
+    using type = typename _Ty::is_always_equal;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Ty, class _Other, class = void>
+struct _Get_rebind_type {
+    using type = typename _Replace_first_parameter<_Other, _Ty>::type;
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Ty, class _Other>
+struct _Get_rebind_type<_Ty, _Other, void_t<typename _Ty::template rebind<_Other>::other>> {
+    using type = typename _Ty::template rebind<_Other>::other;
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+_EXPORT_STD template <class _Ty>
+class allocator;
+
+template <class _Alloc, class = void>
+struct _Is_default_allocator : false_type {};
+
+template <class _Ty>
+struct _Is_default_allocator<allocator<_Ty>, void_t<typename allocator<_Ty>::_From_primary>>
+    : is_same<typename allocator<_Ty>::_From_primary, allocator<_Ty>>::type {};
+
+#if _HAS_CXX23
+template <class _Alloc, class _SizeTy>
+concept _Has_member_allocate_at_least = requires(_Alloc& _Al, const _SizeTy& _Count) { _Al.allocate_at_least(_Count); };
+#endif // _HAS_CXX23
+
+template <class _Void, class... _Types>
+struct _Has_no_allocator_construct : true_type {};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc, class _Ptr, class... _Args>
+struct _Has_no_allocator_construct<
+    void_t<decltype(_STD declval<_Alloc&>().construct(_STD declval<_Ptr>(), _STD declval<_Args>()...))>, _Alloc, _Ptr,
+    _Args...> : false_type {};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc, class _Ptr, class... _Args>
+using _Uses_default_construct =
+    disjunction<_Is_default_allocator<_Alloc>, _Has_no_allocator_construct<void, _Alloc, _Ptr, _Args...>>;
+
+template <class _Alloc, class _Ptr, class = void>
+struct _Has_no_alloc_destroy : true_type {};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc, class _Ptr>
+struct _Has_no_alloc_destroy<_Alloc, _Ptr, void_t<decltype(_STD declval<_Alloc&>().destroy(_STD declval<_Ptr>()))>>
+    : false_type {};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc, class _Ptr>
+using _Uses_default_destroy = disjunction<_Is_default_allocator<_Alloc>, _Has_no_alloc_destroy<_Alloc, _Ptr>>;
+
+template <class _Alloc, class _Size_type, class _Const_void_pointer, class = void>
+struct _Has_allocate_hint : false_type {};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc, class _Size_type, class _Const_void_pointer>
+struct _Has_allocate_hint<_Alloc, _Size_type, _Const_void_pointer,
+    void_t<decltype(_STD declval<_Alloc&>().allocate(
+        _STD declval<const _Size_type&>(), _STD declval<const _Const_void_pointer&>()))>> : true_type {};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc, class = void>
+struct _Has_max_size : false_type {};
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc>
+struct _Has_max_size<_Alloc, void_t<decltype(_STD declval<const _Alloc&>().max_size())>> : true_type {};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc, class = void>
+struct _Has_select_on_container_copy_construction : false_type {};
+
+template <class _Alloc>
+struct _Has_select_on_container_copy_construction<_Alloc,
+    void_t<decltype(_STD declval<const _Alloc&>().select_on_container_copy_construction())>> : true_type {};
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Ptr, class _SizeTy = size_t>
+struct allocation_result {
+    _Ptr ptr;
+    _SizeTy count;
+};
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <class _Alloc>
+struct _NO_SPECIALIZATIONS_CITING("N5014 [allocator.traits.general]/1") allocator_traits;
+
+_STL_DISABLE_DEPRECATED_WARNING
+template <class _Alloc>
+struct _Normal_allocator_traits { // defines traits for allocators
+    using allocator_type = _Alloc;
+    using value_type     = typename _Alloc::value_type;
+
+    using pointer            = typename _Get_pointer_type<_Alloc>::type;
+    using const_pointer      = typename _Get_const_pointer_type<_Alloc>::type;
+    using void_pointer       = typename _Get_void_pointer_type<_Alloc>::type;
+    using const_void_pointer = typename _Get_const_void_pointer_type<_Alloc>::type;
+
+    using size_type       = typename _Get_size_type<_Alloc>::type;
+    using difference_type = typename _Get_difference_type<_Alloc>::type;
+
+    using propagate_on_container_copy_assignment = typename _Get_propagate_on_container_copy<_Alloc>::type;
+    using propagate_on_container_move_assignment = typename _Get_propagate_on_container_move<_Alloc>::type;
+    using propagate_on_container_swap            = typename _Get_propagate_on_container_swap<_Alloc>::type;
+    using is_always_equal                        = typename _Get_is_always_equal<_Alloc>::type;
+
+    template <class _Other>
+    using rebind_alloc = typename _Get_rebind_type<_Alloc, _Other>::type;
+
+    template <class _Other>
+    using rebind_traits = allocator_traits<rebind_alloc<_Other>>;
+
+    _NODISCARD_RAW_PTR_ALLOC static _CONSTEXPR20 __declspec(allocator) pointer allocate(
+        _Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count) {
+        return _Al.allocate(_Count);
+    }
+
+    _NODISCARD_RAW_PTR_ALLOC static _CONSTEXPR20 __declspec(allocator) pointer allocate(
+        _Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count, const const_void_pointer _Hint) {
+        if constexpr (_Has_allocate_hint<_Alloc, size_type, const_void_pointer>::value) {
+            return _Al.allocate(_Count, _Hint);
+        } else {
+            return _Al.allocate(_Count);
+        }
+    }
+
+#if _HAS_CXX23
+    _NODISCARD_RAW_PTR_ALLOC static constexpr allocation_result<pointer, size_type> allocate_at_least(
+        _Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count) {
+        if constexpr (_Has_member_allocate_at_least<_Alloc, size_type>) {
+            return _Al.allocate_at_least(_Count);
+        } else {
+            return {_Al.allocate(_Count), _Count};
+        }
+    }
+#endif // _HAS_CXX23
+
+    static _CONSTEXPR20 void deallocate(_Alloc& _Al, pointer _Ptr, size_type _Count) {
+        _Al.deallocate(_Ptr, _Count);
+    }
+
+    template <class _Ty, class... _Types>
+    static _CONSTEXPR20 void construct(_Alloc& _Al, _Ty* _Ptr, _Types&&... _Args) {
+        if constexpr (_Uses_default_construct<_Alloc, _Ty*, _Types...>::value) {
+#if _HAS_CXX20
+            _STD construct_at(_Ptr, _STD forward<_Types>(_Args)...);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            ::new (static_cast<void*>(_Ptr)) _Ty(_STD forward<_Types>(_Args)...);
+#endif // ^^^ !_HAS_CXX20 ^^^
+        } else {
+            _Al.construct(_Ptr, _STD forward<_Types>(_Args)...);
+        }
+    }
+
+    template <class _Ty>
+    static _CONSTEXPR20 void destroy(_Alloc& _Al, _Ty* _Ptr) {
+        if constexpr (_Uses_default_destroy<_Alloc, _Ty*>::value) {
+#if _HAS_CXX20
+            _STD destroy_at(_Ptr);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            _Ptr->~_Ty();
+#endif // ^^^ !_HAS_CXX20 ^^^
+        } else {
+            _Al.destroy(_Ptr);
+        }
+    }
+
+    _NODISCARD static _CONSTEXPR20 size_type max_size(const _Alloc& _Al) noexcept {
+        if constexpr (_Has_max_size<_Alloc>::value) {
+            return _Al.max_size();
+        } else {
+            return _STD _Max_limit<size_type>() / sizeof(value_type);
+        }
+    }
+
+    _NODISCARD static _CONSTEXPR20 _Alloc select_on_container_copy_construction(const _Alloc& _Al) {
+        if constexpr (_Has_select_on_container_copy_construction<_Alloc>::value) {
+            return _Al.select_on_container_copy_construction();
+        } else {
+            return _Al;
+        }
+    }
+};
+_STL_RESTORE_DEPRECATED_WARNING
+
+template <class _Alloc>
+struct _Default_allocator_traits { // traits for std::allocator
+    using allocator_type = _Alloc;
+    using value_type     = typename _Alloc::value_type;
+
+    using pointer            = value_type*;
+    using const_pointer      = const value_type*;
+    using void_pointer       = void*;
+    using const_void_pointer = const void*;
+
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+
+    using propagate_on_container_copy_assignment = false_type;
+    using propagate_on_container_move_assignment = true_type;
+    using propagate_on_container_swap            = false_type;
+    using is_always_equal                        = true_type;
+
+    template <class _Other>
+    using rebind_alloc = allocator<_Other>;
+
+    template <class _Other>
+    using rebind_traits = allocator_traits<allocator<_Other>>;
+
+    _NODISCARD_RAW_PTR_ALLOC static _CONSTEXPR20 __declspec(allocator) pointer allocate(
+        _Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count) {
+#if _HAS_CXX20 // TRANSITION, GH-1532
+        if (_STD is_constant_evaluated()) {
+            return _Al.allocate(_Count);
+        } else
+#endif // _HAS_CXX20
+        {
+            (void) _Al;
+            return static_cast<pointer>(
+                _Allocate<_New_alignof<value_type>>(_Get_size_of_n<sizeof(value_type)>(_Count)));
+        }
+    }
+
+    _NODISCARD_RAW_PTR_ALLOC static _CONSTEXPR20 __declspec(allocator) pointer allocate(
+        _Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count, const_void_pointer) {
+#if _HAS_CXX20 // TRANSITION, GH-1532
+        if (_STD is_constant_evaluated()) {
+            return _Al.allocate(_Count);
+        } else
+#endif // _HAS_CXX20
+        {
+            (void) _Al;
+            return static_cast<pointer>(
+                _Allocate<_New_alignof<value_type>>(_Get_size_of_n<sizeof(value_type)>(_Count)));
+        }
+    }
+
+#if _HAS_CXX23
+    _NODISCARD_RAW_PTR_ALLOC static constexpr allocation_result<pointer, size_type> allocate_at_least(
+        _Alloc& _Al, _CRT_GUARDOVERFLOW const size_type _Count) {
+        return {_Al.allocate(_Count), _Count};
+    }
+#endif // _HAS_CXX23
+
+    static _CONSTEXPR20 void deallocate(_Alloc& _Al, const pointer _Ptr, const size_type _Count) noexcept
+    /* strengthened */ {
+        // no overflow check on the following multiply; we assume _Allocate did that check
+#if _HAS_CXX20 // TRANSITION, GH-1532
+        if (_STD is_constant_evaluated()) {
+            _Al.deallocate(_Ptr, _Count);
+        } else
+#endif // _HAS_CXX20
+        {
+            (void) _Al;
+            _STD _Deallocate<_New_alignof<value_type>>(_Ptr, sizeof(value_type) * _Count);
+        }
+    }
+
+    template <class _Objty, class... _Types>
+    static _CONSTEXPR20 void construct(_Alloc&, _Objty* const _Ptr, _Types&&... _Args) {
+#if _HAS_CXX20
+        _STD construct_at(_Ptr, _STD forward<_Types>(_Args)...);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        ::new (const_cast<void*>(static_cast<const volatile void*>(_Ptr))) _Objty(_STD forward<_Types>(_Args)...);
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+
+    template <class _Uty>
+    static _CONSTEXPR20 void destroy(_Alloc&, _Uty* const _Ptr) {
+#if _HAS_CXX20
+        _STD destroy_at(_Ptr);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        _Ptr->~_Uty();
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+
+    _NODISCARD static _CONSTEXPR20 size_type max_size(const _Alloc&) noexcept {
+        return static_cast<size_t>(-1) / sizeof(value_type);
+    }
+
+    _NODISCARD static _CONSTEXPR20 _Alloc select_on_container_copy_construction(const _Alloc& _Al) {
+        return _Al;
+    }
+};
+
+_EXPORT_STD template <class _Alloc>
+struct _NO_SPECIALIZATIONS_CITING("N5014 [allocator.traits.general]/1") allocator_traits
+    : conditional_t<_Is_default_allocator<_Alloc>::value, _Default_allocator_traits<_Alloc>,
+          _Normal_allocator_traits<_Alloc>> {};
+
+// _Choose_pocca_v returns whether an attempt to propagate allocators is necessary in copy assignment operations.
+// Note that even when false_type, callers should call _Pocca as we want to assign allocators even when equal.
+template <class _Alloc>
+constexpr bool _Choose_pocca_v = allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value
+                              && !allocator_traits<_Alloc>::is_always_equal::value;
+
+enum class _Pocma_values {
+    _Equal_allocators, // usually allows contents to be stolen (e.g. with swap)
+    _Propagate_allocators, // usually allows the allocator to be propagated, and then contents stolen
+    _No_propagate_allocators, // usually turns moves into copies
+};
+
+template <class _Alloc>
+constexpr _Pocma_values _Choose_pocma_v = allocator_traits<_Alloc>::is_always_equal::value
+                                            ? _Pocma_values::_Equal_allocators
+                                            : (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value
+                                                      ? _Pocma_values::_Propagate_allocators
+                                                      : _Pocma_values::_No_propagate_allocators);
+
+template <class _Alloc, class _Value_type>
+using _Rebind_alloc_t = typename allocator_traits<_Alloc>::template rebind_alloc<_Value_type>;
+
+// If _Alloc is already rebound appropriately, binds an lvalue reference to it, avoiding a copy. Otherwise, creates a
+// rebound copy.
+template <class _Alloc, class _Value_type>
+using _Maybe_rebind_alloc_t =
+    typename _Select<is_same_v<typename _Alloc::value_type, _Value_type>>::template _Apply<_Alloc&,
+        _Rebind_alloc_t<_Alloc, _Value_type>>;
+
+template <class _Alloc> // tests if allocator has simple addressing
+constexpr bool _Is_simple_alloc_v =
+    is_same_v<typename allocator_traits<_Alloc>::size_type, size_t>
+    && is_same_v<typename allocator_traits<_Alloc>::difference_type, ptrdiff_t>
+    && is_same_v<typename allocator_traits<_Alloc>::pointer, typename _Alloc::value_type*>
+    && is_same_v<typename allocator_traits<_Alloc>::const_pointer, const typename _Alloc::value_type*>;
+
+// SCARY iterators are permitted but not required by the Standard. See:
+// N2911 Minimizing Dependencies Within Generic Classes For Faster And Smaller Programs
+// N2980 SCARY Iterator Assignment And Initialization
+template <class _Value_type>
+struct _Simple_types { // wraps types from allocators with simple addressing for use in iterators
+                       // and other SCARY machinery
+    using value_type      = _Value_type;
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer         = value_type*;
+    using const_pointer   = const value_type*;
+};
+
+// The number of user bytes a single byte of ASan shadow memory can track.
+_INLINE_VAR constexpr size_t _Asan_granularity      = 8;
+_INLINE_VAR constexpr size_t _Asan_granularity_mask = _Asan_granularity - 1;
+
+// Controls whether ASan `container-overflow` errors are reported for this allocator.
+template <class>
+constexpr bool _Disable_ASan_container_annotations_for_allocator = false;
+
+struct _Asan_aligned_pointers {
+    const void* _First;
+    const void* _End;
+
+    _NODISCARD constexpr const void* _Clamp_to_end(const void* _Mid) const noexcept {
+        _STL_INTERNAL_CHECK(_Mid >= _First);
+        if (_Mid > _End) {
+            return _End;
+        } else {
+            return _Mid;
+        }
+    }
+};
+
+// The way that ASan shadow memory works, each eight byte block of memory ("shadow memory section")
+// has a single byte to mark it as either poison or valid.
+// Each section has 0 to 8 "valid" bytes followed by poison bytes, so:
+// ```
+//   [ v v v p p p p p ]
+// ```
+// or
+// ```
+//   [ v v v v v v v v ]
+// ```
+// are okay, but
+// ```
+//   [ p p p p v v v v ]
+// ```
+// is not.
+//
+// This function exists to fix up `first` and `end` pointers so that one can call
+// `__sanitizer_annotate_contiguous_container`:
+//
+//   - `__sanitizer_annotate_contiguous_container` checks that `first` is aligned to an 8-byte boundary
+//   - if `end` is not aligned to an 8-byte boundary, `__sanitizer_annotate_contiguous_container` still poisons the
+//     remaining bytes in the shadow memory section.
+//
+// Because of the second property, we can only mark poison up to the final aligned address before the true `last`.
+// Otherwise, we'd poison the memory _after_ `last` as well.
+// For the first property, we can assume that everything before `first` in the shadow memory section is valid
+// (since otherwise we couldn't mark `first` valid), and so we just return back the first address in
+// `first`'s shadow memory section.
+//
+// ### Example
+//
+// ```cpp
+// struct alignas(8) cat {
+//     int meow; // bytes [0, 4)
+//     char buffer[16]; // bytes [4, 20)
+//     int purr; // bytes [20, 24)
+// };
+// ```
+//
+// First, `meow` and `purr` are just regular data members, not container buffers, so they _must_ be valid.
+// Then, assume we want to poison all of `buffer`.
+// This would mean that, in a perfect world, we want something like:
+//
+// ```
+//    |  meow |               buffer                | purr  |
+//   [ v v v v p p p p ][ p p p p p p p p ][ p p p p v v v v ]
+//           sm1                sm2                sm3
+// ```
+//
+// However, note that by the rules above, `sm3` is not a valid shadow memory section; we always need
+// the valid bytes to come before the poison bytes. Thus, the closest we can actually get to it is:
+//
+// ```
+//    |  meow |               buffer                | purr  |
+//   [ v v v v p p p p ][ p p p p p p p p ][ v v v v v v v v ]
+//           sm1                sm2                sm3
+// ```
+//
+// We call `aligned = _Get_asan_aligned_first_end(cat.buffer, cat.buffer + 16);`, and we get back
+//
+// ```cpp
+// aligned = {
+//     ._First = &cat.meow,
+//     ._End = cat.buffer + 12,
+// };
+// ```
+//
+// Then, we poison as much of buffer as we can via
+//
+// ```cpp
+// __sanitizer_annotate_contiguous_container(
+//     aligned._First,
+//     aligned._End,
+//     cat.buffer,
+//     aligned._Clamp_to_end(cat.buffer + 16));
+// ```
+//
+// We are allowed to assume that `&cat.meow` is valid, since otherwise `cat.buffer + [0, 4)` could not be valid.
+// We cannot poison up to `cat.buffer + 16`, since then `&purr` could not be valid.
+// Thus, this results in the shadow memory state from the second example.
+_NODISCARD inline _Asan_aligned_pointers _Get_asan_aligned_first_end(
+    const void* const _First, const void* const _End) noexcept {
+    return {
+        reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(_First) & ~_Asan_granularity_mask),
+        reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(_End) & ~_Asan_granularity_mask),
+    };
+}
+
+// When we can assume that the allocator we are using will always align allocations to the 8-byte,
+// we can simply push the `_End` pointer to the end of the shadow memory section.
+// This is _not_ safe in general (see _Get_asan_aligned_first_end's comment for why).
+_NODISCARD inline const void* _Get_asan_aligned_after(const void* const _End) noexcept {
+    return reinterpret_cast<const void*>(
+        (reinterpret_cast<uintptr_t>(_End) + _Asan_granularity_mask) & ~_Asan_granularity_mask);
+}
+
+template <class _Container, class = void>
+constexpr size_t _Container_allocation_minimum_asan_alignment = alignof(typename _Container::value_type);
+
+template <class _Container>
+constexpr size_t _Container_allocation_minimum_asan_alignment<_Container,
+    void_t<decltype(_Container::allocator_type::_Minimum_asan_allocation_alignment)>> =
+    (_STD max) (alignof(typename _Container::value_type),
+        _Container::allocator_type::_Minimum_asan_allocation_alignment);
+
+_EXPORT_STD template <class _Ty>
+class allocator {
+public:
+    static_assert(!is_const_v<_Ty>, "The C++ Standard forbids containers of const elements "
+                                    "because allocator<const T> is ill-formed.");
+    static_assert(!is_function_v<_Ty>, "The C++ Standard forbids allocators for function elements "
+                                       "because of [allocator.requirements].");
+    static_assert(!is_reference_v<_Ty>, "The C++ Standard forbids allocators for reference elements "
+                                        "because of [allocator.requirements].");
+
+    using _From_primary = allocator;
+
+    using value_type = _Ty;
+
+#if _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+    using pointer _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS       = _Ty*;
+    using const_pointer _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS = const _Ty*;
+
+    using reference _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS       = _Ty&;
+    using const_reference _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS = const _Ty&;
+#endif // _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+
+    using propagate_on_container_move_assignment           = true_type;
+    using is_always_equal _CXX20_DEPRECATE_IS_ALWAYS_EQUAL = true_type;
+
+#if _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+    template <class _Other>
+    struct _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES rebind {
+        using other = allocator<_Other>;
+    };
+
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NODISCARD _Ty* address(_Ty& _Val) const noexcept {
+        return _STD addressof(_Val);
+    }
+
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NODISCARD const _Ty* address(const _Ty& _Val) const noexcept {
+        return _STD addressof(_Val);
+    }
+#endif // _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+    constexpr allocator() noexcept {}
+
+    constexpr allocator(const allocator&) noexcept = default;
+    template <class _Other>
+    constexpr allocator(const allocator<_Other>&) noexcept {}
+    _CONSTEXPR20 ~allocator()                           = default;
+    _CONSTEXPR20 allocator& operator=(const allocator&) = default;
+
+    _CONSTEXPR20 void deallocate(_Ty* const _Ptr, const size_t _Count) noexcept /* strengthened */ {
+        _STL_ASSERT(_Ptr != nullptr || _Count == 0, "null pointer cannot point to a block of non-zero size");
+        // no overflow check on the following multiply; we assume _Allocate did that check
+        _STD _Deallocate<_New_alignof<_Ty>>(_Ptr, sizeof(_Ty) * _Count);
+    }
+
+    _NODISCARD_RAW_PTR_ALLOC _CONSTEXPR20 __declspec(allocator) _Ty* allocate(_CRT_GUARDOVERFLOW const size_t _Count) {
+        static_assert(sizeof(value_type) > 0, "value_type must be complete before calling allocate.");
+        return static_cast<_Ty*>(_STD _Allocate<_New_alignof<_Ty>>(_Get_size_of_n<sizeof(_Ty)>(_Count)));
+    }
+
+#if _HAS_CXX23
+    _NODISCARD_RAW_PTR_ALLOC constexpr allocation_result<_Ty*> allocate_at_least(
+        _CRT_GUARDOVERFLOW const size_t _Count) {
+        return {allocate(_Count), _Count};
+    }
+#endif // _HAS_CXX23
+
+#if _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NODISCARD_RAW_PTR_ALLOC __declspec(allocator)
+    _Ty* allocate(_CRT_GUARDOVERFLOW const size_t _Count, const void*) {
+        return allocate(_Count);
+    }
+
+    template <class _Objty, class... _Types>
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS void construct(_Objty* const _Ptr, _Types&&... _Args) {
+        ::new (const_cast<void*>(static_cast<const volatile void*>(_Ptr))) _Objty(_STD forward<_Types>(_Args)...);
+    }
+
+    template <class _Uty>
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS void destroy(_Uty* const _Ptr) {
+        _Ptr->~_Uty();
+    }
+
+    _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NODISCARD size_t max_size() const noexcept {
+        return static_cast<size_t>(-1) / sizeof(_Ty);
+    }
+#endif // _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+    static constexpr size_t _Minimum_asan_allocation_alignment = _Asan_granularity;
+};
+
+#if _HAS_DEPRECATED_ALLOCATOR_VOID || _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+template <>
+class allocator<void> {
+public:
+    using value_type = void;
+#if _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+    using pointer _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS       = void*;
+    using const_pointer _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS = const void*;
+
+    template <class _Other>
+    struct _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES rebind {
+        using other = allocator<_Other>;
+    };
+#endif // _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+#if _HAS_CXX20
+    using size_type       = size_t;
+    using difference_type = ptrdiff_t;
+
+    using propagate_on_container_move_assignment           = true_type;
+    using is_always_equal _CXX20_DEPRECATE_IS_ALWAYS_EQUAL = true_type;
+#endif // _HAS_CXX20
+};
+#endif // _HAS_DEPRECATED_ALLOCATOR_VOID || _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+
+_EXPORT_STD template <class _Ty, class _Other>
+_NODISCARD _CONSTEXPR20 bool operator==(const allocator<_Ty>&, const allocator<_Other>&) noexcept {
+    return true;
+}
+
+#if !_HAS_CXX20
+template <class _Ty, class _Other>
+_NODISCARD bool operator!=(const allocator<_Ty>&, const allocator<_Other>&) noexcept {
+    return false;
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX17
+// See N4950 [unord.map.overview]/4
+template <class _Alloc>
+using _Guide_size_type_t =
+    typename allocator_traits<conditional_t<_Is_allocator<_Alloc>::value, _Alloc, allocator<int>>>::size_type;
+#endif // _HAS_CXX17
+
+template <class _Alloc>
+using _Alloc_ptr_t = typename allocator_traits<_Alloc>::pointer;
+
+template <class _Alloc>
+using _Alloc_size_t = typename allocator_traits<_Alloc>::size_type;
+
+template <class _Alloc>
+_CONSTEXPR20 void _Pocca(_Alloc& _Left, const _Alloc& _Right) noexcept {
+    if constexpr (allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value) {
+        _Left = _Right;
+    }
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Pocma(_Alloc& _Left, _Alloc& _Right) noexcept { // (maybe) propagate on container move assignment
+    if constexpr (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value) {
+        _Left = _STD move(_Right);
+    }
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Pocs(_Alloc& _Left, _Alloc& _Right) noexcept {
+    if constexpr (allocator_traits<_Alloc>::propagate_on_container_swap::value) {
+        swap(_Left, _Right); // intentional ADL
+    } else {
+        _STL_ASSERT(_Left == _Right, "containers incompatible for swap");
+    }
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Destroy_range(_Alloc_ptr_t<_Alloc> _First, const _Alloc_ptr_t<_Alloc> _Last, _Alloc& _Al) noexcept {
+    // note that this is an optimization for debug mode codegen; in release mode the BE removes all of this
+    using _Ty = typename _Alloc::value_type;
+    if constexpr (!conjunction_v<is_trivially_destructible<_Ty>, _Uses_default_destroy<_Alloc, _Ty*>>) {
+        for (; _First != _Last; ++_First) {
+            allocator_traits<_Alloc>::destroy(_Al, _STD _Unfancy(_First));
+        }
+    }
+}
+
+template <class _NoThrowFwdIt, class _NoThrowSentinel>
+_CONSTEXPR20 void _Destroy_range(_NoThrowFwdIt _First, const _NoThrowSentinel _Last) noexcept {
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        for (; _First != _Last; ++_First) {
+            _STD _Destroy_in_place(*_First);
+        }
+    } else
+#endif // _HAS_CXX20
+    { // note that this is an optimization for debug mode codegen; in release mode the BE removes all of this
+        if constexpr (!is_trivially_destructible_v<_Iter_value_t<_NoThrowFwdIt>>) {
+            for (; _First != _Last; ++_First) {
+                _STD _Destroy_in_place(*_First);
+            }
+        }
+    }
+}
+
+template <class _Size_type, class _Unsigned_type>
+_NODISCARD constexpr _Size_type _Convert_size(const _Unsigned_type _Len)
+    noexcept(sizeof(_Unsigned_type) <= sizeof(_Size_type)) {
+    // convert _Unsigned_type to _Size_type, avoiding truncation
+    _STL_INTERNAL_STATIC_ASSERT(_Unsigned_type(-1) > 0);
+    _STL_INTERNAL_STATIC_ASSERT(_Size_type(-1) > 0);
+
+    if constexpr (sizeof(_Unsigned_type) > sizeof(_Size_type)) {
+        if (_Len > _STD _Max_limit<_Size_type>()) {
+            _Xlength_error("size is too long for _Size_type");
+        }
+    }
+
+    return static_cast<_Size_type>(_Len);
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
+    // deallocate a plain pointer using an allocator
+    using _Alloc_traits = allocator_traits<_Alloc>;
+    if constexpr (is_same_v<_Alloc_ptr_t<_Alloc>, typename _Alloc::value_type*>) {
+        _Alloc_traits::deallocate(_Al, _Ptr, 1);
+    } else {
+        using _Ptr_traits = pointer_traits<_Alloc_ptr_t<_Alloc>>;
+        _Alloc_traits::deallocate(_Al, _Ptr_traits::pointer_to(*_Ptr), 1);
+    }
+}
+
+template <class _Alloc>
+_CONSTEXPR20 void _Delete_plain_internal(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
+    // destroy *_Ptr in place, then deallocate _Ptr using _Al; used for internal container types the user didn't name
+    using _Ty = typename _Alloc::value_type;
+    _Ptr->~_Ty();
+    _STD _Deallocate_plain(_Al, _Ptr);
+}
+
+template <class _Alloc>
+struct _Alloc_construct_ptr { // pointer used to help construct 1 _Alloc::value_type without EH
+    using pointer = _Alloc_ptr_t<_Alloc>;
+    _Alloc& _Al;
+    pointer _Ptr;
+
+    _CONSTEXPR20 explicit _Alloc_construct_ptr(_Alloc& _Al_) : _Al(_Al_), _Ptr(nullptr) {}
+
+    _NODISCARD _CONSTEXPR20 pointer _Release() noexcept { // disengage *this and return contained pointer
+        return _STD exchange(_Ptr, nullptr);
+    }
+
+    _CONSTEXPR20 void _Allocate() { // disengage *this, then allocate a new memory block
+        _Ptr = nullptr; // if allocate throws, prevents double-free
+        _Ptr = _Al.allocate(1);
+    }
+
+    _CONSTEXPR20 ~_Alloc_construct_ptr() { // if this instance is engaged, deallocate storage
+        if (_Ptr) {
+            _Al.deallocate(_Ptr, 1);
+        }
+    }
+
+    _Alloc_construct_ptr(const _Alloc_construct_ptr&)            = delete;
+    _Alloc_construct_ptr& operator=(const _Alloc_construct_ptr&) = delete;
+};
+
+struct _Fake_allocator {};
+
+struct _Container_base0 {
+    _CONSTEXPR20 void _Orphan_all() noexcept {}
+    _CONSTEXPR20 void _Swap_proxy_and_iterators(_Container_base0&) noexcept {}
+    _CONSTEXPR20 void _Alloc_proxy(const _Fake_allocator&) noexcept {}
+    _CONSTEXPR20 void _Reload_proxy(const _Fake_allocator&, const _Fake_allocator&) noexcept {}
+};
+
+struct _Iterator_base0 {
+    _CONSTEXPR20 void _Adopt(const void*) noexcept {}
+    _CONSTEXPR20 const _Container_base0* _Getcont() const noexcept {
+        return nullptr;
+    }
+
+    static constexpr bool _Unwrap_when_unverified = true;
+};
+
+struct _Container_base12;
+struct _Container_proxy { // store head of iterator chain and back pointer
+    _CONSTEXPR20 _Container_proxy() noexcept = default;
+    _CONSTEXPR20 _Container_proxy(_Container_base12* _Mycont_) noexcept : _Mycont(_Mycont_) {}
+
+    const _Container_base12* _Mycont       = nullptr;
+    mutable _Iterator_base12* _Myfirstiter = nullptr;
+};
+
+struct _Container_base12 {
+public:
+    _CONSTEXPR20 _Container_base12() noexcept = default;
+
+    _Container_base12(const _Container_base12&)            = delete;
+    _Container_base12& operator=(const _Container_base12&) = delete;
+
+    _CONSTEXPR20 void _Orphan_all() noexcept;
+    _CONSTEXPR20 void _Swap_proxy_and_iterators(_Container_base12&) noexcept;
+
+    template <class _Alloc>
+    _CONSTEXPR20 void _Alloc_proxy(_Alloc&& _Al) {
+        _Container_proxy* const _New_proxy = _Unfancy(_Al.allocate(1));
+        _Construct_in_place(*_New_proxy, this);
+        _Myproxy            = _New_proxy;
+        _New_proxy->_Mycont = this;
+    }
+
+    template <class _Alloc>
+    _CONSTEXPR20 void _Reload_proxy(_Alloc&& _Old_alloc, _Alloc&& _New_alloc) {
+        // pre: no iterators refer to the existing proxy
+        _Container_proxy* const _New_proxy = _Unfancy(_New_alloc.allocate(1));
+        _Construct_in_place(*_New_proxy, this);
+        _New_proxy->_Mycont = this;
+        _Delete_plain_internal(_Old_alloc, _STD exchange(_Myproxy, _New_proxy));
+    }
+
+    _Container_proxy* _Myproxy = nullptr;
+
+private:
+    _CONSTEXPR20 void _Orphan_all_unlocked_v3() noexcept;
+    _CONSTEXPR20 void _Swap_proxy_and_iterators_unlocked(_Container_base12&) noexcept;
+
+    void _Orphan_all_locked_v3() noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_all_unlocked_v3();
+    }
+
+    void _Swap_proxy_and_iterators_locked(_Container_base12& _Right) noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Swap_proxy_and_iterators_unlocked(_Right);
+    }
+};
+
+struct _Iterator_base12 { // store links to container proxy, next iterator
+public:
+    _CONSTEXPR20 _Iterator_base12() noexcept = default; // construct orphaned iterator
+
+    _CONSTEXPR20 _Iterator_base12(const _Iterator_base12& _Right) noexcept {
+        *this = _Right;
+    }
+
+    _CONSTEXPR20 _Iterator_base12& operator=(const _Iterator_base12& _Right) noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Assign_unlocked(_Right);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Assign_locked(_Right);
+        }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+        _Myproxy = _Right._Myproxy;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+        return *this;
+    }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    _CONSTEXPR20 ~_Iterator_base12() noexcept {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Orphan_me_unlocked_v3();
+        } else
+#endif // _HAS_CXX20
+        {
+            _Orphan_me_locked_v3();
+        }
+    }
+
+    _CONSTEXPR20 void _Adopt(const _Container_base12* _Parent) noexcept {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            _Adopt_unlocked(_Parent);
+        } else
+#endif // _HAS_CXX20
+        {
+            _Adopt_locked(_Parent);
+        }
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+    _CONSTEXPR20 void _Adopt(const _Container_base12* _Parent) noexcept {
+        if (_Parent) { // have a parent, do adoption
+            _Myproxy = _Parent->_Myproxy;
+        } else { // no future parent, just disown current parent
+            _Myproxy = nullptr;
+        }
+    }
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+
+    _CONSTEXPR20 const _Container_base12* _Getcont() const noexcept {
+        return _Myproxy ? _Myproxy->_Mycont : nullptr;
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _ITERATOR_DEBUG_LEVEL == 0;
+
+    mutable _Container_proxy* _Myproxy    = nullptr;
+    mutable _Iterator_base12* _Mynextiter = nullptr;
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+private:
+    _CONSTEXPR20 void _Assign_unlocked(const _Iterator_base12& _Right) noexcept {
+        if (_Myproxy == _Right._Myproxy) {
+            return;
+        }
+
+        if (_Right._Myproxy) {
+            _Adopt_unlocked(_Right._Myproxy->_Mycont);
+        } else { // becoming invalid, disown current parent
+            _Orphan_me_unlocked_v3();
+        }
+    }
+
+    void _Assign_locked(const _Iterator_base12& _Right) noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Assign_unlocked(_Right);
+    }
+
+    _CONSTEXPR20 void _Adopt_unlocked(const _Container_base12* _Parent) noexcept {
+        if (!_Parent) {
+            _Orphan_me_unlocked_v3();
+            return;
+        }
+
+        _Container_proxy* _Parent_proxy = _Parent->_Myproxy;
+        if (_Myproxy != _Parent_proxy) { // change parentage
+            if (_Myproxy) { // adopted, remove self from list
+                _Orphan_me_unlocked_v3();
+            }
+            _Mynextiter                 = _Parent_proxy->_Myfirstiter;
+            _Parent_proxy->_Myfirstiter = this;
+            _Myproxy                    = _Parent_proxy;
+        }
+    }
+
+    void _Adopt_locked(const _Container_base12* _Parent) noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Adopt_unlocked(_Parent);
+    }
+
+    _CONSTEXPR20 void _Orphan_me_unlocked_v3() noexcept {
+        if (!_Myproxy) { // already orphaned
+            return;
+        }
+
+        // adopted, remove self from list
+        _Iterator_base12** _Pnext = &_Myproxy->_Myfirstiter;
+        while (*_Pnext && *_Pnext != this) {
+            _Pnext = &(*_Pnext)->_Mynextiter;
+        }
+
+        _STL_VERIFY(*_Pnext, "ITERATOR LIST CORRUPTED!");
+        *_Pnext  = _Mynextiter;
+        _Myproxy = nullptr;
+    }
+
+    void _Orphan_me_locked_v3() noexcept {
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Orphan_me_unlocked_v3();
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+};
+
+_CONSTEXPR20 void _Container_base12::_Orphan_all_unlocked_v3() noexcept {
+    if (!_Myproxy) { // no proxy, already done
+        return;
+    }
+
+    // proxy allocated, drain it
+    for (auto _Pnext = _STD exchange(_Myproxy->_Myfirstiter, nullptr); _Pnext; _Pnext = _Pnext->_Mynextiter) {
+        _Pnext->_Myproxy = nullptr;
+    }
+}
+
+_CONSTEXPR20 void _Container_base12::_Orphan_all() noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        _Orphan_all_unlocked_v3();
+    } else
+#endif // _HAS_CXX20
+    {
+        _Orphan_all_locked_v3();
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+}
+
+_CONSTEXPR20 void _Container_base12::_Swap_proxy_and_iterators_unlocked(_Container_base12& _Right) noexcept {
+    _Container_proxy* _Temp = _Myproxy;
+    _Myproxy                = _Right._Myproxy;
+    _Right._Myproxy         = _Temp;
+
+    if (_Myproxy) {
+        _Myproxy->_Mycont = this;
+    }
+
+    if (_Right._Myproxy) {
+        _Right._Myproxy->_Mycont = &_Right;
+    }
+}
+
+_CONSTEXPR20 void _Container_base12::_Swap_proxy_and_iterators(_Container_base12& _Right) noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        _Swap_proxy_and_iterators_unlocked(_Right);
+    } else
+#endif // _HAS_CXX20
+    {
+        _Swap_proxy_and_iterators_locked(_Right);
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+    _Swap_proxy_and_iterators_unlocked(_Right);
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+}
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+using _Container_base = _Container_base0;
+using _Iterator_base  = _Iterator_base0;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL > 0 vvv
+using _Container_base = _Container_base12;
+using _Iterator_base  = _Iterator_base12;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL > 0 ^^^
+
+struct _Leave_proxy_unbound {
+    explicit _Leave_proxy_unbound() = default;
+}; // tag to indicate that a proxy is being allocated before it is safe to bind to a _Container_base12
+
+struct _Fake_proxy_ptr_impl { // fake replacement for a container proxy smart pointer when no container proxy is in use
+    _Fake_proxy_ptr_impl(const _Fake_proxy_ptr_impl&)            = delete;
+    _Fake_proxy_ptr_impl& operator=(const _Fake_proxy_ptr_impl&) = delete;
+    _CONSTEXPR20 _Fake_proxy_ptr_impl(const _Fake_allocator&, _Leave_proxy_unbound) noexcept {}
+    _CONSTEXPR20 _Fake_proxy_ptr_impl(const _Fake_allocator&, const _Container_base0&) noexcept {}
+
+    _CONSTEXPR20 void _Bind(const _Fake_allocator&, _Container_base0*) noexcept {}
+    _CONSTEXPR20 void _Release() noexcept {}
+};
+
+struct _Basic_container_proxy_ptr12 {
+    // smart pointer components for a _Container_proxy * that don't depend on the allocator
+    _Container_proxy* _Ptr = nullptr;
+
+    constexpr void _Release() noexcept { // disengage this _Basic_container_proxy_ptr12
+        _Ptr = nullptr;
+    }
+
+protected:
+    _CONSTEXPR20 _Basic_container_proxy_ptr12()                       = default;
+    _Basic_container_proxy_ptr12(const _Basic_container_proxy_ptr12&) = delete;
+    _Basic_container_proxy_ptr12(_Basic_container_proxy_ptr12&&)      = delete;
+};
+
+template <class _Alloc>
+struct _Container_proxy_ptr12 : _Basic_container_proxy_ptr12 {
+    // smart pointer components for a _Container_proxy * for an allocator family
+    _Alloc& _Al;
+
+    _CONSTEXPR20 _Container_proxy_ptr12(_Alloc& _Al_, _Leave_proxy_unbound) : _Al(_Al_) {
+        // create a new unbound _Container_proxy
+        _Ptr = _Unfancy(_Al_.allocate(1));
+        _Construct_in_place(*_Ptr);
+    }
+
+    _CONSTEXPR20 _Container_proxy_ptr12(_Alloc& _Al_, _Container_base12& _Mycont) : _Al(_Al_) {
+        // create a new _Container_proxy pointing at _Mycont
+        _Ptr = _Unfancy(_Al_.allocate(1));
+        _Construct_in_place(*_Ptr, _STD addressof(_Mycont));
+        _Mycont._Myproxy = _Ptr;
+    }
+
+    _CONSTEXPR20 void _Bind(_Alloc& _Old_alloc, _Container_base12* _Mycont) noexcept {
+        // Attach the proxy stored in *this to _Mycont, and destroy _Mycont's existing proxy
+        // with _Old_alloc. Requires that no iterators are alive referring to _Mycont.
+        _Ptr->_Mycont = _Mycont;
+        _Delete_plain_internal(_Old_alloc, _STD exchange(_Mycont->_Myproxy, _STD exchange(_Ptr, nullptr)));
+    }
+
+    _CONSTEXPR20 ~_Container_proxy_ptr12() {
+        if (_Ptr) {
+            _Delete_plain_internal(_Al, _Ptr);
+        }
+    }
+};
+
+#if _ITERATOR_DEBUG_LEVEL == 0
+template <class _Alloc>
+_CONSTEXPR20 _Fake_allocator _Get_proxy_allocator(const _Alloc&) noexcept {
+    return {};
+}
+
+template <class _Alloc>
+using _Container_proxy_ptr = _Fake_proxy_ptr_impl;
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 0 / _ITERATOR_DEBUG_LEVEL > 0 vvv
+template <class _Alloc>
+_CONSTEXPR20 _Rebind_alloc_t<_Alloc, _Container_proxy> _Get_proxy_allocator(const _Alloc& _Al)
+    noexcept(noexcept(static_cast<_Rebind_alloc_t<_Alloc, _Container_proxy>>(_Al))) {
+    return static_cast<_Rebind_alloc_t<_Alloc, _Container_proxy>>(_Al);
+}
+
+template <class _Alloc>
+using _Container_proxy_ptr = _Container_proxy_ptr12<_Rebind_alloc_t<_Alloc, _Container_proxy>>;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL > 0 ^^^
+
+struct _Zero_then_variadic_args_t {
+    explicit _Zero_then_variadic_args_t() = default;
+}; // tag type for value-initializing first, constructing second from remaining args
+
+struct _One_then_variadic_args_t {
+    explicit _One_then_variadic_args_t() = default;
+}; // tag type for constructing first from one arg, constructing second from remaining args
+
+template <class _Ty1, class _Ty2, bool = is_empty_v<_Ty1> && !is_final_v<_Ty1>>
+class _Compressed_pair final : private _Ty1 { // store a pair of values, deriving from empty first
+public:
+    _Ty2 _Myval2;
+
+    using _Mybase = _Ty1; // for visualization
+
+    template <class... _Other2>
+    constexpr explicit _Compressed_pair(_Zero_then_variadic_args_t, _Other2&&... _Val2)
+        noexcept(conjunction_v<is_nothrow_default_constructible<_Ty1>, is_nothrow_constructible<_Ty2, _Other2...>>)
+        : _Ty1(), _Myval2(_STD forward<_Other2>(_Val2)...) {}
+
+    template <class _Other1, class... _Other2>
+    constexpr _Compressed_pair(_One_then_variadic_args_t, _Other1&& _Val1, _Other2&&... _Val2)
+        noexcept(conjunction_v<is_nothrow_constructible<_Ty1, _Other1>, is_nothrow_constructible<_Ty2, _Other2...>>)
+        : _Ty1(_STD forward<_Other1>(_Val1)), _Myval2(_STD forward<_Other2>(_Val2)...) {}
+
+    constexpr _Ty1& _Get_first() noexcept {
+        return *this;
+    }
+
+    constexpr const _Ty1& _Get_first() const noexcept {
+        return *this;
+    }
+};
+
+template <class _Ty1, class _Ty2>
+class _Compressed_pair<_Ty1, _Ty2, false> final { // store a pair of values, not deriving from first
+public:
+    _Ty1 _Myval1;
+    _Ty2 _Myval2;
+
+    template <class... _Other2>
+    constexpr explicit _Compressed_pair(_Zero_then_variadic_args_t, _Other2&&... _Val2)
+        noexcept(conjunction_v<is_nothrow_default_constructible<_Ty1>, is_nothrow_constructible<_Ty2, _Other2...>>)
+        : _Myval1(), _Myval2(_STD forward<_Other2>(_Val2)...) {}
+
+    template <class _Other1, class... _Other2>
+    constexpr _Compressed_pair(_One_then_variadic_args_t, _Other1&& _Val1, _Other2&&... _Val2)
+        noexcept(conjunction_v<is_nothrow_constructible<_Ty1, _Other1>, is_nothrow_constructible<_Ty2, _Other2...>>)
+        : _Myval1(_STD forward<_Other1>(_Val1)), _Myval2(_STD forward<_Other2>(_Val2)...) {}
+
+    constexpr _Ty1& _Get_first() noexcept {
+        return _Myval1;
+    }
+
+    constexpr const _Ty1& _Get_first() const noexcept {
+        return _Myval1;
+    }
+};
+
+template <class _Ty>
+pair<_Ty*, ptrdiff_t> _Get_temporary_buffer(ptrdiff_t _Count) noexcept {
+    if (static_cast<size_t>(_Count) <= static_cast<size_t>(-1) / sizeof(_Ty)) {
+        for (; 0 < _Count; _Count /= 2) {
+            const auto _Size = static_cast<size_t>(_Count) * sizeof(_Ty);
+            void* _Pbuf;
+#ifdef __cpp_aligned_new
+            if constexpr (alignof(_Ty) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+                _Pbuf = ::operator new(_Size, align_val_t{alignof(_Ty)}, nothrow);
+            } else
+#endif // defined(__cpp_aligned_new)
+            {
+                _Pbuf = ::operator new(_Size, nothrow);
+            }
+
+            if (_Pbuf) {
+                return {static_cast<_Ty*>(_Pbuf), _Count};
+            }
+        }
+    }
+
+    return {nullptr, 0};
+}
+
+template <class _Ty>
+void _Return_temporary_buffer(_Ty* const _Pbuf) noexcept {
+#ifdef __cpp_aligned_new
+    if constexpr (alignof(_Ty) > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        ::operator delete(_Pbuf, align_val_t{alignof(_Ty)});
+    } else
+#endif // defined(__cpp_aligned_new)
+    {
+        ::operator delete(_Pbuf);
+    }
+}
+
+template <class _Ty, class _InIt>
+void _Construct_in_place_by_deref(_Ty& _Val, _InIt& _Iter)
+    noexcept(noexcept(::new (static_cast<void*>(_STD addressof(_Val))) _Ty(*_Iter))) {
+    ::new (static_cast<void*>(_STD addressof(_Val))) _Ty(*_Iter);
+}
+
+template <class _NoThrowFwdIt>
+struct _NODISCARD _Uninitialized_backout {
+    // struct to undo partially constructed ranges in _Uninitialized_xxx algorithms
+    _NoThrowFwdIt _First;
+    _NoThrowFwdIt _Last;
+
+    constexpr explicit _Uninitialized_backout(_NoThrowFwdIt _Dest) : _First(_Dest), _Last(_Dest) {}
+
+    constexpr _Uninitialized_backout(_NoThrowFwdIt _First_, _NoThrowFwdIt _Last_) : _First(_First_), _Last(_Last_) {}
+
+    _Uninitialized_backout(const _Uninitialized_backout&)            = delete;
+    _Uninitialized_backout& operator=(const _Uninitialized_backout&) = delete;
+
+    _CONSTEXPR20 ~_Uninitialized_backout() {
+        _STD _Destroy_range(_First, _Last);
+    }
+
+    template <class... _Types>
+    _CONSTEXPR20 void _Emplace_back(_Types&&... _Vals) {
+        // construct a new element at *_Last and increment
+        _STD _Construct_in_place(*_Last, _STD forward<_Types>(_Vals)...);
+        ++_Last;
+    }
+
+    template <class _InIt>
+    void _Emplace_back_deref(_InIt& _Iter) {
+        // construct a new element at *_Last from the result of dereferencing _Iter and increment.
+        _STD _Construct_in_place_by_deref(*_Last, _Iter);
+        ++_Last;
+    }
+
+    template <class _InIt>
+    void _Emplace_back_deref_move(_InIt& _Iter) {
+        // construct a new element at *_Last from the result of dereferencing _Iter and increment,
+        // with lvalue cast to xvalue if necessary for uninitialized_move(_n).
+        if constexpr (is_lvalue_reference_v<decltype(*_Iter)>) {
+            _STD _Construct_in_place(*_Last, _STD move(*_Iter));
+        } else {
+            _STD _Construct_in_place_by_deref(*_Last, _Iter);
+        }
+        ++_Last;
+    }
+
+    constexpr _NoThrowFwdIt _Release() { // suppress any exception handling backout and return _Last
+        _First = _Last;
+        return _Last;
+    }
+};
+
+template <class _InIt, class _NoThrowFwdIt>
+_NoThrowFwdIt _Uninitialized_move_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+    // move [_First, _Last) to raw [_Dest, ...)
+    if constexpr (_Iter_move_cat<_InIt, _NoThrowFwdIt>::_Bitcopy_constructible) {
+#if 0 // TRANSITION, _HAS_CXX26
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX26
+        {
+            return _STD _Copy_memcpy(_First, _Last, _Dest);
+        }
+    }
+    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
+    for (; _First != _Last; ++_First) {
+        _Backout._Emplace_back_deref_move(_First);
+    }
+
+    return _Backout._Release();
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It>
+    concept _No_throw_input_iterator =
+        input_iterator<_It> && is_lvalue_reference_v<iter_reference_t<_It>>
+        && same_as<remove_cvref_t<iter_reference_t<_It>>, remove_reference_t<iter_reference_t<_It>>> // per LWG-3888
+        && same_as<remove_cvref_t<iter_reference_t<_It>>, iter_value_t<_It>>;
+
+    template <class _Se, class _It>
+    concept _No_throw_sentinel_for = sentinel_for<_Se, _It>;
+
+    template <class _It>
+    concept _No_throw_forward_iterator =
+        _No_throw_input_iterator<_It> && forward_iterator<_It> && _No_throw_sentinel_for<_It, _It>;
+
+    template <class _Rng>
+    concept _No_throw_input_range = range<_Rng> && _No_throw_input_iterator<iterator_t<_Rng>>
+                                 && _No_throw_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>;
+
+    template <class _Rng>
+    concept _No_throw_forward_range = _No_throw_input_range<_Rng> && _No_throw_forward_iterator<iterator_t<_Rng>>;
+
+    template <class _InIt, class _OutIt>
+    in_out_result<_InIt, _OutIt> _Copy_memcpy_count(_InIt _IFirst, _OutIt _OFirst, const size_t _Count) noexcept {
+        // (pre-verified contiguous iterator)
+        const auto _IFirstPtr     = _STD _To_address(_IFirst);
+        const auto _OFirstPtr     = _STD _To_address(_OFirst);
+        const auto _IFirst_ch     = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
+        const auto _OFirst_ch     = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
+        const size_t _Count_bytes = _Count * sizeof(iter_value_t<_InIt>);
+        _CSTD memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
+        if constexpr (is_pointer_v<_InIt>) {
+            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
+        } else {
+            _IFirst += static_cast<iter_difference_t<_InIt>>(_Count);
+        }
+
+        if constexpr (is_pointer_v<_OutIt>) {
+            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
+        } else {
+            _OFirst += static_cast<iter_difference_t<_OutIt>>(_Count);
+        }
+        return {_STD move(_IFirst), _STD move(_OFirst)};
+    }
+
+    template <class _InIt, class _OutIt, class _DistIt>
+    in_out_result<_InIt, _OutIt> _Copy_memcpy_distance(
+        _InIt _IFirst, _OutIt _OFirst, const _DistIt _DFirst, const _DistIt _DLast) noexcept {
+        // (pre-verified contiguous iterator)
+        // equivalent to _Copy_memcpy_count(_IFirst, _OFirst, _DLast - _DFirst) but computes distance more efficiently
+        const auto _IFirstPtr   = _STD _To_address(_IFirst);
+        const auto _OFirstPtr   = _STD _To_address(_OFirst);
+        const auto _DFirstPtr   = _STD _To_address(_DFirst);
+        const auto _DLastPtr    = _STD _To_address(_DLast);
+        const auto _IFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
+        const auto _OFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
+        const auto _DFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_DFirstPtr));
+        const auto _DLast_ch    = const_cast<char*>(reinterpret_cast<const volatile char*>(_DLastPtr));
+        const auto _Count_bytes = static_cast<size_t>(_DLast_ch - _DFirst_ch);
+        _CSTD memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
+        if constexpr (is_pointer_v<_InIt>) {
+            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
+        } else {
+            _IFirst += static_cast<iter_difference_t<_InIt>>(_Count_bytes / sizeof(iter_value_t<_InIt>));
+        }
+
+        if constexpr (is_pointer_v<_OutIt>) {
+            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
+        } else {
+            _OFirst += static_cast<iter_difference_t<_OutIt>>(_Count_bytes / sizeof(iter_value_t<_OutIt>));
+        }
+        return {_STD move(_IFirst), _STD move(_OFirst)};
+    }
+
+    template <class _InIt, class _OutIt>
+    in_out_result<_InIt, _OutIt> _Copy_memcpy_common(
+        _InIt _IFirst, _InIt _ILast, _OutIt _OFirst, _OutIt _OLast) noexcept {
+        const auto _IFirstPtr   = _STD _To_address(_IFirst);
+        const auto _ILastPtr    = _STD _To_address(_ILast);
+        const auto _OFirstPtr   = _STD _To_address(_OFirst);
+        const auto _OLastPtr    = _STD _To_address(_OLast);
+        const auto _IFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
+        const auto _ILast_ch    = const_cast<const char*>(reinterpret_cast<const volatile char*>(_ILastPtr));
+        const auto _OFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
+        const auto _OLast_ch    = const_cast<const char*>(reinterpret_cast<const volatile char*>(_OLastPtr));
+        const auto _Count_bytes = static_cast<size_t>((_STD min) (_ILast_ch - _IFirst_ch, _OLast_ch - _OFirst_ch));
+        _CSTD memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
+        if constexpr (is_pointer_v<_InIt>) {
+            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
+        } else {
+            _IFirst += static_cast<iter_difference_t<_InIt>>(_Count_bytes / sizeof(iter_value_t<_InIt>));
+        }
+
+        if constexpr (is_pointer_v<_OutIt>) {
+            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
+        } else {
+            _OFirst += static_cast<iter_difference_t<_OutIt>>(_Count_bytes / sizeof(iter_value_t<_OutIt>));
+        }
+        return {_STD move(_IFirst), _STD move(_OFirst)};
+    }
+
+    _EXPORT_STD template <class _In, class _Out>
+    using uninitialized_move_result = in_out_result<_In, _Out>;
+
+    template <input_iterator _It, sentinel_for<_It> _Se, _No_throw_forward_iterator _Out,
+        _No_throw_sentinel_for<_Out> _OSe>
+        requires (constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>)
+    uninitialized_move_result<_It, _Out> _Uninitialized_move_unchecked(
+        _It _IFirst, _Se _ILast, _Out _OFirst, _OSe _OLast) {
+        constexpr bool _Is_sized1  = sized_sentinel_for<_Se, _It>;
+        constexpr bool _Is_sized2  = sized_sentinel_for<_OSe, _Out>;
+        constexpr bool _Can_memcpy = _Iter_move_cat<_It, _Out>::_Bitcopy_constructible
+                                  && _Sized_or_unreachable_sentinel_for<_Se, _It>
+                                  && _Sized_or_unreachable_sentinel_for<_OSe, _Out>;
+        if constexpr (_Can_memcpy && (_Is_sized1 || _Is_sized2)) {
+            if constexpr (_Is_sized1 && _Is_sized2) {
+                return _RANGES _Copy_memcpy_common(_IFirst, _RANGES next(_IFirst, _STD move(_ILast)), _OFirst,
+                    _RANGES next(_OFirst, _STD move(_OLast)));
+            } else if constexpr (_Is_sized1) {
+                const auto _Dist = _ILast - _IFirst;
+                _STD _Contiguous_iter_verify(_OFirst, static_cast<iter_difference_t<_Out>>(_Dist));
+                return _RANGES _Copy_memcpy_distance(_IFirst, _OFirst, _IFirst, _IFirst + _Dist);
+            } else {
+                _STL_INTERNAL_STATIC_ASSERT(_Is_sized2);
+                const auto _Dist = _OLast - _OFirst;
+                _STD _Contiguous_iter_verify(_IFirst, static_cast<iter_difference_t<_It>>(_Dist));
+                return _RANGES _Copy_memcpy_distance(_IFirst, _OFirst, _OFirst, _OFirst + _Dist);
+            }
+        } else {
+            if constexpr (_Can_memcpy) {
+                // We were eligible for the memcpy optimization above, except for both sentinels being unreachable.
+                // The following classic code is doomed, because no exceptions will end the infinite loop.
+                // Following our usual pattern, let's emit a debug assertion, then run the loop anyways.
+                _STL_ASSERT(false, "Tried to std::uninitialized_move() two ranges with unreachable sentinels");
+            }
+
+            _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+            for (; _IFirst != _ILast && _Backout._Last != _OLast; ++_IFirst) {
+                _Backout._Emplace_back(_RANGES iter_move(_IFirst));
+            }
+
+            return {_STD move(_IFirst), _Backout._Release()};
+        }
+    }
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Alloc>
+class _NODISCARD _Uninitialized_backout_al {
+    // struct to undo partially constructed ranges in _Uninitialized_xxx_al algorithms
+private:
+    using pointer = _Alloc_ptr_t<_Alloc>;
+
+public:
+    _CONSTEXPR20 _Uninitialized_backout_al(pointer _Dest, _Alloc& _Al_) : _First(_Dest), _Last(_Dest), _Al(_Al_) {}
+
+    _Uninitialized_backout_al(const _Uninitialized_backout_al&)            = delete;
+    _Uninitialized_backout_al& operator=(const _Uninitialized_backout_al&) = delete;
+
+    _CONSTEXPR20 ~_Uninitialized_backout_al() {
+        _STD _Destroy_range(_First, _Last, _Al);
+    }
+
+    template <class... _Types>
+    _CONSTEXPR20 void _Emplace_back(_Types&&... _Vals) { // construct a new element at *_Last and increment
+        allocator_traits<_Alloc>::construct(_Al, _STD _Unfancy(_Last), _STD forward<_Types>(_Vals)...);
+        ++_Last;
+    }
+
+    constexpr pointer _Release() { // suppress any exception handling backout and return _Last
+        _First = _Last;
+        return _Last;
+    }
+
+private:
+    pointer _First;
+    pointer _Last;
+    _Alloc& _Al;
+};
+
+template <class _InIt, class _Se, class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
+    _InIt _First, _Se _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
+    // copy [_First, _Last) to raw _Dest, using _Al
+    // note: only called internally from elsewhere in the STL
+    using _Ptrval = typename _Alloc::value_type*;
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    _STD _Adl_verify_range(_First, _Last);
+#endif // ^^^ defined(_ENABLE_STL_INTERNAL_CHECK) ^^^
+
+#if _HAS_CXX20
+    auto _UFirst = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+    auto _ULast  = _RANGES _Unwrap_sent<_InIt>(_STD move(_Last));
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    // In pre-concepts world, _Uninitialized_copy should only ever be called with an iterator
+    // and sentinel of the same type, so `_Get_unwrapped` is fine to call.
+    auto _UFirst = _STD _Get_unwrapped(_STD move(_First));
+    auto _ULast  = _STD _Get_unwrapped(_STD move(_Last));
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    constexpr bool _Can_memcpy = _Sent_copy_cat<decltype(_UFirst), decltype(_ULast), _Ptrval>::_Bitcopy_constructible
+                              && _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>::value;
+
+    if constexpr (_Can_memcpy) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if constexpr (is_same_v<decltype(_UFirst), decltype(_ULast)>) {
+                _STD _Copy_memcpy(_STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _Unfancy(_Dest));
+                _Dest += _ULast - _UFirst;
+            } else {
+                const auto _Count = static_cast<size_t>(_STD _Contiguous_iter_distance(_UFirst, _ULast));
+                _STD _Copy_memcpy_n(_STD _To_address(_UFirst), _Count, _STD _Unfancy(_Dest));
+                _Dest += _Count;
+            }
+            return _Dest;
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Backout._Emplace_back(*_UFirst);
+    }
+
+    return _Backout._Release();
+}
+
+template <class _InIt, class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_copy_n(
+    _InIt _First, size_t _Count, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
+    // copy _First + [0, _Count) to raw _Dest, using _Al
+    // note: only called internally from elsewhere in the STL
+    using _Ptrval = typename _Alloc::value_type*;
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+#else // ^^^ Checking / No checking vvv
+    auto _UFirst = _STD _Get_unwrapped(_STD move(_First));
+#endif // ^^^ No checking ^^^
+
+    constexpr bool _Can_memcpy =
+        conjunction_v<bool_constant<_Iter_copy_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
+            _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>;
+
+    if constexpr (_Can_memcpy) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _STD _Copy_memcpy_n(_UFirst, _Count, _STD _Unfancy(_Dest));
+            _Dest += _Count;
+            return _Dest;
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _Count != 0; ++_UFirst, (void) --_Count) {
+        _Backout._Emplace_back(*_UFirst);
+    }
+
+    return _Backout._Release();
+}
+
+template <class _InIt, class _NoThrowFwdIt>
+_NoThrowFwdIt _Uninitialized_copy_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+    // copy [_First, _Last) to raw [_Dest, ...)
+    if constexpr (_Iter_copy_cat<_InIt, _NoThrowFwdIt>::_Bitcopy_constructible) {
+#if 0 // TRANSITION, _HAS_CXX26
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX26
+        {
+            return _STD _Copy_memcpy(_First, _Last, _Dest);
+        }
+    }
+
+    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
+    for (; _First != _Last; ++_First) {
+        _Backout._Emplace_back_deref(_First);
+    }
+
+    return _Backout._Release();
+}
+
+_EXPORT_STD template <class _InIt, class _NoThrowFwdIt>
+_NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
+    // copy [_First, _Last) to raw [_Dest, ...)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+template <class _InIt, class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_move(
+    const _InIt _First, const _InIt _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
+    // move [_First, _Last) to raw _Dest, using _Al
+    // note: only called internally from elsewhere in the STL
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    _STD _Adl_verify_range(_First, _Last);
+#endif // ^^^ defined(_ENABLE_STL_INTERNAL_CHECK) ^^^
+    using _Ptrval     = typename _Alloc::value_type*;
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (conjunction_v<bool_constant<_Iter_move_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
+                      _Uses_default_construct<_Alloc, _Ptrval, decltype(_STD move(*_UFirst))>>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _STD _Copy_memcpy(_UFirst, _ULast, _STD _Unfancy(_Dest));
+            return _Dest + (_ULast - _UFirst);
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
+    for (; _UFirst != _ULast; ++_UFirst) {
+        _Backout._Emplace_back(_STD move(*_UFirst));
+    }
+
+    return _Backout._Release();
+}
+
+template <class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(
+    _Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, const typename _Alloc::value_type& _Val, _Alloc& _Al) {
+    // copy _Count copies of _Val to raw _First, using _Al
+    using _Ty = typename _Alloc::value_type;
+    if constexpr (_Fill_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _Fill_memset(_Unfancy(_First), _Val, static_cast<size_t>(_Count));
+            return _First + _Count;
+        }
+    } else if constexpr (_Fill_zero_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if (_Is_all_bits_zero(_Val)) {
+                _Fill_zero_memset(_Unfancy(_First), static_cast<size_t>(_Count));
+                return _First + _Count;
+            }
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
+    for (; 0 < _Count; --_Count) {
+        _Backout._Emplace_back(_Val);
+    }
+
+    return _Backout._Release();
+}
+
+_EXPORT_STD template <class _NoThrowFwdIt, class _Tval>
+void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) {
+    // copy _Val throughout raw [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if constexpr (_Fill_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
+        _STD _Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
+    } else {
+        if constexpr (_Fill_zero_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
+            if (_STD _Is_all_bits_zero(_Val)) {
+                _STD _Fill_zero_memset(_UFirst, static_cast<size_t>(_ULast - _UFirst));
+                return;
+            }
+        }
+
+        _Uninitialized_backout<_Unwrapped_t<const _NoThrowFwdIt&>> _Backout{_UFirst};
+        while (_Backout._Last != _ULast) {
+            _Backout._Emplace_back(_Val);
+        }
+
+        _Backout._Release();
+    }
+}
+
+template <class _NoThrowFwdIt>
+constexpr bool _Use_memset_value_construct_v = conjunction_v<bool_constant<_Iterator_is_contiguous<_NoThrowFwdIt>>,
+    is_scalar<_Iter_value_t<_NoThrowFwdIt>>, negation<is_volatile<remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>>>,
+    negation<is_member_pointer<_Iter_value_t<_NoThrowFwdIt>>>>;
+
+template <class _Ptr>
+_Ptr _Zero_range(const _Ptr _First, const _Ptr _Last) { // fill [_First, _Last) with zeroes
+    char* const _First_ch = reinterpret_cast<char*>(_STD _To_address(_First));
+    char* const _Last_ch  = reinterpret_cast<char*>(_STD _To_address(_Last));
+    _CSTD memset(_First_ch, 0, static_cast<size_t>(_Last_ch - _First_ch));
+    return _Last;
+}
+
+template <class _Alloc>
+_CONSTEXPR20 _Alloc_ptr_t<_Alloc> _Uninitialized_value_construct_n(
+    _Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, _Alloc& _Al) {
+    // value-initialize _Count objects to raw _First, using _Al
+    using _Ptrty = typename _Alloc::value_type*;
+    if constexpr (_Use_memset_value_construct_v<_Ptrty> && _Uses_default_construct<_Alloc, _Ptrty>::value) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            auto _PFirst = _Unfancy(_First);
+            _Zero_range(_PFirst, _PFirst + _Count);
+            return _First + _Count;
+        }
+    }
+
+    _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
+    for (; 0 < _Count; --_Count) {
+        _Backout._Emplace_back();
+    }
+
+    return _Backout._Release();
+}
+
+template <class _NoThrowFwdIt, class _Diff>
+_NoThrowFwdIt _Uninitialized_value_construct_n_unchecked1(_NoThrowFwdIt _UFirst, _Diff _Count) {
+    // value-initialize all elements in [_UFirst, _UFirst + _Count)
+    _STL_INTERNAL_CHECK(_Count >= 0);
+    if constexpr (_Use_memset_value_construct_v<_NoThrowFwdIt>) {
+        return _STD _Zero_range(_UFirst, _UFirst + _Count);
+    } else {
+        _Uninitialized_backout<_NoThrowFwdIt> _Backout{_UFirst};
+        for (; 0 < _Count; --_Count) {
+            _Backout._Emplace_back();
+        }
+
+        return _Backout._Release();
+    }
+}
+
+#if _HAS_DEPRECATED_TEMPORARY_BUFFER
+_EXPORT_STD template <class _Ty>
+_CXX17_DEPRECATE_TEMPORARY_BUFFER _NODISCARD pair<_Ty*, ptrdiff_t> get_temporary_buffer(ptrdiff_t _Count) noexcept {
+    return _Get_temporary_buffer<_Ty>(_Count);
+}
+
+_EXPORT_STD template <class _Ty>
+_CXX17_DEPRECATE_TEMPORARY_BUFFER void return_temporary_buffer(_Ty* _Pbuf) {
+    _Return_temporary_buffer(_Pbuf);
+}
+#endif // _HAS_DEPRECATED_TEMPORARY_BUFFER
+
+// The key_type of an (unordered) associative container is cv-unqualified, and we can't bind const Key& to a
+// volatile glvalue. Also, Cpp17CopyInsertable and Cpp17MoveInsertable don't require value-preservation for
+// the construction from a volatile glvalue, so generally we can't perform this optimization for them.
+// See N4993 [container.alloc.reqmts]/2.3, /2.4.
+template <class _Ty>
+using _Remove_const_ref_t = remove_const_t<remove_reference_t<_Ty>>;
+
+// assumes _Args have already been _Remove_const_ref_t'd
+template <class _Key, class... _Args>
+struct _In_place_key_extract_set_impl {
+    // by default we can't extract the key in the emplace family and must construct a node we might not use
+    static constexpr bool _Extractable = false;
+};
+
+template <class _Key>
+struct _In_place_key_extract_set_impl<_Key, _Key> {
+    // we can extract the key in emplace if the emplaced type is identical to the key type
+    static constexpr bool _Extractable = true;
+    static const _Key& _Extract(const _Key& _Val) noexcept {
+        return _Val;
+    }
+};
+
+template <class... _Valtys>
+using _In_place_key_extract_set = _In_place_key_extract_set_impl<_Remove_const_ref_t<_Valtys>...>;
+
+// assumes _Args have already been _Remove_const_ref_t'd
+template <class _Key, class... _Args>
+struct _In_place_key_extract_map_impl {
+    // by default we can't extract the key in the emplace family and must construct a node we might not use
+    static constexpr bool _Extractable = false;
+};
+
+template <class _Key, class _Second>
+struct _In_place_key_extract_map_impl<_Key, _Key, _Second> {
+    // if we would call the pair(key, value) constructor family, we can use the first parameter as the key
+    static constexpr bool _Extractable = true;
+    static const _Key& _Extract(const _Key& _Val, const _Second&) noexcept {
+        return _Val;
+    }
+};
+
+template <class _Key, class _First, class _Second>
+struct _In_place_key_extract_map_impl<_Key, pair<_First, _Second>> {
+    // if we would call the pair(pair<other, other>) constructor family, we can use the pair.first member as the key
+    static constexpr bool _Extractable = is_same_v<_Key, _Remove_const_ref_t<_First>>;
+    static const _Key& _Extract(const pair<_First, _Second>& _Val) noexcept {
+        return _Val.first;
+    }
+};
+
+#if _HAS_CXX23
+// if we would call the pair(pair-like) constructor family and the argument is not a subrange,
+// we can use get<0>(pair-like) as the key
+
+template <class _Key, class _Elem>
+struct _In_place_key_extract_map_impl<_Key, array<_Elem, 2>> {
+    static constexpr bool _Extractable = is_same_v<_Key, remove_const_t<_Elem>>;
+    static const _Key& _Extract(const array<_Elem, 2>& _Val) noexcept {
+        return _Val[0];
+    }
+};
+
+template <class _Key, class _First, class _Second>
+struct _In_place_key_extract_map_impl<_Key, tuple<_First, _Second>> {
+    static constexpr bool _Extractable = is_same_v<_Key, _Remove_const_ref_t<_First>>;
+    static const _Key& _Extract(const tuple<_First, _Second>& _Val) noexcept {
+        return _STD get<0>(_Val);
+    }
+};
+#endif // _HAS_CXX23
+
+template <class _Key, class _First, class... _RestTypes>
+struct _In_place_key_extract_map_impl<_Key, piecewise_construct_t, tuple<_First>, tuple<_RestTypes...>> {
+    // if we would call the piecewise_construct_t constructor and the first argument is a 1-tuple,
+    // we can use get<0>(first_tuple) as the key
+    static constexpr bool _Extractable = is_same_v<_Key, _Remove_const_ref_t<_First>>;
+    static const _Key& _Extract(
+        const piecewise_construct_t&, const tuple<_First>& _Tup_val, const tuple<_RestTypes...>&) noexcept {
+        return _STD get<0>(_Tup_val);
+    }
+};
+
+template <class... _Valtys>
+using _In_place_key_extract_map = _In_place_key_extract_map_impl<_Remove_const_ref_t<_Valtys>...>;
+
+#pragma warning(push)
+#pragma warning(disable : 4624) // '%s': destructor was implicitly defined as deleted
+template <class _Ty>
+struct _Wrap {
+    _Ty _Value; // workaround for VSO-586813 "T^ is not allowed in a union"
+};
+#pragma warning(pop)
+
+template <class _Alloc>
+struct _Alloc_temporary2 {
+    using value_type = typename _Alloc::value_type;
+    using _Traits    = allocator_traits<_Alloc>;
+
+    _Alloc& _Al;
+
+#ifdef __cplusplus_winrt
+    union {
+        _Wrap<value_type> _Storage;
+    };
+
+    _NODISCARD _CONSTEXPR20 value_type& _Get_value() noexcept {
+        return _Storage._Value;
+    }
+
+    _NODISCARD _CONSTEXPR20 const value_type& _Get_value() const noexcept {
+        return _Storage._Value;
+    }
+#else // ^^^ workaround for VSO-586813 "T^ is not allowed in a union" / no workaround vvv
+    union {
+        value_type _Value;
+    };
+
+    _NODISCARD _CONSTEXPR20 value_type& _Get_value() noexcept {
+        return _Value;
+    }
+
+    _NODISCARD _CONSTEXPR20 const value_type& _Get_value() const noexcept {
+        return _Value;
+    }
+#endif // ^^^ no workaround ^^^
+
+    template <class... _Args>
+    _CONSTEXPR20 explicit _Alloc_temporary2(_Alloc& _Al_, _Args&&... _Vals)
+        noexcept(noexcept(_Traits::construct(_Al_, _STD addressof(_Get_value()), _STD forward<_Args>(_Vals)...)))
+        : _Al(_Al_) {
+        _Traits::construct(_Al, _STD addressof(_Get_value()), _STD forward<_Args>(_Vals)...);
+    }
+
+    _Alloc_temporary2(const _Alloc_temporary2&)            = delete;
+    _Alloc_temporary2& operator=(const _Alloc_temporary2&) = delete;
+
+    _CONSTEXPR20 ~_Alloc_temporary2() {
+        _Traits::destroy(_Al, _STD addressof(_Get_value()));
+    }
+};
+
+template <class _Alloc>
+_NODISCARD constexpr bool _Allocators_equal(const _Alloc& _Lhs, const _Alloc& _Rhs) noexcept {
+    if constexpr (allocator_traits<_Alloc>::is_always_equal::value) {
+        return true;
+    } else {
+        return _Lhs == _Rhs;
+    }
+}
+
+#if _HAS_CXX23
+template <class _Ty>
+constexpr bool _Has_member_from_primary = requires { typename _Ty::_From_primary; };
+
+// Avoid using allocate_at_least when the allocator publicly derives from std::allocator:
+// "old" allocators might hide allocate and deallocate but fail to hide allocate_at_least.
+// Also avoid using allocate_at_least from std::allocator itself because it currently doesn't do anything useful.
+template <class _Alloc>
+constexpr bool _Should_allocate_at_least =
+    !_Has_member_from_primary<_Alloc>
+    && _Has_member_allocate_at_least<_Alloc, typename allocator_traits<_Alloc>::size_type>;
+#endif // _HAS_CXX23
+
+template <class _Alloc>
+_NODISCARD_RAW_PTR_ALLOC _CONSTEXPR20 typename allocator_traits<_Alloc>::pointer _Allocate_at_least_helper(
+    _Alloc& _Al, _CRT_GUARDOVERFLOW typename allocator_traits<_Alloc>::size_type& _Count) {
+#if _HAS_CXX23
+    if constexpr (_Should_allocate_at_least<_Alloc>) {
+        auto [_Ptr, _Allocated] = _Al.allocate_at_least(_Count);
+        _Count                  = _Allocated;
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-11060638
+        return _Ptr + decltype(_Ptr - _Ptr){0};
+#else // ^^^ workaround / no workaround vvv
+        return _Ptr;
+#endif // ^^^ no workaround ^^^
+    } else
+#endif // _HAS_CXX23
+    {
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-11060638
+        using _Pointer = decltype(_Al.allocate(_Count));
+        return _Al.allocate(_Count) + decltype(_Pointer{} - _Pointer{}){0};
+#else // ^^^ workaround / no workaround vvv
+        return _Al.allocate(_Count);
+#endif // ^^^ no workaround ^^^
+    }
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
+    // remove each matching _Val
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    _UFirst           = _STD _Find_unchecked(_UFirst, _ULast, _Val);
+    auto _UNext       = _UFirst;
+    if (_UFirst != _ULast) {
+#if _VECTORIZED_REMOVE
+        if constexpr (_Vector_alg_in_find_is_safe<decltype(_UFirst), _Ty>) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                const auto _First_ptr = _STD _To_address(_UFirst);
+                const auto _Result    = _STD _Remove_vectorized(_First_ptr, _STD _To_address(_ULast), _Val);
+
+                if constexpr (is_pointer_v<decltype(_UNext)>) {
+                    _UNext = _Result;
+                } else {
+                    _UNext += static_cast<_Iter_diff_t<decltype(_UNext)>>(_Result - _First_ptr);
+                }
+
+                _STD _Seek_wrapped(_First, _UNext);
+                return _First;
+            }
+        }
+#endif // ^^^ _VECTORIZED_REMOVE ^^^
+
+        while (++_UFirst != _ULast) {
+            if (!(*_UFirst == _Val)) {
+                *_UNext = _STD move(*_UFirst);
+                ++_UNext;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UNext);
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD_REMOVE_ALG _CONSTEXPR20 _FwdIt remove_if(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
+    // remove each satisfying _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    _UFirst           = _STD find_if(_UFirst, _ULast, _STD _Pass_fn(_Pred));
+    auto _UNext       = _UFirst;
+    if (_UFirst != _ULast) {
+        while (++_UFirst != _ULast) {
+            if (!_Pred(*_UFirst)) {
+                *_UNext = _STD move(*_UFirst);
+                ++_UNext;
+            }
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UNext);
+    return _First;
+}
+
+template <class _Container, class _Uty>
+_CONSTEXPR20 typename _Container::size_type _Erase_remove(_Container& _Cont, const _Uty& _Val) {
+    // erase each element matching _Val
+    auto _First          = _Cont.begin();
+    const auto _Last     = _Cont.end();
+    const auto _Old_size = _Cont.size();
+    _STD _Seek_wrapped(_First, _STD remove(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _Val));
+    _Cont.erase(_First, _Last);
+    return static_cast<typename _Container::size_type>(_Old_size - _Cont.size());
+}
+
+template <class _Container, class _Pr>
+_CONSTEXPR20 typename _Container::size_type _Erase_remove_if(_Container& _Cont, _Pr _Pred) {
+    // erase each element satisfying _Pred
+    auto _First          = _Cont.begin();
+    const auto _Last     = _Cont.end();
+    const auto _Old_size = _Cont.size();
+    _STD _Seek_wrapped(_First, _STD remove_if(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _Pred));
+    _Cont.erase(_First, _Last);
+    return static_cast<typename _Container::size_type>(_Old_size - _Cont.size());
+}
+
+template <class _Container, class _Pr>
+typename _Container::size_type _Erase_nodes_if(_Container& _Cont, _Pr _Pred) {
+    // erase each element satisfying _Pred
+    auto _First          = _Cont.begin();
+    const auto _Last     = _Cont.end();
+    const auto _Old_size = _Cont.size();
+    while (_First != _Last) {
+        if (_Pred(*_First)) {
+            _First = _Cont.erase(_First);
+        } else {
+            ++_First;
+        }
+    }
+    return _Old_size - _Cont.size();
+}
+
+template <class _Ty1, class _Ty2>
+void _Deduce_as_pair(const pair<_Ty1, _Ty2>&); // not defined
+
+template <class _Ty, class = void>
+constexpr bool _Is_deducible_as_pair = false;
+
+template <class _Ty>
+constexpr bool _Is_deducible_as_pair<_Ty, decltype(_STD _Deduce_as_pair(_STD declval<_Ty>()))> = true;
+
+template <class _Ty>
+constexpr bool _Is_cv_pair = _Is_specialization_v<remove_cv_t<_Ty>, pair>;
+
+template <class _Ty>
+const _Ty& _Normally_bind(_Identity_t<const _Ty&>); // not defined
+
+template <class _Ty>
+_Ty&& _Normally_bind(_Identity_t<_Ty&&>); // not defined
+
+template <class _Ty, class _Uty>
+using _Normally_bound_ref = decltype(_STD _Normally_bind<_Ty>(_STD declval<_Uty>()));
+
+template <class _Ty, class _Uty, class = void>
+constexpr bool _Is_normally_bindable = false;
+
+template <class _Ty, class _Uty>
+constexpr bool _Is_normally_bindable<_Ty, _Uty, void_t<_Normally_bound_ref<_Ty, _Uty>>> = true;
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Cv_std_pair = _Is_cv_pair<_Ty>;
+
+template <class _Ty>
+concept _Usable_for_pair_like_overload =
+#if _HAS_CXX23
+    _Pair_like<_Ty> ||
+#endif // _HAS_CXX23
+    !_Is_deducible_as_pair<_Ty&>;
+
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
+    requires (!_Is_cv_pair<_Ty>)
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Types&&... _Args) noexcept {
+    if constexpr (!uses_allocator_v<remove_cv_t<_Ty>, _Alloc>) {
+        static_assert(is_constructible_v<_Ty, _Types...>,
+            "If uses_allocator_v<remove_cv_t<T>, Alloc> is false, "
+            "T must be constructible from (Types...). (N4981 [allocator.uses.construction]/5)");
+        (void) _Al;
+        return _STD forward_as_tuple(_STD forward<_Types>(_Args)...);
+    } else if constexpr (is_constructible_v<_Ty, allocator_arg_t, const _Alloc&, _Types...>) {
+        using _ReturnType = tuple<allocator_arg_t, const _Alloc&, _Types&&...>;
+        return _ReturnType{allocator_arg, _Al, _STD forward<_Types>(_Args)...};
+    } else if constexpr (is_constructible_v<_Ty, _Types..., const _Alloc&>) {
+        return _STD forward_as_tuple(_STD forward<_Types>(_Args)..., _Al);
+    } else {
+        static_assert(false, "If uses_allocator_v<remove_cv_t<T>, Alloc> is true, "
+                             "T must be constructible from either (allocator_arg_t, const Alloc&, Types...) "
+                             "or (Types..., const Alloc&). (N4981 [allocator.uses.construction]/5)");
+    }
+}
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al) noexcept;
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept;
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>& _Pair) noexcept;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, const pair<_Uty1, _Uty2>& _Pair) noexcept;
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept;
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(
+    const _Alloc& _Al, const pair<_Uty1, _Uty2>&& _Pair) noexcept;
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, _Usable_for_pair_like_overload _Uty>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty&& _Ux) noexcept;
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Tuple1, class _Tuple2>
+_NODISCARD constexpr auto uses_allocator_construction_args(
+    const _Alloc& _Al, piecewise_construct_t, _Tuple1&& _Tup1, _Tuple2&& _Tup2) noexcept {
+    return _STD make_tuple(piecewise_construct,
+        _STD apply(
+            [&_Al](auto&&... _Tuple_args) {
+                return _STD uses_allocator_construction_args<typename _Ty::first_type>(
+                    _Al, _STD forward<decltype(_Tuple_args)>(_Tuple_args)...);
+            },
+            _STD forward<_Tuple1>(_Tup1)),
+        _STD apply(
+            [&_Al](auto&&... _Tuple_args) {
+                return _STD uses_allocator_construction_args<typename _Ty::second_type>(
+                    _Al, _STD forward<decltype(_Tuple_args)>(_Tuple_args)...);
+            },
+            _STD forward<_Tuple2>(_Tup2)));
+}
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct, tuple<>{}, tuple<>{});
+    return _STD make_tuple(piecewise_construct, _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al));
+}
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_STD forward<_Uty1>(_Val1)), _STD forward_as_tuple(_STD forward<_Uty2>(_Val2)));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _STD forward<_Uty1>(_Val1)),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _STD forward<_Uty2>(_Val2)));
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>& _Pair) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_Pair.first), _STD forward_as_tuple(_Pair.second));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _Pair.first),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _Pair.second));
+}
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(
+    const _Alloc& _Al, const pair<_Uty1, _Uty2>& _Pair) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_Pair.first), _STD forward_as_tuple(_Pair.second));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _Pair.first),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _Pair.second));
+}
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_STD get<0>(_STD move(_Pair)), _STD forward_as_tuple(_STD get<1>(_STD move(_Pair)));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _STD get<0>(_STD move(_Pair))),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _STD get<1>(_STD move(_Pair))));
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, class _Uty1, class _Uty2>
+_NODISCARD constexpr auto uses_allocator_construction_args(
+    const _Alloc& _Al, const pair<_Uty1, _Uty2>&& _Pair) noexcept {
+    // equivalent to
+    // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+    //     _STD forward_as_tuple(_STD get<0>(_STD move(_Pair)), _STD forward_as_tuple(_STD get<1>(_STD move(_Pair)));
+    return _STD make_tuple(piecewise_construct,
+        _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _STD get<0>(_STD move(_Pair))),
+        _STD uses_allocator_construction_args<typename _Ty::second_type>(_Al, _STD get<1>(_STD move(_Pair))));
+}
+#endif // _HAS_CXX23
+
+_EXPORT_STD template <_Cv_std_pair _Ty, class _Alloc, _Usable_for_pair_like_overload _Uty>
+_NODISCARD constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty&& _Ux) noexcept {
+#if _HAS_CXX23
+    if constexpr (_Pair_like_non_subrange<_Uty>) {
+        // equivalent to
+        // return _STD uses_allocator_construction_args<_Ty>(_Al, piecewise_construct,
+        //     _STD forward_as_tuple(_STD get<0>(_STD forward<_Uty>(_Ux)),
+        //     _STD forward_as_tuple(_STD get<1>(_STD forward<_Uty>(_Ux)));
+        return _STD make_tuple(piecewise_construct,
+            _STD uses_allocator_construction_args<typename _Ty::first_type>(_Al, _STD get<0>(_STD forward<_Uty>(_Ux))),
+            _STD uses_allocator_construction_args<typename _Ty::second_type>(
+                _Al, _STD get<1>(_STD forward<_Uty>(_Ux))));
+    } else
+#endif // _HAS_CXX23
+    {
+        struct _Pair_remaker {
+            const _Alloc& _Al;
+            _Uty& _Ux;
+
+            constexpr operator remove_cv_t<_Ty>() const {
+                using _Pair_t = remove_cv_t<_Ty>;
+                static_assert(_Is_normally_bindable<_Pair_t, _Uty>,
+                    "The argument must be bindable to a reference to the std::pair type.");
+
+                using _Pair_first_t   = _Pair_t::first_type;
+                using _Pair_second_t  = _Pair_t::second_type;
+                using _Pair_ref_t     = _Normally_bound_ref<_Pair_t, _Uty>;
+                _Pair_ref_t _Pair_ref = _STD forward<_Uty>(_Ux);
+                if constexpr (is_same_v<_Pair_ref_t, const _Pair_t&>) {
+                    // equivalent to
+                    // return _STD make_obj_using_allocator<_Pair_t>(_Al, _Pair_ref);
+                    return _Pair_t{piecewise_construct,
+                        _STD uses_allocator_construction_args<_Pair_first_t>(_Al, _Pair_ref.first),
+                        _STD uses_allocator_construction_args<_Pair_second_t>(_Al, _Pair_ref.second)};
+                } else {
+                    // equivalent to
+                    // return _STD make_obj_using_allocator<_Pair_t>(_Al, _STD move(_Pair_ref));
+                    return _Pair_t{piecewise_construct,
+                        _STD uses_allocator_construction_args<_Pair_first_t>(_Al, _STD get<0>(_STD move(_Pair_ref))),
+                        _STD uses_allocator_construction_args<_Pair_second_t>(_Al, _STD get<1>(_STD move(_Pair_ref)))};
+                }
+            }
+        };
+
+        // equivalent to
+        // return _STD make_tuple(_Pair_remaker{_Al, _Ux});
+        return tuple<_Pair_remaker>({_Al, _Ux});
+    }
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
+_NODISCARD constexpr _Ty make_obj_using_allocator(const _Alloc& _Al, _Types&&... _Args) {
+    return _STD make_from_tuple<_Ty>(_STD uses_allocator_construction_args<_Ty>(_Al, _STD forward<_Types>(_Args)...));
+}
+
+_EXPORT_STD template <class _Ty, class _Alloc, class... _Types>
+constexpr _Ty* uninitialized_construct_using_allocator(_Ty* _Ptr, const _Alloc& _Al, _Types&&... _Args) {
+    return _STD apply(
+        [&](auto&&... _Construct_args) {
+            return _STD construct_at(_Ptr, _STD forward<decltype(_Construct_args)>(_Construct_args)...);
+        },
+        _STD uses_allocator_construction_args<_Ty>(_Al, _STD forward<_Types>(_Args)...));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+_EXPORT_STD struct from_range_t {
+    explicit from_range_t() = default;
+};
+_EXPORT_STD inline constexpr from_range_t from_range;
+
+template <class _Rng, class _Elem>
+concept _Container_compatible_range =
+    (_RANGES input_range<_Rng>) && convertible_to<_RANGES range_reference_t<_Rng>, _Elem>;
+
+template <_RANGES input_range _Rng>
+using _Range_key_type = remove_const_t<typename _RANGES range_value_t<_Rng>::first_type>;
+
+template <_RANGES input_range _Rng>
+using _Range_mapped_type = _RANGES range_value_t<_Rng>::second_type;
+
+template <_RANGES input_range _Rng>
+using _Range_to_alloc_type =
+    pair<const typename _RANGES range_value_t<_Rng>::first_type, typename _RANGES range_value_t<_Rng>::second_type>;
+#endif // _HAS_CXX23
+
+template <class _Ty,
+    bool = is_empty_v<_Ty> && !is_final_v<_Ty>>
+class _Ebco_base : private _Ty { // Empty Base Class Optimization, active
+private:
+    using _Mybase = _Ty; // for visualization
+
+protected:
+    template <class _Other, enable_if_t<!is_same_v<_Remove_cvref_t<_Other>, _Ebco_base>, int> = 0>
+    constexpr explicit _Ebco_base(_Other&& _Val) noexcept(is_nothrow_constructible_v<_Ty, _Other>)
+        : _Ty(_STD forward<_Other>(_Val)) {}
+
+    constexpr _Ty& _Get_val() noexcept {
+        return *this;
+    }
+
+    constexpr const _Ty& _Get_val() const noexcept {
+        return *this;
+    }
+};
+
+template <class _Ty>
+class _Ebco_base<_Ty, false> { // Empty Base Class Optimization, inactive
+private:
+    _Ty _Myval;
+
+protected:
+    template <class _Other, enable_if_t<!is_same_v<_Remove_cvref_t<_Other>, _Ebco_base>, int> = 0>
+    constexpr explicit _Ebco_base(_Other&& _Val) noexcept(is_nothrow_constructible_v<_Ty, _Other>)
+        : _Myval(_STD forward<_Other>(_Val)) {}
+
+    constexpr _Ty& _Get_val() noexcept {
+        return _Myval;
+    }
+
+    constexpr const _Ty& _Get_val() const noexcept {
+        return _Myval;
+    }
+};
+
+_EXPORT_STD inline void* align(size_t _Bound, size_t _Size, void*& _Ptr, size_t& _Space) noexcept /* strengthened */ {
+    // try to carve out _Size bytes on boundary _Bound
+    size_t _Off = static_cast<size_t>(reinterpret_cast<uintptr_t>(_Ptr) & (_Bound - 1));
+    if (_Off != 0) {
+        _Off = _Bound - _Off; // number of bytes to skip
+    }
+
+    if (_Space < _Off || _Space - _Off < _Size) {
+        return nullptr;
+    }
+
+    // enough room, update
+    _Ptr = static_cast<char*>(_Ptr) + _Off;
+    _Space -= _Off;
+    return _Ptr;
+}
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Transparent = requires { typename _Ty::is_transparent; };
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+namespace ranges {
+#if defined(__cpp_lib_byte)
+    _EXPORT_STD template <range _Rng, class _Alloc = allocator<byte>>
+#else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
+    _EXPORT_STD template <range _Rng, class _Alloc>
+#endif // ^^^ !defined(__cpp_lib_byte) ^^^
+    struct elements_of {
+        _MSVC_NO_UNIQUE_ADDRESS _Rng range;
+        _MSVC_NO_UNIQUE_ADDRESS _Alloc allocator{};
+    };
+
+#if defined(__cpp_lib_byte)
+    template <class _Rng, class _Alloc = allocator<byte>>
+    elements_of(_Rng&&, _Alloc = _Alloc()) -> elements_of<_Rng&&, _Alloc>;
+#else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
+    template <class _Rng, class _Alloc>
+    elements_of(_Rng&&, _Alloc) -> elements_of<_Rng&&, _Alloc>;
+#endif // ^^^ !defined(__cpp_lib_byte) ^^^
+} // namespace ranges
+
+template <class>
+constexpr bool _Has_guaranteed_push_back = false; // N5032 [sequence.reqmts]/104, /108; used by flat_(multi)map::insert.
+
+// N5032 [container.reqmts]/66.1; used by various flat_(multi)set inserting functions.
+template <class _Ty>
+constexpr bool _Has_guaranteed_single_insertion = _Has_guaranteed_push_back<_Ty>;
+
+template <class>
+constexpr bool _Has_guaranteed_append_range = false; // N5032 [sequence.reqmts]/112; used by flat_(multi)set::insert.
+#endif // _HAS_CXX23
+
+template <class _Elem, class _UTy>
+_NODISCARD _Elem* _UIntegral_to_buff(_Elem* _RNext, _UTy _UVal) { // used by both to_string and thread::id output
+    // format _UVal into buffer *ending at* _RNext
+    static_assert(is_unsigned_v<_UTy>, "_UTy must be unsigned");
+
+#ifdef _WIN64
+    auto _UVal_trunc = _UVal;
+#else // ^^^ 64-bit / 32-bit vvv
+
+    if constexpr (sizeof(_UTy) > 4) { // For 64-bit numbers, work in chunks to avoid 64-bit divisions.
+        while (_UVal > 0xFFFFFFFFU) {
+            auto _UVal_chunk = static_cast<unsigned long>(_UVal % 100000000);
+            _UVal /= 100000000;
+
+            for (int _Idx = 0; _Idx != 3; ++_Idx) {
+                const unsigned long _UVal_chunk_part = _UVal_chunk % 100;
+                _UVal_chunk /= 100;
+                _RNext -= 2;
+                _CSTD memcpy(_RNext, _Digit_pairs<_Elem>._Data[_UVal_chunk_part], 2 * sizeof(_Elem));
+            }
+
+            _RNext -= 2;
+            _CSTD memcpy(_RNext, _Digit_pairs<_Elem>._Data[_UVal_chunk], 2 * sizeof(_Elem));
+        }
+    }
+
+    auto _UVal_trunc = static_cast<unsigned long>(_UVal);
+#endif // ^^^ 32-bit ^^^
+
+    // If we have a single digit, print [0, 9] and return. (This is necessary to correctly handle 0.)
+    if (_UVal_trunc < 10) {
+        *--_RNext = static_cast<_Elem>('0' + _UVal_trunc);
+        return _RNext;
+    }
+
+    // Print one or more pairs of digits.
+    do {
+        const auto _UVal_trunc_part = static_cast<unsigned long>(_UVal_trunc % 100);
+        _UVal_trunc /= 100;
+        _RNext -= 2;
+        _CSTD memcpy(_RNext, _Digit_pairs<_Elem>._Data[_UVal_trunc_part], 2 * sizeof(_Elem));
+    } while (_UVal_trunc >= 10);
+
+    // If we have an unpaired digit, print it. For example, 1729 is printed as 17 29, and 19937 is printed as 1 99 37.
+    if (_UVal_trunc != 0) {
+        *--_RNext = static_cast<_Elem>('0' + _UVal_trunc);
+    }
+
+    return _RNext;
+}
+_STD_END
+
+#if _HAS_CXX17
+#define _ADAPTOR_EMPLACE_RETURN decltype(auto)
+#else // ^^^ _HAS_CXX17 ^^^ / vvv !_HAS_CXX17 vvv
+#define _ADAPTOR_EMPLACE_RETURN void
+#endif // ^^^ !_HAS_CXX17 ^^^
+
+#if _HAS_CXX17
+#define _CONTAINER_EMPLACE_RETURN reference
+#else // ^^^ _HAS_CXX17 ^^^ / vvv !_HAS_CXX17 vvv
+#define _CONTAINER_EMPLACE_RETURN void
+#endif // ^^^ !_HAS_CXX17 ^^^
+
+#if _HAS_CXX20
+#define _LIST_REMOVE_RETURN size_type
+#else // ^^^ _HAS_CXX20 ^^^ / vvv !_HAS_CXX20 vvv
+#define _LIST_REMOVE_RETURN void
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XMEMORY_
diff --git a/msvc-stl/stl/inc/xnode_handle.h b/msvc-stl/stl/inc/xnode_handle.h
new file mode 100644
index 0000000..2462a50
--- /dev/null
+++ b/msvc-stl/stl/inc/xnode_handle.h
@@ -0,0 +1,216 @@
+// xnode_handle.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XNODE_HANDLE_H
+#define _XNODE_HANDLE_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX17
+#error Node handles are only available with C++17. (Also, you should not include this internal header.)
+#endif // _HAS_CXX17
+
+#include <xmemory>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+_STD_BEGIN
+
+template <class _Iterator, class _NodeType>
+struct _Insert_return_type {
+    _Iterator position;
+    bool inserted;
+    _NodeType node;
+};
+
+template <class _Derived_type, class _KeyTy, class _ValueTy>
+struct _Node_handle_map_base { // map-specific node handle behavior
+    using key_type    = _KeyTy;
+    using mapped_type = _ValueTy;
+
+    key_type& key() const noexcept /* strengthened */ {
+        return _Datum().first;
+    }
+    mapped_type& mapped() const noexcept /* strengthened */ {
+        return _Datum().second;
+    }
+
+private:
+    using _Pair_type = pair<key_type, mapped_type>;
+    _Pair_type& _Datum() const {
+        const auto& _Self = static_cast<const _Derived_type&>(*this);
+        auto& _Data       = _Self._Getptr()->_Myval;
+        // NB: Node handle requires formally-undefined behavior *somewhere*, this
+        // implementation chooses to type-pun pair<const K, T> as pair<K, T>.
+        return reinterpret_cast<_Pair_type&>(_Data);
+    }
+};
+
+template <class _Derived_type, class _ValueTy>
+struct _Node_handle_set_base { // set-specific node handle behavior
+    using value_type = _ValueTy;
+
+    value_type& value() const noexcept /* strengthened */ {
+        const auto& _Self = static_cast<const _Derived_type&>(*this);
+        return _Self._Getptr()->_Myval;
+    }
+};
+
+template <class _Node, class _Alloc, template <class...> class _Base, class... _Types>
+class _Node_handle : public _Base<_Node_handle<_Node, _Alloc, _Base, _Types...>, _Types...> {
+    // storage for a node from one of the node-based standard containers
+public:
+    using allocator_type = _Alloc;
+
+private:
+    using _Alty_traits   = allocator_traits<_Alloc>;
+    using _Alnode        = _Rebind_alloc_t<_Alloc, _Node>;
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using _Nodeptr       = typename _Alnode_traits::pointer;
+
+    _Nodeptr _Ptr{};
+    _Aligned_storage_t<sizeof(_Alloc), alignof(_Alloc)>
+        _Alloc_storage; // Invariant: contains a live _Alloc iff _Ptr != nullptr
+
+    void _Clear() noexcept { // destroy any contained node and return to the empty state
+        if (_Ptr != nullptr) {
+            _Alloc& _Al = _Getal();
+            _Alty_traits::destroy(_Al, _STD addressof(_Ptr->_Myval));
+            _Alnode _Node_alloc{_Al};
+            _Node::_Freenode0(_Node_alloc, _Ptr);
+            _Destroy_in_place(_Al);
+            _Ptr = nullptr;
+        }
+    }
+
+    _Node_handle(const _Nodeptr _Ptr_, const _Alloc& _Al) noexcept
+        : _Ptr{_Ptr_} { // Initialize a _Node_handle that holds the specified node
+                        // pre: _Alloc can release _Ptr
+        _STL_INTERNAL_CHECK(_Ptr_ != nullptr);
+        _Construct_in_place(_Getal(), _Al);
+    }
+
+public:
+    constexpr _Node_handle() noexcept : _Alloc_storage{} {}
+
+    ~_Node_handle() noexcept {
+        _Clear();
+    }
+
+    _Node_handle(_Node_handle&& _That) noexcept : _Ptr{_That._Ptr} { // steal node and allocator (if any) from _That
+        if (_Ptr != nullptr) {
+            _That._Ptr       = nullptr;
+            _Alloc& _That_al = _That._Getal();
+            _Construct_in_place(_Getal(), _STD move(_That_al));
+            _Destroy_in_place(_That_al);
+        }
+    }
+
+    _Node_handle& operator=(_Node_handle&& _That) noexcept /* strengthened */ {
+        // steal state from _That
+        if (_Ptr == nullptr) {
+            if (_That._Ptr != nullptr) {
+                _Alloc& _That_al = _That._Getal();
+                _Construct_in_place(_Getal(), _STD move(_That_al));
+                _Destroy_in_place(_That_al);
+                _Ptr = _STD exchange(_That._Ptr, nullptr);
+            }
+
+            return *this;
+        }
+
+        if (_That._Ptr == nullptr || this == _STD addressof(_That)) {
+            _Clear();
+            return *this;
+        }
+
+        _Alloc& _Al = _Getal();
+        _Alty_traits::destroy(_Al, _STD addressof(_Ptr->_Myval));
+        _Alnode _Node_alloc{_Al};
+        _Alnode_traits::deallocate(_Node_alloc, _Ptr, 1);
+
+        _Alloc& _That_al = _That._Getal();
+        _Pocma(_Al, _That_al);
+        _Destroy_in_place(_That_al);
+
+        _Ptr = _STD exchange(_That._Ptr, nullptr);
+        return *this;
+    }
+
+    _Nodeptr _Getptr() const noexcept {
+        return _Ptr;
+    }
+
+    _Alloc& _Getal() noexcept {
+        return reinterpret_cast<_Alloc&>(_Alloc_storage);
+    }
+    const _Alloc& _Getal() const noexcept {
+        _STL_INTERNAL_CHECK(!empty());
+        return reinterpret_cast<const _Alloc&>(_Alloc_storage);
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept /* strengthened */ {
+        _STL_INTERNAL_CHECK(!empty());
+        return _Getal();
+    }
+
+    explicit operator bool() const noexcept {
+        return _Ptr != nullptr;
+    }
+
+    _NODISCARD bool empty() const noexcept {
+        return _Ptr == nullptr;
+    }
+
+    _Nodeptr _Release() noexcept { // extract the node from *this
+        _STL_INTERNAL_CHECK(!empty());
+        _Destroy_in_place(_Getal());
+        return _STD exchange(_Ptr, nullptr);
+    }
+
+    void swap(_Node_handle& _That) noexcept /* strengthened */ {
+        using _STD swap;
+        if (_Ptr != nullptr) {
+            if (_That._Ptr != nullptr) {
+                _Pocs(_Getal(), _That._Getal());
+            } else {
+                _Alloc& _Al = _Getal();
+                _Construct_in_place(_That._Getal(), _STD move(_Al));
+                _Destroy_in_place(_Al);
+            }
+        } else {
+            if (_That._Ptr == nullptr) {
+                return;
+            }
+
+            _Alloc& _That_al = _That._Getal();
+            _Construct_in_place(_Getal(), _STD move(_That_al));
+            _Destroy_in_place(_That_al);
+        }
+        swap(_Ptr, _That._Ptr); // intentional ADL
+    }
+    friend void swap(_Node_handle& _Left, _Node_handle& _Right) noexcept /* strengthened */ {
+        _Left.swap(_Right);
+    }
+
+    static _Node_handle _Make(const _Nodeptr _Ptr, const allocator_type& _Al) {
+        // initialize a _Node_handle that holds _Ptr and _Al
+        // pre: _Al can release _Ptr
+        _STL_INTERNAL_CHECK(_Ptr != nullptr);
+        return _Node_handle{_Ptr, _Al};
+    }
+};
+
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XNODE_HANDLE_H
diff --git a/msvc-stl/stl/inc/xpolymorphic_allocator.h b/msvc-stl/stl/inc/xpolymorphic_allocator.h
new file mode 100644
index 0000000..6aa2294
--- /dev/null
+++ b/msvc-stl/stl/inc/xpolymorphic_allocator.h
@@ -0,0 +1,369 @@
+// xpolymorphic_allocator.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XPOLYMORPHIC_ALLOCATOR_H
+#define _XPOLYMORPHIC_ALLOCATOR_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <xmemory>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+#if !_HAS_CXX20
+template <class _Ty, class _Outer_alloc, class _Inner_alloc, class... _Types>
+void _Uses_alloc_construct_non_pair(
+    _Ty* const _Ptr, _Outer_alloc& _Outer, const _Inner_alloc& _Inner, _Types&&... _Args) {
+    // uses-allocator construction of *_Ptr by alloc _Outer propagating alloc _Inner, non-pair case
+    if constexpr (uses_allocator_v<remove_cv_t<_Ty>, _Inner_alloc>) {
+        if constexpr (is_constructible_v<_Ty, allocator_arg_t, const _Inner_alloc&, _Types...>) {
+            allocator_traits<_Outer_alloc>::construct(
+                _Outer, _Ptr, allocator_arg_t{}, _Inner, _STD forward<_Types>(_Args)...);
+        } else {
+            static_assert(is_constructible_v<_Ty, _Types..., const _Inner_alloc&>,
+                "N4659 [allocator.uses.construction]/1 (as modified by LWG-3187 and LWG-3677) requires "
+                "is_constructible_v<T, Args..., const Alloc&> when uses_allocator_v<remove_cv_t<T>, Alloc> is true and "
+                "is_constructible_v<T, allocator_arg_t, const Alloc&, Args...> is false");
+            allocator_traits<_Outer_alloc>::construct(_Outer, _Ptr, _STD forward<_Types>(_Args)..., _Inner);
+        }
+    } else {
+        static_assert(is_constructible_v<_Ty, _Types...>,
+            "N4659 [allocator.uses.construction]/1.1 (as modified by LWG-3677) requires is_constructible_v<T, Args...> "
+            "when uses_allocator_v<remove_cv_t<T>, Alloc> is false");
+        allocator_traits<_Outer_alloc>::construct(_Outer, _Ptr, _STD forward<_Types>(_Args)...);
+    }
+}
+
+template <class _Ty, class _Alloc, class... _Types>
+decltype(auto) _Uses_alloc_piecewise(const _Alloc& _Al, tuple<_Types...>&& _Tuple) {
+    if constexpr (uses_allocator_v<remove_cv_t<_Ty>, _Alloc>) {
+        if constexpr (is_constructible_v<_Ty, allocator_arg_t, const _Alloc&, _Types...>) {
+            return _STD tuple_cat(tuple<allocator_arg_t, const _Alloc&>(allocator_arg, _Al), _STD move(_Tuple));
+        } else {
+            return _STD tuple_cat(_STD move(_Tuple), tuple<const _Alloc&>(_Al));
+        }
+    } else {
+        return _STD move(_Tuple);
+    }
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class... _Types1, class... _Types2>
+void _Uses_alloc_construct_pair_piecewise(_CvPair* const _Ptr, _Outer_alloc& _Outer, const _Inner_alloc& _Inner,
+    tuple<_Types1...>&& _Val1, tuple<_Types2...>&& _Val2) {
+    // uses-allocator construction of pair from _Val1 and _Val2 by alloc _Outer propagating alloc _Inner
+    allocator_traits<_Outer_alloc>::construct(_Outer, _Ptr, piecewise_construct,
+        _STD _Uses_alloc_piecewise<typename _CvPair::first_type>(_Inner, _STD move(_Val1)),
+        _STD _Uses_alloc_piecewise<typename _CvPair::second_type>(_Inner, _STD move(_Val2)));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class... _Types1, class... _Types2>
+void _Uses_alloc_construct_pair(_CvPair* const _Ptr, _Outer_alloc& _Outer, const _Inner_alloc& _Inner,
+    piecewise_construct_t, tuple<_Types1...> _Val1, tuple<_Types2...> _Val2) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, piecewise case
+    _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner, _STD move(_Val1), _STD move(_Val2));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc>
+void _Uses_alloc_construct_pair(_CvPair* const _Ptr, _Outer_alloc& _Outer, const _Inner_alloc& _Inner) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, zero-argument case
+    _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner, tuple<>{}, tuple<>{});
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class _Uty, class _Vty>
+void _Uses_alloc_construct_pair(
+    _CvPair* const _Ptr, _Outer_alloc& _Outer, const _Inner_alloc& _Inner, _Uty&& _Arg1, _Vty&& _Arg2) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, two-argument case
+    _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner, _STD forward_as_tuple(_STD forward<_Uty>(_Arg1)),
+        _STD forward_as_tuple(_STD forward<_Vty>(_Arg2)));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class _Uty, class _Vty>
+void _Uses_alloc_construct_pair(
+    _CvPair* const _Ptr, _Outer_alloc& _Outer, const _Inner_alloc& _Inner, const pair<_Uty, _Vty>& _Pair) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, lvalue pair argument
+    _STD _Uses_alloc_construct_pair_piecewise(
+        _Ptr, _Outer, _Inner, _STD forward_as_tuple(_Pair.first), _STD forward_as_tuple(_Pair.second));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class _Uty, class _Vty>
+void _Uses_alloc_construct_pair(
+    _CvPair* const _Ptr, _Outer_alloc& _Outer, const _Inner_alloc& _Inner, pair<_Uty, _Vty>&& _Pair) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, rvalue pair argument
+    _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner,
+        _STD forward_as_tuple(_STD forward<_Uty>(_Pair.first)),
+        _STD forward_as_tuple(_STD forward<_Vty>(_Pair.second)));
+}
+
+template <class _CvPair, class _Outer_alloc, class _Inner_alloc, class _Uty,
+    enable_if_t<!_Is_deducible_as_pair<_Uty>, int> = 0>
+void _Uses_alloc_construct_pair(_CvPair* const _Ptr, _Outer_alloc& _Outer, const _Inner_alloc& _Inner, _Uty&& _Ux) {
+    // uses-allocator construction of pair by alloc _Outer propagating alloc _Inner, non-pair argument
+    static_assert(_Is_normally_bindable<remove_cv_t<_CvPair>, _Uty>,
+        "The argument must be bindable to a reference to the std::pair type.");
+
+    using _Pair_ref_t     = _Normally_bound_ref<remove_cv_t<_CvPair>, _Uty>;
+    _Pair_ref_t _Pair_ref = _STD forward<_Uty>(_Ux);
+    if constexpr (is_lvalue_reference_v<_Pair_ref_t>) {
+        _STD _Uses_alloc_construct_pair_piecewise(
+            _Ptr, _Outer, _Inner, _STD forward_as_tuple(_Pair_ref.first), _STD forward_as_tuple(_Pair_ref.second));
+    } else {
+        _STD _Uses_alloc_construct_pair_piecewise(_Ptr, _Outer, _Inner,
+            _STD forward_as_tuple(_STD forward<typename _CvPair::first_type>(_Pair_ref.first)),
+            _STD forward_as_tuple(_STD forward<typename _CvPair::second_type>(_Pair_ref.second)));
+    }
+}
+#endif // !_HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD class __declspec(novtable) memory_resource {
+    public:
+        virtual ~memory_resource() noexcept = default;
+
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) void* allocate(_CRT_GUARDOVERFLOW const size_t _Bytes,
+            const size_t _Align = alignof(max_align_t)) { // allocate _Bytes bytes of memory with alignment _Align
+            _STL_ASSERT(_STD _Is_pow_2(_Align), "memory_resource::allocate(): Alignment must be a power of two.");
+            void* _Ptr = do_allocate(_Bytes, _Align);
+            return ::operator new(_Bytes, _Ptr);
+        }
+
+        void deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align = alignof(max_align_t)) {
+            // deallocate _Ptr, which was returned from allocate(_Bytes, _Align)
+            _STL_ASSERT(_STD _Is_pow_2(_Align), "memory_resource::deallocate(): Alignment must be a power of two.");
+            return do_deallocate(_Ptr, _Bytes, _Align);
+        }
+
+        _NODISCARD bool is_equal(const memory_resource& _That) const noexcept {
+            // determine if *this and _That can both deallocate memory allocated by either
+            return do_is_equal(_That);
+        }
+
+    private:
+        virtual void* do_allocate(size_t _Bytes, size_t _Align)               = 0;
+        virtual void do_deallocate(void* _Ptr, size_t _Bytes, size_t _Align)  = 0;
+        virtual bool do_is_equal(const memory_resource& _That) const noexcept = 0;
+    };
+
+    _EXPORT_STD _NODISCARD inline bool operator==(
+        const memory_resource& _Left, const memory_resource& _Right) noexcept {
+        return &_Left == &_Right || _Left.is_equal(_Right);
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD inline bool operator!=(const memory_resource& _Left, const memory_resource& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Aligned_get_default_resource() noexcept;
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Unaligned_get_default_resource() noexcept;
+
+    _EXPORT_STD _NODISCARD inline memory_resource* get_default_resource() noexcept {
+#ifdef __cpp_aligned_new
+        return _STD pmr::_Aligned_get_default_resource();
+#else // ^^^ defined(__cpp_aligned_new) / !defined(__cpp_aligned_new) vvv
+        return _STD pmr::_Unaligned_get_default_resource();
+#endif // ^^^ !defined(__cpp_aligned_new) ^^^
+    }
+
+#if _HAS_CXX20
+    template <class _Uty>
+    struct _NODISCARD _Deallocate_bytes_guard {
+        ~_Deallocate_bytes_guard() noexcept {
+            if (_Mem_res) {
+                _Mem_res->deallocate(_Pobj, sizeof(_Uty), alignof(_Uty));
+            }
+        }
+
+        _Deallocate_bytes_guard& operator=(const _Deallocate_bytes_guard&) = delete;
+        _Deallocate_bytes_guard& operator=(_Deallocate_bytes_guard&&)      = delete;
+
+        memory_resource* _Mem_res;
+        void* _Pobj;
+    };
+#endif // _HAS_CXX20
+
+#if _HAS_CXX20 && defined(__cpp_lib_byte)
+    _EXPORT_STD template <class _Ty = byte>
+#else // ^^^ _HAS_CXX20 && defined(__cpp_lib_byte) / !_HAS_CXX20 || !defined(__cpp_lib_byte) vvv
+    _EXPORT_STD template <class _Ty>
+#endif // ^^^ !_HAS_CXX20 || !defined(__cpp_lib_byte) ^^^
+    class polymorphic_allocator {
+    public:
+        template <class>
+        friend class polymorphic_allocator;
+
+        using value_type = _Ty;
+
+        polymorphic_allocator() noexcept = default;
+
+        /* implicit */ polymorphic_allocator(memory_resource* const _Resource_) noexcept // strengthened
+            : _Resource{_Resource_} { // initialize with _Resource_
+            _STL_ASSERT(_Resource,
+                "Cannot initialize polymorphic_allocator with null resource (N4950 [mem.poly.allocator.ctor]/2)");
+        }
+
+        polymorphic_allocator(const polymorphic_allocator&) = default;
+
+        template <class _Uty>
+        polymorphic_allocator(const polymorphic_allocator<_Uty>& _That) noexcept
+            : _Resource{_That._Resource} {} // initialize with _That's resource
+
+        polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+        ~polymorphic_allocator() noexcept {
+            const auto _Tombstone{reinterpret_cast<memory_resource*>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+            _Resource = _Tombstone;
+        }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) _Ty* allocate(_CRT_GUARDOVERFLOW const size_t _Count) {
+            // get space for _Count objects of type _Ty from _Resource
+            void* const _Vp = _Resource->allocate(_Get_size_of_n<sizeof(_Ty)>(_Count), alignof(_Ty));
+            return static_cast<_Ty*>(_Vp);
+        }
+
+        void deallocate(_Ty* const _Ptr, const size_t _Count) noexcept /* strengthened */ {
+            // return space for _Count objects of type _Ty to _Resource
+            // No need to verify that size_t can represent the size of _Ty[_Count].
+            _Resource->deallocate(_Ptr, _Count * sizeof(_Ty), alignof(_Ty));
+        }
+
+#if _HAS_CXX20
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) void* allocate_bytes(
+            const size_t _Bytes, const size_t _Align = alignof(max_align_t)) {
+            return _Resource->allocate(_Bytes, _Align);
+        }
+
+        void deallocate_bytes(void* const _Ptr, const size_t _Bytes,
+            const size_t _Align = alignof(max_align_t)) noexcept /* strengthened */ {
+            _Resource->deallocate(_Ptr, _Bytes, _Align);
+        }
+
+        template <class _Uty>
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) _Uty* allocate_object(
+            _CRT_GUARDOVERFLOW const size_t _Count = 1) {
+            void* const _Vp = allocate_bytes(_Get_size_of_n<sizeof(_Uty)>(_Count), alignof(_Uty));
+            return static_cast<_Uty*>(_Vp);
+        }
+
+        template <class _Uty>
+        void deallocate_object(_Uty* const _Ptr, const size_t _Count = 1) noexcept /* strengthened */ {
+            deallocate_bytes(_Ptr, _Count * sizeof(_Uty), alignof(_Uty));
+        }
+
+        template <class _Uty, class... _Types>
+        _NODISCARD_RAW_PTR_ALLOC __declspec(allocator) _Uty* new_object(_Types&&... _Args) {
+            _Uty* const _Ptr = allocate_object<_Uty>();
+
+            _Deallocate_bytes_guard<_Uty> _Guard{_Resource, _Ptr};
+            construct(_Ptr, _STD forward<_Types>(_Args)...);
+            _Guard._Mem_res = nullptr;
+
+            return _Ptr;
+        }
+
+        template <class _Uty>
+        void delete_object(_Uty* const _Ptr) noexcept /* strengthened */ {
+            _Ptr->~_Uty();
+            deallocate_object(_Ptr);
+        }
+#endif // _HAS_CXX20
+
+        template <class _Uty, class... _Types>
+        void construct(_Uty* const _Ptr, _Types&&... _Args) {
+            // propagate allocator *this if uses_allocator_v<remove_cv_t<_Uty>, polymorphic_allocator>
+#if _HAS_CXX20
+            // equivalent to calling uninitialized_construct_using_allocator except for handling of cv-qualification
+            _STD apply(
+                [_Ptr](auto&&... _Construct_args) {
+                    return ::new (const_cast<void*>(static_cast<const volatile void*>(_Ptr)))
+                        _Uty(_STD forward<decltype(_Construct_args)>(_Construct_args)...);
+                },
+                _STD uses_allocator_construction_args<_Uty>(*this, _STD forward<_Types>(_Args)...));
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+            allocator<char> _Al{};
+            if constexpr (_Is_cv_pair<_Uty>) {
+                _STD _Uses_alloc_construct_pair(_Ptr, _Al, *this, _STD forward<_Types>(_Args)...);
+            } else {
+                _STD _Uses_alloc_construct_non_pair(_Ptr, _Al, *this, _STD forward<_Types>(_Args)...);
+            }
+#endif // ^^^ !_HAS_CXX20 ^^^
+        }
+
+        template <class _Uty>
+        void destroy(_Uty* const _Ptr) noexcept /* strengthened */ {
+            _Ptr->~_Uty();
+        }
+
+        _NODISCARD polymorphic_allocator select_on_container_copy_construction() const noexcept /* strengthened */ {
+            // don't propagate on copy
+            return {};
+        }
+
+        _NODISCARD memory_resource* resource() const noexcept /* strengthened */ {
+            // retrieve this allocator's memory_resource
+            return _Resource;
+        }
+
+        _NODISCARD friend bool operator==(
+            const polymorphic_allocator& _Lhs, const polymorphic_allocator& _Rhs) noexcept {
+            return *_Lhs._Resource == *_Rhs._Resource;
+        }
+
+#if !_HAS_CXX20
+        _NODISCARD friend bool operator!=(
+            const polymorphic_allocator& _Lhs, const polymorphic_allocator& _Rhs) noexcept {
+            return *_Lhs._Resource != *_Rhs._Resource;
+        }
+#endif // !_HAS_CXX20
+
+    private:
+        memory_resource* _Resource = _STD pmr::get_default_resource();
+    };
+
+    _EXPORT_STD template <class _Ty1, class _Ty2>
+    _NODISCARD bool operator==(
+        const polymorphic_allocator<_Ty1>& _Left, const polymorphic_allocator<_Ty2>& _Right) noexcept {
+        // polymorphic_allocators with the same resource are compatible
+        return *_Left.resource() == *_Right.resource();
+    }
+
+#if !_HAS_CXX20
+    template <class _Ty1, class _Ty2>
+    _NODISCARD bool operator!=(
+        const polymorphic_allocator<_Ty1>& _Left, const polymorphic_allocator<_Ty2>& _Right) noexcept {
+        return !(_Left == _Right);
+    }
+#endif // !_HAS_CXX20
+
+} // namespace pmr
+
+template <class _Ty, class _Ptr>
+struct _Has_no_alloc_destroy<pmr::polymorphic_allocator<_Ty>, _Ptr, void> : true_type {
+    // polymorphic_allocator technically _does_ have a destroy member, but it's equivalent to the
+    // default implementation in allocator_traits so we can optimize it away.
+};
+
+#endif // _HAS_CXX17
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XPOLYMORPHIC_ALLOCATOR_H
diff --git a/msvc-stl/stl/inc/xsmf_control.h b/msvc-stl/stl/inc/xsmf_control.h
new file mode 100644
index 0000000..9f8b64a
--- /dev/null
+++ b/msvc-stl/stl/inc/xsmf_control.h
@@ -0,0 +1,169 @@
+// xsmf_control.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XSMF_CONTROL_H
+#define _XSMF_CONTROL_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <type_traits>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+template <class _Base>
+struct _Non_trivial_copy : _Base { // non-trivial copy construction facade
+    using _Base::_Base;
+
+    _Non_trivial_copy() = default;
+    _CONSTEXPR20 _Non_trivial_copy(const _Non_trivial_copy& _That)
+        noexcept(noexcept(_Base::_Construct_from(static_cast<const _Base&>(_That)))) {
+        _Base::_Construct_from(static_cast<const _Base&>(_That));
+    }
+    _Non_trivial_copy(_Non_trivial_copy&&)                 = default;
+    _Non_trivial_copy& operator=(const _Non_trivial_copy&) = default;
+    _Non_trivial_copy& operator=(_Non_trivial_copy&&)      = default;
+};
+
+template <class _Base>
+struct _Deleted_copy : _Base { // deleted copy construction facade
+    using _Base::_Base;
+
+    _Deleted_copy()                                = default;
+    _Deleted_copy(const _Deleted_copy&)            = delete;
+    _Deleted_copy(_Deleted_copy&&)                 = default;
+    _Deleted_copy& operator=(const _Deleted_copy&) = default;
+    _Deleted_copy& operator=(_Deleted_copy&&)      = default;
+};
+
+template <class _Base, class... _Types>
+using _SMF_control_copy = conditional_t<conjunction_v<is_trivially_copy_constructible<_Types>...>, _Base,
+    conditional_t<conjunction_v<is_copy_constructible<_Types>...>, _Non_trivial_copy<_Base>, _Deleted_copy<_Base>>>;
+
+template <class _Base, class... _Types>
+struct _Non_trivial_move : _SMF_control_copy<_Base, _Types...> { // non-trivial move construction facade
+    using _Mybase = _SMF_control_copy<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Non_trivial_move()                         = default;
+    _Non_trivial_move(const _Non_trivial_move&) = default;
+    _CONSTEXPR20 _Non_trivial_move(_Non_trivial_move&& _That)
+        noexcept(noexcept(_Mybase::_Construct_from(static_cast<_Base&&>(_That)))) {
+        _Mybase::_Construct_from(static_cast<_Base&&>(_That));
+    }
+    _Non_trivial_move& operator=(const _Non_trivial_move&) = default;
+    _Non_trivial_move& operator=(_Non_trivial_move&&)      = default;
+};
+
+template <class _Base, class... _Types>
+struct _Deleted_move : _SMF_control_copy<_Base, _Types...> { // deleted move construction facade
+    using _Mybase = _SMF_control_copy<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Deleted_move()                                = default;
+    _Deleted_move(const _Deleted_move&)            = default;
+    _Deleted_move(_Deleted_move&&)                 = delete;
+    _Deleted_move& operator=(const _Deleted_move&) = default;
+    _Deleted_move& operator=(_Deleted_move&&)      = default;
+};
+
+template <class _Base, class... _Types>
+using _SMF_control_move =
+    conditional_t<conjunction_v<is_trivially_move_constructible<_Types>...>, _SMF_control_copy<_Base, _Types...>,
+        conditional_t<conjunction_v<is_move_constructible<_Types>...>, _Non_trivial_move<_Base, _Types...>,
+            _Deleted_move<_Base, _Types...>>>;
+
+template <class _Base, class... _Types>
+struct _Non_trivial_copy_assign : _SMF_control_move<_Base, _Types...> { // non-trivial copy assignment facade
+    using _Mybase = _SMF_control_move<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Non_trivial_copy_assign()                                = default;
+    _Non_trivial_copy_assign(const _Non_trivial_copy_assign&) = default;
+    _Non_trivial_copy_assign(_Non_trivial_copy_assign&&)      = default;
+
+    _CONSTEXPR20 _Non_trivial_copy_assign& operator=(const _Non_trivial_copy_assign& _That)
+        noexcept(noexcept(_Mybase::_Assign_from(static_cast<const _Base&>(_That)))) {
+        _Mybase::_Assign_from(static_cast<const _Base&>(_That));
+        return *this;
+    }
+    _Non_trivial_copy_assign& operator=(_Non_trivial_copy_assign&&) = default;
+};
+
+template <class _Base, class... _Types>
+struct _Deleted_copy_assign : _SMF_control_move<_Base, _Types...> { // deleted copy assignment facade
+    using _Mybase = _SMF_control_move<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Deleted_copy_assign()                                       = default;
+    _Deleted_copy_assign(const _Deleted_copy_assign&)            = default;
+    _Deleted_copy_assign(_Deleted_copy_assign&&)                 = default;
+    _Deleted_copy_assign& operator=(const _Deleted_copy_assign&) = delete;
+    _Deleted_copy_assign& operator=(_Deleted_copy_assign&&)      = default;
+};
+
+template <class _Base, class... _Types>
+using _SMF_control_copy_assign =
+    conditional_t<conjunction_v<is_trivially_destructible<_Types>..., is_trivially_copy_constructible<_Types>...,
+                      is_trivially_copy_assignable<_Types>...>,
+        _SMF_control_move<_Base, _Types...>,
+        conditional_t<conjunction_v<is_copy_constructible<_Types>..., is_copy_assignable<_Types>...>,
+            _Non_trivial_copy_assign<_Base, _Types...>, _Deleted_copy_assign<_Base, _Types...>>>;
+
+template <class _Base, class... _Types>
+struct _Non_trivial_move_assign : _SMF_control_copy_assign<_Base, _Types...> { // non-trivial move assignment facade
+    using _Mybase = _SMF_control_copy_assign<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Non_trivial_move_assign()                                           = default;
+    _Non_trivial_move_assign(const _Non_trivial_move_assign&)            = default;
+    _Non_trivial_move_assign(_Non_trivial_move_assign&&)                 = default;
+    _Non_trivial_move_assign& operator=(const _Non_trivial_move_assign&) = default;
+
+    _CONSTEXPR20 _Non_trivial_move_assign& operator=(_Non_trivial_move_assign&& _That)
+        noexcept(noexcept(_Mybase::_Assign_from(static_cast<_Base&&>(_That)))) {
+        _Mybase::_Assign_from(static_cast<_Base&&>(_That));
+        return *this;
+    }
+};
+
+template <class _Base, class... _Types>
+struct _Deleted_move_assign : _SMF_control_copy_assign<_Base, _Types...> { // deleted move assignment facade
+    using _Mybase = _SMF_control_copy_assign<_Base, _Types...>;
+    using _Mybase::_Mybase;
+
+    _Deleted_move_assign()                                       = default;
+    _Deleted_move_assign(const _Deleted_move_assign&)            = default;
+    _Deleted_move_assign(_Deleted_move_assign&&)                 = default;
+    _Deleted_move_assign& operator=(const _Deleted_move_assign&) = default;
+    _Deleted_move_assign& operator=(_Deleted_move_assign&&)      = delete;
+};
+
+template <class _Base, class... _Types>
+using _SMF_control_move_assign =
+    conditional_t<conjunction_v<is_trivially_destructible<_Types>..., is_trivially_move_constructible<_Types>...,
+                      is_trivially_move_assignable<_Types>...>,
+        _SMF_control_copy_assign<_Base, _Types...>,
+        conditional_t<conjunction_v<is_move_constructible<_Types>..., is_move_assignable<_Types>...>,
+            _Non_trivial_move_assign<_Base, _Types...>, _Deleted_move_assign<_Base, _Types...>>>;
+
+template <class _Base, class... _Types>
+using _SMF_control = _SMF_control_move_assign<_Base, _Types...>;
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XSMF_CONTROL_H
diff --git a/msvc-stl/stl/inc/xstring b/msvc-stl/stl/inc/xstring
new file mode 100644
index 0000000..2348507
--- /dev/null
+++ b/msvc-stl/stl/inc/xstring
@@ -0,0 +1,3653 @@
+// xstring internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XSTRING_
+#define _XSTRING_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_sanitizer_annotate_container.hpp>
+#include <__msvc_string_view.hpp>
+#include <iosfwd>
+#include <xmemory>
+
+#if _HAS_CXX17
+#include <xpolymorphic_allocator.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+template <class _Mystr>
+class _String_const_iterator : public _Iterator_base {
+public:
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Mystr::value_type;
+    using difference_type   = typename _Mystr::difference_type;
+    using pointer           = typename _Mystr::const_pointer;
+    using reference         = const value_type&;
+
+    _CONSTEXPR20 _String_const_iterator() noexcept : _Ptr() {}
+
+    _CONSTEXPR20 _String_const_iterator(pointer _Parg, const _Container_base* _Pstring) noexcept : _Ptr(_Parg) {
+        this->_Adopt(_Pstring);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Ptr, "cannot dereference value-initialized string iterator");
+        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot dereference string iterator because the iterator was "
+                             "invalidated (e.g. reallocation occurred, or the string was destroyed)");
+        const auto _Contptr = _Mycont->_Myptr();
+        const auto _Rawptr  = _Unfancy(_Ptr);
+        _STL_VERIFY(_Contptr <= _Rawptr && _Rawptr < _Contptr + _Mycont->_Mysize,
+            "cannot dereference string iterator because it is out of range (e.g. an end iterator)");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        _Analysis_assume_(_Ptr);
+        return *_Ptr;
+    }
+
+    _NODISCARD _CONSTEXPR20 pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _CONSTEXPR20 _String_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Ptr, "cannot increment value-initialized string iterator");
+        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot increment string iterator because the iterator was "
+                             "invalidated (e.g. reallocation occurred, or the string was destroyed)");
+        _STL_VERIFY(_Unfancy(_Ptr) < _Mycont->_Myptr() + _Mycont->_Mysize, "cannot increment string iterator past end");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        ++_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR20 _String_const_iterator operator++(int) noexcept {
+        _String_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _String_const_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(_Ptr, "cannot decrement value-initialized string iterator");
+        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot decrement string iterator because the iterator was "
+                             "invalidated (e.g. reallocation occurred, or the string was destroyed)");
+        _STL_VERIFY(_Mycont->_Myptr() < _Unfancy(_Ptr), "cannot decrement string iterator before begin");
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        --_Ptr;
+        return *this;
+    }
+
+    _CONSTEXPR20 _String_const_iterator operator--(int) noexcept {
+        _String_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 void _Verify_offset(const difference_type _Off) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Off == 0) {
+            return;
+        }
+
+        _STL_VERIFY(_Ptr, "cannot seek value-initialized string iterator");
+        const auto _Mycont = static_cast<const _Mystr*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot seek string iterator because the iterator was "
+                             "invalidated (e.g. reallocation occurred, or the string was destroyed)");
+        const auto _Contptr = _Mycont->_Myptr();
+        const auto _Rawptr  = _Unfancy(_Ptr);
+
+        if (_Off < 0) {
+            _STL_VERIFY(_Contptr - _Rawptr <= _Off, "cannot seek string iterator before begin");
+        }
+
+        if (_Off > 0) {
+            using _Size_type = typename _Mystr::size_type;
+            const auto _Left = _Mycont->_Mysize - static_cast<_Size_type>(_Rawptr - _Contptr);
+            _STL_VERIFY(static_cast<_Size_type>(_Off) <= _Left, "cannot seek string iterator after end");
+        }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        (void) _Off;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+    _CONSTEXPR20 _String_const_iterator& operator+=(const difference_type _Off) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _Verify_offset(_Off);
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+        _Ptr += _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _String_const_iterator operator+(const difference_type _Off) const noexcept {
+        _String_const_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _String_const_iterator operator+(
+        const difference_type _Off, _String_const_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR20 _String_const_iterator& operator-=(const difference_type _Off) noexcept {
+        return *this += -_Off;
+    }
+
+    _NODISCARD _CONSTEXPR20 _String_const_iterator operator-(const difference_type _Off) const noexcept {
+        _String_const_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 difference_type operator-(const _String_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return static_cast<difference_type>(_Ptr - _Right._Ptr);
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return *(*this + _Off);
+    }
+
+    _NODISCARD _CONSTEXPR20 bool operator==(const _String_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Ptr == _Right._Ptr;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr strong_ordering operator<=>(const _String_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _STD _Unfancy_maybe_null(_Ptr) <=> _STD _Unfancy_maybe_null(_Right._Ptr);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD bool operator!=(const _String_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+
+    _NODISCARD bool operator<(const _String_const_iterator& _Right) const noexcept {
+        _Compat(_Right);
+        return _Ptr < _Right._Ptr;
+    }
+
+    _NODISCARD bool operator>(const _String_const_iterator& _Right) const noexcept {
+        return _Right < *this;
+    }
+
+    _NODISCARD bool operator<=(const _String_const_iterator& _Right) const noexcept {
+        return !(_Right < *this);
+    }
+
+    _NODISCARD bool operator>=(const _String_const_iterator& _Right) const noexcept {
+        return !(*this < _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _CONSTEXPR20 void _Compat(const _String_const_iterator& _Right) const noexcept {
+        // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(),
+            "string iterators incompatible (e.g. point to different string instances)");
+#else // ^^^ _ITERATOR_DEBUG_LEVEL >= 1 / _ITERATOR_DEBUG_LEVEL == 0 vvv
+        (void) _Right;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 0 ^^^
+    }
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+    friend _CONSTEXPR20 void _Verify_range(
+        const _String_const_iterator& _First, const _String_const_iterator& _Last) noexcept {
+        _STL_VERIFY(_First._Getcont() == _Last._Getcont(), "string iterators in range are from different containers");
+        _STL_VERIFY(_First._Ptr <= _Last._Ptr, "string iterator range transposed");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+    using _Prevent_inheriting_unwrap = _String_const_iterator;
+
+    _NODISCARD _CONSTEXPR20 const value_type* _Unwrapped() const noexcept {
+        return _STD _Unfancy_maybe_null(_Ptr);
+    }
+
+    _CONSTEXPR20 void _Seek_to(const value_type* _It) noexcept {
+        _Ptr = _STD _Refancy_maybe_null<pointer>(const_cast<value_type*>(_It));
+    }
+
+    pointer _Ptr; // pointer to element in string
+};
+
+#if _HAS_CXX20
+template <class _Mystr>
+struct pointer_traits<_String_const_iterator<_Mystr>> {
+    using pointer         = _String_const_iterator<_Mystr>;
+    using element_type    = const pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        const auto _Mycont = static_cast<const _Mystr*>(_Iter._Getcont());
+        if (!_Mycont) {
+            _STL_VERIFY(!_Iter._Ptr, "cannot convert string iterator to pointer because the iterator was invalidated "
+                                     "(e.g. reallocation occurred, or the string was destroyed)");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        const auto _Rawptr = _STD to_address(_Iter._Ptr);
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Mycont) {
+            const auto _Contptr = _Mycont->_Myptr();
+            _STL_VERIFY(_Contptr <= _Rawptr && _Rawptr <= _Contptr + _Mycont->_Mysize,
+                "cannot convert string iterator to pointer because it is out of range");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        return _Rawptr;
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Mystr>
+class _String_iterator : public _String_const_iterator<_Mystr> {
+public:
+    using _Mybase = _String_const_iterator<_Mystr>;
+
+#if _HAS_CXX20
+    using iterator_concept = contiguous_iterator_tag;
+#endif // _HAS_CXX20
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = typename _Mystr::value_type;
+    using difference_type   = typename _Mystr::difference_type;
+    using pointer           = typename _Mystr::pointer;
+    using reference         = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD _CONSTEXPR20 reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD _CONSTEXPR20 pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _CONSTEXPR20 _String_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _CONSTEXPR20 _String_iterator operator++(int) noexcept {
+        _String_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _String_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _CONSTEXPR20 _String_iterator operator--(int) noexcept {
+        _String_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    _CONSTEXPR20 _String_iterator& operator+=(const difference_type _Off) noexcept {
+        _Mybase::operator+=(_Off);
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR20 _String_iterator operator+(const difference_type _Off) const noexcept {
+        _String_iterator _Tmp = *this;
+        _Tmp += _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD friend _CONSTEXPR20 _String_iterator operator+(
+        const difference_type _Off, _String_iterator _Next) noexcept {
+        _Next += _Off;
+        return _Next;
+    }
+
+    _CONSTEXPR20 _String_iterator& operator-=(const difference_type _Off) noexcept {
+        _Mybase::operator-=(_Off);
+        return *this;
+    }
+
+    using _Mybase::operator-;
+
+    _NODISCARD _CONSTEXPR20 _String_iterator operator-(const difference_type _Off) const noexcept {
+        _String_iterator _Tmp = *this;
+        _Tmp -= _Off;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const difference_type _Off) const noexcept {
+        return const_cast<reference>(_Mybase::operator[](_Off));
+    }
+
+    using _Prevent_inheriting_unwrap = _String_iterator;
+
+    _NODISCARD _CONSTEXPR20 value_type* _Unwrapped() const noexcept {
+        return const_cast<value_type*>(_STD _Unfancy_maybe_null(this->_Ptr));
+    }
+};
+
+#if _HAS_CXX20
+template <class _Mystr>
+struct pointer_traits<_String_iterator<_Mystr>> {
+    using pointer         = _String_iterator<_Mystr>;
+    using element_type    = pointer::value_type;
+    using difference_type = pointer::difference_type;
+
+    _NODISCARD static constexpr element_type* to_address(const pointer _Iter) noexcept {
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        const auto _Mycont = static_cast<const _Mystr*>(_Iter._Getcont());
+        if (!_Mycont) {
+            _STL_VERIFY(!_Iter._Ptr, "cannot convert string iterator to pointer because the iterator was invalidated "
+                                     "(e.g. reallocation occurred, or the string was destroyed)");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        const auto _Rawptr = _STD to_address(_Iter._Ptr);
+
+#if _ITERATOR_DEBUG_LEVEL >= 1
+        if (_Mycont) {
+            const auto _Contptr = _Mycont->_Myptr();
+            _STL_VERIFY(_Contptr <= _Rawptr && _Rawptr <= _Contptr + _Mycont->_Mysize,
+                "cannot convert string iterator to pointer because it is out of range");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL >= 1
+
+        return const_cast<element_type*>(_Rawptr);
+    }
+};
+#endif // _HAS_CXX20
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer>
+struct _String_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+};
+
+template <class _Val_types>
+class _String_val : public _Container_base {
+public:
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    _CONSTEXPR20 _String_val() noexcept : _Bx() {}
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    _CONSTEXPR20 ~_String_val() noexcept {
+        if constexpr (is_pointer_v<pointer>) {
+            if (!_STD _Is_constant_evaluated()) {
+                const auto _Tombstone{reinterpret_cast<pointer>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+                _Bx._Ptr = _Tombstone;
+                _Mysize  = 0;
+                _Myres   = (_Small_string_capacity + 1) | _Alloc_mask; // first capacity when entering large mode
+
+                // The capacity indicates whether we're in small mode or large mode; see _Large_mode_engaged().
+                // The string would be usable in small mode, so we need large mode for the tombstone to be effective.
+                // `_Small_string_capacity + 1` would be sufficient to make _Large_mode_engaged() return true. However,
+                // basic_string uses a "roundup mask" when allocating; see _Calculate_growth(). So to avoid confusing
+                // the SSO logic, we use the first capacity that would normally be used when entering large mode.
+            }
+        }
+    }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+
+    // length of internal buffer, [1, 16] (NB: used by the debugger visualizer)
+    static constexpr size_type _BUF_SIZE = 16 / sizeof(value_type) < 1 ? 1 : 16 / sizeof(value_type);
+    // roundup mask for allocated buffers, [0, 15]
+    static constexpr size_type _Alloc_mask = sizeof(value_type) <= 1 ? 15
+                                           : sizeof(value_type) <= 2 ? 7
+                                           : sizeof(value_type) <= 4 ? 3
+                                           : sizeof(value_type) <= 8 ? 1
+                                                                     : 0;
+    // capacity in small mode
+    static constexpr size_type _Small_string_capacity = _BUF_SIZE - 1;
+
+    _NODISCARD _CONSTEXPR20 value_type* _Myptr() noexcept {
+        value_type* _Result = _Bx._Buf;
+        if (_Large_mode_engaged()) {
+            _Result = _Unfancy(_Bx._Ptr);
+        }
+
+        return _Result;
+    }
+
+    _NODISCARD _CONSTEXPR20 const value_type* _Myptr() const noexcept {
+        const value_type* _Result = _Bx._Buf;
+        if (_Large_mode_engaged()) {
+            _Result = _Unfancy(_Bx._Ptr);
+        }
+
+        return _Result;
+    }
+
+    _NODISCARD _CONSTEXPR20 bool _Large_mode_engaged() const noexcept {
+        return _Myres > _Small_string_capacity;
+    }
+
+    _CONSTEXPR20 void _Activate_SSO_buffer() noexcept {
+        // start the lifetime of the array elements
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            for (size_type _Idx = 0; _Idx < _BUF_SIZE; ++_Idx) {
+                _Bx._Buf[_Idx] = value_type();
+            }
+        }
+#endif // _HAS_CXX20
+    }
+
+    _CONSTEXPR20 void _Check_offset(const size_type _Off) const {
+        // checks whether _Off is in the bounds of [0, size()]
+        if (_Mysize < _Off) {
+            _Xran();
+        }
+    }
+
+    _CONSTEXPR20 void _Check_offset_exclusive(const size_type _Off) const {
+        // checks whether _Off is in the bounds of [0, size())
+        if (_Mysize <= _Off) {
+            _Xran();
+        }
+    }
+
+    [[noreturn]] static void _Xran() {
+        _Xout_of_range("invalid string position");
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type _Clamp_suffix_size(const size_type _Off, const size_type _Size) const noexcept {
+        // trims _Size to the longest it can be assuming a string at/after _Off
+        return (_STD min) (_Size, static_cast<size_type>(_Mysize - _Off));
+    }
+
+    union _Bxty { // storage for small buffer or pointer to larger one
+        // This constructor previously initialized _Ptr. Don't rely on the new behavior without
+        // renaming `_String_val` (and fixing the visualizer).
+        _CONSTEXPR20 _Bxty() noexcept : _Buf() {} // user-provided, for fancy pointers
+        _CONSTEXPR20 ~_Bxty() noexcept {} // user-provided, for fancy pointers
+
+        value_type _Buf[_BUF_SIZE];
+        pointer _Ptr;
+        char _Alias[_BUF_SIZE]; // TRANSITION, ABI: _Alias is preserved for binary compatibility (especially /clr)
+
+        _CONSTEXPR20 void _Switch_to_buf() noexcept {
+            _STD _Destroy_in_place(_Ptr);
+
+#if _HAS_CXX20
+            // start the lifetime of the array elements
+            if (_STD is_constant_evaluated()) {
+                for (size_type _Idx = 0; _Idx < _BUF_SIZE; ++_Idx) {
+                    _Buf[_Idx] = value_type();
+                }
+            }
+#endif // _HAS_CXX20
+        }
+    };
+    _Bxty _Bx;
+
+    // invariant: _Myres >= _Mysize, and _Myres >= _Small_string_capacity (after string's construction)
+    // neither _Mysize nor _Myres takes account of the extra null terminator
+    size_type _Mysize = 0; // current length of string (size)
+    size_type _Myres  = 0; // current storage reserved for string (capacity)
+};
+
+// get _Ty's size after being EBCO'd
+template <class _Ty>
+constexpr size_t _Size_after_ebco_v = is_empty_v<_Ty> ? 0 : sizeof(_Ty);
+
+struct _String_constructor_concat_tag {
+    // tag to select constructors used by basic_string's concatenation operators (operator+)
+    explicit _String_constructor_concat_tag() = default;
+};
+
+template <class _Traits, class _UElem>
+_CONSTEXPR20 void _Traits_copy_batch(_Out_writes_all_(_Count) _Traits_ch_t<_Traits>* const _First1,
+    _In_reads_(_Count) const _UElem* const _First2, const size_t _Count) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_UElem, _Traits_ch_t<_Traits>, volatile _Traits_ch_t<_Traits>>);
+
+    if constexpr (is_volatile_v<_UElem>) {
+        for (size_t _Idx = 0; _Idx != _Count; ++_Idx) {
+            _Traits::assign(_First1[_Idx], _Traits_ch_t<_Traits>{_First2[_Idx]});
+        }
+    } else {
+        (void) _Traits::copy(_First1, _First2, _Count);
+    }
+}
+
+template <class _Traits, class _UElem>
+_CONSTEXPR20 void _Traits_move_batch(_Out_writes_all_(_Count) _Traits_ch_t<_Traits>* const _First1,
+    _In_reads_(_Count) const _UElem* const _First2, const size_t _Count) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_UElem, _Traits_ch_t<_Traits>, volatile _Traits_ch_t<_Traits>>);
+
+    if constexpr (is_volatile_v<_UElem>) {
+        bool _Loop_forward = true;
+
+        for (const _UElem* _Src = _First2; _Src != _First2 + _Count; ++_Src) {
+            if (_First1 == _Src) {
+                _Loop_forward = false;
+                break;
+            }
+        }
+
+        if (_Loop_forward) {
+            for (size_t _Idx = 0; _Idx != _Count; ++_Idx) {
+                _Traits::assign(_First1[_Idx], _Traits_ch_t<_Traits>{_First2[_Idx]});
+            }
+        } else {
+            for (size_t _Idx = _Count; _Idx != 0; --_Idx) {
+                _Traits::assign(_First1[_Idx - 1], _Traits_ch_t<_Traits>{_First2[_Idx - 1]});
+            }
+        }
+    } else {
+        (void) _Traits::move(_First1, _First2, _Count);
+    }
+}
+
+[[noreturn]] inline void _Xlen_string() {
+    _Xlength_error("string too long");
+}
+
+#if _HAS_CXX23
+template <class _Rng, class _Ty>
+concept _Contiguous_range_of =
+    (_RANGES contiguous_range<_Rng>) && same_as<remove_cvref_t<_RANGES range_reference_t<_Rng>>, _Ty>;
+#endif // _HAS_CXX23
+
+#pragma warning(push)
+// Invalid annotation: 'NullTerminated' property may only be used on buffers whose elements are of integral or pointer
+// type
+#pragma warning(disable : 6510)
+
+_EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
+class basic_string { // null-terminated transparent array of elements
+private:
+    friend _Tidy_deallocate_guard<basic_string>;
+    friend basic_stringbuf<_Elem, _Traits, _Alloc>;
+
+    using _Alty        = _Rebind_alloc_t<_Alloc, _Elem>;
+    using _Alty_traits = allocator_traits<_Alty>;
+
+    using _Scary_val = _String_val<conditional_t<_Is_simple_alloc_v<_Alty>, _Simple_types<_Elem>,
+        _String_iter_types<_Elem, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
+            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer>>>;
+
+    static_assert(!_ENFORCE_MATCHING_ALLOCATORS || is_same_v<_Elem, typename _Alloc::value_type>,
+        _MISMATCHED_ALLOCATOR_MESSAGE("basic_string<T, Traits, Allocator>", "T"));
+
+    static_assert(is_same_v<_Elem, typename _Traits::char_type>,
+        "N4950 [string.require]/3 requires that the supplied "
+        "char_traits character type match the string's character type.");
+
+    static_assert(!is_array_v<_Elem> && is_trivially_copyable_v<_Elem> && is_trivially_default_constructible_v<_Elem>
+                      && is_standard_layout_v<_Elem>,
+        "The character type of basic_string must be a non-array trivially copyable standard-layout type T where "
+        "is_trivially_default_constructible_v<T> is true. See N5001 [strings.general]/1.");
+
+public:
+    using traits_type    = _Traits;
+    using allocator_type = _Alloc;
+
+    using value_type      = _Elem;
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using iterator       = _String_iterator<_Scary_val>;
+    using const_iterator = _String_const_iterator<_Scary_val>;
+
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+private:
+    static constexpr size_type _BUF_SIZE              = _Scary_val::_BUF_SIZE;
+    static constexpr size_type _Alloc_mask            = _Scary_val::_Alloc_mask;
+    static constexpr size_type _Small_string_capacity = _Scary_val::_Small_string_capacity;
+
+    // least real allocation size, including space reserved for terminating null
+    static constexpr size_type _Least_allocation_size = _Small_string_capacity + 1 + 1;
+
+    // When doing _String_val operations by memcpy, we are touching:
+    //   _String_val::_Bx::_Buf (type is array of _Elem)
+    //   _String_val::_Bx::_Ptr (type is pointer)
+    //   _String_val::_Mysize   (type is size_type)
+    //   _String_val::_Myres    (type is size_type)
+    // N5001 [strings.general]/1 says _Elem must be trivially copyable standard-layout, so memcpy is safe.
+    // We need to ask if pointer is safe to memcpy.
+    // size_type must be an unsigned integral type so memcpy is safe.
+    // We also need to disable memcpy if the user has supplied _Traits, since
+    //   they can observe traits::assign and similar.
+    static constexpr bool _Can_memcpy_val =
+        _Is_specialization_v<_Traits, char_traits> && is_trivially_copyable_v<pointer>;
+    // This offset skips over the _Container_base members, if any
+    static constexpr size_t _Memcpy_val_offset = _Size_after_ebco_v<_Container_base>;
+    static constexpr size_t _Memcpy_val_size   = sizeof(_Scary_val) - _Memcpy_val_offset;
+
+    template <class _Iter>
+    // TRANSITION, /clr:pure is incompatible with templated static constexpr data members
+    // static constexpr bool _Is_elem_cvptr =
+    //     _Is_any_of_v<remove_const_t<_Iter>, _Elem*, const _Elem*, volatile _Elem*, const volatile _Elem*>;
+    using _Is_elem_cvptr = bool_constant<
+        _Is_any_of_v<remove_const_t<_Iter>, _Elem*, const _Elem*, volatile _Elem*, const volatile _Elem*>>;
+
+#if _HAS_CXX17
+    template <class _StringViewIsh>
+    using _Is_string_view_ish =
+        enable_if_t<conjunction_v<is_convertible<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>,
+                        negation<is_convertible<const _StringViewIsh&, const _Elem*>>>,
+            int>;
+#endif // _HAS_CXX17
+
+#ifdef _INSERT_STRING_ANNOTATION
+    _CONSTEXPR20 void _Create_annotation() const noexcept {
+        // Annotates the valid range with shadow memory
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myptr(), _My_data._Myres, _My_data._Myres, _My_data._Mysize);
+    }
+
+    _CONSTEXPR20 void _Remove_annotation() const noexcept {
+        // Removes annotation of the range with shadow memory
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myptr(), _My_data._Myres, _My_data._Mysize, _My_data._Myres);
+    }
+
+    _CONSTEXPR20 void _Modify_annotation(const size_type _Old_size, const size_type _New_size) const noexcept {
+        if (_Old_size == _New_size) {
+            return;
+        }
+
+        auto& _My_data = _Mypair._Myval2;
+        _Apply_annotation(_My_data._Myptr(), _My_data._Myres, _Old_size, _New_size);
+    }
+
+    static _CONSTEXPR20 void _Apply_annotation(const value_type* const _First, const size_type _Capacity,
+        const size_type _Old_size, const size_type _New_size) noexcept {
+        if constexpr (!_Disable_ASan_container_annotations_for_allocator<allocator_type>) {
+#if _HAS_CXX20
+            if (_STD is_constant_evaluated()) {
+                return;
+            }
+#endif // _HAS_CXX20
+
+            // Don't annotate small strings; only annotate on the heap.
+            if (_Capacity <= _Small_string_capacity || !_Asan_string_should_annotate) {
+                return;
+            }
+
+            // Note that `_Capacity`, `_Old_size`, and `_New_size` do not include the null terminator
+            const void* const _End      = _First + _Capacity + 1;
+            const void* const _Old_last = _First + _Old_size + 1;
+            const void* const _New_last = _First + _New_size + 1;
+
+            constexpr bool _Large_string_always_asan_aligned =
+                (_Container_allocation_minimum_asan_alignment<basic_string>) >= _Asan_granularity;
+
+            // for the non-aligned buffer options, the buffer must always have size >= 9 bytes,
+            // so it will always end at least one shadow memory section.
+
+            _Asan_aligned_pointers _Aligned;
+            if constexpr (_Large_string_always_asan_aligned) {
+                _Aligned = {_First, _STD _Get_asan_aligned_after(_End)};
+            } else {
+                _Aligned = _STD _Get_asan_aligned_first_end(_First, _End);
+            }
+            const void* const _Old_fixed = _Aligned._Clamp_to_end(_Old_last);
+            const void* const _New_fixed = _Aligned._Clamp_to_end(_New_last);
+
+            // --- always aligned case ---
+            // old state:
+            //   [_First, _Old_last) valid
+            //   [_Old_last, asan_aligned_after(_End)) poison
+            // new state:
+            //   [_First, _New_last) valid
+            //   [_New_last, asan_aligned_after(_End)) poison
+
+            // --- sometimes non-aligned case ---
+            // old state:
+            //   [_Aligned._First, _Old_fixed) valid
+            //   [_Old_fixed, _Aligned._End) poison
+            //   [_Aligned._End, _End) valid
+            // new state:
+            //   [_Aligned._First, _New_fixed) valid
+            //   [_New_fixed, _Aligned._End) poison
+            //   [_Aligned._End, _End) valid
+            _CSTD __sanitizer_annotate_contiguous_container(_Aligned._First, _Aligned._End, _Old_fixed, _New_fixed);
+        }
+    }
+
+#define _ASAN_STRING_REMOVE(_Str)                       (_Str)._Remove_annotation()
+#define _ASAN_STRING_CREATE(_Str)                       (_Str)._Create_annotation()
+#define _ASAN_STRING_MODIFY(_Str, _Old_size, _New_size) (_Str)._Modify_annotation(_Old_size, _New_size)
+#else // ^^^ defined(_INSERT_STRING_ANNOTATION) / !defined(_INSERT_STRING_ANNOTATION) vvv
+#define _ASAN_STRING_REMOVE(_Str)
+#define _ASAN_STRING_CREATE(_Str)
+#define _ASAN_STRING_MODIFY(_Str, _Old_size, _New_size)
+#endif // ^^^ !defined(_INSERT_STRING_ANNOTATION) ^^^
+
+public:
+    _CONSTEXPR20
+    basic_string() noexcept(is_nothrow_default_constructible_v<_Alty>) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct_empty();
+    }
+
+    _CONSTEXPR20 explicit basic_string(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct_empty();
+    }
+
+    _CONSTEXPR20 basic_string(const basic_string& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
+        _Construct<_Construct_strategy::_From_string>(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string(const basic_string& _Right, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct<_Construct_strategy::_From_string>(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string(const basic_string& _Right, const size_type _Roff, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, <end>)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Construct<_Construct_strategy::_From_ptr>(
+            _Right._Mypair._Myval2._Myptr() + _Roff, _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, npos));
+    }
+
+    _CONSTEXPR20 basic_string(
+        const basic_string& _Right, const size_type _Roff, const size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, _Roff + _Count)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Construct<_Construct_strategy::_From_ptr>(
+            _Right._Mypair._Myval2._Myptr() + _Roff, _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count));
+    }
+
+#if _HAS_CXX23
+    constexpr basic_string(basic_string&& _Right, const size_type _Roff, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, <end>), potentially move
+        _Move_construct_from_substr(_Right, _Roff, npos);
+    }
+
+    constexpr basic_string(
+        basic_string&& _Right, const size_type _Roff, const size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, _Roff + _Count), potentially move
+        _Move_construct_from_substr(_Right, _Roff, _Count);
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string(_In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count)
+        : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    _CONSTEXPR20 basic_string(
+        _In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string(_In_z_ const _Elem* const _Ptr) : _Mypair(_Zero_then_variadic_args_t{}) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    _CONSTEXPR20 basic_string(_In_z_ const _Elem* const _Ptr, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+#if _HAS_CXX23
+    basic_string(nullptr_t) = delete;
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch)
+        : _Mypair(_Zero_then_variadic_args_t{}) { // construct from _Count * _Ch
+        _Construct<_Construct_strategy::_From_char>(_Ch, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
+#endif // _HAS_CXX17
+    _CONSTEXPR20 basic_string(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch, const _Alloc& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Count * _Ch with allocator
+        _Construct<_Construct_strategy::_From_char>(_Ch, _Count);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 basic_string(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst = _STD _Get_unwrapped(_First);
+        auto _ULast  = _STD _Get_unwrapped(_Last);
+        if (_UFirst == _ULast) {
+            _Construct_empty();
+        } else {
+            if constexpr (_Is_elem_cvptr<decltype(_UFirst)>::value) {
+                _Construct<_Construct_strategy::_From_ptr>(
+                    _UFirst, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+            } else if constexpr (_Is_cpp17_fwd_iter_v<decltype(_UFirst)>) {
+                const auto _Length = static_cast<size_t>(_STD distance(_UFirst, _ULast));
+                const auto _Count  = _STD _Convert_size<size_type>(_Length);
+                _Construct_from_iter(_STD move(_UFirst), _STD move(_ULast), _Count);
+            } else {
+                _Construct_from_iter(_STD move(_UFirst), _STD move(_ULast));
+            }
+        }
+    }
+
+private:
+    enum class _Allocation_policy { _At_least, _Exactly };
+
+    template <_Allocation_policy _Policy = _Allocation_policy::_At_least>
+    _NODISCARD static _CONSTEXPR20 pointer _Allocate_for_capacity(_Alty& _Al, size_type& _Capacity) {
+        _STL_INTERNAL_CHECK(_Capacity > _Small_string_capacity);
+        ++_Capacity; // Take null terminator into consideration
+
+        pointer _Fancy_ptr = nullptr;
+        if constexpr (_Policy == _Allocation_policy::_At_least) {
+            _Fancy_ptr = _Allocate_at_least_helper(_Al, _Capacity);
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(_Policy == _Allocation_policy::_Exactly);
+            _Fancy_ptr = _Al.allocate(_Capacity);
+        }
+
+#if _HAS_CXX20
+        // Start element lifetimes to avoid UB. This is a more general mechanism than _String_val::_Activate_SSO_buffer,
+        // but likely more impactful to throughput.
+        if (_STD is_constant_evaluated()) {
+            _Elem* const _Ptr = _Unfancy(_Fancy_ptr);
+            for (size_type _Idx = 0; _Idx < _Capacity; ++_Idx) {
+                _STD construct_at(_Ptr + _Idx);
+            }
+        }
+#endif // _HAS_CXX20
+        --_Capacity;
+        return _Fancy_ptr;
+    }
+
+    static _CONSTEXPR20 void _Deallocate_for_capacity(
+        _Alty& _Al, const pointer _Old_ptr, const size_type _Capacity) noexcept {
+        _STL_INTERNAL_CHECK(_Capacity > _Small_string_capacity);
+        _Al.deallocate(_Old_ptr, static_cast<size_type>(_Capacity + 1)); // +1 for null terminator
+    }
+
+    _CONSTEXPR20 void _Construct_empty() {
+        auto& _My_data = _Mypair._Myval2;
+        _My_data._Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+
+        // initialize basic_string data members
+        _My_data._Mysize = 0;
+        _My_data._Myres  = _Small_string_capacity;
+        _My_data._Activate_SSO_buffer();
+
+        // the _Traits::assign is last so the codegen doesn't think the char write can alias this
+        _Traits::assign(_My_data._Bx._Buf[0], _Elem());
+    }
+
+    enum class _Construct_strategy : uint8_t { _From_char, _From_ptr, _From_string };
+
+    template <_Construct_strategy _Strat, class _Char_or_ptr>
+    _CONSTEXPR20 void _Construct(const _Char_or_ptr _Arg, _CRT_GUARDOVERFLOW const size_type _Count) {
+        auto& _My_data = _Mypair._Myval2;
+        _STL_INTERNAL_CHECK(!_My_data._Large_mode_engaged());
+
+        if constexpr (_Strat == _Construct_strategy::_From_char) {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Char_or_ptr, _Elem>);
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(_Is_elem_cvptr<_Char_or_ptr>::value);
+        }
+
+        if (_Count > max_size()) {
+            _Xlen_string(); // result too long
+        }
+
+        auto& _Al     = _Getal();
+        auto _Alproxy = _STD _Get_proxy_allocator(_Al);
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
+
+        if (_Count <= _Small_string_capacity) {
+            _My_data._Mysize = _Count;
+            _My_data._Myres  = _Small_string_capacity;
+
+            if constexpr (_Strat == _Construct_strategy::_From_char) {
+                _Traits::assign(_My_data._Bx._Buf, static_cast<size_t>(_Count), _Arg);
+                _Traits::assign(_My_data._Bx._Buf[_Count], _Elem());
+            } else if constexpr (_Strat == _Construct_strategy::_From_ptr) {
+                _STD _Traits_copy_batch<_Traits>(_My_data._Bx._Buf, _Arg, static_cast<size_t>(_Count));
+                _Traits::assign(_My_data._Bx._Buf[_Count], _Elem());
+            } else { // _Strat == _Construct_strategy::_From_string
+#ifdef _INSERT_STRING_ANNOTATION
+                _Traits::copy(_My_data._Bx._Buf, _Arg, static_cast<size_t>(_Count + 1));
+#else // ^^^ defined(_INSERT_STRING_ANNOTATION) / !defined(_INSERT_STRING_ANNOTATION) vvv
+                _Traits::copy(_My_data._Bx._Buf, _Arg, _BUF_SIZE);
+#endif // ^^^ !defined(_INSERT_STRING_ANNOTATION) ^^^
+            }
+
+            _Proxy._Release();
+            return;
+        }
+
+        size_type _New_capacity = _Calculate_growth(_Count, _Small_string_capacity, max_size());
+        const pointer _New_ptr  = _Allocate_for_capacity(_Al, _New_capacity); // throws
+        _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
+
+        _My_data._Mysize = _Count;
+        _My_data._Myres  = _New_capacity;
+        if constexpr (_Strat == _Construct_strategy::_From_char) {
+            _Traits::assign(_Unfancy(_New_ptr), static_cast<size_t>(_Count), _Arg);
+            _Traits::assign(_Unfancy(_New_ptr)[_Count], _Elem());
+        } else if constexpr (_Strat == _Construct_strategy::_From_ptr) {
+            _STD _Traits_copy_batch<_Traits>(_Unfancy(_New_ptr), _Arg, static_cast<size_t>(_Count));
+            _Traits::assign(_Unfancy(_New_ptr)[_Count], _Elem());
+        } else { // _Strat == _Construct_strategy::_From_string
+            _Traits::copy(_Unfancy(_New_ptr), _Arg, static_cast<size_t>(_Count + 1));
+        }
+
+        _ASAN_STRING_CREATE(*this);
+        _Proxy._Release();
+    }
+
+    template <class _Iter, class _Sent, class _Size = nullptr_t>
+    _CONSTEXPR20 void _Construct_from_iter(_Iter _First, const _Sent _Last, _Size _Count = {}) {
+        // Pre: _Iter models input_iterator or meets the Cpp17InputIterator requirements.
+        // Pre: [_First, _Last) is a valid range.
+        // Pre: if _Iter models forward_iterator or meets the Cpp17ForwardIterator requirements,
+        //      then is_same_v<_Size, size_type> holds.
+        // Pre: if is_same_v<_Size, size_type>, _Count is the length of [_First, _Last).
+        // Pre: *this is in small mode; the lifetime of the SSO elements has already begun.
+
+        auto& _My_data = _Mypair._Myval2;
+        auto& _Al      = _Getal();
+        auto _Alproxy  = _STD _Get_proxy_allocator(_Al);
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
+
+        _My_data._Mysize = 0;
+        _My_data._Myres  = _Small_string_capacity;
+
+        if constexpr (is_same_v<_Size, size_type>) {
+            if (_Count > max_size()) {
+                _Xlen_string(); // result too long
+            }
+
+            if (_Count > _Small_string_capacity) {
+                size_type _New_capacity = _Calculate_growth(_Count);
+                const pointer _New_ptr  = _Allocate_for_capacity(_Al, _New_capacity); // throws
+                _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
+                _My_data._Myres = _New_capacity;
+            }
+        }
+
+        _Tidy_deallocate_guard<basic_string> _Guard{this};
+
+        constexpr bool _Can_construct_by_copy =
+            _Is_specialization_v<_Traits, char_traits> && _Is_EcharT<_Elem> && is_same_v<_Size, size_type>;
+
+        if constexpr (_Can_construct_by_copy) {
+            const auto _Data = _My_data._Myptr();
+            _STD _Copy_n_unchecked4(_STD move(_First), _Count, _Data);
+            _My_data._Mysize = _Count;
+            _Data[_Count]    = _Elem();
+        } else {
+            for (; _First != _Last; ++_First) {
+                if constexpr (!is_same_v<_Size, size_type>) {
+                    if (_My_data._Mysize == _My_data._Myres) { // Need to grow
+                        if (_My_data._Mysize == max_size()) {
+                            _Xlen_string(); // result too long
+                        }
+
+                        _Elem* const _Old_ptr   = _My_data._Myptr();
+                        size_type _New_capacity = _Calculate_growth(_My_data._Mysize + 1);
+                        const pointer _New_ptr  = _Allocate_for_capacity(_Al, _New_capacity); // throws
+
+                        _Traits::copy(_Unfancy(_New_ptr), _Old_ptr, _My_data._Mysize);
+                        if (_My_data._Large_mode_engaged()) { // Need to deallocate old storage
+                            _Deallocate_for_capacity(_Al, _My_data._Bx._Ptr, _My_data._Myres);
+                            _My_data._Bx._Ptr = _New_ptr;
+                        } else {
+                            _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
+                        }
+                        _My_data._Myres = _New_capacity;
+                    }
+                }
+
+                _Elem* const _Ptr = _My_data._Myptr();
+                _Traits::assign(_Ptr[_My_data._Mysize], *_First);
+                ++_My_data._Mysize;
+            }
+
+            _Elem* const _Ptr = _My_data._Myptr();
+            _Traits::assign(_Ptr[_My_data._Mysize], _Elem());
+        }
+
+        _ASAN_STRING_CREATE(*this);
+        _Guard._Target = nullptr;
+        _Proxy._Release();
+    }
+
+public:
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string(from_range_t, _Rng&& _Range, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (_RANGES sized_range<_Rng> || _RANGES forward_range<_Rng>) {
+            const auto _Length = _To_unsigned_like(_RANGES distance(_Range));
+            const auto _Count  = _Convert_size<size_type>(_Length);
+            if constexpr (_Contiguous_range_of<_Rng, _Elem>) {
+                _Construct<_Construct_strategy::_From_ptr>(_RANGES data(_Range), _Count);
+            } else {
+                _Construct_from_iter(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range), _Count);
+            }
+        } else {
+            _Construct_from_iter(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string(basic_string&& _Right) noexcept
+        : _Mypair(_One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
+        _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+        _Take_contents(_Right);
+    }
+
+    _CONSTEXPR20 basic_string(basic_string&& _Right, const _Alloc& _Al)
+        noexcept(_Alty_traits::is_always_equal::value) // strengthened
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        if constexpr (!_Alty_traits::is_always_equal::value) {
+            if (_Getal() != _Right._Getal()) {
+                _Construct<_Construct_strategy::_From_string>(
+                    _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+                return;
+            }
+        }
+
+        _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Getal()));
+        _Take_contents(_Right);
+    }
+
+    _CONSTEXPR20 basic_string(_String_constructor_concat_tag, const basic_string& _Source_of_al,
+        const _Elem* const _Left_ptr, const size_type _Left_size, const _Elem* const _Right_ptr,
+        const size_type _Right_size)
+        : _Mypair(_One_then_variadic_args_t{},
+              _Alty_traits::select_on_container_copy_construction(_Source_of_al._Getal())) {
+        _STL_INTERNAL_CHECK(_Left_size <= max_size());
+        _STL_INTERNAL_CHECK(_Right_size <= max_size());
+        _STL_INTERNAL_CHECK(_Right_size <= max_size() - _Left_size);
+        const auto _New_size    = static_cast<size_type>(_Left_size + _Right_size);
+        size_type _New_capacity = _Small_string_capacity;
+        auto& _My_data          = _Mypair._Myval2;
+        _Elem* _Ptr             = _My_data._Bx._Buf;
+        auto _Alproxy           = _STD _Get_proxy_allocator(_Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data); // throws
+
+        if (_New_capacity < _New_size) {
+            _New_capacity           = _Calculate_growth(_New_size, _Small_string_capacity, max_size());
+            const pointer _Fancyptr = _Allocate_for_capacity(_Getal(), _New_capacity); // throws
+            _Ptr                    = _Unfancy(_Fancyptr);
+            _Construct_in_place(_My_data._Bx._Ptr, _Fancyptr);
+        }
+
+        _My_data._Mysize = _New_size;
+        _My_data._Myres  = _New_capacity;
+        _Traits::copy(_Ptr, _Left_ptr, static_cast<size_t>(_Left_size));
+        _Traits::copy(_Ptr + static_cast<ptrdiff_t>(_Left_size), _Right_ptr, static_cast<size_t>(_Right_size));
+        _Traits::assign(_Ptr[_New_size], _Elem());
+        _ASAN_STRING_CREATE(*this);
+        _Proxy._Release();
+    }
+
+    _CONSTEXPR20 basic_string(_String_constructor_concat_tag, basic_string& _Left, basic_string& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Left._Getal()) {
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Left_data  = _Left._Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _Left_data._Orphan_all();
+        _Right_data._Orphan_all();
+        const auto _Left_size  = _Left_data._Mysize;
+        const auto _Right_size = _Right_data._Mysize;
+
+        const auto _Left_capacity  = _Left_data._Myres;
+        const auto _Right_capacity = _Right_data._Myres;
+        // overflow is OK due to max_size() checks:
+        const auto _New_size     = static_cast<size_type>(_Left_size + _Right_size);
+        const bool _Fits_in_left = _Right_size <= _Left_capacity - _Left_size;
+        if (_Fits_in_left && _Right_capacity <= _Left_capacity) {
+            // take _Left's buffer, max_size() is OK because _Fits_in_left
+            _My_data._Alloc_proxy(_STD _Get_proxy_allocator(_Getal())); // throws, hereafter nothrow in this block
+            _Take_contents(_Left);
+            const auto _Ptr = _My_data._Myptr();
+            _ASAN_STRING_MODIFY(*this, _Left_size, _New_size);
+            _Traits::copy(_Ptr + _Left_size, _Right_data._Myptr(), static_cast<size_t>(_Right_size + 1));
+            _My_data._Mysize = _New_size;
+            return;
+        }
+
+        const bool _Fits_in_right = _Left_size <= _Right_capacity - _Right_size;
+        if (_Allocators_equal(_Getal(), _Right._Getal()) && _Fits_in_right) {
+            // take _Right's buffer, max_size() is OK because _Fits_in_right
+            // At this point, we have tested:
+            // !(_Fits_in_left && _Right_capacity <= _Left_capacity) && _Fits_in_right
+            // therefore: (by De Morgan's Laws)
+            // (!_Fits_in_left || _Right_capacity > _Left_capacity) && _Fits_in_right
+            // therefore: (by the distributive property)
+            // (!_Fits_in_left && _Fits_in_right)  // implying _Right has more capacity
+            //     || (_Right_capacity > _Left_capacity && _Fits_in_right)  // tests that _Right has more capacity
+            // therefore: _Right must have more than the minimum capacity, so it must be _Large_mode_engaged()
+            _STL_INTERNAL_CHECK(_Right_data._Large_mode_engaged());
+            _My_data._Alloc_proxy(_STD _Get_proxy_allocator(_Getal())); // throws, hereafter nothrow in this block
+            _Take_contents(_Right);
+            const auto _Ptr = _Unfancy(_My_data._Bx._Ptr);
+            _ASAN_STRING_MODIFY(*this, _Right_size, _New_size);
+            _Traits::move(_Ptr + _Left_size, _Ptr, static_cast<size_t>(_Right_size + 1));
+            _Traits::copy(_Ptr, _Left_data._Myptr(), static_cast<size_t>(_Left_size));
+            _My_data._Mysize = _New_size;
+            return;
+        }
+
+        // can't use either buffer, reallocate
+        const auto _Max = max_size();
+        if (_Max - _Left_size < _Right_size) { // check if max_size() is OK
+            _Xlen_string();
+        }
+
+        size_type _New_capacity = _Calculate_growth(_New_size, _Small_string_capacity, _Max);
+        auto _Alproxy           = _STD _Get_proxy_allocator(_Getal());
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data); // throws
+        const pointer _Fancyptr = _Allocate_for_capacity(_Getal(), _New_capacity); // throws
+        // nothrow hereafter
+        _Construct_in_place(_My_data._Bx._Ptr, _Fancyptr);
+        _My_data._Mysize = _New_size;
+        _My_data._Myres  = _New_capacity;
+        const auto _Ptr  = _Unfancy(_Fancyptr);
+        _Traits::copy(_Ptr, _Left_data._Myptr(), static_cast<size_t>(_Left_size));
+        _Traits::copy(_Ptr + _Left_size, _Right_data._Myptr(), static_cast<size_t>(_Right_size + 1));
+        _ASAN_STRING_CREATE(*this);
+        _Proxy._Release();
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 explicit basic_string(const _StringViewIsh& _Right, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        _Construct<_Construct_strategy::_From_ptr>(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _Ty, enable_if_t<is_convertible_v<const _Ty&, basic_string_view<_Elem, _Traits>>, int> = 0>
+    _CONSTEXPR20 basic_string(
+        const _Ty& _Right, const size_type _Roff, const size_type _Count, const _Alloc& _Al = _Alloc())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) { // construct from _Right [_Roff, _Roff + _Count) using _Al
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        const auto _As_sub_view = _As_view.substr(static_cast<size_t>(_Roff), static_cast<size_t>(_Count));
+        _Construct<_Construct_strategy::_From_ptr>(_As_sub_view.data(), _Convert_size<size_type>(_As_sub_view.size()));
+    }
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+    _NODISCARD bool _Move_assign_from_buffer(
+        _Elem* const _Right, const size_type _Size, const size_type _Actual_allocation_size) {
+        // Move assign from a buffer, used exclusively by basic_stringbuf; returns _Large_mode_engaged()
+        auto& _My_data = _Mypair._Myval2;
+        _STL_INTERNAL_CHECK(!_My_data._Large_mode_engaged() && _My_data._Mysize == 0);
+        _STL_INTERNAL_CHECK(_Size < _Actual_allocation_size); // So there is room for null terminator
+        _Traits::assign(_Right[_Size], _Elem());
+
+        const bool _Is_large = _Actual_allocation_size >= _Least_allocation_size;
+        if (_Is_large) {
+            _ASAN_STRING_REMOVE(*this);
+            _Construct_in_place(_My_data._Bx._Ptr, _Refancy<pointer>(_Right));
+            _My_data._Mysize = _Size;
+            _My_data._Myres  = _Actual_allocation_size - 1;
+            _ASAN_STRING_CREATE(*this);
+        } else {
+            _Traits::copy(_My_data._Bx._Buf, _Right, _Actual_allocation_size);
+            _My_data._Mysize = _Size;
+            _My_data._Myres  = _Small_string_capacity;
+        }
+
+        return _Is_large;
+    }
+
+    // No instance of this type can exist where an exception may be thrown.
+    struct _Released_buffer {
+        pointer _Ptr;
+        size_type _Size;
+        size_type _Actual_allocation_size;
+    };
+
+    _NODISCARD _Released_buffer _Release_to_buffer(_Alloc& _Al) {
+        // Release to a buffer, or allocate a new one if in small string mode; used exclusively by basic_stringbuf
+        _Released_buffer _Result;
+        auto& _My_data = _Mypair._Myval2;
+        _Result._Size  = _My_data._Mysize;
+        _My_data._Orphan_all();
+        _ASAN_STRING_REMOVE(*this);
+        if (_My_data._Large_mode_engaged()) {
+            _Result._Ptr                    = _My_data._Bx._Ptr;
+            _Result._Actual_allocation_size = _My_data._Myres + 1;
+
+            _My_data._Bx._Switch_to_buf();
+        } else {
+            // use _Least_allocation_size to avoid small mode, if the buffer is assigned back
+            size_type _Allocated = _Least_allocation_size;
+            _Result._Ptr         = _Allocate_at_least_helper(_Al, _Allocated);
+            _Traits::copy(_Unfancy(_Result._Ptr), _My_data._Bx._Buf, _BUF_SIZE);
+            _Result._Actual_allocation_size = _Allocated;
+        }
+        _My_data._Mysize = 0;
+        _My_data._Myres  = _Small_string_capacity;
+        _Traits::assign(_My_data._Bx._Buf[0], _Elem());
+        return _Result;
+    }
+#endif // _HAS_CXX20
+
+    _CONSTEXPR20 basic_string& operator=(basic_string&& _Right)
+        noexcept(_Choose_pocma_v<_Alty> != _Pocma_values::_No_propagate_allocators) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alty>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                // intentionally slams into noexcept on OOM, TRANSITION, VSO-466800
+                _Mypair._Myval2._Orphan_all();
+                _Mypair._Myval2._Reload_proxy(_STD _Get_proxy_allocator(_Al), _STD _Get_proxy_allocator(_Right_al));
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+                return *this;
+            }
+        }
+
+        _Tidy_deallocate();
+        _Pocma(_Al, _Right_al);
+        _Take_contents(_Right);
+        return *this;
+    }
+
+    _CONSTEXPR20 basic_string& assign(basic_string&& _Right) noexcept(noexcept(*this = _STD move(_Right))) {
+        *this = _STD move(_Right);
+        return *this;
+    }
+
+private:
+    _CONSTEXPR20 void _Take_contents(basic_string& _Right) noexcept {
+        // assign by stealing _Right's buffer
+        // pre: this != &_Right
+        // pre: allocator propagation (POCMA) from _Right, if necessary, is complete
+        // pre: *this owns no memory, iterators orphaned
+        // (note: _Buf/_Ptr/_Mysize/_Myres may be garbage init)
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+
+#if !defined(_INSERT_STRING_ANNOTATION)
+        if constexpr (_Can_memcpy_val) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+#if _ITERATOR_DEBUG_LEVEL != 0
+                if (_Right_data._Large_mode_engaged()) {
+                    // take ownership of _Right's iterators along with its buffer
+                    _Swap_proxy_and_iterators(_Right);
+                } else {
+                    _Right_data._Orphan_all();
+                }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+                const auto _My_data_mem =
+                    reinterpret_cast<unsigned char*>(_STD addressof(_Mypair._Myval2)) + _Memcpy_val_offset;
+                const auto _Right_data_mem =
+                    reinterpret_cast<const unsigned char*>(_STD addressof(_Right._Mypair._Myval2)) + _Memcpy_val_offset;
+                _CSTD memcpy(_My_data_mem, _Right_data_mem, _Memcpy_val_size);
+
+                _Right_data._Mysize = 0;
+                _Right_data._Myres  = _Small_string_capacity;
+                _Right_data._Activate_SSO_buffer();
+                _Traits::assign(_Right_data._Bx._Buf[0], _Elem());
+                return;
+            }
+        }
+#endif // ^^^ !defined(_INSERT_STRING_ANNOTATION) ^^^
+
+        if (_Right_data._Large_mode_engaged()) { // steal buffer
+            _Swap_proxy_and_iterators(_Right);
+
+            _Construct_in_place(_My_data._Bx._Ptr, _Right_data._Bx._Ptr);
+            _Right_data._Bx._Switch_to_buf();
+        } else { // copy small string buffer
+            _Right_data._Orphan_all();
+
+            _My_data._Activate_SSO_buffer();
+            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, static_cast<size_t>(_Right_data._Mysize + 1));
+        }
+
+        _My_data._Myres  = _Right_data._Myres;
+        _My_data._Mysize = _Right_data._Mysize;
+
+        _Right_data._Mysize = 0;
+        _Right_data._Myres  = _Small_string_capacity;
+        _Traits::assign(_Right_data._Bx._Buf[0], _Elem());
+    }
+
+#if _HAS_CXX23
+    constexpr void _Move_construct_from_substr(basic_string& _Right, const size_type _Roff, const size_type _Size_max) {
+        auto& _Right_data = _Right._Mypair._Myval2;
+        _Right_data._Check_offset(_Roff);
+
+        const auto _Result_size = _Right_data._Clamp_suffix_size(_Roff, _Size_max);
+        const auto _Right_ptr   = _Right_data._Myptr();
+        auto& _Al               = _Getal();
+        if (_Allocators_equal(_Al, _Right._Getal()) && _Result_size > _Small_string_capacity) {
+            _Mypair._Myval2._Alloc_proxy(_STD _Get_proxy_allocator(_Al));
+
+            if (_Roff != 0) {
+                _Traits::move(_Right_ptr, _Right_ptr + _Roff, static_cast<size_t>(_Result_size));
+            }
+            _Right._Eos(_Result_size);
+            _Take_contents(_Right);
+        } else {
+            _Construct<_Construct_strategy::_From_ptr>(_Right_ptr + _Roff, _Result_size);
+        }
+    }
+#endif // _HAS_CXX23
+
+public:
+    _CONSTEXPR20 basic_string(initializer_list<_Elem> _Ilist, const _Alloc& _Al = allocator_type())
+        : _Mypair(_One_then_variadic_args_t{}, _Al) {
+        _Construct<_Construct_strategy::_From_ptr>(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 basic_string& operator=(initializer_list<_Elem> _Ilist) {
+        return assign(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 basic_string& operator+=(initializer_list<_Elem> _Ilist) {
+        return append(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 basic_string& assign(initializer_list<_Elem> _Ilist) {
+        return assign(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 basic_string& append(initializer_list<_Elem> _Ilist) {
+        return append(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 iterator insert(const const_iterator _Where, const initializer_list<_Elem> _Ilist) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        insert(_Off, _Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const initializer_list<_Elem> _Ilist) {
+        // replace with initializer_list
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Offset = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
+        return replace(_Offset, _Length, _Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
+    }
+
+    _CONSTEXPR20 ~basic_string() noexcept {
+        _Tidy_deallocate();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        auto _Alproxy            = _STD _Get_proxy_allocator(_Getal());
+        const auto _To_delete    = _Mypair._Myval2._Myproxy;
+        _Mypair._Myval2._Myproxy = nullptr;
+        _Delete_plain_internal(_Alproxy, _To_delete);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+    static constexpr auto npos{static_cast<size_type>(-1)};
+
+    _CONSTEXPR20 basic_string& operator=(const basic_string& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al             = _Getal();
+        const auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alty>) {
+            if (_Al != _Right_al) {
+                auto _Alproxy       = _STD _Get_proxy_allocator(_Al);
+                auto _Right_alproxy = _STD _Get_proxy_allocator(_Right_al);
+                _Container_proxy_ptr<_Alty> _New_proxy(_Right_alproxy, _Leave_proxy_unbound{}); // throws
+
+                const size_type _Right_size   = _Right._Mypair._Myval2._Mysize;
+                const _Elem* const _Right_ptr = _Right._Mypair._Myval2._Myptr();
+                if (_Right_size > _Small_string_capacity) {
+                    size_type _New_capacity = _Calculate_growth(_Right_size, _Small_string_capacity, _Right.max_size());
+                    auto _Right_al_non_const = _Right_al;
+                    const pointer _New_ptr   = _Allocate_for_capacity(_Right_al_non_const, _New_capacity); // throws
+                    _Traits::copy(_Unfancy(_New_ptr), _Right_ptr, _Right_size + 1);
+
+                    _Tidy_deallocate();
+                    _Construct_in_place(_Mypair._Myval2._Bx._Ptr, _New_ptr);
+                    _Mypair._Myval2._Mysize = _Right_size;
+                    _Mypair._Myval2._Myres  = _New_capacity;
+                    _ASAN_STRING_CREATE(*this);
+                } else {
+                    _Tidy_deallocate();
+                    _Traits::copy(_Mypair._Myval2._Bx._Buf, _Right_ptr, _Right_size + 1);
+                    _Mypair._Myval2._Mysize = _Right_size;
+                    _Mypair._Myval2._Myres  = _Small_string_capacity;
+                }
+
+                _Pocca(_Al, _Right_al);
+                _New_proxy._Bind(_Alproxy, _STD addressof(_Mypair._Myval2));
+                return *this;
+            }
+        }
+
+        _Pocca(_Al, _Right_al);
+        assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        return *this;
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& operator=(const _StringViewIsh& _Right) {
+        return assign(_Right);
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& operator=(_In_z_ const _Elem* const _Ptr) {
+        return assign(_Ptr);
+    }
+
+#if _HAS_CXX23
+    basic_string& operator=(nullptr_t) = delete;
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string& operator=(const _Elem _Ch) { // assign {_Ch, _Elem()}
+        _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, 1);
+        _Mypair._Myval2._Mysize = 1;
+        _Elem* const _Ptr       = _Mypair._Myval2._Myptr();
+        _Traits::assign(_Ptr[0], _Ch);
+        _Traits::assign(_Ptr[1], _Elem());
+        return *this;
+    }
+
+    _CONSTEXPR20 basic_string& operator+=(const basic_string& _Right) {
+        return append(_Right);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& operator+=(const _StringViewIsh& _Right) {
+        return append(_Right);
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& operator+=(_In_z_ const _Elem* const _Ptr) { // append [_Ptr, <null>)
+        return append(_Ptr);
+    }
+
+    _CONSTEXPR20 basic_string& operator+=(_Elem _Ch) {
+        push_back(_Ch);
+        return *this;
+    }
+
+    _CONSTEXPR20 basic_string& append(const basic_string& _Right) {
+        return _Append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string& append(const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
+        // append _Right [_Roff, _Roff + _Count)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
+        return _Append(_Right._Mypair._Myval2._Myptr() + _Roff, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& append(const _StringViewIsh& _Right) {
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return _Append(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& append(
+        const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
+        // append _Right [_Roff, _Roff + _Count)
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return append(_As_view.substr(static_cast<size_t>(_Roff), static_cast<size_t>(_Count)));
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& append(
+        _In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // append [_Ptr, _Ptr + _Count)
+        return _Append(_Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& append(_In_z_ const _Elem* const _Ptr) { // append [_Ptr, <null>)
+        return _Append(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+    _CONSTEXPR20 basic_string& append(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch) {
+        // append _Count * _Ch
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
+            const auto _New_size = static_cast<size_type>(_Old_size + _Count);
+            _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Traits::assign(_Old_ptr + _Old_size, static_cast<size_t>(_Count), _Ch);
+            _Traits::assign(_Old_ptr[_Old_size + _Count], _Elem());
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Count,
+                const _Elem _Ch) static {
+                _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size));
+                _Traits::assign(_New_ptr + _Old_size, static_cast<size_t>(_Count), _Ch);
+                _Traits::assign(_New_ptr[_Old_size + _Count], _Elem());
+            },
+            _Count, _Ch);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 basic_string& append(const _Iter _First, const _Iter _Last) {
+        // append [_First, _Last), input iterators
+        _STD _Adl_verify_range(_First, _Last);
+        const auto _UFirst = _STD _Get_unwrapped(_First);
+        const auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_elem_cvptr<decltype(_UFirst)>::value) {
+            return _Append(_UFirst, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+        } else {
+            const basic_string _Right(_UFirst, _ULast, get_allocator());
+            return _Append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& append_range(_Rng&& _Range) {
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            return _Append(_RANGES data(_Range), _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            return _Append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string& assign(const basic_string& _Right) {
+        *this = _Right;
+        return *this;
+    }
+
+    _CONSTEXPR20 basic_string& assign(const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
+        // assign _Right [_Roff, _Roff + _Count)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
+        return _Assign(_Right._Mypair._Myval2._Myptr() + _Roff, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& assign(const _StringViewIsh& _Right) {
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return _Assign(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& assign(
+        const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
+        // assign _Right [_Roff, _Roff + _Count)
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return assign(_As_view.substr(static_cast<size_t>(_Roff), static_cast<size_t>(_Count)));
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& assign(
+        _In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // assign [_Ptr, _Ptr + _Count)
+        return _Assign(_Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& assign(_In_z_ const _Elem* const _Ptr) {
+        return _Assign(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+    _CONSTEXPR20 basic_string& assign(_CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch) {
+        // assign _Count * _Ch
+        if (_Count <= _Mypair._Myval2._Myres) {
+            _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, _Count);
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Mypair._Myval2._Mysize = _Count;
+            _Traits::assign(_Old_ptr, _Count, _Ch);
+            _Traits::assign(_Old_ptr[_Count], _Elem());
+            return *this;
+        }
+
+        return _Reallocate_for(
+            _Count,
+            [](_Elem* const _New_ptr, const size_type _Count, const _Elem _Ch) static {
+                _Traits::assign(_New_ptr, _Count, _Ch);
+                _Traits::assign(_New_ptr[_Count], _Elem());
+            },
+            _Ch);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 basic_string& assign(const _Iter _First, const _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        const auto _UFirst = _STD _Get_unwrapped(_First);
+        const auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_elem_cvptr<decltype(_UFirst)>::value) {
+            return _Assign(_UFirst, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+        } else {
+            basic_string _Right(_UFirst, _ULast, get_allocator());
+            if (_Mypair._Myval2._Myres < _Right._Mypair._Myval2._Myres) {
+                _Mypair._Myval2._Orphan_all();
+                _Swap_data(_Right);
+                return *this;
+            } else {
+                return _Assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+            }
+        }
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& assign_range(_Rng&& _Range) {
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            return _Assign(_RANGES data(_Range), _Count);
+        } else {
+            basic_string _Right(from_range, _Range, get_allocator());
+            if (_Mypair._Myval2._Myres < _Right._Mypair._Myval2._Myres) {
+                _Mypair._Myval2._Orphan_all();
+                _Swap_data(_Right);
+                return *this;
+            } else {
+                return _Assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+            }
+        }
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string& insert(const size_type _Off, const basic_string& _Right) {
+        // insert _Right at _Off
+        return _Insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string& insert(
+        const size_type _Off, const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
+        // insert _Right [_Roff, _Roff + _Count) at _Off
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
+        return _Insert(_Off, _Right._Mypair._Myval2._Myptr() + _Roff, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& insert(const size_type _Off, const _StringViewIsh& _Right) {
+        // insert _Right at _Off
+        const basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return _Insert(_Off, _As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& insert(
+        const size_type _Off, const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
+        // insert _Right [_Roff, _Roff + _Count) at _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return insert(_Off, _As_view.substr(static_cast<size_t>(_Roff), static_cast<size_t>(_Count)));
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& insert(
+        const size_type _Off, _In_reads_(_Count) const _Elem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // insert [_Ptr, _Ptr + _Count) at _Off
+        return _Insert(_Off, _Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& insert(const size_type _Off, _In_z_ const _Elem* const _Ptr) {
+        // insert [_Ptr, <null>) at _Off
+        return _Insert(_Off, _Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+    _CONSTEXPR20 basic_string& insert(
+        const size_type _Off, _CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch) {
+        // insert _Count * _Ch at _Off
+        _Mypair._Myval2._Check_offset(_Off);
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
+            const auto _New_size = static_cast<size_type>(_Old_size + _Count);
+            _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Elem* const _Insert_at = _Old_ptr + _Off;
+            _Traits::move(
+                _Insert_at + _Count, _Insert_at, static_cast<size_t>(_Old_size - _Off + 1)); // move suffix + null down
+            _Traits::assign(_Insert_at, static_cast<size_t>(_Count), _Ch); // fill hole
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
+                const size_type _Count, const _Elem _Ch) static {
+                _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Off));
+                _Traits::assign(_New_ptr + _Off, static_cast<size_t>(_Count), _Ch);
+                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off, static_cast<size_t>(_Old_size - _Off + 1));
+            },
+            _Off, _Count, _Ch);
+    }
+
+    _CONSTEXPR20 iterator insert(const const_iterator _Where, const _Elem _Ch) { // insert _Ch at _Where
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        insert(_Off, 1, _Ch);
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    _CONSTEXPR20 iterator insert(
+        const const_iterator _Where, _CRT_GUARDOVERFLOW const size_type _Count, const _Elem _Ch) {
+        // insert _Count * _Elem at _Where
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        insert(_Off, _Count, _Ch);
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 iterator insert(const const_iterator _Where, const _Iter _First, const _Iter _Last) {
+        // insert [_First, _Last) at _Where, input iterators
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        _STD _Adl_verify_range(_First, _Last);
+        const auto _UFirst = _STD _Get_unwrapped(_First);
+        const auto _ULast  = _STD _Get_unwrapped(_Last);
+        if constexpr (_Is_elem_cvptr<decltype(_UFirst)>::value) {
+            _Insert(_Off, _UFirst, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
+        } else {
+            const basic_string _Right(_UFirst, _ULast, get_allocator());
+            _Insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr iterator insert_range(const const_iterator _Where, _Rng&& _Range) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            _Insert(_Off, _RANGES data(_Range), _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            _Insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+
+        return begin() + static_cast<difference_type>(_Off);
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 basic_string& erase(const size_type _Off = 0) { // erase elements [_Off, ...)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Eos(_Off);
+        return *this;
+    }
+
+private:
+    _CONSTEXPR20 basic_string& _Erase_noexcept(const size_type _Off, size_type _Count) noexcept {
+        _Count                    = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        _Elem* const _My_ptr      = _Mypair._Myval2._Myptr();
+        _Elem* const _Erase_at    = _My_ptr + _Off;
+        const auto _New_size      = static_cast<size_type>(_Old_size - _Count);
+        _Traits::move(
+            _Erase_at, _Erase_at + _Count, static_cast<size_t>(_New_size - _Off + 1)); // move suffix + null up
+        _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+        _Mypair._Myval2._Mysize = _New_size;
+        return *this;
+    }
+
+public:
+    _CONSTEXPR20 basic_string& erase(const size_type _Off, const size_type _Count) {
+        // erase elements [_Off, _Off + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Erase_noexcept(_Off, _Count);
+    }
+
+    _CONSTEXPR20 iterator erase(const const_iterator _Where) noexcept /* strengthened */ {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Where._Getcont() == _STD addressof(_Mypair._Myval2), "string iterator incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
+        _Erase_noexcept(_Off, 1);
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    _CONSTEXPR20 iterator erase(const const_iterator _First, const const_iterator _Last) noexcept /* strengthened */ {
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        _Erase_noexcept(_Off, static_cast<size_type>(_Last._Ptr - _First._Ptr));
+        return begin() + static_cast<difference_type>(_Off);
+    }
+
+    _CONSTEXPR20 void clear() noexcept { // erase all
+        _Eos(0);
+    }
+
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, const size_type _Nx, const basic_string& _Right) {
+        // replace [_Off, _Off + _Nx) with _Right
+        return _Replace(_Off, _Nx, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+    }
+
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, size_type _Nx, const basic_string& _Right,
+        const size_type _Roff, size_type _Count = npos) {
+        // replace [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
+        return _Replace(_Off, _Nx, _Right._Mypair._Myval2._Myptr() + _Roff, _Count);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right) {
+        // replace [_Off, _Off + _Nx) with _Right
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return _Replace(_Off, _Nx, _As_view.data(), _Convert_size<size_type>(_As_view.size()));
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right,
+        const size_type _Roff, const size_type _Count = npos) {
+        // replace [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return replace(_Off, _Nx, _As_view.substr(static_cast<size_t>(_Roff), static_cast<size_t>(_Count)));
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& replace(
+        const size_type _Off, size_type _Nx, _In_reads_(_Count) const _Elem* const _Ptr, const size_type _Count) {
+        // replace [_Off, _Off + _Nx) with [_Ptr, _Ptr + _Count)
+        return _Replace(_Off, _Nx, _Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, const size_type _Nx, _In_z_ const _Elem* const _Ptr) {
+        // replace [_Off, _Off + _Nx) with [_Ptr, <null>)
+        return _Replace(_Off, _Nx, _Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
+    }
+
+    _CONSTEXPR20 basic_string& replace(const size_type _Off, size_type _Nx, const size_type _Count, const _Elem _Ch) {
+        // replace [_Off, _Off + _Nx) with _Count * _Ch
+        _Mypair._Myval2._Check_offset(_Off);
+        _Nx = _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx);
+        if (_Count == _Nx) {
+            _Traits::assign(_Mypair._Myval2._Myptr() + _Off, static_cast<size_t>(_Count), _Ch);
+            return *this;
+        }
+
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Count < _Nx || _Count - _Nx <= _Mypair._Myval2._Myres - _Old_size) {
+            // either we are shrinking, or the growth fits
+            // may temporarily overflow; OK because size_type must be unsigned
+            const auto _New_size = static_cast<size_type>(_Old_size + _Count - _Nx);
+            _ASAN_STRING_REMOVE(*this);
+            _Mypair._Myval2._Mysize = _New_size;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Elem* const _Insert_at = _Old_ptr + _Off;
+            _Traits::move(_Insert_at + _Count, _Insert_at + _Nx, static_cast<size_t>(_Old_size - _Nx - _Off + 1));
+            _Traits::assign(_Insert_at, static_cast<size_t>(_Count), _Ch);
+            _ASAN_STRING_CREATE(*this);
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            static_cast<size_type>(_Count - _Nx),
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
+                const size_type _Nx, const size_type _Count, const _Elem _Ch) static {
+                _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Off));
+                _Traits::assign(_New_ptr + _Off, static_cast<size_t>(_Count), _Ch);
+                _Traits::copy(
+                    _New_ptr + _Off + _Count, _Old_ptr + _Off + _Nx, static_cast<size_t>(_Old_size - _Nx - _Off + 1));
+            },
+            _Off, _Nx, _Count, _Ch);
+    }
+
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const basic_string& _Right) {
+        // replace [_First, _Last) with _Right
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Right);
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const _StringViewIsh& _Right) {
+        // replace [_First, _Last) with _Right
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Right);
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 basic_string& replace(const const_iterator _First, const const_iterator _Last,
+        _In_reads_(_Count) const _Elem* const _Ptr, const size_type _Count) {
+        // replace [_First, _Last) with [_Ptr, _Ptr + _Count)
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Ptr, _Count);
+    }
+
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, _In_z_ const _Elem* const _Ptr) {
+        // replace [_First, _Last) with [_Ptr, <null>)
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Ptr);
+    }
+
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const size_type _Count, const _Elem _Ch) {
+        // replace [_First, _Last) with _Count * _Ch
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
+            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Count, _Ch);
+    }
+
+    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
+    _CONSTEXPR20 basic_string& replace(
+        const const_iterator _First, const const_iterator _Last, const _Iter _First2, const _Iter _Last2) {
+        // replace [_First, _Last) with [_First2, _Last2), input iterators
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off    = static_cast<size_type>(_STD _Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
+        _STD _Adl_verify_range(_First2, _Last2);
+        const auto _UFirst2 = _STD _Get_unwrapped(_First2);
+        const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+        if constexpr (_Is_elem_cvptr<decltype(_UFirst2)>::value) {
+            return _Replace(
+                _Off, _Length, _UFirst2, _STD _Convert_size<size_type>(static_cast<size_t>(_ULast2 - _UFirst2)));
+        } else {
+            const basic_string _Right(_UFirst2, _ULast2, get_allocator());
+            return _Replace(_Off, _Length, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<_Elem> _Rng>
+    constexpr basic_string& replace_with_range(const const_iterator _First, const const_iterator _Last, _Rng&& _Range) {
+        _STD _Adl_verify_range(_First, _Last);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First._Getcont() == _STD addressof(_Mypair._Myval2), "string iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        const auto _Off    = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
+        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
+
+        if constexpr (_RANGES sized_range<_Rng> && _Contiguous_range_of<_Rng, _Elem>) {
+            const auto _Count = _Convert_size<size_type>(_To_unsigned_like(_RANGES size(_Range)));
+            return _Replace(_Off, _Length, _RANGES data(_Range), _Count);
+        } else {
+            const basic_string _Right(from_range, _Range, get_allocator());
+            return _Replace(_Off, _Length, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
+        }
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD _CONSTEXPR20 iterator begin() noexcept {
+        return iterator(_Refancy<pointer>(_Mypair._Myval2._Myptr()), _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator begin() const noexcept {
+        return const_iterator(_Refancy<const_pointer>(_Mypair._Myval2._Myptr()), _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 iterator end() noexcept {
+        return iterator(
+            _Refancy<pointer>(_Mypair._Myval2._Myptr()) + static_cast<difference_type>(_Mypair._Myval2._Mysize),
+            _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator end() const noexcept {
+        return const_iterator(
+            _Refancy<const_pointer>(_Mypair._Myval2._Myptr()) + static_cast<difference_type>(_Mypair._Myval2._Mysize),
+            _STD addressof(_Mypair._Myval2));
+    }
+
+    _NODISCARD _CONSTEXPR20 _Elem* _Unchecked_begin() noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Elem* _Unchecked_begin() const noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+
+    _NODISCARD _CONSTEXPR20 _Elem* _Unchecked_end() noexcept {
+        return _Mypair._Myval2._Myptr() + _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 const _Elem* _Unchecked_end() const noexcept {
+        return _Mypair._Myval2._Myptr() + _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD _CONSTEXPR20 reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _CONSTEXPR20 void shrink_to_fit() { // reduce capacity
+        auto& _My_data = _Mypair._Myval2;
+
+        if (!_My_data._Large_mode_engaged()) { // can't shrink from small mode
+            return;
+        }
+
+        if (_My_data._Mysize <= _Small_string_capacity) {
+            _Become_small();
+            return;
+        }
+
+        size_type _Target_capacity = (_STD min) (static_cast<size_type>(_My_data._Mysize | _Alloc_mask), max_size());
+        if (_Target_capacity < _My_data._Myres) { // worth shrinking, do it
+            auto& _Al = _Getal();
+            const pointer _New_ptr =
+                _Allocate_for_capacity<_Allocation_policy::_Exactly>(_Al, _Target_capacity); // throws
+            _ASAN_STRING_REMOVE(*this);
+
+            _My_data._Orphan_all();
+            _Traits::copy(_Unfancy(_New_ptr), _Unfancy(_My_data._Bx._Ptr), static_cast<size_t>(_My_data._Mysize + 1));
+            _Deallocate_for_capacity(_Al, _My_data._Bx._Ptr, _My_data._Myres);
+            _My_data._Bx._Ptr = _New_ptr;
+            _My_data._Myres   = _Target_capacity;
+            _ASAN_STRING_CREATE(*this);
+        }
+    }
+
+    _NODISCARD _CONSTEXPR20 reference at(const size_type _Off) {
+        _Mypair._Myval2._Check_offset_exclusive(_Off);
+        return _Mypair._Myval2._Myptr()[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference at(const size_type _Off) const {
+        _Mypair._Myval2._Check_offset_exclusive(_Off);
+        return _Mypair._Myval2._Myptr()[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 reference operator[](const size_type _Off) noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off <= _Mypair._Myval2._Mysize, "string subscript out of range");
+#endif
+
+        return _Mypair._Myval2._Myptr()[_Off];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference operator[](const size_type _Off) const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Off <= _Mypair._Myval2._Mysize, "string subscript out of range");
+#endif
+
+        return _Mypair._Myval2._Myptr()[_Off];
+    }
+
+#if _HAS_CXX17
+    /* implicit */ _CONSTEXPR20 operator basic_string_view<_Elem, _Traits>() const noexcept {
+        // return a string_view around *this's character-type sequence
+        return basic_string_view<_Elem, _Traits>{
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)};
+    }
+#endif // _HAS_CXX17
+
+    _CONSTEXPR20 void push_back(const _Elem _Ch) { // insert element at end
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Old_size < _Mypair._Myval2._Myres) {
+            const auto _New_size = static_cast<size_type>(_Old_size + 1);
+            _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+            _Elem* const _Ptr       = _Mypair._Myval2._Myptr();
+            _Traits::assign(_Ptr[_Old_size], _Ch);
+            _Traits::assign(_Ptr[_Old_size + 1], _Elem());
+            return;
+        }
+
+        _Reallocate_grow_by(
+            1,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const _Elem _Ch) static {
+                _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size));
+                _Traits::assign(_New_ptr[_Old_size], _Ch);
+                _Traits::assign(_New_ptr[_Old_size + 1], _Elem());
+            },
+            _Ch);
+    }
+
+    _CONSTEXPR20 void pop_back() noexcept /* strengthened */ {
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+
+#if _MSVC_STL_HARDENING_BASIC_STRING || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Old_size != 0, "pop_back() called on empty string");
+#endif
+
+        _Eos(static_cast<size_type>(_Old_size - 1));
+    }
+
+    _NODISCARD _CONSTEXPR20 reference front() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "front() called on empty string");
+#endif
+
+        return _Mypair._Myval2._Myptr()[0];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference front() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "front() called on empty string");
+#endif
+
+        return _Mypair._Myval2._Myptr()[0];
+    }
+
+    _NODISCARD _CONSTEXPR20 reference back() noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "back() called on empty string");
+#endif
+
+        return _Mypair._Myval2._Myptr()[_Mypair._Myval2._Mysize - 1];
+    }
+
+    _NODISCARD _CONSTEXPR20 const_reference back() const noexcept /* strengthened */ {
+#if _MSVC_STL_HARDENING_BASIC_STRING || _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_Mypair._Myval2._Mysize != 0, "back() called on empty string");
+#endif
+
+        return _Mypair._Myval2._Myptr()[_Mypair._Myval2._Mysize - 1];
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ret_z_ const _Elem* c_str() const noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+
+    _NODISCARD _CONSTEXPR20 _Ret_z_ const _Elem* data() const noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+
+#if _HAS_CXX17
+    _NODISCARD _CONSTEXPR20 _Ret_z_ _Elem* data() noexcept {
+        return _Mypair._Myval2._Myptr();
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type length() const noexcept {
+        return _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type size() const noexcept {
+        return _Mypair._Myval2._Mysize;
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type max_size() const noexcept {
+        const size_type _Alloc_max   = _Alty_traits::max_size(_Getal());
+        const size_type _Storage_max = // can always store small string
+            (_STD max) (_Alloc_max, static_cast<size_type>(_BUF_SIZE));
+        constexpr auto _Diff_max  = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        const auto _Effective_max = static_cast<size_type>(_Storage_max - 1); // -1 is for null terminator and/or npos
+        return (_STD min) (_Diff_max, _Effective_max);
+    }
+
+    _CONSTEXPR20 void resize(_CRT_GUARDOVERFLOW const size_type _New_size, const _Elem _Ch = _Elem()) {
+        // determine new length, padding with _Ch elements as needed
+        const size_type _Old_size = size();
+        if (_New_size <= _Old_size) {
+            _Eos(_New_size);
+        } else {
+            append(static_cast<size_type>(_New_size - _Old_size), _Ch);
+        }
+    }
+
+    template <class _Operation>
+    constexpr void
+#if _HAS_CXX23
+        resize_and_overwrite
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        _Resize_and_overwrite
+#endif // ^^^ !_HAS_CXX23 ^^^
+        (_CRT_GUARDOVERFLOW const size_type _New_size, _Operation _Op) {
+        if (_Mypair._Myval2._Myres < _New_size) {
+            _Reallocate_grow_by(static_cast<size_type>(_New_size - _Mypair._Myval2._Mysize),
+                [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size) static {
+                    _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size + 1));
+                });
+        } else {
+            _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+        }
+
+        auto _Arg_ptr           = _Mypair._Myval2._Myptr();
+        auto _Arg_size          = _New_size;
+        const auto _Result_size = _STD move(_Op)(_Arg_ptr, _Arg_size);
+        using _Result_type      = remove_const_t<decltype(_Result_size)>;
+        static_assert(_Integer_like<_Result_type>,
+            "the return type of the operation must be integer-like, N5014 [string.capacity]/8");
+
+        const auto _Result_as_size_type = static_cast<size_type>(_Result_size);
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (_Signed_integer_like<_Result_type>) {
+            _STL_VERIFY(_Result_size >= 0, "the returned size can't be smaller than 0, N5014 [string.capacity]/9.2");
+        }
+        _STL_VERIFY(_Result_as_size_type <= _New_size,
+            "the returned size can't be greater than the passed size, N5014 [string.capacity]/9.3");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+        _Eos(_Result_as_size_type);
+    }
+
+#if _HAS_CXX23
+    template <class _Operation>
+    constexpr void _Resize_and_overwrite(_CRT_GUARDOVERFLOW const size_type _New_size, _Operation _Op) {
+        resize_and_overwrite(_New_size, _Op);
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD _CONSTEXPR20 size_type capacity() const noexcept {
+        return _Mypair._Myval2._Myres;
+    }
+
+#if _HAS_CXX20
+    constexpr void reserve(_CRT_GUARDOVERFLOW const size_type _Newcap) {
+        // determine new minimum length of allocated storage
+        if (_Mypair._Myval2._Myres >= _Newcap) { // requested capacity is not larger than current capacity, ignore
+            return; // nothing to do
+        }
+
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        _Reallocate_grow_by(static_cast<size_type>(_Newcap - _Old_size),
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size) static {
+                _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size + 1));
+            });
+
+        // `_Reallocate_grow_by` calls `_ASAN_STRING_CREATE` assuming that the string
+        // has size (initialized memory) equal to its new capacity (allocated memory).
+        // This is not true for the `reserve` method, so we modify the ASan annotation.
+        _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, _Old_size);
+        _Mypair._Myval2._Mysize = _Old_size;
+    }
+
+    _CXX20_DEPRECATE_STRING_RESERVE_WITHOUT_ARGUMENT void reserve() {
+        if (_Mypair._Myval2._Mysize == 0 && _Mypair._Myval2._Large_mode_engaged()) {
+            _Become_small();
+        }
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    void reserve(_CRT_GUARDOVERFLOW const size_type _Newcap = 0) { // determine new minimum length of allocated storage
+        if (_Mypair._Myval2._Mysize > _Newcap) { // requested capacity is not large enough for current size, ignore
+            return; // nothing to do
+        }
+
+        if (_Mypair._Myval2._Myres == _Newcap) { // we're already at the requested capacity
+            return; // nothing to do
+        }
+
+        if (_Mypair._Myval2._Myres < _Newcap) { // reallocate to grow
+            const size_type _Old_size = _Mypair._Myval2._Mysize;
+            _Reallocate_grow_by(static_cast<size_type>(_Newcap - _Old_size),
+                [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size) static {
+                    _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size + 1));
+                });
+
+            // `_Reallocate_grow_by` calls `_ASAN_STRING_CREATE` assuming that the string
+            // has size (initialized memory) equal to its new capacity (allocated memory).
+            // This is not true for the `reserve` method, so we modify the ASan annotation.
+            _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, _Old_size);
+            _Mypair._Myval2._Mysize = _Old_size;
+            return;
+        }
+
+        if (_Newcap <= _Small_string_capacity && _Mypair._Myval2._Large_mode_engaged()) {
+            // deallocate everything; switch back to "small" mode
+            _Become_small();
+            return;
+        }
+
+        // ignore requests to reserve to [_Small_string_capacity + 1, _Myres)
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD_EMPTY_MEMBER _CONSTEXPR20 bool empty() const noexcept {
+        return _Mypair._Myval2._Mysize == 0;
+    }
+
+    _CONSTEXPR20 size_type copy(
+        _Out_writes_(_Count) _Elem* const _Ptr, size_type _Count, const size_type _Off = 0) const {
+        // copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Count = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
+        _Traits::copy(_Ptr, _Mypair._Myval2._Myptr() + _Off, static_cast<size_t>(_Count));
+        return _Count;
+    }
+
+    _CONSTEXPR20 _Pre_satisfies_(_Dest_size >= _Count) size_type
+        _Copy_s(_Out_writes_all_(_Dest_size) _Elem* const _Dest, const size_type _Dest_size, size_type _Count,
+            const size_type _Off = 0) const {
+        // copy [_Off, _Off + _Count) to [_Dest, _Dest + _Dest_size)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Count = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
+        _Traits::_Copy_s(_Dest, _Dest_size, _Mypair._Myval2._Myptr() + _Off, _Count);
+        return _Count;
+    }
+
+    static _CONSTEXPR20 void _Swap_bx_large_with_small(_Scary_val& _Starts_large, _Scary_val& _Starts_small) noexcept {
+        // exchange a string in large mode with one in small mode
+        const pointer _Ptr = _Starts_large._Bx._Ptr;
+        _Starts_large._Bx._Switch_to_buf();
+        _Traits::copy(_Starts_large._Bx._Buf, _Starts_small._Bx._Buf, _BUF_SIZE);
+
+        _Construct_in_place(_Starts_small._Bx._Ptr, _Ptr);
+    }
+
+    _CONSTEXPR20 void _Swap_data(basic_string& _Right) noexcept {
+        using _STD swap;
+
+        auto& _My_data    = _Mypair._Myval2;
+        auto& _Right_data = _Right._Mypair._Myval2;
+
+#if !defined(_INSERT_STRING_ANNOTATION)
+        if constexpr (_Can_memcpy_val) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                const auto _My_data_mem =
+                    reinterpret_cast<unsigned char*>(_STD addressof(_My_data)) + _Memcpy_val_offset;
+                const auto _Right_data_mem =
+                    reinterpret_cast<unsigned char*>(_STD addressof(_Right_data)) + _Memcpy_val_offset;
+                unsigned char _Temp_mem[_Memcpy_val_size];
+                _CSTD memcpy(_Temp_mem, _My_data_mem, _Memcpy_val_size);
+                _CSTD memcpy(_My_data_mem, _Right_data_mem, _Memcpy_val_size);
+                _CSTD memcpy(_Right_data_mem, _Temp_mem, _Memcpy_val_size);
+
+                return;
+            }
+        }
+#endif // ^^^ !defined(_INSERT_STRING_ANNOTATION) ^^^
+
+        const bool _My_large    = _My_data._Large_mode_engaged();
+        const bool _Right_large = _Right_data._Large_mode_engaged();
+
+        if (_My_large && _Right_large) { // swap buffers, iterators preserved
+            swap(_My_data._Bx._Ptr, _Right_data._Bx._Ptr); // intentional ADL
+        } else if (_My_large) { // swap large with small
+            _Swap_bx_large_with_small(_My_data, _Right_data);
+        } else if (_Right_large) { // swap small with large
+            _Swap_bx_large_with_small(_Right_data, _My_data);
+        } else {
+            _Elem _Temp_buf[_BUF_SIZE];
+            _Traits::copy(_Temp_buf, _My_data._Bx._Buf, static_cast<size_t>(_My_data._Mysize + 1));
+            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, static_cast<size_t>(_Right_data._Mysize + 1));
+            _Traits::copy(_Right_data._Bx._Buf, _Temp_buf, static_cast<size_t>(_My_data._Mysize + 1));
+        }
+
+        _STD swap(_My_data._Mysize, _Right_data._Mysize);
+        _STD swap(_My_data._Myres, _Right_data._Myres);
+    }
+
+    _CONSTEXPR20 void swap(basic_string& _Right) noexcept /* strengthened */ {
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+            auto& _My_data    = _Mypair._Myval2;
+            auto& _Right_data = _Right._Mypair._Myval2;
+
+            if (!_My_data._Large_mode_engaged()) {
+                _My_data._Orphan_all();
+            }
+
+            if (!_Right_data._Large_mode_engaged()) {
+                _Right_data._Orphan_all();
+            }
+
+            _My_data._Swap_proxy_and_iterators(_Right_data);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+            _Swap_data(_Right);
+        }
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find(const _StringViewIsh& _Right, const size_type _Off = 0) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for _Right beginning at or after _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find(const basic_string& _Right, const size_type _Off = 0) const noexcept {
+        // look for _Right beginning at or after _Off
+        return static_cast<size_type>(_Traits_find<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Right._Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Right._Mypair._Myval2._Mysize)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for [_Ptr, _Ptr + _Count) beginning at or after _Off
+        return static_cast<size_type>(
+            _Traits_find<_Traits>(_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize),
+                static_cast<size_t>(_Off), _Ptr, static_cast<size_t>(_Count)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find(_In_z_ const _Elem* const _Ptr, const size_type _Off = 0) const noexcept
+    /* strengthened */ {
+        // look for [_Ptr, <null>) beginning at or after _Off
+        return static_cast<size_type>(_Traits_find<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for _Ch at or after _Off
+        return static_cast<size_type>(_Traits_find_ch<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type rfind(const _StringViewIsh& _Right, const size_type _Off = npos) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for _Right beginning before _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_rfind<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type rfind(const basic_string& _Right, const size_type _Off = npos) const noexcept {
+        // look for _Right beginning before _Off
+        return static_cast<size_type>(_Traits_rfind<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Right._Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Right._Mypair._Myval2._Mysize)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type rfind(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for [_Ptr, _Ptr + _Count) beginning before _Off
+        return static_cast<size_type>(
+            _Traits_rfind<_Traits>(_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize),
+                static_cast<size_t>(_Off), _Ptr, static_cast<size_t>(_Count)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type rfind(_In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept
+    /* strengthened */ {
+        // look for [_Ptr, <null>) beginning before _Off
+        return static_cast<size_type>(_Traits_rfind<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type rfind(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for _Ch before _Off
+        return static_cast<size_type>(_Traits_rfind_ch<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(const _StringViewIsh& _Right, const size_type _Off = 0) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for one of _Right at or after _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(
+        const basic_string& _Right, const size_type _Off = 0) const noexcept {
+        // look for one of _Right at or after _Off
+        return static_cast<size_type>(_Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Right._Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Right._Mypair._Myval2._Mysize)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, _Ptr + _Count) at or after _Off
+        return static_cast<size_type>(
+            _Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize),
+                static_cast<size_t>(_Off), _Ptr, static_cast<size_t>(_Count)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = 0) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, <null>) at or after _Off
+        return static_cast<size_type>(_Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for _Ch at or after _Off
+        return static_cast<size_type>(_Traits_find_ch<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(const _StringViewIsh& _Right, const size_type _Off = npos) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for one of _Right before _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(const basic_string& _Right, size_type _Off = npos) const noexcept {
+        // look for one of _Right before _Off
+        return static_cast<size_type>(_Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Right._Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Right._Mypair._Myval2._Mysize)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, _Ptr + _Count) before _Off
+        return static_cast<size_type>(
+            _Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize),
+                static_cast<size_t>(_Off), _Ptr, static_cast<size_t>(_Count)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, <null>) before _Off
+        return static_cast<size_type>(_Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for _Ch before _Off
+        return static_cast<size_type>(_Traits_rfind_ch<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(const _StringViewIsh& _Right, const size_type _Off = 0) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for none of _Right at or after _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(
+        const basic_string& _Right, const size_type _Off = 0) const noexcept {
+        // look for none of _Right at or after _Off
+        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Right._Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Right._Mypair._Myval2._Mysize)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(_In_reads_(_Count) const _Elem* const _Ptr,
+        const size_type _Off, const size_type _Count) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, _Ptr + _Count) at or after _Off
+        return static_cast<size_type>(
+            _Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize),
+                static_cast<size_t>(_Off), _Ptr, static_cast<size_t>(_Count)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(
+        _In_z_ const _Elem* const _Ptr, size_type _Off = 0) const noexcept /* strengthened */ {
+        // look for one of [_Ptr, <null>) at or after _Off
+        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_first_not_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
+        // look for non-_Ch at or after _Off
+        return static_cast<size_type>(_Traits_find_not_ch<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ch));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(const _StringViewIsh& _Right, const size_type _Off = npos) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // look for none of _Right before _Off
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _As_view.data(), _As_view.size()));
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(
+        const basic_string& _Right, const size_type _Off = npos) const noexcept {
+        // look for none of _Right before _Off
+        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Right._Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Right._Mypair._Myval2._Mysize)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(_In_reads_(_Count) const _Elem* const _Ptr, const size_type _Off,
+        const size_type _Count) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, _Ptr + _Count) before _Off
+        return static_cast<size_type>(
+            _Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize),
+                static_cast<size_t>(_Off), _Ptr, static_cast<size_t>(_Count)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(
+        _In_z_ const _Elem* const _Ptr, const size_type _Off = npos) const noexcept /* strengthened */ {
+        // look for none of [_Ptr, <null>) before _Off
+        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ptr, _Traits::length(_Ptr)));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type find_last_not_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
+        // look for non-_Ch before _Off
+        return static_cast<size_type>(_Traits_rfind_not_ch<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), static_cast<size_t>(_Off), _Ch));
+    }
+
+#if _HAS_CXX17
+    _NODISCARD bool _Starts_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
+        // Used exclusively by filesystem
+        return basic_string_view<_Elem, _Traits>(*this)._Starts_with(_Right);
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 basic_string substr(const size_type _Off = 0, const size_type _Count = npos)
+#if _HAS_CXX23
+        const&
+#else
+        const
+#endif
+    {
+        // return [_Off, _Off + _Count) as new string, default-constructing its allocator
+        return basic_string{*this, _Off, _Count};
+    }
+
+#if _HAS_CXX23
+    _NODISCARD constexpr basic_string substr(const size_type _Off = 0, const size_type _Count = npos) && {
+        // return [_Off, _Off + _Count) as new string, potentially moving, default-constructing its allocator
+        return basic_string{_STD move(*this), _Off, _Count};
+    }
+#endif // _HAS_CXX23
+
+    _CONSTEXPR20 bool _Equal(const basic_string& _Right) const noexcept {
+        // compare [0, size()) with _Right for equality
+        return _Traits_equal<_Traits>(_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize),
+            _Right._Mypair._Myval2._Myptr(), static_cast<size_t>(_Right._Mypair._Myval2._Mysize));
+    }
+
+    _CONSTEXPR20 bool _Equal(_In_z_ const _Elem* const _Ptr) const noexcept {
+        // compare [0, size()) with _Ptr for equality
+        return _Traits_equal<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), _Ptr, _Traits::length(_Ptr));
+    }
+
+#if _HAS_CXX17
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 int compare(const _StringViewIsh& _Right) const
+        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
+        // compare [0, size()) with _Right
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        return _Traits_compare<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), _As_view.data(), _As_view.size());
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 int compare(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right) const {
+        // compare [_Off, _Off + _Nx) with _Right
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off,
+            static_cast<size_t>(_Mypair._Myval2._Clamp_suffix_size(_Off, _Nx)), _As_view.data(), _As_view.size());
+    }
+
+    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
+    _NODISCARD _CONSTEXPR20 int compare(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right,
+        const size_type _Roff, const size_type _Count = npos) const {
+        // compare [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        basic_string_view<_Elem, _Traits> _As_view = _Right;
+        _Mypair._Myval2._Check_offset(_Off);
+        const auto _With_substr = _As_view.substr(static_cast<size_t>(_Roff), static_cast<size_t>(_Count));
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off,
+            static_cast<size_t>(_Mypair._Myval2._Clamp_suffix_size(_Off, _Nx)), _With_substr.data(),
+            _With_substr.size());
+    }
+#endif // _HAS_CXX17
+
+    _NODISCARD _CONSTEXPR20 int compare(const basic_string& _Right) const noexcept {
+        // compare [0, size()) with _Right
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize),
+            _Right._Mypair._Myval2._Myptr(), static_cast<size_t>(_Right._Mypair._Myval2._Mysize));
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(size_type _Off, size_type _Nx, const basic_string& _Right) const {
+        // compare [_Off, _Off + _Nx) with _Right
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off,
+            static_cast<size_t>(_Mypair._Myval2._Clamp_suffix_size(_Off, _Nx)), _Right._Mypair._Myval2._Myptr(),
+            static_cast<size_t>(_Right._Mypair._Myval2._Mysize));
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(const size_type _Off, const size_type _Nx, const basic_string& _Right,
+        const size_type _Roff, const size_type _Count = npos) const {
+        // compare [_Off, _Off + _Nx) with _Right [_Roff, _Roff + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        _Right._Mypair._Myval2._Check_offset(_Roff);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off,
+            static_cast<size_t>(_Mypair._Myval2._Clamp_suffix_size(_Off, _Nx)), _Right._Mypair._Myval2._Myptr() + _Roff,
+            static_cast<size_t>(_Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count)));
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(_In_z_ const _Elem* const _Ptr) const noexcept /* strengthened */ {
+        // compare [0, size()) with [_Ptr, <null>)
+        return _Traits_compare<_Traits>(
+            _Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize), _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(
+        const size_type _Off, const size_type _Nx, _In_z_ const _Elem* const _Ptr) const {
+        // compare [_Off, _Off + _Nx) with [_Ptr, <null>)
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off,
+            static_cast<size_t>(_Mypair._Myval2._Clamp_suffix_size(_Off, _Nx)), _Ptr, _Traits::length(_Ptr));
+    }
+
+    _NODISCARD _CONSTEXPR20 int compare(const size_type _Off, const size_type _Nx,
+        _In_reads_(_Count) const _Elem* const _Ptr, const size_type _Count) const {
+        // compare [_Off, _Off + _Nx) with [_Ptr, _Ptr + _Count)
+        _Mypair._Myval2._Check_offset(_Off);
+        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off,
+            static_cast<size_t>(_Mypair._Myval2._Clamp_suffix_size(_Off, _Nx)), _Ptr, static_cast<size_t>(_Count));
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr bool starts_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .starts_with(_Right);
+    }
+
+    _NODISCARD constexpr bool starts_with(const _Elem _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .starts_with(_Right);
+    }
+
+    _NODISCARD constexpr bool starts_with(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .starts_with(_Right);
+    }
+
+    _NODISCARD constexpr bool ends_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .ends_with(_Right);
+    }
+
+    _NODISCARD constexpr bool ends_with(const _Elem _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .ends_with(_Right);
+    }
+
+    _NODISCARD constexpr bool ends_with(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .ends_with(_Right);
+    }
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+    _NODISCARD constexpr bool contains(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .contains(_Right);
+    }
+
+    _NODISCARD constexpr bool contains(const _Elem _Right) const noexcept {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .contains(_Right);
+    }
+
+    _NODISCARD constexpr bool contains(const _Elem* const _Right) const noexcept /* strengthened */ {
+        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), static_cast<size_t>(_Mypair._Myval2._Mysize)}
+            .contains(_Right);
+    }
+#endif // _HAS_CXX23
+
+    _NODISCARD _CONSTEXPR20 allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+private:
+    _NODISCARD static _CONSTEXPR20 size_type _Calculate_growth(
+        const size_type _Requested, const size_type _Old, const size_type _Max) noexcept {
+        const auto _Masked = static_cast<size_type>(_Requested | _Alloc_mask);
+        if (_Masked > _Max) { // the mask overflows, settle for max_size()
+            return _Max;
+        }
+
+        if (_Old > _Max - _Old / 2) { // similarly, geometric overflows
+            return _Max;
+        }
+
+        return (_STD max) (_Masked, static_cast<size_type>(_Old + _Old / 2));
+    }
+
+    _NODISCARD _CONSTEXPR20 size_type _Calculate_growth(const size_type _Requested) const noexcept {
+        return _Calculate_growth(_Requested, _Mypair._Myval2._Myres, max_size());
+    }
+
+    template <class _Fty, class... _ArgTys>
+    _CONSTEXPR20 basic_string& _Reallocate_for(const size_type _New_size, _Fty _Fn, _ArgTys... _Args) {
+        // reallocate to store exactly _New_size elements, new buffer prepared by
+        // _Fn(_New_ptr, _New_size, _Args...)
+        if (_New_size > max_size()) {
+            _Xlen_string(); // result too long
+        }
+
+        const size_type _Old_capacity = _Mypair._Myval2._Myres;
+        size_type _New_capacity       = _Calculate_growth(_New_size);
+        auto& _Al                     = _Getal();
+        const pointer _New_ptr        = _Allocate_for_capacity(_Al, _New_capacity); // throws
+
+        _Mypair._Myval2._Orphan_all();
+        _ASAN_STRING_REMOVE(*this);
+        _Mypair._Myval2._Mysize = _New_size;
+        _Mypair._Myval2._Myres  = _New_capacity;
+        _Fn(_Unfancy(_New_ptr), _New_size, _Args...);
+        if (_Old_capacity > _Small_string_capacity) {
+            _Deallocate_for_capacity(_Al, _Mypair._Myval2._Bx._Ptr, _Old_capacity);
+            _Mypair._Myval2._Bx._Ptr = _New_ptr;
+        } else {
+            _Construct_in_place(_Mypair._Myval2._Bx._Ptr, _New_ptr);
+        }
+
+        _ASAN_STRING_CREATE(*this);
+        return *this;
+    }
+
+    template <class _Fty, class... _ArgTys>
+    _CONSTEXPR20 basic_string& _Reallocate_grow_by(const size_type _Size_increase, _Fty _Fn, _ArgTys... _Args) {
+        // reallocate to increase size by _Size_increase elements, new buffer prepared by
+        // _Fn(_New_ptr, _Old_ptr, _Old_size, _Args...)
+        auto& _My_data            = _Mypair._Myval2;
+        const size_type _Old_size = _My_data._Mysize;
+        if (max_size() - _Old_size < _Size_increase) {
+            _Xlen_string(); // result too long
+        }
+
+        const auto _New_size          = static_cast<size_type>(_Old_size + _Size_increase);
+        const size_type _Old_capacity = _My_data._Myres;
+        size_type _New_capacity       = _Calculate_growth(_New_size);
+        auto& _Al                     = _Getal();
+        const pointer _New_ptr        = _Allocate_for_capacity(_Al, _New_capacity); // throws
+
+        _My_data._Orphan_all();
+        _ASAN_STRING_REMOVE(*this);
+        _My_data._Mysize      = _New_size;
+        _My_data._Myres       = _New_capacity;
+        _Elem* const _Raw_new = _Unfancy(_New_ptr);
+        if (_Old_capacity > _Small_string_capacity) {
+            const pointer _Old_ptr = _My_data._Bx._Ptr;
+            _Fn(_Raw_new, _Unfancy(_Old_ptr), _Old_size, _Args...);
+            _Deallocate_for_capacity(_Al, _Old_ptr, _Old_capacity);
+            _My_data._Bx._Ptr = _New_ptr;
+        } else {
+            _Fn(_Raw_new, _My_data._Bx._Buf, _Old_size, _Args...);
+            _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
+        }
+
+        _ASAN_STRING_CREATE(*this);
+        return *this;
+    }
+
+    _CONSTEXPR20 void _Become_small() noexcept {
+        // release any held storage and return to small string mode
+        auto& _My_data = _Mypair._Myval2;
+        _STL_INTERNAL_CHECK(_My_data._Large_mode_engaged());
+        _STL_INTERNAL_CHECK(_My_data._Mysize <= _Small_string_capacity);
+
+        _My_data._Orphan_all();
+        _ASAN_STRING_REMOVE(*this);
+        const pointer _Ptr = _My_data._Bx._Ptr;
+        _My_data._Bx._Switch_to_buf();
+        _Traits::copy(_My_data._Bx._Buf, _Unfancy(_Ptr), static_cast<size_t>(_My_data._Mysize + 1));
+        auto& _Al = _Getal();
+        _Deallocate_for_capacity(_Al, _Ptr, _My_data._Myres);
+        _My_data._Myres = _Small_string_capacity;
+    }
+
+    _CONSTEXPR20 void _Eos(const size_type _New_size) noexcept { // set new length and null terminator
+        _ASAN_STRING_MODIFY(*this, _Mypair._Myval2._Mysize, _New_size);
+        _Mypair._Myval2._Mysize = _New_size;
+        _Traits::assign(_Mypair._Myval2._Myptr()[_New_size], _Elem());
+    }
+
+    template <class _UElem>
+    _CONSTEXPR20 basic_string& _Append(
+        _In_reads_(_Count) const _UElem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // append [_Ptr, _Ptr + _Count), handling volatile-qualified _Elem
+        _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_UElem, _Elem, volatile _Elem>);
+
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
+            const auto _New_size = static_cast<size_type>(_Old_size + _Count);
+            _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _STD _Traits_move_batch<_Traits>(_Old_ptr + _Old_size, _Ptr, static_cast<size_t>(_Count));
+            _Traits::assign(_Old_ptr[_Old_size + _Count], _Elem());
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const _UElem* const _Ptr,
+                const size_type _Count) static {
+                _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size));
+                _STD _Traits_copy_batch<_Traits>(_New_ptr + _Old_size, _Ptr, static_cast<size_t>(_Count));
+                _Traits::assign(_New_ptr[_Old_size + _Count], _Elem());
+            },
+            _Ptr, _Count);
+    }
+
+    template <class _UElem>
+    _CONSTEXPR20 basic_string& _Assign(
+        _In_reads_(_Count) const _UElem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // assign [_Ptr, _Ptr + _Count), handling volatile-qualified _Elem
+        _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_UElem, _Elem, volatile _Elem>);
+
+        if (_Count <= _Mypair._Myval2._Myres) {
+            _ASAN_STRING_REMOVE(*this);
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Mypair._Myval2._Mysize = _Count;
+            _STD _Traits_move_batch<_Traits>(_Old_ptr, _Ptr, static_cast<size_t>(_Count));
+            _Traits::assign(_Old_ptr[_Count], _Elem());
+            _ASAN_STRING_CREATE(*this);
+            return *this;
+        }
+
+        return _Reallocate_for(
+            _Count,
+            [](_Elem* const _New_ptr, const size_type _Count, const _UElem* const _Ptr) static {
+                _STD _Traits_copy_batch<_Traits>(_New_ptr, _Ptr, static_cast<size_t>(_Count));
+                _Traits::assign(_New_ptr[_Count], _Elem());
+            },
+            _Ptr);
+    }
+
+    template <class _UElem>
+    _CONSTEXPR20 basic_string& _Insert(
+        const size_type _Off, _In_reads_(_Count) const _UElem* const _Ptr, _CRT_GUARDOVERFLOW const size_type _Count) {
+        // insert [_Ptr, _Ptr + _Count) at _Off, handling volatile-qualified _Elem
+        _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_UElem, _Elem, volatile _Elem>);
+
+        _Mypair._Myval2._Check_offset(_Off);
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+
+        // We can't check for overlapping ranges when constant evaluated since comparison of pointers into string
+        // literals is unspecified, so always reallocate and copy to the new buffer if constant evaluated.
+        const bool _Check_overlap = _Count <= _Mypair._Myval2._Myres - _Old_size;
+
+        if (_Check_overlap && !_STD _Is_constant_evaluated()) {
+            const auto _New_size = static_cast<size_type>(_Old_size + _Count);
+            _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Elem* const _Insert_at = _Old_ptr + _Off;
+            // the range [_Ptr, _Ptr + _Ptr_shifted_after) is left alone by moving the suffix out,
+            // while the range [_Ptr + _Ptr_shifted_after, _Ptr + _Count) shifts down by _Count
+            size_type _Ptr_shifted_after;
+            if (_Ptr + _Count <= _Insert_at || _Ptr > _Old_ptr + _Old_size) {
+                // inserted content is before the shifted region, or does not alias
+                _Ptr_shifted_after = _Count; // none of _Ptr's data shifts
+            } else if (_Insert_at <= _Ptr) { // all of [_Ptr, _Ptr + _Count) shifts
+                _Ptr_shifted_after = 0;
+            } else { // [_Ptr, _Ptr + _Count) contains _Insert_at, so only the part after _Insert_at shifts
+                _Ptr_shifted_after = static_cast<size_type>(_Insert_at - _Ptr);
+            }
+
+            _Traits::move(
+                _Insert_at + _Count, _Insert_at, static_cast<size_t>(_Old_size - _Off + 1)); // move suffix + null down
+            _STD _Traits_copy_batch<_Traits>(_Insert_at, _Ptr, static_cast<size_t>(_Ptr_shifted_after));
+            _STD _Traits_copy_batch<_Traits>(_Insert_at + _Ptr_shifted_after, _Ptr + _Count + _Ptr_shifted_after,
+                static_cast<size_t>(_Count - _Ptr_shifted_after));
+            return *this;
+        }
+
+        return _Reallocate_grow_by(
+            _Count,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
+                const _UElem* const _Ptr, const size_type _Count) static {
+                _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Off));
+                _STD _Traits_copy_batch<_Traits>(_New_ptr + _Off, _Ptr, static_cast<size_t>(_Count));
+                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off, static_cast<size_t>(_Old_size - _Off + 1));
+            },
+            _Off, _Ptr, _Count);
+    }
+
+    template <class _UElem>
+    _CONSTEXPR20 basic_string& _Replace(
+        const size_type _Off, size_type _Nx, _In_reads_(_Count) const _UElem* const _Ptr, const size_type _Count) {
+        // replace [_Off, _Off + _Nx) with [_Ptr, _Ptr + _Count), handling volatile-qualified _Elem
+        _STL_INTERNAL_STATIC_ASSERT(_Is_any_of_v<_UElem, _Elem, volatile _Elem>);
+
+        _Mypair._Myval2._Check_offset(_Off);
+        _Nx = _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx);
+        if (_Nx == _Count) { // size doesn't change, so a single move does the trick
+            _STD _Traits_move_batch<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Ptr, static_cast<size_t>(_Count));
+            return *this;
+        }
+
+        const size_type _Old_size = _Mypair._Myval2._Mysize;
+        const auto _Suffix_size   = static_cast<size_type>(_Old_size - _Nx - _Off + 1);
+        if (_Count < _Nx) { // suffix shifts backwards; we don't have to move anything out of the way
+            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+            _Elem* const _Insert_at = _Old_ptr + _Off;
+            _STD _Traits_move_batch<_Traits>(_Insert_at, _Ptr, static_cast<size_t>(_Count));
+            _Traits::move(_Insert_at + _Count, _Insert_at + _Nx, static_cast<size_t>(_Suffix_size));
+
+            const auto _New_size = static_cast<size_type>(_Old_size - (_Nx - _Count));
+            _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+            _Mypair._Myval2._Mysize = _New_size;
+            return *this;
+        }
+
+        const size_type _Growth = static_cast<size_type>(_Count - _Nx);
+
+        // checking for overlapping ranges is technically UB (considering string literals), so just always reallocate
+        // and copy to the new buffer if constant evaluated
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if (_Growth <= _Mypair._Myval2._Myres - _Old_size) { // growth fits
+                const auto _New_size = static_cast<size_type>(_Old_size + _Growth);
+                _ASAN_STRING_MODIFY(*this, _Old_size, _New_size);
+                _Mypair._Myval2._Mysize = _New_size;
+                _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
+                _Elem* const _Insert_at = _Old_ptr + _Off;
+                _Elem* const _Suffix_at = _Insert_at + _Nx;
+
+                size_type _Ptr_shifted_after; // see rationale in insert
+                if (_Ptr + _Count <= _Insert_at || _Ptr > _Old_ptr + _Old_size) {
+                    _Ptr_shifted_after = _Count;
+                } else if (_Suffix_at <= _Ptr) {
+                    _Ptr_shifted_after = 0;
+                } else {
+                    _Ptr_shifted_after = static_cast<size_type>(_Suffix_at - _Ptr);
+                }
+
+                _Traits::move(_Suffix_at + _Growth, _Suffix_at, static_cast<size_t>(_Suffix_size));
+                // next case must be move, in case _Ptr begins before _Insert_at and contains part of the hole;
+                // this case doesn't occur in insert because the new content must come from outside the removed
+                // content there (because in insert there is no removed content)
+                _STD _Traits_move_batch<_Traits>(_Insert_at, _Ptr, static_cast<size_t>(_Ptr_shifted_after));
+                // the next case can be copy, because it comes from the chunk moved out of the way in the
+                // first move, and the hole we're filling can't alias the chunk we moved out of the way
+                _STD _Traits_copy_batch<_Traits>(_Insert_at + _Ptr_shifted_after, _Ptr + _Growth + _Ptr_shifted_after,
+                    static_cast<size_t>(_Count - _Ptr_shifted_after));
+                return *this;
+            }
+        }
+
+        return _Reallocate_grow_by(
+            _Growth,
+            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
+                const size_type _Nx, const _UElem* const _Ptr, const size_type _Count) static {
+                _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Off));
+                _STD _Traits_copy_batch<_Traits>(_New_ptr + _Off, _Ptr, static_cast<size_t>(_Count));
+                _Traits::copy(
+                    _New_ptr + _Off + _Count, _Old_ptr + _Off + _Nx, static_cast<size_t>(_Old_size - _Nx - _Off + 1));
+            },
+            _Off, _Nx, _Ptr, _Count);
+    }
+
+    _CONSTEXPR20 void _Tidy_deallocate() noexcept { // initialize buffer, deallocating any storage
+        auto& _My_data = _Mypair._Myval2;
+        _My_data._Orphan_all();
+        if (_My_data._Large_mode_engaged()) {
+            _ASAN_STRING_REMOVE(*this);
+            auto& _Al = _Getal();
+            _Deallocate_for_capacity(_Al, _My_data._Bx._Ptr, _My_data._Myres);
+            _My_data._Bx._Switch_to_buf();
+        }
+
+        _My_data._Mysize = 0;
+        _My_data._Myres  = _Small_string_capacity;
+        // the _Traits::assign is last so the codegen doesn't think the char write can alias this
+        _Traits::assign(_My_data._Bx._Buf[0], _Elem());
+    }
+
+public:
+    _CONSTEXPR20 void _Orphan_all() noexcept { // used by filesystem::path
+        _Mypair._Myval2._Orphan_all();
+    }
+
+private:
+    _CONSTEXPR20 void _Swap_proxy_and_iterators(basic_string& _Right) noexcept {
+        _Mypair._Myval2._Swap_proxy_and_iterators(_Right._Mypair._Myval2);
+    }
+
+    _CONSTEXPR20 _Alty& _Getal() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _CONSTEXPR20 const _Alty& _Getal() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _Compressed_pair<_Alty, _Scary_val> _Mypair;
+};
+
+#pragma warning(pop)
+
+#if _HAS_CXX23
+template <class _Elem, class _Traits, class _Alloc>
+constexpr bool _Equivalence_is_equality_impl<basic_string<_Elem, _Traits, _Alloc>> =
+    _Is_implementation_handled_char_traits<_Traits>;
+#endif // _HAS_CXX23
+
+#if _HAS_CXX17
+template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
+    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
+basic_string(_Iter, _Iter, _Alloc = _Alloc())
+    -> basic_string<_Iter_value_t<_Iter>, char_traits<_Iter_value_t<_Iter>>, _Alloc>;
+
+template <class _Elem, class _Traits, class _Alloc = allocator<_Elem>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+explicit basic_string(basic_string_view<_Elem, _Traits>, const _Alloc& = _Alloc())
+    -> basic_string<_Elem, _Traits, _Alloc>;
+
+template <class _Elem, class _Traits, class _Alloc = allocator<_Elem>,
+    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
+basic_string(basic_string_view<_Elem, _Traits>, _Guide_size_type_t<_Alloc>, _Guide_size_type_t<_Alloc>,
+    const _Alloc& = _Alloc()) -> basic_string<_Elem, _Traits, _Alloc>;
+
+#if _HAS_CXX23
+template <_RANGES input_range _Rng, _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
+basic_string(from_range_t, _Rng&&, _Alloc = _Alloc())
+    -> basic_string<_RANGES range_value_t<_Rng>, char_traits<_RANGES range_value_t<_Rng>>, _Alloc>;
+#endif // _HAS_CXX23
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_CONSTEXPR20 void swap(basic_string<_Elem, _Traits, _Alloc>& _Left,
+    basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept /* strengthened */ {
+    _Left.swap(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
+    const auto _Left_size  = _Left.size();
+    const auto _Right_size = _Right.size();
+    if (_Left.max_size() - _Left_size < _Right_size) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _Right.c_str(), _Right_size};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    _In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
+    using _Size_type       = typename basic_string<_Elem, _Traits, _Alloc>::size_type;
+    const auto _Left_size  = _Convert_size<_Size_type>(_Traits::length(_Left));
+    const auto _Right_size = _Right.size();
+    if (_Right.max_size() - _Right_size < _Left_size) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Right, _Left, _Left_size, _Right.c_str(), _Right_size};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const _Elem _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
+    const auto _Right_size = _Right.size();
+    if (_Right_size == _Right.max_size()) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Right, _STD addressof(_Left), 1, _Right.c_str(), _Right_size};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) {
+    using _Size_type       = typename basic_string<_Elem, _Traits, _Alloc>::size_type;
+    const auto _Left_size  = _Left.size();
+    const auto _Right_size = _Convert_size<_Size_type>(_Traits::length(_Right));
+    if (_Left.max_size() - _Left_size < _Right_size) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _Right, _Right_size};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const _Elem _Right) {
+    const auto _Left_size = _Left.size();
+    if (_Left_size == _Left.max_size()) {
+        _Xlen_string();
+    }
+
+    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _STD addressof(_Right), 1};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
+    return _STD move(_Right.insert(0, _Left));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    basic_string<_Elem, _Traits, _Alloc>&& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
+    return _STD move(_Left.append(_Right));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    basic_string<_Elem, _Traits, _Alloc>&& _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+    _STL_VERIFY(_STD addressof(_Left) != _STD addressof(_Right),
+        "You cannot concatenate the same moved string to itself. See N4950 [res.on.arguments]/1.3: "
+        "If a function argument is bound to an rvalue reference parameter, the implementation may assume that "
+        "this parameter is a unique reference to this argument, except that the argument passed to "
+        "a move-assignment operator may be a reference to *this ([lib.types.movedfrom]).");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+    return {_String_constructor_concat_tag{}, _Left, _Right};
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    _In_z_ const _Elem* const _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
+    return _STD move(_Right.insert(0, _Left));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    const _Elem _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
+    return _STD move(_Right.insert(0, 1, _Left));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    basic_string<_Elem, _Traits, _Alloc>&& _Left, _In_z_ const _Elem* const _Right) {
+    return _STD move(_Left.append(_Right));
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 basic_string<_Elem, _Traits, _Alloc> operator+(
+    basic_string<_Elem, _Traits, _Alloc>&& _Left, const _Elem _Right) {
+    _Left.push_back(_Right);
+    return _STD move(_Left);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator==(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return _Left._Equal(_Right);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD _CONSTEXPR20 bool operator==(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept /* strengthened */ {
+    return _Left._Equal(_Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return static_cast<_Get_comparison_category_t<_Traits>>(_Left.compare(_Right) <=> 0);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept /* strengthened */ {
+    return static_cast<_Get_comparison_category_t<_Traits>>(_Left.compare(_Right) <=> 0);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator==(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return _Right._Equal(_Left);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator!=(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return !(_Left == _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator!=(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return !(_Left == _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator!=(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return !(_Left == _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return _Left.compare(_Right) < 0;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return _Right.compare(_Left) > 0;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return _Left.compare(_Right) < 0;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return _Right < _Left;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return _Right < _Left;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return _Right < _Left;
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<=(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return !(_Right < _Left);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<=(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return !(_Right < _Left);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator<=(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return !(_Right < _Left);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>=(
+    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
+    return !(_Left < _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>=(_In_z_ const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept
+/* strengthened */ {
+    return !(_Left < _Right);
+}
+
+template <class _Elem, class _Traits, class _Alloc>
+_NODISCARD bool operator>=(const basic_string<_Elem, _Traits, _Alloc>& _Left, _In_z_ const _Elem* const _Right) noexcept
+/* strengthened */ {
+    return !(_Left < _Right);
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD using string  = basic_string<char, char_traits<char>, allocator<char>>;
+_EXPORT_STD using wstring = basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
+#ifdef __cpp_lib_char8_t
+_EXPORT_STD using u8string = basic_string<char8_t, char_traits<char8_t>, allocator<char8_t>>;
+#endif // defined(__cpp_lib_char8_t)
+_EXPORT_STD using u16string = basic_string<char16_t, char_traits<char16_t>, allocator<char16_t>>;
+_EXPORT_STD using u32string = basic_string<char32_t, char_traits<char32_t>, allocator<char32_t>>;
+
+template <class _Elem, class _Alloc>
+struct hash<basic_string<_Elem, char_traits<_Elem>, _Alloc>>
+    : _Conditionally_enabled_hash<basic_string<_Elem, char_traits<_Elem>, _Alloc>, _Is_EcharT<_Elem>> {
+    _NODISCARD static size_t _Do_hash(const basic_string<_Elem, char_traits<_Elem>, _Alloc>& _Keyval) noexcept {
+        return _Hash_array_representation(_Keyval.c_str(), static_cast<size_t>(_Keyval.size()));
+    }
+};
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+basic_istream<_Elem, _Traits>& operator>>(
+    basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str) {
+    using _Myis   = basic_istream<_Elem, _Traits>;
+    using _Ctype  = typename _Myis::_Ctype;
+    using _Mystr  = basic_string<_Elem, _Traits, _Alloc>;
+    using _Mysizt = typename _Mystr::size_type;
+
+    typename _Myis::iostate _State = _Myis::goodbit;
+    bool _Changed                  = false;
+    const typename _Myis::sentry _Ok(_Istr);
+
+    if (_Ok) { // state okay, extract characters
+        const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Istr.getloc());
+        _Str.erase();
+
+        _TRY_IO_BEGIN
+        _Mysizt _Size;
+        if (0 < _Istr.width() && static_cast<_Mysizt>(_Istr.width()) < _Str.max_size()) {
+            _Size = static_cast<_Mysizt>(_Istr.width());
+        } else {
+            _Size = _Str.max_size();
+        }
+
+        typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();
+
+        for (; 0 < _Size; --_Size, _Meta = _Istr.rdbuf()->snextc()) {
+            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
+                _State |= _Myis::eofbit;
+                break;
+            } else if (_Ctype_fac.is(_Ctype::space, _Traits::to_char_type(_Meta))) {
+                break; // whitespace, quit
+            } else { // add character to string
+                _Str.push_back(_Traits::to_char_type(_Meta));
+                _Changed = true;
+            }
+        }
+        _CATCH_IO_(_Myis, _Istr)
+    }
+
+    _Istr.width(0);
+    if (!_Changed) {
+        _State |= _Myis::failbit;
+    }
+
+    _Istr.setstate(_State);
+    return _Istr;
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc>
+basic_ostream<_Elem, _Traits>& operator<<(
+    basic_ostream<_Elem, _Traits>& _Ostr, const basic_string<_Elem, _Traits, _Alloc>& _Str) {
+    return _Insert_string(_Ostr, _Str.data(), _Str.size());
+}
+
+inline namespace literals {
+    inline namespace string_literals {
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 string operator""s(const char* _Str, size_t _Len) {
+            return string{_Str, _Len};
+        }
+
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 wstring operator""s(const wchar_t* _Str, size_t _Len) {
+            return wstring{_Str, _Len};
+        }
+
+#ifdef __cpp_char8_t
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 basic_string<char8_t> operator""s(const char8_t* _Str, size_t _Len) {
+            return basic_string<char8_t>{_Str, _Len};
+        }
+#endif // defined(__cpp_char8_t)
+
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 u16string operator""s(const char16_t* _Str, size_t _Len) {
+            return u16string{_Str, _Len};
+        }
+
+        _EXPORT_STD _NODISCARD _CONSTEXPR20 u32string operator""s(const char32_t* _Str, size_t _Len) {
+            return u32string{_Str, _Len};
+        }
+    } // namespace string_literals
+} // namespace literals
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc, class _Uty>
+constexpr basic_string<_Elem, _Traits, _Alloc>::size_type erase(
+    basic_string<_Elem, _Traits, _Alloc>& _Cont, const _Uty& _Val) {
+    return _STD _Erase_remove(_Cont, _Val);
+}
+
+_EXPORT_STD template <class _Elem, class _Traits, class _Alloc, class _Pr>
+constexpr basic_string<_Elem, _Traits, _Alloc>::size_type erase_if(
+    basic_string<_Elem, _Traits, _Alloc>& _Cont, _Pr _Pred) {
+    return _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Pred));
+}
+#endif // _HAS_CXX20
+
+#if _HAS_CXX17
+namespace pmr {
+    _EXPORT_STD template <class _Elem, class _Traits = char_traits<_Elem>>
+    using basic_string = _STD basic_string<_Elem, _Traits, polymorphic_allocator<_Elem>>;
+
+    _EXPORT_STD using string = basic_string<char>;
+#ifdef __cpp_lib_char8_t
+    _EXPORT_STD using u8string = basic_string<char8_t>;
+#endif // defined(__cpp_lib_char8_t)
+    _EXPORT_STD using u16string = basic_string<char16_t>;
+    _EXPORT_STD using u32string = basic_string<char32_t>;
+    _EXPORT_STD using wstring   = basic_string<wchar_t>;
+} // namespace pmr
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <class _Elem, class _Traits, class _Alloc>
+constexpr bool _Has_guaranteed_push_back<basic_string<_Elem, _Traits, _Alloc>> = true;
+#endif // _HAS_CXX23
+_STD_END
+
+#undef _ASAN_STRING_REMOVE
+#undef _ASAN_STRING_CREATE
+#undef _ASAN_STRING_MODIFY
+#undef _INSERT_STRING_ANNOTATION
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XSTRING_
diff --git a/msvc-stl/stl/inc/xthreads.h b/msvc-stl/stl/inc/xthreads.h
new file mode 100644
index 0000000..de50b11
--- /dev/null
+++ b/msvc-stl/stl/inc/xthreads.h
@@ -0,0 +1,103 @@
+// xthreads.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _THR_XTHREADS_H
+#define _THR_XTHREADS_H
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <__msvc_threads_core.hpp>
+#include <climits>
+#include <xtimec.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+// threads
+_CRTIMP2_PURE _Thrd_result __cdecl _Thrd_detach(_Thrd_t) noexcept;
+_CRTIMP2_PURE _Thrd_result __cdecl _Thrd_join(_Thrd_t, int*) noexcept;
+_CRTIMP2_PURE void __cdecl _Thrd_yield() noexcept;
+_CRTIMP2_PURE unsigned int __cdecl _Thrd_hardware_concurrency() noexcept;
+_CRTIMP2_PURE _Thrd_id_t __cdecl _Thrd_id() noexcept;
+void __stdcall _Thrd_sleep_for(unsigned long /*ms*/) noexcept;
+
+// mutexes
+enum { // mutex types
+    _Mtx_plain     = 0x01,
+    _Mtx_try       = 0x02,
+    _Mtx_timed     = 0x04,
+    _Mtx_recursive = 0x100
+};
+
+#if defined(_CRTBLD) || defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
+_CRTIMP2_PURE void __cdecl _Mtx_init_in_situ(_Mtx_t, int) noexcept;
+#endif // ^^^ defined(_CRTBLD) || defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) ^^^
+_CRTIMP2_PURE int __cdecl _Mtx_current_owns(_Mtx_t) noexcept;
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_lock(_Mtx_t) noexcept;
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_trylock(_Mtx_t) noexcept;
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_unlock(_Mtx_t) noexcept; // TRANSITION, ABI: Always succeeds
+
+// shared mutex
+// these declarations must be in sync with those in sharedmutex.cpp
+void __cdecl _Smtx_lock_exclusive(_Smtx_t*) noexcept;
+void __cdecl _Smtx_lock_shared(_Smtx_t*) noexcept;
+int __cdecl _Smtx_try_lock_exclusive(_Smtx_t*) noexcept;
+int __cdecl _Smtx_try_lock_shared(_Smtx_t*) noexcept;
+void __cdecl _Smtx_unlock_exclusive(_Smtx_t*) noexcept;
+void __cdecl _Smtx_unlock_shared(_Smtx_t*) noexcept;
+
+// condition variables
+#ifdef _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR
+_CRTIMP2_PURE void __cdecl _Cnd_init_in_situ(_Cnd_t) noexcept;
+#endif // ^^^ defined(_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) ^^^
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_wait(_Cnd_t, _Mtx_t) noexcept; // TRANSITION, ABI: Always succeeds
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_broadcast(_Cnd_t) noexcept; // TRANSITION, ABI: Always succeeds
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_signal(_Cnd_t) noexcept; // TRANSITION, ABI: Always succeeds
+_CRTIMP2_PURE void __cdecl _Cnd_register_at_thread_exit(_Cnd_t, _Mtx_t, int*) noexcept;
+_CRTIMP2_PURE void __cdecl _Cnd_unregister_at_thread_exit(_Mtx_t) noexcept;
+_CRTIMP2_PURE void __cdecl _Cnd_do_broadcast_at_thread_exit() noexcept;
+// '_unchecked' means it is not checked against the 'steady_clock', so may report timeout prematurely
+_Thrd_result __stdcall _Cnd_timedwait_for_unchecked(_Cnd_t, _Mtx_t, unsigned int) noexcept;
+} // extern "C"
+
+_STD_BEGIN
+enum { // constants for error codes
+    _DEVICE_OR_RESOURCE_BUSY,
+    _INVALID_ARGUMENT,
+    _NO_SUCH_PROCESS,
+    _NOT_ENOUGH_MEMORY,
+    _OPERATION_NOT_PERMITTED,
+    _RESOURCE_DEADLOCK_WOULD_OCCUR,
+    _RESOURCE_UNAVAILABLE_TRY_AGAIN
+};
+
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __cdecl _Throw_Cpp_error(int _Code);
+_STD_END
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _THR_XTHREADS_H
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/msvc-stl/stl/inc/xtimec.h b/msvc-stl/stl/inc/xtimec.h
new file mode 100644
index 0000000..7e615fa
--- /dev/null
+++ b/msvc-stl/stl/inc/xtimec.h
@@ -0,0 +1,59 @@
+// xtimec.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _THR_XTIMEC_H
+#define _THR_XTIMEC_H
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <ctime>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+extern "C" {
+
+#ifdef _CRTBLD
+_CRTIMP2_PURE long __cdecl _Xtime_diff_to_millis2(const _timespec64*, const _timespec64*) noexcept;
+#endif // _CRTBLD
+
+_CRTIMP2_PURE long long __cdecl _Xtime_get_ticks() noexcept;
+
+#ifdef _CRTBLD
+// Used by several src files, but not dllexported.
+void _Timespec64_get_sys(_timespec64*) noexcept;
+#endif // defined(_CRTBLD)
+
+_CRTIMP2_PURE long long __cdecl _Query_perf_counter() noexcept;
+_CRTIMP2_PURE long long __cdecl _Query_perf_frequency() noexcept;
+
+} // extern "C"
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _THR_XTIMEC_H
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/msvc-stl/stl/inc/xtr1common b/msvc-stl/stl/inc/xtr1common
new file mode 100644
index 0000000..e90039f
--- /dev/null
+++ b/msvc-stl/stl/inc/xtr1common
@@ -0,0 +1,266 @@
+// xtr1common internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XTR1COMMON_
+#define _XTR1COMMON_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("known_semantics")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef known_semantics
+#undef no_specializations
+
+_STD_BEGIN
+_EXPORT_STD template <class _Ty, _Ty _Val>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS integral_constant {
+    static constexpr _Ty value = _Val;
+
+    using value_type = _Ty;
+    using type       = integral_constant;
+
+    constexpr operator value_type() const noexcept {
+        return value;
+    }
+
+    _NODISCARD constexpr value_type operator()() const noexcept {
+        return value;
+    }
+};
+
+_EXPORT_STD template <bool _Val>
+using bool_constant = integral_constant<bool, _Val>;
+
+_EXPORT_STD using true_type  = bool_constant<true>;
+_EXPORT_STD using false_type = bool_constant<false>;
+
+_EXPORT_STD template <bool _Test, class _Ty = void>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS enable_if {}; // no member "type" when !_Test
+
+template <class _Ty>
+struct enable_if<true, _Ty> { // type is _Ty for _Test
+    using type = _Ty;
+};
+
+_EXPORT_STD template <bool _Test, class _Ty = void>
+using enable_if_t = typename enable_if<_Test, _Ty>::type;
+
+_EXPORT_STD template <bool _Test, class _Ty1, class _Ty2>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS conditional { // Choose _Ty1 if _Test is true, and _Ty2 otherwise
+    using type = _Ty1;
+};
+
+template <class _Ty1, class _Ty2>
+struct conditional<false, _Ty1, _Ty2> {
+    using type = _Ty2;
+};
+
+_EXPORT_STD template <bool _Test, class _Ty1, class _Ty2>
+using conditional_t = typename conditional<_Test, _Ty1, _Ty2>::type;
+
+#ifdef __clang__
+_EXPORT_STD template <class _Ty1, class _Ty2>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_same_v = __is_same(_Ty1, _Ty2);
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_same : bool_constant<__is_same(_Ty1, _Ty2)> {};
+#else // ^^^ Clang / not Clang vvv
+_EXPORT_STD template <class, class>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_same_v = false; // determine whether arguments are the same type
+template <class _Ty>
+constexpr bool is_same_v<_Ty, _Ty> = true;
+
+_EXPORT_STD template <class _Ty1, class _Ty2>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_same : bool_constant<is_same_v<_Ty1, _Ty2>> {};
+#endif // ^^^ not Clang ^^^
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS remove_const { // remove top-level const qualifier
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_const<const _Ty> {
+    using type = _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_const_t = typename remove_const<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS remove_volatile { // remove top-level volatile qualifier
+    using type = _Ty;
+};
+
+template <class _Ty>
+struct remove_volatile<volatile _Ty> {
+    using type = _Ty;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_volatile_t = typename remove_volatile<_Ty>::type;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS remove_cv { // remove top-level const and volatile qualifiers
+    using type = _Ty;
+
+    template <template <class> class _Fn>
+    using _Apply = _Fn<_Ty>; // apply cv-qualifiers from the class template argument to _Fn<_Ty>
+};
+
+template <class _Ty>
+struct remove_cv<const _Ty> {
+    using type = _Ty;
+
+    template <template <class> class _Fn>
+    using _Apply = const _Fn<_Ty>;
+};
+
+template <class _Ty>
+struct remove_cv<volatile _Ty> {
+    using type = _Ty;
+
+    template <template <class> class _Fn>
+    using _Apply = volatile _Fn<_Ty>;
+};
+
+template <class _Ty>
+struct remove_cv<const volatile _Ty> {
+    using type = _Ty;
+
+    template <template <class> class _Fn>
+    using _Apply = const volatile _Fn<_Ty>;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_cv_t = typename remove_cv<_Ty>::type;
+
+template <bool _First_value, class _First, class... _Rest>
+struct _Disjunction { // handle true trait or last trait
+    using type = _First;
+};
+
+template <class _False, class _Next, class... _Rest>
+struct _Disjunction<false, _False, _Next, _Rest...> { // first trait is false, try the next trait
+    using type = typename _Disjunction<static_cast<bool>(_Next::value), _Next, _Rest...>::type;
+};
+
+_EXPORT_STD template <class... _Traits>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS disjunction : false_type {}; // If _Traits is empty, false_type
+
+template <class _First, class... _Rest>
+struct disjunction<_First, _Rest...> : _Disjunction<static_cast<bool>(_First::value), _First, _Rest...>::type {
+    // the first true trait in _Traits, or the last trait if none are true
+};
+
+_EXPORT_STD template <class... _Traits>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool disjunction_v = disjunction<_Traits...>::value;
+
+template <class _Ty, class... _Types>
+constexpr bool _Is_any_of_v = // true if and only if _Ty is in _Types
+#if _HAS_CXX17
+    (is_same_v<_Ty, _Types> || ...);
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+    disjunction_v<is_same<_Ty, _Types>...>;
+#endif // ^^^ !_HAS_CXX17 ^^^
+
+_NODISCARD constexpr bool _Is_constant_evaluated() noexcept { // Internal function for any standard mode
+    return __builtin_is_constant_evaluated();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD _NODISCARD constexpr bool is_constant_evaluated() noexcept {
+    return __builtin_is_constant_evaluated();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool, char,
+    signed char, unsigned char, wchar_t,
+#ifdef __cpp_char8_t
+    char8_t,
+#endif // defined(__cpp_char8_t)
+    char16_t, char32_t, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_integral : bool_constant<is_integral_v<_Ty>> {};
+
+template <class _Ty>
+constexpr bool _Is_nonbool_integral = is_integral_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>;
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_floating_point_v =
+    _Is_any_of_v<remove_cv_t<_Ty>, float, double, long double>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_floating_point : bool_constant<is_floating_point_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_TYPE_TRAITS constexpr bool is_arithmetic_v = // determine whether _Ty is an arithmetic type
+    is_integral_v<_Ty> || is_floating_point_v<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_arithmetic : bool_constant<is_arithmetic_v<_Ty>> {};
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS remove_reference {
+    using type                 = _Ty;
+    using _Const_thru_ref_type = const _Ty;
+};
+
+template <class _Ty>
+struct remove_reference<_Ty&> {
+    using type                 = _Ty;
+    using _Const_thru_ref_type = const _Ty&;
+};
+
+template <class _Ty>
+struct remove_reference<_Ty&&> {
+    using type                 = _Ty;
+    using _Const_thru_ref_type = const _Ty&&;
+};
+
+_EXPORT_STD template <class _Ty>
+using remove_reference_t = typename remove_reference<_Ty>::type;
+
+template <class _Ty>
+using _Const_thru_ref = typename remove_reference<_Ty>::_Const_thru_ref_type;
+
+template <class _Ty>
+using _Remove_cvref_t _MSVC_KNOWN_SEMANTICS = remove_cv_t<remove_reference_t<_Ty>>;
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty>
+using remove_cvref_t = _Remove_cvref_t<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS remove_cvref {
+    using type = remove_cvref_t<_Ty>;
+};
+#endif // _HAS_CXX20
+
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("known_semantics")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XTR1COMMON_
diff --git a/msvc-stl/stl/inc/xtree b/msvc-stl/stl/inc/xtree
new file mode 100644
index 0000000..d643d8a
--- /dev/null
+++ b/msvc-stl/stl/inc/xtree
@@ -0,0 +1,2011 @@
+// xtree internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XTREE_
+#define _XTREE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#include <xmemory>
+
+#if _HAS_CXX17
+#include <xnode_handle.h>
+#endif // _HAS_CXX17
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+#if _HAS_CXX20
+template <class _Ty>
+constexpr bool _Is_transparent_v = _Transparent<_Ty>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class = void>
+constexpr bool _Is_transparent_v = false;
+
+template <class _Ty>
+constexpr bool _Is_transparent_v<_Ty, void_t<typename _Ty::is_transparent>> = true;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Mytree, class _Base = _Iterator_base0>
+class _Tree_unchecked_const_iterator : public _Base {
+public:
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mytree::_Nodeptr;
+    using value_type      = typename _Mytree::value_type;
+    using difference_type = typename _Mytree::difference_type;
+    using pointer         = typename _Mytree::const_pointer;
+    using reference       = const value_type&;
+
+    _Tree_unchecked_const_iterator() noexcept : _Ptr() {}
+
+    _Tree_unchecked_const_iterator(_Nodeptr _Pnode, const _Mytree* _Plist) noexcept : _Ptr(_Pnode) {
+        this->_Adopt(_Plist);
+    }
+
+    _NODISCARD reference operator*() const noexcept {
+        return _Ptr->_Myval;
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Tree_unchecked_const_iterator& operator++() noexcept {
+        if (_Ptr->_Right->_Isnil) { // climb looking for right subtree
+            _Nodeptr _Pnode;
+            while (!(_Pnode = _Ptr->_Parent)->_Isnil && _Ptr == _Pnode->_Right) {
+                _Ptr = _Pnode; // ==> parent while right subtree
+            }
+
+            _Ptr = _Pnode; // ==> parent (head if end())
+        } else {
+            _Ptr = _Mytree::_Min(_Ptr->_Right); // ==> smallest of right subtree
+        }
+
+        return *this;
+    }
+
+    _Tree_unchecked_const_iterator operator++(int) noexcept {
+        _Tree_unchecked_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _Tree_unchecked_const_iterator& operator--() noexcept {
+        if (_Ptr->_Isnil) {
+            _Ptr = _Ptr->_Right; // end() ==> rightmost
+        } else if (_Ptr->_Left->_Isnil) { // climb looking for left subtree
+            _Nodeptr _Pnode;
+            while (!(_Pnode = _Ptr->_Parent)->_Isnil && _Ptr == _Pnode->_Left) {
+                _Ptr = _Pnode; // ==> parent while left subtree
+            }
+
+            if (!_Ptr->_Isnil) { // decrement non-begin()
+                _Ptr = _Pnode; // ==> parent if not head
+            }
+        } else {
+            _Ptr = _Mytree::_Max(_Ptr->_Left); // ==> largest of left subtree
+        }
+
+        return *this;
+    }
+
+    _Tree_unchecked_const_iterator operator--(int) noexcept {
+        _Tree_unchecked_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const _Tree_unchecked_const_iterator& _Right) const noexcept {
+        return _Ptr == _Right._Ptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const _Tree_unchecked_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+    _NODISCARD bool operator==(_Default_sentinel) const noexcept {
+        return !!_Ptr->_Isnil; // TRANSITION, avoid warning C4800:
+                               // "Implicit conversion from 'char' to bool. Possible information loss" (/Wall)
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(_Default_sentinel) const noexcept {
+        return !_Ptr->_Isnil;
+    }
+#endif // !_HAS_CXX20
+
+    _Nodeptr _Ptr; // pointer to node
+};
+
+template <class _Mytree>
+class _Tree_unchecked_iterator : public _Tree_unchecked_const_iterator<_Mytree> {
+public:
+    using _Mybase           = _Tree_unchecked_const_iterator<_Mytree>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mytree::_Nodeptr;
+    using value_type      = typename _Mytree::value_type;
+    using difference_type = typename _Mytree::difference_type;
+    using pointer         = typename _Mytree::pointer;
+    using reference       = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Tree_unchecked_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Tree_unchecked_iterator operator++(int) noexcept {
+        _Tree_unchecked_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _Tree_unchecked_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _Tree_unchecked_iterator operator--(int) noexcept {
+        _Tree_unchecked_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+};
+
+template <class _Mytree>
+class _Tree_const_iterator : public _Tree_unchecked_const_iterator<_Mytree, _Iterator_base> {
+public:
+    using _Mybase           = _Tree_unchecked_const_iterator<_Mytree, _Iterator_base>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mytree::_Nodeptr;
+    using value_type      = typename _Mytree::value_type;
+    using difference_type = typename _Mytree::difference_type;
+    using pointer         = typename _Mytree::const_pointer;
+    using reference       = const value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        const auto _Mycont = static_cast<const _Mytree*>(this->_Getcont());
+        _STL_VERIFY(_Mycont, "cannot dereference value-initialized map/set iterator");
+        _STL_VERIFY(this->_Ptr != _Mycont->_Myhead, "cannot dereference end map/set iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return this->_Ptr->_Myval;
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Tree_const_iterator& operator++() noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(this->_Getcont(), "cannot increment value-initialized map/set iterator");
+        _STL_VERIFY(!this->_Ptr->_Isnil, "cannot increment end map/set iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Tree_const_iterator operator++(int) noexcept {
+        _Tree_const_iterator _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    _Tree_const_iterator& operator--() noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(this->_Getcont(), "cannot decrement value-initialized map/set iterator");
+        _Nodeptr _Ptrsav = this->_Ptr;
+        _Mybase::operator--();
+        _STL_VERIFY(_Ptrsav != this->_Ptr, "cannot decrement begin map/set iterator");
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+        _Mybase::operator--();
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+
+        return *this;
+    }
+
+    _Tree_const_iterator operator--(int) noexcept {
+        _Tree_const_iterator _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    _NODISCARD bool operator==(const _Tree_const_iterator& _Right) const noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(this->_Getcont() == _Right._Getcont(), "map/set iterators incompatible");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        return this->_Ptr == _Right._Ptr;
+    }
+
+#if !_HAS_CXX20
+    _NODISCARD bool operator!=(const _Tree_const_iterator& _Right) const noexcept {
+        return !(*this == _Right);
+    }
+#endif // !_HAS_CXX20
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+    friend void _Verify_range(const _Tree_const_iterator& _First, const _Tree_const_iterator& _Last) noexcept {
+        _STL_VERIFY(_First._Getcont() == _Last._Getcont(), "map/set iterators in range are from different containers");
+    }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+    using _Prevent_inheriting_unwrap = _Tree_const_iterator;
+
+    _NODISCARD _Tree_unchecked_const_iterator<_Mytree> _Unwrapped() const noexcept {
+        return _Tree_unchecked_const_iterator<_Mytree>(this->_Ptr, static_cast<const _Mytree*>(this->_Getcont()));
+    }
+
+    void _Seek_to(const _Tree_unchecked_const_iterator<_Mytree> _It) noexcept {
+        this->_Ptr = _It._Ptr;
+    }
+};
+
+template <class _Mytree>
+class _Tree_iterator : public _Tree_const_iterator<_Mytree> {
+public:
+    using _Mybase           = _Tree_const_iterator<_Mytree>;
+    using iterator_category = bidirectional_iterator_tag;
+
+    using _Nodeptr        = typename _Mytree::_Nodeptr;
+    using value_type      = typename _Mytree::value_type;
+    using difference_type = typename _Mytree::difference_type;
+
+    using pointer   = typename _Mytree::pointer;
+    using reference = value_type&;
+
+    using _Mybase::_Mybase;
+
+    _NODISCARD reference operator*() const noexcept {
+        return const_cast<reference>(_Mybase::operator*());
+    }
+
+    _NODISCARD pointer operator->() const noexcept {
+        return pointer_traits<pointer>::pointer_to(**this);
+    }
+
+    _Tree_iterator& operator++() noexcept {
+        _Mybase::operator++();
+        return *this;
+    }
+
+    _Tree_iterator operator++(int) noexcept {
+        _Tree_iterator _Tmp = *this;
+        _Mybase::operator++();
+        return _Tmp;
+    }
+
+    _Tree_iterator& operator--() noexcept {
+        _Mybase::operator--();
+        return *this;
+    }
+
+    _Tree_iterator operator--(int) noexcept {
+        _Tree_iterator _Tmp = *this;
+        _Mybase::operator--();
+        return _Tmp;
+    }
+
+    using _Prevent_inheriting_unwrap = _Tree_iterator;
+
+    _NODISCARD _Tree_unchecked_iterator<_Mytree> _Unwrapped() const noexcept {
+        return _Tree_unchecked_iterator<_Mytree>(this->_Ptr, static_cast<const _Mytree*>(this->_Getcont()));
+    }
+};
+
+template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
+    class _Nodeptr_type>
+struct _Tree_iter_types {
+    using value_type      = _Value_type;
+    using size_type       = _Size_type;
+    using difference_type = _Difference_type;
+    using pointer         = _Pointer;
+    using const_pointer   = _Const_pointer;
+    using _Nodeptr        = _Nodeptr_type;
+};
+
+template <class _Value_type, class _Voidptr>
+struct _Tree_node {
+    using _Nodeptr   = _Rebind_pointer_t<_Voidptr, _Tree_node>;
+    using value_type = _Value_type;
+    _Nodeptr _Left; // left subtree, or smallest element if head
+    _Nodeptr _Parent; // parent, or root of tree if head
+    _Nodeptr _Right; // right subtree, or largest element if head
+    char _Color; // _Red or _Black, _Black if head
+    char _Isnil; // true only if head (also nil) node; TRANSITION, ABI, should be bool
+    value_type _Myval = // the stored value, unused if head
+        _Returns_exactly<value_type>(); // fake a viable constructor to workaround GH-2749
+
+    enum _Redbl { // colors for link to parent
+        _Red,
+        _Black
+    };
+
+    _Tree_node()                             = default;
+    _Tree_node(const _Tree_node&)            = delete;
+    _Tree_node& operator=(const _Tree_node&) = delete;
+
+    template <class _Alloc>
+    static _Nodeptr _Buyheadnode(_Alloc& _Al) {
+        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Buyheadnode call");
+        const auto _Pnode = _Al.allocate(1);
+        _Construct_in_place(_Pnode->_Left, _Pnode);
+        _Construct_in_place(_Pnode->_Parent, _Pnode);
+        _Construct_in_place(_Pnode->_Right, _Pnode);
+        _Pnode->_Color = _Black;
+        _Pnode->_Isnil = true;
+        return _Pnode;
+    }
+
+    template <class _Alloc, class... _Valty>
+    static _Nodeptr _Buynode(_Alloc& _Al, _Nodeptr _Myhead, _Valty&&... _Val) {
+        // allocate a node with defaults and set links and value
+        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Buynode call");
+        _Alloc_construct_ptr<_Alloc> _Newnode(_Al);
+        _Newnode._Allocate();
+        allocator_traits<_Alloc>::construct(_Al, _STD addressof(_Newnode._Ptr->_Myval), _STD forward<_Valty>(_Val)...);
+        _Construct_in_place(_Newnode._Ptr->_Left, _Myhead);
+        _Construct_in_place(_Newnode._Ptr->_Parent, _Myhead);
+        _Construct_in_place(_Newnode._Ptr->_Right, _Myhead);
+        _Newnode._Ptr->_Color = _Red;
+        _Newnode._Ptr->_Isnil = false;
+        return _Newnode._Release();
+    }
+
+    template <class _Alloc>
+    static void _Freenode0(_Alloc& _Al, _Nodeptr _Ptr) noexcept {
+        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Freenode0 call");
+        _Destroy_in_place(_Ptr->_Left);
+        _Destroy_in_place(_Ptr->_Parent);
+        _Destroy_in_place(_Ptr->_Right);
+        allocator_traits<_Alloc>::deallocate(_Al, _Ptr, 1);
+    }
+
+    template <class _Alloc>
+    static void _Freenode(_Alloc& _Al, _Nodeptr _Ptr) noexcept {
+        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Freenode call");
+        allocator_traits<_Alloc>::destroy(_Al, _STD addressof(_Ptr->_Myval));
+        _Freenode0(_Al, _Ptr);
+    }
+};
+
+template <class _Ty>
+struct _Tree_simple_types : _Simple_types<_Ty> {
+    using _Node    = _Tree_node<_Ty, void*>;
+    using _Nodeptr = _Node*;
+};
+
+enum class _Tree_child {
+    _Right, // perf note: compare with _Right rather than _Left where possible for comparison with zero
+    _Left,
+    _Unused // indicates that tree child should never be used for insertion
+};
+
+template <class _Nodeptr>
+struct _Tree_id {
+    _Nodeptr _Parent; // the leaf node under which a new node should be inserted
+    _Tree_child _Child;
+};
+
+template <class _Nodeptr>
+struct _Tree_find_result {
+    _Tree_id<_Nodeptr> _Location;
+    _Nodeptr _Bound;
+};
+
+template <class _Nodeptr>
+struct _Tree_find_hint_result {
+    _Tree_id<_Nodeptr> _Location;
+    bool _Duplicate;
+};
+
+[[noreturn]] inline void _Throw_tree_length_error() {
+    _Xlength_error("map/set too long");
+}
+
+template <class _Val_types>
+class _Tree_val : public _Container_base {
+public:
+    using _Nodeptr = typename _Val_types::_Nodeptr;
+
+    using value_type      = typename _Val_types::value_type;
+    using size_type       = typename _Val_types::size_type;
+    using difference_type = typename _Val_types::difference_type;
+    using pointer         = typename _Val_types::pointer;
+    using const_pointer   = typename _Val_types::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using _Unchecked_const_iterator = _Tree_unchecked_const_iterator<_Tree_val>;
+    using const_iterator            = _Tree_const_iterator<_Tree_val>;
+
+    template <class _Alnode>
+    struct _NODISCARD _Erase_tree_and_orphan_guard {
+        _Tree_val* _Val_ptr;
+        _Alnode& _Al;
+        _Nodeptr _New_root;
+
+        _Erase_tree_and_orphan_guard& operator=(const _Erase_tree_and_orphan_guard&) = delete;
+        ~_Erase_tree_and_orphan_guard() noexcept {
+            if (_Val_ptr != nullptr) {
+                _Val_ptr->_Erase_tree_and_orphan(_Al, _New_root); // subtree copy failed, bail out
+            }
+        }
+    };
+
+    _Tree_val() noexcept : _Myhead(), _Mysize(0) {}
+
+#if _MSVC_STL_DESTRUCTOR_TOMBSTONES
+    ~_Tree_val() noexcept {
+        if constexpr (is_pointer_v<_Nodeptr>) {
+            const auto _Tombstone{reinterpret_cast<_Nodeptr>(_MSVC_STL_UINTPTR_TOMBSTONE_VALUE)};
+            _Myhead = _Tombstone;
+            _Mysize = 0;
+        }
+    }
+#endif // _MSVC_STL_DESTRUCTOR_TOMBSTONES
+
+    enum _Redbl { // colors for link to parent
+        _Red,
+        _Black
+    };
+
+    static _Nodeptr _Max(_Nodeptr _Pnode) noexcept { // return rightmost node in subtree at _Pnode
+        while (!_Pnode->_Right->_Isnil) {
+            _Pnode = _Pnode->_Right;
+        }
+
+        return _Pnode;
+    }
+
+    static _Nodeptr _Min(_Nodeptr _Pnode) noexcept { // return leftmost node in subtree at _Pnode
+        while (!_Pnode->_Left->_Isnil) {
+            _Pnode = _Pnode->_Left;
+        }
+
+        return _Pnode;
+    }
+
+    void _Lrotate(_Nodeptr _Wherenode) noexcept { // promote right node to root of subtree
+        _Nodeptr _Pnode    = _Wherenode->_Right;
+        _Wherenode->_Right = _Pnode->_Left;
+
+        if (!_Pnode->_Left->_Isnil) {
+            _Pnode->_Left->_Parent = _Wherenode;
+        }
+
+        _Pnode->_Parent = _Wherenode->_Parent;
+
+        if (_Wherenode == _Myhead->_Parent) {
+            _Myhead->_Parent = _Pnode;
+        } else if (_Wherenode == _Wherenode->_Parent->_Left) {
+            _Wherenode->_Parent->_Left = _Pnode;
+        } else {
+            _Wherenode->_Parent->_Right = _Pnode;
+        }
+
+        _Pnode->_Left       = _Wherenode;
+        _Wherenode->_Parent = _Pnode;
+    }
+
+    void _Rrotate(_Nodeptr _Wherenode) noexcept { // promote left node to root of subtree
+        _Nodeptr _Pnode   = _Wherenode->_Left;
+        _Wherenode->_Left = _Pnode->_Right;
+
+        if (!_Pnode->_Right->_Isnil) {
+            _Pnode->_Right->_Parent = _Wherenode;
+        }
+
+        _Pnode->_Parent = _Wherenode->_Parent;
+
+        if (_Wherenode == _Myhead->_Parent) {
+            _Myhead->_Parent = _Pnode;
+        } else if (_Wherenode == _Wherenode->_Parent->_Right) {
+            _Wherenode->_Parent->_Right = _Pnode;
+        } else {
+            _Wherenode->_Parent->_Left = _Pnode;
+        }
+
+        _Pnode->_Right      = _Wherenode;
+        _Wherenode->_Parent = _Pnode;
+    }
+
+    _Nodeptr _Extract(_Unchecked_const_iterator _Where) noexcept {
+        _Nodeptr _Erasednode = _Where._Ptr; // node to erase
+        ++_Where; // save successor iterator for return
+
+        _Nodeptr _Fixnode; // the node to recolor as needed
+        _Nodeptr _Fixnodeparent; // parent of _Fixnode (which may be nil)
+        _Nodeptr _Pnode = _Erasednode;
+
+        if (_Pnode->_Left->_Isnil) {
+            _Fixnode = _Pnode->_Right; // stitch up right subtree
+        } else if (_Pnode->_Right->_Isnil) {
+            _Fixnode = _Pnode->_Left; // stitch up left subtree
+        } else { // two subtrees, must lift successor node to replace erased
+            _Pnode   = _Where._Ptr; // _Pnode is successor node
+            _Fixnode = _Pnode->_Right; // _Fixnode is only subtree
+        }
+
+        if (_Pnode == _Erasednode) { // at most one subtree, relink it
+            _Fixnodeparent = _Erasednode->_Parent;
+            if (!_Fixnode->_Isnil) {
+                _Fixnode->_Parent = _Fixnodeparent; // link up
+            }
+
+            if (_Myhead->_Parent == _Erasednode) {
+                _Myhead->_Parent = _Fixnode; // link down from root
+            } else if (_Fixnodeparent->_Left == _Erasednode) {
+                _Fixnodeparent->_Left = _Fixnode; // link down to left
+            } else {
+                _Fixnodeparent->_Right = _Fixnode; // link down to right
+            }
+
+            if (_Myhead->_Left == _Erasednode) {
+                _Myhead->_Left = _Fixnode->_Isnil ? _Fixnodeparent // smallest is parent of erased node
+                                                  : _Min(_Fixnode); // smallest in relinked subtree
+            }
+
+            if (_Myhead->_Right == _Erasednode) {
+                _Myhead->_Right = _Fixnode->_Isnil ? _Fixnodeparent // largest is parent of erased node
+                                                   : _Max(_Fixnode); // largest in relinked subtree
+            }
+        } else { // erased has two subtrees, _Pnode is successor to erased
+            _Erasednode->_Left->_Parent = _Pnode; // link left up
+            _Pnode->_Left               = _Erasednode->_Left; // link successor down
+
+            if (_Pnode == _Erasednode->_Right) {
+                _Fixnodeparent = _Pnode; // successor is next to erased
+            } else { // successor further down, link in place of erased
+                _Fixnodeparent = _Pnode->_Parent; // parent is successor's
+                if (!_Fixnode->_Isnil) {
+                    _Fixnode->_Parent = _Fixnodeparent; // link fix up
+                }
+
+                _Fixnodeparent->_Left        = _Fixnode; // link fix down
+                _Pnode->_Right               = _Erasednode->_Right; // link next down
+                _Erasednode->_Right->_Parent = _Pnode; // right up
+            }
+
+            if (_Myhead->_Parent == _Erasednode) {
+                _Myhead->_Parent = _Pnode; // link down from root
+            } else if (_Erasednode->_Parent->_Left == _Erasednode) {
+                _Erasednode->_Parent->_Left = _Pnode; // link down to left
+            } else {
+                _Erasednode->_Parent->_Right = _Pnode; // link down to right
+            }
+
+            _Pnode->_Parent = _Erasednode->_Parent; // link successor up
+            _STD swap(_Pnode->_Color, _Erasednode->_Color); // recolor it
+        }
+
+        if (_Erasednode->_Color == _Black) { // erasing black link, must recolor/rebalance tree
+            for (; _Fixnode != _Myhead->_Parent && _Fixnode->_Color == _Black; _Fixnodeparent = _Fixnode->_Parent) {
+                if (_Fixnode == _Fixnodeparent->_Left) { // fixup left subtree
+                    _Pnode = _Fixnodeparent->_Right;
+                    if (_Pnode->_Color == _Red) { // rotate red up from right subtree
+                        _Pnode->_Color         = _Black;
+                        _Fixnodeparent->_Color = _Red;
+                        _Lrotate(_Fixnodeparent);
+                        _Pnode = _Fixnodeparent->_Right;
+                    }
+
+                    if (_Pnode->_Isnil) {
+                        _Fixnode = _Fixnodeparent; // shouldn't happen
+                    } else if (_Pnode->_Left->_Color == _Black
+                               && _Pnode->_Right->_Color == _Black) { // redden right subtree with black children
+                        _Pnode->_Color = _Red;
+                        _Fixnode       = _Fixnodeparent;
+                    } else { // must rearrange right subtree
+                        if (_Pnode->_Right->_Color == _Black) { // rotate red up from left sub-subtree
+                            _Pnode->_Left->_Color = _Black;
+                            _Pnode->_Color        = _Red;
+                            _Rrotate(_Pnode);
+                            _Pnode = _Fixnodeparent->_Right;
+                        }
+
+                        _Pnode->_Color         = _Fixnodeparent->_Color;
+                        _Fixnodeparent->_Color = _Black;
+                        _Pnode->_Right->_Color = _Black;
+                        _Lrotate(_Fixnodeparent);
+                        break; // tree now recolored/rebalanced
+                    }
+                } else { // fixup right subtree
+                    _Pnode = _Fixnodeparent->_Left;
+                    if (_Pnode->_Color == _Red) { // rotate red up from left subtree
+                        _Pnode->_Color         = _Black;
+                        _Fixnodeparent->_Color = _Red;
+                        _Rrotate(_Fixnodeparent);
+                        _Pnode = _Fixnodeparent->_Left;
+                    }
+
+                    if (_Pnode->_Isnil) {
+                        _Fixnode = _Fixnodeparent; // shouldn't happen
+                    } else if (_Pnode->_Right->_Color == _Black
+                               && _Pnode->_Left->_Color == _Black) { // redden left subtree with black children
+                        _Pnode->_Color = _Red;
+                        _Fixnode       = _Fixnodeparent;
+                    } else { // must rearrange left subtree
+                        if (_Pnode->_Left->_Color == _Black) { // rotate red up from right sub-subtree
+                            _Pnode->_Right->_Color = _Black;
+                            _Pnode->_Color         = _Red;
+                            _Lrotate(_Pnode);
+                            _Pnode = _Fixnodeparent->_Left;
+                        }
+
+                        _Pnode->_Color         = _Fixnodeparent->_Color;
+                        _Fixnodeparent->_Color = _Black;
+                        _Pnode->_Left->_Color  = _Black;
+                        _Rrotate(_Fixnodeparent);
+                        break; // tree now recolored/rebalanced
+                    }
+                }
+            }
+
+            _Fixnode->_Color = _Black; // stopping node is black
+        }
+
+        if (0 < _Mysize) {
+            --_Mysize;
+        }
+
+        return _Erasednode;
+    }
+
+    _Nodeptr _Insert_node(const _Tree_id<_Nodeptr> _Loc, const _Nodeptr _Newnode) noexcept {
+        ++_Mysize;
+        const auto _Head  = _Myhead;
+        _Newnode->_Parent = _Loc._Parent;
+        if (_Loc._Parent == _Head) { // first node in tree, just set head values
+            _Head->_Left     = _Newnode;
+            _Head->_Parent   = _Newnode;
+            _Head->_Right    = _Newnode;
+            _Newnode->_Color = _Black; // the root is black
+            return _Newnode;
+        }
+
+        _STL_INTERNAL_CHECK(_Loc._Child != _Tree_child::_Unused);
+        if (_Loc._Child == _Tree_child::_Right) { // add to right of _Loc._Parent
+            _STL_INTERNAL_CHECK(_Loc._Parent->_Right->_Isnil);
+            _Loc._Parent->_Right = _Newnode;
+            if (_Loc._Parent == _Head->_Right) { // remember rightmost node
+                _Head->_Right = _Newnode;
+            }
+        } else { // add to left of _Loc._Parent
+            _STL_INTERNAL_CHECK(_Loc._Parent->_Left->_Isnil);
+            _Loc._Parent->_Left = _Newnode;
+            if (_Loc._Parent == _Head->_Left) { // remember leftmost node
+                _Head->_Left = _Newnode;
+            }
+        }
+
+        for (_Nodeptr _Pnode = _Newnode; _Pnode->_Parent->_Color == _Red;) {
+            if (_Pnode->_Parent == _Pnode->_Parent->_Parent->_Left) { // fixup red-red in left subtree
+                const auto _Parent_sibling = _Pnode->_Parent->_Parent->_Right;
+                if (_Parent_sibling->_Color == _Red) { // parent's sibling has two red children, blacken both
+                    _Pnode->_Parent->_Color          = _Black;
+                    _Parent_sibling->_Color          = _Black;
+                    _Pnode->_Parent->_Parent->_Color = _Red;
+                    _Pnode                           = _Pnode->_Parent->_Parent;
+                } else { // parent's sibling has red and black children
+                    if (_Pnode == _Pnode->_Parent->_Right) { // rotate right child to left
+                        _Pnode = _Pnode->_Parent;
+                        _Lrotate(_Pnode);
+                    }
+
+                    _Pnode->_Parent->_Color          = _Black; // propagate red up
+                    _Pnode->_Parent->_Parent->_Color = _Red;
+                    _Rrotate(_Pnode->_Parent->_Parent);
+                }
+            } else { // fixup red-red in right subtree
+                const auto _Parent_sibling = _Pnode->_Parent->_Parent->_Left;
+                if (_Parent_sibling->_Color == _Red) { // parent's sibling has two red children, blacken both
+                    _Pnode->_Parent->_Color          = _Black;
+                    _Parent_sibling->_Color          = _Black;
+                    _Pnode->_Parent->_Parent->_Color = _Red;
+                    _Pnode                           = _Pnode->_Parent->_Parent;
+                } else { // parent's sibling has red and black children
+                    if (_Pnode == _Pnode->_Parent->_Left) { // rotate left child to right
+                        _Pnode = _Pnode->_Parent;
+                        _Rrotate(_Pnode);
+                    }
+
+                    _Pnode->_Parent->_Color          = _Black; // propagate red up
+                    _Pnode->_Parent->_Parent->_Color = _Red;
+                    _Lrotate(_Pnode->_Parent->_Parent);
+                }
+            }
+        }
+
+        _Head->_Parent->_Color = _Black; // root is always black
+        return _Newnode;
+    }
+
+    void _Orphan_ptr(const _Nodeptr _Ptr) noexcept {
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Lockit _Lock(_LOCK_DEBUG);
+        _Iterator_base12** _Pnext = &this->_Myproxy->_Myfirstiter;
+        while (*_Pnext) {
+            const auto _Pnextptr = static_cast<const_iterator&>(**_Pnext)._Ptr;
+            if (_Pnextptr == _Myhead || (_Ptr != nullptr && _Pnextptr != _Ptr)) {
+                _Pnext = &(*_Pnext)->_Mynextiter;
+            } else { // orphan the iterator
+                (*_Pnext)->_Myproxy = nullptr;
+                *_Pnext             = (*_Pnext)->_Mynextiter;
+            }
+        }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+        (void) _Ptr;
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL != 2 ^^^
+    }
+
+    template <class _Alnode>
+    void _Erase_tree_and_orphan(_Alnode& _Al, _Nodeptr _Rootnode) noexcept {
+        while (!_Rootnode->_Isnil) { // free subtrees, then node
+            _Erase_tree_and_orphan(_Al, _Rootnode->_Right);
+            auto _To_delete = _STD exchange(_Rootnode, _Rootnode->_Left);
+            _Orphan_ptr(_To_delete);
+            _Alnode::value_type::_Freenode(_Al, _To_delete);
+        }
+    }
+
+    template <class _Alnode>
+    void _Erase_tree(_Alnode& _Al, _Nodeptr _Rootnode) noexcept {
+        while (!_Rootnode->_Isnil) { // free subtrees, then node
+            _Erase_tree(_Al, _Rootnode->_Right);
+            _Alnode::value_type::_Freenode(_Al, _STD exchange(_Rootnode, _Rootnode->_Left));
+        }
+    }
+
+    template <class _Alnode>
+    void _Erase_head(_Alnode& _Al) noexcept {
+        this->_Orphan_all();
+        _Erase_tree(_Al, _Myhead->_Parent);
+        _Alnode::value_type::_Freenode0(_Al, _Myhead);
+    }
+
+    _Nodeptr _Myhead; // pointer to head node
+    size_type _Mysize; // number of elements
+};
+
+template <class _Alnode, class _Scary_val>
+struct _Tree_head_scoped_ptr { // temporary storage for allocated node pointers to ensure exception safety
+    _Alnode& _Al;
+    _Scary_val* _Mycont;
+
+    _Tree_head_scoped_ptr(_Alnode& _Al_, _Scary_val& _Mycont_) : _Al(_Al_), _Mycont(_STD addressof(_Mycont_)) {
+        _Mycont->_Myhead = _Alnode::value_type::_Buyheadnode(_Al);
+    }
+
+    void _Release() noexcept {
+        _Mycont = nullptr;
+    }
+
+    ~_Tree_head_scoped_ptr() {
+        if (_Mycont) {
+            _Mycont->_Erase_head(_Al);
+        }
+    }
+};
+
+template <class _Alnode>
+struct _Tree_temp_node_alloc : _Alloc_construct_ptr<_Alnode> {
+    // EH helper for _Tree_temp_node
+    explicit _Tree_temp_node_alloc(_Alnode& _Al_) : _Alloc_construct_ptr<_Alnode>(_Al_) {
+        _Alloc_construct_ptr<_Alnode>::_Allocate();
+    }
+
+    _Tree_temp_node_alloc(const _Tree_temp_node_alloc&)            = delete;
+    _Tree_temp_node_alloc& operator=(const _Tree_temp_node_alloc&) = delete;
+};
+
+template <class _Alnode>
+struct _Tree_temp_node : _Tree_temp_node_alloc<_Alnode> {
+    // temporarily stores a constructed tree node
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using _Nodeptr       = typename _Alnode_traits::pointer;
+
+    enum _Redbl { // colors for link to parent
+        _Red,
+        _Black
+    };
+
+    template <class... _Valtys>
+    explicit _Tree_temp_node(_Alnode& _Al_, _Nodeptr _Myhead, _Valtys&&... _Vals)
+        : _Tree_temp_node_alloc<_Alnode>(_Al_) {
+        _Alnode_traits::construct(this->_Al, _STD addressof(this->_Ptr->_Myval), _STD forward<_Valtys>(_Vals)...);
+        _Construct_in_place(this->_Ptr->_Left, _Myhead);
+        _Construct_in_place(this->_Ptr->_Parent, _Myhead);
+        _Construct_in_place(this->_Ptr->_Right, _Myhead);
+        this->_Ptr->_Color = _Red;
+        this->_Ptr->_Isnil = false;
+    }
+
+    _Tree_temp_node(const _Tree_temp_node&)            = delete;
+    _Tree_temp_node& operator=(const _Tree_temp_node&) = delete;
+
+    ~_Tree_temp_node() {
+        if (this->_Ptr) {
+            _Destroy_in_place(this->_Ptr->_Left);
+            _Destroy_in_place(this->_Ptr->_Parent);
+            _Destroy_in_place(this->_Ptr->_Right);
+            _Alnode_traits::destroy(this->_Al, _STD addressof(this->_Ptr->_Myval));
+        }
+    }
+};
+
+template <class _Traits>
+class _Tree { // ordered red-black tree for map/multimap/set/multiset
+public:
+    using key_type       = typename _Traits::key_type;
+    using value_type     = typename _Traits::value_type;
+    using allocator_type = typename _Traits::allocator_type;
+
+protected:
+    using _Alty          = _Rebind_alloc_t<allocator_type, value_type>;
+    using _Alty_traits   = allocator_traits<_Alty>;
+    using _Node          = _Tree_node<value_type, typename _Alty_traits::void_pointer>;
+    using _Alnode        = _Rebind_alloc_t<allocator_type, _Node>;
+    using _Alnode_traits = allocator_traits<_Alnode>;
+    using _Nodeptr       = typename _Alnode_traits::pointer;
+
+    using _Scary_val = _Tree_val<conditional_t<_Is_simple_alloc_v<_Alnode>, _Tree_simple_types<value_type>,
+        _Tree_iter_types<value_type, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
+            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Nodeptr>>>;
+
+    static constexpr bool _Multi  = _Traits::_Multi;
+    static constexpr bool _Is_set = is_same_v<key_type, value_type>;
+
+    enum _Redbl { // colors for link to parent
+        _Red,
+        _Black
+    };
+
+public:
+    using value_compare = typename _Traits::value_compare;
+
+    using key_compare = typename _Traits::key_compare;
+
+    using size_type       = typename _Alty_traits::size_type;
+    using difference_type = typename _Alty_traits::difference_type;
+    using pointer         = typename _Alty_traits::pointer;
+    using const_pointer   = typename _Alty_traits::const_pointer;
+    using reference       = value_type&;
+    using const_reference = const value_type&;
+
+    using iterator       = conditional_t<_Is_set, _Tree_const_iterator<_Scary_val>, _Tree_iterator<_Scary_val>>;
+    using const_iterator = _Tree_const_iterator<_Scary_val>;
+    using _Unchecked_iterator =
+        conditional_t<_Is_set, _Tree_unchecked_const_iterator<_Scary_val>, _Tree_unchecked_iterator<_Scary_val>>;
+    using _Unchecked_const_iterator = _Tree_unchecked_const_iterator<_Scary_val>;
+
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    enum class _Strategy : bool {
+        _Copy,
+        _Move,
+    };
+
+    _Tree(const key_compare& _Parg) : _Mypair(_One_then_variadic_args_t{}, _Parg, _Zero_then_variadic_args_t{}) {
+        _Alloc_sentinel_and_proxy();
+    }
+
+    _Tree(const key_compare& _Parg, const allocator_type& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Parg, _One_then_variadic_args_t{}, _Al) {
+        _Alloc_sentinel_and_proxy();
+    }
+
+    template <class _Any_alloc>
+    _Tree(const _Tree& _Right, _Any_alloc&& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), _One_then_variadic_args_t{},
+              _STD forward<_Any_alloc>(_Al)) {
+        auto _Alproxy     = _STD _Get_proxy_allocator(_Getal());
+        const auto _Scary = _Get_scary();
+        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, *_Scary);
+        _Tree_head_scoped_ptr<_Alnode, _Scary_val> _Sentinel(_Getal(), *_Scary);
+        _Copy<_Strategy::_Copy>(_Right);
+        _Sentinel._Release();
+        _Proxy._Release();
+    }
+
+    _Tree(_Tree&& _Right)
+        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), // intentionally copy comparator, see LWG-2227
+              _One_then_variadic_args_t{}, _STD move(_Right._Getal())) {
+        _Alloc_sentinel_and_proxy();
+        _Swap_val_excluding_comp(_Right);
+    }
+
+    _Tree(_Tree&& _Right, const allocator_type& _Al)
+        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), // intentionally copy comparator, see LWG-2227
+              _One_then_variadic_args_t{}, _Al) {
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            if (_Getal() != _Right._Getal()) {
+                auto _Alproxy     = _STD _Get_proxy_allocator(_Getal());
+                const auto _Scary = _Get_scary();
+                _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, *_Scary);
+                _Tree_head_scoped_ptr<_Alnode, _Scary_val> _Sentinel(_Getal(), *_Scary);
+                _Copy<_Strategy::_Move>(_Right);
+                _Sentinel._Release();
+                _Proxy._Release();
+                return;
+            }
+        }
+
+        _Alloc_sentinel_and_proxy();
+        _Swap_val_excluding_comp(_Right);
+    }
+
+    _Tree& operator=(_Tree&& _Right)
+        noexcept(_Alnode_traits::is_always_equal::value && is_nothrow_move_assignable_v<key_compare>) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al                 = _Getal();
+        auto& _Right_al           = _Right._Getal();
+        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
+        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
+            if (_Al != _Right_al) {
+                clear();
+                _Getcomp()          = _Right._Getcomp(); // intentionally copy comparator, see LWG-2227
+                auto _Alproxy       = _STD _Get_proxy_allocator(_Al);
+                auto _Right_alproxy = _STD _Get_proxy_allocator(_Right_al);
+                _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                const auto _Scary       = _Get_scary();
+                const auto _Right_scary = _Right._Get_scary();
+                const auto _Newhead     = _STD exchange(_Right_scary->_Myhead, _Node::_Buyheadnode(_Right_al));
+                const auto _Newsize     = _STD exchange(_Right_scary->_Mysize, size_type{0});
+                _Scary->_Erase_head(_Al);
+                _Pocma(_Al, _Right_al);
+                _Scary->_Myhead = _Newhead;
+                _Scary->_Mysize = _Newsize;
+                _Proxy._Bind(_Alproxy, _Scary);
+                _Scary->_Swap_proxy_and_iterators(*_Right_scary);
+                return *this;
+            }
+        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
+            if (_Al != _Right_al) {
+                clear();
+                _Getcomp() = _Right._Getcomp(); // intentionally copy comparator, see LWG-2227
+                _Copy<_Strategy::_Move>(_Right);
+                return *this;
+            }
+        }
+
+        clear();
+        _Getcomp() = _Right._Getcomp(); // intentionally copy comparator, see LWG-2227
+        _Pocma(_Al, _Right_al);
+        _Swap_val_excluding_comp(_Right);
+
+        return *this;
+    }
+
+private:
+    void _Swap_val_excluding_comp(_Tree& _Right) { // swap contents (except comparator) with _Right, equal allocators
+        using _STD swap;
+        const auto _Scary       = _Get_scary();
+        const auto _Right_scary = _Right._Get_scary();
+        _Scary->_Swap_proxy_and_iterators(*_Right_scary);
+        swap(_Scary->_Myhead, _Right_scary->_Myhead); // intentional ADL
+        _STD swap(_Scary->_Mysize, _Right_scary->_Mysize);
+    }
+
+protected:
+    template <class... _Valtys>
+    pair<_Nodeptr, bool> _Emplace(_Valtys&&... _Vals) {
+        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Valtys...>;
+        const auto _Scary             = _Get_scary();
+        _Tree_find_result<_Nodeptr> _Loc;
+        _Nodeptr _Inserted;
+        if constexpr (!_Multi && _In_place_key_extractor::_Extractable) {
+            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
+            _Loc                = _Find_lower_bound(_Keyval);
+            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                return {_Loc._Bound, false};
+            }
+
+            _Check_grow_by_1();
+            _Inserted = _Tree_temp_node<_Alnode>(_Getal(), _Scary->_Myhead, _STD forward<_Valtys>(_Vals)...)._Release();
+            // nothrow hereafter
+        } else {
+            _Tree_temp_node<_Alnode> _Newnode(_Getal(), _Scary->_Myhead, _STD forward<_Valtys>(_Vals)...);
+            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
+            if constexpr (_Multi) { // duplicate check if unique
+                _Loc = _Find_upper_bound(_Keyval);
+            } else {
+                _Loc = _Find_lower_bound(_Keyval);
+                if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                    return {_Loc._Bound, false};
+                }
+            }
+
+            _Check_grow_by_1();
+            // nothrow hereafter
+            _Inserted = _Newnode._Release();
+        }
+
+        return {_Scary->_Insert_node(_Loc._Location, _Inserted), true};
+    }
+
+public:
+    template <class... _Valtys>
+    pair<iterator, bool> emplace(_Valtys&&... _Vals) {
+        const auto _Result = _Emplace(_STD forward<_Valtys>(_Vals)...);
+        return {iterator(_Result.first, _Get_scary()), _Result.second};
+    }
+
+protected:
+    template <class... _Valtys>
+    _Nodeptr _Emplace_hint(const _Nodeptr _Hint, _Valtys&&... _Vals) {
+        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Valtys...>;
+        const auto _Scary             = _Get_scary();
+        _Tree_find_hint_result<_Nodeptr> _Loc;
+        _Nodeptr _Inserted;
+        if constexpr (!_Multi && _In_place_key_extractor::_Extractable) {
+            _Loc = _Find_hint(_Hint, _In_place_key_extractor::_Extract(_Vals...));
+            if (_Loc._Duplicate) {
+                return _Loc._Location._Parent;
+            }
+
+            _Check_grow_by_1();
+            _Inserted = _Tree_temp_node<_Alnode>(_Getal(), _Scary->_Myhead, _STD forward<_Valtys>(_Vals)...)._Release();
+            // nothrow hereafter
+        } else {
+            _Tree_temp_node<_Alnode> _Newnode(_Getal(), _Scary->_Myhead, _STD forward<_Valtys>(_Vals)...);
+            _Loc = _Find_hint(_Hint, _Traits::_Kfn(_Newnode._Ptr->_Myval));
+            if constexpr (!_Multi) {
+                if (_Loc._Duplicate) {
+                    return _Loc._Location._Parent;
+                }
+            }
+
+            _Check_grow_by_1();
+            // nothrow hereafter
+            _Inserted = _Newnode._Release();
+        }
+
+        return _Scary->_Insert_node(_Loc._Location, _Inserted);
+    }
+
+public:
+    template <class... _Valtys>
+    iterator emplace_hint(const_iterator _Where, _Valtys&&... _Vals) { // insert value_type(_Val...) at _Where
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Emplace_hint(_Where._Ptr, _STD forward<_Valtys>(_Vals)...), _Scary);
+    }
+
+    ~_Tree() noexcept {
+        const auto _Scary = _Get_scary();
+        _Scary->_Erase_head(_Getal());
+#if _ITERATOR_DEBUG_LEVEL != 0 // TRANSITION, ABI
+        auto _Alproxy = _STD _Get_proxy_allocator(_Getal());
+        _Delete_plain_internal(_Alproxy, _Scary->_Myproxy);
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    }
+
+public:
+    _Tree& operator=(const _Tree& _Right) {
+        if (this == _STD addressof(_Right)) {
+            return *this;
+        }
+
+        auto& _Al       = _Getal();
+        auto& _Right_al = _Right._Getal();
+        if constexpr (_Choose_pocca_v<_Alnode>) {
+            if (_Al != _Right_al) {
+                clear();
+                const auto _Scary = _Get_scary();
+                _Scary->_Orphan_all();
+                auto _Alproxy       = _STD _Get_proxy_allocator(_Al);
+                auto _Right_alproxy = _STD _Get_proxy_allocator(_Right_al);
+                _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
+                auto _Right_al_non_const = _Right_al;
+                auto _Newhead            = _Node::_Buyheadnode(_Right_al_non_const);
+                _Node::_Freenode0(_Al, _Scary->_Myhead);
+                _Pocca(_Al, _Right_al);
+                _Scary->_Myhead = _Newhead;
+                _Proxy._Bind(_Alproxy, _Scary);
+                _Getcomp() = _Right._Getcomp();
+                _Copy<_Strategy::_Copy>(_Right);
+                return *this;
+            }
+        }
+
+        clear();
+        _Getcomp() = _Right._Getcomp();
+        _Pocca(_Al, _Right_al);
+        _Copy<_Strategy::_Copy>(_Right);
+
+        return *this;
+    }
+
+    _NODISCARD iterator begin() noexcept {
+        const auto _Scary = _Get_scary();
+        return iterator(_Scary->_Myhead->_Left, _Scary);
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        const auto _Scary = _Get_scary();
+        return const_iterator(_Scary->_Myhead->_Left, _Scary);
+    }
+
+    _NODISCARD iterator end() noexcept {
+        const auto _Scary = _Get_scary();
+        return iterator(_Scary->_Myhead, _Scary);
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        const auto _Scary = _Get_scary();
+        return const_iterator(_Scary->_Myhead, _Scary);
+    }
+
+    _Unchecked_iterator _Unchecked_begin() noexcept {
+        return _Unchecked_iterator(_Get_scary()->_Myhead->_Left, nullptr);
+    }
+
+    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
+        return _Unchecked_const_iterator(_Get_scary()->_Myhead->_Left, nullptr);
+    }
+
+    _Default_sentinel _Unchecked_end() const noexcept {
+        return {};
+    }
+
+    _Unchecked_const_iterator _Unchecked_end_iter() const noexcept {
+        return _Unchecked_const_iterator(_Get_scary()->_Myhead, nullptr);
+    }
+
+    _NODISCARD reverse_iterator rbegin() noexcept {
+        return reverse_iterator(end());
+    }
+
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return const_reverse_iterator(end());
+    }
+
+    _NODISCARD reverse_iterator rend() noexcept {
+        return reverse_iterator(begin());
+    }
+
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return const_reverse_iterator(begin());
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return begin();
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return end();
+    }
+
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return rbegin();
+    }
+
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return rend();
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _Get_scary()->_Mysize;
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        constexpr auto _Diff_max = static_cast<size_type>(_STD _Max_limit<difference_type>());
+        return (_STD min) (_Diff_max, _Alnode_traits::max_size(_Getal()));
+    }
+
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Get_scary()->_Mysize == 0;
+    }
+
+    _NODISCARD allocator_type get_allocator() const noexcept {
+        return static_cast<allocator_type>(_Getal());
+    }
+
+    _NODISCARD key_compare key_comp() const {
+        return _Getcomp();
+    }
+
+    _NODISCARD value_compare value_comp() const {
+        return value_compare(key_comp());
+    }
+
+    template <bool _Multi2 = _Multi, enable_if_t<!_Multi2, int> = 0>
+    pair<iterator, bool> insert(const value_type& _Val) {
+        const auto _Result = _Emplace(_Val);
+        return {iterator(_Result.first, _Get_scary()), _Result.second};
+    }
+
+    template <bool _Multi2 = _Multi, enable_if_t<_Multi2, int> = 0>
+    iterator insert(const value_type& _Val) {
+        return iterator(_Emplace(_Val).first, _Get_scary());
+    }
+
+    template <bool _Multi2 = _Multi, enable_if_t<!_Multi2, int> = 0>
+    pair<iterator, bool> insert(value_type&& _Val) {
+        const auto _Result = _Emplace(_STD move(_Val));
+        return {iterator(_Result.first, _Get_scary()), _Result.second};
+    }
+
+    template <bool _Multi2 = _Multi, enable_if_t<_Multi2, int> = 0>
+    iterator insert(value_type&& _Val) {
+        return iterator(_Emplace(_STD move(_Val)).first, _Get_scary());
+    }
+
+    iterator insert(const_iterator _Where, const value_type& _Val) {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Emplace_hint(_Where._Ptr, _Val), _Scary);
+    }
+
+    iterator insert(const_iterator _Where, value_type&& _Val) {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Emplace_hint(_Where._Ptr, _STD move(_Val)), _Scary);
+    }
+
+protected:
+    template <class _Iter, class _Sent>
+    void _Insert_range_unchecked(_Iter _First, const _Sent _Last) {
+        const auto _Myhead = _Get_scary()->_Myhead;
+        for (; _First != _Last; ++_First) {
+            _Emplace_hint(_Myhead, *_First);
+        }
+    }
+
+public:
+    template <class _Iter>
+    void insert(_Iter _First, _Iter _Last) {
+        _STD _Adl_verify_range(_First, _Last);
+        _Insert_range_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last));
+    }
+
+#if _HAS_CXX23
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
+        _Insert_range_unchecked(_RANGES _Ubegin(_Range), _RANGES _Uend(_Range));
+    }
+#endif // _HAS_CXX23
+
+    void insert(initializer_list<value_type> _Ilist) {
+        _Insert_range_unchecked(_Ilist.begin(), _Ilist.end());
+    }
+
+private:
+    _Nodeptr _Erase_unchecked(_Unchecked_const_iterator _Where) noexcept {
+        const auto _Scary                    = _Get_scary();
+        _Unchecked_const_iterator _Successor = _Where;
+        ++_Successor; // save successor iterator for return
+        _Nodeptr _Erasednode = _Scary->_Extract(_Where); // node to erase
+        _Scary->_Orphan_ptr(_Erasednode);
+        _Node::_Freenode(_Getal(), _Erasednode); // delete erased node
+        return _Successor._Ptr; // return successor nodeptr
+    }
+
+    _Nodeptr _Erase_unchecked(_Unchecked_const_iterator _First, _Unchecked_const_iterator _Last) noexcept {
+        const auto _Begin = _Unchecked_begin();
+        if (_First == _Begin && _Last._Ptr->_Isnil) {
+            // erase all
+            clear();
+            return _Last._Ptr;
+        }
+
+        // partial erase, one at a time
+        while (_First != _Last) {
+            _Erase_unchecked(_First++);
+        }
+
+        return _Last._Ptr;
+    }
+
+    size_type _Erase(const pair<_Nodeptr, _Nodeptr> _Where) noexcept {
+        const _Unchecked_const_iterator _First(_Where.first, nullptr);
+        const _Unchecked_const_iterator _Last(_Where.second, nullptr);
+        const auto _Num = static_cast<size_type>(_STD distance(_First, _Last));
+        _Erase_unchecked(_First, _Last);
+        return _Num;
+    }
+
+public:
+    template <class _Iter = iterator, enable_if_t<!is_same_v<_Iter, const_iterator>, int> = 0>
+    iterator erase(iterator _Where) noexcept /* strengthened */ {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set erase iterator from incorrect container");
+        _STL_VERIFY(!_Where._Ptr->_Isnil, "cannot erase map/set end() iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Erase_unchecked(_Where._Unwrapped()), _Scary);
+    }
+
+    iterator erase(const_iterator _Where) noexcept /* strengthened */ {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary, "map/set erase iterator from incorrect container");
+        _STL_VERIFY(!_Where._Ptr->_Isnil, "cannot erase map/set end() iterator");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        return iterator(_Erase_unchecked(_Where._Unwrapped()), _Scary);
+    }
+
+    iterator erase(const_iterator _First, const_iterator _Last) noexcept /* strengthened */ {
+        return iterator(_Erase_unchecked(_First._Unwrapped(), _Last._Unwrapped()), _Get_scary());
+    }
+
+    size_type erase(const key_type& _Keyval) noexcept(noexcept(_Eqrange(_Keyval))) /* strengthened */ {
+        return _Erase(_Eqrange(_Keyval));
+    }
+
+#if _HAS_CXX23
+    template <class _Kx>
+        requires _Transparent<key_compare> && (!is_convertible_v<_Kx, const_iterator>)
+              && (!is_convertible_v<_Kx, iterator>)
+    size_type erase(_Kx&& _Keyval) noexcept(noexcept(_Eqrange(_Keyval))) /* strengthened */ {
+        return _Erase(_Eqrange(_Keyval));
+    }
+#endif // _HAS_CXX23
+
+    void clear() noexcept {
+        const auto _Scary = _Get_scary();
+        _Scary->_Orphan_ptr(nullptr);
+        auto _Head = _Scary->_Myhead;
+        _Scary->_Erase_tree(_Getal(), _Head->_Parent);
+        _Head->_Parent  = _Head;
+        _Head->_Left    = _Head;
+        _Head->_Right   = _Head;
+        _Scary->_Mysize = 0;
+    }
+
+private:
+    template <class _Other>
+    _NODISCARD _Nodeptr _Find(const _Other& _Keyval) const {
+        const _Tree_find_result<_Nodeptr> _Loc = _Find_lower_bound(_Keyval);
+        if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+            return _Loc._Bound;
+        }
+
+        return _Get_scary()->_Myhead;
+    }
+
+public:
+    _NODISCARD iterator find(const key_type& _Keyval) {
+        return iterator(_Find(_Keyval), _Get_scary());
+    }
+
+    _NODISCARD const_iterator find(const key_type& _Keyval) const {
+        return const_iterator(_Find(_Keyval), _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD iterator find(const _Other& _Keyval) {
+        return iterator(_Find(_Keyval), _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD const_iterator find(const _Other& _Keyval) const {
+        return const_iterator(_Find(_Keyval), _Get_scary());
+    }
+
+#if _HAS_CXX20
+    _NODISCARD bool contains(const key_type& _Keyval) const {
+        return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
+    }
+
+    template <class _Other>
+        requires _Transparent<key_compare>
+    _NODISCARD bool contains(const _Other& _Keyval) const {
+        return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
+    }
+#endif // _HAS_CXX20
+
+    _NODISCARD size_type count(const key_type& _Keyval) const {
+        if constexpr (_Multi) {
+            const auto _Ans = _Eqrange(_Keyval);
+            return static_cast<size_type>(_STD distance(
+                _Unchecked_const_iterator(_Ans.first, nullptr), _Unchecked_const_iterator(_Ans.second, nullptr)));
+        } else {
+            return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
+        }
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD size_type count(const _Other& _Keyval) const {
+        const auto _Ans = _Eqrange(_Keyval);
+        return static_cast<size_type>(_STD distance(
+            _Unchecked_const_iterator(_Ans.first, nullptr), _Unchecked_const_iterator(_Ans.second, nullptr)));
+    }
+
+    _NODISCARD iterator lower_bound(const key_type& _Keyval) {
+        return iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    _NODISCARD const_iterator lower_bound(const key_type& _Keyval) const {
+        return const_iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD iterator lower_bound(const _Other& _Keyval) {
+        return iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD const_iterator lower_bound(const _Other& _Keyval) const {
+        return const_iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    _NODISCARD iterator upper_bound(const key_type& _Keyval) {
+        return iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    _NODISCARD const_iterator upper_bound(const key_type& _Keyval) const {
+        return const_iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD iterator upper_bound(const _Other& _Keyval) {
+        return iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD const_iterator upper_bound(const _Other& _Keyval) const {
+        return const_iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
+    }
+
+    _NODISCARD pair<iterator, iterator> equal_range(const key_type& _Keyval) {
+        const auto _Result = _Eqrange(_Keyval);
+        const auto _Scary  = _Get_scary();
+        return {iterator(_Result.first, _Scary), iterator(_Result.second, _Scary)};
+    }
+
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Keyval) const {
+        const auto _Result = _Eqrange(_Keyval);
+        const auto _Scary  = _Get_scary();
+        return {const_iterator(_Result.first, _Scary), const_iterator(_Result.second, _Scary)};
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD pair<iterator, iterator> equal_range(const _Other& _Keyval) {
+        const auto _Result = _Eqrange(_Keyval);
+        const auto _Scary  = _Get_scary();
+        return {iterator(_Result.first, _Scary), iterator(_Result.second, _Scary)};
+    }
+
+    template <class _Other, class _Mycomp = key_compare, enable_if_t<_Is_transparent_v<_Mycomp>, int> = 0>
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Keyval) const {
+        const auto _Result = _Eqrange(_Keyval);
+        const auto _Scary  = _Get_scary();
+        return {const_iterator(_Result.first, _Scary), const_iterator(_Result.second, _Scary)};
+    }
+
+    void swap(_Tree& _Right) noexcept(_Is_nothrow_swappable<key_compare>::value) /* strengthened */ {
+        using _STD swap;
+        if (this != _STD addressof(_Right)) {
+            _Pocs(_Getal(), _Right._Getal());
+            _Swap_val_excluding_comp(_Right);
+            swap(_Getcomp(), _Right._Getcomp()); // intentional ADL
+        }
+    }
+
+protected:
+    template <class _Keyty>
+    _Tree_find_hint_result<_Nodeptr> _Find_hint(const _Nodeptr _Hint, const _Keyty& _Keyval) const {
+        const auto& _Comp = _Getcomp();
+        const auto _Head  = _Get_scary()->_Myhead;
+        if constexpr (_Multi) { // insert even if duplicate
+            if (_Hint->_Isnil) {
+                // insert at end if greater than or equal to last element
+                if (_Head->_Parent->_Isnil || !_DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Head->_Right->_Myval))) {
+                    return {{_Head->_Right, _Tree_child::_Right}, false};
+                }
+
+                // _Hint is end(); it must be closer to the end of equivalents
+                return {_Find_upper_bound(_Keyval)._Location, false};
+            }
+
+            if (_Hint == _Head->_Left) {
+                // insert at beginning if less than or equal to first element
+                if (!_DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
+                    return {{_Hint, _Tree_child::_Left}, false};
+                }
+
+                // _Hint is begin(); it must be closer to the beginning of equivalents
+                return {_Find_lower_bound(_Keyval)._Location, false};
+            }
+
+            if (!_DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
+                // _Val <= *_Hint
+                const auto _Prev = (--(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
+                if (!_DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Prev->_Myval))) {
+                    // _Val <= *_Hint and _Val >= *prev(_Hint); insert here
+                    if (_Prev->_Right->_Isnil) {
+                        return {{_Prev, _Tree_child::_Right}, false};
+                    } else {
+                        return {{_Hint, _Tree_child::_Left}, false};
+                    }
+                }
+
+                // _Val goes before *_Hint; _Hint must be closer to the end of equivalents
+                return {_Find_upper_bound(_Keyval)._Location, false};
+            }
+
+            // _Val goes after *_Hint; _Hint must be closer to the beginning of equivalents
+            return {_Find_lower_bound(_Keyval)._Location, false};
+        } else { // insert only if unique
+            if (_Hint->_Isnil) { // insert at end if after last element
+                // insert at end if greater than last element
+                if (_Head->_Parent->_Isnil || _DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Head->_Right->_Myval), _Keyval)) {
+                    return {{_Head->_Right, _Tree_child::_Right}, false};
+                }
+            } else if (_Hint == _Head->_Left) {
+                // insert at beginning if less than first element
+                if (_DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Hint->_Myval))) {
+                    return {{_Hint, _Tree_child::_Left}, false};
+                }
+            } else if (_DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Hint->_Myval))) {
+                // _Val < *_Hint
+                const auto _Prev = (--(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
+                if (_DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Prev->_Myval), _Keyval)) {
+                    // _Val < *_Hint and _Val > *prev(_Hint); insert here
+                    if (_Prev->_Right->_Isnil) {
+                        return {{_Prev, _Tree_child::_Right}, false};
+                    } else {
+                        return {{_Hint, _Tree_child::_Left}, false};
+                    }
+                }
+            } else if (_DEBUG_LT_PRED(_Comp, _Traits::_Kfn(_Hint->_Myval), _Keyval)) {
+                // _Val > *_Hint
+                const auto _Next = (++(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
+                if (_Next->_Isnil || _DEBUG_LT_PRED(_Comp, _Keyval, _Traits::_Kfn(_Next->_Myval))) {
+                    // _Val > *_Hint and _Val < *next(_Hint); insert here
+                    if (_Hint->_Right->_Isnil) {
+                        return {{_Hint, _Tree_child::_Right}, false};
+                    }
+
+                    return {{_Next, _Tree_child::_Left}, false};
+                }
+            } else {
+                // _Val is equivalent to *_Hint; don't insert
+                return {{_Hint, _Tree_child::_Right}, true};
+            }
+
+            const auto _Loc = _Find_lower_bound(_Keyval);
+            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                return {{_Loc._Bound, _Tree_child::_Unused}, true};
+            }
+
+            return {_Loc._Location, false};
+        }
+    }
+
+    template <class _Keyty>
+    _Tree_find_result<_Nodeptr> _Find_upper_bound(const _Keyty& _Keyval) const {
+        const auto _Scary = _Get_scary();
+        _Tree_find_result<_Nodeptr> _Result{{_Scary->_Myhead->_Parent, _Tree_child::_Right}, _Scary->_Myhead};
+        _Nodeptr _Trynode = _Result._Location._Parent;
+        while (!_Trynode->_Isnil) {
+            _Result._Location._Parent = _Trynode;
+            if (_DEBUG_LT_PRED(_Getcomp(), _Keyval, _Traits::_Kfn(_Trynode->_Myval))) {
+                _Result._Location._Child = _Tree_child::_Left;
+                _Result._Bound           = _Trynode;
+                _Trynode                 = _Trynode->_Left;
+            } else {
+                _Result._Location._Child = _Tree_child::_Right;
+                _Trynode                 = _Trynode->_Right;
+            }
+        }
+
+        return _Result;
+    }
+
+    template <class _Keyty>
+    bool _Lower_bound_duplicate(const _Nodeptr _Bound, const _Keyty& _Keyval) const {
+        return !_Bound->_Isnil && !_DEBUG_LT_PRED(_Getcomp(), _Keyval, _Traits::_Kfn(_Bound->_Myval));
+    }
+
+    template <class _Keyty>
+    _Tree_find_result<_Nodeptr> _Find_lower_bound(const _Keyty& _Keyval) const {
+        const auto _Scary = _Get_scary();
+        _Tree_find_result<_Nodeptr> _Result{{_Scary->_Myhead->_Parent, _Tree_child::_Right}, _Scary->_Myhead};
+        _Nodeptr _Trynode = _Result._Location._Parent;
+        while (!_Trynode->_Isnil) {
+            _Result._Location._Parent = _Trynode;
+            if (_DEBUG_LT_PRED(_Getcomp(), _Traits::_Kfn(_Trynode->_Myval), _Keyval)) {
+                _Result._Location._Child = _Tree_child::_Right;
+                _Trynode                 = _Trynode->_Right;
+            } else {
+                _Result._Location._Child = _Tree_child::_Left;
+                _Result._Bound           = _Trynode;
+                _Trynode                 = _Trynode->_Left;
+            }
+        }
+
+        return _Result;
+    }
+
+    void _Check_grow_by_1() {
+        if (max_size() == _Get_scary()->_Mysize) {
+            _Throw_tree_length_error();
+        }
+    }
+
+    template <_Strategy _Strat>
+    void _Copy(const _Tree& _Right) { // copy or move entire tree from _Right
+        const auto _Scary        = _Get_scary();
+        const auto _Right_scary  = _Right._Get_scary();
+        _Scary->_Myhead->_Parent = _Copy_nodes<_Strat>(_Right_scary->_Myhead->_Parent, _Scary->_Myhead);
+        _Scary->_Mysize          = _Right_scary->_Mysize;
+        if (!_Scary->_Myhead->_Parent->_Isnil) { // nonempty tree, look for new smallest and largest
+            _Scary->_Myhead->_Left  = _Scary_val::_Min(_Scary->_Myhead->_Parent);
+            _Scary->_Myhead->_Right = _Scary_val::_Max(_Scary->_Myhead->_Parent);
+        } else { // empty tree, just tidy head pointers
+            _Scary->_Myhead->_Left  = _Scary->_Myhead;
+            _Scary->_Myhead->_Right = _Scary->_Myhead;
+        }
+    }
+
+    template <_Strategy _Strat, class _Ty>
+    _Nodeptr _Copy_or_move(_Ty& _Val) {
+        if constexpr (_Strat == _Strategy::_Copy) {
+            return _Buynode(_Val);
+        } else {
+            if constexpr (_Is_set) {
+                return _Buynode(_STD move(_Val));
+            } else {
+                return _Buynode(_STD move(const_cast<key_type&>(_Val.first)), _STD move(_Val.second));
+            }
+        }
+    }
+
+    template <_Strategy _Strat>
+    _Nodeptr _Copy_nodes(_Nodeptr _Rootnode, _Nodeptr _Wherenode) {
+        // copy entire subtree, recursively
+        const auto _Scary = _Get_scary();
+        _Nodeptr _Newroot = _Scary->_Myhead; // point at nil node
+
+        if (!_Rootnode->_Isnil) { // copy or move a node, then any subtrees
+            _Newroot          = _Copy_or_move<_Strat>(_Rootnode->_Myval); // memorize new root
+            _Newroot->_Parent = _Wherenode;
+            _Newroot->_Color  = _Rootnode->_Color;
+
+            typename _Scary_val::template _Erase_tree_and_orphan_guard<_Alnode> _Guard{_Scary, _Getal(), _Newroot};
+
+            _Newroot->_Left  = _Copy_nodes<_Strat>(_Rootnode->_Left, _Newroot);
+            _Newroot->_Right = _Copy_nodes<_Strat>(_Rootnode->_Right, _Newroot);
+
+            _Guard._Val_ptr = nullptr;
+        }
+
+        return _Newroot; // return newly constructed tree
+    }
+
+    template <class _Other>
+    pair<_Nodeptr, _Nodeptr> _Eqrange(const _Other& _Keyval) const
+        noexcept(_Nothrow_compare<key_compare, key_type, _Other> && _Nothrow_compare<key_compare, _Other, key_type>) {
+        // find range of nodes equivalent to _Keyval
+        const auto _Scary = _Get_scary();
+        const auto& _Comp = _Getcomp();
+        _Nodeptr _Pnode   = _Scary->_Myhead->_Parent;
+        _Nodeptr _Lonode  = _Scary->_Myhead; // end() if search fails
+        _Nodeptr _Hinode  = _Scary->_Myhead; // end() if search fails
+
+        while (!_Pnode->_Isnil) {
+            const auto& _Nodekey = _Traits::_Kfn(_Pnode->_Myval);
+            if (_DEBUG_LT_PRED(_Comp, _Nodekey, _Keyval)) {
+                _Pnode = _Pnode->_Right; // descend right subtree
+            } else { // _Pnode not less than _Keyval, remember it
+                if (_Hinode->_Isnil && _DEBUG_LT_PRED(_Comp, _Keyval, _Nodekey)) {
+                    _Hinode = _Pnode; // _Pnode greater, remember it
+                }
+
+                _Lonode = _Pnode;
+                _Pnode  = _Pnode->_Left; // descend left subtree
+            }
+        }
+
+        _Pnode = _Hinode->_Isnil ? _Scary->_Myhead->_Parent : _Hinode->_Left; // continue scan for upper bound
+        while (!_Pnode->_Isnil) {
+            if (_DEBUG_LT_PRED(_Getcomp(), _Keyval, _Traits::_Kfn(_Pnode->_Myval))) {
+                // _Pnode greater than _Keyval, remember it
+                _Hinode = _Pnode;
+                _Pnode  = _Pnode->_Left; // descend left subtree
+            } else {
+                _Pnode = _Pnode->_Right; // descend right subtree
+            }
+        }
+
+        return {_Lonode, _Hinode};
+    }
+
+#if _HAS_CXX17
+public:
+    using node_type = typename _Traits::node_type;
+
+    node_type extract(const const_iterator _Where) {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Where._Getcont() == _Scary && !_Where._Ptr->_Isnil, "map/set erase iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto _Ptr = _Scary->_Extract(_Where._Unwrapped());
+        _Scary->_Orphan_ptr(_Ptr);
+        return node_type::_Make(_Ptr, _Getal());
+    }
+
+    node_type extract(const key_type& _Keyval) {
+        const const_iterator _Where = find(_Keyval);
+        if (_Where == end()) {
+            return node_type{};
+        }
+
+        return extract(_Where);
+    }
+
+#if _HAS_CXX23
+    template <class _Kx>
+        requires _Transparent<key_compare> && (!is_convertible_v<_Kx, const_iterator>)
+              && (!is_convertible_v<_Kx, iterator>)
+    node_type extract(_Kx&& _Keyval) {
+        const const_iterator _Where = find(_Keyval);
+        if (_Where == end()) {
+            return node_type{};
+        }
+
+        return extract(_Where);
+    }
+#endif // _HAS_CXX23
+
+    auto insert(node_type&& _Handle) {
+        if (_Handle.empty()) {
+            if constexpr (_Multi) {
+                return end();
+            } else {
+                return _Insert_return_type<iterator, node_type>{end(), false, {}};
+            }
+        }
+
+        _Check_node_allocator(_Handle);
+        const auto _Scary        = _Get_scary();
+        const auto _Attempt_node = _Handle._Getptr();
+        const auto& _Keyval      = _Traits::_Kfn(_Attempt_node->_Myval);
+        _Tree_find_result<_Nodeptr> _Loc;
+        if constexpr (_Multi) {
+            _Loc = _Find_upper_bound(_Keyval);
+        } else {
+            _Loc = _Find_lower_bound(_Keyval);
+            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                return _Insert_return_type<iterator, node_type>{
+                    iterator(_Loc._Bound, _Scary), false, _STD move(_Handle)};
+            }
+        }
+
+        _Check_grow_by_1();
+
+        // nothrow hereafter
+
+        _Attempt_node->_Left = _Scary->_Myhead;
+        // _Attempt_node->_Parent handled in _Insert_node
+        _Attempt_node->_Right = _Scary->_Myhead;
+        _Attempt_node->_Color = _Red;
+
+        const auto _Inserted = _Scary->_Insert_node(_Loc._Location, _Handle._Release());
+        if constexpr (_Multi) {
+            return iterator(_Inserted, _Scary);
+        } else {
+            return _Insert_return_type<iterator, node_type>{iterator(_Inserted, _Scary), true, _STD move(_Handle)};
+        }
+    }
+
+    iterator insert(const const_iterator _Hint, node_type&& _Handle) {
+        const auto _Scary = _Get_scary();
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(_Hint._Getcont() == _Scary, "map/set insert iterator outside range");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+        if (_Handle.empty()) {
+            return end();
+        }
+
+        _Check_node_allocator(_Handle);
+        const auto _Attempt_node = _Handle._Getptr();
+        const auto& _Keyval      = _Traits::_Kfn(_Attempt_node->_Myval);
+        const auto _Loc          = _Find_hint(_Hint._Ptr, _Keyval);
+        if (_Loc._Duplicate) {
+            return iterator(_Loc._Location._Parent, _Scary);
+        }
+
+        _Check_grow_by_1();
+
+        _Attempt_node->_Left = _Scary->_Myhead;
+        // _Attempt_node->_Parent handled in _Insert_node
+        _Attempt_node->_Right = _Scary->_Myhead;
+        _Attempt_node->_Color = _Red;
+
+        return iterator(_Scary->_Insert_node(_Loc._Location, _Handle._Release()), _Scary);
+    }
+
+    template <class>
+    friend class _Tree;
+
+    template <class _Other_traits>
+    void merge(_Tree<_Other_traits>& _That) {
+        static_assert(is_same_v<_Nodeptr, typename _Tree<_Other_traits>::_Nodeptr>,
+            "merge() requires an argument with a compatible node type.");
+
+        static_assert(is_same_v<allocator_type, typename _Tree<_Other_traits>::allocator_type>,
+            "merge() requires an argument with the same allocator type.");
+
+        if constexpr (is_same_v<_Tree, _Tree<_Other_traits>>) {
+            if (this == _STD addressof(_That)) {
+                return;
+            }
+        }
+
+#if _ITERATOR_DEBUG_LEVEL == 2
+        if constexpr (!_Alnode_traits::is_always_equal::value) {
+            _STL_VERIFY(_Getal() == _That._Getal(), "allocator incompatible for merge");
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+
+        const auto _Scary      = _Get_scary();
+        const auto _Head       = _Scary->_Myhead;
+        const auto _That_scary = _That._Get_scary();
+        auto _First            = _That._Unchecked_begin();
+        while (!_First._Ptr->_Isnil) {
+            const auto _Attempt_node = _First._Ptr;
+            ++_First;
+            _Tree_find_result<_Nodeptr> _Loc;
+            const auto& _Keyval = _Traits::_Kfn(_Attempt_node->_Myval);
+            if constexpr (_Multi) {
+                _Loc = _Find_upper_bound(_Keyval);
+            } else {
+                _Loc = _Find_lower_bound(_Keyval);
+                if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
+                    continue;
+                }
+            }
+
+            _Check_grow_by_1();
+
+            // nothrow hereafter for this iteration
+            const auto _Extracted = _That_scary->_Extract(_Unchecked_const_iterator(_Attempt_node, nullptr));
+            _Extracted->_Left     = _Head;
+            // _Extracted->_Parent handled in _Insert_node
+            _Extracted->_Right = _Head;
+            _Extracted->_Color = _Red;
+
+            const auto _Inserted = _Scary->_Insert_node(_Loc._Location, _Extracted);
+            _Reparent_ptr(_Inserted, _That);
+        }
+    }
+
+    template <class _Other_traits>
+    void merge(_Tree<_Other_traits>&& _That) {
+        static_assert(is_same_v<_Nodeptr, typename _Tree<_Other_traits>::_Nodeptr>,
+            "merge() requires an argument with a compatible node type.");
+
+        static_assert(is_same_v<allocator_type, typename _Tree<_Other_traits>::allocator_type>,
+            "merge() requires an argument with the same allocator type.");
+
+        merge(_That);
+    }
+
+protected:
+    template <class _Other_traits>
+    void _Reparent_ptr(const _Nodeptr _Ptr, _Tree<_Other_traits>& _Old_parent) {
+        (void) _Ptr;
+        (void) _Old_parent;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _Lockit _Lock(_LOCK_DEBUG);
+        const auto _Old_parent_scary = _Old_parent._Get_scary();
+        _Iterator_base12** _Pnext    = &_Old_parent_scary->_Myproxy->_Myfirstiter;
+        _STL_VERIFY(_Pnext, "source container corrupted");
+        if (_Ptr == nullptr || _Ptr == _Old_parent_scary->_Myhead) {
+            return;
+        }
+
+        const auto _My_saved_proxy               = _Get_scary()->_Myproxy;
+        _Iterator_base12** const _My_saved_first = &_My_saved_proxy->_Myfirstiter;
+
+        while (*_Pnext) {
+            _Iterator_base12** const _Next = &(*_Pnext)->_Mynextiter;
+            const auto _Iter               = static_cast<const_iterator*>(*_Pnext);
+            if (_Iter->_Ptr == _Ptr) { // reparent the iterator
+                *_Pnext            = *_Next;
+                _Iter->_Myproxy    = _My_saved_proxy;
+                _Iter->_Mynextiter = *_My_saved_first;
+                *_My_saved_first   = _Iter;
+            } else { // skip the iterator
+                _Pnext = _Next;
+            }
+        }
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+    }
+
+    void _Check_node_allocator(node_type& _Handle) const {
+        (void) _Handle;
+#if _ITERATOR_DEBUG_LEVEL == 2
+        _STL_VERIFY(get_allocator() == _Handle._Getal(), "node handle allocator incompatible for insert");
+#endif // _ITERATOR_DEBUG_LEVEL == 2
+    }
+#endif // _HAS_CXX17
+
+    void _Alloc_sentinel_and_proxy() {
+        const auto _Scary = _Get_scary();
+        auto _Alproxy     = _STD _Get_proxy_allocator(_Getal());
+        _Container_proxy_ptr<_Alnode> _Proxy(_Alproxy, *_Scary);
+        _Scary->_Myhead = _Node::_Buyheadnode(_Getal());
+        _Proxy._Release();
+    }
+
+    template <class... _Valty>
+    _Nodeptr _Buynode(_Valty&&... _Val) {
+        return _Node::_Buynode(_Getal(), _Get_scary()->_Myhead, _STD forward<_Valty>(_Val)...);
+    }
+
+    key_compare& _Getcomp() noexcept {
+        return _Mypair._Get_first();
+    }
+
+    const key_compare& _Getcomp() const noexcept {
+        return _Mypair._Get_first();
+    }
+
+    _Alnode& _Getal() noexcept {
+        return _Mypair._Myval2._Get_first();
+    }
+
+    const _Alnode& _Getal() const noexcept {
+        return _Mypair._Myval2._Get_first();
+    }
+
+    _Scary_val* _Get_scary() noexcept {
+        return _STD addressof(_Mypair._Myval2._Myval2);
+    }
+
+    const _Scary_val* _Get_scary() const noexcept {
+        return _STD addressof(_Mypair._Myval2._Myval2);
+    }
+
+private:
+    _Compressed_pair<key_compare, _Compressed_pair<_Alnode, _Scary_val>> _Mypair;
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XTREE_
diff --git a/msvc-stl/stl/inc/xutility b/msvc-stl/stl/inc/xutility
new file mode 100644
index 0000000..488bc52
--- /dev/null
+++ b/msvc-stl/stl/inc/xutility
@@ -0,0 +1,8021 @@
+// xutility internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _XUTILITY_
+#define _XUTILITY_
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#include <__msvc_iter_core.hpp>
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+#include <cwchar>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#pragma push_macro("intrinsic")
+#pragma push_macro("lifetimebound")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef intrinsic
+#undef lifetimebound
+#undef no_specializations
+
+#if defined(_CRTBLD) && defined(CRTDLL2)
+// TRANSITION, ABI: The vector algorithms are compiled into the import lib, so we disable their usage when building
+// the DLL. (We could additionally link them into the DLL - not as exports, just for internal usage - but we
+// haven't chosen to do that yet.) When we can break ABI and export the vector algorithms from the DLL,
+// this preprocessor case should be removed.
+#ifndef _USE_STD_VECTOR_ALGORITHMS
+#define _USE_STD_VECTOR_ALGORITHMS 0
+#elif _USE_STD_VECTOR_ALGORITHMS
+#error Vector algorithms are not supported when building msvcp140.dll, but _USE_STD_VECTOR_ALGORITHMS is set.
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS != 0 ^^^
+#elif defined(_M_CEE_PURE) || defined(_M_HYBRID)
+#ifndef _USE_STD_VECTOR_ALGORITHMS
+#define _USE_STD_VECTOR_ALGORITHMS 0
+#elif _USE_STD_VECTOR_ALGORITHMS
+#error Vector algorithms are not supported on this architecture, but _USE_STD_VECTOR_ALGORITHMS is set.
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS != 0 ^^^
+#else // ^^^ vector algorithms unsupported for /clr:pure or CHPE / vector algorithms supported by default vvv
+#ifndef _USE_STD_VECTOR_ALGORITHMS
+#define _USE_STD_VECTOR_ALGORITHMS 1
+#endif // !defined(_USE_STD_VECTOR_ALGORITHMS)
+#endif // ^^^ vector algorithms supported by default ^^^
+
+// _USE_STD_VECTOR_ALGORITHMS is our documented control macro:
+// https://learn.microsoft.com/cpp/standard-library/vectorized-stl-algorithms
+// In the STL's implementation, we inspect the following detection macros,
+// because various algorithms are vectorized for various architectures.
+
+// _CALL_ALL_X64_VECTOR_ALGORITHMS_ON_ARM64EC is a macro to test ARM64EC fallbacks for x64 algorithms.
+
+#if !_USE_STD_VECTOR_ALGORITHMS
+#define _VECTORIZED_FOR_X64_X86               0
+#define _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC 0
+#elif defined(_M_ARM64) || (defined(_M_ARM64EC) && !defined(_CALL_ALL_X64_VECTOR_ALGORITHMS_ON_ARM64EC))
+#define _VECTORIZED_FOR_X64_X86               0
+#define _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC 1
+#elif defined(_M_X64) || defined(_M_IX86)
+#define _VECTORIZED_FOR_X64_X86               1
+#define _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC 1
+#else // ^^^ known architecture / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+
+#define _VECTORIZED_ADJACENT_FIND      _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_BITSET_FROM_STRING _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_BITSET_TO_STRING   _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_COUNT              _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_FIND               _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_FIND_END           _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_FIND_FIRST_OF      _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_FIND_LAST          _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_FIND_LAST_OF       _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_INCLUDES           _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_IS_SORTED_UNTIL    _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_MINMAX             _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_MINMAX_ELEMENT     _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_MISMATCH           _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_REMOVE             _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_REMOVE_COPY        _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_REPLACE            _VECTORIZED_FOR_X64_X86
+#define _VECTORIZED_REPLACE_COPY       _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_REVERSE            _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_REVERSE_COPY       _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_ROTATE             _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_SEARCH             _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_SEARCH_N           _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_SWAP_RANGES        _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_UNIQUE             _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+#define _VECTORIZED_UNIQUE_COPY        _VECTORIZED_FOR_X64_X86_ARM64_ARM64EC
+
+// We choose not to vectorize minmax_element for 64-bit integers on ARM64/ARM64EC
+// as this does not improve performance over the scalar code.
+#define _VECTORIZED_MINMAX_ELEMENT_64BIT_INT _VECTORIZED_FOR_X64_X86
+
+#ifndef _USE_STD_VECTOR_FLOATING_ALGORITHMS
+#if _USE_STD_VECTOR_ALGORITHMS && !defined(_M_FP_EXCEPT)
+#define _USE_STD_VECTOR_FLOATING_ALGORITHMS 1
+#else // ^^^ use vector algorithms and not use _M_FP_EXCEPT / not use vector algorithms or use _M_FP_EXCEPT vvv
+#define _USE_STD_VECTOR_FLOATING_ALGORITHMS 0
+#endif // ^^^ not use vector algorithms or use _M_FP_EXCEPT ^^^
+#else // ^^^ !defined(_USE_STD_VECTOR_FLOATING_ALGORITHMS) / defined(_USE_STD_VECTOR_FLOATING_ALGORITHMS) vvv
+#if _USE_STD_VECTOR_FLOATING_ALGORITHMS && !_USE_STD_VECTOR_ALGORITHMS
+#error _USE_STD_VECTOR_FLOATING_ALGORITHMS must imply _USE_STD_VECTOR_ALGORITHMS.
+#endif // _USE_STD_VECTOR_FLOATING_ALGORITHMS && !_USE_STD_VECTOR_ALGORITHMS
+#endif // ^^^ defined(_USE_STD_VECTOR_FLOATING_ALGORITHMS) ^^^
+
+extern "C" {
+// The "noalias" attribute tells the compiler optimizer that pointers going into these hand-vectorized algorithms
+// won't be stored beyond the lifetime of the function, and that the function will only reference arrays denoted by
+// those pointers. The optimizer also assumes in that case that a pointer parameter is not returned to the caller via
+// the return value, so functions using "noalias" must usually return void. This attribute is valuable because these
+// functions are in native code objects that the compiler cannot analyze. In the absence of the noalias attribute, the
+// compiler has to assume that the denoted arrays are "globally address taken", and that any later calls to
+// unanalyzable routines may modify those arrays.
+
+#if _VECTORIZED_REVERSE
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_1(void* _First, void* _Last) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_2(void* _First, void* _Last) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_4(void* _First, void* _Last) noexcept;
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_8(void* _First, void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_REVERSE ^^^
+
+#if _VECTORIZED_SWAP_RANGES
+__declspec(noalias) void __cdecl __std_swap_ranges_trivially_swappable_noalias(
+    void* _First1, void* _Last1, void* _First2) noexcept;
+#endif // ^^^ _VECTORIZED_SWAP_RANGES ^^^
+
+#if _VECTORIZED_ROTATE
+__declspec(noalias) void __stdcall __std_rotate(void* _First, void* _Mid, void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_ROTATE ^^^
+
+#if _VECTORIZED_COUNT
+__declspec(noalias) size_t __stdcall __std_count_trivial_1(
+    const void* _First, const void* _Last, uint8_t _Val) noexcept;
+__declspec(noalias) size_t __stdcall __std_count_trivial_2(
+    const void* _First, const void* _Last, uint16_t _Val) noexcept;
+__declspec(noalias) size_t __stdcall __std_count_trivial_4(
+    const void* _First, const void* _Last, uint32_t _Val) noexcept;
+__declspec(noalias) size_t __stdcall __std_count_trivial_8(
+    const void* _First, const void* _Last, uint64_t _Val) noexcept;
+#endif // ^^^ _VECTORIZED_COUNT ^^^
+
+#if _VECTORIZED_FIND
+const void* __stdcall __std_find_trivial_1(const void* _First, const void* _Last, uint8_t _Val) noexcept;
+const void* __stdcall __std_find_trivial_2(const void* _First, const void* _Last, uint16_t _Val) noexcept;
+const void* __stdcall __std_find_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
+const void* __stdcall __std_find_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;
+#endif // ^^^ _VECTORIZED_FIND ^^^
+
+#if _VECTORIZED_FIND_LAST
+const void* __stdcall __std_find_last_trivial_1(const void* _First, const void* _Last, uint8_t _Val) noexcept;
+const void* __stdcall __std_find_last_trivial_2(const void* _First, const void* _Last, uint16_t _Val) noexcept;
+const void* __stdcall __std_find_last_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
+const void* __stdcall __std_find_last_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;
+#endif // ^^^ _VECTORIZED_FIND_LAST ^^^
+
+#if _VECTORIZED_ADJACENT_FIND
+const void* __stdcall __std_adjacent_find_1(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_adjacent_find_2(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_adjacent_find_4(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_adjacent_find_8(const void* _First, const void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_ADJACENT_FIND ^^^
+
+#if _VECTORIZED_SEARCH
+const void* __stdcall __std_search_1(
+    const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept;
+const void* __stdcall __std_search_2(
+    const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept;
+const void* __stdcall __std_search_4(
+    const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept;
+const void* __stdcall __std_search_8(
+    const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept;
+#endif // ^^^ _VECTORIZED_SEARCH ^^^
+
+#if _VECTORIZED_FIND_END
+const void* __stdcall __std_find_end_1(
+    const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept;
+const void* __stdcall __std_find_end_2(
+    const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept;
+const void* __stdcall __std_find_end_4(
+    const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept;
+const void* __stdcall __std_find_end_8(
+    const void* _First1, const void* _Last1, const void* _First2, size_t _Count2) noexcept;
+#endif // ^^^ _VECTORIZED_FIND_END ^^^
+
+#if _VECTORIZED_MINMAX_ELEMENT
+const void* __stdcall __std_min_element_1i(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_min_element_1u(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_min_element_2i(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_min_element_2u(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_min_element_4i(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_min_element_4u(const void* _First, const void* _Last) noexcept;
+#if _VECTORIZED_MINMAX_ELEMENT_64BIT_INT
+const void* __stdcall __std_min_element_8i(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_min_element_8u(const void* _First, const void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT_64BIT_INT ^^^
+const void* __stdcall __std_min_element_f_(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_min_element_d_(const void* _First, const void* _Last) noexcept;
+
+const void* __stdcall __std_max_element_1i(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_max_element_1u(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_max_element_2i(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_max_element_2u(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_max_element_4i(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_max_element_4u(const void* _First, const void* _Last) noexcept;
+#if _VECTORIZED_MINMAX_ELEMENT_64BIT_INT
+const void* __stdcall __std_max_element_8i(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_max_element_8u(const void* _First, const void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT_64BIT_INT ^^^
+const void* __stdcall __std_max_element_f_(const void* _First, const void* _Last) noexcept;
+const void* __stdcall __std_max_element_d_(const void* _First, const void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+#if _VECTORIZED_MINMAX
+__declspec(noalias) int8_t __stdcall __std_min_1i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint8_t __stdcall __std_min_1u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int16_t __stdcall __std_min_2i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint16_t __stdcall __std_min_2u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int32_t __stdcall __std_min_4i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint32_t __stdcall __std_min_4u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int64_t __stdcall __std_min_8i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint64_t __stdcall __std_min_8u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) float __stdcall __std_min_f(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) double __stdcall __std_min_d(const void* _First, const void* _Last) noexcept;
+
+__declspec(noalias) int8_t __stdcall __std_max_1i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint8_t __stdcall __std_max_1u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int16_t __stdcall __std_max_2i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint16_t __stdcall __std_max_2u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int32_t __stdcall __std_max_4i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint32_t __stdcall __std_max_4u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) int64_t __stdcall __std_max_8i(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) uint64_t __stdcall __std_max_8u(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) float __stdcall __std_max_f(const void* _First, const void* _Last) noexcept;
+__declspec(noalias) double __stdcall __std_max_d(const void* _First, const void* _Last) noexcept;
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+
+#if _VECTORIZED_MISMATCH
+__declspec(noalias) size_t __stdcall __std_mismatch_1(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_2(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_4(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const void* _First2, size_t _Count) noexcept;
+#endif // ^^^ _VECTORIZED_MISMATCH ^^^
+
+} // extern "C"
+
+_STD_BEGIN
+
+template <class _Target, class _Source>
+_Target _Find_arg_cast(const _Source _Val) noexcept {
+    if constexpr (is_integral_v<_Source>) {
+        return static_cast<_Target>(_Val);
+    } else {
+        return _STD _Bit_cast<_Target>(_Val);
+    }
+}
+
+#if _VECTORIZED_REVERSE
+template <size_t _Nx>
+__declspec(noalias) void _Reverse_vectorized(void* _First, void* _Last) noexcept {
+    if constexpr (_Nx == 1) {
+        ::__std_reverse_trivially_swappable_1(_First, _Last);
+    } else if constexpr (_Nx == 2) {
+        ::__std_reverse_trivially_swappable_2(_First, _Last);
+    } else if constexpr (_Nx == 4) {
+        ::__std_reverse_trivially_swappable_4(_First, _Last);
+    } else if constexpr (_Nx == 8) {
+        ::__std_reverse_trivially_swappable_8(_First, _Last);
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_REVERSE ^^^
+
+#if _VECTORIZED_COUNT
+template <class _Ty, class _TVal>
+__declspec(noalias) size_t _Count_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return ::__std_count_trivial_1(_First, _Last, _STD _Find_arg_cast<uint8_t>(_Val));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return ::__std_count_trivial_2(_First, _Last, _STD _Find_arg_cast<uint16_t>(_Val));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return ::__std_count_trivial_4(_First, _Last, _STD _Find_arg_cast<uint32_t>(_Val));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return ::__std_count_trivial_8(_First, _Last, _STD _Find_arg_cast<uint64_t>(_Val));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_COUNT ^^^
+
+#if _VECTORIZED_FIND
+template <class _Ty, class _TVal>
+_Ty* _Find_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_1(_First, _Last, _STD _Find_arg_cast<uint8_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_2(_First, _Last, _STD _Find_arg_cast<uint16_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_4(_First, _Last, _STD _Find_arg_cast<uint32_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_8(_First, _Last, _STD _Find_arg_cast<uint64_t>(_Val))));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND ^^^
+
+#if _VECTORIZED_FIND_LAST
+template <class _Ty, class _TVal>
+_Ty* _Find_last_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_last_trivial_1(_First, _Last, _STD _Find_arg_cast<uint8_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_last_trivial_2(_First, _Last, _STD _Find_arg_cast<uint16_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_last_trivial_4(_First, _Last, _STD _Find_arg_cast<uint32_t>(_Val))));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_last_trivial_8(_First, _Last, _STD _Find_arg_cast<uint64_t>(_Val))));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND_LAST ^^^
+
+#if _VECTORIZED_ADJACENT_FIND
+template <class _Ty>
+_Ty* _Adjacent_find_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    if constexpr (sizeof(_Ty) == 1) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_adjacent_find_1(_First, _Last)));
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_adjacent_find_2(_First, _Last)));
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_adjacent_find_4(_First, _Last)));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_adjacent_find_8(_First, _Last)));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_ADJACENT_FIND ^^^
+
+#if _VECTORIZED_FIND_FIRST_OF || _VECTORIZED_FIND_LAST_OF
+// find_first_of vectorization is likely to be a win after this size (in elements)
+// (Used with _Find_first_of_vectorized, _Find_first_of_pos_vectorized, _Find_first_not_of_pos_vectorized,
+// _Find_last_of_pos_vectorized, and _Find_last_not_of_pos_vectorized.)
+_INLINE_VAR constexpr ptrdiff_t _Threshold_find_first_of = 16;
+#endif // ^^^ _VECTORIZED_FIND_FIRST_OF || _VECTORIZED_FIND_LAST_OF ^^^
+
+#if _VECTORIZED_SEARCH
+template <class _Ty1, class _Ty2>
+_Ty1* _Search_vectorized(_Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, const size_t _Count2) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Ty1) == sizeof(_Ty2));
+    if constexpr (sizeof(_Ty1) == 1) {
+        return const_cast<_Ty1*>(static_cast<const _Ty1*>(::__std_search_1(_First1, _Last1, _First2, _Count2)));
+    } else if constexpr (sizeof(_Ty1) == 2) {
+        return const_cast<_Ty1*>(static_cast<const _Ty1*>(::__std_search_2(_First1, _Last1, _First2, _Count2)));
+    } else if constexpr (sizeof(_Ty1) == 4) {
+        return const_cast<_Ty1*>(static_cast<const _Ty1*>(::__std_search_4(_First1, _Last1, _First2, _Count2)));
+    } else if constexpr (sizeof(_Ty1) == 8) {
+        return const_cast<_Ty1*>(static_cast<const _Ty1*>(::__std_search_8(_First1, _Last1, _First2, _Count2)));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_SEARCH ^^^
+
+#if _VECTORIZED_FIND_END
+template <class _Ty1, class _Ty2>
+_Ty1* _Find_end_vectorized(
+    _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, const size_t _Count2) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Ty1) == sizeof(_Ty2));
+    if constexpr (sizeof(_Ty1) == 1) {
+        return const_cast<_Ty1*>(static_cast<const _Ty1*>(::__std_find_end_1(_First1, _Last1, _First2, _Count2)));
+    } else if constexpr (sizeof(_Ty1) == 2) {
+        return const_cast<_Ty1*>(static_cast<const _Ty1*>(::__std_find_end_2(_First1, _Last1, _First2, _Count2)));
+    } else if constexpr (sizeof(_Ty1) == 4) {
+        return const_cast<_Ty1*>(static_cast<const _Ty1*>(::__std_find_end_4(_First1, _Last1, _First2, _Count2)));
+    } else if constexpr (sizeof(_Ty1) == 8) {
+        return const_cast<_Ty1*>(static_cast<const _Ty1*>(::__std_find_end_8(_First1, _Last1, _First2, _Count2)));
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_FIND_END ^^^
+
+#if _VECTORIZED_MINMAX_ELEMENT
+template <class _Ty>
+_Ty* _Min_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_f_(_First, _Last)));
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_d_(_First, _Last)));
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_1i(_First, _Last)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_1u(_First, _Last)));
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_2i(_First, _Last)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_2u(_First, _Last)));
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_4i(_First, _Last)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_4u(_First, _Last)));
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+#if _VECTORIZED_MINMAX_ELEMENT_64BIT_INT
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_8i(_First, _Last)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_min_element_8u(_First, _Last)));
+        }
+#else // ^^^ _VECTORIZED_MINMAX_ELEMENT_64BIT_INT / !_VECTORIZED_MINMAX_ELEMENT_64BIT_INT vvv
+        static_assert(false, "unexpected size");
+#endif // ^^^ !_VECTORIZED_MINMAX_ELEMENT_64BIT_INT ^^^
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+
+template <class _Ty>
+_Ty* _Max_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_f_(_First, _Last)));
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_d_(_First, _Last)));
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_1i(_First, _Last)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_1u(_First, _Last)));
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_2i(_First, _Last)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_2u(_First, _Last)));
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_4i(_First, _Last)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_4u(_First, _Last)));
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+#if _VECTORIZED_MINMAX_ELEMENT_64BIT_INT
+        if constexpr (_Signed) {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_8i(_First, _Last)));
+        } else {
+            return const_cast<_Ty*>(static_cast<const _Ty*>(::__std_max_element_8u(_First, _Last)));
+        }
+#else // ^^^ _VECTORIZED_MINMAX_ELEMENT_64BIT_INT / !_VECTORIZED_MINMAX_ELEMENT_64BIT_INT vvv
+        static_assert(false, "unexpected size");
+#endif // ^^^ !_VECTORIZED_MINMAX_ELEMENT_64BIT_INT ^^^
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+#if _VECTORIZED_MINMAX
+template <class _Ty>
+auto _Min_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_pointer_v<_Ty>) {
+#ifdef _WIN64
+        return reinterpret_cast<void*>(::__std_min_8u(_First, _Last));
+#else
+        return reinterpret_cast<void*>(::__std_min_4u(_First, _Last));
+#endif
+    } else if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return ::__std_min_f(_First, _Last);
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return ::__std_min_d(_First, _Last);
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return ::__std_min_1i(_First, _Last);
+        } else {
+            return ::__std_min_1u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return ::__std_min_2i(_First, _Last);
+        } else {
+            return ::__std_min_2u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return ::__std_min_4i(_First, _Last);
+        } else {
+            return ::__std_min_4u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+        if constexpr (_Signed) {
+            return ::__std_min_8i(_First, _Last);
+        } else {
+            return ::__std_min_8u(_First, _Last);
+        }
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+
+template <class _Ty>
+auto _Max_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
+    constexpr bool _Signed = is_signed_v<_Ty>;
+
+    if constexpr (is_pointer_v<_Ty>) {
+#ifdef _WIN64
+        return reinterpret_cast<void*>(::__std_max_8u(_First, _Last));
+#else
+        return reinterpret_cast<void*>(::__std_max_4u(_First, _Last));
+#endif
+    } else if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
+        return ::__std_max_f(_First, _Last);
+    } else if constexpr (_Is_any_of_v<remove_const_t<_Ty>, double, long double>) {
+        return ::__std_max_d(_First, _Last);
+    } else if constexpr (sizeof(_Ty) == 1) {
+        if constexpr (_Signed) {
+            return ::__std_max_1i(_First, _Last);
+        } else {
+            return ::__std_max_1u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 2) {
+        if constexpr (_Signed) {
+            return ::__std_max_2i(_First, _Last);
+        } else {
+            return ::__std_max_2u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 4) {
+        if constexpr (_Signed) {
+            return ::__std_max_4i(_First, _Last);
+        } else {
+            return ::__std_max_4u(_First, _Last);
+        }
+    } else if constexpr (sizeof(_Ty) == 8) {
+        if constexpr (_Signed) {
+            return ::__std_max_8i(_First, _Last);
+        } else {
+            return ::__std_max_8u(_First, _Last);
+        }
+    } else {
+        static_assert(false, "unexpected size");
+    }
+}
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+
+#if _VECTORIZED_MISMATCH
+template <size_t _Element_size>
+size_t _Mismatch_vectorized(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    if constexpr (_Element_size % 8 == 0) {
+        return __std_mismatch_8(_First1, _First2, _Count * (_Element_size / 8)) / (_Element_size / 8);
+    } else if constexpr (_Element_size % 4 == 0) {
+        return __std_mismatch_4(_First1, _First2, _Count * (_Element_size / 4)) / (_Element_size / 4);
+    } else if constexpr (_Element_size % 2 == 0) {
+        return __std_mismatch_2(_First1, _First2, _Count * (_Element_size / 2)) / (_Element_size / 2);
+    } else {
+        return __std_mismatch_1(_First1, _First2, _Count * _Element_size) / _Element_size;
+    }
+}
+#endif // ^^^ _VECTORIZED_MISMATCH ^^^
+
+template <class _Ty>
+struct _Get_first_parameter;
+
+template <template <class, class...> class _Ty, class _First, class... _Rest>
+struct _Get_first_parameter<_Ty<_First, _Rest...>> { // given _Ty<_First, _Rest...>, extract _First
+    using type = _First;
+};
+
+template <class _Newfirst, class _Ty>
+struct _Replace_first_parameter;
+
+template <class _Newfirst, template <class, class...> class _Ty, class _First, class... _Rest>
+struct _Replace_first_parameter<_Newfirst, _Ty<_First, _Rest...>> { // given _Ty<_First, _Rest...>, replace _First
+    using type = _Ty<_Newfirst, _Rest...>;
+};
+
+template <class _Ty, class = void>
+struct _Get_ptr_difference_type {
+    using type = ptrdiff_t;
+};
+
+template <class _Ty>
+struct _Get_ptr_difference_type<_Ty, void_t<typename _Ty::difference_type>> {
+    using type = typename _Ty::difference_type;
+};
+
+template <class _Ty, class _Other, class = void>
+struct _Get_rebind_alias {
+    using type = typename _Replace_first_parameter<_Other, _Ty>::type;
+};
+
+template <class _Ty, class _Other>
+struct _Get_rebind_alias<_Ty, _Other, void_t<typename _Ty::template rebind<_Other>>> {
+    using type = typename _Ty::template rebind<_Other>;
+};
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Ty, class... _Types>
+    requires (!is_unbounded_array_v<_Ty>) && requires(_Ty* _Location, _Types&&... _Args) {
+        ::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...); // per LWG-3888
+    }
+constexpr _Ty* construct_at(_Ty* const _Location, _Types&&... _Args)
+    noexcept(noexcept(::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...))) /* strengthened */ {
+    if constexpr (is_array_v<_Ty>) {
+        static_assert(sizeof...(_Types) == 0, "The array is only allowed to be value-initialized by std::construct_at. "
+                                              "(N5032 [specialized.construct]/2)");
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-117294, DevCom-10798145
+        ::new (static_cast<void*>(_Location)) _Ty();
+        return __builtin_launder(_Location); // per old resolution of LWG-3436
+#else // ^^^ workaround / no workaround vvv
+        _MSVC_CONSTEXPR return ::new (static_cast<void*>(_Location)) _Ty[1]();
+#endif // ^^^ no workaround ^^^
+    } else {
+        _MSVC_CONSTEXPR return ::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...);
+    }
+}
+#endif // _HAS_CXX20
+
+template <class _Ty, class... _Types>
+_CONSTEXPR20 void _Construct_in_place(_Ty& _Obj, _Types&&... _Args)
+    noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
+#if _HAS_CXX20
+    if (_STD is_constant_evaluated()) {
+        _STD construct_at(_STD addressof(_Obj), _STD forward<_Types>(_Args)...);
+    } else
+#endif // _HAS_CXX20
+    {
+        ::new (static_cast<void*>(_STD addressof(_Obj))) _Ty(_STD forward<_Types>(_Args)...);
+    }
+}
+
+template <class _Ty>
+void _Default_construct_in_place(_Ty& _Obj) noexcept(is_nothrow_default_constructible_v<_Ty>) {
+    ::new (static_cast<void*>(_STD addressof(_Obj))) _Ty;
+}
+
+template <class _Ty, class _Elem>
+struct _Ptr_traits_base {
+    using pointer         = _Ty;
+    using element_type    = _Elem;
+    using difference_type = typename _Get_ptr_difference_type<_Ty>::type;
+
+    template <class _Other>
+    using rebind = typename _Get_rebind_alias<_Ty, _Other>::type;
+
+    using _Reftype = conditional_t<is_void_v<_Elem>, char, _Elem>&;
+
+    _NODISCARD static _CONSTEXPR20 pointer pointer_to(_Reftype _Val)
+        noexcept(noexcept(_Ty::pointer_to(_Val))) /* strengthened */ {
+        return _Ty::pointer_to(_Val);
+    }
+};
+
+template <class, class = void, class = void>
+struct _Ptr_traits_sfinae_layer {};
+
+template <class _Ty, class _Uty>
+struct _Ptr_traits_sfinae_layer<_Ty, _Uty, void_t<typename _Get_first_parameter<_Ty>::type>>
+    : _Ptr_traits_base<_Ty, typename _Get_first_parameter<_Ty>::type> {};
+
+template <class _Ty>
+struct _Ptr_traits_sfinae_layer<_Ty, void_t<typename _Ty::element_type>, void>
+    : _Ptr_traits_base<_Ty, typename _Ty::element_type> {};
+
+_EXPORT_STD template <class _Ty>
+struct pointer_traits : _Ptr_traits_sfinae_layer<_Ty> {};
+
+template <class _Ty>
+struct pointer_traits<_Ty*> {
+    using pointer         = _Ty*;
+    using element_type    = _Ty;
+    using difference_type = ptrdiff_t;
+
+    template <class _Other>
+    using rebind = _Other*;
+
+    using _Reftype = conditional_t<is_void_v<_Ty>, char, _Ty>&;
+
+    _NODISCARD static _CONSTEXPR20 pointer pointer_to(_Reftype _Val) noexcept {
+        return _STD addressof(_Val);
+    }
+};
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Has_to_address = requires(const _Ty& _Val) {
+    typename pointer_traits<_Ty>;
+    pointer_traits<_Ty>::to_address(_Val);
+};
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty* to_address(_Ty* const _Val) noexcept {
+    static_assert(!is_function_v<_Ty>, "N4950 [pointer.conversion]/1: Mandates: T is not a function type.");
+    return _Val;
+}
+
+_EXPORT_STD template <class _Ptr>
+_NODISCARD constexpr auto to_address(const _Ptr& _Val) noexcept {
+    if constexpr (_Has_to_address<_Ptr>) {
+        return pointer_traits<_Ptr>::to_address(_Val);
+    } else {
+        return _STD to_address(_Val.operator->()); // plain pointer overload must come first
+    }
+}
+
+_EXPORT_STD struct identity {
+    template <class _Ty>
+    _NODISCARD constexpr _Ty&& operator()(_Ty&& _Left) const noexcept {
+        return _STD forward<_Ty>(_Left);
+    }
+
+    using is_transparent = int;
+};
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Ty = void>
+struct plus {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left + _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct minus {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left - _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct multiplies {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = _Ty;
+
+    _NODISCARD constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
+        return _Left * _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct equal_to {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left == _Right))) /* strengthened */ {
+        return _Left == _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct not_equal_to {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left != _Right))) /* strengthened */ {
+        return _Left != _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct greater {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left > _Right))) /* strengthened */ {
+        return _Left > _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct greater_equal {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left >= _Right))) /* strengthened */ {
+        return _Left >= _Right;
+    }
+};
+
+_EXPORT_STD template <class _Ty = void>
+struct less_equal {
+    using _FIRST_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS  = _Ty;
+    using _SECOND_ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = _Ty;
+    using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS          = bool;
+
+    _NODISCARD constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left <= _Right))) /* strengthened */ {
+        return _Left <= _Right;
+    }
+};
+
+template <>
+struct plus<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct minus<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct multiplies<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct equal_to<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct not_equal_to<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct greater<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct greater_equal<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <>
+struct less_equal<void> {
+    template <class _Ty1, class _Ty2>
+    _NODISCARD constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
+        noexcept(noexcept(static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right))) // strengthened
+        -> decltype(static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right)) {
+        return static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right);
+    }
+
+    using is_transparent = int;
+};
+
+template <class _Fx>
+struct _Ref_fn { // pass function object by value as a reference
+    // _Ref_fn is an aggregate so it can be enregistered, unlike reference_wrapper
+
+    template <class... _Args>
+    constexpr decltype(auto) operator()(_Args&&... _Vals) noexcept(
+        _Select_invoke_traits<_Fx&, _Args...>::_Is_nothrow_invocable::value) { // forward function call operator
+        if constexpr (is_member_pointer_v<_Fx>) {
+            return _STD invoke(_Fn, _STD forward<_Args>(_Vals)...);
+        } else {
+            return _Fn(_STD forward<_Args>(_Vals)...);
+        }
+    }
+
+    _Fx& _Fn;
+};
+
+template <class _Fn>
+_NODISCARD constexpr auto _Pass_fn(_Fn& _Func) noexcept {
+    constexpr bool _Pass_by_value = conjunction_v<bool_constant<sizeof(_Fn) <= sizeof(void*)>,
+        is_trivially_copy_constructible<_Fn>, is_trivially_destructible<_Fn>>;
+    if constexpr (_Pass_by_value) {
+        return _Func;
+    } else {
+        return _Ref_fn<_Fn>{_Func}; // pass functor by "reference"
+    }
+}
+
+#if _HAS_CXX23
+_EXPORT_STD template <class _Result_type, class _Callable, class... _Types>
+    requires is_invocable_r_v<_Result_type, _Callable, _Types...>
+_NODISCARD constexpr _Result_type invoke_r(_Callable&& _Obj, _Types&&... _Args)
+    noexcept(is_nothrow_invocable_r_v<_Result_type, _Callable, _Types...>) {
+    if constexpr (is_void_v<_Result_type>) {
+        (void) _STD invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
+    } else {
+        return _STD invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
+    }
+}
+#endif // _HAS_CXX23
+
+struct _Unused_parameter { // generic unused parameter struct
+    constexpr _Unused_parameter() noexcept = default;
+    template <class _Ty>
+    constexpr _Unused_parameter(_Ty&&) noexcept {}
+};
+
+template <class _Ty>
+using _Algorithm_int_t = conditional_t<is_integral_v<_Ty>, _Ty, ptrdiff_t>;
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Destructible_object = is_object_v<_Ty> && destructible<_Ty>;
+
+namespace ranges {
+    namespace _Iter_move {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void iter_move() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void iter_move();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty&& __t) {
+            iter_move(static_cast<_Ty&&>(__t)); // intentional ADL
+        };
+
+        template <class _Ty>
+        concept _Can_deref = requires(_Ty&& __t) { *static_cast<_Ty&&>(__t); };
+
+        struct _Must_have_ADL_found_iter_move_or_be_dereferenceable {};
+
+        class _Cpo {
+        private:
+            template <class _Ty>
+            _NODISCARD static auto _Choose_return_type() {
+                if constexpr (_Has_ADL<_Ty>) {
+                    return type_identity<decltype(iter_move(_STD declval<_Ty>()))>{}; // intentional ADL
+                } else if constexpr (_Can_deref<_Ty>) {
+                    using _Ref = decltype(*_STD declval<_Ty>());
+                    if constexpr (is_lvalue_reference_v<_Ref>) {
+                        return type_identity<remove_reference_t<_Ref>&&>{};
+                    } else {
+                        return type_identity<_Ref>{};
+                    }
+                } else {
+                    return _Must_have_ADL_found_iter_move_or_be_dereferenceable{};
+                }
+            }
+
+            template <class _Ty>
+            using _Return_type = decltype(_Choose_return_type<_Ty>())::type;
+
+            enum class _St { _None, _Custom, _Fallback };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                if constexpr (_Has_ADL<_Ty>) {
+                    return {_St::_Custom, noexcept(iter_move(_STD declval<_Ty>()))}; // intentional ADL
+                } else if constexpr (_Can_deref<_Ty>) {
+                    return {_St::_Fallback, noexcept(*_STD declval<_Ty>())};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <class _Ty>
+            _NODISCARD static constexpr _Return_type<_Ty> operator()(_Ty&& _Val) noexcept(_Choice<_Ty>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty>._Strategy;
+
+                if constexpr (_Strat == _St::_Custom) {
+                    return iter_move(static_cast<_Ty&&>(_Val)); // intentional ADL
+                } else if constexpr (_Strat == _St::_Fallback) {
+                    using _Ref = decltype(*static_cast<_Ty&&>(_Val));
+                    if constexpr (is_lvalue_reference_v<_Ref>) {
+                        return _STD move(*static_cast<_Ty&&>(_Val));
+                    } else {
+                        return *static_cast<_Ty&&>(_Val);
+                    }
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Iter_move
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Iter_move::_Cpo iter_move;
+    }
+} // namespace ranges
+
+// iter_swap defined below since it depends on indirectly_movable_storable
+
+_EXPORT_STD template <class _Ty>
+    requires _Dereferenceable<_Ty> && requires(_Ty& __t) {
+        { _RANGES iter_move(__t) } -> _Can_reference;
+    }
+using iter_rvalue_reference_t = decltype(_RANGES iter_move(_STD declval<_Ty&>()));
+
+template <class _It>
+concept _Indirectly_readable_impl =
+    requires(const _It __i) {
+        typename iter_value_t<_It>;
+        typename iter_reference_t<_It>;
+        typename iter_rvalue_reference_t<_It>;
+        { *__i } -> same_as<iter_reference_t<_It>>;
+        { _RANGES iter_move(__i) } -> same_as<iter_rvalue_reference_t<_It>>;
+    } && common_reference_with<iter_reference_t<_It>&&, iter_value_t<_It>&>
+    && common_reference_with<iter_reference_t<_It>&&, iter_rvalue_reference_t<_It>&&>
+    && common_reference_with<iter_rvalue_reference_t<_It>&&, const iter_value_t<_It>&>;
+
+_EXPORT_STD template <class _It>
+concept indirectly_readable = _Indirectly_readable_impl<remove_cvref_t<_It>>;
+
+template <class _Ty>
+struct _Indirect_value_impl {
+    using type = iter_value_t<_Ty>&;
+};
+
+template <indirectly_readable _It>
+using _Indirect_value_t = _Indirect_value_impl<_It>::type;
+
+_EXPORT_STD template <indirectly_readable _Ty>
+using iter_common_reference_t = common_reference_t<iter_reference_t<_Ty>, _Indirect_value_t<_Ty>>;
+
+_EXPORT_STD template <class _It, class _Ty>
+concept indirectly_writable = requires(_It&& __i, _Ty&& __t) {
+    *__i                                                                = static_cast<_Ty&&>(__t);
+    *static_cast<_It&&>(__i)                                            = static_cast<_Ty&&>(__t);
+    const_cast<const iter_reference_t<_It>&&>(*__i)                     = static_cast<_Ty&&>(__t);
+    const_cast<const iter_reference_t<_It>&&>(*static_cast<_It&&>(__i)) = static_cast<_Ty&&>(__t);
+};
+
+template <bool _Is_integer_class>
+struct _Make_unsigned_like_impl {
+    template <class _Ty>
+    using _Apply = _Ty::_Unsigned_type;
+};
+template <>
+struct _Make_unsigned_like_impl<false> {
+    template <class _Ty>
+    using _Apply = make_unsigned_t<_Ty>;
+};
+
+template <class _Ty>
+using _Make_unsigned_like_t = _Make_unsigned_like_impl<_Integer_class<_Ty>>::template _Apply<_Ty>;
+
+template <_Integer_like _Ty>
+_NODISCARD constexpr auto _To_unsigned_like(const _Ty _Value) noexcept {
+    return static_cast<_Make_unsigned_like_t<_Ty>>(_Value);
+}
+
+template <bool _Is_integer_class>
+struct _Make_signed_like_impl {
+    template <class _Ty>
+    using _Apply = _Ty::_Signed_type;
+};
+template <>
+struct _Make_signed_like_impl<false> {
+    template <class _Ty>
+    using _Apply = make_signed_t<_Ty>;
+};
+
+template <class _Ty>
+using _Make_signed_like_t = _Make_signed_like_impl<_Integer_class<_Ty>>::template _Apply<_Ty>;
+
+_EXPORT_STD template <class _Ty>
+concept incrementable = regular<_Ty> && weakly_incrementable<_Ty> && requires(_Ty __t) {
+    { __t++ } -> same_as<_Ty>;
+};
+
+template <bool _Iterator_category_present>
+struct _Iter_concept_impl2 {
+    template <class _It, class _Traits>
+    using _Apply = _Traits::iterator_category;
+};
+template <>
+struct _Iter_concept_impl2<false> {
+    template <class _It, class _Traits>
+        requires _Is_from_primary<iterator_traits<_It>>
+    using _Apply = random_access_iterator_tag;
+};
+
+template <bool _Iterator_concept_present>
+struct _Iter_concept_impl1 {
+    template <class _It, class _Traits>
+    using _Apply = _Traits::iterator_concept;
+};
+template <>
+struct _Iter_concept_impl1<false> {
+    template <class _It, class _Traits>
+    using _Apply = _Iter_concept_impl2<_Has_member_iterator_category<_Traits>>::template _Apply<_It, _Traits>;
+};
+
+template <class _It, class _Traits = conditional_t<_Is_from_primary<iterator_traits<_It>>, _It, iterator_traits<_It>>>
+using _Iter_concept = _Iter_concept_impl1<_Has_member_iterator_concept<_Traits>>::template _Apply<_It, _Traits>;
+
+_EXPORT_STD template <class _It>
+concept input_iterator = input_or_output_iterator<_It> && indirectly_readable<_It> && requires {
+    typename _Iter_concept<_It>;
+} && derived_from<_Iter_concept<_It>, input_iterator_tag>;
+
+_EXPORT_STD template <class _It, class _Ty>
+concept output_iterator = input_or_output_iterator<_It> && indirectly_writable<_It, _Ty>
+                       && requires(_It __i, _Ty&& __t) { *__i++ = static_cast<_Ty&&>(__t); };
+
+_EXPORT_STD template <class _It>
+concept forward_iterator = input_iterator<_It> && derived_from<_Iter_concept<_It>, forward_iterator_tag>
+                        && incrementable<_It> && sentinel_for<_It, _It>;
+
+_EXPORT_STD template <class _It>
+concept bidirectional_iterator =
+    forward_iterator<_It> && derived_from<_Iter_concept<_It>, bidirectional_iterator_tag> && requires(_It __i) {
+        { --__i } -> same_as<_It&>;
+        { __i-- } -> same_as<_It>;
+    };
+
+_EXPORT_STD template <class _It>
+concept random_access_iterator =
+    bidirectional_iterator<_It> && derived_from<_Iter_concept<_It>, random_access_iterator_tag> && totally_ordered<_It>
+    && sized_sentinel_for<_It, _It> && requires(_It __i, const _It __j, const iter_difference_t<_It> __n) {
+           { __i += __n } -> same_as<_It&>;
+           { __j + __n } -> same_as<_It>;
+           { __n + __j } -> same_as<_It>;
+           { __i -= __n } -> same_as<_It&>;
+           { __j - __n } -> same_as<_It>;
+           { __j[__n] } -> same_as<iter_reference_t<_It>>;
+       };
+
+_EXPORT_STD template <class _It>
+concept contiguous_iterator =
+    random_access_iterator<_It> && derived_from<_Iter_concept<_It>, contiguous_iterator_tag>
+    && is_lvalue_reference_v<iter_reference_t<_It>> && same_as<iter_value_t<_It>, remove_cvref_t<iter_reference_t<_It>>>
+    && requires(const _It& __i) {
+           { _STD to_address(__i) } -> same_as<add_pointer_t<iter_reference_t<_It>>>;
+       };
+
+_EXPORT_STD template <class _Fn, class _It>
+concept indirectly_unary_invocable = indirectly_readable<_It> && copy_constructible<_Fn>
+                                  && invocable<_Fn&, _Indirect_value_t<_It>> && invocable<_Fn&, iter_reference_t<_It>>
+                                  && common_reference_with<invoke_result_t<_Fn&, _Indirect_value_t<_It>>,
+                                      invoke_result_t<_Fn&, iter_reference_t<_It>>>;
+
+_EXPORT_STD template <class _Fn, class _It>
+concept indirectly_regular_unary_invocable =
+    indirectly_readable<_It> && copy_constructible<_Fn> && regular_invocable<_Fn&, _Indirect_value_t<_It>>
+    && regular_invocable<_Fn&, iter_reference_t<_It>>
+    && common_reference_with<invoke_result_t<_Fn&, _Indirect_value_t<_It>>,
+        invoke_result_t<_Fn&, iter_reference_t<_It>>>;
+
+_EXPORT_STD template <class _Fn, class _It>
+concept indirect_unary_predicate = indirectly_readable<_It> && copy_constructible<_Fn>
+                                && predicate<_Fn&, _Indirect_value_t<_It>> && predicate<_Fn&, iter_reference_t<_It>>;
+
+_EXPORT_STD template <class _Fn, class _It1, class _It2>
+concept indirect_binary_predicate = indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fn>
+                                 && predicate<_Fn&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
+                                 && predicate<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
+                                 && predicate<_Fn&, iter_reference_t<_It1>, _Indirect_value_t<_It2>>
+                                 && predicate<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
+
+_EXPORT_STD template <class _Fn, class _It1, class _It2 = _It1>
+concept indirect_equivalence_relation =
+    indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fn>
+    && equivalence_relation<_Fn&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
+    && equivalence_relation<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
+    && equivalence_relation<_Fn&, iter_reference_t<_It1>, _Indirect_value_t<_It2>>
+    && equivalence_relation<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
+
+_EXPORT_STD template <class _Fn, class _It1, class _It2 = _It1>
+concept indirect_strict_weak_order = indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fn>
+                                  && strict_weak_order<_Fn&, _Indirect_value_t<_It1>, _Indirect_value_t<_It2>>
+                                  && strict_weak_order<_Fn&, _Indirect_value_t<_It1>, iter_reference_t<_It2>>
+                                  && strict_weak_order<_Fn&, iter_reference_t<_It1>, _Indirect_value_t<_It2>>
+                                  && strict_weak_order<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
+
+_EXPORT_STD template <class _Fn, class... _Its>
+    requires (indirectly_readable<_Its> && ...) && invocable<_Fn, iter_reference_t<_Its>...>
+using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Its>...>;
+
+template <class _It>
+struct _Projected_difference_type_impl {
+    struct _Base {};
+};
+
+template <weakly_incrementable _It>
+struct _Projected_difference_type_impl<_It> {
+    struct _Base {
+        using difference_type = iter_difference_t<_It>;
+    };
+};
+
+template <class _It, class _Proj>
+struct _Projected_impl {
+    struct _Type : _Projected_difference_type_impl<_It>::_Base {
+        using _Iterator   = _It;
+        using _Projection = _Proj;
+
+        using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>;
+        [[noreturn]] indirect_result_t<_Proj&, _It> operator*() const {
+            static_assert(
+                false, "std::projected::operator*() can't be instantiated (N5008 [projected] as modified by LWG-4270)");
+        }
+    };
+};
+
+_EXPORT_STD template <indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
+using projected = _Projected_impl<_It, _Proj>::_Type;
+
+template <class _Ty>
+concept _Projected_specialization = same_as<_Ty, projected<typename _Ty::_Iterator, typename _Ty::_Projection>>;
+
+template <_Projected_specialization _ProjTy>
+struct _Indirect_value_impl<_ProjTy> {
+    using type = invoke_result_t<typename _ProjTy::_Projection&, _Indirect_value_t<typename _ProjTy::_Iterator>>;
+};
+
+_EXPORT_STD template <class _In, class _Out>
+concept indirectly_movable = indirectly_readable<_In> && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
+
+_EXPORT_STD template <class _In, class _Out>
+concept indirectly_movable_storable =
+    indirectly_movable<_In, _Out> && indirectly_writable<_Out, iter_value_t<_In>> && movable<iter_value_t<_In>>
+    && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>>
+    && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
+
+_EXPORT_STD template <class _In, class _Out>
+concept indirectly_copyable = indirectly_readable<_In> && indirectly_writable<_Out, iter_reference_t<_In>>;
+
+_EXPORT_STD template <class _In, class _Out>
+concept indirectly_copyable_storable =
+    indirectly_copyable<_In, _Out> && indirectly_writable<_Out, iter_value_t<_In>&>
+    && indirectly_writable<_Out, const iter_value_t<_In>&> && indirectly_writable<_Out, iter_value_t<_In>&&>
+    && indirectly_writable<_Out, const iter_value_t<_In>&&> && copyable<iter_value_t<_In>>
+    && constructible_from<iter_value_t<_In>, iter_reference_t<_In>>
+    && assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
+
+namespace ranges {
+    namespace _Iter_swap {
+        template <class _Ty1, class _Ty2>
+        void iter_swap(_Ty1, _Ty2) = delete;
+
+        template <class _Ty1, class _Ty2>
+        concept _Has_ADL =
+            (_Has_class_or_enum_type<_Ty1> || _Has_class_or_enum_type<_Ty2>) && requires(_Ty1&& __t1, _Ty2&& __t2) {
+                iter_swap(static_cast<_Ty1&&>(__t1), static_cast<_Ty2&&>(__t2)); // intentional ADL
+            };
+
+        template <class _Ty1, class _Ty2>
+        concept _Can_swap_references =
+            indirectly_readable<remove_reference_t<_Ty1>> && indirectly_readable<remove_reference_t<_Ty2>>
+            && swappable_with<iter_reference_t<_Ty1>, iter_reference_t<_Ty2>>;
+
+        template <class _Ty1, class _Ty2>
+        concept _Symmetric_indirectly_movable_storable =
+            indirectly_movable_storable<remove_reference_t<_Ty1>, remove_reference_t<_Ty2>>
+            && indirectly_movable_storable<remove_reference_t<_Ty2>, remove_reference_t<_Ty1>>;
+
+        template <class _Xty, class _Yty>
+        _NODISCARD constexpr iter_value_t<remove_reference_t<_Xty>> _Iter_exchange_move(_Xty&& _XVal, _Yty&& _YVal)
+            noexcept(noexcept(iter_value_t<remove_reference_t<_Xty>>(_RANGES iter_move(_XVal)))) {
+            iter_value_t<remove_reference_t<_Xty>> _Tmp(_RANGES iter_move(_XVal));
+            *_XVal = _RANGES iter_move(_YVal);
+            return _Tmp;
+        }
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Custom, _Swap, _Exchange };
+
+            template <class _Ty1, class _Ty2>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                if constexpr (_Has_ADL<_Ty1, _Ty2>) {
+                    return {_St::_Custom,
+                        noexcept(iter_swap(_STD declval<_Ty1>(), _STD declval<_Ty2>()))}; // intentional ADL
+                } else if constexpr (_Can_swap_references<_Ty1, _Ty2>) {
+                    return {_St::_Swap, noexcept(_RANGES swap(*_STD declval<_Ty1>(), *_STD declval<_Ty2>()))};
+                } else if constexpr (_Symmetric_indirectly_movable_storable<_Ty1, _Ty2>) {
+                    constexpr auto _Nothrow = noexcept(*_STD declval<_Ty1>() = _Iter_swap::_Iter_exchange_move(
+                                                           _STD declval<_Ty2>(), _STD declval<_Ty1>()));
+                    return {_St::_Exchange, _Nothrow};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty1, class _Ty2>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();
+
+        public:
+            template <class _Ty1, class _Ty2>
+                requires (_Choice<_Ty1, _Ty2>._Strategy != _St::_None)
+            static constexpr void operator()(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(_Choice<_Ty1, _Ty2>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty1, _Ty2>._Strategy;
+
+                if constexpr (_Strat == _St::_Custom) {
+                    (void) iter_swap(static_cast<_Ty1&&>(_Val1), static_cast<_Ty2&&>(_Val2)); // intentional ADL
+                } else if constexpr (_Strat == _St::_Swap) {
+                    _RANGES swap(*static_cast<_Ty1&&>(_Val1), *static_cast<_Ty2&&>(_Val2));
+                } else if constexpr (_Strat == _St::_Exchange) {
+                    *static_cast<_Ty1&&>(_Val1) =
+                        _Iter_swap::_Iter_exchange_move(static_cast<_Ty2&&>(_Val2), static_cast<_Ty1&&>(_Val1));
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Iter_swap
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Iter_swap::_Cpo iter_swap;
+    }
+} // namespace ranges
+
+_EXPORT_STD template <class _It1, class _It2 = _It1>
+concept indirectly_swappable =
+    indirectly_readable<_It1> && indirectly_readable<_It2> && requires(const _It1 __i1, const _It2 __i2) {
+        _RANGES iter_swap(__i1, __i1);
+        _RANGES iter_swap(__i2, __i2);
+        _RANGES iter_swap(__i1, __i2);
+        _RANGES iter_swap(__i2, __i1);
+    };
+
+_EXPORT_STD template <class _It1, class _It2, class _Rel, class _Proj1 = identity, class _Proj2 = identity>
+concept indirectly_comparable = indirect_binary_predicate<_Rel, projected<_It1, _Proj1>, projected<_It2, _Proj2>>;
+
+_EXPORT_STD template <class _It>
+concept permutable = forward_iterator<_It> && indirectly_movable_storable<_It, _It> && indirectly_swappable<_It, _It>;
+
+namespace ranges {
+    _EXPORT_STD struct less;
+} // namespace ranges
+
+_EXPORT_STD template <class _It1, class _It2, class _Out, class _Pr = ranges::less, class _Pj1 = identity,
+    class _Pj2 = identity>
+concept mergeable =
+    input_iterator<_It1> && input_iterator<_It2> && weakly_incrementable<_Out> && indirectly_copyable<_It1, _Out>
+    && indirectly_copyable<_It2, _Out> && indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>;
+
+_EXPORT_STD template <class _It, class _Pr = ranges::less, class _Proj = identity>
+concept sortable = permutable<_It> && indirect_strict_weak_order<_Pr, projected<_It, _Proj>>;
+
+template <class _Iter>
+using _Iter_ref_t = iter_reference_t<_Iter>;
+
+template <class _Iter>
+using _Iter_value_t = iter_value_t<_Iter>;
+
+template <class _Iter>
+using _Iter_diff_t = iter_difference_t<_Iter>;
+
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Iter>
+using _Iter_ref_t = typename iterator_traits<_Iter>::reference;
+
+template <class _Iter>
+using _Iter_value_t = typename iterator_traits<_Iter>::value_type;
+
+template <class _Iter>
+using _Iter_diff_t = typename iterator_traits<_Iter>::difference_type;
+
+template <class _Ty>
+using _Make_unsigned_like_t = make_unsigned_t<_Ty>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class... _Iters>
+using _Common_diff_t = common_type_t<_Iter_diff_t<_Iters>...>;
+
+template <class _Iter>
+using _Iter_cat_t = typename iterator_traits<_Iter>::iterator_category;
+
+#if _HAS_CXX20
+template <class _Ty>
+concept _Iterator_for_container = requires { typename _Iter_cat_t<_Ty>; };
+
+template <class _Ty>
+constexpr bool _Is_iterator_v = _Iterator_for_container<_Ty>;
+
+template <class _Ty>
+struct _Is_iterator : bool_constant<_Iterator_for_container<_Ty>> {};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class = void>
+constexpr bool _Is_iterator_v = false;
+
+template <class _Ty>
+constexpr bool _Is_iterator_v<_Ty, void_t<_Iter_cat_t<_Ty>>> = true;
+
+template <class _Ty>
+struct _Is_iterator : bool_constant<_Is_iterator_v<_Ty>> {};
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Iter>
+constexpr bool _Is_cpp17_input_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, input_iterator_tag>;
+
+template <class _Iter>
+constexpr bool _Is_ranges_input_iter_v =
+#if _HAS_CXX20
+    (input_iterator<_Iter> && sentinel_for<_Iter, _Iter>) ||
+#endif
+    _Is_cpp17_input_iter_v<_Iter>;
+
+template <class _Iter>
+constexpr bool _Is_cpp17_fwd_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, forward_iterator_tag>;
+
+template <class _Iter>
+constexpr bool _Is_ranges_fwd_iter_v =
+#if _HAS_CXX20
+    forward_iterator<_Iter> ||
+#endif
+    _Is_cpp17_fwd_iter_v<_Iter>;
+
+template <class _Iter>
+constexpr bool _Is_cpp17_bidi_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, bidirectional_iterator_tag>;
+
+template <class _Iter>
+constexpr bool _Is_ranges_bidi_iter_v =
+#if _HAS_CXX20
+    bidirectional_iterator<_Iter> ||
+#endif
+    _Is_cpp17_bidi_iter_v<_Iter>;
+
+template <class _Iter>
+constexpr bool _Is_cpp17_random_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, random_access_iterator_tag>;
+
+template <class _Iter>
+constexpr bool _Is_ranges_random_iter_v =
+#if _HAS_CXX20
+    random_access_iterator<_Iter> ||
+#endif
+    _Is_cpp17_random_iter_v<_Iter>;
+
+#define _REQUIRE_CPP17_MUTABLE_ITERATOR(_Iter) \
+    static_assert(_Is_cpp17_fwd_iter_v<_Iter>, \
+        "Non-ranges algorithms require that mutable iterators be Cpp17ForwardIterators or stronger.")
+
+#define _REQUIRE_CPP17_MUTABLE_BIDIRECTIONAL_ITERATOR(_Iter) \
+    static_assert(_Is_cpp17_bidi_iter_v<_Iter>,              \
+        "This algorithm requires that mutable iterators be Cpp17BidirectionalIterators or stronger.")
+
+template <class, class = void>
+struct _Is_checked_helper {}; // default definition, no longer used, retained due to pseudo-documentation
+
+#if _ITERATOR_DEBUG_LEVEL != 0
+template <class _Ty>
+constexpr void _Verify_range(const _Ty* const _First, const _Ty* const _Last) noexcept {
+    // special case range verification for pointers
+    _STL_VERIFY(_First <= _Last, "transposed pointer range");
+}
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+template <class _Iter, class = void>
+constexpr bool _Allow_inheriting_unwrap_v = true;
+
+template <class _Iter>
+constexpr bool _Allow_inheriting_unwrap_v<_Iter, void_t<typename _Iter::_Prevent_inheriting_unwrap>> =
+    is_same_v<_Iter, typename _Iter::_Prevent_inheriting_unwrap>;
+
+template <class _Iter, class _Sentinel = _Iter, class = void>
+constexpr bool _Range_verifiable_v = false;
+
+template <class _Iter, class _Sentinel>
+constexpr bool _Range_verifiable_v<_Iter, _Sentinel,
+    void_t<decltype(_Verify_range(_STD declval<const _Iter&>(), _STD declval<const _Sentinel&>()))>> =
+    _Allow_inheriting_unwrap_v<_Iter>;
+
+template <class _Iter, class _Sentinel>
+constexpr void _Adl_verify_range(const _Iter& _First, const _Sentinel& _Last) {
+    // check that [_First, _Last) forms an iterator range
+    if constexpr (is_pointer_v<_Iter> && is_pointer_v<_Sentinel>) {
+#if _ITERATOR_DEBUG_LEVEL != 0
+        _STL_VERIFY(_First <= _Last, "transposed pointer range");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+    } else if constexpr (_Range_verifiable_v<_Iter, _Sentinel>) {
+        _Verify_range(_First, _Last);
+    }
+}
+
+template <class _Iter, class = void>
+constexpr bool _Unwrappable_v = false;
+
+template <class _Iter>
+constexpr bool _Unwrappable_v<_Iter,
+    void_t<decltype(_STD declval<_Remove_cvref_t<_Iter>&>()._Seek_to(_STD declval<_Iter>()._Unwrapped()))>> =
+    _Allow_inheriting_unwrap_v<_Remove_cvref_t<_Iter>>;
+
+template <class _Iter, class = void>
+constexpr bool _Has_nothrow_unwrapped = false;
+template <class _Iter>
+constexpr bool _Has_nothrow_unwrapped<_Iter, void_t<decltype(_STD declval<_Iter>()._Unwrapped())>> =
+    noexcept(_STD declval<_Iter>()._Unwrapped());
+
+template <class _Iter>
+_NODISCARD constexpr decltype(auto) _Get_unwrapped(_Iter&& _It)
+    noexcept(!_Unwrappable_v<_Iter> || _Has_nothrow_unwrapped<_Iter>) {
+    // unwrap an iterator previously subjected to _Adl_verify_range or otherwise validated
+    if constexpr (is_pointer_v<decay_t<_Iter>>) { // special-case pointers and arrays
+        return _It + 0;
+    } else if constexpr (_Unwrappable_v<_Iter>) {
+        return static_cast<_Iter&&>(_It)._Unwrapped();
+    } else {
+        return static_cast<_Iter&&>(_It);
+    }
+}
+
+template <class _Iter>
+using _Unwrapped_t = _Remove_cvref_t<decltype(_STD _Get_unwrapped(_STD declval<_Iter>()))>;
+
+template <class _Iter, class = bool>
+constexpr bool _Do_unwrap_when_unverified_v = false;
+
+template <class _Iter>
+constexpr bool _Do_unwrap_when_unverified_v<_Iter, decltype(static_cast<bool>(_Iter::_Unwrap_when_unverified))> =
+    static_cast<bool>(_Iter::_Unwrap_when_unverified);
+
+template <class _Iter>
+constexpr bool _Unwrappable_for_unverified_v =
+    _Unwrappable_v<_Iter> && _Do_unwrap_when_unverified_v<_Remove_cvref_t<_Iter>>;
+
+template <class _Iter>
+_NODISCARD constexpr decltype(auto) _Get_unwrapped_unverified(_Iter&& _It) {
+    // unwrap an iterator not previously subjected to _Adl_verify_range
+    if constexpr (is_pointer_v<decay_t<_Iter>>) { // special-case pointers and arrays
+        return _It + 0;
+    } else if constexpr (_Unwrappable_for_unverified_v<_Iter>) {
+        return static_cast<_Iter&&>(_It)._Unwrapped();
+    } else {
+        return static_cast<_Iter&&>(_It);
+    }
+}
+
+template <class _Iter>
+using _Unwrapped_unverified_t = _Remove_cvref_t<decltype(_Get_unwrapped_unverified(_STD declval<_Iter>()))>;
+
+struct _Distance_unknown {
+    constexpr _Distance_unknown operator-() const noexcept {
+        return {};
+    }
+};
+
+template <class _Diff>
+constexpr _Diff _Max_possible_v{static_cast<_Make_unsigned_like_t<_Diff>>(-1) >> 1};
+
+template <class _Diff>
+constexpr _Diff _Min_possible_v{-_Max_possible_v<_Diff> - 1};
+
+template <class _Iter, class = void>
+constexpr bool _Offset_verifiable_v = false;
+
+template <class _Iter>
+constexpr bool
+    _Offset_verifiable_v<_Iter, void_t<decltype(_STD declval<const _Iter&>()._Verify_offset(_Iter_diff_t<_Iter>{}))>> =
+        true;
+
+template <class _Iter>
+constexpr bool _Unwrappable_for_offset_v = _Unwrappable_v<_Iter> && _Offset_verifiable_v<_Remove_cvref_t<_Iter>>;
+
+template <class _Iter, class _Diff>
+_NODISCARD constexpr decltype(auto) _Get_unwrapped_n(_Iter&& _It, const _Diff _Off) {
+    if constexpr (is_pointer_v<decay_t<_Iter>>) {
+        return _It + 0;
+    } else if constexpr (_Unwrappable_for_offset_v<_Iter> && _Integer_like<_Diff>) {
+        // ask an iterator to assert that the iterator moved _Off positions is valid, and unwrap
+        using _IDiff     = _Iter_diff_t<_Remove_cvref_t<_Iter>>;
+        using _CDiff     = common_type_t<_Diff, _IDiff>;
+        const auto _COff = static_cast<_CDiff>(_Off);
+
+        _STL_ASSERT(_COff <= static_cast<_CDiff>(_Max_possible_v<_IDiff>)
+                        && (is_unsigned_v<_Diff> || static_cast<_CDiff>(_Min_possible_v<_IDiff>) <= _COff),
+            "integer overflow");
+        (void) _COff;
+
+        _It._Verify_offset(static_cast<_IDiff>(_Off));
+        return static_cast<_Iter&&>(_It)._Unwrapped();
+    } else if constexpr (_Unwrappable_for_unverified_v<_Iter>) {
+        // iterator doesn't support offset-based asserts, or offset unknown; defer to unverified unwrap
+        return static_cast<_Iter&&>(_It)._Unwrapped();
+    } else {
+        // pass through iterator that doesn't participate in checking
+        return static_cast<_Iter&&>(_It);
+    }
+}
+
+template <class _Iter, class _UIter, class = void>
+constexpr bool _Wrapped_seekable_v = false;
+
+template <class _Iter, class _UIter>
+constexpr bool
+    _Wrapped_seekable_v<_Iter, _UIter, void_t<decltype(_STD declval<_Iter&>()._Seek_to(_STD declval<_UIter>()))>> =
+        true;
+
+template <class _Iter, class _UIter>
+constexpr void _Seek_wrapped(_Iter& _It, _UIter&& _UIt) {
+    if constexpr (_Wrapped_seekable_v<_Iter, _UIter>) {
+        _It._Seek_to(_STD forward<_UIter>(_UIt));
+    } else {
+        _It = _STD forward<_UIter>(_UIt);
+    }
+}
+
+#if _HAS_CXX17
+#if _HAS_CXX20
+// detects whether _Ty resembles an allocator, N4981 [container.reqmts]/69
+template <class _Ty>
+concept _Allocator_for_container = requires(_Ty& _Alloc) {
+    typename _Ty::value_type;
+    _Alloc.deallocate(_Alloc.allocate(size_t{1}), size_t{1});
+};
+
+template <class _Ty>
+concept _Not_allocator_for_container = !_Allocator_for_container<_Ty>;
+
+template <class _Ty>
+struct _Is_allocator : bool_constant<_Allocator_for_container<_Ty>> {};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class = void>
+struct _Is_allocator : false_type {}; // selected when _Ty can't possibly be an allocator
+
+template <class _Ty>
+struct _Is_allocator<_Ty, void_t<typename _Ty::value_type, decltype(_STD declval<_Ty&>().deallocate(
+                                                               _STD declval<_Ty&>().allocate(size_t{1}), size_t{1}))>>
+    : true_type {}; // selected when _Ty resembles an allocator, N4950 [container.reqmts]/69
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+// deduction guide utilities (N4950 [associative.general]/2)
+template <class _Iter>
+using _Guide_key_t =
+#if _HAS_CXX23
+    remove_const_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    remove_const_t<typename iterator_traits<_Iter>::value_type::first_type>;
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+template <class _Iter>
+using _Guide_val_t =
+#if _HAS_CXX23
+    tuple_element_t<1, typename iterator_traits<_Iter>::value_type>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    typename iterator_traits<_Iter>::value_type::second_type;
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+template <class _Iter>
+using _Guide_pair_t =
+#if _HAS_CXX23
+    pair<add_const_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>,
+        tuple_element_t<1, typename iterator_traits<_Iter>::value_type>>;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    pair<add_const_t<typename iterator_traits<_Iter>::value_type::first_type>,
+        typename iterator_traits<_Iter>::value_type::second_type>;
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+_EXPORT_STD template <class _Ty>
+struct _NO_SPECIALIZATIONS_CITING("N5014 [execpol.type]/3") is_execution_policy : false_type {};
+
+_EXPORT_STD template <class _Ty>
+_NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES constexpr bool is_execution_policy_v = is_execution_policy<_Ty>::value;
+
+// Note: The noexcept specifiers on all parallel algorithm overloads enforce termination as per
+// N4950 [execpol.seq]/2, [execpol.par]/2, [execpol.parunseq]/2, and [execpol.unseq]/2
+template <class _ExPo>
+using _Enable_if_execution_policy_t = typename remove_reference_t<_ExPo>::_Standard_execution_policy;
+
+#define _REQUIRE_PARALLEL_ITERATOR(_Iter) \
+    static_assert(_Is_ranges_fwd_iter_v<_Iter>, "Parallel algorithms require forward iterators or stronger.")
+
+#endif // _HAS_CXX17
+
+template <class _Checked, class _Iter>
+_NODISCARD constexpr auto _Idl_distance(const _Iter& _First, const _Iter& _Last) {
+    // Returns the distance between _First and _Last or
+    // an indicator that the distance cannot be determined in O(1).
+    _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Unwrapped_t<_Checked>, _Iter>);
+    if constexpr (_Is_ranges_random_iter_v<_Iter>) {
+        return static_cast<_Iter_diff_t<_Checked>>(_Last - _First);
+    } else {
+        return _Distance_unknown{};
+    }
+}
+
+template <class _Elem, bool _Is_enum = is_enum_v<_Elem>>
+struct _Unwrap_enum { // if _Elem is an enum, gets its underlying type; otherwise leaves _Elem unchanged
+    using type = underlying_type_t<_Elem>;
+};
+
+template <class _Elem>
+struct _Unwrap_enum<_Elem, false> { // passthrough non-enum type
+    using type = _Elem;
+};
+
+template <class _Elem>
+using _Unwrap_enum_t = typename _Unwrap_enum<_Elem>::type;
+
+#if _ITERATOR_DEBUG_LEVEL < 2
+#define _DEBUG_LT_PRED(pred, x, y) static_cast<bool>(pred(x, y))
+#define _DEBUG_ORDER_UNWRAPPED(first, last, pred)
+#define _DEBUG_ORDER_SET_UNWRAPPED(otherIter, first, last, pred)
+
+#else // ^^^ _ITERATOR_DEBUG_LEVEL < 2 / _ITERATOR_DEBUG_LEVEL == 2 vvv
+#define _DEBUG_LT_PRED(pred, x, y)                _STD _Debug_lt_pred(pred, x, y)
+#define _DEBUG_ORDER_UNWRAPPED(first, last, pred) _STD _Debug_order_unchecked(first, last, pred)
+#define _DEBUG_ORDER_SET_UNWRAPPED(otherIter, first, last, pred) \
+    _STD _Debug_order_set_unchecked<otherIter>(first, last, pred)
+
+template <class _Pr, class _Ty1, class _Ty2>
+constexpr bool _Enable_debug_lt_pred_order_check = is_same_v<_Remove_cvref_t<_Ty1>, _Remove_cvref_t<_Ty2>>;
+
+template <class _Pr, class _Ty1, class _Ty2, bool _Order_check = _Enable_debug_lt_pred_order_check<_Pr, _Ty1, _Ty2>>
+constexpr bool _Debug_lt_pred_order_check_noexcept =
+    noexcept(static_cast<bool>(_STD declval<_Pr&>()(_STD declval<_Ty2&>(), _STD declval<_Ty1&>())));
+
+template <class _Pr, class _Ty1, class _Ty2>
+constexpr bool _Debug_lt_pred_order_check_noexcept<_Pr, _Ty1, _Ty2, false> = true;
+
+template <class _Pr, class _Ty1, class _Ty2>
+_NODISCARD constexpr bool _Debug_lt_pred(_Pr&& _Pred, _Ty1&& _Left, _Ty2&& _Right) noexcept(
+    noexcept(static_cast<bool>(_Pred(_Left, _Right))) && _Debug_lt_pred_order_check_noexcept<_Pr, _Ty1, _Ty2>) {
+    const auto _Result = static_cast<bool>(_Pred(_Left, _Right));
+
+    if constexpr (_Enable_debug_lt_pred_order_check<_Pr, _Ty1, _Ty2>) {
+        if (_Result) {
+            _STL_VERIFY(!static_cast<bool>(_Pred(_Right, _Left)), "invalid comparator");
+        }
+    }
+
+    return _Result;
+}
+
+template <class _InIt, class _Sentinel, class _Pr>
+constexpr void _Debug_order_unchecked(_InIt _First, _Sentinel _Last, _Pr&& _Pred) {
+    // test if range is ordered by predicate
+    if constexpr (_Is_ranges_fwd_iter_v<_InIt>) {
+        if (_First != _Last) {
+            for (auto _Next = _First; ++_Next != _Last; _First = _Next) {
+                _STL_VERIFY(!static_cast<bool>(_Pred(*_Next, *_First)), "sequence not ordered");
+            }
+        }
+    }
+}
+
+template <class _OtherIt, class _InIt, class _Pr>
+constexpr void _Debug_order_set_unchecked(_InIt _First, _InIt _Last, _Pr&& _Pred) {
+    // test if range is ordered by predicate
+    if constexpr (is_same_v<_Iter_value_t<_OtherIt>, _Iter_value_t<_InIt>>) {
+        _STD _Debug_order_unchecked(_First, _Last, _Pred);
+    }
+}
+#endif // ^^^ _ITERATOR_DEBUG_LEVEL == 2 ^^^
+
+// from <iterator>
+_EXPORT_STD template <class _InIt, class _Diff>
+_CONSTEXPR17 void advance(_InIt& _Where, _Diff _Off) { // increment iterator by offset
+    if constexpr (_Is_ranges_random_iter_v<_InIt>) {
+        _Where += _Off;
+    } else {
+        if constexpr (is_signed_v<_Diff> && !_Is_ranges_bidi_iter_v<_InIt>) {
+            _STL_ASSERT(_Off >= 0, "negative advance of non-bidirectional iterator");
+        }
+
+        decltype(auto) _UWhere      = _STD _Get_unwrapped_n(_STD move(_Where), _Off);
+        constexpr bool _Need_rewrap = !is_reference_v<decltype(_STD _Get_unwrapped_n(_STD move(_Where), _Off))>;
+
+        if constexpr (is_signed_v<_Diff> && _Is_ranges_bidi_iter_v<_InIt>) {
+            for (; _Off < 0; ++_Off) {
+                --_UWhere;
+            }
+        }
+
+        for (; 0 < _Off; --_Off) {
+            ++_UWhere;
+        }
+
+        if constexpr (_Need_rewrap) {
+            _STD _Seek_wrapped(_Where, _STD move(_UWhere));
+        }
+    }
+}
+
+_EXPORT_STD template <class _InIt>
+_NODISCARD _CONSTEXPR17 _Iter_diff_t<_InIt> distance(_InIt _First, _InIt _Last) {
+    if constexpr (_Is_ranges_random_iter_v<_InIt>) {
+        return _Last - _First; // assume the iterator will do debug checking
+    } else {
+        _STD _Adl_verify_range(_First, _Last);
+        auto _UFirst             = _STD _Get_unwrapped(_First);
+        const auto _ULast        = _STD _Get_unwrapped(_Last);
+        _Iter_diff_t<_InIt> _Off = 0;
+        for (; _UFirst != _ULast; ++_UFirst) {
+            ++_Off;
+        }
+
+        return _Off;
+    }
+}
+
+template <class _InIt>
+constexpr _InIt _Next_iter(_InIt _First) { // increment iterator
+    return ++_First;
+}
+
+_EXPORT_STD template <class _InIt>
+_NODISCARD _CONSTEXPR17 _InIt next(
+    _InIt _First, typename iterator_traits<_InIt>::difference_type _Off = 1) { // increment iterator
+    static_assert(_Is_ranges_input_iter_v<_InIt>, "next requires input iterator");
+
+    _STD advance(_First, _Off);
+    return _First;
+}
+
+template <class _BidIt>
+constexpr _BidIt _Prev_iter(_BidIt _First) { // decrement iterator
+    return --_First;
+}
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD _CONSTEXPR17 _BidIt prev(
+    _BidIt _First, typename iterator_traits<_BidIt>::difference_type _Off = 1) { // decrement iterator
+    static_assert(_Is_ranges_bidi_iter_v<_BidIt>, "prev requires bidirectional iterator");
+
+    _STD advance(_First, -_Off);
+    return _First;
+}
+
+template <class _Iter, class _Pointer, bool = is_pointer_v<_Remove_cvref_t<_Iter>>>
+constexpr bool _Has_nothrow_operator_arrow = _Is_nothrow_convertible_v<_Iter, _Pointer>;
+
+template <class _Iter, class _Pointer>
+constexpr bool _Has_nothrow_operator_arrow<_Iter, _Pointer, false> =
+    noexcept(_STD _Fake_copy_init<_Pointer>(_STD declval<_Iter>().operator->()));
+
+_EXPORT_STD template <class _BidIt>
+class reverse_iterator {
+public:
+    using iterator_type = _BidIt;
+
+#if _HAS_CXX20
+    using iterator_concept =
+        conditional_t<random_access_iterator<_BidIt>, random_access_iterator_tag, bidirectional_iterator_tag>;
+    using iterator_category = conditional_t<derived_from<_Iter_cat_t<_BidIt>, random_access_iterator_tag>,
+        random_access_iterator_tag, _Iter_cat_t<_BidIt>>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using iterator_category = _Iter_cat_t<_BidIt>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+    using value_type      = _Iter_value_t<_BidIt>;
+    using difference_type = _Iter_diff_t<_BidIt>;
+    using pointer         = typename iterator_traits<_BidIt>::pointer;
+    using reference       = _Iter_ref_t<_BidIt>;
+
+    template <class>
+    friend class reverse_iterator;
+
+    _CONSTEXPR17 reverse_iterator() = default;
+
+    _CONSTEXPR17 explicit reverse_iterator(_BidIt _Right)
+        noexcept(is_nothrow_move_constructible_v<_BidIt>) // strengthened
+        : current(_STD move(_Right)) {}
+
+    template <class _Other>
+#if _HAS_CXX20
+        requires (!is_same_v<_Other, _BidIt>) && convertible_to<const _Other&, _BidIt>
+#endif // _HAS_CXX20
+    _CONSTEXPR17 reverse_iterator(const reverse_iterator<_Other>& _Right)
+        noexcept(is_nothrow_constructible_v<_BidIt, const _Other&>) // strengthened
+        : current(_Right.current) {
+    }
+
+    template <class _Other>
+#if _HAS_CXX20
+        requires (!is_same_v<_Other, _BidIt>)
+              && convertible_to<const _Other&, _BidIt> && assignable_from<_BidIt&, const _Other&>
+#endif // _HAS_CXX20
+    _CONSTEXPR17 reverse_iterator& operator=(const reverse_iterator<_Other>& _Right)
+        noexcept(is_nothrow_assignable_v<_BidIt&, const _Other&>) /* strengthened */ {
+        current = _Right.current;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 _BidIt base() const noexcept(is_nothrow_copy_constructible_v<_BidIt>) /* strengthened */ {
+        return current;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator*() const
+        noexcept(is_nothrow_copy_constructible_v<_BidIt> && noexcept(*--(_STD declval<_BidIt&>()))) /* strengthened */ {
+        _BidIt _Tmp = current;
+        return *--_Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR17 pointer operator->() const
+        noexcept(is_nothrow_copy_constructible_v<_BidIt> && noexcept(--(_STD declval<_BidIt&>()))
+                 && _Has_nothrow_operator_arrow<_BidIt&, pointer>) /* strengthened */
+#if _HAS_CXX20
+        requires (is_pointer_v<_BidIt> || requires(const _BidIt __i) { __i.operator->(); })
+#endif
+    {
+        _BidIt _Tmp = current;
+        --_Tmp;
+        if constexpr (is_pointer_v<_BidIt>) {
+            return _Tmp;
+        } else {
+            return _Tmp.operator->();
+        }
+    }
+
+    _CONSTEXPR17 reverse_iterator& operator++() noexcept(noexcept(--current)) /* strengthened */ {
+        --current;
+        return *this;
+    }
+
+    _CONSTEXPR17 reverse_iterator operator++(int)
+        noexcept(is_nothrow_copy_constructible_v<_BidIt> && noexcept(--current)) /* strengthened */ {
+        reverse_iterator _Tmp = *this;
+        --current;
+        return _Tmp;
+    }
+
+    _CONSTEXPR17 reverse_iterator& operator--() noexcept(noexcept(++current)) /* strengthened */ {
+        ++current;
+        return *this;
+    }
+
+    _CONSTEXPR17 reverse_iterator operator--(int)
+        noexcept(is_nothrow_copy_constructible_v<_BidIt> && noexcept(++current)) /* strengthened */ {
+        reverse_iterator _Tmp = *this;
+        ++current;
+        return _Tmp;
+    }
+
+    _NODISCARD _CONSTEXPR17 reverse_iterator operator+(const difference_type _Off) const
+        noexcept(noexcept(reverse_iterator(current - _Off))) /* strengthened */ {
+        return reverse_iterator(current - _Off);
+    }
+
+    _CONSTEXPR17 reverse_iterator& operator+=(const difference_type _Off)
+        noexcept(noexcept(current -= _Off)) /* strengthened */ {
+        current -= _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 reverse_iterator operator-(const difference_type _Off) const
+        noexcept(noexcept(reverse_iterator(current + _Off))) /* strengthened */ {
+        return reverse_iterator(current + _Off);
+    }
+
+    _CONSTEXPR17 reverse_iterator& operator-=(const difference_type _Off)
+        noexcept(noexcept(current += _Off)) /* strengthened */ {
+        current += _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator[](const difference_type _Off) const
+        noexcept(noexcept(_STD _Fake_copy_init<reference>(current[_Off]))) /* strengthened */ {
+        return current[static_cast<difference_type>(-_Off - 1)];
+    }
+
+#if _HAS_CXX20
+    _NODISCARD friend constexpr iter_rvalue_reference_t<_BidIt> iter_move(const reverse_iterator& _It)
+        noexcept(is_nothrow_copy_constructible_v<_BidIt> && noexcept(_RANGES iter_move(--_STD declval<_BidIt&>()))) {
+        auto _Tmp = _It.current;
+        --_Tmp;
+        return _RANGES iter_move(_Tmp);
+    }
+
+    template <indirectly_swappable<_BidIt> _BidIt2>
+    friend constexpr void iter_swap(const reverse_iterator& _Left, const reverse_iterator<_BidIt2>& _Right)
+        noexcept(is_nothrow_copy_constructible_v<_BidIt> && is_nothrow_copy_constructible_v<_BidIt2>
+                 && noexcept(_RANGES iter_swap(--_STD declval<_BidIt&>(), --_STD declval<_BidIt2&>()))) {
+        auto _LTmp = _Left.current;
+        auto _RTmp = _Right.base();
+        --_LTmp;
+        --_RTmp;
+        _RANGES iter_swap(_LTmp, _RTmp);
+    }
+#endif // _HAS_CXX20
+
+    using _Prevent_inheriting_unwrap = reverse_iterator;
+
+    template <class _BidIt2, enable_if_t<_Range_verifiable_v<_BidIt, _BidIt2>, int> = 0>
+    friend constexpr void _Verify_range(
+        const reverse_iterator& _First, const reverse_iterator<_BidIt2>& _Last) noexcept {
+        _Verify_range(_Last._Get_current(), _First.current); // note reversed parameters
+    }
+
+    template <class _BidIt2 = _BidIt, enable_if_t<_Offset_verifiable_v<_BidIt2>, int> = 0>
+    constexpr void _Verify_offset(const difference_type _Off) const noexcept {
+        _STL_VERIFY(_Off != _Min_possible_v<difference_type>, "integer overflow");
+        current._Verify_offset(-_Off);
+    }
+
+    template <class _BidIt2 = _BidIt, enable_if_t<_Unwrappable_v<const _BidIt2&>, int> = 0>
+    _NODISCARD constexpr reverse_iterator<_Unwrapped_t<const _BidIt2&>> _Unwrapped() const& noexcept(
+        noexcept(static_cast<reverse_iterator<_Unwrapped_t<const _BidIt2&>>>(current._Unwrapped()))) {
+        return static_cast<reverse_iterator<_Unwrapped_t<const _BidIt2&>>>(current._Unwrapped());
+    }
+    template <class _BidIt2 = _BidIt, enable_if_t<_Unwrappable_v<_BidIt2>, int> = 0>
+    _NODISCARD constexpr reverse_iterator<_Unwrapped_t<_BidIt2>> _Unwrapped() && noexcept(
+        noexcept(static_cast<reverse_iterator<_Unwrapped_t<_BidIt2>>>(_STD move(current)._Unwrapped()))) {
+        return static_cast<reverse_iterator<_Unwrapped_t<_BidIt2>>>(_STD move(current)._Unwrapped());
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_BidIt>;
+
+    template <class _Src, enable_if_t<_Wrapped_seekable_v<_BidIt, const _Src&>, int> = 0>
+    constexpr void _Seek_to(const reverse_iterator<_Src>& _It) noexcept(noexcept(current._Seek_to(_It.current))) {
+        current._Seek_to(_It.current);
+    }
+
+    _NODISCARD constexpr const _BidIt& _Get_current() const noexcept {
+        return current;
+    }
+
+protected:
+    _BidIt current{};
+};
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool operator==(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() == _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() == _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() == _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool operator!=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() != _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() != _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() != _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool operator<(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() > _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() > _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() > _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool operator>(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() < _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() < _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() < _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool operator<=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() >= _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() >= _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() >= _Right._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 bool operator>=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Get_current() <= _Right._Get_current()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left._Get_current() <= _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left._Get_current() <= _Right._Get_current();
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _BidIt1, three_way_comparable_with<_BidIt1> _BidIt2>
+_NODISCARD constexpr compare_three_way_result_t<_BidIt1, _BidIt2> operator<=>(
+    const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
+    noexcept(noexcept(_Right._Get_current() <=> _Left._Get_current())) /* strengthened */ {
+    return _Right._Get_current() <=> _Left._Get_current();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR17 auto operator-(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
+    noexcept(noexcept(_Right._Get_current() - _Left._Get_current())) /* strengthened */
+    -> decltype(_Right._Get_current() - _Left._Get_current()) {
+    return _Right._Get_current() - _Left._Get_current();
+}
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD _CONSTEXPR17 reverse_iterator<_BidIt> operator+(typename reverse_iterator<_BidIt>::difference_type _Off,
+    const reverse_iterator<_BidIt>& _Right) noexcept(noexcept(_Right + _Off)) /* strengthened */ {
+    return _Right + _Off;
+}
+
+_EXPORT_STD template <class _BidIt>
+_NODISCARD _CONSTEXPR17 reverse_iterator<_BidIt> make_reverse_iterator(_BidIt _Iter)
+    noexcept(is_nothrow_move_constructible_v<_BidIt>) /* strengthened */ {
+    return reverse_iterator<_BidIt>(_STD move(_Iter));
+}
+
+#if _HAS_CXX20
+template <class _BidIt1, class _BidIt2>
+    requires (!sized_sentinel_for<_BidIt1, _BidIt2>)
+constexpr bool disable_sized_sentinel_for<reverse_iterator<_BidIt1>, reverse_iterator<_BidIt2>> = true;
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto begin(_Container& _Cont) noexcept(noexcept(_Cont.begin())) -> decltype(_Cont.begin()) {
+    return _Cont.begin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto begin(const _Container& _Cont) noexcept(noexcept(_Cont.begin()))
+    -> decltype(_Cont.begin()) {
+    return _Cont.begin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto end(_Container& _Cont) noexcept(noexcept(_Cont.end())) -> decltype(_Cont.end()) {
+    return _Cont.end();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto end(const _Container& _Cont) noexcept(noexcept(_Cont.end())) -> decltype(_Cont.end()) {
+    return _Cont.end();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty* begin(_Ty (&_Array)[_Size]) noexcept {
+    return _Array;
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty* end(_Ty (&_Array)[_Size]) noexcept {
+    return _Array + _Size;
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(_STD begin(_Cont)))
+    -> decltype(_STD begin(_Cont)) {
+    return _STD begin(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto cend(const _Container& _Cont) noexcept(noexcept(_STD end(_Cont)))
+    -> decltype(_STD end(_Cont)) {
+    return _STD end(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto rbegin(_Container& _Cont) noexcept(noexcept(_Cont.rbegin())) -> decltype(_Cont.rbegin()) {
+    return _Cont.rbegin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto rbegin(const _Container& _Cont) noexcept(noexcept(_Cont.rbegin()))
+    -> decltype(_Cont.rbegin()) {
+    return _Cont.rbegin();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto rend(_Container& _Cont) noexcept(noexcept(_Cont.rend())) -> decltype(_Cont.rend()) {
+    return _Cont.rend();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto rend(const _Container& _Cont) noexcept(noexcept(_Cont.rend())) -> decltype(_Cont.rend()) {
+    return _Cont.rend();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR17 reverse_iterator<_Ty*> rbegin(_Ty (&_Array)[_Size]) noexcept {
+    return reverse_iterator<_Ty*>(_Array + _Size);
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD _CONSTEXPR17 reverse_iterator<_Ty*> rend(_Ty (&_Array)[_Size]) noexcept {
+    return reverse_iterator<_Ty*>(_Array);
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _CONSTEXPR17 reverse_iterator<const _Elem*> rbegin(initializer_list<_Elem> _Ilist) noexcept {
+    return reverse_iterator<const _Elem*>(_Ilist.end());
+}
+
+_EXPORT_STD template <class _Elem>
+_NODISCARD _CONSTEXPR17 reverse_iterator<const _Elem*> rend(initializer_list<_Elem> _Ilist) noexcept {
+    return reverse_iterator<const _Elem*>(_Ilist.begin());
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto crbegin(const _Container& _Cont) noexcept(noexcept(_STD rbegin(_Cont)))
+    -> decltype(_STD rbegin(_Cont)) {
+    return _STD rbegin(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD _CONSTEXPR17 auto crend(const _Container& _Cont) noexcept(noexcept(_STD rend(_Cont)))
+    -> decltype(_STD rend(_Cont)) {
+    return _STD rend(_Cont);
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto size(const _Container& _Cont) noexcept(noexcept(_Cont.size())) -> decltype(_Cont.size()) {
+    return _Cont.size();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr size_t size(const _Ty (&)[_Size]) noexcept {
+    return _Size;
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto ssize(const _Container& _Cont) noexcept(noexcept(_Cont.size()))
+    -> common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>> {
+    using _Common = common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>>;
+    return static_cast<_Common>(_Cont.size());
+}
+
+_EXPORT_STD template <class _Ty, ptrdiff_t _Size>
+_NODISCARD constexpr ptrdiff_t ssize(const _Ty (&)[_Size]) noexcept {
+    return _Size;
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Container>
+_NODISCARD_EMPTY_NON_MEMBER constexpr auto empty(const _Container& _Cont) noexcept(noexcept(_Cont.empty()))
+    -> decltype(_Cont.empty()) {
+    return _Cont.empty();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD_EMPTY_NON_MEMBER constexpr bool empty(const _Ty (&)[_Size]) noexcept {
+    return false;
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto data(_Container& _Cont) noexcept(noexcept(_Cont.data())) -> decltype(_Cont.data()) {
+    return _Cont.data();
+}
+
+_EXPORT_STD template <class _Container>
+_NODISCARD constexpr auto data(const _Container& _Cont) noexcept(noexcept(_Cont.data())) -> decltype(_Cont.data()) {
+    return _Cont.data();
+}
+
+_EXPORT_STD template <class _Ty, size_t _Size>
+_NODISCARD constexpr _Ty* data(_Ty (&_Array)[_Size]) noexcept {
+    return _Array;
+}
+
+#if _HAS_CXX20
+#if _HAS_CXX23
+_EXPORT_STD template <indirectly_readable _Ty>
+using iter_const_reference_t = common_reference_t<const iter_value_t<_Ty>&&, iter_reference_t<_Ty>>;
+
+template <indirectly_readable _Iter>
+using _Iter_const_rvalue_reference_t = common_reference_t<const iter_value_t<_Iter>&&, iter_rvalue_reference_t<_Iter>>;
+
+template <class _Ty>
+concept _Constant_iterator = input_iterator<_Ty> && same_as<iter_const_reference_t<_Ty>, iter_reference_t<_Ty>>;
+
+_EXPORT_STD template <input_iterator _Iter>
+class basic_const_iterator;
+
+_EXPORT_STD template <input_iterator _Iter>
+using const_iterator = conditional_t<_Constant_iterator<_Iter>, _Iter, basic_const_iterator<_Iter>>;
+
+template <class _Sent>
+struct _Const_sentinel {
+    using type = _Sent;
+};
+
+template <input_iterator _Sent>
+struct _Const_sentinel<_Sent> {
+    using type = const_iterator<_Sent>;
+};
+
+_EXPORT_STD template <semiregular _Sent>
+using const_sentinel = _Const_sentinel<_Sent>::type;
+
+template <class _Ty>
+concept _Not_a_const_iterator = !_Is_specialization_v<_Ty, basic_const_iterator>;
+
+template <class>
+struct _Basic_const_iterator_category {};
+
+template <forward_iterator _Iter>
+struct _Basic_const_iterator_category<_Iter> {
+    using iterator_category = iterator_traits<_Iter>::iterator_category;
+};
+
+_EXPORT_STD template <input_iterator _Iter>
+class basic_const_iterator : public _Basic_const_iterator_category<_Iter> {
+private:
+    template <input_iterator>
+    friend class basic_const_iterator;
+
+    /* [[no_unique_address]] */ _Iter _Current{};
+
+    using _Reference        = iter_const_reference_t<_Iter>;
+    using _Rvalue_reference = _Iter_const_rvalue_reference_t<_Iter>;
+
+    _NODISCARD static consteval auto _Get_iter_concept() noexcept {
+        if constexpr (contiguous_iterator<_Iter>) {
+            return contiguous_iterator_tag{};
+        } else if constexpr (random_access_iterator<_Iter>) {
+            return random_access_iterator_tag{};
+        } else if constexpr (bidirectional_iterator<_Iter>) {
+            return bidirectional_iterator_tag{};
+        } else if constexpr (forward_iterator<_Iter>) {
+            return forward_iterator_tag{};
+        } else {
+            return input_iterator_tag{};
+        }
+    }
+
+public:
+    using iterator_type    = _Iter;
+    using iterator_concept = decltype(_Get_iter_concept());
+    using value_type       = iter_value_t<_Iter>;
+    using difference_type  = iter_difference_t<_Iter>;
+
+    basic_const_iterator()
+        requires default_initializable<_Iter>
+    = default;
+
+    constexpr basic_const_iterator(_Iter _Current_) noexcept(is_nothrow_move_constructible_v<_Iter>) // strengthened
+        : _Current(_STD move(_Current_)) {}
+
+    template <convertible_to<_Iter> _Other>
+    constexpr basic_const_iterator(basic_const_iterator<_Other> _Current_)
+        noexcept(is_nothrow_constructible_v<_Iter, _Other>) // strengthened
+        : _Current(_STD move(_Current_._Current)) {}
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires convertible_to<_Other, _Iter>
+    constexpr basic_const_iterator(_Other&& _Current_)
+        noexcept(is_nothrow_constructible_v<_Iter, _Other>) // strengthened
+        : _Current(_STD forward<_Other>(_Current_)) {}
+
+    _NODISCARD constexpr const _Iter& base() const& noexcept {
+        return _Current;
+    }
+
+    _NODISCARD constexpr _Iter base() && noexcept(is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
+        return _STD move(_Current);
+    }
+
+    _NODISCARD constexpr _Reference operator*() const
+        noexcept(noexcept(static_cast<_Reference>(*_Current))) /* strengthened */ {
+        return static_cast<_Reference>(*_Current);
+    }
+
+    _NODISCARD constexpr const auto* operator->() const
+        noexcept(contiguous_iterator<_Iter> || noexcept(*_Current)) /* strengthened */
+        requires is_lvalue_reference_v<iter_reference_t<_Iter>>
+              && same_as<remove_cvref_t<iter_reference_t<_Iter>>, value_type>
+    {
+        if constexpr (contiguous_iterator<_Iter>) {
+            return _STD to_address(_Current);
+        } else {
+            return _STD addressof(*_Current);
+        }
+    }
+
+    constexpr basic_const_iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+        ++_Current;
+        return *this;
+    }
+
+    constexpr void operator++(int) noexcept(noexcept(++_Current)) /* strengthened */ {
+        ++_Current;
+    }
+
+    constexpr basic_const_iterator operator++(int)
+        noexcept(noexcept(++*this) && is_nothrow_copy_constructible_v<basic_const_iterator>) // strengthened
+        requires forward_iterator<_Iter>
+    {
+        auto _Tmp = *this;
+        ++*this;
+        return _Tmp;
+    }
+
+    constexpr basic_const_iterator& operator--() noexcept(noexcept(--_Current)) // strengthened
+        requires bidirectional_iterator<_Iter>
+    {
+        --_Current;
+        return *this;
+    }
+
+    constexpr basic_const_iterator operator--(int)
+        noexcept(noexcept(--*this) && is_nothrow_copy_constructible_v<basic_const_iterator>) // strengthened
+        requires bidirectional_iterator<_Iter>
+    {
+        auto _Tmp = *this;
+        --*this;
+        return _Tmp;
+    }
+
+    constexpr basic_const_iterator& operator+=(const difference_type _Off)
+        noexcept(noexcept(_Current += _Off)) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        _Current += _Off;
+        return *this;
+    }
+
+    constexpr basic_const_iterator& operator-=(const difference_type _Off)
+        noexcept(noexcept(_Current -= _Off)) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        _Current -= _Off;
+        return *this;
+    }
+
+    _NODISCARD constexpr _Reference operator[](const difference_type _Idx) const
+        noexcept(noexcept(static_cast<_Reference>(_Current[_Idx]))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return static_cast<_Reference>(_Current[_Idx]);
+    }
+
+    template <sentinel_for<_Iter> _Sent>
+    _NODISCARD constexpr bool operator==(const _Sent& _Se) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current == _Se))) /* strengthened */ {
+        return _Current == _Se;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires _Constant_iterator<_Other> && convertible_to<const _Iter&, _Other>
+    _NODISCARD constexpr operator _Other() const& noexcept(
+        is_nothrow_convertible_v<const _Iter&, _Other>) /* strengthened */ {
+        return _Current;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires _Constant_iterator<_Other> && convertible_to<_Iter, _Other>
+    _NODISCARD constexpr operator _Other() && noexcept(is_nothrow_convertible_v<_Iter, _Other>) /* strengthened */ {
+        return _STD move(_Current);
+    }
+
+    _NODISCARD constexpr bool operator<(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current < _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Current < _Right._Current;
+    }
+
+    _NODISCARD constexpr bool operator>(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current > _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Current > _Right._Current;
+    }
+
+    _NODISCARD constexpr bool operator<=(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current <= _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Current <= _Right._Current;
+    }
+
+    _NODISCARD constexpr bool operator>=(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current >= _Right._Current))) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return _Current >= _Right._Current;
+    }
+
+    _NODISCARD constexpr auto operator<=>(const basic_const_iterator& _Right) const
+        noexcept(noexcept(_Current <=> _Right._Current)) // strengthened
+        requires random_access_iterator<_Iter> && three_way_comparable<_Iter>
+    {
+        return _Current <=> _Right._Current;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD constexpr bool operator<(const _Other& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current < _Right))) /* strengthened */ {
+        return _Current < _Right;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD constexpr bool operator>(const _Other& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current > _Right))) /* strengthened */ {
+        return _Current > _Right;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD constexpr bool operator<=(const _Other& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current <= _Right))) /* strengthened */ {
+        return _Current <= _Right;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD constexpr bool operator>=(const _Other& _Right) const
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Current >= _Right))) /* strengthened */ {
+        return _Current >= _Right;
+    }
+
+    template <_Different_from<basic_const_iterator> _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+              && three_way_comparable_with<_Iter, _Other>
+    _NODISCARD constexpr auto operator<=>(const _Other& _Right) const
+        noexcept(noexcept(_Current <=> _Right)) /* strengthened */ {
+        return _Current <=> _Right;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD friend constexpr bool operator<(const _Other& _Left, const basic_const_iterator& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left < _Right._Current))) /* strengthened */ {
+        return _Left < _Right._Current;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD friend constexpr bool operator>(const _Other& _Left, const basic_const_iterator& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left > _Right._Current))) /* strengthened */ {
+        return _Left > _Right._Current;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD friend constexpr bool operator<=(const _Other& _Left, const basic_const_iterator& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left <= _Right._Current))) /* strengthened */ {
+        return _Left <= _Right._Current;
+    }
+
+    template <_Not_a_const_iterator _Other>
+        requires random_access_iterator<_Iter> && totally_ordered_with<_Iter, _Other>
+    _NODISCARD friend constexpr bool operator>=(const _Other& _Left, const basic_const_iterator& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left >= _Right._Current))) /* strengthened */ {
+        return _Left >= _Right._Current;
+    }
+
+    _NODISCARD friend constexpr basic_const_iterator operator+(const basic_const_iterator& _It,
+        const difference_type _Off) noexcept(noexcept(basic_const_iterator{_It._Current + _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current + _Off};
+    }
+
+    _NODISCARD friend constexpr basic_const_iterator operator+(const difference_type _Off,
+        const basic_const_iterator& _It) noexcept(noexcept(basic_const_iterator{_It._Current + _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current + _Off};
+    }
+
+    _NODISCARD friend constexpr basic_const_iterator operator-(const basic_const_iterator& _It,
+        const difference_type _Off) noexcept(noexcept(basic_const_iterator{_It._Current - _Off})) // strengthened
+        requires random_access_iterator<_Iter>
+    {
+        return basic_const_iterator{_It._Current - _Off};
+    }
+
+    template <sized_sentinel_for<_Iter> _Sent>
+    _NODISCARD constexpr difference_type operator-(const _Sent& _Se) const
+        noexcept(noexcept(_Current - _Se)) /* strengthened */ {
+        return _Current - _Se;
+    }
+
+    template <_Not_a_const_iterator _Sent>
+        requires sized_sentinel_for<_Sent, _Iter>
+    _NODISCARD friend constexpr difference_type operator-(const _Sent& _Se, const basic_const_iterator& _It)
+        noexcept(noexcept(_Se - _It._Current)) /* strengthened */ {
+        return _Se - _It._Current;
+    }
+
+    _NODISCARD friend constexpr _Rvalue_reference iter_move(const basic_const_iterator& _It)
+        noexcept(noexcept(static_cast<_Rvalue_reference>(_RANGES iter_move(_It._Current)))) {
+        return static_cast<_Rvalue_reference>(_RANGES iter_move(_It._Current));
+    }
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+    requires input_iterator<common_type_t<_Ty1, _Ty2>>
+struct common_type<basic_const_iterator<_Ty1>, _Ty2> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+    requires input_iterator<common_type_t<_Ty1, _Ty2>>
+struct common_type<_Ty2, basic_const_iterator<_Ty1>> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+template <class _Ty1, common_with<_Ty1> _Ty2>
+    requires input_iterator<common_type_t<_Ty1, _Ty2>>
+struct common_type<basic_const_iterator<_Ty1>, basic_const_iterator<_Ty2>> {
+    using type = basic_const_iterator<common_type_t<_Ty1, _Ty2>>;
+};
+
+_EXPORT_STD template <input_iterator _Iter>
+_NODISCARD constexpr const_iterator<_Iter> make_const_iterator(_Iter _It)
+    noexcept(is_nothrow_constructible_v<const_iterator<_Iter>, _Iter&>) /* strengthened */ {
+    return _It;
+}
+
+_EXPORT_STD template <semiregular _Sent>
+_NODISCARD constexpr const_sentinel<_Sent> make_const_sentinel(_Sent _Se)
+    noexcept(is_nothrow_constructible_v<const_sentinel<_Sent>, _Sent&>) /* strengthened */ {
+    return _Se;
+}
+#endif // _HAS_CXX23
+
+namespace ranges {
+    template <class>
+    constexpr bool _Has_complete_elements = false;
+
+    template <class _Ty>
+        requires requires(_Ty& __t) { sizeof(__t[0]); }
+    constexpr bool _Has_complete_elements<_Ty> = true;
+
+    _EXPORT_STD template <class>
+    constexpr bool enable_borrowed_range = false; // specializations allowed by N5014 [range.range]/6
+
+    template <class _Rng>
+    concept _Should_range_access = is_lvalue_reference_v<_Rng> || enable_borrowed_range<remove_cvref_t<_Rng>>;
+
+    namespace _Begin {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void begin() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void begin();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.begin()) } -> input_or_output_iterator;
+        };
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(begin(__t)) } -> input_or_output_iterator; // intentional ADL
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Array, _Member, _Non_member };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (is_array_v<remove_reference_t<_Ty>>) {
+                    static_assert(_Has_complete_elements<_Ty>,
+                        "The range access customization point objects "
+                        "std::ranges::begin, std::ranges::end, std::ranges::rbegin, std::ranges::rend, "
+                        "and std::ranges::data do not accept arrays with incomplete element types.");
+                    return {_St::_Array, true};
+                } else if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().begin()))};
+                } else if constexpr (_Has_ADL<_Ty>) {
+                    return {_St::_Non_member,
+                        noexcept(_STD _Fake_copy_init(begin(_STD declval<_Ty>())))}; // intentional ADL
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Array) {
+                    return _Val;
+                } else if constexpr (_Strat == _St::_Member) {
+                    return _Val.begin();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return begin(_Val); // intentional ADL
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Begin
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Begin::_Cpo begin;
+    }
+
+    _EXPORT_STD template <class _Ty>
+    using iterator_t = decltype(_RANGES begin(_STD declval<_Ty&>()));
+
+    namespace _End {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void end() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void end();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.end()) } -> sentinel_for<iterator_t<_Ty>>;
+        };
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(end(__t)) } -> sentinel_for<iterator_t<_Ty>>; // intentional ADL
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Array, _Member, _Non_member };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                using _UnRef = remove_reference_t<_Ty>;
+
+                if constexpr (is_array_v<_UnRef>) {
+                    static_assert(_Has_complete_elements<_UnRef>,
+                        "The range access customization point objects "
+                        "std::ranges::begin, std::ranges::end, std::ranges::rbegin, std::ranges::rend, "
+                        "and std::ranges::data do not accept arrays with incomplete element types.");
+                    if constexpr (extent_v<_UnRef> != 0) {
+                        return {_St::_Array, true};
+                    } else {
+                        return {_St::_None};
+                    }
+                } else if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().end()))};
+                } else if constexpr (_Has_ADL<_Ty>) {
+                    return {
+                        _St::_Non_member, noexcept(_STD _Fake_copy_init(end(_STD declval<_Ty>())))}; // intentional ADL
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Array) {
+                    // extent_v<remove_reference_t<_Ty&>> reuses specializations from _Choose
+                    return _Val + extent_v<remove_reference_t<_Ty&>>;
+                } else if constexpr (_Strat == _St::_Member) {
+                    return _Val.end();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return end(_Val); // intentional ADL
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _End
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _End::_Cpo end;
+    }
+
+    _EXPORT_STD template <class _Rng>
+    concept range = requires(_Rng& __r) {
+        _RANGES begin(__r);
+        _RANGES end(__r);
+    };
+
+    _EXPORT_STD template <class _Rng>
+    concept input_range = range<_Rng> && input_iterator<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using sentinel_t = decltype(_RANGES end(_STD declval<_Rng&>()));
+
+    template <class _Wrapped>
+    concept _Weakly_unwrappable = _Allow_inheriting_unwrap_v<remove_cvref_t<_Wrapped>>
+                               && requires(_Wrapped&& _Wr) { _STD forward<_Wrapped>(_Wr)._Unwrapped(); };
+
+    template <class _Sent>
+    concept _Weakly_unwrappable_sentinel = _Weakly_unwrappable<const remove_reference_t<_Sent>&>;
+
+    template <class _Iter>
+    concept _Weakly_unwrappable_iterator =
+        _Weakly_unwrappable<_Iter> && requires(_Iter&& _It, remove_cvref_t<_Iter>& _MutIt) {
+            _MutIt._Seek_to(_STD forward<_Iter>(_It)._Unwrapped());
+        };
+
+    template <class _Sent, class _Iter>
+    concept _Unwrappable_sentinel_for = _Weakly_unwrappable_sentinel<_Sent> && _Weakly_unwrappable_iterator<_Iter>
+                                     && requires(_Iter&& _It, const remove_reference_t<_Sent>& _Se) {
+                                            {
+                                                _Se._Unwrapped()
+                                            } -> sentinel_for<decltype(_STD forward<_Iter>(_It)._Unwrapped())>;
+                                        };
+
+    template <class _Sent, class _Iter>
+    _NODISCARD constexpr decltype(auto) _Unwrap_iter(_Iter&& _It)
+        noexcept(!_Unwrappable_sentinel_for<_Sent, _Iter> || _Has_nothrow_unwrapped<_Iter>) {
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<remove_cvref_t<_Sent>, remove_cvref_t<_Iter>>);
+        if constexpr (is_pointer_v<remove_cvref_t<_Iter>>) {
+            return _It + 0;
+        } else if constexpr (_Unwrappable_sentinel_for<_Sent, _Iter>) {
+            return static_cast<_Iter&&>(_It)._Unwrapped();
+        } else {
+            return static_cast<_Iter&&>(_It);
+        }
+    }
+
+    template <class _Iter, class _Sent>
+    _NODISCARD constexpr decltype(auto) _Unwrap_sent(_Sent&& _Se)
+        noexcept(!_Unwrappable_sentinel_for<_Sent, _Iter> || _Has_nothrow_unwrapped<_Sent>) {
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<remove_cvref_t<_Sent>, remove_cvref_t<_Iter>>);
+        if constexpr (is_pointer_v<remove_cvref_t<_Sent>>) {
+            return _Se + 0;
+        } else if constexpr (_Unwrappable_sentinel_for<_Sent, _Iter>) {
+            return static_cast<_Sent&&>(_Se)._Unwrapped();
+        } else {
+            return static_cast<_Sent&&>(_Se);
+        }
+    }
+
+    template <range _Rng, class _Iter>
+    _NODISCARD constexpr decltype(auto) _Unwrap_range_iter(_Iter&& _It)
+        noexcept(noexcept(_RANGES _Unwrap_iter<sentinel_t<_Rng>>(static_cast<_Iter&&>(_It)))) {
+        _STL_INTERNAL_STATIC_ASSERT(same_as<remove_cvref_t<_Iter>, iterator_t<_Rng>>);
+        return _RANGES _Unwrap_iter<sentinel_t<_Rng>>(static_cast<_Iter&&>(_It));
+    }
+
+    template <range _Rng, class _Sent>
+    _NODISCARD constexpr decltype(auto) _Unwrap_range_sent(_Sent&& _Se)
+        noexcept(noexcept(_RANGES _Unwrap_sent<iterator_t<_Rng>>(static_cast<_Sent&&>(_Se)))) {
+        _STL_INTERNAL_STATIC_ASSERT(same_as<remove_cvref_t<_Sent>, sentinel_t<_Rng>>);
+        return _RANGES _Unwrap_sent<iterator_t<_Rng>>(static_cast<_Sent&&>(_Se));
+    }
+
+    template <class _Iter, class _Sent>
+    using _Unwrap_iter_t = remove_cvref_t<decltype(_RANGES _Unwrap_iter<_Sent>(_STD declval<_Iter>()))>;
+    template <class _Sent, class _Iter>
+    using _Unwrap_sent_t = remove_cvref_t<decltype(_RANGES _Unwrap_sent<_Iter>(_STD declval<_Sent>()))>;
+
+    template <range _Rng>
+    using _Unwrapped_iterator_t = _Unwrap_iter_t<iterator_t<_Rng>, sentinel_t<_Rng>>;
+    template <range _Rng>
+    using _Unwrapped_sentinel_t = _Unwrap_sent_t<sentinel_t<_Rng>, iterator_t<_Rng>>;
+
+    namespace _Unchecked_begin {
+        template <class _Ty>
+        concept _Has_member = requires(_Ty& __t) {
+            { __t._Unchecked_begin() } -> input_or_output_iterator;
+        };
+
+        template <class _Ty>
+        concept _Can_begin = requires(_Ty& __t) { _RANGES _Unwrap_range_iter<_Ty>(_RANGES begin(__t)); };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Unwrap };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    _STL_INTERNAL_STATIC_ASSERT(
+                        same_as<decltype(_STD declval<_Ty>()._Unchecked_begin()), _Unwrapped_iterator_t<_Ty>>);
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>()._Unchecked_begin()))};
+                } else if constexpr (_Can_begin<_Ty>) {
+                    return {_St::_Unwrap, noexcept(_STD _Fake_copy_init(
+                                              _RANGES _Unwrap_range_iter<_Ty>(_RANGES begin(_STD declval<_Ty>()))))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val._Unchecked_begin();
+                } else if constexpr (_Strat == _St::_Unwrap) {
+                    return _RANGES _Unwrap_range_iter<_Ty>(_RANGES begin(_Val));
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Unchecked_begin
+
+    inline namespace _Cpos {
+        inline constexpr _Unchecked_begin::_Cpo _Ubegin;
+    }
+
+    namespace _Unchecked_end {
+        template <class _Ty>
+        concept _Has_member = _Unchecked_begin::_Has_member<_Ty> && requires(_Ty& __t) {
+            __t._Unchecked_begin(); // required explicitly for better diagnostics
+            { __t._Unchecked_end() } -> sentinel_for<decltype(__t._Unchecked_begin())>;
+        };
+
+        template <class _Ty>
+        concept _Can_end = requires(_Ty& __t) { _RANGES _Unwrap_range_sent<_Ty>(_RANGES end(__t)); };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Unwrap };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD declval<_Ty>()._Unchecked_end())};
+                } else if constexpr (_Can_end<_Ty>) {
+                    return {_St::_Unwrap, noexcept(_RANGES _Unwrap_range_sent<_Ty>(_RANGES end(_STD declval<_Ty>())))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val._Unchecked_end();
+                } else if constexpr (_Strat == _St::_Unwrap) {
+                    return _RANGES _Unwrap_range_sent<_Ty>(_RANGES end(_Val));
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Unchecked_end
+
+    inline namespace _Cpos {
+        inline constexpr _Unchecked_end::_Cpo _Uend;
+    }
+
+    _EXPORT_STD template <class _Rng>
+    concept borrowed_range = range<_Rng> && _Should_range_access<_Rng>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_difference_t = iter_difference_t<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_value_t = iter_value_t<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_reference_t = iter_reference_t<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <range _Rng>
+    using range_common_reference_t = iter_common_reference_t<iterator_t<_Rng>>;
+
+#if _HAS_CXX23
+    _EXPORT_STD template <class _Rng>
+    concept constant_range = input_range<_Rng> && _Constant_iterator<iterator_t<_Rng>>;
+
+    template <input_range _Rng>
+    _NODISCARD _MSVC_INTRINSIC constexpr auto& _Possibly_const_range(_Rng& _Range) noexcept {
+        if constexpr (input_range<const _Rng>) {
+            return _STD as_const(_Range);
+        } else {
+            return _Range;
+        }
+    }
+
+    template <class _Ty>
+    _NODISCARD _MSVC_INTRINSIC constexpr auto _As_const_pointer(const _Ty* _Ptr) noexcept {
+        return _Ptr;
+    }
+#endif // _HAS_CXX23
+
+    struct _Cbegin_fn {
+#if _HAS_CXX23
+        template <class _Ty>
+        using _Begin_on_const = decltype(_RANGES begin(_RANGES _Possibly_const_range(_STD declval<_Ty&>())));
+
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) {
+                typename _Begin_on_const<_Ty>;
+                typename const_iterator<_Begin_on_const<_Ty>>;
+                const_iterator<_Begin_on_const<_Ty>>{_RANGES begin(_RANGES _Possibly_const_range(_Val))};
+            }
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(
+            noexcept(const_iterator<_Begin_on_const<_Ty>>{_RANGES begin(_RANGES _Possibly_const_range(_Val))})) {
+            return const_iterator<_Begin_on_const<_Ty>>{_RANGES begin(_RANGES _Possibly_const_range(_Val))};
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+            noexcept(noexcept(_RANGES begin(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES begin(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES begin(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Cbegin_fn cbegin;
+    }
+
+    struct _Cend_fn {
+#if _HAS_CXX23
+        template <class _Ty>
+        using _End_on_const = decltype(_RANGES end(_RANGES _Possibly_const_range(_STD declval<_Ty&>())));
+
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) {
+                typename _End_on_const<_Ty>;
+                typename const_sentinel<_End_on_const<_Ty>>;
+                const_sentinel<_End_on_const<_Ty>>{_RANGES end(_RANGES _Possibly_const_range(_Val))};
+            }
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+            noexcept(noexcept(const_sentinel<_End_on_const<_Ty>>{_RANGES end(_RANGES _Possibly_const_range(_Val))})) {
+            return const_sentinel<_End_on_const<_Ty>>{_RANGES end(_RANGES _Possibly_const_range(_Val))};
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+            noexcept(noexcept(_RANGES end(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES end(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES end(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Cend_fn cend;
+    }
+
+    namespace _Rbegin {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void rbegin() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void rbegin();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.rbegin()) } -> input_or_output_iterator;
+        };
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(rbegin(__t)) } -> input_or_output_iterator; // intentional ADL
+        };
+
+        template <class _Ty>
+        concept _Can_make_reverse = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> bidirectional_iterator;
+            { _RANGES end(__t) } -> same_as<decltype(_RANGES begin(__t))>;
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Non_member, _Make_reverse };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().rbegin()))};
+                } else if constexpr (_Has_ADL<_Ty>) {
+                    return {_St::_Non_member,
+                        noexcept(_STD _Fake_copy_init(rbegin(_STD declval<_Ty>())))}; // intentional ADL
+                } else if constexpr (_Can_make_reverse<_Ty>) {
+                    return {_St::_Make_reverse, noexcept(_STD make_reverse_iterator(_RANGES end(_STD declval<_Ty>())))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val.rbegin();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return rbegin(_Val); // intentional ADL
+                } else if constexpr (_Strat == _St::_Make_reverse) {
+                    return _STD make_reverse_iterator(_RANGES end(_Val));
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Rbegin
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Rbegin::_Cpo rbegin;
+    }
+
+    namespace _Rend {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void rend() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void rend();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.rend()) } -> sentinel_for<decltype(_RANGES rbegin(__t))>;
+        };
+
+        template <class _Ty>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
+            // intentional ADL
+            { _STD _Fake_copy_init(rend(__t)) } -> sentinel_for<decltype(_RANGES rbegin(__t))>;
+        };
+
+        template <class _Ty>
+        concept _Can_make_reverse = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> bidirectional_iterator;
+            { _RANGES end(__t) } -> same_as<decltype(_RANGES begin(__t))>;
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Non_member, _Make_reverse };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().rend()))};
+                } else if constexpr (_Has_ADL<_Ty>) {
+                    return {
+                        _St::_Non_member, noexcept(_STD _Fake_copy_init(rend(_STD declval<_Ty>())))}; // intentional ADL
+                } else if constexpr (_Can_make_reverse<_Ty>) {
+                    return {
+                        _St::_Make_reverse, noexcept(_STD make_reverse_iterator(_RANGES begin(_STD declval<_Ty>())))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val.rend();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return rend(_Val); // intentional ADL
+                } else if constexpr (_Strat == _St::_Make_reverse) {
+                    return _STD make_reverse_iterator(_RANGES begin(_Val));
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Rend
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Rend::_Cpo rend;
+    }
+
+    struct _Crbegin_fn {
+#if _HAS_CXX23
+        template <class _Ty>
+        using _Rbegin_on_const = decltype(_RANGES rbegin(_RANGES _Possibly_const_range(_STD declval<_Ty&>())));
+
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) {
+                typename _Rbegin_on_const<_Ty>;
+                typename const_iterator<_Rbegin_on_const<_Ty>>;
+                const_iterator<_Rbegin_on_const<_Ty>>{_RANGES rbegin(_RANGES _Possibly_const_range(_Val))};
+            }
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(
+            noexcept(const_iterator<_Rbegin_on_const<_Ty>>{_RANGES rbegin(_RANGES _Possibly_const_range(_Val))})) {
+            return const_iterator<_Rbegin_on_const<_Ty>>{_RANGES rbegin(_RANGES _Possibly_const_range(_Val))};
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+            noexcept(noexcept(_RANGES rbegin(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES rbegin(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES rbegin(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Crbegin_fn crbegin;
+    }
+
+    struct _Crend_fn {
+#if _HAS_CXX23
+        template <class _Ty>
+        using _Rend_on_const = decltype(_RANGES rend(_RANGES _Possibly_const_range(_STD declval<_Ty&>())));
+
+        template <_Should_range_access _Ty>
+            requires requires(_Ty& _Val) {
+                typename _Rend_on_const<_Ty>;
+                typename const_sentinel<_Rend_on_const<_Ty>>;
+                const_sentinel<_Rend_on_const<_Ty>>{_RANGES rend(_RANGES _Possibly_const_range(_Val))};
+            }
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+            noexcept(noexcept(const_sentinel<_Rend_on_const<_Ty>>{_RANGES rend(_RANGES _Possibly_const_range(_Val))})) {
+            return const_sentinel<_Rend_on_const<_Ty>>{_RANGES rend(_RANGES _Possibly_const_range(_Val))};
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+            noexcept(noexcept(_RANGES rend(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES rend(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES rend(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Crend_fn crend;
+    }
+
+    _EXPORT_STD template <class>
+    constexpr bool disable_sized_range = false; // specializations allowed by N5014 [range.sized]/3
+
+    namespace _Size {
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
+        void size() = delete; // Block unqualified name lookup
+#else // ^^^ no workaround / workaround vvv
+        void size();
+#endif // ^^^ workaround ^^^
+
+        template <class _Ty, class _UnCV>
+        concept _Has_member = !disable_sized_range<_UnCV> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.size()) } -> _Integer_like;
+        };
+
+        template <class _Ty, class _UnCV>
+        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && !disable_sized_range<_UnCV> && requires(_Ty __t) {
+            { _STD _Fake_copy_init(size(__t)) } -> _Integer_like; // intentional ADL
+        };
+
+        template <class _Ty>
+        concept _Can_difference = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> forward_iterator;
+            { _RANGES end(__t) } -> sized_sentinel_for<decltype(_RANGES begin(__t))>;
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Array, _Member, _Non_member, _Subtract };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                using _UnCV = remove_cvref_t<_Ty>;
+
+                if constexpr (is_array_v<_UnCV>) {
+                    if constexpr (extent_v<_UnCV> != 0) {
+                        return {_St::_Array, true};
+                    } else {
+                        return {_St::_None};
+                    }
+                } else if constexpr (_Has_member<_Ty, _UnCV>) {
+                    return {_St::_Member, noexcept(_STD _Fake_copy_init(_STD declval<_Ty>().size()))};
+                } else if constexpr (_Has_ADL<_Ty, _UnCV>) {
+                    return {
+                        _St::_Non_member, noexcept(_STD _Fake_copy_init(size(_STD declval<_Ty>())))}; // intentional ADL
+                } else if constexpr (_Can_difference<_Ty>) {
+                    return {_St::_Subtract,
+                        noexcept(_RANGES end(_STD declval<_Ty>()) - _RANGES begin(_STD declval<_Ty>()))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <class _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Array) {
+                    // extent_v<remove_cvref_t<_Ty&>> reuses specializations from _Choose
+                    return extent_v<remove_cvref_t<_Ty&>>;
+                } else if constexpr (_Strat == _St::_Member) {
+                    return _Val.size();
+                } else if constexpr (_Strat == _St::_Non_member) {
+                    return size(_Val); // intentional ADL
+                } else if constexpr (_Strat == _St::_Subtract) {
+                    const auto _Delta = _RANGES end(_Val) - _RANGES begin(_Val);
+                    return static_cast<_Make_unsigned_like_t<remove_cv_t<decltype(_Delta)>>>(_Delta);
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Size
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Size::_Cpo size;
+    }
+
+    namespace _Empty {
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) { static_cast<bool>(__t.empty()); };
+
+        template <class _Ty>
+        concept _Has_size = requires(_Ty __t) { _RANGES size(__t); };
+
+        template <class _Ty>
+        concept _Can_begin_end = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> forward_iterator;
+            _RANGES end(__t);
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Size, _Compare };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (is_unbounded_array_v<remove_reference_t<_Ty>>) {
+                    return {_St::_None};
+                } else if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(static_cast<bool>(_STD declval<_Ty>().empty()))};
+                } else if constexpr (_Has_size<_Ty>) {
+                    return {_St::_Size, noexcept(_RANGES size(_STD declval<_Ty>()))};
+                } else if constexpr (_Can_begin_end<_Ty>) {
+                    constexpr auto _Nothrow = noexcept(
+                        static_cast<bool>(_RANGES begin(_STD declval<_Ty>()) == _RANGES end(_STD declval<_Ty>())));
+                    return {_St::_Compare, _Nothrow};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <class _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr bool operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return static_cast<bool>(_Val.empty());
+                } else if constexpr (_Strat == _St::_Size) {
+                    return _RANGES size(_Val) == 0;
+                } else if constexpr (_Strat == _St::_Compare) {
+                    return static_cast<bool>(_RANGES begin(_Val) == _RANGES end(_Val));
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Empty
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Empty::_Cpo empty;
+    }
+
+    namespace _Data {
+        template <class _Ty>
+        concept _Points_to_object = is_pointer_v<_Ty> && is_object_v<remove_pointer_t<_Ty>>;
+
+        template <class _Ty>
+        concept _Has_member = requires(_Ty __t) {
+            { _STD _Fake_copy_init(__t.data()) } -> _Points_to_object;
+        };
+
+        template <class _Ty>
+        concept _Has_contiguous_iterator = requires(_Ty __t) {
+            { _RANGES begin(__t) } -> contiguous_iterator;
+        };
+
+        class _Cpo {
+        private:
+            enum class _St { _None, _Member, _Address };
+
+            template <class _Ty>
+            _NODISCARD static consteval _Choice_t<_St> _Choose() noexcept {
+                _STL_INTERNAL_STATIC_ASSERT(is_lvalue_reference_v<_Ty>);
+                if constexpr (_Has_member<_Ty>) {
+                    return {_St::_Member, noexcept(_STD declval<_Ty>().data())};
+                } else if constexpr (_Has_contiguous_iterator<_Ty>) {
+                    return {_St::_Address, noexcept(_STD to_address(_RANGES begin(_STD declval<_Ty>())))};
+                } else {
+                    return {_St::_None};
+                }
+            }
+
+            template <class _Ty>
+            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();
+
+        public:
+            template <_Should_range_access _Ty>
+                requires (_Choice<_Ty&>._Strategy != _St::_None)
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
+                constexpr _St _Strat = _Choice<_Ty&>._Strategy;
+
+                if constexpr (_Strat == _St::_Member) {
+                    return _Val.data();
+                } else if constexpr (_Strat == _St::_Address) {
+                    return _STD to_address(_RANGES begin(_Val));
+                } else {
+                    static_assert(false); // unexpected strategy
+                }
+            }
+        };
+    } // namespace _Data
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Data::_Cpo data;
+    }
+
+    struct _Cdata_fn {
+#if _HAS_CXX23
+        template <_Should_range_access _Ty>
+            requires requires(
+                _Ty& _Val) { _RANGES _As_const_pointer(_RANGES data(_RANGES _Possibly_const_range(_Val))); }
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+            noexcept(noexcept(_RANGES data(_RANGES _Possibly_const_range(_Val)))) {
+            return _RANGES _As_const_pointer(_RANGES data(_RANGES _Possibly_const_range(_Val)));
+        }
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
+            noexcept(noexcept(_RANGES data(static_cast<_CTy&&>(_Val))))
+            requires requires { _RANGES data(static_cast<_CTy&&>(_Val)); }
+        {
+            return _RANGES data(static_cast<_CTy&&>(_Val));
+        }
+#endif // ^^^ !_HAS_CXX23 ^^^
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Cdata_fn cdata;
+    }
+
+    _EXPORT_STD template <class _Rng>
+    concept sized_range = range<_Rng> && requires(_Rng& __r) { _RANGES size(__r); };
+
+    _EXPORT_STD template <sized_range _Rng>
+    using range_size_t = decltype(_RANGES size(_STD declval<_Rng&>()));
+
+    _EXPORT_STD struct view_base {};
+
+    _EXPORT_STD template <class _Derived>
+        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
+    class view_interface;
+
+    template <class _Ty, class _Uty>
+        requires (!is_same_v<_Ty, view_interface<_Uty>>)
+    void _Strictly_derived_from_view_interface_impl(view_interface<_Uty>*);
+
+    _EXPORT_STD template <class _Ty> // specializations allowed by N5014 [range.view]/7
+    constexpr bool enable_view = derived_from<_Ty, view_base> || requires {
+        _RANGES _Strictly_derived_from_view_interface_impl<remove_cv_t<_Ty>>(
+            static_cast<remove_cv_t<_Ty>*>(nullptr)); // qualified: avoid ADL, handle incomplete types
+    };
+
+    _EXPORT_STD template <class _Ty>
+    concept view = range<_Ty> && movable<_Ty> && enable_view<_Ty>;
+
+    _EXPORT_STD template <class _Rng, class _Ty>
+    concept output_range = range<_Rng> && output_iterator<iterator_t<_Rng>, _Ty>;
+
+    _EXPORT_STD template <class _Rng>
+    concept forward_range = range<_Rng> && forward_iterator<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <class _Rng>
+    concept bidirectional_range = range<_Rng> && bidirectional_iterator<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <class _Rng>
+    concept random_access_range = range<_Rng> && random_access_iterator<iterator_t<_Rng>>;
+
+    _EXPORT_STD template <class _Rng>
+    concept contiguous_range = range<_Rng> && contiguous_iterator<iterator_t<_Rng>> && requires(_Rng& __r) {
+        { _RANGES data(__r) } -> same_as<add_pointer_t<range_reference_t<_Rng>>>;
+    };
+
+    struct _Advance_fn {
+        template <input_or_output_iterator _It>
+        static constexpr void operator()(_It& _Where, iter_difference_t<_It> _Off) {
+            if constexpr (random_access_iterator<_It>) {
+                _Where += _Off;
+            } else {
+                if constexpr (!bidirectional_iterator<_It>) {
+                    _STL_ASSERT(_Off >= 0, "negative advance of non-bidirectional iterator");
+                }
+
+                decltype(auto) _UWhere      = _STD _Get_unwrapped_n(_STD move(_Where), _Off);
+                constexpr bool _Need_rewrap = !is_reference_v<decltype(_STD _Get_unwrapped_n(_STD move(_Where), _Off))>;
+
+                if constexpr (bidirectional_iterator<_It>) {
+                    for (; _Off < 0; ++_Off) {
+                        --_UWhere;
+                    }
+                }
+
+                for (; _Off > 0; --_Off) {
+                    ++_UWhere;
+                }
+
+                if constexpr (_Need_rewrap) {
+                    _STD _Seek_wrapped(_Where, _STD move(_UWhere));
+                }
+            }
+        }
+
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+        static constexpr void operator()(_It& _Where, _Se _Last) {
+            if constexpr (assignable_from<_It&, _Se>) {
+                _Where = static_cast<_Se&&>(_Last);
+            } else if constexpr (sized_sentinel_for<_Se, _It>) {
+                operator()(_Where, _Last - _Where);
+            } else {
+                _STD _Adl_verify_range(_Where, _Last);
+
+                decltype(auto) _UWhere = _RANGES _Unwrap_iter<_Se>(static_cast<_It&&>(_Where));
+                constexpr bool _Need_rewrap =
+                    !is_reference_v<decltype(_RANGES _Unwrap_iter<_Se>(static_cast<_It&&>(_Where)))>;
+                decltype(auto) _ULast = _RANGES _Unwrap_sent<_It>(static_cast<_Se&&>(_Last));
+
+                while (_UWhere != _ULast) {
+                    ++_UWhere;
+                }
+
+                if constexpr (_Need_rewrap) {
+                    _STD _Seek_wrapped(_Where, _STD move(_UWhere));
+                }
+            }
+        }
+
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+        static constexpr iter_difference_t<_It> operator()(_It& _Where, iter_difference_t<_It> _Off, _Se _Last) {
+            if constexpr (sized_sentinel_for<_Se, _It>) {
+                const iter_difference_t<_It> _Delta = _Last - _Where;
+                if ((_Off < 0 && _Off <= _Delta) || (_Off > 0 && _Off >= _Delta)) {
+                    if constexpr (assignable_from<_It&, _Se>) {
+                        _Where = static_cast<_Se&&>(_Last);
+                    } else {
+                        operator()(_Where, _Delta);
+                    }
+                    return _Off - _Delta;
+                }
+
+                operator()(_Where, _Off);
+                return 0;
+            } else {
+                // performance note: develop unwrapping technology for (i, n, s)?
+                if constexpr (bidirectional_iterator<_It>) {
+                    for (; _Off < 0 && _Where != _Last; ++_Off) {
+                        --_Where;
+                    }
+                } else {
+                    _STL_ASSERT(_Off >= 0, "negative advance of non-bidirectional iterator");
+                }
+
+                for (; _Off > 0 && _Where != _Last; --_Off) {
+                    ++_Where;
+                }
+
+                return _Off;
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Advance_fn advance;
+
+    template <class _Ty>
+    using _Distance_iterator_t = // per LWG-4303
+        conditional_t<is_array_v<remove_reference_t<_Ty>>, decay_t<_Ty>, remove_const_t<remove_reference_t<_Ty>>>;
+
+    class _Distance_fn {
+    public:
+        template <class _It, sentinel_for<_It> _Se>
+            requires (!sized_sentinel_for<_Se, _It>)
+        _NODISCARD static constexpr iter_difference_t<_It> operator()(_It _First, _Se _Last)
+            noexcept(_Calculate_noexcept<_It, _Se>()) /* strengthened */ {
+            _STD _Adl_verify_range(_First, _Last);
+            return _Distance_unchecked(
+                _RANGES _Unwrap_iter<_Se>(_STD move(_First)), _RANGES _Unwrap_sent<_It>(_STD move(_Last)));
+        }
+
+        template <class _It, sized_sentinel_for<_Distance_iterator_t<_It>> _Se>
+        _NODISCARD static constexpr iter_difference_t<_Distance_iterator_t<_It>> operator()(
+            _It&& _First, const _Se _Last) noexcept(_Calculate_noexcept<_It, _Se>()) /* strengthened */ {
+            if constexpr (!is_array_v<remove_reference_t<_It>>) {
+                return _Last - _First;
+            } else {
+                return _Last - static_cast<decay_t<_It>>(_First);
+            }
+        }
+
+        template <range _Rng>
+        _NODISCARD static constexpr range_difference_t<_Rng> operator()(_Rng&& _Range)
+            noexcept(_Calculate_noexcept<_Rng>()) /* strengthened */ {
+            if constexpr (sized_range<_Rng>) {
+                return static_cast<range_difference_t<_Rng>>(_RANGES size(_Range));
+            } else {
+                return _Distance_unchecked(_Ubegin(_Range), _Uend(_Range));
+            }
+        }
+
+    private:
+        template <class _It, class _Se>
+        _NODISCARD static constexpr iter_difference_t<_It> _Distance_unchecked(_It _First, const _Se _Last)
+            noexcept(noexcept(++_First != _Last)) {
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+
+            iter_difference_t<_It> _Count = 0;
+            for (; _First != _Last; ++_First) {
+                ++_Count;
+            }
+
+            return _Count;
+        }
+
+        template <class _It, class _Se>
+        _NODISCARD static consteval bool _Calculate_noexcept() noexcept {
+            if constexpr (sized_sentinel_for<_Se, _Distance_iterator_t<_It>>) {
+                if constexpr (!is_array_v<remove_reference_t<_It>>) {
+                    return noexcept(_STD declval<const _Se&>() - _STD declval<_It&>());
+                } else {
+                    return noexcept(_STD declval<const _Se&>() - _STD declval<decay_t<_It>>());
+                }
+            } else if constexpr (sentinel_for<_Se, _It> && !sized_sentinel_for<_Se, _It>) {
+                return noexcept(_Distance_unchecked(
+                    _STD _Get_unwrapped(_STD declval<_It>()), _STD _Get_unwrapped(_STD declval<_Se>())));
+            } else {
+                return false;
+            }
+        }
+
+        template <class _Rng>
+        _NODISCARD static consteval bool _Calculate_noexcept() noexcept {
+            if constexpr (sized_range<_Rng>) {
+                return noexcept(_RANGES size(_STD declval<_Rng&>()));
+            } else {
+                return noexcept(_Distance_unchecked(_Ubegin(_STD declval<_Rng&>()), _Uend(_STD declval<_Rng&>())));
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Distance_fn distance;
+
+    struct _Ssize_fn {
+        template <class _Rng>
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(noexcept(_RANGES size(_Range)))
+            requires requires { _RANGES size(_Range); }
+        {
+            using _Sty = _Make_signed_like_t<decltype(_RANGES size(_Range))>;
+            using _Ty  = common_type_t<conditional_t<is_integral_v<_Sty>, ptrdiff_t, _Sty>, _Sty>;
+            return static_cast<_Ty>(_RANGES size(_Range));
+        }
+    };
+
+    inline namespace _Cpos {
+        _EXPORT_STD inline constexpr _Ssize_fn ssize;
+    }
+
+    struct _Next_fn {
+        template <input_or_output_iterator _It>
+        _NODISCARD static constexpr _It operator()(_It _Where) {
+            ++_Where;
+            return _Where;
+        }
+
+        template <input_or_output_iterator _It>
+        _NODISCARD static constexpr _It operator()(_It _Where, const iter_difference_t<_It> _Off) {
+            _RANGES advance(_Where, _Off);
+            return _Where;
+        }
+
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+        _NODISCARD static constexpr _It operator()(_It _Where, _Se _Last) {
+            _RANGES advance(_Where, static_cast<_Se&&>(_Last));
+            return _Where;
+        }
+
+        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+        _NODISCARD static constexpr _It operator()(_It _Where, const iter_difference_t<_It> _Off, _Se _Last) {
+            _RANGES advance(_Where, _Off, static_cast<_Se&&>(_Last));
+            return _Where;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Next_fn next;
+
+    struct _Prev_fn {
+        template <bidirectional_iterator _It>
+        _NODISCARD static constexpr _It operator()(_It _Where) {
+            --_Where;
+            return _Where;
+        }
+
+        template <bidirectional_iterator _It>
+        _NODISCARD static constexpr _It operator()(_It _Where, const iter_difference_t<_It> _Off) {
+            _STL_ASSERT(_Off != _Min_possible_v<iter_difference_t<_It>>, "integer overflow");
+            _RANGES advance(_Where, -_Off);
+            return _Where;
+        }
+
+        template <bidirectional_iterator _It>
+        _NODISCARD static constexpr _It operator()(_It _Where, const iter_difference_t<_It> _Off, _It _Last) {
+            _STL_ASSERT(_Off != _Min_possible_v<iter_difference_t<_It>>, "integer overflow");
+            _RANGES advance(_Where, -_Off, static_cast<_It&&>(_Last));
+            return _Where;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Prev_fn prev;
+
+    template <forward_iterator _It, sentinel_for<_It> _Se>
+    _NODISCARD constexpr _It _Find_last_iterator(
+        const _It& _First, const _Se& _Last, const iter_difference_t<_It> _Count) {
+        // Find the iterator in [_First, _Last) (of length _Count) which equals _Last
+        _STL_INTERNAL_CHECK(_RANGES distance(_First, _Last) == _Count);
+        if constexpr (is_same_v<_It, _Se>) {
+            return _Last;
+        } else {
+            return _RANGES next(_First, _Count);
+        }
+    }
+
+    _EXPORT_STD struct equal_to {
+        template <class _Ty1, class _Ty2>
+            requires equality_comparable_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right)))) /* strengthened */ {
+            return static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right));
+        }
+
+        using is_transparent = int;
+    };
+
+    _EXPORT_STD struct less {
+        template <class _Ty1, class _Ty2>
+            requires totally_ordered_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right)))) /* strengthened */ {
+            return static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right));
+        }
+
+        using is_transparent = int;
+    };
+
+    _EXPORT_STD struct greater {
+        template <class _Ty1, class _Ty2>
+            requires totally_ordered_with<_Ty1, _Ty2>
+        _NODISCARD constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(
+            noexcept(static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left)))) /* strengthened */ {
+            return static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left));
+        }
+
+        using is_transparent = int;
+    };
+
+    _EXPORT_STD template <class _Rng>
+    concept common_range = range<_Rng> && same_as<iterator_t<_Rng>, sentinel_t<_Rng>>;
+
+    template <class _It, class _Se>
+    concept _Bidi_common = is_same_v<_It, _Se> && bidirectional_iterator<_It>;
+    template <class _Rng>
+    concept _Bidi_common_range = common_range<_Rng> && bidirectional_iterator<iterator_t<_Rng>>;
+
+    template <class _Ty>
+    concept _Can_empty = requires(_Ty __t) { _RANGES empty(__t); };
+
+    _EXPORT_STD template <class _Derived>
+        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
+    class view_interface {
+    private:
+        _NODISCARD constexpr _Derived& _Cast() noexcept {
+            static_assert(derived_from<_Derived, view_interface>,
+                "view_interface's template argument D must derive from view_interface<D> "
+                "(N4950 [view.interface.general]/2).");
+            static_assert(view<_Derived>,
+                "view_interface's template argument must model the view concept (N4950 [view.interface.general]/2).");
+            return static_cast<_Derived&>(*this);
+        }
+
+        _NODISCARD constexpr const _Derived& _Cast() const noexcept {
+            static_assert(derived_from<_Derived, view_interface>,
+                "view_interface's template argument D must derive from view_interface<D> "
+                "(N4950 [view.interface.general]/2).");
+            static_assert(view<_Derived>,
+                "view_interface's template argument must model the view concept (N4950 [view.interface.general]/2).");
+            return static_cast<const _Derived&>(*this);
+        }
+
+    public:
+        _NODISCARD constexpr bool empty()
+            requires sized_range<_Derived> || forward_range<_Derived>
+        {
+            auto& _Self = _Cast();
+            if constexpr (sized_range<_Derived>) {
+                return _RANGES size(_Self) == 0;
+            } else {
+                return _RANGES begin(_Self) == _RANGES end(_Self);
+            }
+        }
+
+        _NODISCARD constexpr bool empty() const
+            requires sized_range<const _Derived> || forward_range<const _Derived>
+        {
+            auto& _Self = _Cast();
+            if constexpr (sized_range<const _Derived>) {
+                return _RANGES size(_Self) == 0;
+            } else {
+                return _RANGES begin(_Self) == _RANGES end(_Self);
+            }
+        }
+
+#if _HAS_CXX23
+        _NODISCARD constexpr auto cbegin()
+            requires input_range<_Derived>
+        {
+            return _RANGES cbegin(_Cast());
+        }
+
+        _NODISCARD constexpr auto cbegin() const
+            requires input_range<const _Derived>
+        {
+            return _RANGES cbegin(_Cast());
+        }
+
+        _NODISCARD constexpr auto cend()
+            requires input_range<_Derived>
+        {
+            return _RANGES cend(_Cast());
+        }
+
+        _NODISCARD constexpr auto cend() const
+            requires input_range<const _Derived>
+        {
+            return _RANGES cend(_Cast());
+        }
+#endif // _HAS_CXX23
+
+        constexpr explicit operator bool()
+            requires _Can_empty<_Derived>
+        {
+            return !_RANGES empty(_Cast());
+        }
+
+        constexpr explicit operator bool() const
+            requires _Can_empty<const _Derived>
+        {
+            return !_RANGES empty(_Cast());
+        }
+
+        _NODISCARD constexpr auto data()
+            requires contiguous_iterator<iterator_t<_Derived>>
+        {
+            return _STD to_address(_RANGES begin(_Cast()));
+        }
+
+        _NODISCARD constexpr auto data() const
+            requires range<const _Derived> && contiguous_iterator<iterator_t<const _Derived>>
+        {
+            return _STD to_address(_RANGES begin(_Cast()));
+        }
+
+        _NODISCARD constexpr auto size()
+            requires forward_range<_Derived> && sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
+        {
+            auto& _Self = _Cast();
+            return _STD _To_unsigned_like(_RANGES end(_Self) - _RANGES begin(_Self));
+        }
+
+        _NODISCARD constexpr auto size() const
+            requires forward_range<const _Derived>
+                  && sized_sentinel_for<sentinel_t<const _Derived>, iterator_t<const _Derived>>
+        {
+            auto& _Self = _Cast();
+            return _STD _To_unsigned_like(_RANGES end(_Self) - _RANGES begin(_Self));
+        }
+
+        _NODISCARD constexpr decltype(auto) front()
+            requires forward_range<_Derived>
+        {
+            auto& _Self = _Cast();
+
+#if _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE || _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(!_RANGES empty(_Self), "front() called on empty ranges::view_interface");
+#endif
+
+            return *_RANGES begin(_Self);
+        }
+
+        _NODISCARD constexpr decltype(auto) front() const
+            requires forward_range<const _Derived>
+        {
+            auto& _Self = _Cast();
+
+#if _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE || _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(!_RANGES empty(_Self), "front() called on empty ranges::view_interface");
+#endif
+
+            return *_RANGES begin(_Self);
+        }
+
+        _NODISCARD constexpr decltype(auto) back()
+            requires bidirectional_range<_Derived> && common_range<_Derived>
+        {
+            auto& _Self = _Cast();
+
+#if _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE || _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(!_RANGES empty(_Self), "back() called on empty ranges::view_interface");
+#endif
+
+            auto _Last = _RANGES end(_Self);
+            return *--_Last;
+        }
+
+        _NODISCARD constexpr decltype(auto) back() const
+            requires bidirectional_range<const _Derived> && common_range<const _Derived>
+        {
+            auto& _Self = _Cast();
+
+#if _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE || _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(!_RANGES empty(_Self), "back() called on empty ranges::view_interface");
+#endif
+
+            auto _Last = _RANGES end(_Self);
+            return *--_Last;
+        }
+
+        template <random_access_range _Rng = _Derived>
+        _NODISCARD constexpr decltype(auto) operator[](const range_difference_t<_Rng> _Idx) {
+            auto& _Self = _Cast();
+
+#if _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE || _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (sized_range<_Derived>) {
+                using _U_diff = _Make_unsigned_like_t<range_difference_t<_Rng>>;
+                _STL_VERIFY(static_cast<_U_diff>(_Idx) < static_cast<_U_diff>(_RANGES size(_Self)),
+                    "ranges::view_interface subscript out of range");
+            }
+#endif // _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE || _ITERATOR_DEBUG_LEVEL != 0
+
+            return _RANGES begin(_Self)[_Idx];
+        }
+
+        template <random_access_range _Rng = const _Derived>
+        _NODISCARD constexpr decltype(auto) operator[](const range_difference_t<_Rng> _Idx) const {
+            auto& _Self = _Cast();
+
+#if _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE || _ITERATOR_DEBUG_LEVEL != 0
+            if constexpr (sized_range<_Derived>) {
+                using _U_diff = _Make_unsigned_like_t<range_difference_t<_Rng>>;
+                _STL_VERIFY(static_cast<_U_diff>(_Idx) < static_cast<_U_diff>(_RANGES size(_Self)),
+                    "ranges::view_interface subscript out of range");
+            }
+#endif // _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE || _ITERATOR_DEBUG_LEVEL != 0
+
+            return _RANGES begin(_Self)[_Idx];
+        }
+    };
+} // namespace ranges
+
+#if _HAS_CXX23
+template <class _Ty>
+concept _Pair_like = _Tuple_like<_Ty> && tuple_size_v<remove_cvref_t<_Ty>> == 2;
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class _Ty>
+concept _Pair_like = !is_reference_v<_Ty> && requires(_Ty __t) {
+    typename tuple_size<_Ty>::type;
+    requires derived_from<tuple_size<_Ty>, integral_constant<size_t, 2>>;
+    typename tuple_element_t<0, remove_const_t<_Ty>>;
+    typename tuple_element_t<1, remove_const_t<_Ty>>;
+    { _STD get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Ty>&>;
+    { _STD get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Ty>&>;
+};
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+namespace ranges {
+    template <class _From, class _To>
+    concept _Uses_nonqualification_pointer_conversion =
+        is_pointer_v<_From> && is_pointer_v<_To>
+        && !convertible_to<remove_pointer_t<_From> (*)[], remove_pointer_t<_To> (*)[]>;
+
+    template <class _From, class _To>
+    concept _Convertible_to_non_slicing =
+        convertible_to<_From, _To> && !_Uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
+
+    template <class _Ty, class _First, class _Second>
+    concept _Pair_like_convertible_from = !range<_Ty>
+#if _HAS_CXX23
+                                       && !is_reference_v<_Ty>
+#endif // _HAS_CXX23
+                                       && _Pair_like<_Ty> && constructible_from<_Ty, _First, _Second>
+                                       && _Convertible_to_non_slicing<_First, tuple_element_t<0, _Ty>>
+                                       && convertible_to<_Second, tuple_element_t<1, _Ty>>;
+
+    template <class _It, class _Se, subrange_kind _Ki>
+    concept _Store_size = (_Ki == subrange_kind::sized) && !sized_sentinel_for<_Se, _It>;
+
+    template <class _It, class _Se, subrange_kind _Ki>
+    class _Subrange_base : public view_interface<subrange<_It, _Se, _Ki>> {
+    protected:
+        using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;
+
+    public:
+        _Subrange_base() = default;
+        constexpr explicit _Subrange_base(const _Size_type&) noexcept {}
+    };
+
+    template <class _It, class _Se, subrange_kind _Ki>
+        requires _Store_size<_It, _Se, _Ki>
+    class _Subrange_base<_It, _Se, _Ki> : public view_interface<subrange<_It, _Se, _Ki>> {
+    protected:
+        using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;
+
+        _Size_type _Size = 0;
+
+    public:
+        _Subrange_base() = default;
+        constexpr explicit _Subrange_base(const _Size_type& _Size_) noexcept : _Size(_Size_) {}
+    };
+
+    _EXPORT_STD template <input_or_output_iterator _It, sentinel_for<_It> _Se, subrange_kind _Ki>
+        requires (_Ki == subrange_kind::sized || !sized_sentinel_for<_Se, _It>)
+    class subrange : public _Subrange_base<_It, _Se, _Ki> {
+    private:
+        using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;
+
+        // TRANSITION, ABI:
+        /* [[no_unique_address]] */ _It _First{};
+        /* [[no_unique_address]] */ _Se _Last{};
+        // [[no_unique_address]] conditional_t<_Store_size<_It, _Se, _Ki>, _Size_type, _Nil> _Size{};
+
+        template <class _Rng>
+        constexpr subrange(true_type, _Rng&& _Val)
+            : subrange(_STD forward<_Rng>(_Val), static_cast<_Size_type>(_RANGES size(_Val))) {
+            // delegation target for subrange(_Rng&&) when we must store the range size
+            _STL_INTERNAL_STATIC_ASSERT(_Store_size<_It, _Se, _Ki>);
+        }
+
+        template <class _Rng>
+        constexpr subrange(false_type, _Rng&& _Val) : subrange(_RANGES begin(_Val), _RANGES end(_Val)) {
+            // delegation target for subrange(_Rng&&) when we need not store the range size
+            _STL_INTERNAL_STATIC_ASSERT(!_Store_size<_It, _Se, _Ki>);
+        }
+
+    public:
+        subrange()
+            requires default_initializable<_It>
+        = default;
+
+        template <_Convertible_to_non_slicing<_It> _It2>
+        constexpr subrange(_It2 _First_, _Se _Last_)
+            requires (!_Store_size<_It, _Se, _Ki>)
+            : _First(_STD move(_First_)), _Last(_STD move(_Last_)) {
+            _STD _Adl_verify_range(_First, _Last);
+        }
+
+        template <_Convertible_to_non_slicing<_It> _It2>
+        constexpr subrange(_It2 _First_, _Se _Last_, const _Size_type _Size_)
+            requires (_Ki == subrange_kind::sized)
+            : _Subrange_base<_It, _Se, _Ki>(_Size_), _First(_STD move(_First_)), _Last(_STD move(_Last_)) {
+            _STD _Adl_verify_range(_First, _Last);
+            if constexpr (sized_sentinel_for<_Se, _It>) {
+                _STL_ASSERT(_Size_ == static_cast<_Size_type>(_Last - _First),
+                    "This constructor's third argument should be equal to the distance "
+                    "between the first and second arguments (N4950 [range.subrange.ctor]/3).");
+            }
+        }
+
+        template <_Different_from<subrange> _Rng>
+            requires (borrowed_range<_Rng> && _Convertible_to_non_slicing<iterator_t<_Rng>, _It>
+                      && convertible_to<sentinel_t<_Rng>, _Se>)
+        constexpr subrange(_Rng&& _Val)
+            requires (!_Store_size<_It, _Se, _Ki> || sized_range<_Rng>)
+            : subrange{bool_constant<_Store_size<_It, _Se, _Ki>>{}, _STD forward<_Rng>(_Val)} {}
+
+        template <borrowed_range _Rng>
+            requires (_Convertible_to_non_slicing<iterator_t<_Rng>, _It> && convertible_to<sentinel_t<_Rng>, _Se>)
+        constexpr subrange(_Rng&& _Val, const _Size_type _Count)
+            requires (_Ki == subrange_kind::sized)
+            : subrange{_RANGES begin(_Val), _RANGES end(_Val), _Count} {}
+
+        template <_Different_from<subrange> _PairLike>
+            requires _Pair_like_convertible_from<_PairLike, const _It&, const _Se&>
+        constexpr operator _PairLike() const {
+            return _PairLike(_First, _Last);
+        }
+
+        _NODISCARD constexpr _It begin() const
+            requires copyable<_It>
+        {
+            return _First;
+        }
+        _NODISCARD constexpr _It begin()
+            requires (!copyable<_It>)
+        {
+            return _STD move(_First);
+        }
+
+        _NODISCARD constexpr _Se end() const {
+            return _Last;
+        }
+
+        _NODISCARD constexpr bool empty() const {
+            return _First == _Last;
+        }
+
+        _NODISCARD constexpr _Size_type size() const
+            requires (_Ki == subrange_kind::sized)
+        {
+            if constexpr (_Store_size<_It, _Se, _Ki>) {
+                return this->_Size;
+            } else {
+                return static_cast<_Size_type>(_Last - _First);
+            }
+        }
+
+        _NODISCARD constexpr subrange next() const&
+            requires forward_iterator<_It>
+        {
+            auto _Tmp = *this;
+            if (_Tmp._First != _Tmp._Last) {
+                ++_Tmp._First;
+                if constexpr (_Store_size<_It, _Se, _Ki>) {
+                    --_Tmp._Size;
+                }
+            }
+            return _Tmp;
+        }
+        _NODISCARD constexpr subrange next(const iter_difference_t<_It> _Count) const&
+            requires forward_iterator<_It>
+        {
+            auto _Tmp = *this;
+            _Tmp.advance(_Count);
+            return _Tmp;
+        }
+
+        _NODISCARD constexpr subrange next() && {
+            if (_First != _Last) {
+                ++_First;
+                if constexpr (_Store_size<_It, _Se, _Ki>) {
+                    --this->_Size;
+                }
+            }
+            return _STD move(*this);
+        }
+        _NODISCARD constexpr subrange next(const iter_difference_t<_It> _Count) && {
+            advance(_Count);
+            return _STD move(*this);
+        }
+
+        _NODISCARD constexpr subrange prev() const
+            requires bidirectional_iterator<_It>
+        {
+            auto _Tmp = *this;
+            --_Tmp._First;
+            if constexpr (_Store_size<_It, _Se, _Ki>) {
+                ++_Tmp._Size;
+            }
+            return _Tmp;
+        }
+        _NODISCARD constexpr subrange prev(const iter_difference_t<_It> _Count) const
+            requires bidirectional_iterator<_It>
+        {
+            auto _Tmp = *this;
+            _Tmp.advance(-_Count);
+            return _Tmp;
+        }
+
+        constexpr subrange& advance(const iter_difference_t<_It> _Count) {
+            if constexpr (bidirectional_iterator<_It>) {
+                if (_Count < 0) {
+                    _RANGES advance(_First, _Count);
+                    if constexpr (_Store_size<_It, _Se, _Ki>) {
+                        this->_Size += static_cast<_Size_type>(-_Count);
+                    }
+                    return *this;
+                }
+            }
+
+            const auto _Remainder = _RANGES advance(_First, _Count, _Last);
+            if constexpr (_Store_size<_It, _Se, _Ki>) {
+                this->_Size -= static_cast<_Size_type>(_Count - _Remainder);
+            }
+            return *this;
+        }
+    };
+
+    template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+    subrange(_It, _Se) -> subrange<_It, _Se>;
+
+    template <input_or_output_iterator _It, sentinel_for<_It> _Se>
+    subrange(_It, _Se, _Make_unsigned_like_t<iter_difference_t<_It>>) -> subrange<_It, _Se, subrange_kind::sized>;
+
+    template <borrowed_range _Rng>
+    subrange(_Rng&&) -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
+        (sized_range<_Rng> || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>) ? subrange_kind::sized
+                                                                                      : subrange_kind::unsized>;
+
+    template <borrowed_range _Rng>
+    subrange(_Rng&&, _Make_unsigned_like_t<range_difference_t<_Rng>>)
+        -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
+
+    template <class _It, class _Se, subrange_kind _Ki>
+    constexpr bool enable_borrowed_range<subrange<_It, _Se, _Ki>> = true;
+
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+        requires ((_Idx == 0 && copyable<_It>) || _Idx == 1)
+    _NODISCARD constexpr auto get(const subrange<_It, _Se, _Ki>& _Val) {
+        if constexpr (_Idx == 0) {
+            return _Val.begin();
+        } else {
+            return _Val.end();
+        }
+    }
+
+    _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
+        requires (_Idx < 2)
+    _NODISCARD constexpr auto get(subrange<_It, _Se, _Ki>&& _Val) {
+        if constexpr (_Idx == 0) {
+            return _Val.begin();
+        } else {
+            return _Val.end();
+        }
+    }
+
+    _EXPORT_STD struct dangling {
+        constexpr dangling() noexcept = default;
+        template <class... _Args>
+        constexpr dangling(_Args&&...) noexcept {}
+    };
+
+    _EXPORT_STD template <range _Rng>
+    using borrowed_iterator_t = conditional_t<borrowed_range<_Rng>, iterator_t<_Rng>, dangling>;
+
+    _EXPORT_STD template <range _Rng>
+    using borrowed_subrange_t = conditional_t<borrowed_range<_Rng>, subrange<iterator_t<_Rng>>, dangling>;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+struct _Container_proxy;
+struct _Iterator_base12;
+
+struct _Default_sentinel {}; // empty struct to serve as the end of a range
+
+#if _HAS_CXX20
+_EXPORT_STD template <semiregular>
+class move_sentinel;
+
+template <class>
+struct _Move_iterator_category {};
+
+template <class _Iter>
+    requires requires { typename _Iter_cat_t<_Iter>; }
+struct _Move_iterator_category<_Iter> {
+    using iterator_category = conditional_t<derived_from<_Iter_cat_t<_Iter>, random_access_iterator_tag>,
+        random_access_iterator_tag, _Iter_cat_t<_Iter>>;
+};
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Iter>
+struct _Move_iterator_category {
+    using iterator_category = _Iter_cat_t<_Iter>;
+};
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+_EXPORT_STD template <class _Iter>
+class move_iterator : public _Move_iterator_category<_Iter> {
+private:
+    _Iter _Current{};
+
+public:
+    using iterator_type   = _Iter;
+    using value_type      = _Iter_value_t<_Iter>;
+    using difference_type = _Iter_diff_t<_Iter>;
+    using pointer         = _Iter;
+
+#if _HAS_CXX20
+private:
+    static constexpr auto _Get_iter_concept() {
+        if constexpr (random_access_iterator<_Iter>) {
+            return random_access_iterator_tag{};
+        } else if constexpr (bidirectional_iterator<_Iter>) {
+            return bidirectional_iterator_tag{};
+        } else if constexpr (forward_iterator<_Iter>) {
+            return forward_iterator_tag{};
+        } else {
+            return input_iterator_tag{};
+        }
+    }
+
+public:
+    using iterator_concept = decltype(_Get_iter_concept());
+
+    using reference = iter_rvalue_reference_t<_Iter>;
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    using reference =
+        conditional_t<is_reference_v<_Iter_ref_t<_Iter>>, remove_reference_t<_Iter_ref_t<_Iter>>&&, _Iter_ref_t<_Iter>>;
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CONSTEXPR17 move_iterator() = default;
+
+    _CONSTEXPR17 explicit move_iterator(_Iter _Right) noexcept(is_nothrow_move_constructible_v<_Iter>) // strengthened
+        : _Current(_STD move(_Right)) {}
+
+    template <class _Other>
+#if _HAS_CXX20
+        requires (!is_same_v<_Other, _Iter>) && convertible_to<const _Other&, _Iter>
+#endif // _HAS_CXX20
+    _CONSTEXPR17 move_iterator(const move_iterator<_Other>& _Right)
+        noexcept(is_nothrow_constructible_v<_Iter, const _Other&>) // strengthened
+        : _Current(_Right.base()) {
+    }
+
+    template <class _Other>
+#if _HAS_CXX20
+        requires (!is_same_v<_Other, _Iter>)
+              && convertible_to<const _Other&, _Iter> && assignable_from<_Iter&, const _Other&>
+#endif // _HAS_CXX20
+    _CONSTEXPR17 move_iterator& operator=(const move_iterator<_Other>& _Right)
+        noexcept(is_nothrow_assignable_v<_Iter&, const _Other&>) /* strengthened */ {
+        _Current = _Right.base();
+        return *this;
+    }
+
+#if _HAS_CXX20
+    _NODISCARD constexpr const iterator_type& base() const& noexcept {
+        return _Current;
+    }
+    _NODISCARD constexpr iterator_type base() && noexcept(is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
+        return _STD move(_Current);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    _NODISCARD _CONSTEXPR17 iterator_type base() const
+        noexcept(is_nothrow_copy_constructible_v<_Iter>) /* strengthened */ {
+        return _Current;
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _NODISCARD _CONSTEXPR17 reference operator*() const
+#if _HAS_CXX20
+        noexcept(noexcept(_RANGES iter_move(_Current))) /* strengthened */ {
+        return _RANGES iter_move(_Current);
+    }
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        noexcept(noexcept(static_cast<reference>(*_Current))) /* strengthened */ {
+        return static_cast<reference>(*_Current);
+    }
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+    _CXX20_DEPRECATE_MOVE_ITERATOR_ARROW _NODISCARD _CONSTEXPR17 pointer operator->() const
+        noexcept(is_nothrow_copy_constructible_v<_Iter>) /* strengthened */ {
+        return _Current;
+    }
+
+    _CONSTEXPR17 move_iterator& operator++() noexcept(noexcept(++_Current)) /* strengthened */ {
+        ++_Current;
+        return *this;
+    }
+
+    _CONSTEXPR17 auto operator++(int)
+        noexcept(is_nothrow_copy_constructible_v<_Iter> && noexcept(++_Current)) /* strengthened */ {
+#if _HAS_CXX20
+        if constexpr (forward_iterator<_Iter>) {
+#endif // _HAS_CXX20
+            move_iterator _Tmp = *this;
+            ++_Current;
+            return _Tmp;
+#if _HAS_CXX20
+        } else {
+            ++_Current;
+        }
+#endif // _HAS_CXX20
+    }
+
+    _CONSTEXPR17 move_iterator& operator--() noexcept(noexcept(--_Current)) /* strengthened */ {
+        --_Current;
+        return *this;
+    }
+
+    _CONSTEXPR17 move_iterator operator--(int)
+        noexcept(is_nothrow_copy_constructible_v<_Iter> && noexcept(--_Current)) /* strengthened */ {
+        move_iterator _Tmp = *this;
+        --_Current;
+        return _Tmp;
+    }
+
+    template <class _Iter2 = _Iter>
+    _NODISCARD auto operator==(_Default_sentinel _Sentinel) const noexcept
+        -> decltype(_STD declval<const _Iter2&>() == _Sentinel) {
+        return _Current == _Sentinel;
+    }
+
+    template <class _Iter2 = _Iter>
+    _NODISCARD auto operator!=(_Default_sentinel _Sentinel) const noexcept
+        -> decltype(_STD declval<const _Iter2&>() != _Sentinel) {
+        return _Current != _Sentinel;
+    }
+
+    _NODISCARD _CONSTEXPR17 move_iterator operator+(const difference_type _Off) const
+        noexcept(noexcept(move_iterator(_Current + _Off))) /* strengthened */ {
+        return move_iterator(_Current + _Off);
+    }
+
+    _CONSTEXPR17 move_iterator& operator+=(const difference_type _Off)
+        noexcept(noexcept(_Current += _Off)) /* strengthened */ {
+        _Current += _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 move_iterator operator-(const difference_type _Off) const
+        noexcept(noexcept(move_iterator(_Current - _Off))) /* strengthened */ {
+        return move_iterator(_Current - _Off);
+    }
+
+    _CONSTEXPR17 move_iterator& operator-=(const difference_type _Off)
+        noexcept(noexcept(_Current -= _Off)) /* strengthened */ {
+        _Current -= _Off;
+        return *this;
+    }
+
+    _NODISCARD _CONSTEXPR17 reference operator[](const difference_type _Off) const
+#if _HAS_CXX20
+        noexcept(noexcept(_RANGES iter_move(_Current + _Off))) /* strengthened */ {
+        return _RANGES iter_move(_Current + _Off);
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+        noexcept(noexcept(_STD move(_Current[_Off]))) /* strengthened */ {
+        return _STD move(_Current[_Off]);
+#endif // ^^^ !_HAS_CXX20 ^^^
+    }
+
+#if _HAS_CXX20
+    template <sentinel_for<_Iter> _Sent>
+    _NODISCARD friend constexpr bool operator==(const move_iterator& _Left, const move_sentinel<_Sent>& _Right)
+        noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left._Current == _Right._Get_last()))) /* strengthened */ {
+        return _Left._Current == _Right._Get_last();
+    }
+
+    template <sized_sentinel_for<_Iter> _Sent>
+    _NODISCARD friend constexpr difference_type operator-(const move_sentinel<_Sent>& _Left,
+        const move_iterator& _Right) noexcept(noexcept(_Left._Get_last() - _Right._Current)) /* strengthened */ {
+        return _Left._Get_last() - _Right._Current;
+    }
+
+    template <sized_sentinel_for<_Iter> _Sent>
+    _NODISCARD friend constexpr difference_type operator-(const move_iterator& _Left,
+        const move_sentinel<_Sent>& _Right) noexcept(noexcept(_Left._Current - _Right._Get_last())) /* strengthened */ {
+        return _Left._Current - _Right._Get_last();
+    }
+
+    _NODISCARD friend constexpr reference iter_move(const move_iterator& _It)
+        noexcept(noexcept(_RANGES iter_move(_It._Current))) {
+        return _RANGES iter_move(_It._Current);
+    }
+
+    template <indirectly_swappable<_Iter> _Iter2>
+    friend constexpr void iter_swap(const move_iterator& _Left, const move_iterator<_Iter2>& _Right)
+        noexcept(noexcept(_RANGES iter_swap(_Left._Current, _Right.base()))) {
+        _RANGES iter_swap(_Left._Current, _Right.base());
+    }
+#endif // _HAS_CXX20
+
+    template <class _Iter2, enable_if_t<_Range_verifiable_v<_Iter, _Iter2>, int> = 0>
+    friend constexpr void _Verify_range(const move_iterator& _First, const move_iterator<_Iter2>& _Last) noexcept {
+        _Verify_range(_First._Current, _Last._Get_current());
+    }
+#if _HAS_CXX20
+    template <sentinel_for<_Iter> _Sent>
+        requires _Range_verifiable_v<_Iter, _Sent>
+    friend constexpr void _Verify_range(const move_iterator& _First, const move_sentinel<_Sent>& _Last) noexcept {
+        _Verify_range(_First._Current, _Last._Get_last());
+    }
+#endif // _HAS_CXX20
+
+    using _Prevent_inheriting_unwrap = move_iterator;
+
+    template <class _Iter2 = iterator_type, enable_if_t<_Offset_verifiable_v<_Iter2>, int> = 0>
+    constexpr void _Verify_offset(const difference_type _Off) const noexcept {
+        _Current._Verify_offset(_Off);
+    }
+
+    template <class _Iter2 = iterator_type, enable_if_t<_Unwrappable_v<const _Iter2&>, int> = 0>
+    _NODISCARD constexpr move_iterator<_Unwrapped_t<const _Iter2&>> _Unwrapped() const& noexcept(
+        noexcept(static_cast<move_iterator<_Unwrapped_t<const _Iter2&>>>(_Current._Unwrapped()))) {
+        return static_cast<move_iterator<_Unwrapped_t<const _Iter2&>>>(_Current._Unwrapped());
+    }
+    template <class _Iter2 = iterator_type, enable_if_t<_Unwrappable_v<_Iter2>, int> = 0>
+    _NODISCARD constexpr move_iterator<_Unwrapped_t<_Iter2>> _Unwrapped() && noexcept(
+        noexcept(static_cast<move_iterator<_Unwrapped_t<_Iter2>>>(_STD move(_Current)._Unwrapped()))) {
+        return static_cast<move_iterator<_Unwrapped_t<_Iter2>>>(_STD move(_Current)._Unwrapped());
+    }
+
+    static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<iterator_type>;
+
+    template <class _Src, enable_if_t<_Wrapped_seekable_v<iterator_type, const _Src&>, int> = 0>
+    constexpr void _Seek_to(const move_iterator<_Src>& _It) noexcept(noexcept(_Current._Seek_to(_It._Get_current()))) {
+        _Current._Seek_to(_It._Get_current());
+    }
+    template <class _Src, enable_if_t<_Wrapped_seekable_v<iterator_type, _Src>, int> = 0>
+    constexpr void _Seek_to(move_iterator<_Src>&& _It)
+        noexcept(noexcept(_Current._Seek_to(_STD move(_It)._Get_current()))) {
+        _Current._Seek_to(_STD move(_It)._Get_current());
+    }
+
+    _NODISCARD constexpr const iterator_type& _Get_current() const& noexcept {
+        return _Current;
+    }
+    _NODISCARD constexpr iterator_type&& _Get_current() && noexcept {
+        return _STD move(_Current);
+    }
+};
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator==(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.base() == _Right.base()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.base() == _Right.base() }->_Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left.base() == _Right.base();
+}
+
+#if !_HAS_CXX20
+template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator!=(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)
+    noexcept(noexcept(_Left == _Right)) /* strengthened */ {
+    return !(_Left == _Right);
+}
+#endif // !_HAS_CXX20
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator<(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)
+    noexcept(noexcept(_STD _Fake_copy_init<bool>(_Left.base() < _Right.base()))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Left.base() < _Right.base() }->_Implicitly_convertible_to<bool>;
+    }
+#endif // _HAS_CXX20
+{
+    return _Left.base() < _Right.base();
+}
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator>(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)
+    noexcept(noexcept(_Right < _Left)) /* strengthened */
+#if _HAS_CXX20
+    requires requires { _Right < _Left; }
+#endif // _HAS_CXX20
+{
+    return _Right < _Left;
+}
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator<=(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)
+    noexcept(noexcept(_Right < _Left)) /* strengthened */
+#if _HAS_CXX20
+    requires requires { _Right < _Left; }
+#endif // _HAS_CXX20
+{
+    return !(_Right < _Left);
+}
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 bool operator>=(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)
+    noexcept(noexcept(_Left < _Right)) /* strengthened */
+#if _HAS_CXX20
+    requires requires { _Left < _Right; }
+#endif // _HAS_CXX20
+{
+    return !(_Left < _Right);
+}
+
+#if _HAS_CXX20
+_EXPORT_STD template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
+_NODISCARD constexpr compare_three_way_result_t<_Iter1, _Iter2> operator<=>(const move_iterator<_Iter1>& _Left,
+    const move_iterator<_Iter2>& _Right) noexcept(noexcept(_Left.base() <=> _Right.base())) /* strengthened */ {
+    return _Left.base() <=> _Right.base();
+}
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _Iter1, class _Iter2>
+_NODISCARD _CONSTEXPR17 auto operator-(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)
+    noexcept(noexcept(_Left.base() - _Right.base())) /* strengthened */
+    -> decltype(_Left.base() - _Right.base()) {
+    return _Left.base() - _Right.base();
+}
+
+_EXPORT_STD template <class _Iter>
+_NODISCARD _CONSTEXPR17 move_iterator<_Iter> operator+(
+    typename move_iterator<_Iter>::difference_type _Off, const move_iterator<_Iter>& _Right)
+    noexcept(noexcept(move_iterator<_Iter>(_Right.base() + _Off))) /* strengthened */
+#if _HAS_CXX20
+    requires requires {
+        { _Right.base() + _Off }->same_as<_Iter>;
+    }
+#endif // _HAS_CXX20
+{
+    return move_iterator<_Iter>(_Right.base() + _Off);
+}
+
+_EXPORT_STD template <class _Iter>
+_NODISCARD _CONSTEXPR17 move_iterator<_Iter> make_move_iterator(_Iter _It)
+    noexcept(is_nothrow_move_constructible_v<_Iter>) /* strengthened */ {
+    return move_iterator<_Iter>(_STD move(_It));
+}
+
+#if _HAS_CXX20
+template <class _Iter1, class _Iter2>
+    requires (!sized_sentinel_for<_Iter1, _Iter2>)
+constexpr bool disable_sized_sentinel_for<move_iterator<_Iter1>, move_iterator<_Iter2>> = true;
+
+_EXPORT_STD struct unreachable_sentinel_t {
+    template <weakly_incrementable _Ty>
+    _NODISCARD constexpr bool operator==(const _Ty&) const noexcept {
+        return false;
+    }
+};
+
+_EXPORT_STD inline constexpr unreachable_sentinel_t unreachable_sentinel{};
+
+namespace ranges {
+    struct _Distance_unbounded {
+        _NODISCARD constexpr _Distance_unbounded operator-() const noexcept {
+            return {};
+        }
+    };
+
+    template <class _Checked, class _Iter, class _Sent>
+    _NODISCARD constexpr auto _Idl_distance(const _Iter& _First, const _Sent& _Last) {
+        // Returns the distance between _First and _Last,
+        // an indicator that the distance is infinite, or
+        // an indicator that the distance cannot be determined in O(1).
+        _STL_INTERNAL_STATIC_ASSERT(same_as<_Unwrapped_t<_Checked>, _Iter>);
+
+        if constexpr (sized_sentinel_for<_Sent, _Iter>) {
+            return static_cast<iter_difference_t<_Checked>>(_Last - _First);
+        } else if constexpr (same_as<_Sent, unreachable_sentinel_t>) {
+            return _Distance_unbounded{};
+        } else {
+            return _Distance_unknown{};
+        }
+    }
+
+    template <range _Rng>
+    _NODISCARD constexpr auto _Idl_distance(_Rng& _Range) {
+        // Returns the length of _Range if it is finite and can be determined in O(1), or
+        // an indicator that the length is infinite, or
+        // an indicator that the length cannot be determined in O(1).
+        if constexpr (sized_range<_Rng>) {
+            return _RANGES distance(_Range);
+        } else if constexpr (same_as<sentinel_t<_Rng>, unreachable_sentinel_t>) {
+            return _Distance_unbounded{};
+        } else {
+            return _Distance_unknown{};
+        }
+    }
+} // namespace ranges
+#endif // _HAS_CXX20
+
+// _Iterator_is_contiguous<_Iter> reports whether an iterator is known to be contiguous.
+// (Without concepts, this detection is limited, which will limit when we can activate optimizations.)
+
+#if _HAS_CXX20
+// When concepts are available, we can detect arbitrary contiguous iterators.
+template <class _Iter>
+constexpr bool _Iterator_is_contiguous = contiguous_iterator<_Iter>;
+
+template <class _Iter>
+_NODISCARD constexpr auto _To_address(const _Iter& _Val) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(contiguous_iterator<_Iter>);
+    return _STD to_address(_Val);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+// When concepts aren't available, we can detect pointers. (Iterators should be unwrapped before using this.)
+template <class _Iter>
+constexpr bool _Iterator_is_contiguous = is_pointer_v<_Iter>;
+
+template <class _Iter>
+_NODISCARD constexpr auto _To_address(const _Iter& _Val) noexcept {
+    _STL_INTERNAL_STATIC_ASSERT(is_pointer_v<_Iter>);
+    return _Val;
+}
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+template <class _Iter>
+_NODISCARD constexpr auto _To_address(const move_iterator<_Iter>& _Val) noexcept {
+    return _To_address(_Val.base());
+}
+
+template <class _Iter, class _Sent>
+_NODISCARD constexpr _Iter_diff_t<_Iter> _Contiguous_iter_distance(const _Iter& _First, const _Sent& _Last)
+    noexcept(is_same_v<_Iter, _Sent> || noexcept(_First + (_Last - _First))) {
+    _STL_INTERNAL_STATIC_ASSERT(_Iterator_is_contiguous<_Iter>);
+    if constexpr (is_same_v<_Iter, _Sent>) {
+        return static_cast<_Iter_diff_t<_Iter>>(_STD _To_address(_Last) - _STD _To_address(_First));
+    } else {
+        return static_cast<_Iter_diff_t<_Iter>>(_STD _To_address(_First + (_Last - _First)) - _STD _To_address(_First));
+    }
+}
+
+template <class _Iter, class _Sent>
+_NODISCARD constexpr auto _Contiguous_iter_distance(const move_iterator<_Iter>& _First, const _Sent& _Last)
+    noexcept(noexcept(_STD _Contiguous_iter_distance(_First.base(), _Last))) {
+    return _STD _Contiguous_iter_distance(_First.base(), _Last);
+}
+
+template <class _Iter>
+constexpr void _Contiguous_iter_verify(const _Iter& _Val, const _Iter_diff_t<_Iter>& _Off)
+    noexcept(noexcept(_Val + _Off)) {
+    _STL_INTERNAL_STATIC_ASSERT(_Iterator_is_contiguous<_Iter>);
+    if constexpr (!is_pointer_v<_Iter>) {
+        (void) _STD _To_address(_Val + _Off);
+    }
+}
+
+template <class _Iter>
+constexpr void _Contiguous_iter_verify(const move_iterator<_Iter>& _Val, const _Iter_diff_t<_Iter>& _Off)
+    noexcept(noexcept(_STD _Contiguous_iter_verify(_Val.base(), _Off))) {
+    _STD _Contiguous_iter_verify(_Val.base(), _Off);
+}
+
+// _Iterators_are_contiguous<_Iter1, _Iter2> reports whether both iterators are known to be contiguous.
+
+template <class _Iter1, class _Iter2>
+constexpr bool _Iterators_are_contiguous = _Iterator_is_contiguous<_Iter1> && _Iterator_is_contiguous<_Iter2>;
+
+template <class _Iter>
+constexpr bool _Iterator_is_volatile = is_volatile_v<remove_reference_t<_Iter_ref_t<_Iter>>>;
+
+template <class _Source, class _Dest>
+constexpr bool _Is_pointer_address_convertible = is_void_v<_Source>
+                                              || is_void_v<_Dest>
+                                              // NOTE: is_same_v is required for function pointers to work
+                                              || is_same_v<remove_cv_t<_Source>, remove_cv_t<_Dest>>
+#ifdef __cpp_lib_is_pointer_interconvertible
+                                              || is_pointer_interconvertible_base_of_v<_Dest, _Source>
+#endif // defined(__cpp_lib_is_pointer_interconvertible)
+    ;
+
+#pragma warning(push)
+#pragma warning(disable : 4242) // '%s': conversion from '%s' to '%s', possible loss of data
+#pragma warning(disable : 4244) // '%s': conversion from '%s' to '%s', possible loss of data (Yes, duplicated message.)
+#pragma warning(disable : 4267) // '%s': conversion from '%s' to '%s', possible loss of data (Yes, duplicated message!)
+#pragma warning(disable : 4365) // '%s': conversion from '%s' to '%s', signed/unsigned mismatch
+#pragma warning(disable : 5267) // definition of implicit assignment operator for '%s' is deprecated because it has a
+                                // user-provided copy constructor
+
+// Determines whether _DestRef is trivially assignable from _SourceRef, and if _Remove_cvref_t<_DestRef> is a class, the
+// assignment uses _Remove_cvref_t<_DestRef>::operator=.
+// Not pedantically reliable for vectorization, but working due to bugs of MSVC, Clang, and EDG. See LLVM-37038.
+template <class _DestRef, class _SourceRef, bool = is_trivially_assignable_v<_DestRef, _SourceRef>>
+constexpr bool _Is_trivially_assignable_returning_same_reference_v =
+    is_same_v<_DestRef, decltype(_STD declval<_DestRef>() = _STD declval<_SourceRef>())>;
+template <class _DestRef, class _SourceRef>
+constexpr bool _Is_trivially_assignable_returning_same_reference_v<_DestRef, _SourceRef, false> = false;
+
+#pragma warning(pop)
+
+template <class _Source, class _Dest, class _SourceRef, class _DestRef>
+struct _Trivial_cat {
+    using _USource = _Unwrap_enum_t<_Source>;
+    using _UDest   = _Unwrap_enum_t<_Dest>;
+
+    static constexpr bool _Same_size_and_compatible =
+        sizeof(_Source) == sizeof(_Dest)
+        // If _UDest is bool, _USource also needs to be bool
+        // Conversion from non-bool => non-bool | bool => bool | bool => non-bool is fine.
+        // Conversion from non-bool => bool is not fine.
+        && is_same_v<bool, _USource> >= is_same_v<bool, _UDest>
+        && (is_same_v<_USource, _UDest> || (is_integral_v<_USource> && is_integral_v<_UDest>)
+            || (is_floating_point_v<_USource> && is_floating_point_v<_UDest>) );
+
+    static constexpr bool _Bitcopy_constructible =
+        _Same_size_and_compatible && is_trivially_constructible_v<_Dest, _SourceRef>;
+
+    static constexpr bool _Bitcopy_assignable =
+        _Same_size_and_compatible && _Is_trivially_assignable_returning_same_reference_v<_DestRef, _SourceRef>;
+};
+
+template <class _Source, class _Dest, class _SourceRef, class _DestRef>
+struct _Trivial_cat<_Source*, _Dest*, _SourceRef, _DestRef> {
+    static constexpr bool _Bitcopy_constructible =
+        _Is_pointer_address_convertible<_Source, _Dest> && is_trivially_constructible_v<_Dest*, _SourceRef>;
+
+    static constexpr bool _Bitcopy_assignable =
+        _Is_pointer_address_convertible<_Source, _Dest>
+        && _Is_trivially_assignable_returning_same_reference_v<_DestRef, _SourceRef>;
+};
+
+struct _False_trivial_cat {
+    static constexpr bool _Bitcopy_constructible = false;
+    static constexpr bool _Bitcopy_assignable    = false;
+};
+
+template <class _SourceIt, class _DestIt,
+    bool _Are_contiguous = _Iterators_are_contiguous<_SourceIt, _DestIt> && !_Iterator_is_volatile<_SourceIt>
+                        && !_Iterator_is_volatile<_DestIt>>
+struct _Iter_move_cat : _Trivial_cat<_Iter_value_t<_SourceIt>, _Iter_value_t<_DestIt>,
+                            remove_reference_t<_Iter_ref_t<_SourceIt>>&&, _Iter_ref_t<_DestIt>> {};
+
+template <class _SourceIt, class _DestIt>
+struct _Iter_move_cat<_SourceIt, _DestIt, false> : _False_trivial_cat {};
+
+template <class _SourceIt, class _DestIt>
+struct _Iter_move_cat<move_iterator<_SourceIt>, _DestIt, false> : _Iter_move_cat<_SourceIt, _DestIt> {};
+
+template <class _SourceIt, class _DestIt,
+    bool _Are_contiguous = _Iterators_are_contiguous<_SourceIt, _DestIt> && !_Iterator_is_volatile<_SourceIt>
+                        && !_Iterator_is_volatile<_DestIt>>
+struct _Iter_copy_cat
+    : _Trivial_cat<_Iter_value_t<_SourceIt>, _Iter_value_t<_DestIt>, _Iter_ref_t<_SourceIt>, _Iter_ref_t<_DestIt>> {};
+
+template <class _SourceIt, class _DestIt>
+struct _Iter_copy_cat<_SourceIt, _DestIt, false> : _False_trivial_cat {};
+
+template <class _SourceIt, class _DestIt>
+struct _Iter_copy_cat<move_iterator<_SourceIt>, _DestIt, false> : _Iter_move_cat<_SourceIt, _DestIt> {};
+
+template <class _Iter1, class _Sent1, class _Iter2>
+_CONSTEXPR20 void _Verify_ranges_do_not_overlap(const _Iter1& _First1, const _Sent1& _Last1, const _Iter2& _First2) {
+#if _ITERATOR_DEBUG_LEVEL == 2
+    if constexpr (_Iterators_are_contiguous<_Iter1, _Iter2>
+#if _HAS_CXX20
+                  && sized_sentinel_for<_Sent1, _Iter1>
+#endif // _HAS_CXX20
+    ) {
+#if _HAS_CXX20
+        if (_STD is_constant_evaluated()) {
+            return;
+        }
+#endif // _HAS_CXX20
+
+        const auto _Offset     = static_cast<ptrdiff_t>(_Last1 - _First1);
+        const auto _Ptr1Offset = _Offset * sizeof(*_STD _To_address(_First1));
+        const auto _Ptr2Offset = _Offset * sizeof(*_STD _To_address(_First2));
+        // This cast to `cv char*` allows us to compare pointers to distinct types,
+        // in case one range provides storage for the other.
+        const auto _PtrFirst1 = reinterpret_cast<const volatile char*>(_STD _To_address(_First1));
+        const auto _PtrLast1  = _PtrFirst1 + _Ptr1Offset;
+        const auto _PtrFirst2 = reinterpret_cast<const volatile char*>(_STD _To_address(_First2));
+        const auto _PtrLast2  = _PtrFirst2 + _Ptr2Offset;
+        _STL_VERIFY(_PtrLast1 <= _PtrFirst2 || _PtrLast2 <= _PtrFirst1, "ranges should not overlap each other");
+    }
+#else // ^^^ _ITERATOR_DEBUG_LEVEL == 2 / _ITERATOR_DEBUG_LEVEL != 2 vvv
+    (void) _First1;
+    (void) _Last1;
+    (void) _First2;
+#endif // _ITERATOR_DEBUG_LEVEL != 2 ^^^
+}
+
+template <bool _Use_memcpy, class _OutCtgIt>
+_OutCtgIt _Impl_copy_memmeow_tail(
+    const char* const _First_ch, const _OutCtgIt _Dest, const size_t _Byte_count, const size_t _Object_count) {
+    _STL_INTERNAL_CHECK(_Byte_count == _Object_count * sizeof(*_Dest));
+    // (pre-verified contiguous iterator)
+    const auto _Dest_ptr = _STD _To_address(_Dest);
+    const auto _Dest_ch  = const_cast<char*>(reinterpret_cast<const volatile char*>(_Dest_ptr));
+
+    if constexpr (_Use_memcpy) {
+        _CSTD memcpy(_Dest_ch, _First_ch, _Byte_count);
+    } else {
+        _CSTD memmove(_Dest_ch, _First_ch, _Byte_count);
+    }
+
+    if constexpr (is_pointer_v<_OutCtgIt>) {
+        (void) _Object_count;
+        // CodeQL [SM02986] This cast is correct: we're bypassing pointer arithmetic for performance.
+        return reinterpret_cast<_OutCtgIt>(_Dest_ch + _Byte_count);
+    } else {
+        return _Dest + static_cast<_Iter_diff_t<_OutCtgIt>>(_Object_count);
+    }
+}
+
+template <bool _Use_memcpy, class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Impl_copy_memmeow(_CtgIt _First, _CtgIt _Last, _OutCtgIt _Dest) {
+    _STL_INTERNAL_CHECK(_First <= _Last);
+    const auto _First_ptr    = _STD _To_address(_First);
+    const auto _Last_ptr     = _STD _To_address(_Last);
+    const auto _Ptr_diff     = _Last_ptr - _First_ptr;
+    const auto _Object_count = static_cast<size_t>(_Ptr_diff);
+    const auto _First_ch     = const_cast<const char*>(reinterpret_cast<const volatile char*>(_First_ptr));
+    const auto _Last_ch      = const_cast<const char*>(reinterpret_cast<const volatile char*>(_Last_ptr));
+    const auto _Byte_count   = static_cast<size_t>(_Last_ch - _First_ch);
+    _STD _Contiguous_iter_verify(_Dest, static_cast<_Iter_diff_t<_OutCtgIt>>(_Ptr_diff));
+    return _STD _Impl_copy_memmeow_tail<_Use_memcpy>(_First_ch, _STD move(_Dest), _Byte_count, _Object_count);
+}
+
+template <bool _Use_memcpy, class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Impl_copy_memmeow_n(_CtgIt _First, const size_t _Object_count, _OutCtgIt _Dest) {
+    _STD _Contiguous_iter_verify(_First, static_cast<_Iter_diff_t<_CtgIt>>(_Object_count));
+    _STD _Contiguous_iter_verify(_Dest, static_cast<_Iter_diff_t<_OutCtgIt>>(_Object_count));
+    const auto _First_ptr  = _STD _To_address(_First);
+    const auto _First_ch   = const_cast<const char*>(reinterpret_cast<const volatile char*>(_First_ptr));
+    const auto _Byte_count = _Object_count * sizeof(*_First_ptr);
+    return _STD _Impl_copy_memmeow_tail<_Use_memcpy>(_First_ch, _STD move(_Dest), _Byte_count, _Object_count);
+}
+
+template <class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Copy_memcpy(_CtgIt _First, _CtgIt _Last, _OutCtgIt _Dest) {
+    return _STD _Impl_copy_memmeow<true>(_First, _Last, _Dest);
+}
+
+template <class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Copy_memcpy_n(_CtgIt _First, const size_t _Object_count, _OutCtgIt _Dest) {
+    return _STD _Impl_copy_memmeow_n<true>(_First, _Object_count, _Dest);
+}
+
+template <class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Copy_memmove(_CtgIt _First, _CtgIt _Last, _OutCtgIt _Dest) {
+    return _STD _Impl_copy_memmeow<false>(_First, _Last, _Dest);
+}
+
+template <class _CtgIt, class _OutCtgIt>
+_OutCtgIt _Copy_memmove_n(_CtgIt _First, const size_t _Object_count, _OutCtgIt _Dest) {
+    return _STD _Impl_copy_memmeow_n<false>(_First, _Object_count, _Dest);
+}
+
+template <class _Fn>
+struct _Map_vb_functor {
+    using type = void;
+};
+
+#if _HAS_CXX20
+template <>
+struct _Map_vb_functor<identity> {
+    using type = identity;
+};
+#endif // _HAS_CXX20
+
+template <class _Fn>
+using _Map_vb_functor_t = typename _Map_vb_functor<_Fn>::type;
+
+template <class _It, bool _RequiresMutable = false>
+constexpr bool _Is_vb_iterator = false;
+
+template <class _VbIt, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_vbool(_VbIt _First, _VbIt _Last, _OutIt _Dest);
+
+template <class _VbIt>
+_NODISCARD _CONSTEXPR20 _Iter_diff_t<_VbIt> _Count_vbool(_VbIt _First, _VbIt _Last, bool _Val) noexcept;
+
+template <class _VbIt>
+_CONSTEXPR20 void _Fill_vbool(_VbIt _First, _VbIt _Last, bool _Val) noexcept;
+
+template <class _VbIt>
+_NODISCARD _CONSTEXPR20 _VbIt _Find_vbool(_VbIt _First, _VbIt _Last, bool _Val) noexcept;
+
+template <class _InIt, class _SizeTy, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_n_unchecked4(_InIt _First, _SizeTy _Count, _OutIt _Dest) {
+    // copy _First + [0, _Count) to _Dest + [0, _Count), returning _Dest + _Count
+    // note: has callers outside the copy family
+    _STL_INTERNAL_STATIC_ASSERT(_Integer_like<_SizeTy>);
+    _STL_INTERNAL_CHECK(_Count >= 0);
+
+    if constexpr (_Iter_copy_cat<_InIt, _OutIt>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _Copy_memmove_n(_First, static_cast<size_t>(_Count), _Dest);
+        }
+    }
+
+    for (; _Count != 0; ++_Dest, (void) ++_First, --_Count) {
+        *_Dest = *_First;
+    }
+
+    return _Dest;
+}
+
+template <class _InIt, class _Sent, class _OutIt>
+using _Sent_copy_cat = conditional_t<
+#if _HAS_CXX20
+    is_same_v<_Sent, _InIt> || sized_sentinel_for<_Sent, _InIt>,
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+    is_same_v<_Sent, _InIt>,
+#endif // ^^^ !_HAS_CXX20 ^^^
+    _Iter_copy_cat<_InIt, _OutIt>, _False_trivial_cat>;
+
+template <class _InIt, class _Sent, class _OutIt>
+_CONSTEXPR20 _OutIt _Copy_unchecked(_InIt _First, _Sent _Last, _OutIt _Dest) {
+    // copy [_First, _Last) to [_Dest, ...)
+    // note: _Copy_unchecked has callers other than the copy family
+    if constexpr (_Is_vb_iterator<_InIt> && _Is_vb_iterator<_OutIt, true>) {
+        return _STD _Copy_vbool(_First, _Last, _Dest);
+    } else {
+        if constexpr (_Sent_copy_cat<_InIt, _Sent, _OutIt>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+#if _HAS_CXX20
+                if constexpr (!is_same_v<_InIt, _Sent>) {
+                    return _STD _Copy_memmove_n(_First, static_cast<size_t>(_Last - _First), _Dest);
+                } else
+#endif // _HAS_CXX20
+                {
+                    return _STD _Copy_memmove(_First, _Last, _Dest);
+                }
+            }
+        }
+
+        for (; _First != _Last; ++_Dest, (void) ++_First) {
+            *_Dest = *_First;
+        }
+
+        return _Dest;
+    }
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest) { // copy [_First, _Last) to [_Dest, ...)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    auto _UDest        = _STD _Get_unwrapped_n(_STD move(_Dest), _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Copy_unchecked(_UFirst, _ULast, _STD move(_UDest)));
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // copy [_First, _Last) to [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD copy(_First, _Last, _Dest);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _To, class _From>
+    concept _Convertible_from = convertible_to<_From, _To>;
+
+    _EXPORT_STD template <class _In, class _Out>
+    struct in_out_result {
+        /* [[no_unique_address]] */ _In in;
+        /* [[no_unique_address]] */ _Out out;
+
+        template <_Convertible_from<const _In&> _IIn, _Convertible_from<const _Out&> _OOut>
+        constexpr operator in_out_result<_IIn, _OOut>() const& {
+            return {in, out};
+        }
+
+        template <_Convertible_from<_In> _IIn, _Convertible_from<_Out> _OOut>
+        constexpr operator in_out_result<_IIn, _OOut>() && {
+            return {_STD move(in), _STD move(out)};
+        }
+    };
+
+    template <forward_iterator _It, class _Se>
+        requires sentinel_for<remove_cvref_t<_Se>, _It>
+    _NODISCARD constexpr _Unwrap_iter_t<_It, _Se> _Get_final_iterator_unwrapped(
+        const _Unwrap_iter_t<_It, _Se>& _UFirst, _Se&& _Last) {
+        // find the iterator in [_UFirst, _Unwrap_sent<_It>(_Last)) which equals _Unwrap_sent<_It>(_Last)
+        // [possibly O(N)]
+        if constexpr (is_same_v<_Unwrap_iter_t<_It, _Se>, _Unwrap_sent_t<_Se, _It>>) {
+            return _RANGES _Unwrap_sent<_It>(_STD forward<_Se>(_Last));
+        } else {
+            return _RANGES next(_UFirst, _RANGES _Unwrap_sent<_It>(_STD forward<_Se>(_Last)));
+        }
+    }
+
+    template <forward_range _Rng>
+    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range) {
+        // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
+        if constexpr (common_range<_Rng>) {
+            if constexpr (same_as<decltype(_Uend(_Range)), _Unwrapped_iterator_t<_Rng>>) {
+                return _Uend(_Range);
+            } else {
+                return _RANGES _Unwrap_range_sent<_Rng>(_RANGES end(_Range));
+            }
+        } else if constexpr (sized_range<_Rng>) {
+            return _RANGES next(_Ubegin(_Range), _RANGES distance(_Range));
+        } else {
+            return _RANGES next(_Ubegin(_Range), _Uend(_Range));
+        }
+    }
+
+    template <forward_range _Rng>
+    _NODISCARD constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range, const _Unwrapped_iterator_t<_Rng>& _Mid) {
+        // find the (unwrapped) iterator in _Range which equals _Uend(_Range) [possibly O(N)]
+        // Pre: [ranges::begin(_Range), _Mid) and [_Mid, ranges::end(_Range)) denote ranges
+        if constexpr (common_range<_Rng>) {
+            if constexpr (same_as<decltype(_Uend(_Range)), _Unwrapped_iterator_t<_Rng>>) {
+                return _Uend(_Range);
+            } else {
+                return _Unwrap_range_sent<_Rng>(_RANGES end(_Range));
+            }
+        } else if constexpr (sized_range<_Rng>) {
+            const auto _Dist = _RANGES distance(_Range);
+            if constexpr (sized_sentinel_for<_Unwrapped_iterator_t<_Rng>, _Unwrapped_iterator_t<_Rng>>) {
+                return _RANGES next(_Mid, _Dist - (_Mid - _Ubegin(_Range)));
+            } else {
+                return _RANGES next(_Ubegin(_Range), _Dist);
+            }
+        } else {
+            return _RANGES next(_Mid, _Uend(_Range));
+        }
+    }
+
+#if _HAS_CXX23
+    _EXPORT_STD template <class _Out, class _Ty>
+    struct out_value_result {
+        _MSVC_NO_UNIQUE_ADDRESS _Out out;
+        _MSVC_NO_UNIQUE_ADDRESS _Ty value;
+
+        template <_Convertible_from<const _Out&> _OOut, _Convertible_from<const _Ty&> _TTy>
+        constexpr operator out_value_result<_OOut, _TTy>() const& {
+            return {out, value};
+        }
+
+        template <_Convertible_from<_Out> _OOut, _Convertible_from<_Ty> _TTy>
+        constexpr operator out_value_result<_OOut, _TTy>() && {
+            return {_STD move(out), _STD move(value)};
+        }
+    };
+#endif // _HAS_CXX23
+
+    _EXPORT_STD template <class _In, class _Out>
+    using copy_result = in_out_result<_In, _Out>;
+
+    template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+        requires indirectly_copyable<_It, _Out>
+    _NODISCARD constexpr copy_result<_It, _Out> _Copy_unchecked(_It _First, _Se _Last, _Out _Output) {
+        if constexpr (_Sent_copy_cat<_It, _Se, _Out>::_Bitcopy_assignable) {
+            if (!_STD is_constant_evaluated()) {
+                if constexpr (is_same_v<_It, _Se>) {
+                    _Output = _STD _Copy_memmove(_STD move(_First), _Last, _STD move(_Output));
+                    return {_STD move(_Last), _STD move(_Output)};
+                } else {
+                    const auto _Dist  = _Last - _First;
+                    const auto _Count = static_cast<size_t>(_Dist);
+                    _Output           = _STD _Copy_memmove_n(_First, _Count, _STD move(_Output));
+                    _First += _Dist;
+                    return {_STD move(_First), _STD move(_Output)};
+                }
+            }
+        }
+
+        for (; _First != _Last; ++_First, (void) ++_Output) {
+            *_Output = *_First;
+        }
+
+        return {_STD move(_First), _STD move(_Output)};
+    }
+
+    struct _Copy_fn {
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+            requires indirectly_copyable<_It, _Out>
+        static constexpr copy_result<_It, _Out> operator()(_It _First, _Se _Last, _Out _Output) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _RANGES _Unwrap_iter<_Se>(_STD move(_First));
+            auto _ULast       = _RANGES _Unwrap_sent<_It>(_STD move(_Last));
+            const auto _Count = _RANGES _Idl_distance<_It>(_UFirst, _ULast);
+            auto _UResult     = _RANGES _Copy_unchecked(
+                _STD move(_UFirst), _STD move(_ULast), _STD _Get_unwrapped_n(_STD move(_Output), _Count));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out>
+            requires indirectly_copyable<iterator_t<_Rng>, _Out>
+        static constexpr copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(_Rng&& _Range, _Out _Output) {
+            const auto _Count = _RANGES _Idl_distance(_Range);
+            auto _First       = _RANGES begin(_Range);
+            auto _UResult = _RANGES _Copy_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Get_unwrapped_n(_STD move(_Output), _Count));
+            _STD _Seek_wrapped(_First, _STD move(_UResult.in));
+            _STD _Seek_wrapped(_Output, _STD move(_UResult.out));
+            return {_STD move(_First), _STD move(_Output)};
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Copy_fn copy;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Diff, class _OutIt>
+_CONSTEXPR20 _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) {
+    // copy [_First, _First + _Count) to [_Dest, ...)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (0 < _Count) {
+        if constexpr (_Is_vb_iterator<_InIt> && _Is_vb_iterator<_OutIt, true>) {
+            return _STD _Copy_vbool(_First, _First + _Count, _Dest);
+        } else {
+            auto _UFirst = _STD _Get_unwrapped_n(_First, _Count);
+            auto _UDest  = _STD _Get_unwrapped_n(_Dest, _Count);
+            if constexpr (_Iter_copy_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+                if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+                {
+                    _UDest = _STD _Copy_memmove_n(_UFirst, static_cast<size_t>(_Count), _UDest);
+                    _STD _Seek_wrapped(_Dest, _UDest);
+                    return _Dest;
+                }
+            }
+
+            for (;;) {
+                *_UDest = *_UFirst;
+                ++_UDest;
+                --_Count;
+                // note that we avoid an extra ++_First here to allow istream_iterator to work, see LWG-2471
+                if (_Count == 0) {
+                    break;
+                }
+
+                ++_UFirst;
+            }
+
+            _STD _Seek_wrapped(_Dest, _UDest);
+        }
+    }
+
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _Diff, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 copy_n(_ExPo&&, _FwdIt1 _First, _Diff _Count_raw, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // copy [_First, _First + _Count) to [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD copy_n(_First, _Count_raw, _Dest);
+}
+#endif // _HAS_CXX17
+
+template <class _CtgIt1, class _CtgIt2>
+_CtgIt2 _Copy_backward_memmove(_CtgIt1 _First, _CtgIt1 _Last, _CtgIt2 _Dest) {
+    // implement copy_backward-like function as memmove
+    const auto _First_ptr = _STD _To_address(_First);
+    const auto _Last_ptr  = _STD _To_address(_Last);
+    _STD _Contiguous_iter_verify(_Dest, static_cast<_Iter_diff_t<_CtgIt2>>(_First_ptr - _Last_ptr));
+    const auto _Dest_ptr = _STD _To_address(_Dest);
+    const auto _First_ch = const_cast<const char*>(reinterpret_cast<const volatile char*>(_First_ptr));
+    const auto _Last_ch  = const_cast<const char*>(reinterpret_cast<const volatile char*>(_Last_ptr));
+    const auto _Dest_ch  = const_cast<char*>(reinterpret_cast<const volatile char*>(_Dest_ptr));
+    const auto _Count    = static_cast<size_t>(_Last_ch - _First_ch);
+    const auto _Result   = _CSTD memmove(_Dest_ch - _Count, _First_ch, _Count);
+    if constexpr (is_pointer_v<_CtgIt2>) {
+        return static_cast<_CtgIt2>(_Result);
+    } else {
+        return _Dest - static_cast<_Iter_diff_t<_CtgIt2>>(_Last_ptr - _First_ptr);
+    }
+}
+
+template <class _BidIt1, class _BidIt2>
+_BidIt2 _Copy_backward_memmove(move_iterator<_BidIt1> _First, move_iterator<_BidIt1> _Last, _BidIt2 _Dest) {
+    return _STD _Copy_backward_memmove(_First.base(), _Last.base(), _Dest);
+}
+
+template <class _BidIt1, class _BidIt2>
+_NODISCARD _CONSTEXPR20 _BidIt2 _Copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
+    // copy [_First, _Last) backwards to [..., _Dest)
+    if constexpr (_Iter_copy_cat<_BidIt1, _BidIt2>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _STD _Copy_backward_memmove(_First, _Last, _Dest);
+        }
+    }
+
+    while (_First != _Last) {
+        *--_Dest = *--_Last;
+    }
+
+    return _Dest;
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_CONSTEXPR20 _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
+    // copy [_First, _Last) backwards to [..., _Dest)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _UDest  = _STD _Get_unwrapped_n(_Dest, -_STD _Idl_distance<_BidIt1>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Copy_backward_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
+    // move [_First, _Last) to [_Dest, ...)
+    // note: _Move_unchecked has callers other than the move family
+    if constexpr (_Is_vb_iterator<_InIt> && _Is_vb_iterator<_OutIt, true>) {
+        return _STD _Copy_vbool(_First, _Last, _Dest);
+    } else {
+        if constexpr (_Iter_move_cat<_InIt, _OutIt>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                return _STD _Copy_memmove(_First, _Last, _Dest);
+            }
+        }
+
+        for (; _First != _Last; ++_Dest, (void) ++_First) {
+            *_Dest = _STD move(*_First);
+        }
+
+        return _Dest;
+    }
+}
+
+_EXPORT_STD template <class _InIt, class _OutIt>
+_CONSTEXPR20 _OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest) {
+    // move [_First, _Last) to [_Dest, ...)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _UDest  = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Move_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt2 move(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept /* terminates */ {
+    // move [_First, _Last) to [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt1);
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt2);
+    return _STD move(_First, _Last, _Dest);
+}
+#endif // _HAS_CXX17
+
+template <class _BidIt1, class _BidIt2>
+_CONSTEXPR20 _BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
+    // move [_First, _Last) backwards to [..., _Dest)
+    // note: _Move_backward_unchecked has callers other than the move_backward family
+    if constexpr (_Iter_move_cat<_BidIt1, _BidIt2>::_Bitcopy_assignable) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            return _STD _Copy_backward_memmove(_First, _Last, _Dest);
+        }
+    }
+
+    while (_First != _Last) {
+        *--_Dest = _STD move(*--_Last);
+    }
+
+    return _Dest;
+}
+
+_EXPORT_STD template <class _BidIt1, class _BidIt2>
+_CONSTEXPR20 _BidIt2 move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
+    // move [_First, _Last) backwards to [..., _Dest)
+    _STD _Adl_verify_range(_First, _Last);
+    const auto _UFirst = _STD _Get_unwrapped(_First);
+    const auto _ULast  = _STD _Get_unwrapped(_Last);
+    const auto _UDest  = _STD _Get_unwrapped_n(_Dest, -_STD _Idl_distance<_BidIt1>(_UFirst, _ULast));
+    _STD _Seek_wrapped(_Dest, _STD _Move_backward_unchecked(_UFirst, _ULast, _UDest));
+    return _Dest;
+}
+
+template <class _Ty>
+struct _Is_character : false_type {}; // by default, not a character type
+
+template <>
+struct _Is_character<char> : true_type {}; // chars are characters
+
+template <>
+struct _Is_character<signed char> : true_type {}; // signed chars are also characters
+
+template <>
+struct _Is_character<unsigned char> : true_type {}; // unsigned chars are also characters
+
+#ifdef __cpp_char8_t
+template <>
+struct _Is_character<char8_t> : true_type {}; // UTF-8 code units are sort-of characters
+#endif // defined(__cpp_char8_t)
+
+template <class _Ty>
+struct _Is_character_or_bool : _Is_character<_Ty>::type {};
+
+template <>
+struct _Is_character_or_bool<bool> : true_type {};
+
+template <class _Ty>
+struct _Is_character_or_byte_or_bool : _Is_character_or_bool<_Ty>::type {};
+
+#ifdef __cpp_lib_byte
+template <>
+struct _Is_character_or_byte_or_bool<byte> : true_type {};
+#endif // defined(__cpp_lib_byte)
+
+// _Fill_memset_is_safe determines if _FwdIt and _Ty are eligible for memset optimization in fill.
+// Need to explicitly test for volatile because _Unwrap_enum_t discards qualifiers.
+template <class _FwdIt, class _Ty, bool = _Iterator_is_contiguous<_FwdIt>>
+constexpr bool _Fill_memset_is_safe = conjunction_v<is_scalar<_Ty>,
+    _Is_character_or_byte_or_bool<_Unwrap_enum_t<remove_reference_t<_Iter_ref_t<_FwdIt>>>>,
+    negation<is_volatile<remove_reference_t<_Iter_ref_t<_FwdIt>>>>, is_assignable<_Iter_ref_t<_FwdIt>, const _Ty&>>;
+
+template <class _FwdIt, class _Ty>
+constexpr bool _Fill_memset_is_safe<_FwdIt, _Ty, false> = false;
+
+template <class _FwdIt, class _Ty, bool = _Iterator_is_contiguous<_FwdIt>>
+constexpr bool _Fill_zero_memset_is_safe =
+    conjunction_v<is_scalar<_Ty>, is_scalar<_Iter_value_t<_FwdIt>>, negation<is_member_pointer<_Iter_value_t<_FwdIt>>>,
+        negation<is_volatile<remove_reference_t<_Iter_ref_t<_FwdIt>>>>, is_assignable<_Iter_ref_t<_FwdIt>, const _Ty&>>;
+
+template <class _FwdIt, class _Ty>
+constexpr bool _Fill_zero_memset_is_safe<_FwdIt, _Ty, false> = false;
+
+template <class _CtgIt, class _Ty>
+void _Fill_memset(_CtgIt _Dest, const _Ty _Val, const size_t _Count) {
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Iter_value_t<_CtgIt>) == sizeof(unsigned char));
+    _STD _Contiguous_iter_verify(_Dest, static_cast<_Iter_diff_t<_CtgIt>>(_Count));
+    // implicitly convert (a cast would suppress warnings); also handles _Iter_value_t<_CtgIt> being bool
+    _Iter_value_t<_CtgIt> _Dest_val = _Val;
+    _CSTD memset(_STD _To_address(_Dest), static_cast<unsigned char>(_Dest_val), _Count);
+}
+
+template <class _CtgIt>
+void _Fill_zero_memset(_CtgIt _Dest, const size_t _Count) {
+    _STD _Contiguous_iter_verify(_Dest, static_cast<_Iter_diff_t<_CtgIt>>(_Count));
+    _CSTD memset(_STD _To_address(_Dest), 0, _Count * sizeof(_Iter_value_t<_CtgIt>));
+}
+
+template <class _Ty>
+_NODISCARD bool _Is_all_bits_zero(const _Ty& _Val) {
+    // checks if scalar type has all bits set to zero
+    _STL_INTERNAL_STATIC_ASSERT(is_scalar_v<_Ty> && !is_member_pointer_v<_Ty>);
+    if constexpr (is_null_pointer_v<_Ty>) {
+        return true;
+    } else if constexpr (is_integral_v<_Ty> || is_pointer_v<_Ty>) {
+        return _Val == _Ty{};
+    } else if constexpr (sizeof(_Ty) == 1) {
+        return _STD _Bit_cast<uint8_t>(_Val) == 0;
+    } else if constexpr (sizeof(_Ty) == 2) {
+        return _STD _Bit_cast<uint16_t>(_Val) == 0;
+    } else if constexpr (sizeof(_Ty) == 4) {
+        return _STD _Bit_cast<uint32_t>(_Val) == 0;
+    } else if constexpr (sizeof(_Ty) == 8) {
+        return _STD _Bit_cast<uint64_t>(_Val) == 0;
+    } else {
+        static constexpr _Ty _Zero{};
+        return _CSTD memcmp(&_Val, &_Zero, sizeof(_Ty)) == 0;
+    }
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_CONSTEXPR20 void fill(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
+    // copy _Val through [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    if constexpr (_Is_vb_iterator<_FwdIt, true>) {
+        _STD _Fill_vbool(_First, _Last, _Val);
+    } else {
+        auto _UFirst      = _STD _Get_unwrapped(_First);
+        const auto _ULast = _STD _Get_unwrapped(_Last);
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
+                _STD _Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
+                return;
+            } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
+                if (_STD _Is_all_bits_zero(_Val)) {
+                    _STD _Fill_zero_memset(_UFirst, static_cast<size_t>(_ULast - _UFirst));
+                    return;
+                }
+            }
+        }
+
+        for (; _UFirst != _ULast; ++_UFirst) {
+            *_UFirst = _Val;
+        }
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+void fill(_ExPo&&, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept /* terminates */ {
+    // copy _Val through [_First, _Last)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD fill(_First, _Last, _Val);
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _OutIt, class _Diff, class _Ty>
+_CONSTEXPR20 _OutIt fill_n(_OutIt _Dest, const _Diff _Count_raw, const _Ty& _Val) {
+    // copy _Val _Count times through [_Dest, ...)
+    _Algorithm_int_t<_Diff> _Count = _Count_raw;
+    if (0 < _Count) {
+        if constexpr (_Is_vb_iterator<_OutIt, true>) {
+            const auto _Last = _Dest + static_cast<typename _OutIt::difference_type>(_Count);
+            _STD _Fill_vbool(_Dest, _Last, _Val);
+            return _Last;
+        } else {
+            auto _UDest = _STD _Get_unwrapped_n(_Dest, _Count);
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                if constexpr (_Fill_memset_is_safe<decltype(_UDest), _Ty>) {
+                    _STD _Fill_memset(_UDest, _Val, static_cast<size_t>(_Count));
+                    _STD _Seek_wrapped(_Dest, _UDest + _Count);
+                    return _Dest;
+                } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UDest), _Ty>) {
+                    if (_STD _Is_all_bits_zero(_Val)) {
+                        _STD _Fill_zero_memset(_UDest, static_cast<size_t>(_Count));
+                        _STD _Seek_wrapped(_Dest, _UDest + static_cast<_Iter_diff_t<decltype(_UDest)>>(_Count));
+                        return _Dest;
+                    }
+                }
+            }
+
+            for (; 0 < _Count; --_Count, (void) ++_UDest) {
+                *_UDest = _Val;
+            }
+
+            _STD _Seek_wrapped(_Dest, _UDest);
+        }
+    }
+    return _Dest;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt fill_n(_ExPo&&, _FwdIt _Dest, _Diff _Count_raw, const _Ty& _Val) noexcept /* terminates */ {
+    // copy _Val _Count times through [_Dest, ...)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD fill_n(_Dest, _Count_raw, _Val);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Fill_n_fn {
+        template <class _Ty, output_iterator<const _Ty&> _It>
+        static constexpr _It operator()(_It _First, iter_difference_t<_It> _Count, const _Ty& _Value) {
+            if (_Count > 0) {
+                auto _UFirst = _STD _Get_unwrapped_n(_STD move(_First), _Count);
+                if (!_STD is_constant_evaluated()) {
+                    if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
+                        _STD _Fill_memset(_UFirst, _Value, static_cast<size_t>(_Count));
+                        _STD _Seek_wrapped(_First, _UFirst + _Count); // no need to move since _UFirst is a pointer
+                        return _First;
+                    } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
+                        if (_STD _Is_all_bits_zero(_Value)) {
+                            _STD _Fill_zero_memset(_UFirst, static_cast<size_t>(_Count));
+                            _STD _Seek_wrapped(_First, _UFirst + _Count); // no need to move since _UFirst is a pointer
+                            return _First;
+                        }
+                    }
+                }
+
+                for (; _Count > 0; ++_UFirst, (void) --_Count) {
+                    *_UFirst = _Value;
+                }
+
+                _STD _Seek_wrapped(_First, _STD move(_UFirst));
+            }
+
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Fill_n_fn fill_n;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Ty1, class _Ty2, class = void>
+constexpr bool _Can_compare_with_operator_equal = false;
+
+template <class _Ty1, class _Ty2>
+constexpr bool
+    _Can_compare_with_operator_equal<_Ty1, _Ty2, void_t<decltype(_STD declval<_Ty1&>() == _STD declval<_Ty2&>())>> =
+        true;
+
+template <class _Ty1, class _Ty2>
+constexpr bool _Is_pointer_address_comparable =
+    _Can_compare_with_operator_equal<_Ty1*, _Ty2*>
+    && (_Is_pointer_address_convertible<_Ty1, _Ty2> || _Is_pointer_address_convertible<_Ty2, _Ty1>);
+
+// _Can_memcmp_elements<_Elem1, _Elem2> reports whether `_Elem1 == _Elem2` can be optimized to memcmp.
+// Here, _Elem1 and _Elem2 aren't top-level const, because we remove_const_t before using _Can_memcmp_elements.
+
+// Integral types are eligible for memcmp in very specific cases.
+// * They must be the same size. (`int == long` is eligible; `int == long long` isn't.)
+// * The usual arithmetic conversions must preserve bit patterns. (This is true for `int == unsigned int`,
+//   but false for `short == unsigned short`.)
+#pragma warning(push)
+#pragma warning(disable : 4806) // no value of type 'bool' promoted to type 'char' can equal the given constant
+template <class _Elem1, class _Elem2,
+    bool = sizeof(_Elem1) == sizeof(_Elem2) && is_integral_v<_Elem1> && is_integral_v<_Elem2>>
+constexpr bool _Can_memcmp_elements =
+    is_same_v<_Elem1, bool> || is_same_v<_Elem2, bool> || static_cast<_Elem1>(-1) == static_cast<_Elem2>(-1);
+#pragma warning(pop)
+
+#ifdef __cpp_lib_byte
+// Allow memcmping std::byte.
+// inline is required here as explicit specializations of variable templates are problematic in C++14.
+// However, std::byte is C++17 and above so we are safe.
+template <>
+inline constexpr bool _Can_memcmp_elements<byte, byte, false> = true;
+#endif // defined(__cpp_lib_byte)
+
+// Pointer elements are eligible for memcmp when they point to the same type, ignoring cv-qualification.
+// This handles pointers to object types, pointers to void, and pointers to function types.
+template <class _Ty1, class _Ty2>
+constexpr bool _Can_memcmp_elements<_Ty1*, _Ty2*, false> = _Is_pointer_address_comparable<_Ty1, _Ty2>;
+
+#ifdef __clang__
+template <class _Elem1, class _Elem2>
+constexpr bool _Is_same_and_builtin_trivially_equality_comparable =
+    is_same_v<_Elem1, _Elem2> && __is_trivially_equality_comparable(_Elem1);
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+template <class _Elem1, class _Elem2>
+constexpr bool _Is_same_and_builtin_trivially_equality_comparable = false;
+#endif // ^^^ !defined(__clang__) ^^^
+
+template <class _Elem1, class _Elem2>
+constexpr bool _Can_memcmp_elements<_Elem1, _Elem2, false> =
+    _Is_same_and_builtin_trivially_equality_comparable<_Elem1, _Elem2>;
+
+// _Can_memcmp_elements_with_pred<_Elem1, _Elem2, _Pr> reports whether the memcmp optimization is applicable,
+// given contiguously stored elements. (This avoids having to repeat the metaprogramming that finds the element types.)
+// _Elem1 and _Elem2 aren't top-level const here.
+template <class _Elem1, class _Elem2, class _Pr>
+constexpr bool _Can_memcmp_elements_with_pred = false;
+
+// With equal_to<_Elem3> we need to make sure that both _Elem1 and _Elem2 are convertible to _Elem3 without changing
+// object representation (we use _Iter_copy_cat for this task) and _Elem3 can be safely memcmp'ed with itself
+template <class _Elem1, class _Elem2, class _Elem3>
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<_Elem3>> =
+    _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible
+    && _Can_memcmp_elements<remove_cv_t<_Elem3>, remove_cv_t<_Elem3>>;
+
+// equal_to<> is transparent.
+template <class _Elem1, class _Elem2>
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<>> = _Can_memcmp_elements<_Elem1, _Elem2>;
+
+#if _HAS_CXX20
+// ranges::equal_to is also transparent.
+template <class _Elem1, class _Elem2>
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, _RANGES equal_to> = _Can_memcmp_elements<_Elem1, _Elem2>;
+#endif // _HAS_CXX20
+
+// _Equal_memcmp_is_safe<_Iter1, _Iter2, _Pr> reports whether we can activate the memcmp optimization
+// for arbitrary iterators and predicates.
+// It ignores top-level constness on the iterators and on the elements.
+template <class _Iter1, class _Iter2, class _Pr>
+constexpr bool _Equal_memcmp_is_safe_helper =
+    _Iterators_are_contiguous<_Iter1, _Iter2> && !_Iterator_is_volatile<_Iter1> && !_Iterator_is_volatile<_Iter2>
+    && _Can_memcmp_elements_with_pred<_Iter_value_t<_Iter1>, _Iter_value_t<_Iter2>, _Pr>;
+
+template <class _Iter1, class _Iter2, class _Pr>
+constexpr bool _Equal_memcmp_is_safe =
+    _Equal_memcmp_is_safe_helper<remove_const_t<_Iter1>, remove_const_t<_Iter2>, remove_const_t<_Pr>>;
+
+#if _VECTORIZED_SEARCH || _VECTORIZED_ADJACENT_FIND || _VECTORIZED_FIND_END || _VECTORIZED_FIND_FIRST_OF \
+    || _VECTORIZED_UNIQUE || _VECTORIZED_UNIQUE_COPY
+template <size_t _Size>
+constexpr bool _Is_vector_element_size = _Size == 1 || _Size == 2 || _Size == 4 || _Size == 8;
+
+// Can we activate the vector algorithms for search, adjacent_find, find_end, find_first_of, and default_searcher?
+// (Also used indirectly for unique and unique_copy.)
+template <class _It1, class _It2, class _Pr>
+constexpr bool _Vector_alg_in_search_is_safe =
+    _Equal_memcmp_is_safe<_It1, _It2, _Pr> && _Is_vector_element_size<sizeof(_Iter_value_t<_It1>)>;
+#endif // ^^^ _Vector_alg_in_search_is_safe is available ^^^
+
+template <class _CtgIt1, class _CtgIt2>
+_NODISCARD int _Memcmp_count(_CtgIt1 _First1, _CtgIt2 _First2, const size_t _Count) {
+    _STD _Contiguous_iter_verify(_First1, static_cast<_Iter_diff_t<_CtgIt1>>(_Count));
+    _STD _Contiguous_iter_verify(_First2, static_cast<_Iter_diff_t<_CtgIt2>>(_Count));
+    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Iter_value_t<_CtgIt1>) == sizeof(_Iter_value_t<_CtgIt2>));
+    const auto _First1_ch = reinterpret_cast<const char*>(_STD _To_address(_First1));
+    const auto _First2_ch = reinterpret_cast<const char*>(_STD _To_address(_First2));
+    return _CSTD memcmp(_First1_ch, _First2_ch, _Count * sizeof(_Iter_value_t<_CtgIt1>));
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Pr _Pred) {
+    // compare [_First1, _Last1) to [_First2, ...)
+    _STD _Adl_verify_range(_First1, _Last1);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1));
+    if constexpr (_Equal_memcmp_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _STL_INTERNAL_STATIC_ASSERT(
+                sizeof(_Iter_value_t<decltype(_UFirst1)>) == sizeof(_Iter_value_t<decltype(_UFirst2)>));
+            _STD _Contiguous_iter_verify(_UFirst2, static_cast<_Iter_diff_t<_InIt2>>(_ULast1 - _UFirst1));
+
+            const auto _First1_ch = reinterpret_cast<const char*>(_STD _To_address(_UFirst1));
+            const auto _Size      = reinterpret_cast<const char*>(_STD _To_address(_ULast1)) - _First1_ch;
+            return _CSTD memcmp(_First1_ch, _STD _To_address(_UFirst2), static_cast<size_t>(_Size)) == 0;
+        }
+    }
+
+    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) {
+        if (!_Pred(*_UFirst1, *_UFirst2)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool equal(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2,
+    _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) {
+    // compare [_First1, _Last1) to [_First2, ...)
+    return _STD equal(_First1, _Last1, _First2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2) noexcept
+/* terminates */ {
+    // compare [_First1, _Last1) to [_First2, ...)
+    return _STD equal(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool equal(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
+    // compare [_First1, _Last1) to [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+    if constexpr (_Is_ranges_random_iter_v<_InIt1> && _Is_ranges_random_iter_v<_InIt2>) {
+        if (_ULast1 - _UFirst1 != _ULast2 - _UFirst2) {
+            return false;
+        }
+
+        return _STD equal(_UFirst1, _ULast1, _UFirst2, _STD _Pass_fn(_Pred));
+    } else {
+        for (;;) {
+            if (_UFirst1 == _ULast1) {
+                return _UFirst2 == _ULast2;
+            }
+
+            if (_UFirst2 == _ULast2) {
+                return false;
+            }
+
+            if (!_Pred(*_UFirst1, *_UFirst2)) {
+                return false;
+            }
+
+            ++_UFirst1;
+            ++_UFirst2;
+        }
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool equal(
+    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; // terminates
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 bool equal(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
+    // compare [_First1, _Last1) to [_First2, _Last2)
+    return _STD equal(_First1, _Last1, _First2, _Last2, equal_to<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2) noexcept /* terminates */ {
+    // compare [_First1, _Last1) to [_First2, _Last2)
+    return _STD equal(_STD forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <forward_range _Rng, class _It>
+    _NODISCARD constexpr iterator_t<_Rng> _Rewrap_iterator(_Rng&& _Range, _It&& _Val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_It>, _Unwrapped_iterator_t<_Rng>>);
+
+        if constexpr (is_same_v<remove_cvref_t<_It>, iterator_t<_Rng>>) {
+            return _STD forward<_It>(_Val);
+        } else {
+            auto _Result = _RANGES begin(_Range);
+            _Result._Seek_to(_STD forward<_It>(_Val));
+            return _Result;
+        }
+    }
+
+    _EXPORT_STD template <class _In1, class _In2>
+    struct in_in_result {
+        /* [[no_unique_address]] */ _In1 in1;
+        /* [[no_unique_address]] */ _In2 in2;
+
+        template <_Convertible_from<const _In1&> _IIn1, _Convertible_from<const _In2&> _IIn2>
+        constexpr operator in_in_result<_IIn1, _IIn2>() const& {
+            return {in1, in2};
+        }
+
+        template <_Convertible_from<_In1> _IIn1, _Convertible_from<_In2> _IIn2>
+        constexpr operator in_in_result<_IIn1, _IIn2>() && {
+            return {_STD move(in1), _STD move(in2)};
+        }
+    };
+
+    _EXPORT_STD template <class _In1, class _In2>
+    using mismatch_result = in_in_result<_In1, _In2>;
+
+    template <input_iterator _It1, input_iterator _It2, class _Pr, class _Pj1, class _Pj2>
+        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+    _NODISCARD constexpr mismatch_result<_It1, _It2> _Mismatch_n(
+        _It1 _First1, _It2 _First2, iter_difference_t<_It1> _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        _STL_INTERNAL_CHECK(_Count >= 0);
+#if _VECTORIZED_MISMATCH
+        if constexpr (_Equal_memcmp_is_safe<_It1, _It2, _Pr> && is_same_v<_Pj1, identity>
+                      && is_same_v<_Pj2, identity>) {
+            if (!_STD is_constant_evaluated()) {
+                _STL_INTERNAL_STATIC_ASSERT(sizeof(iter_value_t<_It1>) == sizeof(iter_value_t<_It2>));
+                _STD _Contiguous_iter_verify(_First1, _Count);
+                _STD _Contiguous_iter_verify(_First2, static_cast<iter_difference_t<_It2>>(_Count));
+
+                constexpr size_t _Elem_size = sizeof(iter_value_t<_It1>);
+
+                const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>(
+                    _STD _To_address(_First1), _STD _To_address(_First2), static_cast<size_t>(_Count));
+
+                return {_First1 + static_cast<iter_difference_t<_It1>>(_Pos),
+                    _First2 + static_cast<iter_difference_t<_It2>>(_Pos)};
+            }
+        }
+#endif // ^^^ _VECTORIZED_MISMATCH ^^^
+        for (; _Count != 0; ++_First1, (void) ++_First2, --_Count) {
+            if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                break;
+            }
+        }
+
+        return {_STD move(_First1), _STD move(_First2)};
+    }
+
+    template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2, class _Pr,
+        class _Pj1, class _Pj2>
+        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+    _NODISCARD constexpr mismatch_result<_It1, _It2> _Mismatch_4(
+        _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void) ++_First2) {
+            if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                break;
+            }
+        }
+
+        return {_STD move(_First1), _STD move(_First2)};
+    }
+
+    struct _Mismatch_fn {
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr mismatch_result<_It1, _It2> operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+
+            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
+                iter_difference_t<_It1> _Count1       = _Last1 - _First1;
+                const iter_difference_t<_It2> _Count2 = _Last2 - _First2;
+                if (_Count1 > _Count2) {
+                    _Count1 = static_cast<decltype(_Count1)>(_Count2);
+                }
+
+                auto _Result = _RANGES _Mismatch_n(_STD _Get_unwrapped(_STD move(_First1)),
+                    _STD _Get_unwrapped(_STD move(_First2)), _Count1, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                    _STD _Pass_fn(_Proj2));
+                _STD _Seek_wrapped(_First1, _STD move(_Result.in1));
+                _STD _Seek_wrapped(_First2, _STD move(_Result.in2));
+                return {_STD move(_First1), _STD move(_First2)};
+            } else {
+                auto _Result = _RANGES _Mismatch_4(_RANGES _Unwrap_iter<_Se1>(_STD move(_First1)),
+                    _RANGES _Unwrap_sent<_It1>(_STD move(_Last1)), _RANGES _Unwrap_iter<_Se2>(_STD move(_First2)),
+                    _RANGES _Unwrap_sent<_It2>(_STD move(_Last2)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                    _STD _Pass_fn(_Proj2));
+                _STD _Seek_wrapped(_First1, _STD move(_Result.in1));
+                _STD _Seek_wrapped(_First2, _STD move(_Result.in2));
+                return {_STD move(_First1), _STD move(_First2)};
+            }
+        }
+
+        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr mismatch_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
+                range_difference_t<_Rng1> _Count1       = _RANGES distance(_Range1);
+                const range_difference_t<_Rng2> _Count2 = _RANGES distance(_Range2);
+                if (_Count1 > _Count2) {
+                    _Count1 = static_cast<range_difference_t<_Rng1>>(_Count2);
+                }
+
+                auto _First1 = _RANGES begin(_Range1);
+                auto _First2 = _RANGES begin(_Range2);
+                auto _Result = _RANGES _Mismatch_n(_STD _Get_unwrapped(_STD move(_First1)),
+                    _STD _Get_unwrapped(_STD move(_First2)), _Count1, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1),
+                    _STD _Pass_fn(_Proj2));
+                _STD _Seek_wrapped(_First1, _STD move(_Result.in1));
+                _STD _Seek_wrapped(_First2, _STD move(_Result.in2));
+                return {_STD move(_First1), _STD move(_First2)};
+            } else {
+                auto _First1 = _RANGES begin(_Range1);
+                auto _First2 = _RANGES begin(_Range2);
+                auto _Result = _RANGES _Mismatch_4(_RANGES _Unwrap_range_iter<_Rng1>(_STD move(_First1)),
+                    _Uend(_Range1), _RANGES _Unwrap_range_iter<_Rng2>(_STD move(_First2)), _Uend(_Range2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                _STD _Seek_wrapped(_First1, _STD move(_Result.in1));
+                _STD _Seek_wrapped(_First2, _STD move(_Result.in2));
+                return {_STD move(_First1), _STD move(_First2)};
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Mismatch_fn mismatch;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Elem1, class _Elem2>
+constexpr bool _Lex_compare_memcmp_classify_elements =
+#if _VECTORIZED_MISMATCH
+    is_integral_v<_Elem1> && is_integral_v<_Elem2> && sizeof(_Elem1) == sizeof(_Elem2)
+    && is_unsigned_v<_Elem1> == is_unsigned_v<_Elem2>;
+#else // ^^^ _VECTORIZED_MISMATCH / !_VECTORIZED_MISMATCH vvv
+    conjunction_v<_Is_character_or_bool<_Elem1>, _Is_character_or_bool<_Elem2>, is_unsigned<_Elem1>,
+        is_unsigned<_Elem2>>;
+#endif // ^^^ !_VECTORIZED_MISMATCH ^^^
+
+#ifdef __cpp_lib_byte
+template <>
+inline constexpr bool _Lex_compare_memcmp_classify_elements<byte, byte> = true;
+#endif // defined(__cpp_lib_byte)
+
+template <class _Elem1, class _Elem2, class _Pr>
+struct _Lex_compare_memcmp_classify_pred {
+    using _Pred = void;
+};
+
+template <class _Elem1, class _Elem2, class _Elem3>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, less<_Elem3>> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem3, _Elem3>
+                                    && _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible
+                                    && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible,
+        less<int>, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, less<>> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, less<int>, void>;
+};
+
+template <class _Elem1, class _Elem2, class _Elem3>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, greater<_Elem3>> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem3, _Elem3>
+                                    && _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible
+                                    && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible,
+        greater<int>, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, greater<>> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, greater<int>, void>;
+};
+
+#if _HAS_CXX20
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, _RANGES less> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, less<int>, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, _RANGES greater> {
+    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, greater<int>, void>;
+};
+#endif // _HAS_CXX20
+
+template <class _It1, class _It2, class _Pr>
+using _Lex_compare_memcmp_classify =
+    conditional_t<_Iterators_are_contiguous<_It1, _It2> && !_Iterator_is_volatile<_It1> && !_Iterator_is_volatile<_It2>,
+        typename _Lex_compare_memcmp_classify_pred<_Iter_value_t<_It1>, _Iter_value_t<_It2>, _Pr>::_Pred, void>;
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool lexicographical_compare(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
+    // order [_First1, _Last1) vs. [_First2, _Last2)
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+
+    using _Memcmp_pred = _Lex_compare_memcmp_classify<decltype(_UFirst1), decltype(_UFirst2), _Pr>;
+    if constexpr (!is_void_v<_Memcmp_pred>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            const auto _Num1  = static_cast<size_t>(_STD _Contiguous_iter_distance(_UFirst1, _ULast1));
+            const auto _Num2  = static_cast<size_t>(_STD _Contiguous_iter_distance(_UFirst2, _ULast2));
+            const size_t _Num = (_STD min) (_Num1, _Num2);
+#if _VECTORIZED_MISMATCH
+            const auto _First1_ptr = _STD _To_address(_UFirst1);
+            const auto _First2_ptr = _STD _To_address(_UFirst2);
+            const size_t _Pos      = _Mismatch_vectorized<sizeof(*_First1_ptr)>(_First1_ptr, _First2_ptr, _Num);
+            if (_Pos == _Num2) {
+                return false;
+            } else if (_Pos == _Num1) {
+                return true;
+            } else {
+                return _Pred(_First1_ptr[_Pos], _First2_ptr[_Pos]);
+            }
+#else // ^^^ _VECTORIZED_MISMATCH / !_VECTORIZED_MISMATCH vvv
+            const int _Ans = _STD _Memcmp_count(_UFirst1, _UFirst2, _Num);
+            return _Memcmp_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2);
+#endif // ^^^ !_VECTORIZED_MISMATCH ^^^
+        }
+    }
+
+    for (; _UFirst1 != _ULast1 && _UFirst2 != _ULast2; ++_UFirst1, (void) ++_UFirst2) { // something to compare, do it
+        if (_DEBUG_LT_PRED(_Pred, *_UFirst1, *_UFirst2)) {
+            return true;
+        } else if (_Pred(*_UFirst2, *_UFirst1)) {
+            return false;
+        }
+    }
+
+    return _UFirst1 == _ULast1 && _UFirst2 != _ULast2;
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD _CONSTEXPR20 bool lexicographical_compare(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
+    // order [_First1, _Last1) vs. [_First2, _Last2)
+    return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2, _Pr _Pred) noexcept /* terminates */ {
+    // order [_First1, _Last1) vs. [_First2, _Last2)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
+    const _FwdIt2 _Last2) noexcept /* terminates */ {
+    // order [_First1, _Last1) vs. [_First2, _Last2)
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt1);
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt2);
+    return _STD lexicographical_compare(_First1, _Last1, _First2, _Last2);
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+template <class _Elem1, class _Elem2, class _Cmp>
+struct _Lex_compare_three_way_memcmp_classify_comp {
+    using _Comp = void;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, compare_three_way> {
+    using _Comp = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>
+                                    && three_way_comparable_with<const _Elem1&, const _Elem2&>,
+        compare_three_way, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Synth_three_way> {
+    using _Comp = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>
+                                    && three_way_comparable_with<const _Elem1&, const _Elem2&>,
+        _Synth_three_way, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Strong_order::_Cpo> {
+    using _Comp =
+        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_strong_order<_Elem1, _Elem2>,
+            _Strong_order::_Cpo, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Weak_order::_Cpo> {
+    using _Comp =
+        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_weak_order<_Elem1, _Elem2>,
+            _Weak_order::_Cpo, void>;
+};
+
+template <class _Elem1, class _Elem2>
+struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Partial_order::_Cpo> {
+    using _Comp =
+        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_partial_order<_Elem1, _Elem2>,
+            _Partial_order::_Cpo, void>;
+};
+
+template <class _It1, class _It2, class _Cmp>
+using _Lex_compare_three_way_memcmp_classify =
+    conditional_t<_Iterators_are_contiguous<_It1, _It2> && !_Iterator_is_volatile<_It1> && !_Iterator_is_volatile<_It2>,
+        typename _Lex_compare_three_way_memcmp_classify_comp<_Iter_value_t<_It1>, _Iter_value_t<_It2>, _Cmp>::_Comp,
+        void>;
+
+_EXPORT_STD template <class _InIt1, class _InIt2, class _Cmp>
+_NODISCARD constexpr auto lexicographical_compare_three_way(const _InIt1 _First1, const _InIt1 _Last1,
+    const _InIt2 _First2, const _InIt2 _Last2, _Cmp _Comp) -> decltype(_Comp(*_First1, *_First2)) {
+    static_assert(
+        _Classify_category<decltype(_Comp(*_First1, *_First2))> != _Comparison_category::_Comparison_category_none,
+        "The result of the comparator must have comparison category type (N4988 [alg.three.way]/2).");
+
+    _STD _Adl_verify_range(_First1, _Last1);
+    _STD _Adl_verify_range(_First2, _Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    const auto _ULast1 = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+
+    using _Memcmp_pred = _Lex_compare_three_way_memcmp_classify<decltype(_UFirst1), decltype(_UFirst2), _Cmp>;
+    if constexpr (!is_void_v<_Memcmp_pred>) {
+        if (!_STD is_constant_evaluated()) {
+            const auto _Num1  = static_cast<size_t>(_STD _Contiguous_iter_distance(_UFirst1, _ULast1));
+            const auto _Num2  = static_cast<size_t>(_STD _Contiguous_iter_distance(_UFirst2, _ULast2));
+            const size_t _Num = (_STD min) (_Num1, _Num2);
+#if _VECTORIZED_MISMATCH
+            const auto _First1_ptr = _STD to_address(_UFirst1);
+            const auto _First2_ptr = _STD to_address(_UFirst2);
+            const size_t _Pos      = _Mismatch_vectorized<sizeof(*_First1_ptr)>(_First1_ptr, _First2_ptr, _Num);
+            if (_Pos == _Num1) {
+                return _Pos == _Num2 ? strong_ordering::equal : strong_ordering::less;
+            } else if (_Pos == _Num2) {
+                return strong_ordering::greater;
+            } else {
+                const auto _Val1 = _First1_ptr[_Pos];
+                const auto _Val2 = _First2_ptr[_Pos];
+                __assume(_Val1 != _Val2); // avoid one comparison
+                return _Comp(_Val1, _Val2);
+            }
+#else // ^^^ _VECTORIZED_MISMATCH / !_VECTORIZED_MISMATCH vvv
+            const int _Ans = _STD _Memcmp_count(_UFirst1, _UFirst2, _Num);
+            if (_Ans == 0) {
+                return _Num1 <=> _Num2;
+            } else {
+                return _Memcmp_pred{}(_Ans, 0);
+            }
+#endif // ^^^ !_VECTORIZED_MISMATCH ^^^
+        }
+    }
+
+    for (;;) {
+        if (_UFirst1 == _ULast1) {
+            return _UFirst2 == _ULast2 ? strong_ordering::equal : strong_ordering::less;
+        }
+
+        if (_UFirst2 == _ULast2) {
+            return strong_ordering::greater;
+        }
+
+        if (const auto _CmpResult = _Comp(*_UFirst1, *_UFirst2); _CmpResult != 0) {
+            return _CmpResult;
+        }
+
+        ++_UFirst1;
+        ++_UFirst2;
+    }
+}
+
+_EXPORT_STD template <class _InIt1, class _InIt2>
+_NODISCARD constexpr auto lexicographical_compare_three_way(
+    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
+    return _STD lexicographical_compare_three_way(_First1, _Last1, _First2, _Last2, compare_three_way{});
+}
+#endif // _HAS_CXX20
+
+template <class _Ty, class _Elem>
+struct _Vector_alg_in_find_is_safe_object_pointers : false_type {};
+template <class _Ty1, class _Ty2>
+struct _Vector_alg_in_find_is_safe_object_pointers<_Ty1*, _Ty2*>
+    : conjunction<
+          // _Ty1* is an object pointer type
+          disjunction<is_object<_Ty1>, is_void<_Ty1>>,
+          // _Ty2* is an object pointer type
+          disjunction<is_object<_Ty2>, is_void<_Ty2>>,
+          // either _Ty1 is the same as _Ty2 (ignoring cv-qualifiers), or one of the two is void
+          disjunction<is_same<remove_cv_t<_Ty1>, remove_cv_t<_Ty2>>, is_void<_Ty1>, is_void<_Ty2>>> {};
+
+// Can we activate the vector algorithms to find a value in a range of elements?
+template <class _Ty, class _Elem>
+constexpr bool _Vector_alg_in_find_is_safe_elem =
+    _Is_same_and_builtin_trivially_equality_comparable<_Ty, _Elem>
+    || disjunction_v<
+#ifdef __cpp_lib_byte
+        // We're finding a std::byte in a range of std::byte.
+        conjunction<is_same<_Ty, byte>, is_same<_Elem, byte>>,
+#endif // defined(__cpp_lib_byte)
+       // We're finding an integer in a range of integers.
+       // This case is the one that requires careful runtime handling in _Could_compare_equal_to_value_type.
+        conjunction<is_integral<_Ty>, is_integral<_Elem>>,
+        // We're finding an (object or function) pointer in a range of pointers of the same type.
+        conjunction<is_pointer<_Ty>, is_same<_Ty, _Elem>>,
+        // We're finding a nullptr in a range of (object or function) pointers.
+        conjunction<is_null_pointer<_Ty>, is_pointer<_Elem>>,
+        // We're finding an object pointer in a range of object pointers, and:
+        // - One of the pointer types is a cv void*.
+        // - One of the pointer types is a cv1 U* and the other is a cv2 U*.
+        _Vector_alg_in_find_is_safe_object_pointers<_Ty, _Elem>>;
+
+// Can we activate the vector algorithms for find, count, remove, remove_copy, and ranges::find_last?
+// (Also used indirectly for replace and search_n.)
+template <class _Iter, class _Ty>
+constexpr bool _Vector_alg_in_find_is_safe =
+    // The iterator must be contiguous so we can get raw pointers.
+    _Iterator_is_contiguous<_Iter>
+    // The iterator must not be volatile.
+    && !_Iterator_is_volatile<_Iter>
+    // The type of the value to find must be compatible with the type of the elements.
+    && _Vector_alg_in_find_is_safe_elem<_Ty, _Iter_value_t<_Iter>>;
+
+template <class _InIt, class _Ty>
+_NODISCARD constexpr bool _Could_compare_equal_to_value_type(const _Ty& _Val) {
+    // check whether _Val is within the limits of _Elem
+    _STL_INTERNAL_STATIC_ASSERT(_Vector_alg_in_find_is_safe<_InIt, _Ty>);
+
+    using _Elem = _Iter_value_t<_InIt>;
+
+    if constexpr (disjunction_v<is_same<_Ty, _Elem>, // If types are the same, _Val can compare equal to _Elem
+                      is_same<_Ty, bool>, // true or false can be represented in any integer type
+                      is_pointer<_Ty>, // we only compare pointers vs. other pointers with the same representation
+                      is_null_pointer<_Ty> // we only compare nullptr_t against pointers; any pointer can be null
+                      >) {
+        return true;
+    } else {
+        _STL_INTERNAL_STATIC_ASSERT(is_integral_v<_Elem> && is_integral_v<_Ty>);
+
+        if constexpr (is_same_v<_Elem, bool>) {
+            return _Val == true || _Val == false;
+        } else if constexpr (is_signed_v<_Elem>) {
+            constexpr _Elem _Min = _STD _Min_limit<_Elem>();
+            constexpr _Elem _Max = _STD _Max_limit<_Elem>();
+
+            if constexpr (is_signed_v<_Ty>) {
+                // signed _Elem, signed _Ty
+                return _Min <= _Val && _Val <= _Max;
+            } else {
+                // signed _Elem, unsigned _Ty
+                if constexpr (_Elem{-1} == static_cast<_Ty>(-1)) {
+                    // negative values of _Elem can compare equal to values of _Ty
+                    return _Val <= _Max || static_cast<_Ty>(_Min) <= _Val;
+                } else {
+                    // negative values of _Elem cannot compare equal to values of _Ty
+                    return _Val <= _Max;
+                }
+            }
+        } else {
+            constexpr _Elem _Max = _STD _Max_limit<_Elem>();
+
+            if constexpr (is_unsigned_v<_Ty>) {
+                // unsigned _Elem, unsigned _Ty
+                return _Val <= _Max;
+            } else {
+                // unsigned _Elem, signed _Ty
+                if constexpr (_Ty{-1} == static_cast<_Elem>(-1)) {
+                    // negative values of _Ty can compare equal to values of _Elem
+                    return _Val <= _Max;
+                } else {
+                    // negative values of _Ty cannot compare equal to values of _Elem
+                    return 0 <= _Val && _Val <= _Max;
+                }
+            }
+        }
+    }
+}
+
+template <class _InIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, const _Ty& _Val) {
+    // find first matching _Val; choose optimization
+    // activate optimization for contiguous iterators to most scalar types (possibly const-qualified)
+    if constexpr (_Vector_alg_in_find_is_safe<_InIt, _Ty>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if (!_STD _Could_compare_equal_to_value_type<_InIt>(_Val)) {
+                return _Last;
+            }
+#if _VECTORIZED_FIND
+            const auto _First_ptr = _STD _To_address(_First);
+            const auto _Result    = _STD _Find_vectorized(_First_ptr, _STD _To_address(_Last), _Val);
+            if constexpr (is_pointer_v<_InIt>) {
+                return _Result;
+            } else {
+                return _First + static_cast<_Iter_diff_t<_InIt>>(_Result - _First_ptr);
+            }
+#else // ^^^ _VECTORIZED_FIND / !_VECTORIZED_FIND vvv
+            if constexpr (sizeof(_Iter_value_t<_InIt>) <= 2) {
+                const auto _First_ptr = _STD _To_address(_First);
+                const auto _Count     = static_cast<size_t>(_STD _Contiguous_iter_distance(_First, _Last));
+
+                using _Ptr_t = remove_reference_t<_Iter_ref_t<_InIt>>*;
+                _Ptr_t _Result;
+
+                if constexpr (sizeof(_Iter_value_t<_InIt>) == 1) {
+                    _Result =
+                        static_cast<_Ptr_t>(_CSTD memchr(_First_ptr, _STD _Find_arg_cast<unsigned char>(_Val), _Count));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(sizeof(_Iter_value_t<_InIt>) == 2);
+                    _Result = reinterpret_cast<_Ptr_t>(const_cast<wchar_t*>(_CSTD wmemchr(
+                        reinterpret_cast<const wchar_t*>(_First_ptr), _STD _Find_arg_cast<wchar_t>(_Val), _Count)));
+                }
+
+                if constexpr (is_pointer_v<_InIt>) {
+                    return _Result ? _Result : _Last;
+                } else {
+                    return _Result ? _First + (_Result - _First_ptr) : _Last;
+                }
+            }
+#endif // ^^^ !_VECTORIZED_FIND ^^^
+        }
+    }
+
+    for (; _First != _Last; ++_First) {
+        if (*_First == _Val) {
+            break;
+        }
+    }
+
+    return _First;
+}
+
+_EXPORT_STD template <class _InIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _InIt find(_InIt _First, const _InIt _Last, const _Ty& _Val) { // find first matching _Val
+    _STD _Adl_verify_range(_First, _Last);
+    if constexpr (_Is_vb_iterator<_InIt> && is_same_v<_Ty, bool>) {
+        return _STD _Find_vbool(_First, _Last, _Val);
+    } else {
+        _STD _Seek_wrapped(_First, _STD _Find_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _Val));
+        return _First;
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt find(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept; // terminates
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _Se, class _It>
+    concept _Sized_or_unreachable_sentinel_for = sized_sentinel_for<_Se, _It> || same_as<_Se, unreachable_sentinel_t>;
+
+    template <class _Rng>
+    concept _Sized_or_infinite_range =
+        range<_Rng> && (sized_range<_Rng> || same_as<sentinel_t<_Rng>, unreachable_sentinel_t>);
+
+    // concept-constrained for strict enforcement as it is used by several algorithms
+    template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
+        requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+    _NODISCARD constexpr _It _Find_unchecked(_It _First, const _Se _Last, const _Ty& _Val, _Pj _Proj = {}) {
+        constexpr bool _Elements_are_1_byte  = sizeof(_Iter_value_t<_It>) == 1;
+        constexpr bool _Elements_are_2_bytes = sizeof(_Iter_value_t<_It>) == 2;
+        constexpr bool _Is_sized             = sized_sentinel_for<_Se, _It>;
+
+        if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty> && same_as<_Pj, identity>
+                      && (_Elements_are_1_byte    ? _Is_sized || same_as<_Se, unreachable_sentinel_t>
+                          : _Elements_are_2_bytes ? _Is_sized
+                                                  : _Is_sized && _VECTORIZED_FIND)) {
+            if (!_STD is_constant_evaluated()) {
+                if (!_STD _Could_compare_equal_to_value_type<_It>(_Val)) {
+                    if constexpr (_Is_sized) {
+                        return _RANGES next(_STD move(_First), _Last);
+                    } else {
+                        _STL_ASSERT(false, "Tried to find a value in a range with unreachable sentinel "
+                                           "that cannot be represented by the range's value type");
+                    }
+                }
+
+                using _Ptr_t          = remove_reference_t<_Iter_ref_t<_It>>*;
+                const auto _First_ptr = _STD _To_address(_First);
+
+                _Ptr_t _Result;
+#if _VECTORIZED_FIND
+                if constexpr (_Is_sized) {
+                    // Prefer this over memchr()/wmemchr() below for performance
+                    const auto _Last_ptr = _STD _To_address(_First + (_Last - _First));
+                    _Result              = _STD _Find_vectorized(_First_ptr, _Last_ptr, _Val);
+                } else
+#endif // ^^^ _VECTORIZED_FIND ^^^
+                {
+                    if constexpr (_Elements_are_2_bytes) {
+                        _STL_INTERNAL_STATIC_ASSERT(_Is_sized);
+                        const auto _Wchar_ptr    = reinterpret_cast<const wchar_t*>(_First_ptr);
+                        const auto _Wchar_val    = _STD _Find_arg_cast<wchar_t>(_Val);
+                        const auto _Dist         = static_cast<size_t>(_STD _Contiguous_iter_distance(_First, _Last));
+                        const auto _Const_result = _CSTD wmemchr(_Wchar_ptr, _Wchar_val, _Dist);
+                        _Result                  = reinterpret_cast<_Ptr_t>(const_cast<wchar_t*>(_Const_result));
+                    } else {
+                        _STL_INTERNAL_STATIC_ASSERT(_Elements_are_1_byte);
+                        size_t _Count;
+                        if constexpr (_Is_sized) {
+                            _Count = static_cast<size_t>(_STD _Contiguous_iter_distance(_First, _Last));
+                        } else {
+                            _Count = SIZE_MAX;
+                        }
+
+                        // C23 7.27.5.2 "The memchr generic function"/2 says "The implementation shall behave as if
+                        // it reads the characters sequentially and stops as soon as a matching character is found."
+                        // C23 7.32.4.6.9 "The wmemchr generic function"/2 lacks such wording,
+                        // so we don't use wmemchr(), avoiding issues with unreachable_sentinel_t.
+                        _Result = static_cast<_Ptr_t>(
+                            _CSTD memchr(_First_ptr, _STD _Find_arg_cast<unsigned char>(_Val), _Count));
+                    }
+
+                    if constexpr (_Is_sized) {
+                        if (_Result == nullptr) {
+                            return _RANGES next(_STD move(_First), _Last);
+                        }
+                    }
+                }
+
+                if constexpr (is_pointer_v<_It>) {
+                    return _Result;
+                } else {
+                    return _RANGES next(_STD move(_First), _Result - _First_ptr);
+                }
+            }
+        }
+
+        for (; _First != _Last; ++_First) {
+            if (_STD invoke(_Proj, *_First) == _Val) {
+                break;
+            }
+        }
+
+        return _First;
+    }
+
+    struct _Find_fn {
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _RANGES _Find_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _Val, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <input_range _Rng, class _Ty, class _Pj = identity>
+            requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _RANGES _Find_unchecked(
+                _RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range), _Val, _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_fn find;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _InIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InIt _Last, const _Ty& _Val) {
+    // count elements that match _Val
+    _STD _Adl_verify_range(_First, _Last);
+    if constexpr (_Is_vb_iterator<_InIt> && is_same_v<_Ty, bool>) {
+        return _STD _Count_vbool(_First, _Last, _Val);
+    } else {
+        auto _UFirst      = _STD _Get_unwrapped(_First);
+        const auto _ULast = _STD _Get_unwrapped(_Last);
+
+#if _VECTORIZED_COUNT
+        if constexpr (_Vector_alg_in_find_is_safe<decltype(_UFirst), _Ty>) {
+#if _HAS_CXX20
+            if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+            {
+                if (!_STD _Could_compare_equal_to_value_type<decltype(_UFirst)>(_Val)) {
+                    return 0;
+                }
+
+                return static_cast<_Iter_diff_t<_InIt>>(
+                    _STD _Count_vectorized(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val));
+            }
+        }
+#endif // ^^^ _VECTORIZED_COUNT ^^^
+
+        _Iter_diff_t<_InIt> _Count = 0;
+
+        for (; _UFirst != _ULast; ++_UFirst) {
+            if (*_UFirst == _Val) {
+                ++_Count;
+            }
+        }
+
+        return _Count;
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _Iter_diff_t<_FwdIt> count(
+    _ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept; // terminates
+#endif // _HAS_CXX17
+
+template <class _InIt, class _Ty, class _Pr>
+_NODISCARD constexpr _InIt _Find_pr(_InIt _First, const _InIt _Last, const _Ty& _Val, _Pr _Pred) {
+    for (; _First != _Last; ++_First) {
+        if (_Pred(*_First, _Val)) {
+            break;
+        }
+    }
+
+    return _First;
+}
+
+template <class _InIt, class _Ty, class _Pr>
+_NODISCARD constexpr _Iter_diff_t<_InIt> _Count_pr(_InIt _First, const _InIt _Last, const _Ty& _Val, _Pr _Pred) {
+    _Iter_diff_t<_InIt> _Count = 0;
+
+    for (; _First != _Last; ++_First) {
+        if (_Pred(*_First, _Val)) {
+            ++_Count;
+        }
+    }
+
+    return _Count;
+}
+
+enum class _TrimResult : unsigned char { _KeepTrimming, _HaveWorkAfterTrimming, _ReturnFalse, _ReturnTrue };
+
+template <class _BidIt1, class _BidIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 _TrimResult _Trim_equal(
+    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
+    // advances the iterators, trimming matching prefixes then matching suffixes
+    // from [_First1, _Back1] and [_First2, _Back2]
+    _STL_INTERNAL_CHECK(_First1 != _Back1);
+    _STL_INTERNAL_CHECK(_STD distance(_First1, _Back1) == _STD distance(_First2, _Back2));
+    if (_Pred(*_First1, *_First2)) {
+        do {
+            ++_First1;
+            ++_First2;
+            if (_First1 == _Back1) {
+                // only one element is left
+                return _Pred(*_First1, *_First2) ? _TrimResult::_ReturnTrue : _TrimResult::_ReturnFalse;
+            }
+        } while (_Pred(*_First1, *_First2));
+    } else {
+        if (!_Pred(*_Back1, *_Back2)) {
+            // nothing to trim
+            return _TrimResult::_HaveWorkAfterTrimming;
+        }
+        --_Back1;
+        --_Back2;
+    }
+
+    for (;;) {
+        if (_First1 == _Back1) {
+            // only one element is left, it can't match because it wasn't trimmed by the first loop
+            return _TrimResult::_ReturnFalse;
+        }
+
+        if (!_Pred(*_Back1, *_Back2)) {
+            return _TrimResult::_KeepTrimming;
+        }
+        --_Back1;
+        --_Back2;
+    }
+}
+
+template <class _BidIt1, class _BidIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 _TrimResult _Trim_reversed(
+    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
+    // advances the iterators, trimming each range's prefix that matches the other range's suffix
+    // from [_First1, _Back1] and [_First2, _Back2]
+    _STL_INTERNAL_CHECK(_First1 != _Back1);
+    _STL_INTERNAL_CHECK(_STD distance(_First1, _Back1) == _STD distance(_First2, _Back2));
+    if (_Pred(*_First1, *_Back2)) {
+        do {
+            ++_First1;
+            --_Back2;
+            if (_First1 == _Back1) {
+                // only one element is left
+                return _Pred(*_First1, *_First2) ? _TrimResult::_ReturnTrue : _TrimResult::_ReturnFalse;
+            }
+        } while (_Pred(*_First1, *_Back2));
+    } else {
+        if (!_Pred(*_Back1, *_First2)) {
+            // nothing to trim
+            return _TrimResult::_HaveWorkAfterTrimming;
+        }
+        --_Back1;
+        ++_First2;
+    }
+
+    for (;;) {
+        if (_First1 == _Back1) {
+            // only one element is left, it can't match because it wasn't trimmed by the first loop
+            return _TrimResult::_ReturnFalse;
+        }
+
+        if (!_Pred(*_Back1, *_First2)) {
+            return _TrimResult::_KeepTrimming;
+        }
+        --_Back1;
+        ++_First2;
+    }
+}
+
+template <class _BidIt1, class _BidIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 _TrimResult _Trim_completely(
+    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
+    // alternates between calling _Trim_reversed and _Trim_equal until no more trimming is possible
+    _TrimResult _Res = _TrimResult::_KeepTrimming;
+
+    for (bool _Check_reversed = true; _Res == _TrimResult::_KeepTrimming; _Check_reversed = !_Check_reversed) {
+        if (_Check_reversed) {
+            _Res = _STD _Trim_reversed(_First1, _Back1, _First2, _Back2, _Pred);
+        } else {
+            _Res = _STD _Trim_equal(_First1, _Back1, _First2, _Back2, _Pred);
+        }
+    }
+
+    return _Res;
+}
+
+template <class _FwdIt1, class _FwdIt2, class _Pr>
+_NODISCARD _CONSTEXPR20 bool _Check_match_counts(
+    _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) {
+    // test if [_First1, _Last1) == permuted [_First2, _Last2), after matching prefix removal
+    _STL_INTERNAL_CHECK(!_Pred(*_First1, *_First2));
+    _STL_INTERNAL_CHECK(_STD distance(_First1, _Last1) == _STD distance(_First2, _Last2));
+    if constexpr (_Is_ranges_bidi_iter_v<_FwdIt1> && _Is_ranges_bidi_iter_v<_FwdIt2>) {
+        do { // find last inequality
+            --_Last1;
+            --_Last2;
+        } while (_Pred(*_Last1, *_Last2));
+
+        if (_First1 == _Last1) {
+            return false;
+        }
+
+        const _TrimResult _Res = _STD _Trim_completely(_First1, _Last1, _First2, _Last2, _Pred);
+
+        if (_Res != _TrimResult::_HaveWorkAfterTrimming) {
+            return _Res == _TrimResult::_ReturnTrue;
+        }
+
+        ++_Last1;
+        ++_Last2;
+    }
+
+    for (_FwdIt1 _Next1 = _First1; _Next1 != _Last1; ++_Next1) {
+        if (_Next1 == _STD _Find_pr(_First1, _Next1, *_Next1, _Pred)) { // new value, compare match counts
+            _Iter_diff_t<_FwdIt2> _Count2 = _STD _Count_pr(_First2, _Last2, *_Next1, _Pred);
+            if (_Count2 == 0) {
+                return false; // second range lacks value, not a permutation
+            }
+
+            _FwdIt1 _Skip1                = _STD _Next_iter(_Next1);
+            _Iter_diff_t<_FwdIt1> _Count1 = _STD _Count_pr(_Skip1, _Last1, *_Next1, _Pred) + 1;
+            if (_Count2 != _Count1) {
+                return false; // match counts differ, not a permutation
+            }
+        }
+    }
+
+    return true;
+}
+
+_EXPORT_STD template <class _BidIt>
+_CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse elements in [_First, _Last)
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _ULast  = _STD _Get_unwrapped(_Last);
+#if _VECTORIZED_REVERSE
+    using _Elem                         = remove_reference_t<_Iter_ref_t<decltype(_UFirst)>>;
+    constexpr bool _Allow_vectorization = conjunction_v<bool_constant<_Iterator_is_contiguous<decltype(_UFirst)>>,
+        _Is_trivially_swappable<_Elem>, negation<is_volatile<_Elem>>>;
+    constexpr size_t _Nx                = sizeof(_Elem);
+
+    if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            _STD _Reverse_vectorized<_Nx>(_STD _To_address(_UFirst), _STD _To_address(_ULast));
+            return;
+        }
+    }
+#endif // ^^^ _VECTORIZED_REVERSE ^^^
+
+    for (; _UFirst != _ULast && _UFirst != --_ULast; ++_UFirst) {
+        swap(*_UFirst, *_ULast); // intentional ADL
+    }
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+void reverse(_ExPo&&, _BidIt _First, _BidIt _Last) noexcept /* terminates */ {
+    // reverse elements in [_First, _Last)
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_BIDIRECTIONAL_ITERATOR(_BidIt);
+    return _STD reverse(_First, _Last);
+}
+#endif // _HAS_CXX17
+
+template <class _BidIt>
+constexpr pair<_BidIt, _BidIt> _Reverse_until_sentinel_unchecked(_BidIt _First, _BidIt _Sentinel, _BidIt _Last) {
+    // reverse until either _First or _Last hits _Sentinel
+    while (_First != _Sentinel && _Last != _Sentinel) {
+        swap(*_First, *--_Last); // intentional ADL
+        ++_First;
+    }
+
+    return pair<_BidIt, _BidIt>(_First, _Last);
+}
+
+_EXPORT_STD template <class _FwdIt>
+_CONSTEXPR20 _FwdIt rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last) {
+    // exchange the ranges [_First, _Mid) and [_Mid, _Last)
+    // that is, rotates [_First, _Last) left by distance(_First, _Mid) positions
+    // returns the iterator pointing at *_First's new home
+    _STD _Adl_verify_range(_First, _Mid);
+    _STD _Adl_verify_range(_Mid, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    auto _UMid        = _STD _Get_unwrapped(_Mid);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    if (_UFirst == _UMid) {
+        return _Last;
+    }
+
+    if (_UMid == _ULast) {
+        return _First;
+    }
+
+    if constexpr (_Is_cpp17_random_iter_v<_FwdIt>) {
+#if _VECTORIZED_ROTATE
+        using _Elem = remove_reference_t<_Iter_ref_t<decltype(_UFirst)>>;
+
+        if constexpr (conjunction_v<bool_constant<_Iterator_is_contiguous<decltype(_UFirst)>>,
+                          _Is_trivially_swappable<_Elem>, negation<is_volatile<_Elem>>>) {
+            if (!_STD _Is_constant_evaluated()) {
+                ::__std_rotate(_STD _To_address(_UFirst), _STD _To_address(_UMid), _STD _To_address(_ULast));
+                return _First + (_Last - _Mid);
+            }
+        }
+#endif // ^^^ _VECTORIZED_ROTATE ^^^
+        _STD reverse(_UFirst, _UMid);
+        _STD reverse(_UMid, _ULast);
+        _STD reverse(_UFirst, _ULast);
+        _STD _Seek_wrapped(_First, _UFirst + (_ULast - _UMid));
+    } else if constexpr (_Is_cpp17_bidi_iter_v<_FwdIt>) {
+        _STD reverse(_UFirst, _UMid);
+        _STD reverse(_UMid, _ULast);
+        auto _Tmp = _STD _Reverse_until_sentinel_unchecked(_UFirst, _UMid, _ULast);
+        _STD reverse(_Tmp.first, _Tmp.second);
+        _STD _Seek_wrapped(_First, _UMid != _Tmp.first ? _Tmp.first : _Tmp.second);
+    } else {
+        auto _UNext = _UMid;
+        do { // rotate the first cycle
+            swap(*_UFirst, *_UNext); // intentional ADL
+            ++_UFirst;
+            ++_UNext;
+            if (_UFirst == _UMid) {
+                _UMid = _UNext;
+            }
+        } while (_UNext != _ULast);
+        _STD _Seek_wrapped(_First, _UFirst);
+        while (_UMid != _ULast) { // rotate subsequent cycles
+            _UNext = _UMid;
+            do {
+                swap(*_UFirst, *_UNext); // intentional ADL
+                ++_UFirst;
+                ++_UNext;
+                if (_UFirst == _UMid) {
+                    _UMid = _UNext;
+                }
+            } while (_UNext != _ULast);
+        }
+    }
+
+    return _First;
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_FwdIt rotate(_ExPo&&, _FwdIt _First, _FwdIt _Mid, _FwdIt _Last) noexcept /* terminates */ {
+    // rotate [_First, _Last) left by distance(_First, _Mid) positions
+    // not parallelized as benchmarks show it isn't worth it
+    _REQUIRE_CPP17_MUTABLE_ITERATOR(_FwdIt);
+    return _STD rotate(_First, _Mid, _Last);
+}
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _InIt, class _Pr>
+_NODISCARD _CONSTEXPR20 _InIt find_if(_InIt _First, const _InIt _Last, _Pr _Pred) { // find first satisfying _Pred
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst      = _STD _Get_unwrapped(_First);
+    const auto _ULast = _STD _Get_unwrapped(_Last);
+    for (; _UFirst != _ULast; ++_UFirst) {
+        if (_Pred(*_UFirst)) {
+            break;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _Result, class _Wrapped, class _Unwrapped>
+    _NODISCARD constexpr _Result _Rewrap_subrange(_Wrapped& _Val, subrange<_Unwrapped>&& _UResult) {
+        // conditionally computes a wrapped subrange from a wrapped iterator or range and unwrapped subrange
+        if constexpr (is_same_v<_Result, dangling>) {
+            return dangling{};
+        } else if constexpr (is_same_v<_Result, subrange<_Unwrapped>>) {
+            return _STD move(_UResult);
+        } else if constexpr (range<_Wrapped>) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_range<_Wrapped>);
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Unwrapped, _Unwrapped_iterator_t<_Wrapped>>);
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Result, subrange<iterator_t<_Wrapped>>>);
+
+            auto _First = _RANGES begin(_Val);
+            auto _Last  = _First;
+            _First._Seek_to(_UResult.begin());
+            _Last._Seek_to(_UResult.end());
+            return _Result{_STD move(_First), _STD move(_Last)};
+        } else {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Unwrapped, _Unwrapped_t<_Wrapped>>);
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Result, subrange<_Wrapped>>);
+
+            auto _Last = _Val;
+            _Val._Seek_to(_UResult.begin());
+            _Last._Seek_to(_UResult.end());
+            return _Result{_STD move(_Val), _STD move(_Last)};
+        }
+    }
+
+    // concept-constrained for strict enforcement as it is used by several algorithms
+    template <input_iterator _It, sentinel_for<_It> _Se, class _Pj, indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+    _NODISCARD constexpr _It _Find_if_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+        for (; _First != _Last; ++_First) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                break;
+            }
+        }
+
+        return _First;
+    }
+
+    struct _Find_if_fn {
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            auto _UResult = _RANGES _Find_if_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            auto _First   = _RANGES begin(_Range);
+            auto _UResult = _RANGES _Find_if_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)),
+                _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_if_fn find_if;
+
+    class _Find_if_not_fn {
+    public:
+        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            auto _UResult = _Find_if_not_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) {
+            auto _First = _RANGES begin(_Range);
+
+            auto _UResult = _Find_if_not_unchecked(_RANGES _Unwrap_range_iter<_Rng>(_STD move(_First)), _Uend(_Range),
+                _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr _It _Find_if_not_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
+
+            for (; _First != _Last; ++_First) {
+                if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                    break;
+                }
+            }
+
+            return _First;
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Find_if_not_fn find_if_not;
+
+    class _Adjacent_find_fn {
+    public:
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_binary_predicate<projected<_It, _Pj>, projected<_It, _Pj>> _Pr = ranges::equal_to>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+
+            auto _UResult = _Adjacent_find_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            _STD _Seek_wrapped(_First, _STD move(_UResult));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_binary_predicate<projected<iterator_t<_Rng>, _Pj>, projected<iterator_t<_Rng>, _Pj>> _Pr =
+                ranges::equal_to>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UResult =
+                _Adjacent_find_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+
+    private:
+        template <class _It, class _Se, class _Pj, class _Pr>
+        _NODISCARD static constexpr _It _Adjacent_find_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+            // find first satisfying _Pred with successor
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+            _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<_Pr, projected<_It, _Pj>, projected<_It, _Pj>>);
+
+            if (_First == _Last) {
+                return _First;
+            }
+
+#if _VECTORIZED_ADJACENT_FIND
+            if constexpr (_Vector_alg_in_search_is_safe<_It, _It, _Pr> && sized_sentinel_for<_Se, _It>
+                          && is_same_v<_Pj, identity>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _First_ptr = _STD _To_address(_First);
+                    const auto _Last_ptr  = _STD _To_address(_First + (_Last - _First));
+
+                    const auto _Result = _STD _Adjacent_find_vectorized(_First_ptr, _Last_ptr);
+                    if constexpr (is_pointer_v<_It>) {
+                        return _Result;
+                    } else {
+                        return _First + static_cast<iter_difference_t<_It>>(_Result - _First_ptr);
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_ADJACENT_FIND ^^^
+
+            for (auto _Next = _First;; ++_First) {
+                if (++_Next == _Last) {
+                    return _Next;
+                }
+
+                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Next))) {
+                    return _First;
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Adjacent_find_fn adjacent_find;
+
+    template <forward_iterator _It1, input_iterator _It2, sentinel_for<_It2> _Se2, class _Pr, class _Pj1, class _Pj2>
+        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+    _NODISCARD constexpr pair<bool, _It1> _Equal_rev_pred(
+        _It1 _First1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        // Returns {true, _First1 + (_Last2 - _First2)} if [_First1, ...) equals [_First2, _Last2), and {false, {}}
+        // otherwise.
+        for (; _First2 != _Last2; ++_First1, (void) ++_First2) {
+            if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
+                return {false, _It1 {}};
+            }
+        }
+
+        return {true, _STD move(_First1)};
+    }
+
+    class _Search_fn {
+    public:
+        template <forward_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
+            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
+            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr subrange<_It1> operator()(
+            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            _STD _Adl_verify_range(_First1, _Last1);
+            _STD _Adl_verify_range(_First2, _Last2);
+            auto _UFirst1 = _RANGES _Unwrap_iter<_Se1>(_STD move(_First1));
+            auto _ULast1  = _RANGES _Unwrap_sent<_It1>(_STD move(_Last1));
+            auto _UFirst2 = _RANGES _Unwrap_iter<_Se2>(_STD move(_First2));
+            auto _ULast2  = _RANGES _Unwrap_sent<_It2>(_STD move(_Last2));
+
+            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
+                const auto _Count1 = _ULast1 - _UFirst1;
+                const auto _Count2 = _ULast2 - _UFirst2;
+                auto _UResult = _Search_sized(_STD move(_UFirst1), _STD move(_ULast1), _Count1, _STD move(_UFirst2),
+                    _STD move(_ULast2), _Count2, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<subrange<_It1>>(_First1, _STD move(_UResult));
+            } else {
+                auto _UResult = _Search_unsized(_STD move(_UFirst1), _STD move(_ULast1), _STD move(_UFirst2),
+                    _STD move(_ULast2), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<subrange<_It1>>(_First1, _STD move(_UResult));
+            }
+        }
+
+        template <forward_range _Rng1, forward_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
+            class _Pj2 = identity>
+            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
+        _NODISCARD static constexpr borrowed_subrange_t<_Rng1> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
+            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
+                const auto _Count1 = _RANGES distance(_Range1);
+                const auto _Count2 = _RANGES distance(_Range2);
+                auto _UResult      = _Search_sized(_Ubegin(_Range1), _Uend(_Range1), _Count1, _Ubegin(_Range2),
+                    _Uend(_Range2), _Count2, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, _STD move(_UResult));
+            } else {
+                auto _UResult = _Search_unsized(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
+                    _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj1), _STD _Pass_fn(_Proj2));
+                return _RANGES _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, _STD move(_UResult));
+            }
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr subrange<_It1> _Search_sized(_It1 _First1, const _Se1 _Last1,
+            iter_difference_t<_It1> _Count1, _It2 _First2, const _Se2 _Last2, const iter_difference_t<_It2> _Count2,
+            _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First1, _Last1) == _Count1);
+            _STL_INTERNAL_CHECK(_RANGES distance(_First2, _Last2) == _Count2);
+
+#if _VECTORIZED_SEARCH
+            if constexpr (_Vector_alg_in_search_is_safe<_It1, _It2, _Pr> && is_same_v<_Pj1, identity>
+                          && is_same_v<_Pj2, identity>) {
+                if (!_STD is_constant_evaluated()) {
+                    _STD _Contiguous_iter_verify(_First2, _Count2);
+
+                    const auto _Ptr1 = _STD to_address(_First1);
+                    const auto _Ptr2 = _STD to_address(_First2);
+                    remove_const_t<decltype(_Ptr1)> _Ptr_last1;
+
+                    if constexpr (is_same_v<_It1, _Se1>) {
+                        _Ptr_last1 = _STD to_address(_Last1);
+                    } else {
+                        _Ptr_last1 = _STD to_address(_First1 + _Count1);
+                    }
+
+                    const auto _Ptr_res1 =
+                        _STD _Search_vectorized(_Ptr1, _Ptr_last1, _Ptr2, static_cast<size_t>(_Count2));
+
+                    if constexpr (is_pointer_v<_It1>) {
+                        if (_Ptr_res1 != _Ptr_last1) {
+                            return {_Ptr_res1, _Ptr_res1 + _Count2};
+                        } else {
+                            return {_Ptr_res1, _Ptr_res1};
+                        }
+                    } else {
+                        _First1 += static_cast<iter_difference_t<_It1>>(_Ptr_res1 - _Ptr1);
+                        if (_First1 != _Last1) {
+                            return {_First1, _First1 + static_cast<iter_difference_t<_It1>>(_Count2)};
+                        } else {
+                            return {_First1, _First1};
+                        }
+                    }
+                }
+            }
+#endif // ^^^ _VECTORIZED_SEARCH ^^^
+
+            for (; _Count1 >= _Count2; ++_First1, (void) --_Count1) {
+                auto _Match_and_mid1 = _RANGES _Equal_rev_pred(_First1, _First2, _Last2, _Pred, _Proj1, _Proj2);
+                if (_Match_and_mid1.first) {
+                    return {_STD move(_First1), _STD move(_Match_and_mid1.second)};
+                }
+            }
+
+            _First1 = _RANGES _Find_last_iterator(_First1, _Last1, _Count1);
+            return {_First1, _First1};
+        }
+
+        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
+        _NODISCARD static constexpr subrange<_It1> _Search_unsized(
+            _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
+
+            for (;; ++_First1) {
+                auto _Mid1 = _First1;
+                for (auto _Mid2 = _First2;; ++_Mid1, (void) ++_Mid2) {
+                    if (_Mid2 == _Last2) { // match
+                        return {_STD move(_First1), _STD move(_Mid1)};
+                    }
+
+                    if (_Mid1 == _Last1) { // not enough haystack left to find a match
+                        return {_Mid1, _Mid1};
+                    }
+
+                    if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_Mid1), _STD invoke(_Proj2, *_Mid2))) { // mismatch
+                        break;
+                    }
+                }
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Search_fn search;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _Iter, class _Elem = _Iter_value_t<_Iter>>
+constexpr bool _Is_min_max_iterators_safe =
+    _Iterator_is_contiguous<_Iter> // The iterator must be contiguous so we can get raw pointers.
+    && !_Iterator_is_volatile<_Iter> // The iterator must not be volatile.
+    && disjunction_v<
+#if _USE_STD_VECTOR_FLOATING_ALGORITHMS
+#if defined(__LDBL_DIG__) && __LDBL_DIG__ == 18
+        is_same<_Elem, float>, is_same<_Elem, double>,
+#else // ^^^ 80-bit long double (not supported by MSVC in general, see GH-1316) / 64-bit long double vvv
+        is_floating_point<_Elem>, // Element is floating-point or...
+#endif // ^^^ 64-bit long double ^^^
+#endif // _USE_STD_VECTOR_FLOATING_ALGORITHMS
+        is_integral<_Elem>, is_pointer<_Elem>>; // ... integral or pointer type.
+
+template <class _Iter, class _Pr>
+constexpr bool _Is_predicate_less = _Is_any_of_v<_Pr,
+#if _HAS_CXX20
+    _RANGES less,
+#endif // _HAS_CXX20
+    less<>, less<_Iter_value_t<_Iter>>>;
+
+template <class _Iter, class _Pr>
+constexpr bool _Is_predicate_greater = _Is_any_of_v<_Pr,
+#if _HAS_CXX20
+    _RANGES greater,
+#endif // _HAS_CXX20
+    greater<>, greater<_Iter_value_t<_Iter>>>;
+
+#if _VECTORIZED_MINMAX_ELEMENT_64BIT_INT
+template <class _Ty>
+_INLINE_VAR constexpr bool _Is_64bit_int_excluded_from_min_max_element_optimization = false;
+#else // ^^^ _VECTORIZED_MINMAX_ELEMENT_64BIT_INT / !_VECTORIZED_MINMAX_ELEMENT_64BIT_INT vvv
+template <class _Ty>
+_INLINE_VAR constexpr bool _Is_64bit_int_excluded_from_min_max_element_optimization =
+    sizeof(_Ty) == 8 && !is_floating_point_v<_Ty>;
+#endif // ^^^ !_VECTORIZED_MINMAX_ELEMENT_64BIT_INT ^^^
+
+template <class _Iter, class _Pr>
+constexpr bool _Is_min_max_optimization_safe = // Activate the vector algorithms for min_/max_element?
+    _Is_min_max_iterators_safe<_Iter> && _Is_predicate_less<_Iter, _Pr>
+    && !_Is_64bit_int_excluded_from_min_max_element_optimization<_Iter_value_t<_Iter>>;
+
+// Unlike the position-based vectorized implementation, the value-based vectorized implementation
+// does not always produce the expected results for floating-point types.
+//
+// Efficient vectorization needs to find the vertical minmax first, and then the horizontal one.
+// This alters the order of comparison: index zero element is first compared against
+// vector size equal index element and only in the end against index one element.
+// With equivalent but distinguishable +0.0 and -0.0 values, the altered comparison order
+// will not produce the expected result in some cases (will return +0.0 instead of -0.0 or the reverse).
+//
+// The result is still acceptable for /fp:fast when +0.0 / -0.0 are not expected to be properly distinguished,
+// and the compiler itself takes advantage of it.
+template <class _Iter, class _Pr, class _Elem = _Iter_value_t<_Iter>>
+constexpr bool _Is_min_max_value_optimization_safe = // Activate the vector algorithms for ranges::min/max?
+#ifndef _M_FP_FAST
+    !is_floating_point_v<_Elem> &&
+#endif // ^^^ !defined(_M_FP_FAST) ^^^
+    _Is_min_max_iterators_safe<_Iter> && _Is_predicate_less<_Iter, _Pr>;
+
+template <class _FwdIt, class _Pr>
+constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find largest element
+#if _VECTORIZED_MINMAX_ELEMENT
+    if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            const auto _First_ptr = _STD _To_address(_First);
+            const auto _Result    = _STD _Max_element_vectorized(_First_ptr, _STD _To_address(_Last));
+            if constexpr (is_pointer_v<_FwdIt>) {
+                return _Result;
+            } else {
+                return _First + static_cast<_Iter_diff_t<_FwdIt>>(_Result - _First_ptr);
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+    _FwdIt _Found = _First;
+    if (_First != _Last) {
+        while (++_First != _Last) {
+            if (_DEBUG_LT_PRED(_Pred, *_Found, *_First)) {
+                _Found = _First;
+            }
+        }
+    }
+
+    return _Found;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD constexpr _FwdIt max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find largest element
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Seek_wrapped(_First,
+        _STD _Max_element_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD constexpr _FwdIt max_element(_FwdIt _First, _FwdIt _Last) { // find largest element
+    return _STD max_element(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt max_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find largest element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD max_element(_First, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt max_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
+    // find largest element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD max_element(_First, _Last);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It, class _Se, class _Pr, class _Pj>
+    _NODISCARD constexpr _It _Max_element_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+        _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+        _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>);
+
+#if _VECTORIZED_MINMAX_ELEMENT
+        if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
+                      && sized_sentinel_for<_Se, _It>) {
+            if (!_STD is_constant_evaluated()) {
+                const auto _First_ptr = _STD to_address(_First);
+                const auto _Last_ptr  = _STD to_address(_First + (_Last - _First));
+                const auto _Result    = _STD _Max_element_vectorized(_First_ptr, _Last_ptr);
+                if constexpr (is_pointer_v<_It>) {
+                    return _Result;
+                } else {
+                    return _First + static_cast<iter_difference_t<_It>>(_Result - _First_ptr);
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+        auto _Found = _First;
+        if (_First == _Last) {
+            return _Found;
+        }
+
+        while (++_First != _Last) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_Found), _STD invoke(_Proj, *_First))) {
+                _Found = _First;
+            }
+        }
+
+        return _Found;
+    }
+
+    struct _Max_element_fn {
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            _STD _Seek_wrapped(
+                _First, _RANGES _Max_element_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                            _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UResult = _RANGES _Max_element_unchecked(
+                _Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Max_element_fn max_element;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
+    // return leftmost/largest
+    _STL_ASSERT(
+        _Ilist.size() != 0, "An initializer_list passed to std::max must not be empty. (N4971 [alg.min.max]/13)");
+#if _VECTORIZED_MINMAX
+    if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            return static_cast<_Ty>(_STD _Max_vectorized(_Ilist.begin(), _Ilist.end()));
+        }
+    }
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+    const _Ty* _Res = _STD _Max_element_unchecked(_Ilist.begin(), _Ilist.end(), _STD _Pass_fn(_Pred));
+    return *_Res;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist) {
+    // return leftmost/largest
+    return (_STD max) (_Ilist, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It>
+    concept _Prefer_iterator_copies = // When we have a choice, should we copy iterators or copy elements?
+                                      // pre: input_iterator<_It>
+        sizeof(_It) <= 2 * sizeof(iter_value_t<_It>)
+        && (is_trivially_copyable_v<_It> || !is_trivially_copyable_v<iter_value_t<_It>>);
+
+    struct _Max_fn {
+        template <class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr const _Ty& operator()(const _Ty& _Left _MSVC_LIFETIMEBOUND,
+            const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred = {}, _Pj _Proj = {}) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, _Left), _STD invoke(_Proj, _Right))) {
+                return _Right;
+            } else {
+                return _Left;
+            }
+        }
+
+        template <copyable _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr _Ty operator()(initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _First = _Range.begin();
+            const auto _Last  = _Range.end();
+            _STL_ASSERT(_First != _Last,
+                "An initializer_list passed to std::ranges::max must not be empty. (N4971 [alg.min.max]/13)");
+#if _VECTORIZED_MINMAX
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+                if (!_STD is_constant_evaluated()) {
+                    return static_cast<_Ty>(_STD _Max_vectorized(_First, _Last));
+                }
+            }
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+            return *_RANGES _Max_element_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+            requires indirectly_copyable_storable<iterator_t<_Rng>, range_value_t<_Rng>*>
+        _NODISCARD static constexpr range_value_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UFirst = _Ubegin(_Range);
+            auto _ULast  = _Uend(_Range);
+            _STL_ASSERT(
+                _UFirst != _ULast, "A range passed to std::ranges::max must not be empty. (N4971 [alg.min.max]/13)");
+#if _VECTORIZED_MINMAX
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<decltype(_UFirst), _Pr>
+                          && sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _First_ptr = _STD to_address(_UFirst);
+                    const auto _Last_ptr  = _STD to_address(_UFirst + (_ULast - _UFirst));
+                    return static_cast<range_value_t<_Rng>>(_STD _Max_vectorized(_First_ptr, _Last_ptr));
+                }
+            }
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<decltype(_UFirst)>) {
+                return static_cast<range_value_t<_Rng>>(*_RANGES _Max_element_unchecked(
+                    _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)));
+            } else {
+                range_value_t<_Rng> _Found(*_UFirst);
+                while (++_UFirst != _ULast) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, _Found), _STD invoke(_Proj, *_UFirst))) {
+                        _Found = *_UFirst;
+                    }
+                }
+
+                return _Found;
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Max_fn max;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+template <class _FwdIt, class _Pr>
+constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find smallest element
+#if _VECTORIZED_MINMAX_ELEMENT
+    if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            const auto _First_ptr = _STD _To_address(_First);
+            const auto _Result    = _STD _Min_element_vectorized(_First_ptr, _STD _To_address(_Last));
+            if constexpr (is_pointer_v<_FwdIt>) {
+                return _Result;
+            } else {
+                return _First + static_cast<_Iter_diff_t<_FwdIt>>(_Result - _First_ptr);
+            }
+        }
+    }
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+    _FwdIt _Found = _First;
+    if (_First != _Last) {
+        while (++_First != _Last) {
+            if (_DEBUG_LT_PRED(_Pred, *_First, *_Found)) {
+                _Found = _First;
+            }
+        }
+    }
+
+    return _Found;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Pr>
+_NODISCARD constexpr _FwdIt min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find smallest element
+    _STD _Adl_verify_range(_First, _Last);
+    _STD _Seek_wrapped(_First,
+        _STD _Min_element_unchecked(_STD _Get_unwrapped(_First), _STD _Get_unwrapped(_Last), _STD _Pass_fn(_Pred)));
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt>
+_NODISCARD constexpr _FwdIt min_element(_FwdIt _First, _FwdIt _Last) { // find smallest element
+    return _STD min_element(_First, _Last, less<>{});
+}
+
+#if _HAS_CXX17
+_EXPORT_STD template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt min_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept /* terminates */ {
+    // find smallest element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD min_element(_First, _Last, _STD _Pass_fn(_Pred));
+}
+
+_EXPORT_STD template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
+_NODISCARD _FwdIt min_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept /* terminates */ {
+    // find smallest element
+    // not parallelized at present, parallelism expected to be feasible in a future release
+    _REQUIRE_PARALLEL_ITERATOR(_FwdIt);
+    return _STD min_element(_First, _Last);
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    template <class _It, class _Se, class _Pr, class _Pj>
+    _NODISCARD constexpr _It _Min_element_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
+        _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It>);
+        _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
+        _STL_INTERNAL_STATIC_ASSERT(indirect_strict_weak_order<_Pr, projected<_It, _Pj>>);
+
+#if _VECTORIZED_MINMAX_ELEMENT
+        if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
+                      && sized_sentinel_for<_Se, _It>) {
+            if (!_STD is_constant_evaluated()) {
+                const auto _First_ptr = _STD to_address(_First);
+                const auto _Last_ptr  = _STD to_address(_First + (_Last - _First));
+                const auto _Result    = _STD _Min_element_vectorized(_First_ptr, _Last_ptr);
+                if constexpr (is_pointer_v<_It>) {
+                    return _Result;
+                } else {
+                    return _First + static_cast<iter_difference_t<_It>>(_Result - _First_ptr);
+                }
+            }
+        }
+#endif // ^^^ _VECTORIZED_MINMAX_ELEMENT ^^^
+
+        auto _Found = _First;
+        if (_First == _Last) {
+            return _Found;
+        }
+
+        while (++_First != _Last) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, *_First), _STD invoke(_Proj, *_Found))) {
+                _Found = _First;
+            }
+        }
+
+        return _Found;
+    }
+
+    struct _Min_element_fn {
+        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
+            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) {
+            _STD _Adl_verify_range(_First, _Last);
+            _STD _Seek_wrapped(
+                _First, _RANGES _Min_element_unchecked(_RANGES _Unwrap_iter<_Se>(_STD move(_First)),
+                            _RANGES _Unwrap_sent<_It>(_STD move(_Last)), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)));
+            return _First;
+        }
+
+        template <forward_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr borrowed_iterator_t<_Rng> operator()(
+            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UResult = _RANGES _Min_element_unchecked(
+                _Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+            return _RANGES _Rewrap_iterator(_Range, _STD move(_UResult));
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Min_element_fn min_element;
+} // namespace ranges
+#endif // _HAS_CXX20
+#endif // _HAS_CXX17
+
+_EXPORT_STD template <class _Ty, class _Pr>
+_NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
+    // return leftmost/smallest
+    _STL_ASSERT(
+        _Ilist.size() != 0, "An initializer_list passed to std::min must not be empty. (N4971 [alg.min.max]/5)");
+#if _VECTORIZED_MINMAX
+    if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+        if (!_Is_constant_evaluated()) {
+            return static_cast<_Ty>(_STD _Min_vectorized(_Ilist.begin(), _Ilist.end()));
+        }
+    }
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+    const _Ty* _Res = _STD _Min_element_unchecked(_Ilist.begin(), _Ilist.end(), _STD _Pass_fn(_Pred));
+    return *_Res;
+}
+
+_EXPORT_STD template <class _Ty>
+_NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist) {
+    // return leftmost/smallest
+    return (_STD min) (_Ilist, less<>{});
+}
+
+#if _HAS_CXX20
+namespace ranges {
+    struct _Min_fn {
+        template <class _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr const _Ty& operator()(const _Ty& _Left _MSVC_LIFETIMEBOUND,
+            const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred = {}, _Pj _Proj = {}) {
+            if (_STD invoke(_Pred, _STD invoke(_Proj, _Right), _STD invoke(_Proj, _Left))) {
+                return _Right;
+            } else {
+                return _Left;
+            }
+        }
+
+        template <copyable _Ty, class _Pj = identity,
+            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
+        _NODISCARD static constexpr _Ty operator()(initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            const auto _First = _Range.begin();
+            const auto _Last  = _Range.end();
+            _STL_ASSERT(_First != _Last,
+                "An initializer_list passed to std::ranges::min must not be empty. (N4971 [alg.min.max]/5)");
+#if _VECTORIZED_MINMAX
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
+                if (!_STD is_constant_evaluated()) {
+                    return static_cast<_Ty>(_STD _Min_vectorized(_First, _Last));
+                }
+            }
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+            return *_RANGES _Min_element_unchecked(_First, _Last, _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj));
+        }
+
+        template <input_range _Rng, class _Pj = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
+            requires indirectly_copyable_storable<iterator_t<_Rng>, range_value_t<_Rng>*>
+        _NODISCARD static constexpr range_value_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
+            auto _UFirst = _Ubegin(_Range);
+            auto _ULast  = _Uend(_Range);
+            _STL_ASSERT(
+                _UFirst != _ULast, "A range passed to std::ranges::min must not be empty. (N4971 [alg.min.max]/5)");
+#if _VECTORIZED_MINMAX
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<decltype(_UFirst), _Pr>
+                          && sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _First_ptr = _STD to_address(_UFirst);
+                    const auto _Last_ptr  = _STD to_address(_UFirst + (_ULast - _UFirst));
+                    return static_cast<range_value_t<_Rng>>(_STD _Min_vectorized(_First_ptr, _Last_ptr));
+                }
+            }
+#endif // ^^^ _VECTORIZED_MINMAX ^^^
+            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<decltype(_UFirst)>) {
+                return static_cast<range_value_t<_Rng>>(*_RANGES _Min_element_unchecked(
+                    _STD move(_UFirst), _STD move(_ULast), _STD _Pass_fn(_Pred), _STD _Pass_fn(_Proj)));
+            } else {
+                range_value_t<_Rng> _Found(*_UFirst);
+                while (++_UFirst != _ULast) {
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_UFirst), _STD invoke(_Proj, _Found))) {
+                        _Found = *_UFirst;
+                    }
+                }
+
+                return _Found;
+            }
+        }
+    };
+
+    _EXPORT_STD inline constexpr _Min_fn min;
+} // namespace ranges
+#endif // _HAS_CXX20
+
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt lower_bound(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
+    // find first element not before _Val
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _Count  = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
+
+    while (0 < _Count) { // divide and conquer, find half that contains answer
+        const auto _Count2 = static_cast<decltype(_Count)>(_Count / 2);
+        const auto _UMid   = _STD next(_UFirst, _Count2);
+        if (_Pred(*_UMid, _Val)) { // try top half
+            _UFirst = _STD _Next_iter(_UMid);
+            _Count -= _Count2 + 1;
+        } else {
+            _Count = _Count2;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
+    // find first element not before _Val
+    return _STD lower_bound(_First, _Last, _Val, less<>{});
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
+_NODISCARD _CONSTEXPR20 _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
+    // find first element that _Val is before
+    _STD _Adl_verify_range(_First, _Last);
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _Count  = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
+
+    while (0 < _Count) { // divide and conquer, find half that contains answer
+        const auto _Count2 = static_cast<decltype(_Count)>(_Count / 2);
+        const auto _UMid   = _STD next(_UFirst, _Count2);
+        if (_Pred(_Val, *_UMid)) {
+            _Count = _Count2;
+        } else { // try top half
+            _UFirst = _STD _Next_iter(_UMid);
+            _Count -= _Count2 + 1;
+        }
+    }
+
+    _STD _Seek_wrapped(_First, _UFirst);
+    return _First;
+}
+
+_EXPORT_STD template <class _FwdIt, class _Ty>
+_NODISCARD _CONSTEXPR20 _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
+    // find first element that _Val is before
+    return _STD upper_bound(_First, _Last, _Val, less<>{});
+}
+
+template <class _FwdIt1, class _FwdIt2>
+_CONSTEXPR20 _FwdIt2 _Swap_ranges_unchecked(_FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) {
+    // swap [_First1, _Last1) with [_First2, ...)
+
+#if _VECTORIZED_SWAP_RANGES
+    using _Elem1 = remove_reference_t<_Iter_ref_t<_FwdIt1>>;
+    using _Elem2 = remove_reference_t<_Iter_ref_t<_FwdIt2>>;
+    if constexpr (is_same_v<_Elem1, _Elem2> && _Is_trivially_swappable_v<_Elem1>
+                  && _Iterators_are_contiguous<_FwdIt1, _FwdIt2>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            const auto _Dist2 = static_cast<_Iter_diff_t<_FwdIt2>>(_Last1 - _First1);
+            _STD _Contiguous_iter_verify(_First2, _Dist2);
+            ::__std_swap_ranges_trivially_swappable_noalias(
+                _STD _To_address(_First1), _STD _To_address(_Last1), _STD _To_address(_First2));
+            return _First2 + _Dist2;
+        }
+    }
+#endif // ^^^ _VECTORIZED_SWAP_RANGES ^^^
+
+    for (; _First1 != _Last1; ++_First1, (void) ++_First2) {
+        swap(*_First1, *_First2); // intentional ADL
+    }
+
+    return _First2;
+}
+
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc();
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xlength_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xoverflow_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xruntime_error(_In_z_ const char*);
+extern "C++" [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _XGetLastError();
+
+_EXPORT_STD template <class _Category, class _Ty, class _Diff = ptrdiff_t, class _Pointer = _Ty*,
+    class _Reference = _Ty&>
+struct _CXX17_DEPRECATE_ITERATOR_BASE_CLASS iterator { // base type for iterator classes
+    using iterator_category = _Category;
+    using value_type        = _Ty;
+    using difference_type   = _Diff;
+    using pointer           = _Pointer;
+    using reference         = _Reference;
+};
+
+#if _HAS_CXX23
+template <_Integer_like _Int>
+_NODISCARD constexpr bool _Add_overflow(const _Int _Left, const _Int _Right, _Int& _Out) {
+#ifdef __clang__
+    if constexpr (integral<_Int>) {
+        return __builtin_add_overflow(_Left, _Right, &_Out);
+    } else
+#endif // defined(__clang__)
+    {
+        if constexpr (!_Signed_integer_like<_Int>) {
+            _Out = static_cast<_Int>(_Left + _Right);
+            return _Out < _Left || _Out < _Right;
+        } else {
+            using _UInt = _Make_unsigned_like_t<_Int>;
+            _Out        = static_cast<_Int>(static_cast<_UInt>(_Left) + static_cast<_UInt>(_Right));
+            return (_Left > 0 && _Right > 0 && _Out <= 0) || (_Left < 0 && _Right < 0 && _Out >= 0);
+        }
+    }
+}
+#endif // _HAS_CXX23
+
+#if _HAS_CXX17
+#if _HAS_CXX20
+template <_Integer_like _Int>
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Int, enable_if_t<_Is_nonbool_integral<_Int>, int> = 0>
+#endif // ^^^ !_HAS_CXX20 ^^^
+_NODISCARD constexpr bool _Mul_overflow(const _Int _Left, const _Int _Right, _Int& _Out) {
+#if defined(__clang__) && !_HAS_CXX20
+    return __builtin_mul_overflow(_Left, _Right, &_Out);
+#else // ^^^ defined(__clang__) && !_HAS_CXX20 / !defined(__clang__) || _HAS_CXX20 vvv
+#ifdef __clang__
+    if constexpr (is_integral_v<_Int>) {
+        return __builtin_mul_overflow(_Left, _Right, &_Out);
+    } else
+#endif // defined(__clang__)
+    {
+        if constexpr (static_cast<_Int>(-1) > static_cast<_Int>(0)) {
+            constexpr auto _UInt_max = _STD _Max_limit<_Int>();
+            const bool _Overflow     = _Left != 0 && _Right > _UInt_max / _Left;
+            if (!_Overflow) {
+                _Out = static_cast<_Int>(_Left * _Right);
+            }
+            return _Overflow;
+        } else {
+            // vvv Based on llvm::MulOverflow vvv
+            // https://github.com/llvm/llvm-project/blob/88e5206/llvm/include/llvm/Support/MathExtras.h#L725-L750
+            //===----------------------------------------------------------------------===//
+            //
+            // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+            // See https://llvm.org/LICENSE.txt for license information.
+            // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+            //
+            //===----------------------------------------------------------------------===//
+            using _UInt = _Make_unsigned_like_t<_Int>;
+            const _UInt _ULeft =
+                static_cast<_UInt>(_Left < 0 ? (0 - static_cast<_UInt>(_Left)) : static_cast<_UInt>(_Left));
+            const _UInt _URight =
+                static_cast<_UInt>(_Right < 0 ? (0 - static_cast<_UInt>(_Right)) : static_cast<_UInt>(_Right));
+            const _UInt _UResult = static_cast<_UInt>(_ULeft * _URight);
+
+            const bool _Negative = (_Left < 0) != (_Right < 0);
+            _Out                 = static_cast<_Int>(_Negative ? (0 - _UResult) : _UResult);
+            if (_ULeft == 0 || _URight == 0) {
+                return false;
+            }
+
+            constexpr auto _Int_max = static_cast<_UInt>(_STD _Max_limit<_Int>());
+            if (_Negative) {
+                return _ULeft > (_Int_max + _UInt{1}) / _URight;
+            } else {
+                return _ULeft > _Int_max / _URight;
+            }
+            // ^^^ Based on llvm::MulOverflow ^^^
+        }
+    }
+#endif // ^^^ !defined(__clang__) || _HAS_CXX20 ^^^
+}
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <class _Ty>
+constexpr bool _Equivalence_is_equality_impl = is_integral_v<_Ty> || is_pointer_v<_Ty>;
+
+// For ranges::less and ranges::greater, see N5032 [range.cmp]/9, [concept.totallyordered]/1.1, [cmp.concept]/1.2.
+template <class _Compare, class _Key>
+constexpr bool _Equivalence_is_equality =
+    _Is_any_of_v<_Compare, _RANGES less, _RANGES greater>
+    || (_Is_any_of_v<_Compare, less<>, less<_Key>, greater<>, greater<_Key>> && _Equivalence_is_equality_impl<_Key>);
+#endif // _HAS_CXX23
+
+template <class _Elem>
+struct _Digit_pair_table {
+    _Elem _Data[100][2];
+
+    constexpr explicit _Digit_pair_table() : _Data{} {
+        for (int _Idx = 0; _Idx != 100; ++_Idx) {
+            _Data[_Idx][0] = static_cast<_Elem>('0' + _Idx / 10);
+            _Data[_Idx][1] = static_cast<_Elem>('0' + _Idx % 10);
+        }
+    }
+
+    _Digit_pair_table(const _Digit_pair_table&)            = delete;
+    _Digit_pair_table& operator=(const _Digit_pair_table&) = delete;
+};
+
+template <class _Elem>
+constexpr _Digit_pair_table<_Elem> _Digit_pairs{};
+_STD_END
+
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("lifetimebound")
+#pragma pop_macro("intrinsic")
+#pragma pop_macro("msvc")
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _XUTILITY_
diff --git a/msvc-stl/stl/inc/ymath.h b/msvc-stl/stl/inc/ymath.h
new file mode 100644
index 0000000..222cf92
--- /dev/null
+++ b/msvc-stl/stl/inc/ymath.h
@@ -0,0 +1,39 @@
+// ymath.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _YMATH
+#define _YMATH
+#include <yvals.h>
+#if _STL_COMPILER_PREPROCESSOR
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Cosh(double, double) noexcept;
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Sinh(double, double) noexcept;
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Exp(double*, double, short) noexcept;
+
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _FCosh(float, float) noexcept;
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _FSinh(float, float) noexcept;
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _FExp(float*, float, short) noexcept;
+
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _LCosh(long double, long double) noexcept;
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _LDtest(long double*) noexcept;
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _LSinh(long double, long double) noexcept;
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _LExp(long double*, long double, short) noexcept;
+
+_END_EXTERN_C_UNLESS_PURE
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _YMATH
diff --git a/msvc-stl/stl/inc/yvals.h b/msvc-stl/stl/inc/yvals.h
new file mode 100644
index 0000000..1b61260
--- /dev/null
+++ b/msvc-stl/stl/inc/yvals.h
@@ -0,0 +1,512 @@
+// yvals.h internal header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This header is used to compile the import library
+// (via locale0_implib.cpp => locale0.cpp => xfacet => yvals.h and regex.cpp => awint.hpp => yvals.h).
+// MAJOR LIMITATIONS apply to what can be included here!
+// Before editing this file, read: /docs/import_library.md
+
+#ifndef _YVALS
+#define _YVALS
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#ifdef _ENFORCE_ONLY_CORE_HEADERS
+_EMIT_STL_ERROR(
+    STL1005, "Tried to include a non-core C++ Standard Library header file with _ENFORCE_ONLY_CORE_HEADERS defined.");
+#endif // defined(_ENFORCE_ONLY_CORE_HEADERS)
+
+#include <__msvc_doom_core.hpp>
+#include <crtdbg.h>
+#include <crtdefs.h>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+#if defined(MRTDLL) && defined(_CRTBLD)
+// process-global is the default for code built with /clr or /clr:oldSyntax.
+// appdomain-global is the default for code built with /clr:pure.
+// Code in MSVCM is built with /clr, but is used by user code built with /clr:pure
+// so it must conform to the expectations of /clr:pure clients.
+// Use __PURE_APPDOMAIN_GLOBAL when a global needs to be appdomain-global for pure
+// clients and process-global for mixed clients.
+#define __PURE_APPDOMAIN_GLOBAL __declspec(appdomain)
+#else
+#define __PURE_APPDOMAIN_GLOBAL
+#endif
+
+#ifndef _CRT_MSVCP_CURRENT
+#ifdef _CRT_WINDOWS
+// Windows
+#ifdef _DEBUG
+#define _CRT_MSVCP_CURRENT "msvcpd_win.dll"
+#else
+#define _CRT_MSVCP_CURRENT "msvcp_win.dll"
+#endif
+#else // ^^^ defined(_CRT_WINDOWS) / !defined(_CRT_WINDOWS) vvv
+// Visual Studio
+#ifdef _DEBUG
+#define _CRT_MSVCP_CURRENT "msvcp140d.dll"
+#else
+#define _CRT_MSVCP_CURRENT "msvcp140.dll"
+#endif
+#endif // ^^^ !defined(_CRT_WINDOWS) ^^^
+#endif // !defined(_CRT_MSVCP_CURRENT)
+
+#ifdef _ITERATOR_DEBUG_LEVEL // A. _ITERATOR_DEBUG_LEVEL is already defined.
+
+// A1. Validate _ITERATOR_DEBUG_LEVEL.
+#if _ITERATOR_DEBUG_LEVEL > 2 && defined(_DEBUG)
+#error _ITERATOR_DEBUG_LEVEL > 2 is not supported in debug mode.
+#elif _ITERATOR_DEBUG_LEVEL > 1 && !defined(_DEBUG)
+#error _ITERATOR_DEBUG_LEVEL > 1 is not supported in release mode.
+#endif
+
+// A2. Inspect _HAS_ITERATOR_DEBUGGING.
+#ifdef _HAS_ITERATOR_DEBUGGING // A2i. _HAS_ITERATOR_DEBUGGING is already defined, validate it.
+#if _ITERATOR_DEBUG_LEVEL == 2 && _HAS_ITERATOR_DEBUGGING != 1
+#error _ITERATOR_DEBUG_LEVEL == 2 must imply _HAS_ITERATOR_DEBUGGING == 1.
+#elif _ITERATOR_DEBUG_LEVEL < 2 && _HAS_ITERATOR_DEBUGGING != 0
+#error _ITERATOR_DEBUG_LEVEL < 2 must imply _HAS_ITERATOR_DEBUGGING == 0.
+#endif
+#else // A2ii. _HAS_ITERATOR_DEBUGGING is not yet defined, derive it.
+#if _ITERATOR_DEBUG_LEVEL == 2
+#define _HAS_ITERATOR_DEBUGGING 1
+#else
+#define _HAS_ITERATOR_DEBUGGING 0
+#endif
+#endif // ^^^ !defined(_HAS_ITERATOR_DEBUGGING) ^^^
+
+// A3. Inspect _SECURE_SCL.
+#ifdef _SECURE_SCL // A3i. _SECURE_SCL is already defined, validate it.
+#if _ITERATOR_DEBUG_LEVEL > 0 && _SECURE_SCL != 1
+#error _ITERATOR_DEBUG_LEVEL > 0 must imply _SECURE_SCL == 1.
+#elif _ITERATOR_DEBUG_LEVEL == 0 && _SECURE_SCL != 0
+#error _ITERATOR_DEBUG_LEVEL == 0 must imply _SECURE_SCL == 0.
+#endif
+#else // A3ii. _SECURE_SCL is not yet defined, derive it.
+#if _ITERATOR_DEBUG_LEVEL > 0
+#define _SECURE_SCL 1
+#else
+#define _SECURE_SCL 0
+#endif
+#endif // ^^^ !defined(_SECURE_SCL) ^^^
+
+#else // B. _ITERATOR_DEBUG_LEVEL is not yet defined.
+
+// B1. Inspect _HAS_ITERATOR_DEBUGGING.
+#ifdef _HAS_ITERATOR_DEBUGGING // B1i. _HAS_ITERATOR_DEBUGGING is already defined, validate it.
+#if _HAS_ITERATOR_DEBUGGING > 1
+#error _HAS_ITERATOR_DEBUGGING must be either 0 or 1.
+#elif _HAS_ITERATOR_DEBUGGING == 1 && !defined(_DEBUG)
+#error _HAS_ITERATOR_DEBUGGING == 1 is not supported in release mode.
+#endif
+#else // B1ii. _HAS_ITERATOR_DEBUGGING is not yet defined, default it.
+#ifdef _DEBUG
+#define _HAS_ITERATOR_DEBUGGING 1
+#else
+#define _HAS_ITERATOR_DEBUGGING 0
+#endif
+#endif // ^^^ !defined(_HAS_ITERATOR_DEBUGGING) ^^^
+
+// B2. Inspect _SECURE_SCL.
+#ifdef _SECURE_SCL // B2i. _SECURE_SCL is already defined, validate it.
+#if _SECURE_SCL > 1
+#error _SECURE_SCL must be either 0 or 1.
+#endif
+#else // B2ii. _SECURE_SCL is not yet defined, default it.
+#if _HAS_ITERATOR_DEBUGGING == 1
+#define _SECURE_SCL 1
+#else
+#define _SECURE_SCL 0
+#endif
+#endif // ^^^ !defined(_SECURE_SCL) ^^^
+
+// B3. Derive _ITERATOR_DEBUG_LEVEL.
+#if _HAS_ITERATOR_DEBUGGING
+#define _ITERATOR_DEBUG_LEVEL 2
+#elif _SECURE_SCL
+#define _ITERATOR_DEBUG_LEVEL 1
+#else // ^^^ _SECURE_SCL / !_SECURE_SCL vvv
+#define _ITERATOR_DEBUG_LEVEL 0
+#endif // ^^^ !_HAS_ITERATOR_DEBUGGING && !_SECURE_SCL ^^^
+
+#endif // ^^^ !defined(_ITERATOR_DEBUG_LEVEL) ^^^
+
+#ifndef _ALLOW_MSC_VER_MISMATCH
+#pragma detect_mismatch("_MSC_VER", "1900")
+#endif // !defined(_ALLOW_MSC_VER_MISMATCH)
+
+#ifndef _ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH
+#pragma detect_mismatch("_ITERATOR_DEBUG_LEVEL", _STL_STRINGIZE(_ITERATOR_DEBUG_LEVEL))
+#endif // !defined(_ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH)
+
+#ifndef _ALLOW_RUNTIME_LIBRARY_MISMATCH
+#if !defined(_DLL) && !defined(_DEBUG)
+#pragma detect_mismatch("RuntimeLibrary", "MT_StaticRelease")
+#elif !defined(_DLL) && defined(_DEBUG)
+#pragma detect_mismatch("RuntimeLibrary", "MTd_StaticDebug")
+#elif defined(_DLL) && !defined(_DEBUG)
+#pragma detect_mismatch("RuntimeLibrary", "MD_DynamicRelease")
+#elif defined(_DLL) && defined(_DEBUG)
+#pragma detect_mismatch("RuntimeLibrary", "MDd_DynamicDebug")
+#endif // defined(_DLL) etc.
+#endif // !defined(_ALLOW_RUNTIME_LIBRARY_MISMATCH)
+
+#ifdef _CONTAINER_DEBUG_LEVEL
+_EMIT_STL_ERROR(STL1006, "_CONTAINER_DEBUG_LEVEL has been removed. It was superseded by _MSVC_STL_HARDENING.");
+#endif
+
+#ifndef _MSVC_STL_HARDENING
+#define _MSVC_STL_HARDENING 0
+#endif
+
+#ifndef _MSVC_STL_HARDENING_ARRAY
+#define _MSVC_STL_HARDENING_ARRAY _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_BASIC_STACKTRACE
+#define _MSVC_STL_HARDENING_BASIC_STACKTRACE _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_BASIC_STRING
+#define _MSVC_STL_HARDENING_BASIC_STRING _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_BASIC_STRING_VIEW
+#define _MSVC_STL_HARDENING_BASIC_STRING_VIEW _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_BITSET
+#define _MSVC_STL_HARDENING_BITSET _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_COMMON_ITERATOR
+#define _MSVC_STL_HARDENING_COMMON_ITERATOR _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_COUNTED_ITERATOR
+#define _MSVC_STL_HARDENING_COUNTED_ITERATOR _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_DEQUE
+#define _MSVC_STL_HARDENING_DEQUE _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_EXPECTED
+#define _MSVC_STL_HARDENING_EXPECTED _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_FORWARD_LIST
+#define _MSVC_STL_HARDENING_FORWARD_LIST _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_LIST
+#define _MSVC_STL_HARDENING_LIST _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_MDSPAN
+#define _MSVC_STL_HARDENING_MDSPAN _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_OPTIONAL
+#define _MSVC_STL_HARDENING_OPTIONAL _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE
+#define _MSVC_STL_HARDENING_RANGES_VIEW_INTERFACE _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_SHARED_PTR_ARRAY
+#define _MSVC_STL_HARDENING_SHARED_PTR_ARRAY _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_SPAN
+#define _MSVC_STL_HARDENING_SPAN _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_VALARRAY
+#define _MSVC_STL_HARDENING_VALARRAY _MSVC_STL_HARDENING
+#endif
+
+#ifndef _MSVC_STL_HARDENING_VECTOR
+#define _MSVC_STL_HARDENING_VECTOR _MSVC_STL_HARDENING
+#endif
+
+#ifdef _STL_CRT_SECURE_INVALID_PARAMETER
+_EMIT_STL_ERROR(STL1007, "_STL_CRT_SECURE_INVALID_PARAMETER has been removed. "
+                         "It was superseded by _MSVC_STL_DOOM_FUNCTION.");
+#endif
+
+#ifdef _STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER
+_EMIT_STL_ERROR(STL1008, "_STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER has been removed. "
+                         "It was superseded by _MSVC_STL_USE_ABORT_AS_DOOM_FUNCTION.");
+#endif
+
+#define _STL_REPORT_ERROR(mesg) \
+    _RPTF0(_CRT_ASSERT, mesg);  \
+    _MSVC_STL_DOOM_FUNCTION(mesg)
+
+#define _STL_VERIFY(cond, mesg)  \
+    if (!(cond)) {               \
+        _STL_REPORT_ERROR(mesg); \
+    }                            \
+    _Analysis_assume_(cond)
+
+#ifdef _DEBUG
+#define _STL_ASSERT(cond, mesg) _STL_VERIFY(cond, mesg)
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _STL_ASSERT(cond, mesg) _Analysis_assume_(cond)
+#endif // ^^^ !defined(_DEBUG) ^^^
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+#define _STL_INTERNAL_CHECK(...) _STL_VERIFY(__VA_ARGS__, "STL internal check: " #__VA_ARGS__)
+#else // ^^^ defined(_ENABLE_STL_INTERNAL_CHECK) / !defined(_ENABLE_STL_INTERNAL_CHECK) vvv
+#define _STL_INTERNAL_CHECK(...) _Analysis_assume_(__VA_ARGS__)
+#endif // ^^^ !defined(_ENABLE_STL_INTERNAL_CHECK) ^^^
+
+#ifndef _MSVC_STL_DESTRUCTOR_TOMBSTONES
+#define _MSVC_STL_DESTRUCTOR_TOMBSTONES 0
+#endif
+
+#ifndef _MSVC_STL_UINTPTR_TOMBSTONE_VALUE
+#define _MSVC_STL_UINTPTR_TOMBSTONE_VALUE uintptr_t{19937}
+#endif
+
+#include <use_ansi.h>
+
+#ifdef _STATIC_CPPLIB
+#ifndef _DISABLE_DEPRECATE_STATIC_CPPLIB
+#ifdef _DLL
+_EMIT_STL_WARNING(STL4000, "_STATIC_CPPLIB is deprecated and will be REMOVED.");
+#endif
+#ifdef _M_CEE_MIXED
+#error _STATIC_CPPLIB is not supported while building with /clr
+#endif
+#endif // !defined(_DISABLE_DEPRECATE_STATIC_CPPLIB)
+#ifdef _M_CEE_PURE
+#error _STATIC_CPPLIB cannot be used with /clr:pure (the resulting assembly would not be pure)
+#endif
+#endif // defined(_STATIC_CPPLIB)
+
+#if defined(_M_CEE_PURE) && !defined(_SILENCE_CLR_PURE_DEPRECATION_WARNING)
+_EMIT_STL_WARNING(STL4001, "/clr:pure is deprecated and will be REMOVED.");
+#endif
+
+#ifndef _MRTIMP2_PURE
+#ifdef _M_CEE_PURE
+#define _MRTIMP2_PURE
+#else
+#define _MRTIMP2_PURE _MRTIMP2
+#endif
+#endif // !defined(_MRTIMP2_PURE)
+
+#if defined(_DLL) && !defined(_STATIC_CPPLIB) && !defined(_M_CEE_PURE)
+#define _DLL_CPPLIB
+#endif
+
+#ifndef _CRTIMP2_PURE
+#ifdef _M_CEE_PURE
+#define _CRTIMP2_PURE
+#else
+#define _CRTIMP2_PURE _CRTIMP2
+#endif
+#endif // !defined(_CRTIMP2_PURE)
+
+#ifndef _CRTIMP2_IMPORT
+#if defined(CRTDLL2) && defined(_CRTBLD)
+#define _CRTIMP2_IMPORT __declspec(dllexport)
+#elif defined(_DLL) && !defined(_STATIC_CPPLIB)
+#define _CRTIMP2_IMPORT __declspec(dllimport)
+#else // ^^^ defined(_DLL) && !defined(_STATIC_CPPLIB) / !defined(_DLL) || defined(_STATIC_CPPLIB) vvv
+#define _CRTIMP2_IMPORT
+#endif // ^^^ !defined(_DLL) || defined(_STATIC_CPPLIB) ^^^
+#endif // !defined(_CRTIMP2_IMPORT)
+
+#ifndef _CRTIMP2_PURE_IMPORT
+#ifdef _M_CEE_PURE
+#define _CRTIMP2_PURE_IMPORT
+#else
+#define _CRTIMP2_PURE_IMPORT _CRTIMP2_IMPORT
+#endif
+#endif // !defined(_CRTIMP2_PURE_IMPORT)
+
+#ifndef _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE
+#ifdef _BUILDING_SATELLITE_CODECVT_IDS
+#define _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE
+#else
+#define _CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE _CRTIMP2_PURE_IMPORT
+#endif
+#endif // !defined(_CRTIMP2_PURE_IMPORT_UNLESS_CODECVT_ID_SATELLITE)
+
+#ifndef _CRTDATA2_IMPORT
+#if defined(MRTDLL) && defined(_CRTBLD)
+#define _CRTDATA2_IMPORT
+#else
+#define _CRTDATA2_IMPORT _CRTIMP2_IMPORT
+#endif
+#endif // !defined(_CRTDATA2_IMPORT)
+
+#define _LOCK_LOCALE 0
+#define _LOCK_STREAM 2
+#define _LOCK_DEBUG  3
+
+_STD_BEGIN
+enum _Uninitialized { // tag for suppressing initialization
+    _Noinit
+};
+
+extern "C++" class _CRTIMP2_PURE_IMPORT _Lockit { // lock while object in existence -- MUST NEST
+public:
+#ifdef _M_CEE_PURE
+    __CLR_OR_THIS_CALL _Lockit() noexcept : _Locktype(0) {
+        _Lockit_ctor(this);
+    }
+
+    explicit __CLR_OR_THIS_CALL _Lockit(int _Kind) noexcept { // set the lock
+        _Lockit_ctor(this, _Kind);
+    }
+
+    __CLR_OR_THIS_CALL ~_Lockit() noexcept { // clear the lock
+        _Lockit_dtor(this);
+    }
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+    __thiscall _Lockit() noexcept;
+    explicit __thiscall _Lockit(int) noexcept; // set the lock
+    __thiscall ~_Lockit() noexcept; // clear the lock
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+    static void __cdecl _Lockit_ctor(int) noexcept;
+    static void __cdecl _Lockit_dtor(int) noexcept;
+
+private:
+    static void __cdecl _Lockit_ctor(_Lockit*) noexcept;
+    static void __cdecl _Lockit_ctor(_Lockit*, int) noexcept;
+    static void __cdecl _Lockit_dtor(_Lockit*) noexcept;
+
+public:
+    __CLR_OR_THIS_CALL _Lockit(const _Lockit&)            = delete;
+    _Lockit& __CLR_OR_THIS_CALL operator=(const _Lockit&) = delete;
+
+private:
+    int _Locktype;
+};
+
+#ifdef _M_CEE_PURE
+class _CRTIMP2_PURE_IMPORT _EmptyLockit { // empty lock class used for bin compat
+private:
+    int _Locktype;
+};
+#endif // defined(_M_CEE_PURE)
+
+#ifdef _M_CEE
+#ifndef _PREPARE_CONSTRAINED_REGIONS
+#ifdef _M_CEE_PURE
+#define _PREPARE_CONSTRAINED_REGIONS 1
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#define _PREPARE_CONSTRAINED_REGIONS 0
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+#endif // !defined(_PREPARE_CONSTRAINED_REGIONS)
+
+// Note: PrepareConstrainedRegions is not supported in .NET versions 6.0 and later. /clr:pure is
+// also not supported in /clr:netcore mode (which targets .NET 8.0 and later), so
+// _PREPARE_CONSTRAINED_REGIONS == 0 in that case.
+
+#if _PREPARE_CONSTRAINED_REGIONS
+#define _BEGIN_LOCK(_Kind)                                                                  \
+    {                                                                                       \
+        bool _MustReleaseLock = false;                                                      \
+        int _LockKind         = _Kind;                                                      \
+        System::Runtime::CompilerServices::RuntimeHelpers::PrepareConstrainedRegions();     \
+        try {                                                                               \
+            System::Runtime::CompilerServices::RuntimeHelpers::PrepareConstrainedRegions(); \
+            try {                                                                           \
+            } finally {                                                                     \
+                _STD _Lockit::_Lockit_ctor(_LockKind);                                      \
+                _MustReleaseLock = true;                                                    \
+            }
+
+#define _END_LOCK()                                \
+    }                                              \
+    finally {                                      \
+        if (_MustReleaseLock) {                    \
+            _STD _Lockit::_Lockit_dtor(_LockKind); \
+        }                                          \
+    }                                              \
+    }
+
+#else // ^^^ _PREPARE_CONSTRAINED_REGIONS / !_PREPARE_CONSTRAINED_REGIONS vvv
+#define _BEGIN_LOCK(_Kind) \
+    {                      \
+        _STD _Lockit _Lock(_Kind);
+
+#define _END_LOCK() }
+
+#endif // ^^^ !_PREPARE_CONSTRAINED_REGIONS ^^^
+
+#define _BEGIN_LOCINFO(_VarName) \
+    _BEGIN_LOCK(_LOCK_LOCALE)    \
+    _Locinfo _VarName;
+
+#define _END_LOCINFO() _END_LOCK()
+
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+#define _BEGIN_LOCK(_Kind) \
+    {                      \
+        _STD _Lockit _Lock(_Kind);
+
+#define _END_LOCK() }
+
+#define _BEGIN_LOCINFO(_VarName) \
+    {                            \
+        _Locinfo _VarName;
+
+#define _END_LOCINFO() }
+#endif // ^^^ !defined(_M_CEE) ^^^
+
+#if _HAS_EXCEPTIONS
+#define _TRY_BEGIN try {
+#define _CATCH(x) \
+    }             \
+    catch (x) {
+#define _CATCH_ALL \
+    }              \
+    catch (...) {
+#define _CATCH_END }
+
+#define _RERAISE    throw
+#define _THROW(...) throw(__VA_ARGS__)
+
+#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+#define _TRY_BEGIN \
+    {              \
+        if (1) {
+#define _CATCH(x) \
+    }             \
+    else if (0) {
+#define _CATCH_ALL \
+    }              \
+    else if (0) {
+#define _CATCH_END \
+    }              \
+    }
+
+#define _RAISE(x) _MSVC_STL_DOOM_FUNCTION("_RAISE was called with !_HAS_EXCEPTIONS")
+
+#define _RERAISE
+#define _THROW(...) (__VA_ARGS__)._Raise()
+#endif // ^^^ !_HAS_EXCEPTIONS ^^^
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _YVALS
diff --git a/msvc-stl/stl/inc/yvals_core.h b/msvc-stl/stl/inc/yvals_core.h
new file mode 100644
index 0000000..29ced7d
--- /dev/null
+++ b/msvc-stl/stl/inc/yvals_core.h
@@ -0,0 +1,1959 @@
+// yvals_core.h internal header (core)
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _YVALS_CORE_H_
+#define _YVALS_CORE_H_
+#ifndef _STL_COMPILER_PREPROCESSOR
+// All STL headers avoid exposing their contents when included by various
+// non-C++-compiler tools to avoid breaking builds when we use newer language
+// features in the headers than such tools understand.
+#if defined(RC_INVOKED) || defined(Q_MOC_RUN) || defined(__midl)
+#define _STL_COMPILER_PREPROCESSOR 0
+#else
+#define _STL_COMPILER_PREPROCESSOR 1
+#endif
+#endif // !defined(_STL_COMPILER_PREPROCESSOR)
+
+#if _STL_COMPILER_PREPROCESSOR
+
+// This does not use `_EMIT_STL_ERROR`, as it is checking the language itself.
+#ifndef __cplusplus
+#error error STL1003: Unexpected compiler, expected C++ compiler.
+#endif // !defined(__cplusplus)
+
+// Implemented unconditionally:
+// N3911 void_t
+// N4089 Safe Conversions In unique_ptr<T[]>
+// N4169 invoke()
+// N4258 noexcept Cleanups
+// N4259 uncaught_exceptions()
+// N4277 Trivially Copyable reference_wrapper
+// N4279 insert_or_assign()/try_emplace() For map/unordered_map
+// N4280 size(), empty(), data()
+// N4366 Precisely Constraining unique_ptr Assignment
+// N4387 Improving pair And tuple
+// N4389 bool_constant
+// N4508 shared_mutex (Untimed)
+// N4510 Supporting Incomplete Types In vector/list/forward_list
+// P0006R0 Variable Templates For Type Traits (is_same_v, etc.)
+// P0007R1 as_const()
+// P0013R1 Logical Operator Type Traits (conjunction, etc.)
+// P0033R1 Rewording enable_shared_from_this
+// P0063R3 C11 Standard Library
+// P0074R0 owner_less<>
+// P0092R1 <chrono> floor(), ceil(), round(), abs()
+// P0340R3 SFINAE-Friendly underlying_type
+// P0414R2 shared_ptr<T[]>, shared_ptr<T[N]>
+// P0418R2 atomic compare_exchange memory_order Requirements
+// P0435R1 Overhauling common_type
+// P0497R0 Fixing shared_ptr For Arrays
+// P0513R0 Poisoning hash
+// P0516R0 Marking shared_future Copying As noexcept
+// P0517R0 Constructing future_error From future_errc
+// P0548R1 Tweaking common_type And duration
+// P0558R1 Resolving atomic<T> Named Base Class Inconsistencies
+// P0599R1 noexcept hash
+// P0738R2 istream_iterator Cleanup
+// P0771R1 noexcept For std::function's Move Constructor
+// P0777R1 Avoiding Unnecessary decay
+// P0809R0 Comparing Unordered Containers
+// P0883R2 Fixing Atomic Initialization
+// P0935R0 Eradicating Unnecessarily Explicit Default Constructors
+// P0941R2 Feature-Test Macros
+// P0952R2 A New Specification For generate_canonical()
+// P0972R0 noexcept For <chrono> zero(), min(), max()
+// P1065R2 constexpr INVOKE
+//     (the std::invoke function only; other components like bind and reference_wrapper are C++20 only)
+// P1164R1 Making create_directory() Intuitive
+// P1165R1 Consistently Propagating Stateful Allocators In basic_string's operator+()
+// P1902R1 Missing Feature-Test Macros 2017-2019
+// P2013R5 Freestanding Language: Optional ::operator new
+//     (no change is needed for our hosted implementation)
+// P2198R7 Freestanding Feature-Test Macros And Implementation-Defined Extensions
+//     (except for __cpp_lib_freestanding_ranges)
+// P2338R4 Freestanding Library: Character Primitives And The C Library
+//     (except for __cpp_lib_freestanding_charconv)
+// P2401R0 Conditional noexcept For exchange()
+// P2407R5 Freestanding Library: Partial Classes
+//     (__cpp_lib_freestanding_algorithm and __cpp_lib_freestanding_array only)
+// P2937R0 Freestanding Library: Remove strtok
+// P2968R2 Make std::ignore A First-Class Object
+// P3016R6 Resolve Inconsistencies In begin/end For valarray And Braced Initializer Lists
+// P3223R2 Making istream::ignore() Less Surprising
+// P3323R1 Forbid atomic<cv T>, Specify atomic_ref<cv T>
+//     (for atomic<cv T>)
+// P3503R3 Make Type-Erased Allocator Use In promise And packaged_task Consistent
+// P3612R1 Harmonize Proxy-Reference Operations
+//     (deprecation controlled by _HAS_CXX26)
+
+// _HAS_CXX17 controls:
+// N4190 Removing auto_ptr, random_shuffle(), And Old <functional> Stuff
+// P0003R5 Removing Dynamic Exception Specifications
+// P0004R1 Removing Deprecated Iostreams Aliases
+// P0005R4 not_fn()
+// P0024R2 Parallel Algorithms
+// P0025R1 clamp()
+// P0030R1 hypot(x, y, z)
+// P0031R0 constexpr For <array> (Again) And <iterator>
+// P0032R3 Homogeneous Interface For variant/any/optional
+// P0040R3 Extending Memory Management Tools
+// P0067R5 Elementary String Conversions
+// P0083R3 Splicing Maps And Sets
+// P0084R2 Emplace Return Type
+// P0088R3 <variant>
+// P0137R1 launder()
+// P0152R1 atomic::is_always_lock_free
+// P0154R1 hardware_destructive_interference_size, etc.
+// P0156R2 scoped_lock
+// P0163R0 shared_ptr::weak_type
+// P0174R2 Deprecating Vestigial Library Parts
+// P0185R1 is_swappable, is_nothrow_swappable
+// P0209R2 make_from_tuple()
+// P0218R1 <filesystem>
+// P0220R1 <any>, <memory_resource>, <optional>, <string_view>, apply(), sample(), Boyer-Moore search()
+// P0226R1 Mathematical Special Functions
+// P0253R1 Fixing Searcher Return Types
+// P0254R2 Integrating string_view And std::string
+// P0258R2 has_unique_object_representations
+// P0272R1 Non-const basic_string::data()
+// P0295R0 gcd(), lcm()
+// P0298R3 std::byte
+// P0302R1 Removing Allocator Support In std::function
+// P0307R2 Making Optional Greater Equal Again
+// P0336R1 Renaming Parallel Execution Policies
+// P0337R0 Deleting polymorphic_allocator Assignment
+// P0358R1 Fixes For not_fn()
+// P0393R3 Making Variant Greater Equal
+// P0394R4 Parallel Algorithms Should terminate() For Exceptions
+// P0403R1 UDLs For <string_view> ("meow"sv, etc.)
+// P0426R1 constexpr For char_traits
+// P0433R2 Deduction Guides For The STL
+// P0452R1 Unifying <numeric> Parallel Algorithms
+// P0472R3 Put monostate In <utility>
+// P0504R0 Revisiting in_place_t/in_place_type_t<T>/in_place_index_t<I>
+// P0505R0 constexpr For <chrono> (Again)
+// P0508R0 Clarifying insert_return_type
+// P0510R0 Rejecting variants Of Nothing, Arrays, References, And Incomplete Types
+// P0521R0 Deprecating shared_ptr::unique()
+// P0602R4 Propagating Copy/Move Triviality In variant/optional
+// P0604R0 invoke_result, is_invocable, is_nothrow_invocable
+// P0607R0 Inline Variables For The STL
+// P0608R3 Improving variant's Converting Constructor/Assignment
+// P0618R0 Deprecating <codecvt>
+// P0682R1 Repairing Elementary String Conversions
+// P0739R0 Improving Class Template Argument Deduction For The STL
+// P0858R0 Constexpr Iterator Requirements
+// P1169R4 static operator()
+// P1518R2 Stop Overconstraining Allocators In Container Deduction Guides
+// P2162R2 Inheriting From variant
+// P2251R1 Require span And basic_string_view To Be Trivially Copyable
+//     (basic_string_view always provides this behavior)
+// P2338R4 Freestanding Library: Character Primitives And The C Library
+//     (including __cpp_lib_freestanding_charconv)
+// P2407R5 Freestanding Library: Partial Classes
+//     (including __cpp_lib_freestanding_optional, __cpp_lib_freestanding_string_view, and
+//     __cpp_lib_freestanding_variant)
+// P2517R1 Conditional noexcept For apply()
+// P2875R4 Undeprecate polymorphic_allocator::destroy
+// LWG-2385 function::assign allocator argument doesn't make sense
+// Enforcement of matching allocator value_types
+
+// Implemented when char8_t is available (C++14/17 with /Zc:char8_t, C++20 without /Zc:char8_t-):
+// P0482R6 Library Support For char8_t
+//     (mbrtoc8 and c8rtomb not yet implemented, see GH-2207)
+
+// _HAS_CXX20 controls:
+// P0019R8 atomic_ref
+// P0020R6 atomic<float>, atomic<double>, atomic<long double>
+// P0053R7 <syncstream>
+// P0122R7 <span>
+// P0202R3 constexpr For <algorithm> And exchange()
+// P0318R1 unwrap_reference, unwrap_ref_decay
+// P0325R4 to_array()
+// P0339R6 polymorphic_allocator<>
+// P0355R7 <chrono> Calendars And Time Zones
+// P0356R5 bind_front()
+// P0357R3 Supporting Incomplete Types In reference_wrapper
+// P0408R7 Efficient Access To basic_stringbuf's Buffer
+// P0415R1 constexpr For <complex> (Again)
+// P0439R0 enum class memory_order
+// P0457R2 starts_with()/ends_with() For basic_string/basic_string_view
+// P0458R2 contains() For Ordered And Unordered Associative Containers
+// P0463R1 endian
+// P0466R5 Layout-Compatibility And Pointer-Interconvertibility Traits
+// P0475R1 Guaranteed Copy Elision For Piecewise Construction
+// P0476R2 <bit> bit_cast
+// P0487R1 Fixing operator>>(basic_istream&, CharT*)
+// P0528R3 Atomic Compare-And-Exchange With Padding Bits
+// P0550R2 remove_cvref
+// P0553R4 <bit> Rotating And Counting Functions
+// P0556R3 <bit> Integral Power-Of-2 Operations (renamed by P1956R1)
+// P0586R2 Integer Comparison Functions
+// P0591R4 Utility Functions For Uses-Allocator Construction
+// P0595R2 is_constant_evaluated()
+// P0616R0 Using move() In <numeric>
+// P0619R4 Removing C++17-Deprecated Features
+// P0631R8 <numbers> Math Constants
+// P0645R10 <format> Text Formatting
+// P0646R1 list/forward_list remove()/remove_if()/unique() Return size_type
+// P0653R2 to_address()
+// P0655R1 visit<R>()
+// P0660R10 <stop_token> And jthread
+// P0674R1 make_shared() For Arrays
+// P0718R2 atomic<shared_ptr<T>>, atomic<weak_ptr<T>>
+// P0753R2 osyncstream Manipulators
+// P0758R1 is_nothrow_convertible
+// P0767R1 Deprecating is_pod
+// P0768R1 Library Support For The Spaceship Comparison Operator <=>
+// P0769R2 shift_left(), shift_right()
+// P0784R7 Library Support For More constexpr Containers
+// P0811R3 midpoint(), lerp()
+// P0849R8 auto(x): decay-copy In The Language
+//     (library part only)
+// P0879R0 constexpr For Swapping Functions
+// P0887R1 type_identity
+// P0896R4 Ranges
+// P0898R3 Standard Library Concepts
+// P0912R5 Library Support For Coroutines
+// P0919R3 Heterogeneous Lookup For Unordered Containers
+// P0966R1 string::reserve() Should Not Shrink
+// P0980R1 constexpr std::string
+// P1001R2 execution::unseq
+// P1004R2 constexpr std::vector
+// P1006R1 constexpr For pointer_traits<T*>::pointer_to()
+// P1007R3 assume_aligned()
+// P1020R1 Smart Pointer Creation With Default Initialization
+// P1023R0 constexpr For std::array Comparisons
+// P1024R3 Enhancing span Usability
+// P1032R1 Miscellaneous constexpr
+// P1035R7 Input Range Adaptors
+// P1065R2 constexpr INVOKE
+//     (except the std::invoke function which is implemented unconditionally)
+// P1085R2 Removing span Comparisons
+// P1115R3 erase()/erase_if() Return size_type
+// P1123R0 Atomic Compare-And-Exchange With Padding Bits For atomic_ref
+// P1135R6 The C++20 Synchronization Library
+// P1207R4 Movability Of Single-Pass Iterators
+// P1208R6 <source_location>
+// P1209R0 erase_if(), erase()
+// P1227R2 Signed std::ssize(), Unsigned span::size()
+// P1243R4 Rangify New Algorithms
+// P1248R1 Fixing Relations
+// P1252R2 Ranges Design Cleanup
+// P1357R1 is_bounded_array, is_unbounded_array
+// P1391R4 Range Constructor For string_view
+// P1394R4 Range Constructor For span
+// P1423R3 char8_t Backward Compatibility Remediation
+// P1456R1 Move-Only Views
+// P1474R1 Helpful Pointers For contiguous_iterator
+// P1522R1 Iterator Difference Type And Integer Overflow
+// P1523R1 Views And Size Types
+// P1612R1 Relocating endian To <bit>
+// P1614R2 Adding Spaceship <=> To The Library
+// P1638R1 basic_istream_view::iterator Should Not Be Copyable
+// P1645R1 constexpr For <numeric> Algorithms
+// P1651R0 bind_front() Should Not Unwrap reference_wrapper
+// P1690R1 Refining Heterogeneous Lookup For Unordered Containers
+// P1716R3 Range Comparison Algorithms Are Over-Constrained
+// P1739R4 Avoiding Template Bloat For Ranges
+// P1754R1 Rename Concepts To standard_case
+// P1831R1 Deprecating volatile In The Standard Library
+// P1862R1 Range Adaptors For Non-Copyable Iterators
+// P1865R1 Adding max() To latch And barrier
+// P1870R1 Rename forwarding-range To borrowed_range (Was safe_range before LWG-3379)
+// P1871R1 disable_sized_sentinel_for
+// P1872R0 span Should Have size_type, Not index_type
+// P1878R1 Constraining Readable Types
+// P1907R2 ranges::ssize
+// P1956R1 <bit> has_single_bit(), bit_ceil(), bit_floor(), bit_width()
+// P1959R0 Removing weak_equality And strong_equality
+// P1960R0 atomic_ref Cleanup
+// P1964R2 Replacing boolean With boolean-testable
+// P1973R1 Renaming default_init To for_overwrite
+// P1976R2 Explicit Constructors For Fixed-Extent span From Dynamic-Extent Ranges
+// P1983R0 Fixing Minor Ranges Issues
+// P1994R1 elements_view Needs Its Own sentinel
+// P2017R1 Conditionally Borrowed Ranges
+// P2091R0 Fixing Issues With Range Access CPOs
+// P2102R0 Making "Implicit Expression Variations" More Explicit
+// P2106R0 Range Algorithm Result Types
+// P2116R0 Removing tuple-Like Protocol Support From Fixed-Extent span
+// P2167R3 Improving boolean-testable Usage
+// P2198R7 Freestanding Feature-Test Macros And Implementation-Defined Extensions
+//     (including __cpp_lib_freestanding_ranges)
+// P2210R2 Superior String Splitting
+// P2216R3 std::format Improvements
+// P2231R1 Completing constexpr In optional And variant
+// P2251R1 Require span And basic_string_view To Be Trivially Copyable
+//     (span always provides this behavior)
+// P2259R1 Repairing Input Range Adaptors And counted_iterator
+// P2281R1 Clarifying Range Adaptor Objects
+// P2325R3 Views Should Not Be Required To Be Default Constructible
+// P2328R1 join_view Should Join All views Of ranges
+// P2367R0 Remove Misuses Of List-Initialization From Clause 24 Ranges
+// P2372R3 Fixing Locale Handling In chrono Formatters
+// P2393R1 Cleaning Up Integer-Class Types
+// P2404R3 Move-Only Types For Comparison Concepts
+// P2408R5 Ranges Iterators As Inputs To Non-Ranges Algorithms
+// P2415R2 What Is A view?
+// P2418R2 Add Support For std::generator-like Types To std::format
+// P2419R2 Clarify Handling Of Encodings In Localized Formatting Of chrono Types
+// P2432R1 Fix istream_view
+// P2465R3 Standard Library Modules std And std.compat
+// P2508R1 basic_format_string, format_string, wformat_string
+// P2510R3 Formatting Pointers
+// P2520R0 move_iterator<T*> Should Be A Random-Access Iterator
+// P2538R1 ADL-Proof projected
+// P2572R1 std::format Fill Character Allowances
+// P2588R3 barrier's Phase Completion Guarantees
+// P2602R2 Poison Pills Are Too Toxic
+// P2609R3 Relaxing Ranges Just A Smidge
+// P2655R3 common_reference_t Of reference_wrapper Should Be A Reference Type
+// P2675R1 Improving std::format's Width Estimation
+// P2711R1 Making Multi-Param Constructors Of Views explicit
+// P2736R2 Referencing The Unicode Standard
+// P2770R0 Stashing Stashing Iterators For Proper Flattening
+// P2905R2 Runtime Format Strings
+// P2909R4 Fix Formatting Of Code Units As Integers
+// P2997R1 Removing The Common Reference Requirement From The Indirectly Invocable Concepts
+// P3136R1 Retiring Niebloids
+// P3323R1 Forbid atomic<cv T>, Specify atomic_ref<cv T>
+//     (for atomic_ref<cv T>)
+// P3349R1 Converting Contiguous Iterators To Pointers
+// P3860R1 Make atomic_ref<T> Convertible To atomic_ref<const T>
+
+// _HAS_CXX23 controls:
+// P0009R18 <mdspan>
+// P0288R9 move_only_function
+// P0323R12 <expected>
+// P0401R6 Providing Size Feedback In The Allocator Interface
+// P0429R9 <flat_map>
+// P0448R4 <spanstream>
+// P0627R6 unreachable()
+// P0798R8 Monadic Operations For optional
+// P0881R7 <stacktrace>
+// P0943R6 Supporting C Atomics In C++
+// P1048R1 is_scoped_enum
+// P1072R10 basic_string::resize_and_overwrite
+// P1132R7 out_ptr(), inout_ptr()
+// P1147R1 Printing volatile Pointers
+// P1206R7 Conversions From Ranges To Containers
+// P1222R4 <flat_set>
+// P1223R5 ranges::find_last, ranges::find_last_if, ranges::find_last_if_not
+// P1272R4 byteswap()
+// P1328R1 constexpr type_info::operator==()
+// P1413R3 Deprecate aligned_storage And aligned_union
+// P1425R4 Iterator Pair Constructors For stack And queue
+// P1467R9 Extended Floating-Point Types
+//     (only the <stdfloat> header; we don't support any optional extended floating-point types)
+// P1659R3 ranges::starts_with, ranges::ends_with
+// P1679R3 contains() For basic_string/basic_string_view
+// P1682R3 to_underlying() For Enumerations
+// P1899R3 views::stride
+// P1951R1 Default Template Arguments For pair's Forwarding Constructor
+// P1989R2 Range Constructor For string_view
+// P2077R3 Heterogeneous Erasure Overloads For Associative Containers
+// P2093R14 <print>: Formatted Output
+// P2136R3 invoke_r()
+// P2164R9 views::enumerate
+// P2165R4 Compatibility Between tuple, pair, And tuple-like Objects
+// P2166R1 Prohibiting basic_string And basic_string_view Construction From nullptr
+// P2186R2 Removing Garbage Collection Support
+// P2255R2 Type Traits To Detect References Binding To Temporaries
+// P2273R3 constexpr unique_ptr
+// P2278R4 cbegin Should Always Return A Constant Iterator
+// P2286R8 Formatting Ranges
+// P2291R3 constexpr Integral <charconv>
+// P2302R4 ranges::contains, ranges::contains_subrange
+// P2321R2 zip
+// P2322R6 ranges::fold_left, ranges::fold_right, Etc.
+// P2374R4 views::cartesian_product
+// P2387R3 Pipe Support For User-Defined Range Adaptors
+// P2417R2 More constexpr bitset
+// P2438R2 string::substr() &&
+// P2440R1 ranges::iota, ranges::shift_left, ranges::shift_right
+// P2441R2 views::join_with
+// P2442R1 Windowing Range Adaptors: views::chunk, views::slide
+// P2443R1 views::chunk_by
+// P2445R1 forward_like()
+// P2446R2 views::as_rvalue
+// P2467R1 ios_base::noreplace: Exclusive Mode For fstreams
+// P2474R2 views::repeat
+// P2494R2 Relaxing Range Adaptors To Allow Move-Only Types
+// P2499R0 string_view Range Constructor Should Be explicit
+// P2502R2 <generator>: Synchronous Coroutine Generator For Ranges
+// P2505R5 Monadic Functions For expected
+// P2539R4 Synchronizing print() With The Underlying Stream
+// P2540R1 Empty Product For Certain Views
+// P2549R1 unexpected<E>::error()
+// P2585R1 Improve Default Container Formatting
+// P2590R2 Explicit Lifetime Management
+// P2599R2 mdspan: index_type, size_type
+// P2604R0 mdspan: data_handle_type, data_handle(), exhaustive
+// P2613R1 mdspan: empty()
+// P2614R2 Deprecating float_denorm_style, numeric_limits::has_denorm, numeric_limits::has_denorm_loss
+// P2652R2 Disallowing User Specialization Of allocator_traits
+// P2674R1 is_implicit_lifetime
+// P2679R2 Fixing start_lifetime_as And start_lifetime_as_array
+// P2693R1 Formatting thread::id And stacktrace
+// P2713R1 Escaping Improvements In std::format
+// P2763R1 Fixing layout_stride's Default Constructor For Fully Static Extents
+// P2787R1 pmr::generator
+// P2833R2 Freestanding Library: inout expected span
+//     (except for __cpp_lib_span which also covers C++26 span::at)
+// P2836R1 basic_const_iterator Should Follow Its Underlying Type's Convertibility
+// P3107R5 Permit An Efficient Implementation Of <print>
+// P3142R0 Printing Blank Lines With println()
+// P3235R3 std::print More Types Faster With Less Memory
+//     (partial implementation; see GH-4924)
+// P3567R2 flat_meow Fixes
+
+// Parallel Algorithms Notes
+// C++ allows an implementation to implement parallel algorithms as calls to the serial algorithms.
+// This implementation parallelizes several common algorithm calls, but not all.
+//
+// std::execution::unseq has no direct analogue for any optimizer we target as of 2020-07-29,
+// though we will map it to #pragma loop(ivdep) for the for_each algorithms only as these are the only algorithms where
+// the library does not need to introduce inter-loop-body dependencies to accomplish the algorithm's goals.
+//
+// The following algorithms are parallelized.
+// * adjacent_difference
+// * adjacent_find
+// * all_of
+// * any_of
+// * count
+// * count_if
+// * destroy
+// * destroy_n
+// * equal
+// * exclusive_scan
+// * find
+// * find_end
+// * find_first_of
+// * find_if
+// * find_if_not
+// * for_each
+// * for_each_n
+// * inclusive_scan
+// * is_heap
+// * is_heap_until
+// * is_partitioned
+// * is_sorted
+// * is_sorted_until
+// * mismatch
+// * none_of
+// * partition
+// * reduce
+// * remove
+// * remove_if
+// * replace
+// * replace_if
+// * search
+// * search_n
+// * set_difference
+// * set_intersection
+// * sort
+// * stable_sort
+// * transform
+// * transform_exclusive_scan
+// * transform_inclusive_scan
+// * transform_reduce
+// * uninitialized_default_construct
+// * uninitialized_default_construct_n
+// * uninitialized_value_construct
+// * uninitialized_value_construct_n
+//
+// The following are not presently parallelized:
+//
+// No apparent parallelism performance improvement on target hardware; all algorithms which
+// merely copy or permute elements with no branches are typically memory bandwidth limited.
+// * copy
+// * copy_n
+// * fill
+// * fill_n
+// * move
+// * reverse
+// * reverse_copy
+// * rotate
+// * rotate_copy
+// * shift_left
+// * shift_right
+// * swap_ranges
+//
+// Possibly same as above, but not yet tested.
+// * uninitialized_copy
+// * uninitialized_copy_n
+// * uninitialized_fill
+// * uninitialized_fill_n
+// * uninitialized_move
+// * uninitialized_move_n
+//
+// Confusion over user parallelism requirements exists; likely in the above category anyway.
+// * generate
+// * generate_n
+//
+// Effective parallelism suspected to be infeasible.
+// * partial_sort
+// * partial_sort_copy
+//
+// Not yet evaluated; parallelism may be implemented in a future release and is suspected to be beneficial.
+// * copy_if
+// * includes
+// * inplace_merge
+// * lexicographical_compare
+// * max_element
+// * merge
+// * min_element
+// * minmax_element
+// * nth_element
+// * partition_copy
+// * remove_copy
+// * remove_copy_if
+// * replace_copy
+// * replace_copy_if
+// * set_symmetric_difference
+// * set_union
+// * stable_partition
+// * unique
+// * unique_copy
+
+#include <vcruntime.h>
+#include <xkeycheck.h> // The _HAS_CXX tags must be defined before including this.
+
+#define _STL_STRINGIZE_(S) #S
+#define _STL_STRINGIZE(S)  _STL_STRINGIZE_(S)
+
+#define _STL_PRAGMA(PRAGMA)          _Pragma(#PRAGMA)
+#define _STL_PRAGMA_MESSAGE(MESSAGE) _STL_PRAGMA(message(MESSAGE))
+#define _EMIT_STL_MESSAGE(MESSAGE)   _STL_PRAGMA_MESSAGE(__FILE__ "(" _STL_STRINGIZE(__LINE__) "): " MESSAGE)
+
+#define _EMIT_STL_WARNING(NUMBER, MESSAGE) _EMIT_STL_MESSAGE("warning " #NUMBER ": " MESSAGE)
+#define _EMIT_STL_ERROR(NUMBER, MESSAGE)   static_assert(false, "error " #NUMBER ": " MESSAGE)
+
+#ifndef _STL_WARNING_LEVEL
+#if defined(_MSVC_WARNING_LEVEL) && _MSVC_WARNING_LEVEL >= 4
+#define _STL_WARNING_LEVEL 4
+#else // defined(_MSVC_WARNING_LEVEL) && _MSVC_WARNING_LEVEL >= 4
+#define _STL_WARNING_LEVEL 3
+#endif // defined(_MSVC_WARNING_LEVEL) && _MSVC_WARNING_LEVEL >= 4
+#endif // !defined(_STL_WARNING_LEVEL)
+
+#if _STL_WARNING_LEVEL < 3
+#error _STL_WARNING_LEVEL cannot be less than 3.
+#endif // _STL_WARNING_LEVEL < 3
+
+#if _STL_WARNING_LEVEL > 4
+#error _STL_WARNING_LEVEL cannot be greater than 4.
+#endif // _STL_WARNING_LEVEL > 4
+
+#ifndef __has_cpp_attribute
+#define _FALLTHROUGH
+#elif __has_cpp_attribute(fallthrough) >= 201603L // TRANSITION, VSO-2696854
+#define _FALLTHROUGH [[fallthrough]]
+#else
+#define _FALLTHROUGH
+#endif
+
+// vcruntime.h defines _NODISCARD to [[nodiscard]]
+
+#define _NODISCARD_REMOVE_ALG                                                                                 \
+    [[nodiscard("The 'remove' and 'remove_if' algorithms return the iterator past the last element "          \
+                "that should be kept. You need to call container.erase(result, container.end()) afterwards. " \
+                "In C++20, 'std::erase' and 'std::erase_if' are simpler replacements for these two steps.")]]
+
+#define _NODISCARD_UNIQUE_ALG                                                                             \
+    [[nodiscard("The 'unique' algorithm returns the iterator past the last element that should be kept. " \
+                "You need to call container.erase(result, container.end()) afterwards.")]]
+
+#define _NODISCARD_EMPTY_MEMBER                                                                        \
+    [[nodiscard("This member function returns a bool indicating whether the collection is empty and "  \
+                "has no other effects. It is not useful to call this member function and discard the " \
+                "return value. Use the 'clear()' member function if you want to erase all elements.")]]
+
+#define _NODISCARD_EMPTY_ARRAY_MEMBER                                                                  \
+    [[nodiscard("This member function returns a bool indicating whether the array is empty and "       \
+                "has no other effects. It is not useful to call this member function and discard the " \
+                "return value. There's no way to clear an array as its size is fixed.")]]
+
+#define _NODISCARD_EMPTY_MEMBER_NO_CLEAR                                                               \
+    [[nodiscard("This member function returns a bool indicating whether the collection is empty and "  \
+                "has no other effects. It is not useful to call this member function and discard the " \
+                "return value. This collection can be cleared by assigning an empty value to it.")]]
+
+#define _NODISCARD_EMPTY_NON_MEMBER                                                            \
+    [[nodiscard("This function returns a bool indicating whether the collection is empty and " \
+                "has no other effects. It is not useful to call this function and discard the return value.")]]
+
+#define _NODISCARD_BARRIER_TOKEN \
+    [[nodiscard("The token from 'arrive()' should not be discarded; it should be passed to 'wait()'.")]]
+
+#define _NODISCARD_TRY_WAIT                                                                                            \
+    [[nodiscard("This member function returns the state of the synchronization object and does not do anything else; " \
+                "it is not useful to call this member function and discard the return value.")]]
+
+#define _NODISCARD_TRY_CHANGE_STATE                                                                 \
+    [[nodiscard("This function returns whether the operation succeeded in modifying object state. " \
+                "It is dangerous to ignore the return value.")]]
+
+#define _NODISCARD_SMART_PTR_ALLOC                                                                         \
+    [[nodiscard("This function constructs an object wrapped by a smart pointer and has no other effects; " \
+                "it is not useful to call this function and discard the return value.")]]
+
+#define _NODISCARD_RAW_PTR_ALLOC                                             \
+    [[nodiscard("This function allocates memory and returns a raw pointer. " \
+                "Discarding the return value will cause a memory leak.")]]
+
+#define _NODISCARD_ASSUME_ALIGNED                                                                                 \
+    [[nodiscard("'std::assume_aligned' has a potential effect on the return value (not on the passed argument). " \
+                "It is not useful to call 'std::assume_aligned' and discard the return value.")]]
+
+#define _NODISCARD_LAUNDER                                                                                 \
+    [[nodiscard("'std::launder' has a potential effect on the return value (not on the passed argument). " \
+                "It is not useful to call 'std::launder' and discard the return value.")]]
+
+#ifdef _SILENCE_NODISCARD_LOCK_WARNINGS
+#define _NODISCARD_LOCK
+#else // ^^^ warning disabled / warning enabled vvv
+#define _NODISCARD_LOCK                                                                                             \
+    [[nodiscard("A lock should be stored in a variable to protect the scope. If you're intentionally constructing " \
+                "a temporary to protect the rest of the current expression using the comma operator, you can cast " \
+                "the temporary to void or define _SILENCE_NODISCARD_LOCK_WARNINGS to suppress this warning.")]]
+#endif // ^^^ warning enabled ^^^
+
+#define _NODISCARD_CTOR_THREAD                                             \
+    [[nodiscard("This temporary 'std::thread' is not joined or detached, " \
+                "so 'std::terminate' will be called at the end of the statement.")]]
+
+#define _NODISCARD_CTOR_JTHREAD                                                                    \
+    [[nodiscard("This temporary 'std::jthread' is implicitly joined at the end of the statement. " \
+                "If this is intentional, you can add '.join()' to suppress this warning. "         \
+                "Otherwise, this 'std::jthread' should be stored in a variable.")]]
+
+#define _NODISCARD_ASYNC                                                                                        \
+    [[nodiscard("The result of 'std::async' should be stored in a variable. If the return value is discarded, " \
+                "the temporary 'std::future' is destroyed, waiting for an async result or evaluating "          \
+                "a deferred result, thus defeating the purpose of 'std::async'.")]]
+
+#define _NODISCARD_GET_FUTURE \
+    [[nodiscard("Since 'get_future' may be called only once, discarding the result is likely a mistake.")]]
+
+#pragma push_macro("msvc")
+#pragma push_macro("known_semantics")
+#pragma push_macro("noop_dtor")
+#pragma push_macro("intrinsic")
+#pragma push_macro("lifetimebound")
+#pragma push_macro("no_specializations")
+#undef msvc
+#undef known_semantics
+#undef noop_dtor
+#undef intrinsic
+#undef lifetimebound
+#undef no_specializations
+
+#ifndef __has_cpp_attribute
+#define _HAS_MSVC_ATTRIBUTE(x) 0
+#else
+#define _HAS_MSVC_ATTRIBUTE(x) __has_cpp_attribute(msvc::x)
+#endif
+
+// Should we use [[msvc::known_semantics]] to tell the compiler that certain
+// type trait specializations have the standard-mandated semantics?
+#if _HAS_MSVC_ATTRIBUTE(known_semantics)
+#define _MSVC_KNOWN_SEMANTICS [[msvc::known_semantics]]
+#else
+#define _MSVC_KNOWN_SEMANTICS
+#endif
+
+// Should we use [[msvc::noop_dtor]] to tell the compiler that some non-trivial
+// destructors have no effects?
+#if _HAS_MSVC_ATTRIBUTE(noop_dtor)
+#define _MSVC_NOOP_DTOR [[msvc::noop_dtor]]
+#else
+#define _MSVC_NOOP_DTOR
+#endif
+
+// Should we use [[msvc::intrinsic]] allowing the compiler to implement the
+// behavior of certain trivial functions?
+#if _HAS_MSVC_ATTRIBUTE(intrinsic)
+#define _MSVC_INTRINSIC [[msvc::intrinsic]]
+#else
+#define _MSVC_INTRINSIC
+#endif
+
+// Should we enable [[msvc::lifetimebound]] or [[clang::lifetimebound]] warnings?
+#if !defined(__has_cpp_attribute) || defined(_SILENCE_LIFETIMEBOUND_WARNING)
+#define _MSVC_LIFETIMEBOUND
+#elif _HAS_MSVC_ATTRIBUTE(lifetimebound)
+#define _MSVC_LIFETIMEBOUND [[msvc::lifetimebound]]
+#elif __has_cpp_attribute(_Clang::__lifetimebound__)
+#define _MSVC_LIFETIMEBOUND [[_Clang::__lifetimebound__]]
+#else
+#define _MSVC_LIFETIMEBOUND
+#endif
+
+// Should we mark templates that users shouldn't specialize with [[msvc::no_specializations]]
+// or [[clang::no_specializations]]?
+#if _HAS_MSVC_ATTRIBUTE(no_specializations)
+#define _NO_SPECIALIZATIONS_MSG(_Msg) [[msvc::no_specializations(_Msg)]]
+#elif defined(__has_cpp_attribute) && __has_cpp_attribute(_Clang::__no_specializations__)
+#define _NO_SPECIALIZATIONS_MSG(_Msg) [[_Clang::__no_specializations__(_Msg)]]
+#else
+#define _NO_SPECIALIZATIONS_MSG(_Msg)
+#endif
+
+#define _NO_SPECIALIZATIONS_CITING(_Standardese) \
+    _NO_SPECIALIZATIONS_MSG("Specializing this standard library template is forbidden by " _Standardese)
+#define _NO_SPECIALIZATIONS_OF_VARIABLE_TEMPLATES     _NO_SPECIALIZATIONS_CITING("N5014 [namespace.std]/3")
+#define _NO_SPECIALIZATIONS_OF_MEMBER_CLASS_TEMPLATES _NO_SPECIALIZATIONS_CITING("N5014 [namespace.std]/4.3")
+#define _NO_SPECIALIZATIONS_OF_TYPE_TRAITS            _NO_SPECIALIZATIONS_CITING("N5014 [meta.rqmts]/4")
+
+#if _HAS_CXX23 // TRANSITION, ABI, should just use [[no_unique_address]] when _HAS_CXX20.
+// Should we enable use of [[msvc::no_unique_address]] or [[no_unique_address]] to allow potentially-overlapping member
+// subobjects?
+#if _HAS_MSVC_ATTRIBUTE(no_unique_address)
+#define _MSVC_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#elif __has_cpp_attribute(no_unique_address) // TRANSITION, DevCom-10747012, EDG recognizes [[no_unique_address]].
+#define _MSVC_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+#error Either [[msvc::no_unique_address]] or [[no_unique_address]] must be supported because this is ABI-critical.
+#endif
+#endif // _HAS_CXX23
+
+#undef _HAS_MSVC_ATTRIBUTE
+#pragma pop_macro("no_specializations")
+#pragma pop_macro("lifetimebound")
+#pragma pop_macro("intrinsic")
+#pragma pop_macro("noop_dtor")
+#pragma pop_macro("known_semantics")
+#pragma pop_macro("msvc")
+
+// warning C4577: 'noexcept' used with no exception handling mode specified;
+// termination on exception is not guaranteed. Specify /EHsc (/Wall)
+#if _HAS_EXCEPTIONS
+#define _STL_DISABLED_WARNING_C4577
+#else
+#define _STL_DISABLED_WARNING_C4577 4577
+#endif
+
+// warning C4984: 'if constexpr' is a C++17 language extension
+#if !_HAS_CXX17
+#define _STL_DISABLED_WARNING_C4984 4984
+#else
+#define _STL_DISABLED_WARNING_C4984
+#endif
+
+// warning C5053: support for 'explicit(<expr>)' in C++17 and earlier is a vendor extension
+#if !_HAS_CXX20
+#define _STL_DISABLED_WARNING_C5053 5053
+#else
+#define _STL_DISABLED_WARNING_C5053
+#endif
+
+#ifndef _STL_EXTRA_DISABLED_WARNINGS
+#define _STL_EXTRA_DISABLED_WARNINGS
+#endif // !defined(_STL_EXTRA_DISABLED_WARNINGS)
+
+// warning C4180: qualifier applied to function type has no meaning; ignored
+// warning C4324: structure was padded due to alignment specifier
+// warning C4412: function signature contains type 'meow'; C++ objects are unsafe to pass between pure code
+//                and mixed or native. (/Wall)
+// warning C4455: literal suffix identifiers that do not start with an underscore are reserved
+// warning C4494: Ignoring __declspec(allocator) because the function return type is not a pointer or reference
+// warning C4514: unreferenced inline function has been removed (/Wall)
+// warning C4574: 'MACRO' is defined to be '0': did you mean to use '#if MACRO'? (/Wall)
+// warning C4582: 'union': constructor is not implicitly called (/Wall)
+// warning C4583: 'union': destructor is not implicitly called (/Wall)
+// warning C4587: behavior change: constructor is no longer implicitly called (/Wall)
+// warning C4588: behavior change: destructor is no longer implicitly called (/Wall)
+// warning C4619: #pragma warning: there is no warning number 'number' (/Wall)
+// warning C4623: default constructor was implicitly defined as deleted (/Wall)
+// warning C4625: copy constructor was implicitly defined as deleted (/Wall)
+// warning C4626: assignment operator was implicitly defined as deleted (/Wall)
+// warning C4643: Forward declaring 'meow' in namespace std is not permitted by the C++ Standard. (/Wall)
+// warning C4648: standard attribute 'meow' is ignored
+// warning C4702: unreachable code
+// warning C4793: function compiled as native
+// warning C4820: 'N' bytes padding added after data member 'meow' (/Wall)
+// warning C4868: compiler may not enforce left-to-right evaluation order in braced initializer list (/Wall)
+// warning C4988: variable declared outside class/function scope (/Wall /d1WarnOnGlobals)
+// warning C5026: move constructor was implicitly defined as deleted (/Wall)
+// warning C5027: move assignment operator was implicitly defined as deleted (/Wall)
+// warning C5045: Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified (/Wall)
+// warning C5220: a non-static data member with a volatile qualified type no longer implies that compiler generated
+//                copy/move constructors and copy/move assignment operators are not trivial (/Wall)
+// warning C5246: 'member': the initialization of a subobject should be wrapped in braces (/Wall)
+// warning C5278: adding a specialization for 'type trait' has undefined behavior
+// warning C5280: a static operator '()' requires at least '/std:c++23preview'
+// warning C5281: a static lambda requires at least '/std:c++23preview'
+// warning C5285: cannot declare a specialization for 'meow'
+// warning C5291: 'DERIVED': deriving from the base class 'BASE' can cause potential runtime issues
+//                due to an ABI bug. Recommend adding a 4-byte data member to the base class
+//                for the padding at the end of it to work around this bug. (/Wall, TRANSITION, ABI)
+// warning C6294: Ill-defined for-loop: initial condition does not satisfy test. Loop body not executed
+
+#ifndef _STL_DISABLED_WARNINGS
+// clang-format off: make macros readable
+#define _STL_DISABLED_WARNINGS                        \
+    4180 4324 4412 4455 4494 4514 4574 4582 4583 4587 \
+    4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 \
+    4868 4988 5026 5027 5045 5220 5246 5278 5280 5281 \
+    5285 5291 6294                                    \
+    _STL_DISABLED_WARNING_C4577                       \
+    _STL_DISABLED_WARNING_C4984                       \
+    _STL_DISABLED_WARNING_C5053                       \
+    _STL_EXTRA_DISABLED_WARNINGS
+// clang-format on
+#endif // !defined(_STL_DISABLED_WARNINGS)
+
+// warning: constexpr if is a C++17 extension [-Wc++17-extensions]
+// warning: explicit(bool) is a C++20 extension [-Wc++20-extensions]
+// warning: declaring overloaded 'operator()' as 'static' is a C++23 extension [-Wc++23-extensions]
+// warning: static lambdas are a C++23 extension [-Wc++23-extensions]
+// warning: ignoring __declspec(allocator) because the function return type '%s' is not a pointer or reference type
+//     [-Wignored-attributes]
+// warning: '#pragma float_control' is not supported on this target - ignored [-Wignored-pragmas]
+// warning: '%s' cannot be specialized [-Winvalid-specialization]
+// warning: unknown pragma ignored [-Wunknown-pragmas]
+// warning: user-defined literal suffixes not starting with '_' are reserved [-Wuser-defined-literals]
+#ifndef _STL_DISABLE_CLANG_WARNINGS
+#ifdef __clang__
+// clang-format off: make macros readable
+#define _STL_DISABLE_CLANG_WARNINGS                                  \
+    _Pragma("clang diagnostic push")                                 \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"")       \
+    _Pragma("clang diagnostic ignored \"-Wc++20-extensions\"")       \
+    _Pragma("clang diagnostic ignored \"-Wc++23-extensions\"")       \
+    _Pragma("clang diagnostic ignored \"-Wignored-attributes\"")     \
+    _Pragma("clang diagnostic ignored \"-Wignored-pragmas\"")        \
+    _Pragma("clang diagnostic ignored \"-Winvalid-specialization\"") \
+    _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")        \
+    _Pragma("clang diagnostic ignored \"-Wuser-defined-literals\"")
+// clang-format on
+#elif defined(__CUDACC__) // use the same macros for Clang and CUDA's _Pragma operators
+// warning #342-D: operator may not be a static member function
+// warning #3395-D: a "static" lambda expression is nonstandard
+// clang-format off: make macros readable
+#define _STL_DISABLE_CLANG_WARNINGS  \
+    _Pragma("nv_diagnostic push")    \
+    _Pragma("nv_diag_suppress 342")  \
+    _Pragma("nv_diag_suppress 3395")
+// clang-format on
+#else // ^^^ defined(__CUDACC__) / !defined(__CUDACC__) vvv
+#define _STL_DISABLE_CLANG_WARNINGS
+#endif // ^^^ !defined(__CUDACC__) ^^^
+#endif // !defined(_STL_DISABLE_CLANG_WARNINGS)
+
+#ifndef _STL_RESTORE_CLANG_WARNINGS
+#ifdef __clang__
+#define _STL_RESTORE_CLANG_WARNINGS _Pragma("clang diagnostic pop")
+#elif defined(__CUDACC__) // use the same macros for Clang and CUDA's _Pragma operators
+#define _STL_RESTORE_CLANG_WARNINGS _Pragma("nv_diagnostic pop")
+#else // ^^^ defined(__CUDACC__) / !defined(__CUDACC__) vvv
+#define _STL_RESTORE_CLANG_WARNINGS
+#endif // ^^^ !defined(__CUDACC__) ^^^
+#endif // !defined(_STL_RESTORE_CLANG_WARNINGS)
+
+// warning: use of NaN is undefined behavior due to the currently enabled
+//     floating-point options [-Wnan-infinity-disabled]
+// warning: use of infinity is undefined behavior due to the currently enabled
+//     floating-point options [-Wnan-infinity-disabled]
+#ifndef _STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED
+#ifdef __clang__
+// clang-format off: make macros readable
+#define _STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED \
+    _Pragma("clang diagnostic push")                \
+    _Pragma("clang diagnostic ignored \"-Wnan-infinity-disabled\"")
+// clang-format on
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#define _STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED
+#endif // ^^^ !defined(__clang__) ^^^
+#endif // !defined(_STL_DISABLE_CLANG_WARNING_NAN_INF_DISABLED)
+
+#ifndef _STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED
+#ifdef __clang__
+#define _STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED _Pragma("clang diagnostic pop")
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#define _STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED
+#endif // ^^^ !defined(__clang__) ^^^
+#endif // !defined(_STL_RESTORE_CLANG_WARNING_NAN_INF_DISABLED)
+
+// clang-format off: make macros readable
+#ifndef _STL_DISABLE_DEPRECATED_WARNING
+#ifdef __clang__
+#define _STL_DISABLE_DEPRECATED_WARNING \
+    _Pragma("clang diagnostic push")    \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+// warning C4877: overriding non-pure virtual function 'Base::meow': was declared deprecated (/Wall)
+// warning C4996: 'meow': was declared deprecated
+#define _STL_DISABLE_DEPRECATED_WARNING \
+    _Pragma("warning(push)")            \
+    _Pragma("warning(disable : 4877 4996)")
+#endif // ^^^ !defined(__clang__) ^^^
+#endif // _STL_DISABLE_DEPRECATED_WARNING
+// clang-format on
+
+#ifndef _STL_RESTORE_DEPRECATED_WARNING
+#ifdef __clang__
+#define _STL_RESTORE_DEPRECATED_WARNING _Pragma("clang diagnostic pop")
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#define _STL_RESTORE_DEPRECATED_WARNING _Pragma("warning(pop)")
+#endif // ^^^ !defined(__clang__) ^^^
+#endif // !defined(_STL_RESTORE_DEPRECATED_WARNING)
+
+#define _CPPLIB_VER       650
+#define _MSVC_STL_VERSION 145
+#define _MSVC_STL_UPDATE  202605L
+
+#ifndef _ALLOW_COMPILER_AND_STL_VERSION_MISMATCH
+#if defined(__CUDACC__) && defined(__CUDACC_VER_MAJOR__)
+#if __CUDACC_VER_MAJOR__ < 13 || (__CUDACC_VER_MAJOR__ == 13 && __CUDACC_VER_MINOR__ < 2)
+_EMIT_STL_ERROR(STL1002, "Unexpected compiler version, expected CUDA 13.2 or newer.");
+#endif // ^^^ old CUDA ^^^
+#elif defined(__EDG__)
+// not attempting to detect __EDG_VERSION__ being less than expected
+#elif defined(__clang__)
+#if __clang_major__ < 22
+_EMIT_STL_ERROR(STL1000, "Unexpected compiler version, expected Clang 22 or newer.");
+#endif // ^^^ old Clang ^^^
+#elif defined(_MSC_VER)
+#if _MSC_VER < 1950 // Coarse-grained, not inspecting _MSC_FULL_VER
+_EMIT_STL_ERROR(STL1001, "Unexpected compiler version, expected MSVC Compiler 19.50 or newer.");
+#endif // ^^^ old MSVC ^^^
+#else // vvv other compilers vvv
+// not attempting to detect other compilers
+#endif // ^^^ other compilers ^^^
+#endif // !defined(_ALLOW_COMPILER_AND_STL_VERSION_MISMATCH)
+
+#ifndef _HAS_STATIC_RTTI
+#define _HAS_STATIC_RTTI 1
+#endif // !defined(_HAS_STATIC_RTTI)
+
+#if defined(_CPPRTTI) && !_HAS_STATIC_RTTI
+#error /GR implies _HAS_STATIC_RTTI.
+#endif // defined(_CPPRTTI) && !_HAS_STATIC_RTTI
+
+// N4950 [dcl.constexpr]/1: "A function or static data member declared with the
+// constexpr or consteval specifier is implicitly an inline function or variable"
+
+// Functions that became constexpr in C++17
+#if _HAS_CXX17
+#define _CONSTEXPR17 constexpr
+#else // ^^^ constexpr in C++17 and later / inline (not constexpr) in C++14 vvv
+#define _CONSTEXPR17 inline
+#endif // ^^^ inline (not constexpr) in C++14 ^^^
+
+// Functions that became constexpr in C++20
+#if _HAS_CXX20
+#define _CONSTEXPR20 constexpr
+#else // ^^^ constexpr in C++20 and later / inline (not constexpr) in C++17 and earlier vvv
+#define _CONSTEXPR20 inline
+#endif // ^^^ inline (not constexpr) in C++17 and earlier ^^^
+
+// Functions that became constexpr in C++23
+#if _HAS_CXX23
+#define _CONSTEXPR23 constexpr
+#else // ^^^ constexpr in C++23 and later / inline (not constexpr) in C++20 and earlier vvv
+#define _CONSTEXPR23 inline
+#endif // ^^^ inline (not constexpr) in C++20 and earlier ^^^
+
+// P2465R3 Standard Library Modules std And std.compat
+#ifdef _BUILD_STD_MODULE
+#if !_HAS_CXX20
+#error The Standard Library Modules are available only with C++20 or later.
+#endif // ^^^ !_HAS_CXX20 ^^^
+#define _EXPORT_STD export
+#else // ^^^ defined(_BUILD_STD_MODULE) / !defined(_BUILD_STD_MODULE) vvv
+#define _EXPORT_STD
+#endif // ^^^ !defined(_BUILD_STD_MODULE) ^^^
+
+// P0607R0 Inline Variables For The STL
+#if _HAS_CXX17
+#define _INLINE_VAR inline
+#else
+#define _INLINE_VAR
+#endif
+
+// N4190 Removing auto_ptr, random_shuffle(), And Old <functional> Stuff
+#ifndef _HAS_AUTO_PTR_ETC
+#define _HAS_AUTO_PTR_ETC (!_HAS_CXX17)
+#endif // !defined(_HAS_AUTO_PTR_ETC)
+
+// P0003R5 Removing Dynamic Exception Specifications
+#ifndef _HAS_UNEXPECTED
+#define _HAS_UNEXPECTED (!_HAS_CXX17)
+#endif // !defined(_HAS_UNEXPECTED)
+
+#if _HAS_UNEXPECTED && _HAS_CXX23
+_EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpected<E>.");
+#endif // _HAS_UNEXPECTED && _HAS_CXX23
+
+// P0004R1 Removing Deprecated Iostreams Aliases
+#ifndef _HAS_OLD_IOSTREAMS_MEMBERS
+#define _HAS_OLD_IOSTREAMS_MEMBERS (!_HAS_CXX17)
+#endif // !defined(_HAS_OLD_IOSTREAMS_MEMBERS)
+
+// P0298R3 std::byte
+#ifndef _HAS_STD_BYTE
+#define _HAS_STD_BYTE _HAS_CXX17 // TRANSITION, OS-14273702
+#endif // !defined(_HAS_STD_BYTE)
+
+// P0302R1 Removing Allocator Support In std::function
+// LWG-2385 function::assign allocator argument doesn't make sense
+#ifndef _HAS_FUNCTION_ALLOCATOR_SUPPORT
+#define _HAS_FUNCTION_ALLOCATOR_SUPPORT (!_HAS_CXX17)
+#endif // !defined(_HAS_FUNCTION_ALLOCATOR_SUPPORT)
+
+// STL4000 is "_STATIC_CPPLIB is deprecated", currently in yvals.h
+// STL4001 is "/clr:pure is deprecated", currently in yvals.h
+// STL4002 was "The non-Standard std::tr1 namespace and TR1-only machinery are deprecated and will be REMOVED."
+// STL4003 was "The non-Standard std::identity struct is deprecated and will be REMOVED."
+
+// Enforcement of matching allocator value_types
+#ifndef _ENFORCE_MATCHING_ALLOCATORS
+#define _ENFORCE_MATCHING_ALLOCATORS _HAS_CXX17
+#endif // !defined(_ENFORCE_MATCHING_ALLOCATORS)
+
+#define _MISMATCHED_ALLOCATOR_MESSAGE(_CONTAINER, _VALUE_TYPE)                                                      \
+    _CONTAINER " requires that Allocator's value_type match " _VALUE_TYPE " (See N4950 [container.alloc.reqmts]/5)" \
+               " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0"                      \
+               " to suppress this error."
+
+// Enforcement of Standard facet specializations
+#ifndef _ENFORCE_FACET_SPECIALIZATIONS
+#define _ENFORCE_FACET_SPECIALIZATIONS 0
+#endif // !defined(_ENFORCE_FACET_SPECIALIZATIONS)
+
+#define _FACET_SPECIALIZATION_MESSAGE                                                  \
+    "Unsupported facet specialization; see N4950 [locale.category]. "                  \
+    "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " \
+    "to suppress this error."
+
+// To improve compiler throughput, use 'hidden friend' operators in <system_error> instead of non-members that are
+// depicted in the Standard.
+#ifndef _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS
+#define _STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS 1
+#endif // !defined(_STL_OPTIMIZE_SYSTEM_ERROR_OPERATORS)
+
+// Controls whether the STL will force /fp:fast to enable vectorization of algorithms defined
+// in the standard as special cases; such as reduce, transform_reduce, inclusive_scan, exclusive_scan
+#ifndef _STD_VECTORIZE_WITH_FLOAT_CONTROL
+#ifdef _M_FP_EXCEPT
+#define _STD_VECTORIZE_WITH_FLOAT_CONTROL 0
+#else // ^^^ floating-point exceptions enabled / floating-point exceptions disabled (default) vvv
+#define _STD_VECTORIZE_WITH_FLOAT_CONTROL 1
+#endif // ^^^ floating-point exceptions disabled (default) ^^^
+#endif // !defined(_STD_VECTORIZE_WITH_FLOAT_CONTROL)
+
+// P0174R2 Deprecating Vestigial Library Parts
+// P0521R0 Deprecating shared_ptr::unique()
+// Other C++17 deprecation warnings
+
+// N4659 D.4 [depr.cpp.headers]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_C_HEADER                                                               \
+    [[deprecated("warning STL4004: "                                                            \
+                 "<ccomplex>, <cstdalign>, <cstdbool>, and <ctgmath> are deprecated in C++17. " \
+                 "You can define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING "                  \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_C_HEADER
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.6 [depr.str.strstreams]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_STRSTREAM_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_STRSTREAM                                              \
+    [[deprecated("warning STL4005: <strstream> is deprecated in C++17. "        \
+                 "You can define _SILENCE_CXX17_STRSTREAM_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_STRSTREAM
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.7 [depr.uncaught]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_UNCAUGHT_EXCEPTION                                              \
+    [[deprecated("warning STL4006: "                                                     \
+                 "std::uncaught_exception() is deprecated in C++17. "                    \
+                 "It is superseded by std::uncaught_exceptions(), plural. "              \
+                 "You can define _SILENCE_CXX17_UNCAUGHT_EXCEPTION_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_UNCAUGHT_EXCEPTION
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.8.1 [depr.weak.result_type]
+// N4659 D.8.2 [depr.func.adaptor.typedefs]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS                                                                         \
+    [[deprecated(                                                                                                 \
+        "warning STL4007: Many result_type typedefs "                                                             \
+        "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " \
+        "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING "                                     \
+        "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.8.3 [depr.negators]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_NEGATORS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_NEGATORS                                                                                \
+    [[deprecated("warning STL4008: "                                                                             \
+                 "std::not1(), std::not2(), std::unary_negate, and std::binary_negate are deprecated in C++17. " \
+                 "They are superseded by std::not_fn(). "                                                        \
+                 "You can define _SILENCE_CXX17_NEGATORS_DEPRECATION_WARNING "                                   \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_NEGATORS
+#endif // ^^^ warning disabled ^^^
+
+// STL4009 was "std::allocator<void> is deprecated in C++17"
+
+// N4659 D.9 [depr.default.allocator]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS                                              \
+    [[deprecated("warning STL4010: "                                                        \
+                 "Various members of std::allocator are deprecated in C++17. "              \
+                 "Use std::allocator_traits instead of accessing these members directly. "  \
+                 "You can define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_OLD_ALLOCATOR_MEMBERS
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.10 [depr.storage.iterator]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_RAW_STORAGE_ITERATOR_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_RAW_STORAGE_ITERATOR                                                  \
+    [[deprecated("warning STL4011: "                                                           \
+                 "std::raw_storage_iterator is deprecated in C++17. "                          \
+                 "Consider using the std::uninitialized_copy() family of algorithms instead. " \
+                 "You can define _SILENCE_CXX17_RAW_STORAGE_ITERATOR_DEPRECATION_WARNING "     \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_RAW_STORAGE_ITERATOR
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.11 [depr.temporary.buffer]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_TEMPORARY_BUFFER_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_TEMPORARY_BUFFER                                                                   \
+    [[deprecated("warning STL4012: "                                                                        \
+                 "std::get_temporary_buffer() and std::return_temporary_buffer() are deprecated in C++17. " \
+                 "You can define _SILENCE_CXX17_TEMPORARY_BUFFER_DEPRECATION_WARNING "                      \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_TEMPORARY_BUFFER
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.12 [depr.meta.types]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_IS_LITERAL_TYPE_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_IS_LITERAL_TYPE                                                     \
+    [[deprecated("warning STL4013: "                                                         \
+                 "std::is_literal_type and std::is_literal_type_v are deprecated in C++17. " \
+                 "You can define _SILENCE_CXX17_IS_LITERAL_TYPE_DEPRECATION_WARNING "        \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_IS_LITERAL_TYPE
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.12 [depr.meta.types]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_RESULT_OF_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_RESULT_OF                                                      \
+    [[deprecated("warning STL4014: "                                                    \
+                 "std::result_of and std::result_of_t are deprecated in C++17. "        \
+                 "They are superseded by std::invoke_result and std::invoke_result_t. " \
+                 "You can define _SILENCE_CXX17_RESULT_OF_DEPRECATION_WARNING "         \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_RESULT_OF
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.13 [depr.iterator.primitives]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_ITERATOR_BASE_CLASS                                                                          \
+    [[deprecated(                                                                                                     \
+        "warning STL4015: "                                                                                           \
+        "The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17. "        \
+        "(The <iterator> header is NOT deprecated.) The C++ Standard has never required user-defined iterators to "   \
+        "derive from std::iterator. To fix this warning, stop deriving from std::iterator and start providing "       \
+        "publicly accessible typedefs named iterator_category, value_type, difference_type, pointer, and reference. " \
+        "Note that value_type is required to be non-const, even for constant iterators. "                             \
+        "You can define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING "                                      \
+        "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_ITERATOR_BASE_CLASS
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.14 [depr.util.smartptr.shared.obs]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_SHARED_PTR_UNIQUE                                              \
+    [[deprecated("warning STL4016: "                                                    \
+                 "std::shared_ptr::unique() is deprecated in C++17. "                   \
+                 "You can define _SILENCE_CXX17_SHARED_PTR_UNIQUE_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_SHARED_PTR_UNIQUE
+#endif // ^^^ warning disabled ^^^
+
+// N4659 D.15 [depr.locale.stdcvt]
+// N4659 D.16 [depr.conversions]
+#if _HAS_CXX17 && !defined(_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
+#define _CXX17_DEPRECATE_CODECVT_HEADER                                                                        \
+    [[deprecated(                                                                                              \
+        "warning STL4017: "                                                                                    \
+        "std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, " \
+        "std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. "        \
+        "(The std::codecvt class template is NOT deprecated.) "                                                \
+        "The C++ Standard doesn't provide equivalent non-deprecated functionality; "                           \
+        "consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. "            \
+        "You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING "                                    \
+        "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX17_DEPRECATE_CODECVT_HEADER
+#endif // ^^^ warning disabled ^^^
+
+// STL4018 was "The non-Standard std::tr2::sys namespace is deprecated and will be REMOVED."
+
+// STL4019 was "The member std::fpos::seekpos() is non-Standard, and [...] will be removed"
+
+// P0482R6 Library Support For char8_t
+// Other C++20 deprecation warnings
+
+// N4868 D.23 [depr.locale.category]
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_CODECVT_FACETS                                                                                \
+    [[deprecated("warning STL4020: "                                                                                   \
+                 "std::codecvt<char16_t, char, mbstate_t>, std::codecvt<char32_t, char, mbstate_t>, "                  \
+                 "std::codecvt_byname<char16_t, char, mbstate_t>, and std::codecvt_byname<char32_t, char, mbstate_t> " \
+                 "are deprecated in C++20. You can define _SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING "          \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_CODECVT_FACETS
+#endif // ^^^ warning disabled ^^^
+
+// N4868 D.24 [depr.fs.path.factory]
+#if _HAS_CXX20 && defined(__cpp_char8_t) && !defined(_SILENCE_CXX20_U8PATH_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_U8PATH                                                                                      \
+    [[deprecated("warning STL4021: "                                                                                 \
+                 "The std::filesystem::u8path() overloads are deprecated in C++20. "                                 \
+                 "The constructors of std::filesystem::path provide equivalent functionality via construction from " \
+                 "u8string, u8string_view, or iterators with value_type char8_t. "                                   \
+                 "You can define _SILENCE_CXX20_U8PATH_DEPRECATION_WARNING "                                         \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_U8PATH
+#endif // ^^^ warning disabled ^^^
+
+// STL4022 warned about "The hash_meow and unordered_meow containers' non-Standard lower_bound() member"
+// STL4023 warned about "The hash_meow and unordered_meow containers' non-Standard upper_bound() member"
+
+// P0966R1 [depr.string.capacity]
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_STRING_RESERVE_WITHOUT_ARGUMENT_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_STRING_RESERVE_WITHOUT_ARGUMENT                                                             \
+    [[deprecated("warning STL4024: "                                                                                 \
+                 "std::string::reserve() without an argument is deprecated in C++20. "                               \
+                 "To shrink the string's capacity, use std::string::shrink_to_fit() instead. Otherwise, provide an " \
+                 "argument to std::string::reserve(). "                                                              \
+                 "You can define _SILENCE_CXX20_STRING_RESERVE_WITHOUT_ARGUMENT_DEPRECATION_WARNING "                \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_STRING_RESERVE_WITHOUT_ARGUMENT
+#endif // ^^^ warning disabled ^^^
+
+// P0767R1 [depr.meta.types]
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_IS_POD_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_IS_POD                                                                                     \
+    [[deprecated("warning STL4025: "                                                                                \
+                 "std::is_pod and std::is_pod_v are deprecated in C++20. "                                          \
+                 "The std::is_trivially_copyable and/or std::is_standard_layout traits likely suit your use case. " \
+                 "You can define _SILENCE_CXX20_IS_POD_DEPRECATION_WARNING "                                        \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_IS_POD
+#endif // ^^^ warning disabled ^^^
+
+// STL4026 was
+// "std::experimental::erase() and std::experimental::erase_if() are deprecated by Microsoft and will be REMOVED."
+
+// P0768R1 [depr.relops]
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_REL_OPS                                                                                      \
+    [[deprecated("warning STL4027: "                                                                                  \
+                 "The namespace std::rel_ops and its contents are deprecated in C++20. "                              \
+                 "Their use is superseded by C++20's <=> operator and automatic rewrites of relational expressions. " \
+                 "You can define _SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING or "                                      \
+                 "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_REL_OPS
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_ATOMIC_INIT_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_ATOMIC_INIT                                                  \
+    [[deprecated("warning STL4028: "                                                  \
+                 "std::atomic_init() overloads are deprecated in C++20. "             \
+                 "The constructors of std::atomic provide equivalent functionality. " \
+                 "You can define _SILENCE_CXX20_ATOMIC_INIT_DEPRECATION_WARNING "     \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_ATOMIC_INIT
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT                                              \
+    [[deprecated("warning STL4029: "                                                                \
+                 "std::atomic_*() overloads for shared_ptr are deprecated in C++20. "               \
+                 "The shared_ptr specialization of std::atomic provides superior functionality. "   \
+                 "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_OLD_SHARED_PTR_ATOMIC_SUPPORT
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_VOLATILE                                                                   \
+    [[deprecated("warning STL4030: "                                                                \
+                 "Some operations on volatile-qualified types in the STL are deprecated in C++20. " \
+                 "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING "                      \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_VOLATILE
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_MOVE_ITERATOR_ARROW_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_MOVE_ITERATOR_ARROW                                              \
+    [[deprecated("warning STL4031: "                                                      \
+                 "std::move_iterator::operator->() is deprecated in C++20. "              \
+                 "You can define _SILENCE_CXX20_MOVE_ITERATOR_ARROW_DEPRECATION_WARNING " \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_MOVE_ITERATOR_ARROW
+#endif // ^^^ warning disabled ^^^
+
+// STL4032 was "std::pmr::polymorphic_allocator::destroy() is deprecated in C++17 by LWG-3036." (reverted by P2875R4)
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_IS_ALWAYS_EQUAL_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_IS_ALWAYS_EQUAL                                                \
+    [[deprecated("warning STL4033: "                                                    \
+                 "std::allocator::is_always_equal is deprecated in C++20 by LWG-3170. " \
+                 "Prefer std::allocator_traits<allocator<T>>::is_always_equal. "        \
+                 "You can define _SILENCE_CXX20_IS_ALWAYS_EQUAL_DEPRECATION_WARNING "   \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_IS_ALWAYS_EQUAL
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX23 && !defined(_SILENCE_CXX23_ALIGNED_STORAGE_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS)
+#define _CXX23_DEPRECATE_ALIGNED_STORAGE                                                     \
+    [[deprecated("warning STL4034: "                                                         \
+                 "std::aligned_storage and std::aligned_storage_t are deprecated in C++23. " \
+                 "Prefer alignas(T) std::byte t_buff[sizeof(T)]. "                           \
+                 "You can define _SILENCE_CXX23_ALIGNED_STORAGE_DEPRECATION_WARNING "        \
+                 "or _SILENCE_ALL_CXX23_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX23_DEPRECATE_ALIGNED_STORAGE
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX23 && !defined(_SILENCE_CXX23_ALIGNED_UNION_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS)
+#define _CXX23_DEPRECATE_ALIGNED_UNION                                                   \
+    [[deprecated("warning STL4035: "                                                     \
+                 "std::aligned_union and std::aligned_union_t are deprecated in C++23. " \
+                 "Prefer alignas(Ts...) std::byte t_buff[std::max({sizeof(Ts)...})]. "   \
+                 "You can define _SILENCE_CXX23_ALIGNED_UNION_DEPRECATION_WARNING "      \
+                 "or _SILENCE_ALL_CXX23_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX23_DEPRECATE_ALIGNED_UNION
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX20 && !defined(_SILENCE_CXX20_CISO646_REMOVED_WARNING) && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_REMOVE_CISO646                                             \
+    [[deprecated("warning STL4036: "                                      \
+                 "<ciso646> is removed in C++20. "                        \
+                 "You can define _SILENCE_CXX20_CISO646_REMOVED_WARNING " \
+                 "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_REMOVE_CISO646
+#endif // ^^^ warning disabled ^^^
+
+#if !defined(_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING)
+#define _DEPRECATE_NONFLOATING_COMPLEX                                                 \
+    [[deprecated("warning STL4037: "                                                   \
+                 "The effect of instantiating the template std::complex for any "      \
+                 "type other than float, double, or long double is unspecified. "      \
+                 "You can define _SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING to " \
+                 "suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _DEPRECATE_NONFLOATING_COMPLEX
+#endif // ^^^ warning disabled ^^^
+
+// STL4038 is used to warn that "The contents of <meow> are available only with C++NN or later."
+
+// STL4039 is used to warn that "The contents of <coroutine> are not available with /await."
+
+// STL4040 is used to warn that "The contents of <any> require static RTTI."
+
+#if _HAS_CXX23 && !defined(_SILENCE_CXX23_UNIX_STREAMS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS)
+#define _CXX23_DEPRECATE_UNIX_STREAMS                                                                                  \
+    [[deprecated(                                                                                                      \
+        "warning STL4041: "                                                                                            \
+        "std::errc enumerators std::errc::no_message_available, std::errc::no_stream_resources, "                      \
+        "std::errc::not_a_stream, and std::errc::stream_timeout and their corresponding errno macros ENODATA, ENOSR, " \
+        "ENOSTR, and ETIME are deprecated in C++23 by LWG-3869. These errno macros are deprecated in POSIX 2008 and "  \
+        "removed in POSIX 202x. You can define _SILENCE_CXX23_UNIX_STREAMS_DEPRECATION_WARNING or "                    \
+        "_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX23_DEPRECATE_UNIX_STREAMS
+#endif // ^^^ warning disabled ^^^
+
+#if _HAS_CXX23 && !defined(_SILENCE_CXX23_DENORM_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS)
+#define _CXX23_DEPRECATE_DENORM                                                                                        \
+    [[deprecated("warning STL4042: "                                                                                   \
+                 "std::float_denorm_style, std::numeric_limits::has_denorm, and std::numeric_limits::has_denorm_loss " \
+                 "are deprecated in C++23. You can define _SILENCE_CXX23_DENORM_DEPRECATION_WARNING or "               \
+                 "_SILENCE_ALL_CXX23_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX23_DEPRECATE_DENORM
+#endif // ^^^ warning disabled ^^^
+
+// STL4043 was "stdext::checked_array_iterator, stdext::unchecked_array_iterator,
+// and related factory functions are non-Standard extensions and will be removed"
+
+// STL4044 was "The contents of the stdext::cvt namespace are non-Standard extensions and will be removed"
+
+// STL4045 was "The ipfx(), isfx(), opfx(), and osfx() functions are [...] non-Standard extensions"
+
+// STL4046 was "Non-Standard TR1 components in <random> are deprecated and will be REMOVED."
+
+#if _HAS_CXX20 && defined(__cpp_char8_t) && !defined(_SILENCE_CXX20_CODECVT_CHAR8_T_FACETS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS                                                                     \
+    [[deprecated(                                                                                                   \
+        "warning STL4047: std::codecvt<char16_t, char8_t, mbstate_t>, std::codecvt<char32_t, char8_t, mbstate_t>, " \
+        "std::codecvt_byname<char16_t, char8_t, mbstate_t>, and std::codecvt_byname<char32_t, char8_t, mbstate_t> " \
+        "are deprecated by LWG-3767. You can define _SILENCE_CXX20_CODECVT_CHAR8_T_FACETS_DEPRECATION_WARNING or "  \
+        "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS
+#endif // ^^^ warning disabled ^^^
+
+// STL4048 was "locale::empty() is a non-Standard extension and will be removed in the future."
+
+
+#if _HAS_CXX26 && !defined(_SILENCE_VECTOR_BOOL_STATIC_REFERENCE_SWAP_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX26_DEPRECATION_WARNINGS)
+#define _DEPRECATE_VECTOR_BOOL_STATIC_REFERENCE_SWAP                                                                  \
+    [[deprecated("warning STL4049: Static std::vector<bool>::swap(reference, reference) is deprecated by C++26 (see " \
+                 "LWG-3638 and P3612R1). Use non-member function swap(reference, reference) instead. You can define " \
+                 "_SILENCE_VECTOR_BOOL_STATIC_REFERENCE_SWAP_DEPRECATION_WARNING or "                                 \
+                 "_SILENCE_ALL_CXX26_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _DEPRECATE_VECTOR_BOOL_STATIC_REFERENCE_SWAP
+#endif // ^^^ warning disabled ^^^
+
+// next warning number: STL4050
+
+// next error number: STL1014
+
+// P0619R4 Removing C++17-Deprecated Features
+#ifndef _HAS_FEATURES_REMOVED_IN_CXX20
+#define _HAS_FEATURES_REMOVED_IN_CXX20 (!_HAS_CXX20)
+#endif // !defined(_HAS_FEATURES_REMOVED_IN_CXX20)
+
+#ifndef _HAS_DEPRECATED_ADAPTOR_TYPEDEFS
+#define _HAS_DEPRECATED_ADAPTOR_TYPEDEFS (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_ADAPTOR_TYPEDEFS)
+
+#ifndef _HAS_DEPRECATED_ALLOCATOR_MEMBERS
+#define _HAS_DEPRECATED_ALLOCATOR_MEMBERS (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_ALLOCATOR_MEMBERS)
+
+#ifndef _HAS_DEPRECATED_ALLOCATOR_VOID
+#define _HAS_DEPRECATED_ALLOCATOR_VOID (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_ALLOCATOR_VOID)
+
+#ifndef _HAS_DEPRECATED_IS_LITERAL_TYPE
+#define _HAS_DEPRECATED_IS_LITERAL_TYPE (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_IS_LITERAL_TYPE)
+
+#ifndef _HAS_DEPRECATED_NEGATORS
+#define _HAS_DEPRECATED_NEGATORS (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_NEGATORS)
+
+#ifndef _HAS_DEPRECATED_RAW_STORAGE_ITERATOR
+#define _HAS_DEPRECATED_RAW_STORAGE_ITERATOR (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_RAW_STORAGE_ITERATOR)
+
+#ifndef _HAS_DEPRECATED_RESULT_OF
+#define _HAS_DEPRECATED_RESULT_OF (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_RESULT_OF)
+
+#ifndef _HAS_DEPRECATED_SHARED_PTR_UNIQUE
+#define _HAS_DEPRECATED_SHARED_PTR_UNIQUE (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_SHARED_PTR_UNIQUE)
+
+#ifndef _HAS_DEPRECATED_TEMPORARY_BUFFER
+#define _HAS_DEPRECATED_TEMPORARY_BUFFER (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_TEMPORARY_BUFFER)
+
+#ifndef _HAS_DEPRECATED_UNCAUGHT_EXCEPTION
+#define _HAS_DEPRECATED_UNCAUGHT_EXCEPTION (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_DEPRECATED_UNCAUGHT_EXCEPTION)
+
+#if _HAS_DEPRECATED_ADAPTOR_TYPEDEFS
+#define _ARGUMENT_TYPE_NAME        argument_type
+#define _FIRST_ARGUMENT_TYPE_NAME  first_argument_type
+#define _SECOND_ARGUMENT_TYPE_NAME second_argument_type
+#define _RESULT_TYPE_NAME          result_type
+#else // ^^^ _HAS_DEPRECATED_ADAPTOR_TYPEDEFS / !_HAS_DEPRECATED_ADAPTOR_TYPEDEFS vvv
+#define _ARGUMENT_TYPE_NAME        _Unnameable_argument
+#define _FIRST_ARGUMENT_TYPE_NAME  _Unnameable_first_argument
+#define _SECOND_ARGUMENT_TYPE_NAME _Unnameable_second_argument
+#define _RESULT_TYPE_NAME          _Unnameable_result
+#endif // ^^^ !_HAS_DEPRECATED_ADAPTOR_TYPEDEFS ^^^
+
+// P1423R3 char8_t Backward Compatibility Remediation
+// Controls whether we allow the stream insertions this proposal forbids
+#ifndef _HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20
+#define _HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20 (_HAS_FEATURES_REMOVED_IN_CXX20)
+#endif // !defined(_HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20)
+
+#ifndef _HAS_FEATURES_REMOVED_IN_CXX23
+#define _HAS_FEATURES_REMOVED_IN_CXX23 (!_HAS_CXX23)
+#endif // !defined(_HAS_FEATURES_REMOVED_IN_CXX23)
+
+// P2186R2 Removing Garbage Collection Support
+#ifndef _HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23
+#define _HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23 (_HAS_FEATURES_REMOVED_IN_CXX23)
+#endif // !defined(_HAS_GARBAGE_COLLECTION_SUPPORT_DELETED_IN_CXX23)
+
+// C++14
+#define __cpp_lib_chrono_udls                      201304L
+#define __cpp_lib_complex_udls                     201309L
+#define __cpp_lib_exchange_function                201304L
+#define __cpp_lib_freestanding_algorithm           202311L
+#define __cpp_lib_freestanding_array               202311L
+#define __cpp_lib_freestanding_char_traits         202306L
+#define __cpp_lib_freestanding_cstdlib             202306L
+#define __cpp_lib_freestanding_cstring             202311L
+#define __cpp_lib_freestanding_cwchar              202306L
+#define __cpp_lib_freestanding_errc                202306L
+#define __cpp_lib_freestanding_feature_test_macros 202306L
+#define __cpp_lib_freestanding_functional          202306L
+#define __cpp_lib_freestanding_iterator            202306L
+#define __cpp_lib_freestanding_memory              202306L
+#define __cpp_lib_freestanding_operator_new        202306L
+#define __cpp_lib_freestanding_ratio               202306L
+#define __cpp_lib_freestanding_tuple               202306L
+#define __cpp_lib_freestanding_utility             202306L
+#define __cpp_lib_generic_associative_lookup       201304L
+#define __cpp_lib_initializer_list                 202511L
+#define __cpp_lib_integer_sequence                 201304L
+#define __cpp_lib_integral_constant_callable       201304L
+#define __cpp_lib_is_final                         201402L
+#define __cpp_lib_is_null_pointer                  201309L
+#define __cpp_lib_make_reverse_iterator            201402L
+#define __cpp_lib_make_unique                      201304L
+#define __cpp_lib_null_iterators                   201304L
+#define __cpp_lib_quoted_string_io                 201304L
+#define __cpp_lib_result_of_sfinae                 201210L
+#define __cpp_lib_robust_nonmodifying_seq_ops      201304L
+#ifndef _M_CEE_PURE
+#define __cpp_lib_shared_timed_mutex 201402L
+#endif // !defined(_M_CEE_PURE)
+#define __cpp_lib_string_udls                  201304L
+#define __cpp_lib_transformation_trait_aliases 201304L
+#define __cpp_lib_tuple_element_t              201402L
+#define __cpp_lib_tuples_by_type               201304L
+#define __cpp_lib_valarray                     202511L
+
+// C++17
+#define __cpp_lib_addressof_constexpr              201603L
+#define __cpp_lib_allocator_traits_is_always_equal 201411L
+#define __cpp_lib_as_const                         201510L
+#define __cpp_lib_bool_constant                    201505L
+#define __cpp_lib_enable_shared_from_this          201603L
+#define __cpp_lib_incomplete_container_elements    201505L
+#define __cpp_lib_invoke                           201411L
+#define __cpp_lib_logical_traits                   201510L
+#define __cpp_lib_map_try_emplace                  201411L
+#define __cpp_lib_nonmember_container_access       201411L
+#define __cpp_lib_shared_mutex                     201505L
+#define __cpp_lib_transparent_operators            201510L
+#define __cpp_lib_type_trait_variable_templates    201510L
+#define __cpp_lib_uncaught_exceptions              201411L
+#define __cpp_lib_unordered_map_try_emplace        201411L
+#define __cpp_lib_void_t                           201411L
+
+#if _HAS_CXX17
+#if _HAS_STATIC_RTTI
+#define __cpp_lib_any 201606L
+#endif // _HAS_STATIC_RTTI
+#define __cpp_lib_apply                      201603L
+#define __cpp_lib_atomic_is_always_lock_free 201603L
+#define __cpp_lib_boyer_moore_searcher       201603L
+#if _HAS_STD_BYTE
+#define __cpp_lib_byte 201603L
+#endif // _HAS_STD_BYTE
+#define __cpp_lib_clamp                             201603L
+#define __cpp_lib_filesystem                        201703L
+#define __cpp_lib_freestanding_charconv             202306L
+#define __cpp_lib_freestanding_optional             202311L
+#define __cpp_lib_freestanding_string_view          202311L
+#define __cpp_lib_freestanding_variant              202311L
+#define __cpp_lib_gcd_lcm                           201606L
+#define __cpp_lib_hardware_interference_size        201703L
+#define __cpp_lib_has_unique_object_representations 201606L
+#define __cpp_lib_hypot                             201603L
+#define __cpp_lib_is_aggregate                      201703L
+#define __cpp_lib_is_invocable                      201703L
+#define __cpp_lib_is_swappable                      201603L
+#define __cpp_lib_launder                           201606L
+#define __cpp_lib_make_from_tuple                   201606L
+#define __cpp_lib_math_special_functions            201603L
+#define __cpp_lib_memory_resource                   201603L
+#define __cpp_lib_node_extract                      201606L
+#define __cpp_lib_not_fn                            201603L
+#ifndef _M_CEE_PURE
+#define __cpp_lib_parallel_algorithm 201603L
+#endif // !defined(_M_CEE_PURE)
+#define __cpp_lib_raw_memory_algorithms 201606L
+#define __cpp_lib_sample                201603L
+#define __cpp_lib_scoped_lock           201703L
+#define __cpp_lib_shared_ptr_weak_type  201606L
+#define __cpp_lib_string_view           201803L
+#define __cpp_lib_to_chars              201611L
+#endif // _HAS_CXX17
+
+// C++20
+#define __cpp_lib_atomic_value_initialization 201911L
+
+#ifdef __cpp_char8_t
+#define __cpp_lib_char8_t 201907L
+#endif // defined(__cpp_char8_t)
+
+#ifdef __cpp_impl_coroutine
+#define __cpp_lib_coroutine 201902L
+#endif // defined(__cpp_impl_coroutine)
+
+#if _HAS_CXX20
+#define __cpp_lib_algorithm_iterator_requirements 202207L
+#define __cpp_lib_assume_aligned                  201811L
+#define __cpp_lib_atomic_flag_test                201907L
+#define __cpp_lib_atomic_float                    201711L
+#define __cpp_lib_atomic_lock_free_type_aliases   201907L
+#define __cpp_lib_atomic_ref                      201806L
+#define __cpp_lib_atomic_shared_ptr               201711L
+#define __cpp_lib_atomic_wait                     201907L
+#define __cpp_lib_barrier                         202302L
+#define __cpp_lib_bind_front                      201907L
+#define __cpp_lib_bit_cast                        201806L
+#define __cpp_lib_bitops                          201907L
+#define __cpp_lib_bounded_array_traits            201902L
+#define __cpp_lib_common_reference                202302L
+#define __cpp_lib_common_reference_wrapper        202302L
+#define __cpp_lib_concepts                        202207L
+#define __cpp_lib_constexpr_algorithms            201806L
+#define __cpp_lib_constexpr_complex               201711L
+#define __cpp_lib_constexpr_dynamic_alloc         201907L
+#define __cpp_lib_constexpr_functional            201907L
+#define __cpp_lib_constexpr_iterator              201811L
+#define __cpp_lib_constexpr_numeric               201911L
+#define __cpp_lib_constexpr_string                201907L
+#define __cpp_lib_constexpr_string_view           201811L
+#define __cpp_lib_constexpr_tuple                 201811L
+#define __cpp_lib_constexpr_utility               201811L
+#define __cpp_lib_constexpr_vector                201907L
+#define __cpp_lib_destroying_delete               201806L
+#define __cpp_lib_endian                          201907L
+#define __cpp_lib_erase_if                        202002L
+#define __cpp_lib_format                          202304L
+#define __cpp_lib_format_uchar                    202311L
+#define __cpp_lib_freestanding_ranges             202306L
+#define __cpp_lib_generic_unordered_lookup        201811L
+#define __cpp_lib_int_pow2                        202002L
+#define __cpp_lib_integer_comparison_functions    202002L
+#define __cpp_lib_interpolate                     201902L
+#define __cpp_lib_is_constant_evaluated           201811L
+
+#ifndef __clang__ // TRANSITION, LLVM-48860
+#define __cpp_lib_is_layout_compatible 201907L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_is_nothrow_convertible 201806L
+
+#ifndef __clang__ // TRANSITION, LLVM-48860
+#define __cpp_lib_is_pointer_interconvertible 201907L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_jthread                 201911L
+#define __cpp_lib_latch                   201907L
+#define __cpp_lib_list_remove_return_type 201806L
+#define __cpp_lib_math_constants          201907L
+
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, Clang and EDG support for modules
+#define __cpp_lib_modules 202207L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_move_iterator_concept   202207L
+#define __cpp_lib_polymorphic_allocator   201902L
+#define __cpp_lib_remove_cvref            201711L
+#define __cpp_lib_semaphore               201907L
+#define __cpp_lib_smart_ptr_for_overwrite 202002L
+#define __cpp_lib_source_location         201907L
+#define __cpp_lib_span                    202002L
+#define __cpp_lib_ssize                   201902L
+#define __cpp_lib_starts_ends_with        201711L
+#define __cpp_lib_syncbuf                 201803L
+#define __cpp_lib_three_way_comparison    201907L
+#define __cpp_lib_to_address              201711L
+#define __cpp_lib_to_array                201907L
+#define __cpp_lib_type_identity           201806L
+#define __cpp_lib_unwrap_ref              201811L
+#endif // _HAS_CXX20
+
+// C++23
+#if _HAS_CXX23
+#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
+#define __cpp_lib_allocate_at_least                 202302L
+#define __cpp_lib_associative_heterogeneous_erasure 202110L
+#define __cpp_lib_bind_back                         202202L
+#define __cpp_lib_byteswap                          202110L
+#define __cpp_lib_constexpr_bitset                  202207L
+#define __cpp_lib_constexpr_charconv                202207L
+#define __cpp_lib_constexpr_typeinfo                202106L
+#define __cpp_lib_containers_ranges                 202202L
+#define __cpp_lib_expected                          202211L
+#define __cpp_lib_flat_map                          202511L
+#define __cpp_lib_flat_set                          202511L
+#define __cpp_lib_format_ranges                     202207L
+#define __cpp_lib_formatters                        202302L
+#define __cpp_lib_forward_like                      202207L
+#define __cpp_lib_freestanding_expected             202311L
+#define __cpp_lib_freestanding_mdspan               202311L
+#define __cpp_lib_generator                         202207L
+#define __cpp_lib_invoke_r                          202106L
+#define __cpp_lib_ios_noreplace                     202207L
+
+#if defined(__clang__) || defined(__EDG__) || _MSC_VER >= 1951 // TRANSITION, toolset update
+#define __cpp_lib_is_implicit_lifetime 202302L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_is_scoped_enum           202011L
+#define __cpp_lib_mdspan                   202207L
+#define __cpp_lib_move_only_function       202110L
+#define __cpp_lib_out_ptr                  202311L
+#define __cpp_lib_print                    202406L
+#define __cpp_lib_ranges_as_const          202311L
+#define __cpp_lib_ranges_as_rvalue         202207L
+#define __cpp_lib_ranges_cartesian_product 202207L
+#define __cpp_lib_ranges_chunk             202202L
+#define __cpp_lib_ranges_chunk_by          202202L
+#define __cpp_lib_ranges_contains          202207L
+#define __cpp_lib_ranges_enumerate         202302L
+#define __cpp_lib_ranges_find_last         202207L
+#define __cpp_lib_ranges_fold              202207L
+#define __cpp_lib_ranges_iota              202202L
+#define __cpp_lib_ranges_join_with         202202L
+#define __cpp_lib_ranges_repeat            202207L
+#define __cpp_lib_ranges_slide             202202L
+#define __cpp_lib_ranges_starts_ends_with  202106L
+#define __cpp_lib_ranges_stride            202207L
+#define __cpp_lib_ranges_to_container      202202L
+#define __cpp_lib_ranges_zip               202110L
+
+#if defined(__clang__) || defined(__EDG__) || _MSC_VER >= 1951 // TRANSITION, GH-5755, toolset update
+#define __cpp_lib_reference_from_temporary 202202L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_spanstream 202106L
+#define __cpp_lib_stacktrace 202011L
+
+#if !defined(__clang__) && !defined(__EDG__) && _MSC_VER >= 1951 // TRANSITION, GH-6169, toolset update
+#define __cpp_lib_start_lifetime_as 202207L
+#endif // ^^^ no workaround ^^^
+
+#define __cpp_lib_stdatomic_h                 202011L
+#define __cpp_lib_string_contains             202011L
+#define __cpp_lib_string_resize_and_overwrite 202110L
+#define __cpp_lib_to_underlying               202102L
+#define __cpp_lib_tuple_like                  202207L
+#define __cpp_lib_unreachable                 202202L
+#endif // _HAS_CXX23
+
+// macros with language mode sensitivity
+#if _HAS_CXX20
+#define __cpp_lib_array_constexpr 201811L // P1032R1 Miscellaneous constexpr
+#elif _HAS_CXX17
+#define __cpp_lib_array_constexpr 201803L // P0858R0 Constexpr Iterator Requirements
+#endif
+
+#if _HAS_CXX20
+#define __cpp_lib_chrono 201907L // P1466R3 Miscellaneous Minor Fixes For <chrono>
+#elif _HAS_CXX17
+#define __cpp_lib_chrono 201611L // P0505R0 constexpr For <chrono> (Again)
+#else
+#define __cpp_lib_chrono 201510L // P0092R1 <chrono> floor(), ceil(), round(), abs()
+#endif
+
+#if _HAS_CXX23
+#define __cpp_lib_constexpr_memory 202202L // P2273R3 constexpr unique_ptr
+#elif _HAS_CXX20
+#define __cpp_lib_constexpr_memory 201811L // P1006R1 constexpr For pointer_traits<T*>::pointer_to()
+#endif
+
+#ifndef _M_CEE_PURE
+#if _HAS_CXX20
+#define __cpp_lib_execution 201902L // P1001R2 execution::unseq
+#elif _HAS_CXX17
+#define __cpp_lib_execution 201603L // P0024R2 Parallel Algorithms
+#endif // language mode
+#endif // !defined(_M_CEE_PURE)
+
+#if _HAS_CXX23
+#define __cpp_lib_optional 202110L // P0798R8 Monadic Operations For optional
+#elif _HAS_CXX20
+#define __cpp_lib_optional 202106L // P2231R1 Completing constexpr In optional And variant
+#elif _HAS_CXX17
+#define __cpp_lib_optional 201606L // P0307R2 Making Optional Greater Equal Again
+#endif
+
+#if _HAS_CXX23
+// P2997R1 Removing The Common Reference Requirement From The Indirectly Invocable Concepts
+#define __cpp_lib_ranges 202406L
+#elif _HAS_CXX20
+#define __cpp_lib_ranges 202110L // P2415R2 What Is A view?
+#endif
+
+#if _HAS_CXX20
+#define __cpp_lib_shared_ptr_arrays 201707L // P0674R1 make_shared() For Arrays
+#else
+#define __cpp_lib_shared_ptr_arrays 201611L // P0497R0 Fixing shared_ptr For Arrays
+#endif
+
+#if _HAS_CXX23
+#define __cpp_lib_shift 202202L // P2440R1 ranges::shift_left, ranges::shift_right
+#elif _HAS_CXX20
+#define __cpp_lib_shift 201806L // P0769R2 shift_left(), shift_right()
+#endif
+
+#if _HAS_CXX20
+#define __cpp_lib_variant 202106L // P2231R1 Completing constexpr In optional And variant
+#elif _HAS_CXX17
+#define __cpp_lib_variant 202102L // P2162R2 Inheriting From variant
+#endif
+
+#ifdef _RTC_CONVERSION_CHECKS_ENABLED
+_EMIT_STL_ERROR(STL1013, "The STL doesn't support /RTCc because it rejects conformant code. Remove the /RTCc option.");
+#endif
+
+#define _EMPTY_ARGUMENT // for empty macro argument
+
+// extern "C++" attaches declarations to the global module, see N4964 [module.unit]/7.2.
+// It has no effect in C++14/17.
+
+// In the STL's headers (which might be used to build the named module std), we unconditionally
+// and directly mark declarations of our separately compiled machinery as extern "C++", allowing
+// the named module to work with the separately compiled code (which is always built classically).
+
+// TRANSITION: _USE_EXTERN_CXX_EVERYWHERE_FOR_STL controls whether we also wrap the STL's
+// header-only code in this linkage-specification, as a temporary workaround to allow
+// importing the named module in a translation unit with classic includes.
+
+#ifndef _USE_EXTERN_CXX_EVERYWHERE_FOR_STL
+#define _USE_EXTERN_CXX_EVERYWHERE_FOR_STL _HAS_CXX20
+#endif // ^^^ !defined(_USE_EXTERN_CXX_EVERYWHERE_FOR_STL) ^^^
+
+#if _USE_EXTERN_CXX_EVERYWHERE_FOR_STL
+#define _EXTERN_CXX_WORKAROUND     extern "C++" {
+#define _END_EXTERN_CXX_WORKAROUND }
+#else // ^^^ _USE_EXTERN_CXX_EVERYWHERE_FOR_STL / !_USE_EXTERN_CXX_EVERYWHERE_FOR_STL vvv
+#define _EXTERN_CXX_WORKAROUND
+#define _END_EXTERN_CXX_WORKAROUND
+#endif // ^^^ !_USE_EXTERN_CXX_EVERYWHERE_FOR_STL ^^^
+
+#define _STD_BEGIN         \
+    _EXTERN_CXX_WORKAROUND \
+    namespace std {
+#define _STD_END \
+    }            \
+    _END_EXTERN_CXX_WORKAROUND
+
+#define _STD    ::std::
+#define _CHRONO ::std::chrono::
+#define _RANGES ::std::ranges::
+
+#define _CSTD ::
+
+#ifdef _M_CEE_PURE
+#define _EXTERN_C_UNLESS_PURE
+#define _END_EXTERN_C_UNLESS_PURE
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+#define _EXTERN_C_UNLESS_PURE     extern "C" {
+#define _END_EXTERN_C_UNLESS_PURE } // extern "C"
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+#if defined(MRTDLL) && !defined(_CRTBLD)
+#error In yvals_core.h, defined(MRTDLL) implies defined(_CRTBLD); !defined(_CRTBLD) implies !defined(MRTDLL)
+#endif // defined(MRTDLL) && !defined(_CRTBLD)
+
+#if defined(MRTDLL) && !defined(_M_CEE_PURE)
+#error In yvals_core.h, defined(MRTDLL) implies defined(_M_CEE_PURE); !defined(_M_CEE_PURE) implies !defined(MRTDLL)
+#endif // defined(MRTDLL) && !defined(_M_CEE_PURE)
+
+// The earliest Windows supported by this implementation is Windows 10.
+
+#ifdef __cpp_noexcept_function_type
+#define _NOEXCEPT_FNPTR noexcept
+#else // ^^^ defined(__cpp_noexcept_function_type) / !defined(__cpp_noexcept_function_type) vvv
+#define _NOEXCEPT_FNPTR
+#endif // ^^^ !defined(__cpp_noexcept_function_type) ^^^
+
+#ifdef __clang__
+#define _STL_INTRIN_HEADER <intrin.h>
+#define _STL_UNREACHABLE   __builtin_unreachable()
+#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#define _STL_INTRIN_HEADER <intrin0.h>
+#define _STL_UNREACHABLE   __assume(false)
+#endif // ^^^ !defined(__clang__) ^^^
+
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+#define _STL_INTERNAL_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#else // ^^^ defined(_ENABLE_STL_INTERNAL_CHECK) / !defined(_ENABLE_STL_INTERNAL_CHECK) vvv
+#define _STL_INTERNAL_STATIC_ASSERT(...)
+#endif // ^^^ !defined(_ENABLE_STL_INTERNAL_CHECK) ^^^
+
+#ifdef __CUDACC__ // TRANSITION, CUDA rejects MSVC __restrict (GH-5061); CUDA __restrict__ is unusable in C++ (GH-5097)
+#define _RESTRICT
+#else // ^^^ workaround / no workaround vvv
+#define _RESTRICT __restrict
+#endif // ^^^ no workaround ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _YVALS_CORE_H_
diff --git a/msvc-stl/stl/modules/modules.json b/msvc-stl/stl/modules/modules.json
new file mode 100644
index 0000000..b2fc38f
--- /dev/null
+++ b/msvc-stl/stl/modules/modules.json
@@ -0,0 +1,9 @@
+{
+    "version": 1,
+    "revision": 0,
+    "library": "microsoft/STL",
+    "module-sources": [
+        "std.ixx",
+        "std.compat.ixx"
+    ]
+}
diff --git a/msvc-stl/stl/modules/std.compat.ixx b/msvc-stl/stl/modules/std.compat.ixx
new file mode 100644
index 0000000..a44c414
--- /dev/null
+++ b/msvc-stl/stl/modules/std.compat.ixx
@@ -0,0 +1,533 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+export module std.compat;
+
+export import std;
+
+// "C++ headers for C library facilities" [tab:headers.cpp.c]
+
+// <cassert>
+// Nothing to do, only macros.
+
+// <cctype>
+export using std::isalnum;
+export using std::isalpha;
+export using std::isblank;
+export using std::iscntrl;
+export using std::isdigit;
+export using std::isgraph;
+export using std::islower;
+export using std::isprint;
+export using std::ispunct;
+export using std::isspace;
+export using std::isupper;
+export using std::isxdigit;
+export using std::tolower;
+export using std::toupper;
+
+// <cerrno>
+// Nothing to do, only macros.
+
+// <cfenv>
+export using std::fenv_t;
+export using std::fexcept_t;
+export using std::feclearexcept;
+export using std::fegetexceptflag;
+export using std::feraiseexcept;
+export using std::fesetexceptflag;
+export using std::fetestexcept;
+export using std::fegetround;
+export using std::fesetround;
+export using std::fegetenv;
+export using std::feholdexcept;
+export using std::fesetenv;
+export using std::feupdateenv;
+
+// <cfloat>
+// Nothing to do, only macros.
+
+// <cinttypes>
+export using std::imaxdiv_t;
+export using std::imaxabs;
+export using std::imaxdiv;
+export using std::strtoimax;
+export using std::strtoumax;
+export using std::wcstoimax;
+export using std::wcstoumax;
+
+// <climits>
+// Nothing to do, only macros.
+
+// <clocale>
+export using std::lconv;
+export using std::setlocale;
+export using std::localeconv;
+
+// <cmath>
+export using std::float_t;
+export using std::double_t;
+export using std::acos;
+export using std::acosf;
+export using std::acosl;
+export using std::asin;
+export using std::asinf;
+export using std::asinl;
+export using std::atan;
+export using std::atanf;
+export using std::atanl;
+export using std::atan2;
+export using std::atan2f;
+export using std::atan2l;
+export using std::cos;
+export using std::cosf;
+export using std::cosl;
+export using std::sin;
+export using std::sinf;
+export using std::sinl;
+export using std::tan;
+export using std::tanf;
+export using std::tanl;
+export using std::acosh;
+export using std::acoshf;
+export using std::acoshl;
+export using std::asinh;
+export using std::asinhf;
+export using std::asinhl;
+export using std::atanh;
+export using std::atanhf;
+export using std::atanhl;
+export using std::cosh;
+export using std::coshf;
+export using std::coshl;
+export using std::sinh;
+export using std::sinhf;
+export using std::sinhl;
+export using std::tanh;
+export using std::tanhf;
+export using std::tanhl;
+export using std::exp;
+export using std::expf;
+export using std::expl;
+export using std::exp2;
+export using std::exp2f;
+export using std::exp2l;
+export using std::expm1;
+export using std::expm1f;
+export using std::expm1l;
+export using std::frexp;
+export using std::frexpf;
+export using std::frexpl;
+export using std::ilogb;
+export using std::ilogbf;
+export using std::ilogbl;
+export using std::ldexp;
+export using std::ldexpf;
+export using std::ldexpl;
+export using std::log;
+export using std::logf;
+export using std::logl;
+export using std::log10;
+export using std::log10f;
+export using std::log10l;
+export using std::log1p;
+export using std::log1pf;
+export using std::log1pl;
+export using std::log2;
+export using std::log2f;
+export using std::log2l;
+export using std::logb;
+export using std::logbf;
+export using std::logbl;
+export using std::modf;
+export using std::modff;
+export using std::modfl;
+export using std::scalbn;
+export using std::scalbnf;
+export using std::scalbnl;
+export using std::scalbln;
+export using std::scalblnf;
+export using std::scalblnl;
+export using std::cbrt;
+export using std::cbrtf;
+export using std::cbrtl;
+export using std::abs;
+export using std::fabs;
+export using std::fabsf;
+export using std::fabsl;
+export using std::_Binary_hypot::hypot; // export only C's hypot(x, y), not C++'s hypot(x, y, z)
+export using std::hypotf;
+export using std::hypotl;
+export using std::pow;
+export using std::powf;
+export using std::powl;
+export using std::sqrt;
+export using std::sqrtf;
+export using std::sqrtl;
+export using std::erf;
+export using std::erff;
+export using std::erfl;
+export using std::erfc;
+export using std::erfcf;
+export using std::erfcl;
+export using std::lgamma;
+export using std::lgammaf;
+export using std::lgammal;
+export using std::tgamma;
+export using std::tgammaf;
+export using std::tgammal;
+export using std::ceil;
+export using std::ceilf;
+export using std::ceill;
+export using std::floor;
+export using std::floorf;
+export using std::floorl;
+export using std::nearbyint;
+export using std::nearbyintf;
+export using std::nearbyintl;
+export using std::rint;
+export using std::rintf;
+export using std::rintl;
+export using std::lrint;
+export using std::lrintf;
+export using std::lrintl;
+export using std::llrint;
+export using std::llrintf;
+export using std::llrintl;
+export using std::round;
+export using std::roundf;
+export using std::roundl;
+export using std::lround;
+export using std::lroundf;
+export using std::lroundl;
+export using std::llround;
+export using std::llroundf;
+export using std::llroundl;
+export using std::trunc;
+export using std::truncf;
+export using std::truncl;
+export using std::fmod;
+export using std::fmodf;
+export using std::fmodl;
+export using std::remainder;
+export using std::remainderf;
+export using std::remainderl;
+export using std::remquo;
+export using std::remquof;
+export using std::remquol;
+export using std::copysign;
+export using std::copysignf;
+export using std::copysignl;
+export using std::nan;
+export using std::nanf;
+export using std::nanl;
+export using std::nextafter;
+export using std::nextafterf;
+export using std::nextafterl;
+export using std::nexttoward;
+export using std::nexttowardf;
+export using std::nexttowardl;
+export using std::fdim;
+export using std::fdimf;
+export using std::fdiml;
+export using std::fmax;
+export using std::fmaxf;
+export using std::fmaxl;
+export using std::fmin;
+export using std::fminf;
+export using std::fminl;
+export using std::fma;
+export using std::fmaf;
+export using std::fmal;
+export using std::fpclassify;
+export using std::isfinite;
+export using std::isinf;
+export using std::isnan;
+export using std::isnormal;
+export using std::signbit;
+export using std::isgreater;
+export using std::isgreaterequal;
+export using std::isless;
+export using std::islessequal;
+export using std::islessgreater;
+export using std::isunordered;
+
+// <csetjmp>
+export using std::jmp_buf;
+export using std::longjmp;
+
+// <csignal>
+export using std::sig_atomic_t;
+export using std::signal;
+export using std::raise;
+
+// <cstdarg>
+export using std::va_list;
+
+// <cstddef>
+export using std::ptrdiff_t;
+export using std::size_t;
+export using std::max_align_t;
+export using std::nullptr_t; // added to the C Standard Library in C23
+
+// <cstdint>
+export using std::int8_t;
+export using std::int16_t;
+export using std::int32_t;
+export using std::int64_t;
+export using std::int_fast8_t;
+export using std::int_fast16_t;
+export using std::int_fast32_t;
+export using std::int_fast64_t;
+export using std::int_least8_t;
+export using std::int_least16_t;
+export using std::int_least32_t;
+export using std::int_least64_t;
+export using std::intmax_t;
+export using std::intptr_t;
+export using std::uint8_t;
+export using std::uint16_t;
+export using std::uint32_t;
+export using std::uint64_t;
+export using std::uint_fast8_t;
+export using std::uint_fast16_t;
+export using std::uint_fast32_t;
+export using std::uint_fast64_t;
+export using std::uint_least8_t;
+export using std::uint_least16_t;
+export using std::uint_least32_t;
+export using std::uint_least64_t;
+export using std::uintmax_t;
+export using std::uintptr_t;
+
+// <cstdio>
+// already exported std::size_t, see <cstddef>
+export using std::FILE;
+export using std::fpos_t;
+export using std::remove;
+export using std::rename;
+export using std::tmpfile;
+export using std::tmpnam;
+export using std::fclose;
+export using std::fflush;
+export using std::fopen;
+export using std::freopen;
+export using std::setbuf;
+export using std::setvbuf;
+export using std::fprintf;
+export using std::fscanf;
+export using std::printf;
+export using std::scanf;
+export using std::snprintf;
+export using std::sprintf;
+export using std::sscanf;
+export using std::vfprintf;
+export using std::vfscanf;
+export using std::vprintf;
+export using std::vscanf;
+export using std::vsnprintf;
+export using std::vsprintf;
+export using std::vsscanf;
+export using std::fgetc;
+export using std::fgets;
+export using std::fputc;
+export using std::fputs;
+export using std::getc;
+export using std::getchar;
+export using std::putc;
+export using std::putchar;
+export using std::puts;
+export using std::ungetc;
+export using std::fread;
+export using std::fwrite;
+export using std::fgetpos;
+export using std::fseek;
+export using std::fsetpos;
+export using std::ftell;
+export using std::rewind;
+export using std::clearerr;
+export using std::feof;
+export using std::ferror;
+export using std::perror;
+
+// <cstdlib>
+// already exported std::size_t, see <cstddef>
+export using std::div_t;
+export using std::ldiv_t;
+export using std::lldiv_t;
+export using std::abort;
+export using std::atexit;
+export using std::at_quick_exit;
+export using std::exit;
+export using std::_Exit;
+export using std::quick_exit;
+export using std::getenv;
+export using std::system;
+export using std::calloc;
+export using std::free;
+export using std::malloc;
+export using std::realloc;
+export using std::atof;
+export using std::atoi;
+export using std::atol;
+export using std::atoll;
+export using std::strtod;
+export using std::strtof;
+export using std::strtold;
+export using std::strtol;
+export using std::strtoll;
+export using std::strtoul;
+export using std::strtoull;
+export using std::mblen;
+export using std::mbtowc;
+export using std::wctomb;
+export using std::mbstowcs;
+export using std::wcstombs;
+export using std::bsearch;
+export using std::qsort;
+export using std::rand;
+export using std::srand;
+// already exported std::abs, see <cmath>
+export using std::labs;
+export using std::llabs;
+export using std::div;
+export using std::ldiv;
+export using std::lldiv;
+
+// <cstring>
+// already exported std::size_t, see <cstddef>
+export using std::memcpy;
+export using std::memmove;
+export using std::strcpy;
+export using std::strncpy;
+export using std::strcat;
+export using std::strncat;
+export using std::memcmp;
+export using std::strcmp;
+export using std::strcoll;
+export using std::strncmp;
+export using std::strxfrm;
+export using std::memchr;
+export using std::strchr;
+export using std::strcspn;
+export using std::strpbrk;
+export using std::strrchr;
+export using std::strspn;
+export using std::strstr;
+export using std::strtok;
+export using std::memset;
+export using std::strerror;
+export using std::strlen;
+
+// <ctime>
+// already exported std::size_t, see <cstddef>
+export using std::clock_t;
+export using std::time_t;
+export using std::timespec;
+export using std::tm;
+export using std::clock;
+export using std::difftime;
+export using std::mktime;
+export using std::time;
+export using std::timespec_get;
+export using std::asctime;
+export using std::ctime;
+export using std::gmtime;
+export using std::localtime;
+export using std::strftime;
+
+// <cuchar>
+export using std::mbstate_t;
+// already exported std::size_t, see <cstddef>
+export using std::mbrtoc16;
+export using std::c16rtomb;
+export using std::mbrtoc32;
+export using std::c32rtomb;
+
+// <cwchar>
+// already exported std::size_t, see <cstddef>
+// already exported std::mbstate_t, see <cuchar>
+export using std::wint_t;
+// already exported std::tm, see <ctime>
+export using std::fwprintf;
+export using std::fwscanf;
+export using std::swprintf;
+export using std::swscanf;
+export using std::vfwprintf;
+export using std::vfwscanf;
+export using std::vswprintf;
+export using std::vswscanf;
+export using std::vwprintf;
+export using std::vwscanf;
+export using std::wprintf;
+export using std::wscanf;
+export using std::fgetwc;
+export using std::fgetws;
+export using std::fputwc;
+export using std::fputws;
+export using std::fwide;
+export using std::getwc;
+export using std::getwchar;
+export using std::putwc;
+export using std::putwchar;
+export using std::ungetwc;
+export using std::wcstod;
+export using std::wcstof;
+export using std::wcstold;
+export using std::wcstol;
+export using std::wcstoll;
+export using std::wcstoul;
+export using std::wcstoull;
+export using std::wcscpy;
+export using std::wcsncpy;
+export using std::wmemcpy;
+export using std::wmemmove;
+export using std::wcscat;
+export using std::wcsncat;
+export using std::wcscmp;
+export using std::wcscoll;
+export using std::wcsncmp;
+export using std::wcsxfrm;
+export using std::wmemcmp;
+export using std::wcschr;
+export using std::wcscspn;
+export using std::wcspbrk;
+export using std::wcsrchr;
+export using std::wcsspn;
+export using std::wcsstr;
+export using std::wcstok;
+export using std::wmemchr;
+export using std::wcslen;
+export using std::wmemset;
+export using std::wcsftime;
+export using std::btowc;
+export using std::wctob;
+export using std::mbsinit;
+export using std::mbrlen;
+export using std::mbrtowc;
+export using std::wcrtomb;
+export using std::mbsrtowcs;
+export using std::wcsrtombs;
+
+// <cwctype>
+// already exported std::wint_t, see <cwchar>
+export using std::wctrans_t;
+export using std::wctype_t;
+export using std::iswalnum;
+export using std::iswalpha;
+export using std::iswblank;
+export using std::iswcntrl;
+export using std::iswdigit;
+export using std::iswgraph;
+export using std::iswlower;
+export using std::iswprint;
+export using std::iswpunct;
+export using std::iswspace;
+export using std::iswupper;
+export using std::iswxdigit;
+export using std::iswctype;
+export using std::wctype;
+export using std::towlower;
+export using std::towupper;
+export using std::towctrans;
+export using std::wctrans;
diff --git a/msvc-stl/stl/modules/std.ixx b/msvc-stl/stl/modules/std.ixx
new file mode 100644
index 0000000..00b289b
--- /dev/null
+++ b/msvc-stl/stl/modules/std.ixx
@@ -0,0 +1,159 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// In a module-file, the optional `module;` must appear first; see [cpp.pre].
+module;
+
+// This named module expects to be built with classic headers, not header units.
+#define _BUILD_STD_MODULE
+
+// The subset of "C headers" [tab:c.headers] corresponding to
+// the "C++ headers for C library facilities" [tab:headers.cpp.c]
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fenv.h>
+#include <float.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <uchar.h>
+#include <wchar.h>
+#include <wctype.h>
+
+// <intrin.h> defines some types outside of `extern "C"` or `extern "C++"`.
+#include <intrin.h>
+
+export module std;
+
+#pragma warning(push)
+#pragma warning(disable : 5244) // '#include <meow>' in the purview of module 'std' appears erroneous.
+
+// "C++ library headers" [tab:headers.cpp]
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <barrier>
+#include <bit>
+#include <bitset>
+#include <charconv>
+#include <chrono>
+#include <codecvt>
+#include <compare>
+#include <complex>
+#include <concepts>
+#include <condition_variable>
+#include <coroutine>
+#include <deque>
+#include <exception>
+#include <execution>
+#include <filesystem>
+#include <format>
+#include <forward_list>
+#include <fstream>
+#include <functional>
+#include <future>
+#include <initializer_list>
+#include <iomanip>
+#include <ios>
+#include <iosfwd>
+#include <iostream>
+#include <istream>
+#include <iterator>
+#include <latch>
+#include <limits>
+#include <list>
+#include <locale>
+#include <map>
+#include <memory>
+#include <memory_resource>
+#include <mutex>
+#include <new>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#include <ostream>
+#include <queue>
+#include <random>
+#include <ranges>
+#include <ratio>
+#include <regex>
+#include <scoped_allocator>
+#include <semaphore>
+#include <set>
+#include <shared_mutex>
+#include <source_location>
+#include <span>
+#include <sstream>
+#include <stack>
+#include <stdexcept>
+#include <stop_token>
+#include <streambuf>
+#include <string>
+#include <string_view>
+#include <strstream>
+#include <syncstream>
+#include <system_error>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <valarray>
+#include <variant>
+#include <vector>
+#include <version>
+
+#if _HAS_STATIC_RTTI
+#include <any>
+#endif // _HAS_STATIC_RTTI
+
+#if _HAS_CXX23
+#include <expected>
+#include <flat_map>
+#include <flat_set>
+#include <generator>
+#include <mdspan>
+#include <print>
+#include <spanstream>
+#include <stacktrace>
+#include <stdfloat>
+#endif // _HAS_CXX23
+
+// "C++ headers for C library facilities" [tab:headers.cpp.c]
+#include <cassert>
+#include <cctype>
+#include <cerrno>
+#include <cfenv>
+#include <cfloat>
+#include <cinttypes>
+#include <climits>
+#include <clocale>
+#include <cmath>
+#include <csetjmp>
+#include <csignal>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <cuchar>
+#include <cwchar>
+#include <cwctype>
+
+#pragma warning(pop)
diff --git a/msvc-stl/stl/msbuild/stl_1/amd64.exports b/msvc-stl/stl/msbuild/stl_1/amd64.exports
new file mode 100644
index 0000000..2608945
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/amd64.exports
@@ -0,0 +1,7 @@
+_Aligned_get_default_resource
+_Aligned_new_delete_resource
+_Aligned_set_default_resource
+_Unaligned_get_default_resource
+_Unaligned_new_delete_resource
+_Unaligned_set_default_resource
+null_memory_resource
diff --git a/msvc-stl/stl/msbuild/stl_1/arm64.exports b/msvc-stl/stl/msbuild/stl_1/arm64.exports
new file mode 100644
index 0000000..2608945
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/arm64.exports
@@ -0,0 +1,7 @@
+_Aligned_get_default_resource
+_Aligned_new_delete_resource
+_Aligned_set_default_resource
+_Unaligned_get_default_resource
+_Unaligned_new_delete_resource
+_Unaligned_set_default_resource
+null_memory_resource
diff --git a/msvc-stl/stl/msbuild/stl_1/dirs.proj b/msvc-stl/stl/msbuild/stl_1/dirs.proj
new file mode 100644
index 0000000..e177b7c
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Condition="'$(CrtBuildMD)'  != 'false'" Include="md\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/i386.exports b/msvc-stl/stl/msbuild/stl_1/i386.exports
new file mode 100644
index 0000000..2608945
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/i386.exports
@@ -0,0 +1,7 @@
+_Aligned_get_default_resource
+_Aligned_new_delete_resource
+_Aligned_set_default_resource
+_Unaligned_get_default_resource
+_Unaligned_new_delete_resource
+_Unaligned_set_default_resource
+null_memory_resource
diff --git a/msvc-stl/stl/msbuild/stl_1/md/dirs.proj b/msvc-stl/stl/msbuild/stl_1/md/dirs.proj
new file mode 100644
index 0000000..d2ad61f
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/md/dirs.proj
@@ -0,0 +1,17 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_1_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_1_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_1_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_1_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_app.vcxproj b/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_app.vcxproj
new file mode 100644
index 0000000..bcd687a
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{AC581714-5C34-43F1-88AA-F239723F751F}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_1.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_kernel32.vcxproj
new file mode 100644
index 0000000..7c4f796
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{58C30DB7-35C9-432D-8490-66F6E5901B8F}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_1.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_netfx.vcxproj
new file mode 100644
index 0000000..dfa3b1d
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{CAA5F16A-A6C1-4450-981D-E3BF0F0A7B5B}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_1.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_onecore.vcxproj
new file mode 100644
index 0000000..993fe5a
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/md/msvcp_1_md_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2BD1256B-3615-4061-AD30-4F5E1E092381}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_1.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/msvcp_1.settings.targets b/msvc-stl/stl/msbuild/stl_1/msvcp_1.settings.targets
new file mode 100644
index 0000000..03e2a3a
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/msvcp_1.settings.targets
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <PropertyGroup Label="Configuration">
+        <ConfigurationType>DynamicLibrary</ConfigurationType>
+        <GenerateImportLib>true</GenerateImportLib>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <FinalBinary>p_1</FinalBinary>
+
+        <TargetAppFamily Condition="'$(MsvcpFlavor)' == 'app'">true</TargetAppFamily>
+        <TargetCoreSystem Condition="'$(MsvcpFlavor)' == 'onecore'">true</TargetCoreSystem>
+        <TargetNetFx Condition="'$(MsvcpFlavor)' == 'netfx'">true</TargetNetFx>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt_build.settings.targets"/>
+
+    <PropertyGroup>
+        <ClrLibSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr</ClrLibSuffix>
+
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'app'">_app</MsvcpFlavorSuffix>
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr$(NetFxVerX)</MsvcpFlavorSuffix>
+
+        <OutputName>msvcp$(VCToolsProdVerSuffix)_1$(BuildSuffix)$(MsvcpFlavorSuffix)</OutputName>
+        <LibOutputFileName>msvcprt_1$(BuildSuffix)$(ClrLibSuffix)</LibOutputFileName>
+        <LibOutputFile>$(LibOutputFileName).lib</LibOutputFile>
+
+        <ClDefines Condition="'$(MsvcpFlavor)' == 'app'">$(ClDefines);_CRT_APP</ClDefines>
+
+        <UseMsvcrt>false</UseMsvcrt>
+        <RCIntermediateOutputDirectory>$(IntermediateOutputDirectory)</RCIntermediateOutputDirectory>
+        <IntermediateImportLibOutput>$(CrtBuildDir)\msvcprt_1$(BuildSuffix).$(MsvcpFlavor).import_only.lib</IntermediateImportLibOutput>
+        <DllDefName>$(LibOutputFileName).$(MsvcpFlavor)</DllDefName>
+        <DllDef>$(IntermediateOutputDirectory)\$(DllDefName).def</DllDef>
+
+        <LinkGenerateDebugInformation>true</LinkGenerateDebugInformation>
+        <LinkProgramDataBaseFileName>$(OutputPath)\$(OutputName)$(_PDB_VER_NAME_)$(DllPdbFlavorSuffix)</LinkProgramDataBaseFileName>
+
+        <LinkAdditionalOptions>-debugtype:cv,fixup $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) != 'true'">-opt:ref,icf=3 $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) == 'true'">-opt:ref,noicf $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:libcpmt$(BuildSuffix).lib $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:$(LibOutputFile) $(LinkAdditionalOptions)</LinkAdditionalOptions>
+
+        <LinkGenerateMapFile>true</LinkGenerateMapFile>
+        <LinkRelease>true</LinkRelease>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <CppPreprocess Include="$(MSBuildThisFileDirectory)\msvcprt_1.src">
+            <Defines>LIBRARYNAME=$(OutputName.ToUpper());$(DllCppDefines)</Defines>
+        </CppPreprocess>
+        <DefFromI Include="$(IntermediateOutputDirectory)\msvcprt_1.i">
+            <DestFolder1>$(IntermediateOutputDirectory)</DestFolder1>
+            <DestFolder2>$(IntermediateOutputDirectory)</DestFolder2>
+            <DestFile>$(DllDefName)</DestFile>
+        </DefFromI>
+        <ResourceCompile Include="$(MSBuildThisFileDirectory)\msvcprt_1.rc"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <TargetLib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(UniversalCRTLib)"/>
+    </ItemGroup>
+
+    <!-- Copy the output dll and pdb to various destinations -->
+    <ItemGroup>
+        <CopyFilesForCrossTools Condition="'$(MsvcpFlavor)' == 'kernel32'" Include="
+           $(LinkOutputFile);
+           $(LinkProgramDataBaseFileName);
+        "/>
+    </ItemGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)\stl_1.files.settings.targets"/>
+
+    <Import Project="$(VCToolsRootPath)\crt\crt_build.targets"/>
+    <Target Name="GetBaseAddress"/>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/msvcprt_1.rc b/msvc-stl/stl/msbuild/stl_1/msvcprt_1.rc
new file mode 100644
index 0000000..238996a
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/msvcprt_1.rc
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+//////////////////////////////////////////////////////////////////////////////////////
+//
+// msvcprt_1.rc : Defines the version resource for the C++ Runtime Library "_1" DLL
+//
+//////////////////////////////////////////////////////////////////////////////////////
+
+#include "winver.h"                       // extract from windows header
+#include "verstamp.h"
+
+#define MKARGSTR2(X) #X
+#define MKARGSTR(X)  MKARGSTR2(X)
+
+#define VER_FILETYPE VFT_DLL
+#define VER_FILESUBTYPE VFT_UNKNOWN
+
+#define VER_FILEDESCRIPTION_STR  "Microsoft\256 C Runtime Library _1\0"
+#define VER_INTERNALNAME_STR     MKARGSTR(SXS_TARGET)
+#define VER_ORIGINALFILENAME_STR MKARGSTR(SXS_TARGET)
+
+#include <common.ver>
diff --git a/msvc-stl/stl/msbuild/stl_1/msvcprt_1.src b/msvc-stl/stl/msbuild/stl_1/msvcprt_1.src
new file mode 100644
index 0000000..a02db4e
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/msvcprt_1.src
@@ -0,0 +1,13 @@
+; Copyright (c) Microsoft Corporation.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+;********************************************************************************
+;
+; This is the .DEF file for the Microsoft Visual C++ Run-Time Library "_1" DLL
+; The release version is MSVCPXX_1.DLL and the debug version MSVCPXX_1D.DLL.
+;
+;********************************************************************************
+
+LIBRARY LIBRARYNAME
+
+EXPORTS
diff --git a/msvc-stl/stl/msbuild/stl_1/stl_1.files.settings.targets b/msvc-stl/stl/msbuild/stl_1/stl_1.files.settings.targets
new file mode 100644
index 0000000..a3b8043
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/stl_1.files.settings.targets
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <ItemGroup>
+        <ClCompile Include="$(CrtRoot)\github\stl\src\memory_resource.cpp" />
+        <ClCompile Condition="'$(CrtBuildModelIsDll)' == 'true'" Include="$(CrtRoot)\github\stl\src\dllmain_satellite.cpp" />
+    </ItemGroup>
+
+    <Choose>
+      <When Condition="'$(CrtBuildModel)' != 'md'">
+        <!-- Only check exports of release, DLL, builds -->
+      </When>
+
+      <When Condition="'$(BuildArchitecture)' == 'i386' or '$(BuildArchitecture)' == 'chpe'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\i386.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+      <When Condition="'$(BuildArchitecture)' == 'amd64' or '$(BuildArchitecture)' == 'arm64ec'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\amd64.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+      <When Condition="'$(BuildArchitecture)' == 'arm64'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\arm64.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+    </Choose>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/xmd/dirs.proj b/msvc-stl/stl/msbuild/stl_1/xmd/dirs.proj
new file mode 100644
index 0000000..2389765
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/xmd/dirs.proj
@@ -0,0 +1,20 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_1_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_1_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_1_xmd_onecore.vcxproj" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
+        <ProjectFile Include="msvcp_1_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_app.vcxproj b/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_app.vcxproj
new file mode 100644
index 0000000..51787d7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E30D9740-AD72-4A90-B8A9-A1CABCC52EB9}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_1.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_kernel32.vcxproj
new file mode 100644
index 0000000..1f062f8
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{A90AB3DB-494B-4ECD-AEFB-E880F9C58F74}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_1.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_netfx.vcxproj
new file mode 100644
index 0000000..dbe6c5a
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B37B087A-D591-472E-8E73-396CD32F5E77}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_1.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_onecore.vcxproj
new file mode 100644
index 0000000..f455d54
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_1/xmd/msvcp_1_xmd_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{6E55B52D-472B-4A51-AC94-B1E391ECAAD7}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_1.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/amd64.exports b/msvc-stl/stl/msbuild/stl_2/amd64.exports
new file mode 100644
index 0000000..38ff0ff
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/amd64.exports
@@ -0,0 +1,44 @@
+__std_smf_assoc_laguerre
+__std_smf_assoc_laguerref
+__std_smf_assoc_legendre
+__std_smf_assoc_legendref
+__std_smf_beta
+__std_smf_betaf
+__std_smf_comp_ellint_1
+__std_smf_comp_ellint_1f
+__std_smf_comp_ellint_2
+__std_smf_comp_ellint_2f
+__std_smf_comp_ellint_3
+__std_smf_comp_ellint_3f
+__std_smf_cyl_bessel_i
+__std_smf_cyl_bessel_if
+__std_smf_cyl_bessel_j
+__std_smf_cyl_bessel_jf
+__std_smf_cyl_bessel_k
+__std_smf_cyl_bessel_kf
+__std_smf_cyl_neumann
+__std_smf_cyl_neumannf
+__std_smf_ellint_1
+__std_smf_ellint_1f
+__std_smf_ellint_2
+__std_smf_ellint_2f
+__std_smf_ellint_3
+__std_smf_ellint_3f
+__std_smf_expint
+__std_smf_expintf
+__std_smf_hermite
+__std_smf_hermitef
+__std_smf_hypot3
+__std_smf_hypot3f
+__std_smf_laguerre
+__std_smf_laguerref
+__std_smf_legendre
+__std_smf_legendref
+__std_smf_riemann_zeta
+__std_smf_riemann_zetaf
+__std_smf_sph_bessel
+__std_smf_sph_besself
+__std_smf_sph_legendre
+__std_smf_sph_legendref
+__std_smf_sph_neumann
+__std_smf_sph_neumannf
diff --git a/msvc-stl/stl/msbuild/stl_2/arm64.exports b/msvc-stl/stl/msbuild/stl_2/arm64.exports
new file mode 100644
index 0000000..38ff0ff
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/arm64.exports
@@ -0,0 +1,44 @@
+__std_smf_assoc_laguerre
+__std_smf_assoc_laguerref
+__std_smf_assoc_legendre
+__std_smf_assoc_legendref
+__std_smf_beta
+__std_smf_betaf
+__std_smf_comp_ellint_1
+__std_smf_comp_ellint_1f
+__std_smf_comp_ellint_2
+__std_smf_comp_ellint_2f
+__std_smf_comp_ellint_3
+__std_smf_comp_ellint_3f
+__std_smf_cyl_bessel_i
+__std_smf_cyl_bessel_if
+__std_smf_cyl_bessel_j
+__std_smf_cyl_bessel_jf
+__std_smf_cyl_bessel_k
+__std_smf_cyl_bessel_kf
+__std_smf_cyl_neumann
+__std_smf_cyl_neumannf
+__std_smf_ellint_1
+__std_smf_ellint_1f
+__std_smf_ellint_2
+__std_smf_ellint_2f
+__std_smf_ellint_3
+__std_smf_ellint_3f
+__std_smf_expint
+__std_smf_expintf
+__std_smf_hermite
+__std_smf_hermitef
+__std_smf_hypot3
+__std_smf_hypot3f
+__std_smf_laguerre
+__std_smf_laguerref
+__std_smf_legendre
+__std_smf_legendref
+__std_smf_riemann_zeta
+__std_smf_riemann_zetaf
+__std_smf_sph_bessel
+__std_smf_sph_besself
+__std_smf_sph_legendre
+__std_smf_sph_legendref
+__std_smf_sph_neumann
+__std_smf_sph_neumannf
diff --git a/msvc-stl/stl/msbuild/stl_2/dirs.proj b/msvc-stl/stl/msbuild/stl_2/dirs.proj
new file mode 100644
index 0000000..e177b7c
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Condition="'$(CrtBuildMD)'  != 'false'" Include="md\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/i386.exports b/msvc-stl/stl/msbuild/stl_2/i386.exports
new file mode 100644
index 0000000..c89459d
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/i386.exports
@@ -0,0 +1,44 @@
+___std_smf_assoc_laguerre@16
+___std_smf_assoc_laguerref@12
+___std_smf_assoc_legendre@16
+___std_smf_assoc_legendref@12
+___std_smf_beta@16
+___std_smf_betaf@8
+___std_smf_comp_ellint_1@8
+___std_smf_comp_ellint_1f@4
+___std_smf_comp_ellint_2@8
+___std_smf_comp_ellint_2f@4
+___std_smf_comp_ellint_3@16
+___std_smf_comp_ellint_3f@8
+___std_smf_cyl_bessel_i@16
+___std_smf_cyl_bessel_if@8
+___std_smf_cyl_bessel_j@16
+___std_smf_cyl_bessel_jf@8
+___std_smf_cyl_bessel_k@16
+___std_smf_cyl_bessel_kf@8
+___std_smf_cyl_neumann@16
+___std_smf_cyl_neumannf@8
+___std_smf_ellint_1@16
+___std_smf_ellint_1f@8
+___std_smf_ellint_2@16
+___std_smf_ellint_2f@8
+___std_smf_ellint_3@24
+___std_smf_ellint_3f@12
+___std_smf_expint@8
+___std_smf_expintf@4
+___std_smf_hermite@12
+___std_smf_hermitef@8
+___std_smf_hypot3@24
+___std_smf_hypot3f@12
+___std_smf_laguerre@12
+___std_smf_laguerref@8
+___std_smf_legendre@12
+___std_smf_legendref@8
+___std_smf_riemann_zeta@8
+___std_smf_riemann_zetaf@4
+___std_smf_sph_bessel@12
+___std_smf_sph_besself@8
+___std_smf_sph_legendre@16
+___std_smf_sph_legendref@12
+___std_smf_sph_neumann@12
+___std_smf_sph_neumannf@8
diff --git a/msvc-stl/stl/msbuild/stl_2/md/dirs.proj b/msvc-stl/stl/msbuild/stl_2/md/dirs.proj
new file mode 100644
index 0000000..4541ab7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/md/dirs.proj
@@ -0,0 +1,17 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_2_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_2_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_2_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_2_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_app.vcxproj b/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_app.vcxproj
new file mode 100644
index 0000000..7453d58
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{451BB540-FBE3-4BFC-B3FC-1D118E6D44ED}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_2.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_kernel32.vcxproj
new file mode 100644
index 0000000..82b61e1
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{219EFF3E-A40D-46E4-86DC-887AF90330CA}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_2.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_netfx.vcxproj
new file mode 100644
index 0000000..559fbc7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{DEC67AC5-1EF2-4745-BAFF-28484A23477E}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_2.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_onecore.vcxproj
new file mode 100644
index 0000000..44c38df
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/md/msvcp_2_md_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{24C78BD7-AED7-4090-BE81-8E3247ECC5A3}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_2.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/msvcp_2.settings.targets b/msvc-stl/stl/msbuild/stl_2/msvcp_2.settings.targets
new file mode 100644
index 0000000..d70f43c
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/msvcp_2.settings.targets
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <PropertyGroup Label="Configuration">
+        <ConfigurationType>DynamicLibrary</ConfigurationType>
+        <GenerateImportLib>true</GenerateImportLib>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <FinalBinary>p_2</FinalBinary>
+
+        <TargetAppFamily Condition="'$(MsvcpFlavor)' == 'app'">true</TargetAppFamily>
+        <TargetCoreSystem Condition="'$(MsvcpFlavor)' == 'onecore'">true</TargetCoreSystem>
+        <TargetNetFx Condition="'$(MsvcpFlavor)' == 'netfx'">true</TargetNetFx>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt_build.settings.targets"/>
+
+    <PropertyGroup>
+        <ClrLibSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr</ClrLibSuffix>
+
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'app'">_app</MsvcpFlavorSuffix>
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr$(NetFxVerX)</MsvcpFlavorSuffix>
+
+        <OutputName>msvcp$(VCToolsProdVerSuffix)_2$(BuildSuffix)$(MsvcpFlavorSuffix)</OutputName>
+        <LibOutputFileName>msvcprt_2$(BuildSuffix)$(ClrLibSuffix)</LibOutputFileName>
+        <LibOutputFile>$(LibOutputFileName).lib</LibOutputFile>
+
+        <ClDefines Condition="'$(MsvcpFlavor)' == 'app'">$(ClDefines);_CRT_APP</ClDefines>
+
+        <UseMsvcrt>false</UseMsvcrt>
+        <RCIntermediateOutputDirectory>$(IntermediateOutputDirectory)</RCIntermediateOutputDirectory>
+        <IntermediateImportLibOutput>$(CrtBuildDir)\msvcprt_2$(BuildSuffix).$(MsvcpFlavor).import_only.lib</IntermediateImportLibOutput>
+        <DllDefName>$(LibOutputFileName).$(MsvcpFlavor)</DllDefName>
+        <DllDef>$(IntermediateOutputDirectory)\$(DllDefName).def</DllDef>
+
+        <LinkGenerateDebugInformation>true</LinkGenerateDebugInformation>
+        <LinkProgramDataBaseFileName>$(OutputPath)\$(OutputName)$(_PDB_VER_NAME_)$(DllPdbFlavorSuffix)</LinkProgramDataBaseFileName>
+
+        <LinkAdditionalOptions>-debugtype:cv,fixup $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) != 'true'">-opt:ref,icf=3 $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) == 'true'">-opt:ref,noicf $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:libcpmt$(BuildSuffix).lib $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:$(LibOutputFile) $(LinkAdditionalOptions)</LinkAdditionalOptions>
+
+        <LinkGenerateMapFile>true</LinkGenerateMapFile>
+        <LinkRelease>true</LinkRelease>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <CppPreprocess Include="$(MSBuildThisFileDirectory)\msvcprt_2.src">
+            <Defines>LIBRARYNAME=$(OutputName.ToUpper());$(DllCppDefines)</Defines>
+        </CppPreprocess>
+        <DefFromI Include="$(IntermediateOutputDirectory)\msvcprt_2.i">
+            <DestFolder1>$(IntermediateOutputDirectory)</DestFolder1>
+            <DestFolder2>$(IntermediateOutputDirectory)</DestFolder2>
+            <DestFile>$(DllDefName)</DestFile>
+        </DefFromI>
+        <ResourceCompile Include="$(MSBuildThisFileDirectory)\msvcprt_2.rc"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <TargetLib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(UniversalCRTLib)"/>
+    </ItemGroup>
+
+    <!-- Copy the output dll and pdb to various destinations -->
+    <ItemGroup>
+        <CopyFilesForCrossTools Condition="'$(MsvcpFlavor)' == 'kernel32'" Include="
+           $(LinkOutputFile);
+           $(LinkProgramDataBaseFileName);
+        "/>
+    </ItemGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)\stl_2.files.settings.targets"/>
+
+    <Import Project="$(VCToolsRootPath)\crt\crt_build.targets"/>
+    <Target Name="GetBaseAddress"/>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/msvcprt_2.rc b/msvc-stl/stl/msbuild/stl_2/msvcprt_2.rc
new file mode 100644
index 0000000..bf1eba4
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/msvcprt_2.rc
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+//////////////////////////////////////////////////////////////////////////////////////
+//
+// msvcprt_2.rc : Defines the version resource for the C++ Runtime Library "_2" DLL
+//
+//////////////////////////////////////////////////////////////////////////////////////
+
+#include "winver.h"                       // extract from windows header
+#include "verstamp.h"
+
+#define MKARGSTR2(X) #X
+#define MKARGSTR(X)  MKARGSTR2(X)
+
+#define VER_FILETYPE VFT_DLL
+#define VER_FILESUBTYPE VFT_UNKNOWN
+
+#define VER_FILEDESCRIPTION_STR  "Microsoft\256 C Runtime Library _2\0"
+#define VER_INTERNALNAME_STR     MKARGSTR(SXS_TARGET)
+#define VER_ORIGINALFILENAME_STR MKARGSTR(SXS_TARGET)
+
+#include <common.ver>
diff --git a/msvc-stl/stl/msbuild/stl_2/msvcprt_2.src b/msvc-stl/stl/msbuild/stl_2/msvcprt_2.src
new file mode 100644
index 0000000..262de6e
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/msvcprt_2.src
@@ -0,0 +1,13 @@
+; Copyright (c) Microsoft Corporation.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+;********************************************************************************
+;
+; This is the .DEF file for the Microsoft Visual C++ Run-Time Library "_2" DLL
+; The release version is MSVCPXX_2.DLL and the debug version MSVCPXX_2D.DLL.
+;
+;********************************************************************************
+
+LIBRARY LIBRARYNAME
+
+EXPORTS
diff --git a/msvc-stl/stl/msbuild/stl_2/stl_2.files.settings.targets b/msvc-stl/stl/msbuild/stl_2/stl_2.files.settings.targets
new file mode 100644
index 0000000..f11d42d
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/stl_2.files.settings.targets
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <ItemGroup>
+        <ClCompile Include="$(CrtRoot)\github\stl\src\special_math.cpp" />
+        <ClCompile Condition="'$(CrtBuildModelIsDll)' == 'true'" Include="$(CrtRoot)\github\stl\src\dllmain_satellite.cpp" />
+    </ItemGroup>
+
+    <Choose>
+      <When Condition="'$(CrtBuildModel)' != 'md'">
+        <!-- Only check exports of release, DLL, builds -->
+      </When>
+
+      <When Condition="'$(BuildArchitecture)' == 'i386' or '$(BuildArchitecture)' == 'chpe'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\i386.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+      <When Condition="'$(BuildArchitecture)' == 'amd64' or '$(BuildArchitecture)' == 'arm64ec'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\amd64.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+      <When Condition="'$(BuildArchitecture)' == 'arm64'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\arm64.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+    </Choose>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/xmd/dirs.proj b/msvc-stl/stl/msbuild/stl_2/xmd/dirs.proj
new file mode 100644
index 0000000..c8f8062
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/xmd/dirs.proj
@@ -0,0 +1,20 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_2_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_2_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_2_xmd_onecore.vcxproj" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
+        <ProjectFile Include="msvcp_2_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_app.vcxproj b/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_app.vcxproj
new file mode 100644
index 0000000..56f01c7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{EFC70BD7-F82E-4951-8F60-468B164BF419}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_2.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_kernel32.vcxproj
new file mode 100644
index 0000000..f37eede
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3CFB766B-CCA6-4078-9A03-CAE24FF65373}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_2.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_netfx.vcxproj
new file mode 100644
index 0000000..9b2822f
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{4A10E59B-BC11-478F-A911-4985F503B489}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_2.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_onecore.vcxproj
new file mode 100644
index 0000000..8fdb9b6
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_2/xmd/msvcp_2_xmd_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{4897703D-D42F-4CF6-B4C1-B7CFD3D9F054}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_2.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_asan/dirs.proj b/msvc-stl/stl/msbuild/stl_asan/dirs.proj
new file mode 100644
index 0000000..d921f68
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_asan/dirs.proj
@@ -0,0 +1,14 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="stl_asan.vcxproj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_asan/stl_asan.files.settings.targets b/msvc-stl/stl/msbuild/stl_asan/stl_asan.files.settings.targets
new file mode 100644
index 0000000..7d19bab
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_asan/stl_asan.files.settings.targets
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <ItemGroup>
+        <ClCompile Include="$(CrtRoot)\github\stl\src\asan.cpp" />
+    </ItemGroup>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_asan/stl_asan.settings.targets b/msvc-stl/stl/msbuild/stl_asan/stl_asan.settings.targets
new file mode 100644
index 0000000..eef8af4
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_asan/stl_asan.settings.targets
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <PropertyGroup Label="Configuration">
+        <ConfigurationType>StaticLibrary</ConfigurationType>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <FinalBinary>p_stl_asan</FinalBinary>
+        <Arm64CombinedPdb>true</Arm64CombinedPdb>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt_build.settings.targets"/>
+
+    <PropertyGroup>
+        <OutputName>stl_asan</OutputName>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <ClProgramDataBaseFileName>$(OutputLibPdbPath)$(OutputName)$(PdbVerName).pdb</ClProgramDataBaseFileName>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)stl_asan.files.settings.targets"/>
+
+    <Import Project="$(VCToolsRootPath)\crt\crt_build.targets"/>
+    <Target Name="GetBaseAddress"/>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_asan/stl_asan.vcxproj b/msvc-stl/stl/msbuild/stl_asan/stl_asan.vcxproj
new file mode 100644
index 0000000..1cc3606
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_asan/stl_asan.vcxproj
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B8236181-0F0C-465B-8729-36944CBF324A}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$(MSBuildThisFileDirectory)stl_asan.settings.targets" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/dirs.proj b/msvc-stl/stl/msbuild/stl_atomic_wait/dirs.proj
new file mode 100644
index 0000000..e177b7c
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Condition="'$(CrtBuildMD)'  != 'false'" Include="md\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/md/dirs.proj b/msvc-stl/stl/msbuild/stl_atomic_wait/md/dirs.proj
new file mode 100644
index 0000000..03b6a18
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/md/dirs.proj
@@ -0,0 +1,17 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_atomic_wait_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_app.vcxproj b/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_app.vcxproj
new file mode 100644
index 0000000..dd24552
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{99C61FE5-793F-4D49-82F6-27938575B058}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_atomic_wait.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_kernel32.vcxproj
new file mode 100644
index 0000000..8d837de
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2C785D3F-9961-46E9-A202-D410DAD6269D}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_atomic_wait.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_netfx.vcxproj
new file mode 100644
index 0000000..819896e
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B0D8709C-8649-43DF-AB53-AA05134A9B83}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_atomic_wait.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_onecore.vcxproj
new file mode 100644
index 0000000..4e034cd
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{22F86914-609E-4BF5-A1DA-2804C1251044}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_atomic_wait.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets b/msvc-stl/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets
new file mode 100644
index 0000000..ff8ede7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <PropertyGroup Label="Configuration">
+        <ConfigurationType>DynamicLibrary</ConfigurationType>
+        <GenerateImportLib>true</GenerateImportLib>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <FinalBinary>p_atomic_wait</FinalBinary>
+
+        <TargetAppFamily Condition="'$(MsvcpFlavor)' == 'app'">true</TargetAppFamily>
+        <TargetCoreSystem Condition="'$(MsvcpFlavor)' == 'onecore'">true</TargetCoreSystem>
+        <TargetNetFx Condition="'$(MsvcpFlavor)' == 'netfx'">true</TargetNetFx>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt_build.settings.targets"/>
+
+    <PropertyGroup>
+        <ClrLibSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr</ClrLibSuffix>
+
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'app'">_app</MsvcpFlavorSuffix>
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr$(NetFxVerX)</MsvcpFlavorSuffix>
+
+        <OutputName>msvcp$(VCToolsProdVerSuffix)$(BuildSuffix)_atomic_wait$(MsvcpFlavorSuffix)</OutputName>
+        <LibOutputFileName>msvcprt$(BuildSuffix)_atomic_wait$(ClrLibSuffix)</LibOutputFileName>
+        <LibOutputFile>$(LibOutputFileName).lib</LibOutputFile>
+
+        <ClDefines Condition="'$(MsvcpFlavor)' == 'app'">$(ClDefines);_CRT_APP</ClDefines>
+
+        <UseMsvcrt>false</UseMsvcrt>
+        <RCIntermediateOutputDirectory>$(IntermediateOutputDirectory)</RCIntermediateOutputDirectory>
+        <IntermediateImportLibOutput>$(CrtBuildDir)\msvcprt_atomic_wait$(BuildSuffix).$(MsvcpFlavor).import_only.lib</IntermediateImportLibOutput>
+        <DllDefName>$(LibOutputFileName).$(MsvcpFlavor)</DllDefName>
+        <DllDef>$(IntermediateOutputDirectory)\$(DllDefName).def</DllDef>
+
+        <LinkGenerateDebugInformation>true</LinkGenerateDebugInformation>
+        <LinkProgramDataBaseFileName>$(OutputPath)\$(OutputName)$(_PDB_VER_NAME_)$(DllPdbFlavorSuffix)</LinkProgramDataBaseFileName>
+
+        <LinkAdditionalOptions>-debugtype:cv,fixup $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) != 'true'">-opt:ref,icf=3 $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) == 'true'">-opt:ref,noicf $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:libcpmt$(BuildSuffix).lib $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:$(LibOutputFile) $(LinkAdditionalOptions)</LinkAdditionalOptions>
+
+        <LinkGenerateMapFile>true</LinkGenerateMapFile>
+        <LinkRelease>true</LinkRelease>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <CppPreprocess Include="$(MSBuildThisFileDirectory)\..\..\src\msvcp_atomic_wait.src">
+            <Defines>LIBRARYNAME=$(OutputName.ToUpper())</Defines>
+        </CppPreprocess>
+        <DefFromI Include="$(IntermediateOutputDirectory)\msvcp_atomic_wait.i">
+            <DestFolder1>$(IntermediateOutputDirectory)</DestFolder1>
+            <DestFolder2>$(IntermediateOutputDirectory)</DestFolder2>
+            <DestFile>$(DllDefName)</DestFile>
+        </DefFromI>
+        <ResourceCompile Include="$(MSBuildThisFileDirectory)\msvcprt_atomic_wait.rc"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <TargetLib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(UniversalCRTLib)"/>
+        <TargetLib Condition="'$(MsvcpFlavor)' == 'kernel32' or '$(MsvcpFlavor)' == 'netfx'" Include="$(SdkLibPath)\advapi32.lib"/>
+        <TargetLib Condition="'$(MsvcpFlavor)' == 'kernel32' or '$(MsvcpFlavor)' == 'netfx'" Include="$(SdkLibPath)\synchronization.lib"/>
+    </ItemGroup>
+
+    <!-- Copy the output dll and pdb to various destinations -->
+    <ItemGroup>
+        <CopyFilesForCrossTools Condition="'$(MsvcpFlavor)' == 'kernel32'" Include="
+           $(LinkOutputFile);
+           $(LinkProgramDataBaseFileName);
+        "/>
+    </ItemGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)\stl_atomic_wait.files.settings.targets"/>
+
+    <Import Project="$(VCToolsRootPath)\crt\crt_build.targets"/>
+    <Target Name="GetBaseAddress"/>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/msvcprt_atomic_wait.rc b/msvc-stl/stl/msbuild/stl_atomic_wait/msvcprt_atomic_wait.rc
new file mode 100644
index 0000000..b43a7e1
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/msvcprt_atomic_wait.rc
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+//////////////////////////////////////////////////////////////////////////////////////
+//
+// msvcprt_atomic_wait.rc : Defines the version resource for the C++ Runtime Library "_atomic_wait" DLL
+//
+//////////////////////////////////////////////////////////////////////////////////////
+
+#include "winver.h"                       // extract from windows header
+#include "verstamp.h"
+
+#define MKARGSTR2(X) #X
+#define MKARGSTR(X)  MKARGSTR2(X)
+
+#define VER_FILETYPE VFT_DLL
+#define VER_FILESUBTYPE VFT_UNKNOWN
+
+#define VER_FILEDESCRIPTION_STR  "Microsoft\256 C Runtime Library _atomic_wait\0"
+#define VER_INTERNALNAME_STR     MKARGSTR(SXS_TARGET)
+#define VER_ORIGINALFILENAME_STR MKARGSTR(SXS_TARGET)
+
+#include <common.ver>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/stl_atomic_wait.files.settings.targets b/msvc-stl/stl/msbuild/stl_atomic_wait/stl_atomic_wait.files.settings.targets
new file mode 100644
index 0000000..46dcf17
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/stl_atomic_wait.files.settings.targets
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <ItemGroup>
+        <ClCompile Include="$(CrtRoot)\github\stl\src\atomic_wait.cpp;" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\parallel_algorithms.cpp;" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\syncstream.cpp;" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\tzdb.cpp;" />
+        <ClCompile Condition="'$(CrtBuildModelIsDll)' == 'true'" Include="$(CrtRoot)\github\stl\src\dllmain_satellite.cpp;" />
+    </ItemGroup>
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/dirs.proj b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/dirs.proj
new file mode 100644
index 0000000..e050668
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/dirs.proj
@@ -0,0 +1,20 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_atomic_wait_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_xmd_onecore.vcxproj" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
+        <ProjectFile Include="msvcp_atomic_wait_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_app.vcxproj b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_app.vcxproj
new file mode 100644
index 0000000..f71669b
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3AEA1ADF-5AA1-4BAB-B0AA-104B622C75B5}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_atomic_wait.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_kernel32.vcxproj
new file mode 100644
index 0000000..02f0e86
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{D771D7D3-3021-4CBE-A966-68CD817D0C04}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_atomic_wait.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_netfx.vcxproj
new file mode 100644
index 0000000..e8e49d1
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{31EE7F7B-CF43-489D-8419-EDB8F2C152EE}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_atomic_wait.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_onecore.vcxproj
new file mode 100644
index 0000000..336db86
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{57A6A807-C9DC-4ADF-8128-3589FCDAA2E4}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_atomic_wait.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/amd64.exports b/msvc-stl/stl/msbuild/stl_base/amd64.exports
new file mode 100644
index 0000000..5c6b50e
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/amd64.exports
@@ -0,0 +1,1515 @@
+??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??0?$_Yarn@D@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@D@std@@QEAA@PEBD@Z
+??0?$_Yarn@D@std@@QEAA@XZ
+??0?$_Yarn@G@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@G@std@@QEAA@PEBG@Z
+??0?$_Yarn@G@std@@QEAA@XZ
+??0?$_Yarn@_W@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@_W@std@@QEAA@PEB_W@Z
+??0?$_Yarn@_W@std@@QEAA@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@IEAA@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@IEAA@XZ
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@IEAA@XZ
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N1@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N1@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N1@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@XZ
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@XZ
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@XZ
+??0?$codecvt@DDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@DDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@KW4_Codecvt_mode@1@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@KW4_Codecvt_mode@1@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$ctype@D@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@D@std@@QEAA@PEBF_N_K@Z
+??0?$ctype@G@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@G@std@@QEAA@_K@Z
+??0?$ctype@_W@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@_W@std@@QEAA@_K@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0Init@ios_base@std@@QEAA@XZ
+??0_Facet_base@std@@QEAA@AEBV01@@Z
+??0_Facet_base@std@@QEAA@XZ
+??0_Init_locks@std@@QEAA@XZ
+??0_Locimp@locale@std@@AEAA@AEBV012@@Z
+??0_Locimp@locale@std@@AEAA@_N@Z
+??0_Locinfo@std@@QEAA@HPEBD@Z
+??0_Locinfo@std@@QEAA@PEBD@Z
+??0_Lockit@std@@QEAA@H@Z
+??0_Lockit@std@@QEAA@XZ
+??0_Timevec@std@@QEAA@AEBV01@@Z
+??0_Timevec@std@@QEAA@PEAX@Z
+??0_UShinit@std@@QEAA@XZ
+??0_Winit@std@@QEAA@XZ
+??0codecvt_base@std@@QEAA@_K@Z
+??0ctype_base@std@@QEAA@_K@Z
+??0facet@locale@std@@IEAA@_K@Z
+??0id@locale@std@@QEAA@_K@Z
+??0ios_base@std@@IEAA@XZ
+??0task_continuation_context@Concurrency@@AEAA@XZ
+??0time_base@std@@QEAA@_K@Z
+??1?$_Yarn@D@std@@QEAA@XZ
+??1?$_Yarn@G@std@@QEAA@XZ
+??1?$_Yarn@_W@std@@QEAA@XZ
+??1?$basic_ios@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_ios@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_ios@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_iostream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_iostream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_iostream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_istream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_istream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_istream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_ostream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_ostream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_ostream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$codecvt@DDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@GDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_SDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_UDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_WDU_Mbstatet@@@std@@MEAA@XZ
+??1?$ctype@D@std@@MEAA@XZ
+??1?$ctype@G@std@@MEAA@XZ
+??1?$ctype@_W@std@@MEAA@XZ
+??1?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1Init@ios_base@std@@QEAA@XZ
+??1_Facet_base@std@@UEAA@XZ
+??1_Init_locks@std@@QEAA@XZ
+??1_Locimp@locale@std@@MEAA@XZ
+??1_Locinfo@std@@QEAA@XZ
+??1_Lockit@std@@QEAA@XZ
+??1_Timevec@std@@QEAA@XZ
+??1_UShinit@std@@QEAA@XZ
+??1_Winit@std@@QEAA@XZ
+??1codecvt_base@std@@UEAA@XZ
+??1ctype_base@std@@UEAA@XZ
+??1facet@locale@std@@MEAA@XZ
+??1ios_base@std@@UEAA@XZ
+??1time_base@std@@UEAA@XZ
+??4?$_Iosb@H@std@@QEAAAEAV01@$$QEAV01@@Z
+??4?$_Iosb@H@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@D@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@D@std@@QEAAAEAV01@PEBD@Z
+??4?$_Yarn@G@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@G@std@@QEAAAEAV01@PEBG@Z
+??4?$_Yarn@_W@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@_W@std@@QEAAAEAV01@PEB_W@Z
+??4?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4Init@ios_base@std@@QEAAAEAV012@AEBV012@@Z
+??4_Crt_new_delete@std@@QEAAAEAU01@$$QEAU01@@Z
+??4_Crt_new_delete@std@@QEAAAEAU01@AEBU01@@Z
+??4_Facet_base@std@@QEAAAEAV01@AEBV01@@Z
+??4_Init_locks@std@@QEAAAEAV01@AEBV01@@Z
+??4_Timevec@std@@QEAAAEAV01@AEBV01@@Z
+??4_UShinit@std@@QEAAAEAV01@AEBV01@@Z
+??4_Winit@std@@QEAAAEAV01@AEBV01@@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@DU?$char_traits@D@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@GU?$char_traits@G@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@DU?$char_traits@D@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@GU?$char_traits@G@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_N@Z
+??7ios_base@std@@QEBA_NXZ
+??Bid@locale@std@@QEAA_KXZ
+??Bios_base@std@@QEBA_NXZ
+??_7?$basic_ios@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ios@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ios@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_iostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_iostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_iostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_istream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_istream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_istream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_ostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_streambuf@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_streambuf@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$codecvt@DDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@GDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_SDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_UDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_WDU_Mbstatet@@@std@@6B@
+??_7?$ctype@D@std@@6B@
+??_7?$ctype@G@std@@6B@
+??_7?$ctype@_W@std@@6B@
+??_7?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7_Facet_base@std@@6B@
+??_7_Locimp@locale@std@@6B@
+??_7codecvt_base@std@@6B@
+??_7ctype_base@std@@6B@
+??_7facet@locale@std@@6B@
+??_7ios_base@std@@6B@
+??_7time_base@std@@6B@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_istream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_ostream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_istream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_ostream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_istream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_ostream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_istream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_istream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_istream@_WU?$char_traits@_W@std@@@std@@7B@
+??_8?$basic_ostream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_ostream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_ostream@_WU?$char_traits@_W@std@@@std@@7B@
+??_D?$basic_iostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_iostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_D?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_F?$codecvt@DDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@GDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_SDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_UDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_WDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$ctype@D@std@@QEAAXXZ
+??_F?$ctype@G@std@@QEAAXXZ
+??_F?$ctype@_W@std@@QEAAXXZ
+??_F?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F_Locinfo@std@@QEAAXXZ
+??_F_Timevec@std@@QEAAXXZ
+??_Fcodecvt_base@std@@QEAAXXZ
+??_Fctype_base@std@@QEAAXXZ
+??_Ffacet@locale@std@@QEAAXXZ
+??_Fid@locale@std@@QEAAXXZ
+??_Ftime_base@std@@QEAAXXZ
+?CaptureCallstack@platform@details@Concurrency@@YA_KPEAPEAX_K1@Z
+?GetCurrentThreadId@platform@details@Concurrency@@YAJXZ
+?GetNextAsyncId@platform@details@Concurrency@@YAIXZ
+?ReportUnhandledError@_ExceptionHolder@details@Concurrency@@AEAAXXZ
+?_Addcats@_Locinfo@std@@QEAAAEAV12@HPEBD@Z
+?_Addfac@_Locimp@locale@std@@AEAAXPEAVfacet@23@_K@Z
+?_Addstd@ios_base@std@@SAXPEAV12@@Z
+?_Assign@_ContextCallback@details@Concurrency@@AEAAXPEAX@Z
+?_Atexit@@YAXP6AXXZ@Z
+?_BADOFF@std@@3_JB
+?_C_str@?$_Yarn@D@std@@QEBAPEBDXZ
+?_C_str@?$_Yarn@G@std@@QEBAPEBGXZ
+?_C_str@?$_Yarn@_W@std@@QEBAPEB_WXZ
+?_CallInContext@_ContextCallback@details@Concurrency@@QEBAXV?$function@$$A6AXXZ@std@@_N@Z
+?_Callfns@ios_base@std@@AEAAXW4event@12@@Z
+?_Capture@_ContextCallback@details@Concurrency@@AEAAXXZ
+?_Clocptr@_Locimp@locale@std@@0PEAV123@EA
+?_Decref@facet@locale@std@@UEAAPEAV_Facet_base@3@XZ
+?_Donarrow@?$ctype@G@std@@IEBADGD@Z
+?_Donarrow@?$ctype@_W@std@@IEBAD_WD@Z
+?_Dowiden@?$ctype@G@std@@IEBAGD@Z
+?_Dowiden@?$ctype@_W@std@@IEBA_WD@Z
+?_Empty@?$_Yarn@D@std@@QEBA_NXZ
+?_Empty@?$_Yarn@G@std@@QEBA_NXZ
+?_Empty@?$_Yarn@_W@std@@QEBA_NXZ
+?_Execute_once@std@@YAHAEAUonce_flag@1@P6AHPEAX1PEAPEAX@Z1@Z
+?_Ffmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Ffmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Ffmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Findarr@ios_base@std@@AEAAAEAU_Iosarray@12@H@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEBDHH@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEBGHH@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEB_WHH@Z
+?_Fput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBD_K@Z
+?_Fput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBD_K@Z
+?_Fput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBD_K@Z
+?_Getcat@?$codecvt@DDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@GDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_SDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_UDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_WDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@D@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@G@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@_W@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@facet@locale@std@@SA_KPEAPEBV123@PEBV23@@Z
+?_Getcoll@_Locinfo@std@@QEBA?AU_Collvec@@XZ
+?_Getctype@_Locinfo@std@@QEBA?AU_Ctypevec@@XZ
+?_Getcvt@_Locinfo@std@@QEBA?AU_Cvtvec@@XZ
+?_Getdateorder@_Locinfo@std@@QEBAHXZ
+?_Getdays@_Locinfo@std@@QEBAPEBDXZ
+?_Getfalse@_Locinfo@std@@QEBAPEBDXZ
+?_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getfmt@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getfmt@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getfmt@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getgloballocale@locale@std@@CAPEAV_Locimp@12@XZ
+?_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1HAEBVlocale@2@@Z
+?_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1HAEBVlocale@2@@Z
+?_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1HAEBVlocale@2@@Z
+?_Getint@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@0HHAEAHAEBV?$ctype@D@2@@Z
+?_Getint@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@0HHAEAHAEBV?$ctype@G@2@@Z
+?_Getint@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@0HHAEAHAEBV?$ctype@_W@2@@Z
+?_Getlconv@_Locinfo@std@@QEBAPEBUlconv@@XZ
+?_Getmonths@_Locinfo@std@@QEBAPEBDXZ
+?_Getname@_Locinfo@std@@QEBAPEBDXZ
+?_Getptr@_Timevec@std@@QEBAPEAXXZ
+?_Gettnames@_Locinfo@std@@QEBA?AV_Timevec@2@XZ
+?_Gettrue@_Locinfo@std@@QEBAPEBDXZ
+?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBA_JXZ
+?_Gnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBA_JXZ
+?_Gnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBA_JXZ
+?_Gndec@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gndec@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gndec@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Gninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gnpreinc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gnpreinc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Id_cnt@id@locale@std@@0HA
+?_Ifmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Ifmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Ifmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Incref@facet@locale@std@@UEAAXXZ
+?_Index@ios_base@std@@0HA
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAPEAD0PEAH001@Z
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXXZ
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAPEAG0PEAH001@Z
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXXZ
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEAPEA_W0PEAH001@Z
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXXZ
+?_Init@?$codecvt@DDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@GDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_SDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_UDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_WDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@D@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@G@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@_W@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@ios_base@std@@IEAAXXZ
+?_Init@locale@std@@CAPEAV_Locimp@12@_N@Z
+?_Init_cnt@Init@ios_base@std@@0HA
+?_Init_cnt@_UShinit@std@@0HA
+?_Init_cnt@_Winit@std@@0HA
+?_Init_cnt_func@Init@ios_base@std@@CAAEAHXZ
+?_Init_ctor@Init@ios_base@std@@CAXPEAV123@@Z
+?_Init_dtor@Init@ios_base@std@@CAXPEAV123@@Z
+?_Init_locks_ctor@_Init_locks@std@@CAXPEAV12@@Z
+?_Init_locks_dtor@_Init_locks@std@@CAXPEAV12@@Z
+?_Ios_base_dtor@ios_base@std@@CAXPEAV12@@Z
+?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_N_N@Z
+?_Ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_N_N@Z
+?_Ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_N_N@Z
+?_Iput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEAD_K@Z
+?_Iput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEAD_K@Z
+?_Iput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEAD_K@Z
+?_IsCurrentOriginSTA@_ContextCallback@details@Concurrency@@CA_NXZ
+?_IsNonBlockingThread@_Task_impl_base@details@Concurrency@@SA_NXZ
+?_Locimp_Addfac@_Locimp@locale@std@@CAXPEAV123@PEAVfacet@23@_K@Z
+?_Locimp_ctor@_Locimp@locale@std@@CAXPEAV123@AEBV123@@Z
+?_Locimp_dtor@_Locimp@locale@std@@CAXPEAV123@@Z
+?_Locinfo_Addcats@_Locinfo@std@@SAAEAV12@PEAV12@HPEBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPEAV12@HPEBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPEAV12@PEBD@Z
+?_Locinfo_dtor@_Locinfo@std@@SAXPEAV12@@Z
+?_Lock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAAXXZ
+?_Lock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAAXXZ
+?_Lock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAAXXZ
+?_Lockit_ctor@_Lockit@std@@CAXPEAV12@@Z
+?_Lockit_ctor@_Lockit@std@@CAXPEAV12@H@Z
+?_Lockit_ctor@_Lockit@std@@SAXH@Z
+?_Lockit_dtor@_Lockit@std@@CAXPEAV12@@Z
+?_Lockit_dtor@_Lockit@std@@SAXH@Z
+?_LogCancelTask@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogScheduleTask@_TaskEventLogger@details@Concurrency@@QEAAX_N@Z
+?_LogTaskCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogTaskExecutionCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogWorkItemCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogWorkItemStarted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_MP_Add@std@@YAXQEA_K_K@Z
+?_MP_Get@std@@YA_KQEA_K@Z
+?_MP_Mul@std@@YAXQEA_K_K1@Z
+?_MP_Rem@std@@YAXQEA_K_K@Z
+?_Makeloc@_Locimp@locale@std@@CAPEAV123@AEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makeushloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makewloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makexloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Mtx_delete@threads@stdext@@YAXPEAX@Z
+?_Mtx_lock@threads@stdext@@YAXPEAX@Z
+?_Mtx_new@threads@stdext@@YAXAEAPEAX@Z
+?_Mtx_unlock@threads@stdext@@YAXPEAX@Z
+?_New_Locimp@_Locimp@locale@std@@CAPEAV123@AEBV123@@Z
+?_New_Locimp@_Locimp@locale@std@@CAPEAV123@_N@Z
+?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?_Osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?_Osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?_Pnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBA_JXZ
+?_Pnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBA_JXZ
+?_Pnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBA_JXZ
+?_Pninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Pninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Pninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Ptr_cerr@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_cin@std@@3PEAV?$basic_istream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_clog@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_cout@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_wcerr@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcerr@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wcin@std@@3PEAV?$basic_istream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcin@std@@3PEAV?$basic_istream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wclog@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wclog@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wcout@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcout@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@PEBD_K@Z
+?_Put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@PEBG_K@Z
+?_Put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@PEB_W_K@Z
+?_Raise_handler@std@@3P6AXAEBVexception@stdext@@@ZEA
+?_Random_device@std@@YAIXZ
+?_Release_chore@details@Concurrency@@YAXPEAU_Threadpool_chore@12@@Z
+?_Rep@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@D_K@Z
+?_Rep@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@G_K@Z
+?_Rep@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@_W_K@Z
+?_ReportUnobservedException@details@Concurrency@@YAXXZ
+?_Reschedule_chore@details@Concurrency@@YAHPEBU_Threadpool_chore@12@@Z
+?_Reset@_ContextCallback@details@Concurrency@@AEAAXXZ
+?_Rethrow_future_exception@std@@YAXVexception_ptr@1@@Z
+?_Rng_abort@std@@YAXPEBD@Z
+?_Schedule_chore@details@Concurrency@@YAHPEAU_Threadpool_chore@12@@Z
+?_Setgloballocale@locale@std@@CAXPEAX@Z
+?_Src@?1??_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Sync@ios_base@std@@0_NA
+?_Syserror_map@std@@YAPEBDH@Z
+?_Throw_C_error@std@@YAXH@Z
+?_Throw_Cpp_error@std@@YAXH@Z
+?_Throw_future_error@std@@YAXAEBVerror_code@1@@Z
+?_Tidy@?$_Yarn@D@std@@AEAAXXZ
+?_Tidy@?$_Yarn@G@std@@AEAAXXZ
+?_Tidy@?$_Yarn@_W@std@@AEAAXXZ
+?_Tidy@?$ctype@D@std@@IEAAXXZ
+?_Tidy@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEAAXXZ
+?_Tidy@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEAAXXZ
+?_Tidy@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEAAXXZ
+?_Tidy@ios_base@std@@AEAAXXZ
+?_Unlock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAAXXZ
+?_Unlock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAAXXZ
+?_Unlock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAAXXZ
+?_W_Getdays@_Locinfo@std@@QEBAPEBGXZ
+?_W_Getmonths@_Locinfo@std@@QEBAPEBGXZ
+?_W_Gettnames@_Locinfo@std@@QEBA?AV_Timevec@2@XZ
+?_Winerror_map@std@@YAHH@Z
+?_Winerror_message@std@@YAKKPEADK@Z
+?_XGetLastError@std@@YAXXZ
+?_XLgamma@std@@YAMM@Z
+?_XLgamma@std@@YANN@Z
+?_XLgamma@std@@YAOO@Z
+?_Xbad_alloc@std@@YAXXZ
+?_Xbad_function_call@std@@YAXXZ
+?_Xinvalid_argument@std@@YAXPEBD@Z
+?_Xlength_error@std@@YAXPEBD@Z
+?_Xout_of_range@std@@YAXPEBD@Z
+?_Xoverflow_error@std@@YAXPEBD@Z
+?_Xregex_error@std@@YAXW4error_type@regex_constants@1@@Z
+?_Xruntime_error@std@@YAXPEBD@Z
+?__ExceptionPtrAssign@@YAXPEAXPEBX@Z
+?__ExceptionPtrCompare@@YA_NPEBX0@Z
+?__ExceptionPtrCopy@@YAXPEAXPEBX@Z
+?__ExceptionPtrCopyException@@YAXPEAXPEBX1@Z
+?__ExceptionPtrCreate@@YAXPEAX@Z
+?__ExceptionPtrCurrentException@@YAXPEAX@Z
+?__ExceptionPtrDestroy@@YAXPEAX@Z
+?__ExceptionPtrRethrow@@YAXPEBX@Z
+?__ExceptionPtrSwap@@YAXPEAX0@Z
+?__ExceptionPtrToBool@@YA_NPEBX@Z
+?always_noconv@codecvt_base@std@@QEBA_NXZ
+?bad@ios_base@std@@QEBA_NXZ
+?c_str@?$_Yarn@D@std@@QEBAPEBDXZ
+?c_str@?$_Yarn@G@std@@QEBAPEBGXZ
+?c_str@?$_Yarn@_W@std@@QEBAPEB_WXZ
+?cerr@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?cin@std@@3V?$basic_istream@DU?$char_traits@D@std@@@1@A
+?classic@locale@std@@SAAEBV12@XZ
+?classic_table@?$ctype@D@std@@SAPEBFXZ
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXI@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXI@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXI@Z
+?clear@ios_base@std@@QEAAXH@Z
+?clear@ios_base@std@@QEAAXH_N@Z
+?clear@ios_base@std@@QEAAXI@Z
+?clog@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?copyfmt@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@ios_base@std@@QEAAAEAV12@AEBV12@@Z
+?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?do_always_noconv@?$codecvt@DDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@GDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_SDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_UDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_WDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@codecvt_base@std@@MEBA_NXZ
+?do_date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_encoding@?$codecvt@GDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@codecvt_base@std@@MEBAHXZ
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_in@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?do_in@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAG3AEAPEAG@Z
+?do_in@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_S3AEAPEA_S@Z
+?do_in@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_U3AEAPEA_U@Z
+?do_in@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_W3AEAPEA_W@Z
+?do_is@?$ctype@G@std@@MEBAPEBGPEBG0PEAF@Z
+?do_is@?$ctype@G@std@@MEBA_NFG@Z
+?do_is@?$ctype@_W@std@@MEBAPEB_WPEB_W0PEAF@Z
+?do_is@?$ctype@_W@std@@MEBA_NF_W@Z
+?do_length@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_max_length@?$codecvt@GDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@codecvt_base@std@@MEBAHXZ
+?do_narrow@?$ctype@D@std@@MEBADDD@Z
+?do_narrow@?$ctype@D@std@@MEBAPEBDPEBD0DPEAD@Z
+?do_narrow@?$ctype@G@std@@MEBADGD@Z
+?do_narrow@?$ctype@G@std@@MEBAPEBGPEBG0DPEAD@Z
+?do_narrow@?$ctype@_W@std@@MEBAD_WD@Z
+?do_narrow@?$ctype@_W@std@@MEBAPEB_WPEB_W0DPEAD@Z
+?do_out@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?do_out@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBG1AEAPEBGPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_S1AEAPEB_SPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_U1AEAPEB_UPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_W1AEAPEB_WPEAD3AEAPEAD@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DJ@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DK@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DN@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DO@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBX@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_J@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_K@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_N@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GJ@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GK@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GN@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GO@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBX@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_J@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_K@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_N@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WJ@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WK@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WN@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WO@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBX@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_J@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_K@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_N@Z
+?do_put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@DD@Z
+?do_put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@DD@Z
+?do_put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@DD@Z
+?do_scan_is@?$ctype@G@std@@MEBAPEBGFPEBG0@Z
+?do_scan_is@?$ctype@_W@std@@MEBAPEB_WFPEB_W0@Z
+?do_scan_not@?$ctype@G@std@@MEBAPEBGFPEBG0@Z
+?do_scan_not@?$ctype@_W@std@@MEBAPEB_WFPEB_W0@Z
+?do_tolower@?$ctype@D@std@@MEBADD@Z
+?do_tolower@?$ctype@D@std@@MEBAPEBDPEADPEBD@Z
+?do_tolower@?$ctype@G@std@@MEBAGG@Z
+?do_tolower@?$ctype@G@std@@MEBAPEBGPEAGPEBG@Z
+?do_tolower@?$ctype@_W@std@@MEBAPEB_WPEA_WPEB_W@Z
+?do_tolower@?$ctype@_W@std@@MEBA_W_W@Z
+?do_toupper@?$ctype@D@std@@MEBADD@Z
+?do_toupper@?$ctype@D@std@@MEBAPEBDPEADPEBD@Z
+?do_toupper@?$ctype@G@std@@MEBAGG@Z
+?do_toupper@?$ctype@G@std@@MEBAPEBGPEAGPEBG@Z
+?do_toupper@?$ctype@_W@std@@MEBAPEB_WPEA_WPEB_W@Z
+?do_toupper@?$ctype@_W@std@@MEBA_W_W@Z
+?do_unshift@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_widen@?$ctype@D@std@@MEBADD@Z
+?do_widen@?$ctype@D@std@@MEBAPEBDPEBD0PEAD@Z
+?do_widen@?$ctype@G@std@@MEBAGD@Z
+?do_widen@?$ctype@G@std@@MEBAPEBDPEBD0PEAG@Z
+?do_widen@?$ctype@_W@std@@MEBAPEBDPEBD0PEA_W@Z
+?do_widen@?$ctype@_W@std@@MEBA_WD@Z
+?eback@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?eback@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?eback@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?egptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?egptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?egptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?empty@?$_Yarn@D@std@@QEBA_NXZ
+?empty@?$_Yarn@G@std@@QEBA_NXZ
+?empty@?$_Yarn@_W@std@@QEBA_NXZ
+?empty@locale@std@@SA?AV12@XZ
+?encoding@codecvt_base@std@@QEBAHXZ
+?eof@ios_base@std@@QEBA_NXZ
+?epptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?epptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?epptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?exceptions@ios_base@std@@QEAAXH@Z
+?exceptions@ios_base@std@@QEAAXI@Z
+?exceptions@ios_base@std@@QEBAHXZ
+?fail@ios_base@std@@QEBA_NXZ
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAADD@Z
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAGXZ
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA_W_W@Z
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBA_WXZ
+?flags@ios_base@std@@QEAAHH@Z
+?flags@ios_base@std@@QEBAHXZ
+?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ
+?flush@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@XZ
+?flush@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@XZ
+?gbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXH@Z
+?gbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXH@Z
+?gbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXH@Z
+?gcount@?$basic_istream@DU?$char_traits@D@std@@@std@@QEBA_JXZ
+?gcount@?$basic_istream@GU?$char_traits@G@std@@@std@@QEBA_JXZ
+?gcount@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEBA_JXZ
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@D@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_JD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@G@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_JG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEA_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD4@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBG4@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEB_W4@Z
+?get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_new_handler@std@@YAP6AXXZXZ
+?get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_JD@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_JG@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J_W@Z
+?getloc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@ios_base@std@@QEBA?AVlocale@2@XZ
+?global@locale@std@@SA?AV12@AEBV12@@Z
+?good@ios_base@std@@QEBA_NXZ
+?gptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?gptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?gptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?id@?$codecvt@DDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@GDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_WDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$collate@D@std@@2V0locale@2@A
+?id@?$collate@G@std@@2V0locale@2@A
+?id@?$collate@_W@std@@2V0locale@2@A
+?id@?$ctype@D@std@@2V0locale@2@A
+?id@?$ctype@G@std@@2V0locale@2@A
+?id@?$ctype@_W@std@@2V0locale@2@A
+?id@?$messages@D@std@@2V0locale@2@A
+?id@?$messages@G@std@@2V0locale@2@A
+?id@?$messages@_W@std@@2V0locale@2@A
+?id@?$money_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$moneypunct@D$00@std@@2V0locale@2@A
+?id@?$moneypunct@D$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@G$00@std@@2V0locale@2@A
+?id@?$moneypunct@G$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@_W$00@std@@2V0locale@2@A
+?id@?$moneypunct@_W$0A@@std@@2V0locale@2@A
+?id@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$numpunct@D@std@@2V0locale@2@A
+?id@?$numpunct@G@std@@2V0locale@2@A
+?id@?$numpunct@_W@std@@2V0locale@2@A
+?id@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?ignore@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?ignore@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JG@Z
+?ignore@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JG@Z
+?imbue@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@ios_base@std@@QEAA?AVlocale@2@AEBV32@@Z
+?in@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?in@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAG3AEAPEAG@Z
+?in@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_S3AEAPEA_S@Z
+?in@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_U3AEAPEA_U@Z
+?in@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_W3AEAPEA_W@Z
+?in_avail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JXZ
+?in_avail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JXZ
+?in_avail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JXZ
+?init@?$basic_ios@DU?$char_traits@D@std@@@std@@IEAAXPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@_N@Z
+?init@?$basic_ios@GU?$char_traits@G@std@@@std@@IEAAXPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@_N@Z
+?init@?$basic_ios@_WU?$char_traits@_W@std@@@std@@IEAAXPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_N@Z
+?intl@?$moneypunct@D$00@std@@2_NB
+?intl@?$moneypunct@D$0A@@std@@2_NB
+?intl@?$moneypunct@G$00@std@@2_NB
+?intl@?$moneypunct@G$0A@@std@@2_NB
+?intl@?$moneypunct@_W$00@std@@2_NB
+?intl@?$moneypunct@_W$0A@@std@@2_NB
+?ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_N_N@Z
+?ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_N_N@Z
+?ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_N_N@Z
+?is@?$ctype@D@std@@QEBAPEBDPEBD0PEAF@Z
+?is@?$ctype@D@std@@QEBA_NFD@Z
+?is@?$ctype@G@std@@QEBAPEBGPEBG0PEAF@Z
+?is@?$ctype@G@std@@QEBA_NFG@Z
+?is@?$ctype@_W@std@@QEBAPEB_WPEB_W0PEAF@Z
+?is@?$ctype@_W@std@@QEBA_NF_W@Z
+?isfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?isfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?isfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?iword@ios_base@std@@QEAAAEAJH@Z
+?length@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?max_length@codecvt_base@std@@QEBAHXZ
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXAEAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXAEAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXAEAV12@@Z
+?narrow@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADDD@Z
+?narrow@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBADGD@Z
+?narrow@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAD_WD@Z
+?narrow@?$ctype@D@std@@QEBADDD@Z
+?narrow@?$ctype@D@std@@QEBAPEBDPEBD0DPEAD@Z
+?narrow@?$ctype@G@std@@QEBADGD@Z
+?narrow@?$ctype@G@std@@QEBAPEBGPEBG0DPEAD@Z
+?narrow@?$ctype@_W@std@@QEBAD_WD@Z
+?narrow@?$ctype@_W@std@@QEBAPEB_WPEB_W0DPEAD@Z
+?opfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA_NXZ
+?opfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA_NXZ
+?opfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA_NXZ
+?osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?out@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?out@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBG1AEAPEBGPEAD3AEAPEAD@Z
+?out@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_S1AEAPEB_SPEAD3AEAPEAD@Z
+?out@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_U1AEAPEB_UPEAD3AEAPEAD@Z
+?out@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_W1AEAPEB_WPEAD3AEAPEAD@Z
+?overflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHH@Z
+?overflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGG@Z
+?overflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGG@Z
+?pbackfail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHH@Z
+?pbackfail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGG@Z
+?pbackfail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGG@Z
+?pbase@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?pbase@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?pbase@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?pbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXH@Z
+?pbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXH@Z
+?pbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXH@Z
+?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?peek@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?peek@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?pptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?pptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?pptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?precision@ios_base@std@@QEAA_J_J@Z
+?precision@ios_base@std@@QEBA_JXZ
+?pubimbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubimbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubimbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubsetbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAPEAV12@PEAD_J@Z
+?pubsetbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAPEAV12@PEAG_J@Z
+?pubsetbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAPEAV12@PEA_W_J@Z
+?pubsync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?pubsync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAHXZ
+?pubsync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAHXZ
+?put@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@D@Z
+?put@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@G@Z
+?put@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_W@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DJ@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DK@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DN@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DO@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBX@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_J@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_K@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_N@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GJ@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GK@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GN@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GO@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBX@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_J@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_K@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_N@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WJ@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WK@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WN@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WO@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBX@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_J@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_K@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_N@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@DD@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@PEBD3@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@DD@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@PEBG3@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@DD@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@PEB_W4@Z
+?putback@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@D@Z
+?putback@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@G@Z
+?putback@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_W@Z
+?pword@ios_base@std@@QEAAAEAPEAXH@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@XZ
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@XZ
+?rdstate@ios_base@std@@QEBAHXZ
+?read@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?read@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?read@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?readsome@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_JPEAD_J@Z
+?readsome@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_JPEAG_J@Z
+?readsome@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_JPEA_W_J@Z
+?register_callback@ios_base@std@@QEAAXP6AXW4event@12@AEAV12@H@ZH@Z
+?resetiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sbumpc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sbumpc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?scan_is@?$ctype@D@std@@QEBAPEBDFPEBD0@Z
+?scan_is@?$ctype@G@std@@QEBAPEBGFPEBG0@Z
+?scan_is@?$ctype@_W@std@@QEBAPEB_WFPEB_W0@Z
+?scan_not@?$ctype@D@std@@QEBAPEBDFPEBD0@Z
+?scan_not@?$ctype@G@std@@QEBAPEBGFPEBG0@Z
+?scan_not@?$ctype@_W@std@@QEBAPEB_WFPEB_W0@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JH@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JH@Z
+?seekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JH@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JH@Z
+?seekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?set_new_handler@std@@YAP6AXXZP6AXXZ@Z
+?set_rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?set_rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?set_rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?setbase@std@@YA?AU?$_Smanip@H@1@H@Z
+?setbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAPEAV12@PEAD_J@Z
+?setbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAPEAV12@PEAG_J@Z
+?setbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAPEAV12@PEA_W_J@Z
+?setf@ios_base@std@@QEAAHH@Z
+?setf@ios_base@std@@QEAAHHH@Z
+?setg@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD00@Z
+?setg@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG00@Z
+?setg@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W00@Z
+?setiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD00@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD0@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG00@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG0@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W00@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W0@Z
+?setprecision@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXI@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXI@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXI@Z
+?setstate@ios_base@std@@QEAAXH@Z
+?setstate@ios_base@std@@QEAAXH_N@Z
+?setstate@ios_base@std@@QEAAXI@Z
+?setw@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sgetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sgetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?sgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEAD_J@Z
+?sgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JPEAG_J@Z
+?sgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JPEA_W_J@Z
+?showmanyc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JXZ
+?showmanyc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JXZ
+?showmanyc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JXZ
+?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?snextc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?snextc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?sputbackc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
+?sputbackc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?sputbackc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAG_W@Z
+?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
+?sputc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?sputc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAG_W@Z
+?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEBD_J@Z
+?sputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JPEBG_J@Z
+?sputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JPEB_W_J@Z
+?stossc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?stossc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?stossc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?sungetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sungetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sungetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?swap@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@ios_base@std@@QEAAXAEAV12@@Z
+?sync@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sync@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAHXZ
+?sync@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAHXZ
+?sync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?sync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAHXZ
+?sync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAHXZ
+?sync_with_stdio@ios_base@std@@SA_N_N@Z
+?table@?$ctype@D@std@@QEBAPEBFXZ
+?table_size@?$ctype@D@std@@2_KB
+?tellg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAPEAV?$basic_ostream@DU?$char_traits@D@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAPEAV?$basic_ostream@GU?$char_traits@G@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAPEAV?$basic_ostream@GU?$char_traits@G@std@@@2@XZ
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAPEAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAPEAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@XZ
+?tolower@?$ctype@D@std@@QEBADD@Z
+?tolower@?$ctype@D@std@@QEBAPEBDPEADPEBD@Z
+?tolower@?$ctype@G@std@@QEBAGG@Z
+?tolower@?$ctype@G@std@@QEBAPEBGPEAGPEBG@Z
+?tolower@?$ctype@_W@std@@QEBAPEB_WPEA_WPEB_W@Z
+?tolower@?$ctype@_W@std@@QEBA_W_W@Z
+?toupper@?$ctype@D@std@@QEBADD@Z
+?toupper@?$ctype@D@std@@QEBAPEBDPEADPEBD@Z
+?toupper@?$ctype@G@std@@QEBAGG@Z
+?toupper@?$ctype@G@std@@QEBAPEBGPEAGPEBG@Z
+?toupper@?$ctype@_W@std@@QEBAPEB_WPEA_WPEB_W@Z
+?toupper@?$ctype@_W@std@@QEBA_W_W@Z
+?uflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?uflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGXZ
+?uflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGXZ
+?uncaught_exception@std@@YA_NXZ
+?uncaught_exceptions@std@@YAHXZ
+?underflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?underflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGXZ
+?underflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGXZ
+?unget@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ
+?unget@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@XZ
+?unget@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@XZ
+?unsetf@ios_base@std@@QEAAXH@Z
+?unshift@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?wcerr@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcerr@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcin@std@@3V?$basic_istream@GU?$char_traits@G@std@@@1@A
+?wcin@std@@3V?$basic_istream@_WU?$char_traits@_W@std@@@1@A
+?wclog@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wclog@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcout@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcout@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?widen@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADD@Z
+?widen@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAGD@Z
+?widen@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBA_WD@Z
+?widen@?$ctype@D@std@@QEBADD@Z
+?widen@?$ctype@D@std@@QEBAPEBDPEBD0PEAD@Z
+?widen@?$ctype@G@std@@QEBAGD@Z
+?widen@?$ctype@G@std@@QEBAPEBDPEBD0PEAG@Z
+?widen@?$ctype@_W@std@@QEBAPEBDPEBD0PEA_W@Z
+?widen@?$ctype@_W@std@@QEBA_WD@Z
+?width@ios_base@std@@QEAA_J_J@Z
+?width@ios_base@std@@QEBA_JXZ
+?write@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEBD_J@Z
+?write@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEBG_J@Z
+?write@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEB_W_J@Z
+?xalloc@ios_base@std@@SAHXZ
+?xsgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JPEAD_J@Z
+?xsgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JPEAG_J@Z
+?xsgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JPEA_W_J@Z
+?xsputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JPEBD_J@Z
+?xsputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JPEBG_J@Z
+?xsputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JPEB_W_J@Z
+_Chmod
+_Close_dir
+_Cnd_broadcast
+_Cnd_destroy
+_Cnd_destroy_in_situ
+_Cnd_do_broadcast_at_thread_exit
+_Cnd_init
+_Cnd_init_in_situ
+_Cnd_register_at_thread_exit
+_Cnd_signal
+_Cnd_timedwait
+_Cnd_unregister_at_thread_exit
+_Cnd_wait
+_Copy_file
+_Cosh
+_Current_get
+_Current_set
+_Denorm
+_Dtest
+_Equivalent
+_Exp
+_FCosh
+_FDenorm
+_FDtest
+_FExp
+_FInf
+_FNan
+_FSinh
+_FSnan
+_File_size
+_Getcoll
+_Getctype
+_Getcvt
+_Getdateorder
+_Getwctype
+_Getwctypes
+_Hard_links
+_Hugeval
+_Inf
+_LCosh
+_LDenorm
+_LDtest
+_LExp
+_LInf
+_LNan
+_LSinh
+_LSnan
+_Last_write_time
+_Link
+_Lock_shared_ptr_spin_lock
+_Lstat
+_Make_dir
+_Mbrtowc
+_Mtx_clear_owner
+_Mtx_current_owns
+_Mtx_destroy
+_Mtx_destroy_in_situ
+_Mtx_getconcrtcs
+_Mtx_init
+_Mtx_init_in_situ
+_Mtx_lock
+_Mtx_reset_owner
+_Mtx_timedlock
+_Mtx_trylock
+_Mtx_unlock
+_Mtxdst
+_Mtxinit
+_Mtxlock
+_Mtxunlock
+_Nan
+_Open_dir
+_Query_perf_counter
+_Query_perf_frequency
+_Read_dir
+_Remove_dir
+_Rename
+_Resize
+_Set_last_write_time
+_Sinh
+_Snan
+_Stat
+_Statvfs
+_Stod
+_Stodx
+_Stof
+_Stofx
+_Stold
+_Stoldx
+_Stoll
+_Stollx
+_Stolx
+_Stoul
+_Stoull
+_Stoullx
+_Stoulx
+_Strcoll
+_Strxfrm
+_Symlink
+_Symlink_get
+_Temp_get
+_Thrd_abort
+_Thrd_create
+_Thrd_current
+_Thrd_detach
+_Thrd_equal
+_Thrd_exit
+_Thrd_hardware_concurrency
+_Thrd_id
+_Thrd_join
+_Thrd_sleep
+_Thrd_start
+_Thrd_yield
+_To_byte
+_To_wide
+_Tolower
+_Toupper
+_Towlower
+_Towupper
+_Unlink
+_Unlock_shared_ptr_spin_lock
+_WStod
+_WStodx
+_WStof
+_WStofx
+_WStold
+_WStoldx
+_Wcrtomb
+_Wcscoll
+_Wcsxfrm
+_Xtime_diff_to_millis
+_Xtime_diff_to_millis2
+_Xtime_get_ticks
+__Wcrtomb_lk
+__crtCloseThreadpoolTimer
+__crtCloseThreadpoolWait
+__crtCompareStringA
+__crtCompareStringEx
+__crtCompareStringW
+__crtCreateEventExW
+__crtCreateSemaphoreExW
+__crtCreateSymbolicLinkW
+__crtCreateThreadpoolTimer
+__crtCreateThreadpoolWait
+__crtFlushProcessWriteBuffers
+__crtFreeLibraryWhenCallbackReturns
+__crtGetCurrentProcessorNumber
+__crtGetFileInformationByHandleEx
+__crtGetLocaleInfoEx
+__crtGetSystemTimePreciseAsFileTime
+__crtGetTickCount64
+__crtInitOnceExecuteOnce
+__crtInitializeCriticalSectionEx
+__crtIsPackagedApp
+__crtLCMapStringA
+__crtLCMapStringEx
+__crtLCMapStringW
+__crtSetFileInformationByHandle
+__crtSetThreadpoolTimer
+__crtSetThreadpoolWait
+__crtWaitForThreadpoolTimerCallbacks
+__set_stl_sync_api_mode
+xtime_get
diff --git a/msvc-stl/stl/msbuild/stl_base/amd64_onecore.exports b/msvc-stl/stl/msbuild/stl_base/amd64_onecore.exports
new file mode 100644
index 0000000..779c4f7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/amd64_onecore.exports
@@ -0,0 +1,1493 @@
+??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??0?$_Yarn@D@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@D@std@@QEAA@PEBD@Z
+??0?$_Yarn@D@std@@QEAA@XZ
+??0?$_Yarn@G@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@G@std@@QEAA@PEBG@Z
+??0?$_Yarn@G@std@@QEAA@XZ
+??0?$_Yarn@_W@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@_W@std@@QEAA@PEB_W@Z
+??0?$_Yarn@_W@std@@QEAA@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@IEAA@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@IEAA@XZ
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@IEAA@XZ
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N1@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N1@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N1@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@XZ
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@XZ
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@XZ
+??0?$codecvt@DDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@DDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@KW4_Codecvt_mode@1@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@KW4_Codecvt_mode@1@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$ctype@D@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@D@std@@QEAA@PEBF_N_K@Z
+??0?$ctype@G@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@G@std@@QEAA@_K@Z
+??0?$ctype@_W@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@_W@std@@QEAA@_K@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0Init@ios_base@std@@QEAA@XZ
+??0_Facet_base@std@@QEAA@AEBV01@@Z
+??0_Facet_base@std@@QEAA@XZ
+??0_Init_locks@std@@QEAA@XZ
+??0_Locimp@locale@std@@AEAA@AEBV012@@Z
+??0_Locimp@locale@std@@AEAA@_N@Z
+??0_Locinfo@std@@QEAA@HPEBD@Z
+??0_Locinfo@std@@QEAA@PEBD@Z
+??0_Lockit@std@@QEAA@H@Z
+??0_Lockit@std@@QEAA@XZ
+??0_Timevec@std@@QEAA@AEBV01@@Z
+??0_Timevec@std@@QEAA@PEAX@Z
+??0_UShinit@std@@QEAA@XZ
+??0_Winit@std@@QEAA@XZ
+??0codecvt_base@std@@QEAA@_K@Z
+??0ctype_base@std@@QEAA@_K@Z
+??0facet@locale@std@@IEAA@_K@Z
+??0id@locale@std@@QEAA@_K@Z
+??0ios_base@std@@IEAA@XZ
+??0task_continuation_context@Concurrency@@AEAA@XZ
+??0time_base@std@@QEAA@_K@Z
+??1?$_Yarn@D@std@@QEAA@XZ
+??1?$_Yarn@G@std@@QEAA@XZ
+??1?$_Yarn@_W@std@@QEAA@XZ
+??1?$basic_ios@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_ios@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_ios@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_iostream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_iostream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_iostream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_istream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_istream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_istream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_ostream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_ostream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_ostream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$codecvt@DDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@GDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_SDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_UDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_WDU_Mbstatet@@@std@@MEAA@XZ
+??1?$ctype@D@std@@MEAA@XZ
+??1?$ctype@G@std@@MEAA@XZ
+??1?$ctype@_W@std@@MEAA@XZ
+??1?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1Init@ios_base@std@@QEAA@XZ
+??1_Facet_base@std@@UEAA@XZ
+??1_Init_locks@std@@QEAA@XZ
+??1_Locimp@locale@std@@MEAA@XZ
+??1_Locinfo@std@@QEAA@XZ
+??1_Lockit@std@@QEAA@XZ
+??1_Timevec@std@@QEAA@XZ
+??1_UShinit@std@@QEAA@XZ
+??1_Winit@std@@QEAA@XZ
+??1codecvt_base@std@@UEAA@XZ
+??1ctype_base@std@@UEAA@XZ
+??1facet@locale@std@@MEAA@XZ
+??1ios_base@std@@UEAA@XZ
+??1time_base@std@@UEAA@XZ
+??4?$_Iosb@H@std@@QEAAAEAV01@$$QEAV01@@Z
+??4?$_Iosb@H@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@D@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@D@std@@QEAAAEAV01@PEBD@Z
+??4?$_Yarn@G@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@G@std@@QEAAAEAV01@PEBG@Z
+??4?$_Yarn@_W@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@_W@std@@QEAAAEAV01@PEB_W@Z
+??4?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4Init@ios_base@std@@QEAAAEAV012@AEBV012@@Z
+??4_Crt_new_delete@std@@QEAAAEAU01@$$QEAU01@@Z
+??4_Crt_new_delete@std@@QEAAAEAU01@AEBU01@@Z
+??4_Facet_base@std@@QEAAAEAV01@AEBV01@@Z
+??4_Init_locks@std@@QEAAAEAV01@AEBV01@@Z
+??4_Timevec@std@@QEAAAEAV01@AEBV01@@Z
+??4_UShinit@std@@QEAAAEAV01@AEBV01@@Z
+??4_Winit@std@@QEAAAEAV01@AEBV01@@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@DU?$char_traits@D@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@GU?$char_traits@G@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@DU?$char_traits@D@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@GU?$char_traits@G@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_N@Z
+??7ios_base@std@@QEBA_NXZ
+??Bid@locale@std@@QEAA_KXZ
+??Bios_base@std@@QEBA_NXZ
+??_7?$basic_ios@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ios@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ios@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_iostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_iostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_iostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_istream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_istream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_istream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_ostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_streambuf@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_streambuf@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$codecvt@DDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@GDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_SDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_UDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_WDU_Mbstatet@@@std@@6B@
+??_7?$ctype@D@std@@6B@
+??_7?$ctype@G@std@@6B@
+??_7?$ctype@_W@std@@6B@
+??_7?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7_Facet_base@std@@6B@
+??_7_Locimp@locale@std@@6B@
+??_7codecvt_base@std@@6B@
+??_7ctype_base@std@@6B@
+??_7facet@locale@std@@6B@
+??_7ios_base@std@@6B@
+??_7time_base@std@@6B@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_istream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_ostream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_istream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_ostream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_istream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_ostream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_istream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_istream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_istream@_WU?$char_traits@_W@std@@@std@@7B@
+??_8?$basic_ostream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_ostream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_ostream@_WU?$char_traits@_W@std@@@std@@7B@
+??_D?$basic_iostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_iostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_D?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_F?$codecvt@DDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@GDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_SDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_UDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_WDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$ctype@D@std@@QEAAXXZ
+??_F?$ctype@G@std@@QEAAXXZ
+??_F?$ctype@_W@std@@QEAAXXZ
+??_F?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F_Locinfo@std@@QEAAXXZ
+??_F_Timevec@std@@QEAAXXZ
+??_Fcodecvt_base@std@@QEAAXXZ
+??_Fctype_base@std@@QEAAXXZ
+??_Ffacet@locale@std@@QEAAXXZ
+??_Fid@locale@std@@QEAAXXZ
+??_Ftime_base@std@@QEAAXXZ
+?CaptureCallstack@platform@details@Concurrency@@YA_KPEAPEAX_K1@Z
+?GetCurrentThreadId@platform@details@Concurrency@@YAJXZ
+?GetNextAsyncId@platform@details@Concurrency@@YAIXZ
+?ReportUnhandledError@_ExceptionHolder@details@Concurrency@@AEAAXXZ
+?_Addcats@_Locinfo@std@@QEAAAEAV12@HPEBD@Z
+?_Addfac@_Locimp@locale@std@@AEAAXPEAVfacet@23@_K@Z
+?_Addstd@ios_base@std@@SAXPEAV12@@Z
+?_Assign@_ContextCallback@details@Concurrency@@AEAAXPEAX@Z
+?_Atexit@@YAXP6AXXZ@Z
+?_BADOFF@std@@3_JB
+?_C_str@?$_Yarn@D@std@@QEBAPEBDXZ
+?_C_str@?$_Yarn@G@std@@QEBAPEBGXZ
+?_C_str@?$_Yarn@_W@std@@QEBAPEB_WXZ
+?_CallInContext@_ContextCallback@details@Concurrency@@QEBAXV?$function@$$A6AXXZ@std@@_N@Z
+?_Callfns@ios_base@std@@AEAAXW4event@12@@Z
+?_Capture@_ContextCallback@details@Concurrency@@AEAAXXZ
+?_Clocptr@_Locimp@locale@std@@0PEAV123@EA
+?_Decref@facet@locale@std@@UEAAPEAV_Facet_base@3@XZ
+?_Donarrow@?$ctype@G@std@@IEBADGD@Z
+?_Donarrow@?$ctype@_W@std@@IEBAD_WD@Z
+?_Dowiden@?$ctype@G@std@@IEBAGD@Z
+?_Dowiden@?$ctype@_W@std@@IEBA_WD@Z
+?_Empty@?$_Yarn@D@std@@QEBA_NXZ
+?_Empty@?$_Yarn@G@std@@QEBA_NXZ
+?_Empty@?$_Yarn@_W@std@@QEBA_NXZ
+?_Execute_once@std@@YAHAEAUonce_flag@1@P6AHPEAX1PEAPEAX@Z1@Z
+?_Ffmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Ffmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Ffmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Findarr@ios_base@std@@AEAAAEAU_Iosarray@12@H@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEBDHH@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEBGHH@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEB_WHH@Z
+?_Fput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBD_K@Z
+?_Fput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBD_K@Z
+?_Fput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBD_K@Z
+?_Getcat@?$codecvt@DDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@GDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_SDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_UDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_WDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@D@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@G@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@_W@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@facet@locale@std@@SA_KPEAPEBV123@PEBV23@@Z
+?_Getcoll@_Locinfo@std@@QEBA?AU_Collvec@@XZ
+?_Getctype@_Locinfo@std@@QEBA?AU_Ctypevec@@XZ
+?_Getcvt@_Locinfo@std@@QEBA?AU_Cvtvec@@XZ
+?_Getdateorder@_Locinfo@std@@QEBAHXZ
+?_Getdays@_Locinfo@std@@QEBAPEBDXZ
+?_Getfalse@_Locinfo@std@@QEBAPEBDXZ
+?_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getfmt@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getfmt@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getfmt@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getgloballocale@locale@std@@CAPEAV_Locimp@12@XZ
+?_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1HAEBVlocale@2@@Z
+?_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1HAEBVlocale@2@@Z
+?_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1HAEBVlocale@2@@Z
+?_Getint@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@0HHAEAHAEBV?$ctype@D@2@@Z
+?_Getint@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@0HHAEAHAEBV?$ctype@G@2@@Z
+?_Getint@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@0HHAEAHAEBV?$ctype@_W@2@@Z
+?_Getlconv@_Locinfo@std@@QEBAPEBUlconv@@XZ
+?_Getmonths@_Locinfo@std@@QEBAPEBDXZ
+?_Getname@_Locinfo@std@@QEBAPEBDXZ
+?_Getptr@_Timevec@std@@QEBAPEAXXZ
+?_Gettnames@_Locinfo@std@@QEBA?AV_Timevec@2@XZ
+?_Gettrue@_Locinfo@std@@QEBAPEBDXZ
+?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBA_JXZ
+?_Gnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBA_JXZ
+?_Gnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBA_JXZ
+?_Gndec@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gndec@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gndec@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Gninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gnpreinc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gnpreinc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Id_cnt@id@locale@std@@0HA
+?_Ifmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Ifmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Ifmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Incref@facet@locale@std@@UEAAXXZ
+?_Index@ios_base@std@@0HA
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAPEAD0PEAH001@Z
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXXZ
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAPEAG0PEAH001@Z
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXXZ
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEAPEA_W0PEAH001@Z
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXXZ
+?_Init@?$codecvt@DDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@GDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_SDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_UDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_WDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@D@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@G@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@_W@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@ios_base@std@@IEAAXXZ
+?_Init@locale@std@@CAPEAV_Locimp@12@_N@Z
+?_Init_cnt@Init@ios_base@std@@0HA
+?_Init_cnt@_UShinit@std@@0HA
+?_Init_cnt@_Winit@std@@0HA
+?_Init_cnt_func@Init@ios_base@std@@CAAEAHXZ
+?_Init_ctor@Init@ios_base@std@@CAXPEAV123@@Z
+?_Init_dtor@Init@ios_base@std@@CAXPEAV123@@Z
+?_Init_locks_ctor@_Init_locks@std@@CAXPEAV12@@Z
+?_Init_locks_dtor@_Init_locks@std@@CAXPEAV12@@Z
+?_Ios_base_dtor@ios_base@std@@CAXPEAV12@@Z
+?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_N_N@Z
+?_Ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_N_N@Z
+?_Ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_N_N@Z
+?_Iput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEAD_K@Z
+?_Iput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEAD_K@Z
+?_Iput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEAD_K@Z
+?_IsCurrentOriginSTA@_ContextCallback@details@Concurrency@@CA_NXZ
+?_IsNonBlockingThread@_Task_impl_base@details@Concurrency@@SA_NXZ
+?_Locimp_Addfac@_Locimp@locale@std@@CAXPEAV123@PEAVfacet@23@_K@Z
+?_Locimp_ctor@_Locimp@locale@std@@CAXPEAV123@AEBV123@@Z
+?_Locimp_dtor@_Locimp@locale@std@@CAXPEAV123@@Z
+?_Locinfo_Addcats@_Locinfo@std@@SAAEAV12@PEAV12@HPEBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPEAV12@HPEBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPEAV12@PEBD@Z
+?_Locinfo_dtor@_Locinfo@std@@SAXPEAV12@@Z
+?_Lock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAAXXZ
+?_Lock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAAXXZ
+?_Lock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAAXXZ
+?_Lockit_ctor@_Lockit@std@@CAXPEAV12@@Z
+?_Lockit_ctor@_Lockit@std@@CAXPEAV12@H@Z
+?_Lockit_ctor@_Lockit@std@@SAXH@Z
+?_Lockit_dtor@_Lockit@std@@CAXPEAV12@@Z
+?_Lockit_dtor@_Lockit@std@@SAXH@Z
+?_LogCancelTask@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogScheduleTask@_TaskEventLogger@details@Concurrency@@QEAAX_N@Z
+?_LogTaskCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogTaskExecutionCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogWorkItemCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogWorkItemStarted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_MP_Add@std@@YAXQEA_K_K@Z
+?_MP_Get@std@@YA_KQEA_K@Z
+?_MP_Mul@std@@YAXQEA_K_K1@Z
+?_MP_Rem@std@@YAXQEA_K_K@Z
+?_Makeloc@_Locimp@locale@std@@CAPEAV123@AEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makeushloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makewloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makexloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Mtx_delete@threads@stdext@@YAXPEAX@Z
+?_Mtx_lock@threads@stdext@@YAXPEAX@Z
+?_Mtx_new@threads@stdext@@YAXAEAPEAX@Z
+?_Mtx_unlock@threads@stdext@@YAXPEAX@Z
+?_New_Locimp@_Locimp@locale@std@@CAPEAV123@AEBV123@@Z
+?_New_Locimp@_Locimp@locale@std@@CAPEAV123@_N@Z
+?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?_Osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?_Osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?_Pnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBA_JXZ
+?_Pnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBA_JXZ
+?_Pnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBA_JXZ
+?_Pninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Pninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Pninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Ptr_cerr@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_cin@std@@3PEAV?$basic_istream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_clog@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_cout@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_wcerr@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcerr@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wcin@std@@3PEAV?$basic_istream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcin@std@@3PEAV?$basic_istream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wclog@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wclog@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wcout@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcout@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@PEBD_K@Z
+?_Put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@PEBG_K@Z
+?_Put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@PEB_W_K@Z
+?_Raise_handler@std@@3P6AXAEBVexception@stdext@@@ZEA
+?_Random_device@std@@YAIXZ
+?_Release_chore@details@Concurrency@@YAXPEAU_Threadpool_chore@12@@Z
+?_Rep@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@D_K@Z
+?_Rep@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@G_K@Z
+?_Rep@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@_W_K@Z
+?_ReportUnobservedException@details@Concurrency@@YAXXZ
+?_Reschedule_chore@details@Concurrency@@YAHPEBU_Threadpool_chore@12@@Z
+?_Reset@_ContextCallback@details@Concurrency@@AEAAXXZ
+?_Rethrow_future_exception@std@@YAXVexception_ptr@1@@Z
+?_Rng_abort@std@@YAXPEBD@Z
+?_Schedule_chore@details@Concurrency@@YAHPEAU_Threadpool_chore@12@@Z
+?_Setgloballocale@locale@std@@CAXPEAX@Z
+?_Src@?1??_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Sync@ios_base@std@@0_NA
+?_Syserror_map@std@@YAPEBDH@Z
+?_Throw_C_error@std@@YAXH@Z
+?_Throw_Cpp_error@std@@YAXH@Z
+?_Throw_future_error@std@@YAXAEBVerror_code@1@@Z
+?_Tidy@?$_Yarn@D@std@@AEAAXXZ
+?_Tidy@?$_Yarn@G@std@@AEAAXXZ
+?_Tidy@?$_Yarn@_W@std@@AEAAXXZ
+?_Tidy@?$ctype@D@std@@IEAAXXZ
+?_Tidy@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEAAXXZ
+?_Tidy@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEAAXXZ
+?_Tidy@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEAAXXZ
+?_Tidy@ios_base@std@@AEAAXXZ
+?_Unlock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAAXXZ
+?_Unlock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAAXXZ
+?_Unlock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAAXXZ
+?_W_Getdays@_Locinfo@std@@QEBAPEBGXZ
+?_W_Getmonths@_Locinfo@std@@QEBAPEBGXZ
+?_W_Gettnames@_Locinfo@std@@QEBA?AV_Timevec@2@XZ
+?_Winerror_map@std@@YAHH@Z
+?_Winerror_message@std@@YAKKPEADK@Z
+?_XGetLastError@std@@YAXXZ
+?_XLgamma@std@@YAMM@Z
+?_XLgamma@std@@YANN@Z
+?_XLgamma@std@@YAOO@Z
+?_Xbad_alloc@std@@YAXXZ
+?_Xbad_function_call@std@@YAXXZ
+?_Xinvalid_argument@std@@YAXPEBD@Z
+?_Xlength_error@std@@YAXPEBD@Z
+?_Xout_of_range@std@@YAXPEBD@Z
+?_Xoverflow_error@std@@YAXPEBD@Z
+?_Xregex_error@std@@YAXW4error_type@regex_constants@1@@Z
+?_Xruntime_error@std@@YAXPEBD@Z
+?__ExceptionPtrAssign@@YAXPEAXPEBX@Z
+?__ExceptionPtrCompare@@YA_NPEBX0@Z
+?__ExceptionPtrCopy@@YAXPEAXPEBX@Z
+?__ExceptionPtrCopyException@@YAXPEAXPEBX1@Z
+?__ExceptionPtrCreate@@YAXPEAX@Z
+?__ExceptionPtrCurrentException@@YAXPEAX@Z
+?__ExceptionPtrDestroy@@YAXPEAX@Z
+?__ExceptionPtrRethrow@@YAXPEBX@Z
+?__ExceptionPtrSwap@@YAXPEAX0@Z
+?__ExceptionPtrToBool@@YA_NPEBX@Z
+?always_noconv@codecvt_base@std@@QEBA_NXZ
+?bad@ios_base@std@@QEBA_NXZ
+?c_str@?$_Yarn@D@std@@QEBAPEBDXZ
+?c_str@?$_Yarn@G@std@@QEBAPEBGXZ
+?c_str@?$_Yarn@_W@std@@QEBAPEB_WXZ
+?cerr@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?cin@std@@3V?$basic_istream@DU?$char_traits@D@std@@@1@A
+?classic@locale@std@@SAAEBV12@XZ
+?classic_table@?$ctype@D@std@@SAPEBFXZ
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXI@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXI@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXI@Z
+?clear@ios_base@std@@QEAAXH@Z
+?clear@ios_base@std@@QEAAXH_N@Z
+?clear@ios_base@std@@QEAAXI@Z
+?clog@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?copyfmt@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@ios_base@std@@QEAAAEAV12@AEBV12@@Z
+?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?do_always_noconv@?$codecvt@DDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@GDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_SDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_UDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_WDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@codecvt_base@std@@MEBA_NXZ
+?do_date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_encoding@?$codecvt@GDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@codecvt_base@std@@MEBAHXZ
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_in@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?do_in@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAG3AEAPEAG@Z
+?do_in@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_S3AEAPEA_S@Z
+?do_in@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_U3AEAPEA_U@Z
+?do_in@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_W3AEAPEA_W@Z
+?do_is@?$ctype@G@std@@MEBAPEBGPEBG0PEAF@Z
+?do_is@?$ctype@G@std@@MEBA_NFG@Z
+?do_is@?$ctype@_W@std@@MEBAPEB_WPEB_W0PEAF@Z
+?do_is@?$ctype@_W@std@@MEBA_NF_W@Z
+?do_length@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_max_length@?$codecvt@GDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@codecvt_base@std@@MEBAHXZ
+?do_narrow@?$ctype@D@std@@MEBADDD@Z
+?do_narrow@?$ctype@D@std@@MEBAPEBDPEBD0DPEAD@Z
+?do_narrow@?$ctype@G@std@@MEBADGD@Z
+?do_narrow@?$ctype@G@std@@MEBAPEBGPEBG0DPEAD@Z
+?do_narrow@?$ctype@_W@std@@MEBAD_WD@Z
+?do_narrow@?$ctype@_W@std@@MEBAPEB_WPEB_W0DPEAD@Z
+?do_out@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?do_out@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBG1AEAPEBGPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_S1AEAPEB_SPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_U1AEAPEB_UPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_W1AEAPEB_WPEAD3AEAPEAD@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DJ@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DK@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DN@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DO@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBX@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_J@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_K@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_N@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GJ@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GK@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GN@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GO@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBX@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_J@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_K@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_N@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WJ@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WK@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WN@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WO@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBX@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_J@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_K@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_N@Z
+?do_put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@DD@Z
+?do_put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@DD@Z
+?do_put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@DD@Z
+?do_scan_is@?$ctype@G@std@@MEBAPEBGFPEBG0@Z
+?do_scan_is@?$ctype@_W@std@@MEBAPEB_WFPEB_W0@Z
+?do_scan_not@?$ctype@G@std@@MEBAPEBGFPEBG0@Z
+?do_scan_not@?$ctype@_W@std@@MEBAPEB_WFPEB_W0@Z
+?do_tolower@?$ctype@D@std@@MEBADD@Z
+?do_tolower@?$ctype@D@std@@MEBAPEBDPEADPEBD@Z
+?do_tolower@?$ctype@G@std@@MEBAGG@Z
+?do_tolower@?$ctype@G@std@@MEBAPEBGPEAGPEBG@Z
+?do_tolower@?$ctype@_W@std@@MEBAPEB_WPEA_WPEB_W@Z
+?do_tolower@?$ctype@_W@std@@MEBA_W_W@Z
+?do_toupper@?$ctype@D@std@@MEBADD@Z
+?do_toupper@?$ctype@D@std@@MEBAPEBDPEADPEBD@Z
+?do_toupper@?$ctype@G@std@@MEBAGG@Z
+?do_toupper@?$ctype@G@std@@MEBAPEBGPEAGPEBG@Z
+?do_toupper@?$ctype@_W@std@@MEBAPEB_WPEA_WPEB_W@Z
+?do_toupper@?$ctype@_W@std@@MEBA_W_W@Z
+?do_unshift@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_widen@?$ctype@D@std@@MEBADD@Z
+?do_widen@?$ctype@D@std@@MEBAPEBDPEBD0PEAD@Z
+?do_widen@?$ctype@G@std@@MEBAGD@Z
+?do_widen@?$ctype@G@std@@MEBAPEBDPEBD0PEAG@Z
+?do_widen@?$ctype@_W@std@@MEBAPEBDPEBD0PEA_W@Z
+?do_widen@?$ctype@_W@std@@MEBA_WD@Z
+?eback@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?eback@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?eback@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?egptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?egptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?egptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?empty@?$_Yarn@D@std@@QEBA_NXZ
+?empty@?$_Yarn@G@std@@QEBA_NXZ
+?empty@?$_Yarn@_W@std@@QEBA_NXZ
+?empty@locale@std@@SA?AV12@XZ
+?encoding@codecvt_base@std@@QEBAHXZ
+?eof@ios_base@std@@QEBA_NXZ
+?epptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?epptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?epptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?exceptions@ios_base@std@@QEAAXH@Z
+?exceptions@ios_base@std@@QEAAXI@Z
+?exceptions@ios_base@std@@QEBAHXZ
+?fail@ios_base@std@@QEBA_NXZ
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAADD@Z
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAGXZ
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA_W_W@Z
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBA_WXZ
+?flags@ios_base@std@@QEAAHH@Z
+?flags@ios_base@std@@QEBAHXZ
+?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ
+?flush@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@XZ
+?flush@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@XZ
+?gbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXH@Z
+?gbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXH@Z
+?gbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXH@Z
+?gcount@?$basic_istream@DU?$char_traits@D@std@@@std@@QEBA_JXZ
+?gcount@?$basic_istream@GU?$char_traits@G@std@@@std@@QEBA_JXZ
+?gcount@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEBA_JXZ
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@D@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_JD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@G@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_JG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEA_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD4@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBG4@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEB_W4@Z
+?get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_new_handler@std@@YAP6AXXZXZ
+?get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_JD@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_JG@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J_W@Z
+?getloc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@ios_base@std@@QEBA?AVlocale@2@XZ
+?global@locale@std@@SA?AV12@AEBV12@@Z
+?good@ios_base@std@@QEBA_NXZ
+?gptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?gptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?gptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?id@?$codecvt@DDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@GDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_WDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$collate@D@std@@2V0locale@2@A
+?id@?$collate@G@std@@2V0locale@2@A
+?id@?$collate@_W@std@@2V0locale@2@A
+?id@?$ctype@D@std@@2V0locale@2@A
+?id@?$ctype@G@std@@2V0locale@2@A
+?id@?$ctype@_W@std@@2V0locale@2@A
+?id@?$messages@D@std@@2V0locale@2@A
+?id@?$messages@G@std@@2V0locale@2@A
+?id@?$messages@_W@std@@2V0locale@2@A
+?id@?$money_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$moneypunct@D$00@std@@2V0locale@2@A
+?id@?$moneypunct@D$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@G$00@std@@2V0locale@2@A
+?id@?$moneypunct@G$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@_W$00@std@@2V0locale@2@A
+?id@?$moneypunct@_W$0A@@std@@2V0locale@2@A
+?id@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$numpunct@D@std@@2V0locale@2@A
+?id@?$numpunct@G@std@@2V0locale@2@A
+?id@?$numpunct@_W@std@@2V0locale@2@A
+?id@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?ignore@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?ignore@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JG@Z
+?ignore@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JG@Z
+?imbue@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@ios_base@std@@QEAA?AVlocale@2@AEBV32@@Z
+?in@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?in@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAG3AEAPEAG@Z
+?in@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_S3AEAPEA_S@Z
+?in@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_U3AEAPEA_U@Z
+?in@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_W3AEAPEA_W@Z
+?in_avail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JXZ
+?in_avail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JXZ
+?in_avail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JXZ
+?init@?$basic_ios@DU?$char_traits@D@std@@@std@@IEAAXPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@_N@Z
+?init@?$basic_ios@GU?$char_traits@G@std@@@std@@IEAAXPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@_N@Z
+?init@?$basic_ios@_WU?$char_traits@_W@std@@@std@@IEAAXPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_N@Z
+?intl@?$moneypunct@D$00@std@@2_NB
+?intl@?$moneypunct@D$0A@@std@@2_NB
+?intl@?$moneypunct@G$00@std@@2_NB
+?intl@?$moneypunct@G$0A@@std@@2_NB
+?intl@?$moneypunct@_W$00@std@@2_NB
+?intl@?$moneypunct@_W$0A@@std@@2_NB
+?ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_N_N@Z
+?ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_N_N@Z
+?ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_N_N@Z
+?is@?$ctype@D@std@@QEBAPEBDPEBD0PEAF@Z
+?is@?$ctype@D@std@@QEBA_NFD@Z
+?is@?$ctype@G@std@@QEBAPEBGPEBG0PEAF@Z
+?is@?$ctype@G@std@@QEBA_NFG@Z
+?is@?$ctype@_W@std@@QEBAPEB_WPEB_W0PEAF@Z
+?is@?$ctype@_W@std@@QEBA_NF_W@Z
+?isfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?isfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?isfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?iword@ios_base@std@@QEAAAEAJH@Z
+?length@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?max_length@codecvt_base@std@@QEBAHXZ
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXAEAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXAEAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXAEAV12@@Z
+?narrow@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADDD@Z
+?narrow@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBADGD@Z
+?narrow@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAD_WD@Z
+?narrow@?$ctype@D@std@@QEBADDD@Z
+?narrow@?$ctype@D@std@@QEBAPEBDPEBD0DPEAD@Z
+?narrow@?$ctype@G@std@@QEBADGD@Z
+?narrow@?$ctype@G@std@@QEBAPEBGPEBG0DPEAD@Z
+?narrow@?$ctype@_W@std@@QEBAD_WD@Z
+?narrow@?$ctype@_W@std@@QEBAPEB_WPEB_W0DPEAD@Z
+?opfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA_NXZ
+?opfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA_NXZ
+?opfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA_NXZ
+?osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?out@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?out@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBG1AEAPEBGPEAD3AEAPEAD@Z
+?out@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_S1AEAPEB_SPEAD3AEAPEAD@Z
+?out@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_U1AEAPEB_UPEAD3AEAPEAD@Z
+?out@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_W1AEAPEB_WPEAD3AEAPEAD@Z
+?overflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHH@Z
+?overflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGG@Z
+?overflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGG@Z
+?pbackfail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHH@Z
+?pbackfail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGG@Z
+?pbackfail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGG@Z
+?pbase@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?pbase@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?pbase@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?pbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXH@Z
+?pbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXH@Z
+?pbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXH@Z
+?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?peek@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?peek@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?pptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?pptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?pptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?precision@ios_base@std@@QEAA_J_J@Z
+?precision@ios_base@std@@QEBA_JXZ
+?pubimbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubimbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubimbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubsetbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAPEAV12@PEAD_J@Z
+?pubsetbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAPEAV12@PEAG_J@Z
+?pubsetbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAPEAV12@PEA_W_J@Z
+?pubsync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?pubsync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAHXZ
+?pubsync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAHXZ
+?put@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@D@Z
+?put@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@G@Z
+?put@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_W@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DJ@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DK@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DN@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DO@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBX@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_J@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_K@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_N@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GJ@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GK@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GN@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GO@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBX@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_J@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_K@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_N@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WJ@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WK@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WN@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WO@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBX@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_J@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_K@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_N@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@DD@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@PEBD3@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@DD@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@PEBG3@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@DD@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@PEB_W4@Z
+?putback@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@D@Z
+?putback@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@G@Z
+?putback@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_W@Z
+?pword@ios_base@std@@QEAAAEAPEAXH@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@XZ
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@XZ
+?rdstate@ios_base@std@@QEBAHXZ
+?read@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?read@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?read@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?readsome@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_JPEAD_J@Z
+?readsome@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_JPEAG_J@Z
+?readsome@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_JPEA_W_J@Z
+?register_callback@ios_base@std@@QEAAXP6AXW4event@12@AEAV12@H@ZH@Z
+?resetiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sbumpc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sbumpc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?scan_is@?$ctype@D@std@@QEBAPEBDFPEBD0@Z
+?scan_is@?$ctype@G@std@@QEBAPEBGFPEBG0@Z
+?scan_is@?$ctype@_W@std@@QEBAPEB_WFPEB_W0@Z
+?scan_not@?$ctype@D@std@@QEBAPEBDFPEBD0@Z
+?scan_not@?$ctype@G@std@@QEBAPEBGFPEBG0@Z
+?scan_not@?$ctype@_W@std@@QEBAPEB_WFPEB_W0@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JH@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JH@Z
+?seekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JH@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JH@Z
+?seekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?set_new_handler@std@@YAP6AXXZP6AXXZ@Z
+?set_rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?set_rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?set_rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?setbase@std@@YA?AU?$_Smanip@H@1@H@Z
+?setbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAPEAV12@PEAD_J@Z
+?setbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAPEAV12@PEAG_J@Z
+?setbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAPEAV12@PEA_W_J@Z
+?setf@ios_base@std@@QEAAHH@Z
+?setf@ios_base@std@@QEAAHHH@Z
+?setg@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD00@Z
+?setg@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG00@Z
+?setg@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W00@Z
+?setiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD00@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD0@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG00@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG0@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W00@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W0@Z
+?setprecision@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXI@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXI@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXI@Z
+?setstate@ios_base@std@@QEAAXH@Z
+?setstate@ios_base@std@@QEAAXH_N@Z
+?setstate@ios_base@std@@QEAAXI@Z
+?setw@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sgetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sgetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?sgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEAD_J@Z
+?sgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JPEAG_J@Z
+?sgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JPEA_W_J@Z
+?showmanyc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JXZ
+?showmanyc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JXZ
+?showmanyc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JXZ
+?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?snextc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?snextc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?sputbackc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
+?sputbackc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?sputbackc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAG_W@Z
+?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
+?sputc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?sputc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAG_W@Z
+?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEBD_J@Z
+?sputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JPEBG_J@Z
+?sputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JPEB_W_J@Z
+?stossc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?stossc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?stossc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?sungetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sungetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sungetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?swap@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@ios_base@std@@QEAAXAEAV12@@Z
+?sync@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sync@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAHXZ
+?sync@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAHXZ
+?sync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?sync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAHXZ
+?sync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAHXZ
+?sync_with_stdio@ios_base@std@@SA_N_N@Z
+?table@?$ctype@D@std@@QEBAPEBFXZ
+?table_size@?$ctype@D@std@@2_KB
+?tellg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAPEAV?$basic_ostream@DU?$char_traits@D@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAPEAV?$basic_ostream@GU?$char_traits@G@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAPEAV?$basic_ostream@GU?$char_traits@G@std@@@2@XZ
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAPEAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAPEAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@XZ
+?tolower@?$ctype@D@std@@QEBADD@Z
+?tolower@?$ctype@D@std@@QEBAPEBDPEADPEBD@Z
+?tolower@?$ctype@G@std@@QEBAGG@Z
+?tolower@?$ctype@G@std@@QEBAPEBGPEAGPEBG@Z
+?tolower@?$ctype@_W@std@@QEBAPEB_WPEA_WPEB_W@Z
+?tolower@?$ctype@_W@std@@QEBA_W_W@Z
+?toupper@?$ctype@D@std@@QEBADD@Z
+?toupper@?$ctype@D@std@@QEBAPEBDPEADPEBD@Z
+?toupper@?$ctype@G@std@@QEBAGG@Z
+?toupper@?$ctype@G@std@@QEBAPEBGPEAGPEBG@Z
+?toupper@?$ctype@_W@std@@QEBAPEB_WPEA_WPEB_W@Z
+?toupper@?$ctype@_W@std@@QEBA_W_W@Z
+?uflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?uflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGXZ
+?uflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGXZ
+?uncaught_exception@std@@YA_NXZ
+?uncaught_exceptions@std@@YAHXZ
+?underflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?underflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGXZ
+?underflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGXZ
+?unget@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ
+?unget@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@XZ
+?unget@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@XZ
+?unsetf@ios_base@std@@QEAAXH@Z
+?unshift@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?wcerr@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcerr@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcin@std@@3V?$basic_istream@GU?$char_traits@G@std@@@1@A
+?wcin@std@@3V?$basic_istream@_WU?$char_traits@_W@std@@@1@A
+?wclog@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wclog@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcout@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcout@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?widen@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADD@Z
+?widen@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAGD@Z
+?widen@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBA_WD@Z
+?widen@?$ctype@D@std@@QEBADD@Z
+?widen@?$ctype@D@std@@QEBAPEBDPEBD0PEAD@Z
+?widen@?$ctype@G@std@@QEBAGD@Z
+?widen@?$ctype@G@std@@QEBAPEBDPEBD0PEAG@Z
+?widen@?$ctype@_W@std@@QEBAPEBDPEBD0PEA_W@Z
+?widen@?$ctype@_W@std@@QEBA_WD@Z
+?width@ios_base@std@@QEAA_J_J@Z
+?width@ios_base@std@@QEBA_JXZ
+?write@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEBD_J@Z
+?write@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEBG_J@Z
+?write@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEB_W_J@Z
+?xalloc@ios_base@std@@SAHXZ
+?xsgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JPEAD_J@Z
+?xsgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JPEAG_J@Z
+?xsgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JPEA_W_J@Z
+?xsputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JPEBD_J@Z
+?xsputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JPEBG_J@Z
+?xsputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JPEB_W_J@Z
+_Chmod
+_Close_dir
+_Cnd_broadcast
+_Cnd_destroy
+_Cnd_destroy_in_situ
+_Cnd_do_broadcast_at_thread_exit
+_Cnd_init
+_Cnd_init_in_situ
+_Cnd_register_at_thread_exit
+_Cnd_signal
+_Cnd_timedwait
+_Cnd_unregister_at_thread_exit
+_Cnd_wait
+_Copy_file
+_Cosh
+_Current_get
+_Current_set
+_Denorm
+_Dtest
+_Equivalent
+_Exp
+_FCosh
+_FDenorm
+_FDtest
+_FExp
+_FInf
+_FNan
+_FSinh
+_FSnan
+_File_size
+_Getcoll
+_Getctype
+_Getcvt
+_Getdateorder
+_Getwctype
+_Getwctypes
+_Hard_links
+_Hugeval
+_Inf
+_LCosh
+_LDenorm
+_LDtest
+_LExp
+_LInf
+_LNan
+_LSinh
+_LSnan
+_Last_write_time
+_Link
+_Lock_shared_ptr_spin_lock
+_Lstat
+_Make_dir
+_Mbrtowc
+_Mtx_clear_owner
+_Mtx_current_owns
+_Mtx_destroy
+_Mtx_destroy_in_situ
+_Mtx_getconcrtcs
+_Mtx_init
+_Mtx_init_in_situ
+_Mtx_lock
+_Mtx_reset_owner
+_Mtx_timedlock
+_Mtx_trylock
+_Mtx_unlock
+_Mtxdst
+_Mtxinit
+_Mtxlock
+_Mtxunlock
+_Nan
+_Open_dir
+_Query_perf_counter
+_Query_perf_frequency
+_Read_dir
+_Remove_dir
+_Rename
+_Resize
+_Set_last_write_time
+_Sinh
+_Snan
+_Stat
+_Statvfs
+_Stod
+_Stodx
+_Stof
+_Stofx
+_Stold
+_Stoldx
+_Stoll
+_Stollx
+_Stolx
+_Stoul
+_Stoull
+_Stoullx
+_Stoulx
+_Strcoll
+_Strxfrm
+_Symlink
+_Symlink_get
+_Temp_get
+_Thrd_abort
+_Thrd_create
+_Thrd_current
+_Thrd_detach
+_Thrd_equal
+_Thrd_exit
+_Thrd_hardware_concurrency
+_Thrd_id
+_Thrd_join
+_Thrd_sleep
+_Thrd_start
+_Thrd_yield
+_To_byte
+_To_wide
+_Tolower
+_Toupper
+_Towlower
+_Towupper
+_Unlink
+_Unlock_shared_ptr_spin_lock
+_WStod
+_WStodx
+_WStof
+_WStofx
+_WStold
+_WStoldx
+_Wcrtomb
+_Wcscoll
+_Wcsxfrm
+_Xtime_diff_to_millis
+_Xtime_diff_to_millis2
+_Xtime_get_ticks
+__Wcrtomb_lk
+__crtCompareStringA
+__crtCompareStringW
+__crtIsPackagedApp
+__crtLCMapStringA
+__crtLCMapStringW
+__set_stl_sync_api_mode
+xtime_get
diff --git a/msvc-stl/stl/msbuild/stl_base/arm64.exports b/msvc-stl/stl/msbuild/stl_base/arm64.exports
new file mode 100644
index 0000000..779c4f7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/arm64.exports
@@ -0,0 +1,1493 @@
+??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAX_WAEBV_Locinfo@1@@Z
+??0?$_Yarn@D@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@D@std@@QEAA@PEBD@Z
+??0?$_Yarn@D@std@@QEAA@XZ
+??0?$_Yarn@G@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@G@std@@QEAA@PEBG@Z
+??0?$_Yarn@G@std@@QEAA@XZ
+??0?$_Yarn@_W@std@@QEAA@AEBV01@@Z
+??0?$_Yarn@_W@std@@QEAA@PEB_W@Z
+??0?$_Yarn@_W@std@@QEAA@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@IEAA@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@IEAA@XZ
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@IEAA@XZ
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N1@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N1@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N1@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA@W4_Uninitialized@1@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAA@$$QEAV01@@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA@W4_Uninitialized@1@_N@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAA@XZ
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAA@XZ
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@AEBV01@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAA@XZ
+??0?$codecvt@DDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@DDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@KW4_Codecvt_mode@1@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@KW4_Codecvt_mode@1@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QEAA@_K@Z
+??0?$ctype@D@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@D@std@@QEAA@PEBF_N_K@Z
+??0?$ctype@G@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@G@std@@QEAA@_K@Z
+??0?$ctype@_W@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$ctype@_W@std@@QEAA@_K@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAA@_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAA@PEBD_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@AEBV_Locinfo@1@_K@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAA@_K@Z
+??0Init@ios_base@std@@QEAA@XZ
+??0_Facet_base@std@@QEAA@AEBV01@@Z
+??0_Facet_base@std@@QEAA@XZ
+??0_Init_locks@std@@QEAA@XZ
+??0_Locimp@locale@std@@AEAA@AEBV012@@Z
+??0_Locimp@locale@std@@AEAA@_N@Z
+??0_Locinfo@std@@QEAA@HPEBD@Z
+??0_Locinfo@std@@QEAA@PEBD@Z
+??0_Lockit@std@@QEAA@H@Z
+??0_Lockit@std@@QEAA@XZ
+??0_Timevec@std@@QEAA@AEBV01@@Z
+??0_Timevec@std@@QEAA@PEAX@Z
+??0_UShinit@std@@QEAA@XZ
+??0_Winit@std@@QEAA@XZ
+??0codecvt_base@std@@QEAA@_K@Z
+??0ctype_base@std@@QEAA@_K@Z
+??0facet@locale@std@@IEAA@_K@Z
+??0id@locale@std@@QEAA@_K@Z
+??0ios_base@std@@IEAA@XZ
+??0task_continuation_context@Concurrency@@AEAA@XZ
+??0time_base@std@@QEAA@_K@Z
+??1?$_Yarn@D@std@@QEAA@XZ
+??1?$_Yarn@G@std@@QEAA@XZ
+??1?$_Yarn@_W@std@@QEAA@XZ
+??1?$basic_ios@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_ios@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_ios@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_iostream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_iostream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_iostream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_istream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_istream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_istream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_ostream@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_ostream@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_ostream@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAA@XZ
+??1?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAA@XZ
+??1?$codecvt@DDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@GDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_SDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_UDU_Mbstatet@@@std@@MEAA@XZ
+??1?$codecvt@_WDU_Mbstatet@@@std@@MEAA@XZ
+??1?$ctype@D@std@@MEAA@XZ
+??1?$ctype@G@std@@MEAA@XZ
+??1?$ctype@_W@std@@MEAA@XZ
+??1?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEAA@XZ
+??1?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEAA@XZ
+??1Init@ios_base@std@@QEAA@XZ
+??1_Facet_base@std@@UEAA@XZ
+??1_Init_locks@std@@QEAA@XZ
+??1_Locimp@locale@std@@MEAA@XZ
+??1_Locinfo@std@@QEAA@XZ
+??1_Lockit@std@@QEAA@XZ
+??1_Timevec@std@@QEAA@XZ
+??1_UShinit@std@@QEAA@XZ
+??1_Winit@std@@QEAA@XZ
+??1codecvt_base@std@@UEAA@XZ
+??1ctype_base@std@@UEAA@XZ
+??1facet@locale@std@@MEAA@XZ
+??1ios_base@std@@UEAA@XZ
+??1time_base@std@@UEAA@XZ
+??4?$_Iosb@H@std@@QEAAAEAV01@$$QEAV01@@Z
+??4?$_Iosb@H@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@D@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@D@std@@QEAAAEAV01@PEBD@Z
+??4?$_Yarn@G@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@G@std@@QEAAAEAV01@PEBG@Z
+??4?$_Yarn@_W@std@@QEAAAEAV01@AEBV01@@Z
+??4?$_Yarn@_W@std@@QEAAAEAV01@PEB_W@Z
+??4?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@$$QEAV01@@Z
+??4?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAAEAV01@AEBV01@@Z
+??4Init@ios_base@std@@QEAAAEAV012@AEBV012@@Z
+??4_Crt_new_delete@std@@QEAAAEAU01@$$QEAU01@@Z
+??4_Crt_new_delete@std@@QEAAAEAU01@AEBU01@@Z
+??4_Facet_base@std@@QEAAAEAV01@AEBV01@@Z
+??4_Init_locks@std@@QEAAAEAV01@AEBV01@@Z
+??4_Timevec@std@@QEAAAEAV01@AEBV01@@Z
+??4_UShinit@std@@QEAAAEAV01@AEBV01@@Z
+??4_Winit@std@@QEAAAEAV01@AEBV01@@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@DU?$char_traits@D@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@GU?$char_traits@G@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAF@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAG@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAH@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAI@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAJ@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAK@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAM@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAN@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAO@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEAPEAX@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_J@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_K@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@AEA_N@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AEAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@DU?$char_traits@D@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@_N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@GU?$char_traits@G@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV01@_N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@F@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@G@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@H@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@I@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@M@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@O@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AEAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@P6AAEAVios_base@1@AEAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@PEBX@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV01@_N@Z
+??7ios_base@std@@QEBA_NXZ
+??Bid@locale@std@@QEAA_KXZ
+??Bios_base@std@@QEBA_NXZ
+??_7?$basic_ios@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ios@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ios@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_iostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_iostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_iostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_istream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_istream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_istream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_ostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_streambuf@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_streambuf@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$codecvt@DDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@GDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_SDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_UDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_WDU_Mbstatet@@@std@@6B@
+??_7?$ctype@D@std@@6B@
+??_7?$ctype@G@std@@6B@
+??_7?$ctype@_W@std@@6B@
+??_7?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7_Facet_base@std@@6B@
+??_7_Locimp@locale@std@@6B@
+??_7codecvt_base@std@@6B@
+??_7ctype_base@std@@6B@
+??_7facet@locale@std@@6B@
+??_7ios_base@std@@6B@
+??_7time_base@std@@6B@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_istream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_ostream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_istream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_ostream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_istream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_ostream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_istream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_istream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_istream@_WU?$char_traits@_W@std@@@std@@7B@
+??_8?$basic_ostream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_ostream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_ostream@_WU?$char_traits@_W@std@@@std@@7B@
+??_D?$basic_iostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_iostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_D?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+??_D?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+??_F?$codecvt@DDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@GDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_SDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_UDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$codecvt@_WDU_Mbstatet@@@std@@QEAAXXZ
+??_F?$ctype@D@std@@QEAAXXZ
+??_F?$ctype@G@std@@QEAAXXZ
+??_F?$ctype@_W@std@@QEAAXXZ
+??_F?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEAAXXZ
+??_F?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEAAXXZ
+??_F_Locinfo@std@@QEAAXXZ
+??_F_Timevec@std@@QEAAXXZ
+??_Fcodecvt_base@std@@QEAAXXZ
+??_Fctype_base@std@@QEAAXXZ
+??_Ffacet@locale@std@@QEAAXXZ
+??_Fid@locale@std@@QEAAXXZ
+??_Ftime_base@std@@QEAAXXZ
+?CaptureCallstack@platform@details@Concurrency@@YA_KPEAPEAX_K1@Z
+?GetCurrentThreadId@platform@details@Concurrency@@YAJXZ
+?GetNextAsyncId@platform@details@Concurrency@@YAIXZ
+?ReportUnhandledError@_ExceptionHolder@details@Concurrency@@AEAAXXZ
+?_Addcats@_Locinfo@std@@QEAAAEAV12@HPEBD@Z
+?_Addfac@_Locimp@locale@std@@AEAAXPEAVfacet@23@_K@Z
+?_Addstd@ios_base@std@@SAXPEAV12@@Z
+?_Assign@_ContextCallback@details@Concurrency@@AEAAXPEAX@Z
+?_Atexit@@YAXP6AXXZ@Z
+?_BADOFF@std@@3_JB
+?_C_str@?$_Yarn@D@std@@QEBAPEBDXZ
+?_C_str@?$_Yarn@G@std@@QEBAPEBGXZ
+?_C_str@?$_Yarn@_W@std@@QEBAPEB_WXZ
+?_CallInContext@_ContextCallback@details@Concurrency@@QEBAXV?$function@$$A6AXXZ@std@@_N@Z
+?_Callfns@ios_base@std@@AEAAXW4event@12@@Z
+?_Capture@_ContextCallback@details@Concurrency@@AEAAXXZ
+?_Clocptr@_Locimp@locale@std@@0PEAV123@EA
+?_Decref@facet@locale@std@@UEAAPEAV_Facet_base@3@XZ
+?_Donarrow@?$ctype@G@std@@IEBADGD@Z
+?_Donarrow@?$ctype@_W@std@@IEBAD_WD@Z
+?_Dowiden@?$ctype@G@std@@IEBAGD@Z
+?_Dowiden@?$ctype@_W@std@@IEBA_WD@Z
+?_Empty@?$_Yarn@D@std@@QEBA_NXZ
+?_Empty@?$_Yarn@G@std@@QEBA_NXZ
+?_Empty@?$_Yarn@_W@std@@QEBA_NXZ
+?_Execute_once@std@@YAHAEAUonce_flag@1@P6AHPEAX1PEAPEAX@Z1@Z
+?_Ffmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Ffmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Ffmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAPEADPEADDH@Z
+?_Findarr@ios_base@std@@AEAAAEAU_Iosarray@12@H@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEBDHH@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEBGHH@Z
+?_Fiopen@std@@YAPEAU_iobuf@@PEB_WHH@Z
+?_Fput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBD_K@Z
+?_Fput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBD_K@Z
+?_Fput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBD_K@Z
+?_Getcat@?$codecvt@DDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@GDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_SDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_UDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$codecvt@_WDU_Mbstatet@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@D@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@G@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$ctype@_W@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SA_KPEAPEBVfacet@locale@2@PEBV42@@Z
+?_Getcat@facet@locale@std@@SA_KPEAPEBV123@PEBV23@@Z
+?_Getcoll@_Locinfo@std@@QEBA?AU_Collvec@@XZ
+?_Getctype@_Locinfo@std@@QEBA?AU_Ctypevec@@XZ
+?_Getcvt@_Locinfo@std@@QEBA?AU_Cvtvec@@XZ
+?_Getdateorder@_Locinfo@std@@QEBAHXZ
+?_Getdays@_Locinfo@std@@QEBAPEBDXZ
+?_Getfalse@_Locinfo@std@@QEBAPEBDXZ
+?_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AEAVios_base@2@PEAH@Z
+?_Getfmt@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getfmt@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getfmt@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD@Z
+?_Getgloballocale@locale@std@@CAPEAV_Locimp@12@XZ
+?_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1HAEBVlocale@2@@Z
+?_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1HAEBVlocale@2@@Z
+?_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1HAEBVlocale@2@@Z
+?_Getint@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@0HHAEAHAEBV?$ctype@D@2@@Z
+?_Getint@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@0HHAEAHAEBV?$ctype@G@2@@Z
+?_Getint@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@0HHAEAHAEBV?$ctype@_W@2@@Z
+?_Getlconv@_Locinfo@std@@QEBAPEBUlconv@@XZ
+?_Getmonths@_Locinfo@std@@QEBAPEBDXZ
+?_Getname@_Locinfo@std@@QEBAPEBDXZ
+?_Getptr@_Timevec@std@@QEBAPEAXXZ
+?_Gettnames@_Locinfo@std@@QEBA?AV_Timevec@2@XZ
+?_Gettrue@_Locinfo@std@@QEBAPEBDXZ
+?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBA_JXZ
+?_Gnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBA_JXZ
+?_Gnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBA_JXZ
+?_Gndec@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gndec@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gndec@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Gninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Gnpreinc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Gnpreinc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Id_cnt@id@locale@std@@0HA
+?_Ifmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Ifmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Ifmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAPEADPEADPEBDH@Z
+?_Incref@facet@locale@std@@UEAAXXZ
+?_Index@ios_base@std@@0HA
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAPEAD0PEAH001@Z
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXXZ
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAPEAG0PEAH001@Z
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXXZ
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEAPEA_W0PEAH001@Z
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXXZ
+?_Init@?$codecvt@DDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@GDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_SDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_UDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$codecvt@_WDU_Mbstatet@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@D@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@G@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$ctype@_W@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IEAAXAEBV_Locinfo@2@@Z
+?_Init@ios_base@std@@IEAAXXZ
+?_Init@locale@std@@CAPEAV_Locimp@12@_N@Z
+?_Init_cnt@Init@ios_base@std@@0HA
+?_Init_cnt@_UShinit@std@@0HA
+?_Init_cnt@_Winit@std@@0HA
+?_Init_cnt_func@Init@ios_base@std@@CAAEAHXZ
+?_Init_ctor@Init@ios_base@std@@CAXPEAV123@@Z
+?_Init_dtor@Init@ios_base@std@@CAXPEAV123@@Z
+?_Init_locks_ctor@_Init_locks@std@@CAXPEAV12@@Z
+?_Init_locks_dtor@_Init_locks@std@@CAXPEAV12@@Z
+?_Ios_base_dtor@ios_base@std@@CAXPEAV12@@Z
+?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_N_N@Z
+?_Ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_N_N@Z
+?_Ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_N_N@Z
+?_Iput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEAD_K@Z
+?_Iput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEAD_K@Z
+?_Iput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEAD_K@Z
+?_IsCurrentOriginSTA@_ContextCallback@details@Concurrency@@CA_NXZ
+?_IsNonBlockingThread@_Task_impl_base@details@Concurrency@@SA_NXZ
+?_Locimp_Addfac@_Locimp@locale@std@@CAXPEAV123@PEAVfacet@23@_K@Z
+?_Locimp_ctor@_Locimp@locale@std@@CAXPEAV123@AEBV123@@Z
+?_Locimp_dtor@_Locimp@locale@std@@CAXPEAV123@@Z
+?_Locinfo_Addcats@_Locinfo@std@@SAAEAV12@PEAV12@HPEBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPEAV12@HPEBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPEAV12@PEBD@Z
+?_Locinfo_dtor@_Locinfo@std@@SAXPEAV12@@Z
+?_Lock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAAXXZ
+?_Lock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAAXXZ
+?_Lock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAAXXZ
+?_Lockit_ctor@_Lockit@std@@CAXPEAV12@@Z
+?_Lockit_ctor@_Lockit@std@@CAXPEAV12@H@Z
+?_Lockit_ctor@_Lockit@std@@SAXH@Z
+?_Lockit_dtor@_Lockit@std@@CAXPEAV12@@Z
+?_Lockit_dtor@_Lockit@std@@SAXH@Z
+?_LogCancelTask@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogScheduleTask@_TaskEventLogger@details@Concurrency@@QEAAX_N@Z
+?_LogTaskCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogTaskExecutionCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogWorkItemCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_LogWorkItemStarted@_TaskEventLogger@details@Concurrency@@QEAAXXZ
+?_MP_Add@std@@YAXQEA_K_K@Z
+?_MP_Get@std@@YA_KQEA_K@Z
+?_MP_Mul@std@@YAXQEA_K_K1@Z
+?_MP_Rem@std@@YAXQEA_K_K@Z
+?_Makeloc@_Locimp@locale@std@@CAPEAV123@AEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makeushloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makewloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Makexloc@_Locimp@locale@std@@CAXAEBV_Locinfo@3@HPEAV123@PEBV23@@Z
+?_Mtx_delete@threads@stdext@@YAXPEAX@Z
+?_Mtx_lock@threads@stdext@@YAXPEAX@Z
+?_Mtx_new@threads@stdext@@YAXAEAPEAX@Z
+?_Mtx_unlock@threads@stdext@@YAXPEAX@Z
+?_New_Locimp@_Locimp@locale@std@@CAPEAV123@AEBV123@@Z
+?_New_Locimp@_Locimp@locale@std@@CAPEAV123@_N@Z
+?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?_Osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?_Osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?_Pnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBA_JXZ
+?_Pnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBA_JXZ
+?_Pnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBA_JXZ
+?_Pninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAPEADXZ
+?_Pninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAPEAGXZ
+?_Pninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAPEA_WXZ
+?_Ptr_cerr@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_cin@std@@3PEAV?$basic_istream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_clog@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_cout@std@@3PEAV?$basic_ostream@DU?$char_traits@D@std@@@1@EA
+?_Ptr_wcerr@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcerr@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wcin@std@@3PEAV?$basic_istream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcin@std@@3PEAV?$basic_istream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wclog@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wclog@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Ptr_wcout@std@@3PEAV?$basic_ostream@GU?$char_traits@G@std@@@1@EA
+?_Ptr_wcout@std@@3PEAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@EA
+?_Put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@PEBD_K@Z
+?_Put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@PEBG_K@Z
+?_Put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@PEB_W_K@Z
+?_Raise_handler@std@@3P6AXAEBVexception@stdext@@@ZEA
+?_Random_device@std@@YAIXZ
+?_Release_chore@details@Concurrency@@YAXPEAU_Threadpool_chore@12@@Z
+?_Rep@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@D_K@Z
+?_Rep@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@G_K@Z
+?_Rep@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@_W_K@Z
+?_ReportUnobservedException@details@Concurrency@@YAXXZ
+?_Reschedule_chore@details@Concurrency@@YAHPEBU_Threadpool_chore@12@@Z
+?_Reset@_ContextCallback@details@Concurrency@@AEAAXXZ
+?_Rethrow_future_exception@std@@YAXVexception_ptr@1@@Z
+?_Rng_abort@std@@YAXPEBD@Z
+?_Schedule_chore@details@Concurrency@@YAHPEAU_Threadpool_chore@12@@Z
+?_Setgloballocale@locale@std@@CAXPEAX@Z
+?_Src@?1??_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AEAVios_base@3@PEAH@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEBAHPEADAEAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1HAEBVlocale@3@@Z@4QBDB
+?_Sync@ios_base@std@@0_NA
+?_Syserror_map@std@@YAPEBDH@Z
+?_Throw_C_error@std@@YAXH@Z
+?_Throw_Cpp_error@std@@YAXH@Z
+?_Throw_future_error@std@@YAXAEBVerror_code@1@@Z
+?_Tidy@?$_Yarn@D@std@@AEAAXXZ
+?_Tidy@?$_Yarn@G@std@@AEAAXXZ
+?_Tidy@?$_Yarn@_W@std@@AEAAXXZ
+?_Tidy@?$ctype@D@std@@IEAAXXZ
+?_Tidy@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AEAAXXZ
+?_Tidy@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AEAAXXZ
+?_Tidy@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AEAAXXZ
+?_Tidy@ios_base@std@@AEAAXXZ
+?_Unlock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UEAAXXZ
+?_Unlock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UEAAXXZ
+?_Unlock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UEAAXXZ
+?_W_Getdays@_Locinfo@std@@QEBAPEBGXZ
+?_W_Getmonths@_Locinfo@std@@QEBAPEBGXZ
+?_W_Gettnames@_Locinfo@std@@QEBA?AV_Timevec@2@XZ
+?_Winerror_map@std@@YAHH@Z
+?_Winerror_message@std@@YAKKPEADK@Z
+?_XGetLastError@std@@YAXXZ
+?_XLgamma@std@@YAMM@Z
+?_XLgamma@std@@YANN@Z
+?_XLgamma@std@@YAOO@Z
+?_Xbad_alloc@std@@YAXXZ
+?_Xbad_function_call@std@@YAXXZ
+?_Xinvalid_argument@std@@YAXPEBD@Z
+?_Xlength_error@std@@YAXPEBD@Z
+?_Xout_of_range@std@@YAXPEBD@Z
+?_Xoverflow_error@std@@YAXPEBD@Z
+?_Xregex_error@std@@YAXW4error_type@regex_constants@1@@Z
+?_Xruntime_error@std@@YAXPEBD@Z
+?__ExceptionPtrAssign@@YAXPEAXPEBX@Z
+?__ExceptionPtrCompare@@YA_NPEBX0@Z
+?__ExceptionPtrCopy@@YAXPEAXPEBX@Z
+?__ExceptionPtrCopyException@@YAXPEAXPEBX1@Z
+?__ExceptionPtrCreate@@YAXPEAX@Z
+?__ExceptionPtrCurrentException@@YAXPEAX@Z
+?__ExceptionPtrDestroy@@YAXPEAX@Z
+?__ExceptionPtrRethrow@@YAXPEBX@Z
+?__ExceptionPtrSwap@@YAXPEAX0@Z
+?__ExceptionPtrToBool@@YA_NPEBX@Z
+?always_noconv@codecvt_base@std@@QEBA_NXZ
+?bad@ios_base@std@@QEBA_NXZ
+?c_str@?$_Yarn@D@std@@QEBAPEBDXZ
+?c_str@?$_Yarn@G@std@@QEBAPEBGXZ
+?c_str@?$_Yarn@_W@std@@QEBAPEB_WXZ
+?cerr@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?cin@std@@3V?$basic_istream@DU?$char_traits@D@std@@@1@A
+?classic@locale@std@@SAAEBV12@XZ
+?classic_table@?$ctype@D@std@@SAPEBFXZ
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXI@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXI@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXH_N@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXI@Z
+?clear@ios_base@std@@QEAAXH@Z
+?clear@ios_base@std@@QEAAXH_N@Z
+?clear@ios_base@std@@QEAAXI@Z
+?clog@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?copyfmt@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEBV12@@Z
+?copyfmt@ios_base@std@@QEAAAEAV12@AEBV12@@Z
+?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AW4dateorder@time_base@2@XZ
+?do_always_noconv@?$codecvt@DDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@GDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_SDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_UDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@?$codecvt@_WDU_Mbstatet@@@std@@MEBA_NXZ
+?do_always_noconv@codecvt_base@std@@MEBA_NXZ
+?do_date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AW4dateorder@time_base@2@XZ
+?do_encoding@?$codecvt@GDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHXZ
+?do_encoding@codecvt_base@std@@MEBAHXZ
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?do_get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?do_get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?do_in@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?do_in@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAG3AEAPEAG@Z
+?do_in@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_S3AEAPEA_S@Z
+?do_in@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_U3AEAPEA_U@Z
+?do_in@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_W3AEAPEA_W@Z
+?do_is@?$ctype@G@std@@MEBAPEBGPEBG0PEAF@Z
+?do_is@?$ctype@G@std@@MEBA_NFG@Z
+?do_is@?$ctype@_W@std@@MEBAPEB_WPEB_W0PEAF@Z
+?do_is@?$ctype@_W@std@@MEBA_NF_W@Z
+?do_length@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_length@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?do_max_length@?$codecvt@GDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHXZ
+?do_max_length@codecvt_base@std@@MEBAHXZ
+?do_narrow@?$ctype@D@std@@MEBADDD@Z
+?do_narrow@?$ctype@D@std@@MEBAPEBDPEBD0DPEAD@Z
+?do_narrow@?$ctype@G@std@@MEBADGD@Z
+?do_narrow@?$ctype@G@std@@MEBAPEBGPEBG0DPEAD@Z
+?do_narrow@?$ctype@_W@std@@MEBAD_WD@Z
+?do_narrow@?$ctype@_W@std@@MEBAPEB_WPEB_W0DPEAD@Z
+?do_out@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?do_out@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEBG1AEAPEBGPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_S1AEAPEB_SPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_U1AEAPEB_UPEAD3AEAPEAD@Z
+?do_out@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEB_W1AEAPEB_WPEAD3AEAPEAD@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DJ@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DK@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DN@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DO@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBX@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_J@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_K@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_N@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GJ@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GK@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GN@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GO@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBX@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_J@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_K@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_N@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WJ@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WK@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WN@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WO@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBX@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_J@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_K@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_N@Z
+?do_put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@DD@Z
+?do_put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@DD@Z
+?do_put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@DD@Z
+?do_scan_is@?$ctype@G@std@@MEBAPEBGFPEBG0@Z
+?do_scan_is@?$ctype@_W@std@@MEBAPEB_WFPEB_W0@Z
+?do_scan_not@?$ctype@G@std@@MEBAPEBGFPEBG0@Z
+?do_scan_not@?$ctype@_W@std@@MEBAPEB_WFPEB_W0@Z
+?do_tolower@?$ctype@D@std@@MEBADD@Z
+?do_tolower@?$ctype@D@std@@MEBAPEBDPEADPEBD@Z
+?do_tolower@?$ctype@G@std@@MEBAGG@Z
+?do_tolower@?$ctype@G@std@@MEBAPEBGPEAGPEBG@Z
+?do_tolower@?$ctype@_W@std@@MEBAPEB_WPEA_WPEB_W@Z
+?do_tolower@?$ctype@_W@std@@MEBA_W_W@Z
+?do_toupper@?$ctype@D@std@@MEBADD@Z
+?do_toupper@?$ctype@D@std@@MEBAPEBDPEADPEBD@Z
+?do_toupper@?$ctype@G@std@@MEBAGG@Z
+?do_toupper@?$ctype@G@std@@MEBAPEBGPEAGPEBG@Z
+?do_toupper@?$ctype@_W@std@@MEBAPEB_WPEA_WPEB_W@Z
+?do_toupper@?$ctype@_W@std@@MEBA_W_W@Z
+?do_unshift@?$codecvt@DDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@GDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_SDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_UDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_unshift@?$codecvt@_WDU_Mbstatet@@@std@@MEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?do_widen@?$ctype@D@std@@MEBADD@Z
+?do_widen@?$ctype@D@std@@MEBAPEBDPEBD0PEAD@Z
+?do_widen@?$ctype@G@std@@MEBAGD@Z
+?do_widen@?$ctype@G@std@@MEBAPEBDPEBD0PEAG@Z
+?do_widen@?$ctype@_W@std@@MEBAPEBDPEBD0PEA_W@Z
+?do_widen@?$ctype@_W@std@@MEBA_WD@Z
+?eback@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?eback@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?eback@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?egptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?egptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?egptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?empty@?$_Yarn@D@std@@QEBA_NXZ
+?empty@?$_Yarn@G@std@@QEBA_NXZ
+?empty@?$_Yarn@_W@std@@QEBA_NXZ
+?empty@locale@std@@SA?AV12@XZ
+?encoding@codecvt_base@std@@QEBAHXZ
+?eof@ios_base@std@@QEBA_NXZ
+?epptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?epptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?epptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?exceptions@ios_base@std@@QEAAXH@Z
+?exceptions@ios_base@std@@QEAAXI@Z
+?exceptions@ios_base@std@@QEBAHXZ
+?fail@ios_base@std@@QEBA_NXZ
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAADD@Z
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADXZ
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAGXZ
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA_W_W@Z
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBA_WXZ
+?flags@ios_base@std@@QEAAHH@Z
+?flags@ios_base@std@@QEBAHXZ
+?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ
+?flush@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@XZ
+?flush@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@XZ
+?gbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXH@Z
+?gbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXH@Z
+?gbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXH@Z
+?gcount@?$basic_istream@DU?$char_traits@D@std@@@std@@QEBA_JXZ
+?gcount@?$basic_istream@GU?$char_traits@G@std@@@std@@QEBA_JXZ
+?gcount@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEBA_JXZ
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@D@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_JD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@G@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_JG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@AEA_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAG@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAI@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAJ@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAK@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAM@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAN@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAO@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEAPEAX@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_J@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_K@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHAEA_N@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBD4@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEBG4@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@DD@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@PEB_W4@Z
+?get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_new_handler@std@@YAP6AXXZXZ
+?get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AEAVios_base@2@AEAHPEAUtm@@@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_JD@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_JG@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J_W@Z
+?getloc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEBA?AVlocale@2@XZ
+?getloc@ios_base@std@@QEBA?AVlocale@2@XZ
+?global@locale@std@@SA?AV12@AEBV12@@Z
+?good@ios_base@std@@QEBA_NXZ
+?gptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?gptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?gptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?id@?$codecvt@DDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@GDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_WDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$collate@D@std@@2V0locale@2@A
+?id@?$collate@G@std@@2V0locale@2@A
+?id@?$collate@_W@std@@2V0locale@2@A
+?id@?$ctype@D@std@@2V0locale@2@A
+?id@?$ctype@G@std@@2V0locale@2@A
+?id@?$ctype@_W@std@@2V0locale@2@A
+?id@?$messages@D@std@@2V0locale@2@A
+?id@?$messages@G@std@@2V0locale@2@A
+?id@?$messages@_W@std@@2V0locale@2@A
+?id@?$money_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$moneypunct@D$00@std@@2V0locale@2@A
+?id@?$moneypunct@D$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@G$00@std@@2V0locale@2@A
+?id@?$moneypunct@G$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@_W$00@std@@2V0locale@2@A
+?id@?$moneypunct@_W$0A@@std@@2V0locale@2@A
+?id@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$numpunct@D@std@@2V0locale@2@A
+?id@?$numpunct@G@std@@2V0locale@2@A
+?id@?$numpunct@_W@std@@2V0locale@2@A
+?id@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?ignore@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?ignore@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JG@Z
+?ignore@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JG@Z
+?imbue@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?imbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAXAEBVlocale@2@@Z
+?imbue@ios_base@std@@QEAA?AVlocale@2@AEBV32@@Z
+?in@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?in@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAG3AEAPEAG@Z
+?in@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_S3AEAPEA_S@Z
+?in@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_U3AEAPEA_U@Z
+?in@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEA_W3AEAPEA_W@Z
+?in_avail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JXZ
+?in_avail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JXZ
+?in_avail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JXZ
+?init@?$basic_ios@DU?$char_traits@D@std@@@std@@IEAAXPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@_N@Z
+?init@?$basic_ios@GU?$char_traits@G@std@@@std@@IEAAXPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@_N@Z
+?init@?$basic_ios@_WU?$char_traits@_W@std@@@std@@IEAAXPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_N@Z
+?intl@?$moneypunct@D$00@std@@2_NB
+?intl@?$moneypunct@D$0A@@std@@2_NB
+?intl@?$moneypunct@G$00@std@@2_NB
+?intl@?$moneypunct@G$0A@@std@@2_NB
+?intl@?$moneypunct@_W$00@std@@2_NB
+?intl@?$moneypunct@_W$0A@@std@@2_NB
+?ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_N_N@Z
+?ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_N_N@Z
+?ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_N_N@Z
+?is@?$ctype@D@std@@QEBAPEBDPEBD0PEAF@Z
+?is@?$ctype@D@std@@QEBA_NFD@Z
+?is@?$ctype@G@std@@QEBAPEBGPEBG0PEAF@Z
+?is@?$ctype@G@std@@QEBA_NFG@Z
+?is@?$ctype@_W@std@@QEBAPEB_WPEB_W0PEAF@Z
+?is@?$ctype@_W@std@@QEBA_NF_W@Z
+?isfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?isfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?isfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?iword@ios_base@std@@QEAAAEAJH@Z
+?length@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?length@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1_K@Z
+?max_length@codecvt_base@std@@QEBAHXZ
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXAEAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXAEAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAX$$QEAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXAEAV12@@Z
+?narrow@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADDD@Z
+?narrow@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBADGD@Z
+?narrow@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAD_WD@Z
+?narrow@?$ctype@D@std@@QEBADDD@Z
+?narrow@?$ctype@D@std@@QEBAPEBDPEBD0DPEAD@Z
+?narrow@?$ctype@G@std@@QEBADGD@Z
+?narrow@?$ctype@G@std@@QEBAPEBGPEBG0DPEAD@Z
+?narrow@?$ctype@_W@std@@QEBAD_WD@Z
+?narrow@?$ctype@_W@std@@QEBAPEB_WPEB_W0DPEAD@Z
+?opfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA_NXZ
+?opfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA_NXZ
+?opfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA_NXZ
+?osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?out@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBD1AEAPEBDPEAD3AEAPEAD@Z
+?out@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEBG1AEAPEBGPEAD3AEAPEAD@Z
+?out@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_S1AEAPEB_SPEAD3AEAPEAD@Z
+?out@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_U1AEAPEB_UPEAD3AEAPEAD@Z
+?out@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEB_W1AEAPEB_WPEAD3AEAPEAD@Z
+?overflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHH@Z
+?overflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGG@Z
+?overflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGG@Z
+?pbackfail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHH@Z
+?pbackfail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGG@Z
+?pbackfail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGG@Z
+?pbase@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?pbase@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?pbase@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?pbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXH@Z
+?pbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXH@Z
+?pbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXH@Z
+?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?peek@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?peek@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?pptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEBAPEADXZ
+?pptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEBAPEAGXZ
+?pptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEBAPEA_WXZ
+?precision@ios_base@std@@QEAA_J_J@Z
+?precision@ios_base@std@@QEBA_JXZ
+?pubimbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubimbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubimbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AVlocale@2@AEBV32@@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubsetbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAPEAV12@PEAD_J@Z
+?pubsetbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAPEAV12@PEAG_J@Z
+?pubsetbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAPEAV12@PEA_W_J@Z
+?pubsync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?pubsync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAHXZ
+?pubsync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAHXZ
+?put@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@D@Z
+?put@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@G@Z
+?put@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_W@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DJ@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DK@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DN@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DO@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBX@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_J@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_K@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@D_N@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GJ@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GK@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GN@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GO@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBX@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_J@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_K@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@G_N@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WJ@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WK@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WN@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WO@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBX@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_J@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_K@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_W_N@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@DD@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AEAVios_base@2@DPEBUtm@@PEBD3@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@DD@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AEAVios_base@2@GPEBUtm@@PEBG3@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@DD@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QEBA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AEAVios_base@2@_WPEBUtm@@PEB_W4@Z
+?putback@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@D@Z
+?putback@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@G@Z
+?putback@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_W@Z
+?pword@ios_base@std@@QEAAAEAPEAXH@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@XZ
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@PEAV32@@Z
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@XZ
+?rdstate@ios_base@std@@QEBAHXZ
+?read@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEAD_J@Z
+?read@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEAG_J@Z
+?read@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEA_W_J@Z
+?readsome@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA_JPEAD_J@Z
+?readsome@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA_JPEAG_J@Z
+?readsome@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA_JPEA_W_J@Z
+?register_callback@ios_base@std@@QEAAXP6AXW4event@12@AEAV12@H@ZH@Z
+?resetiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sbumpc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sbumpc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?scan_is@?$ctype@D@std@@QEBAPEBDFPEBD0@Z
+?scan_is@?$ctype@G@std@@QEBAPEBGFPEBG0@Z
+?scan_is@?$ctype@_W@std@@QEBAPEB_WFPEB_W0@Z
+?scan_not@?$ctype@D@std@@QEBAPEBDFPEBD0@Z
+?scan_not@?$ctype@G@std@@QEBAPEBGFPEBG0@Z
+?scan_not@?$ctype@_W@std@@QEBAPEB_WFPEB_W0@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JH@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JH@Z
+?seekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@_JH@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@_JH@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@_JH@Z
+?seekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?set_new_handler@std@@YAP6AXXZP6AXXZ@Z
+?set_rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXPEAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?set_rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXPEAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?set_rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXPEAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?setbase@std@@YA?AU?$_Smanip@H@1@H@Z
+?setbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAPEAV12@PEAD_J@Z
+?setbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAPEAV12@PEAG_J@Z
+?setbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAPEAV12@PEA_W_J@Z
+?setf@ios_base@std@@QEAAHH@Z
+?setf@ios_base@std@@QEAAHHH@Z
+?setg@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD00@Z
+?setg@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG00@Z
+?setg@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W00@Z
+?setiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD00@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXPEAD0@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG00@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXPEAG0@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W00@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXPEA_W0@Z
+?setprecision@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXI@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXI@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXH_N@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXI@Z
+?setstate@ios_base@std@@QEAAXH@Z
+?setstate@ios_base@std@@QEAAXH_N@Z
+?setstate@ios_base@std@@QEAAXI@Z
+?setw@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sgetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sgetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?sgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEAD_J@Z
+?sgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JPEAG_J@Z
+?sgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JPEA_W_J@Z
+?showmanyc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JXZ
+?showmanyc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JXZ
+?showmanyc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JXZ
+?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?snextc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?snextc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?sputbackc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
+?sputbackc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?sputbackc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAG_W@Z
+?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
+?sputc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGG@Z
+?sputc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAG_W@Z
+?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEBD_J@Z
+?sputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAA_JPEBG_J@Z
+?sputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAA_JPEB_W_J@Z
+?stossc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAXXZ
+?stossc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAXXZ
+?stossc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAXXZ
+?sungetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sungetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QEAAGXZ
+?sungetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QEAAGXZ
+?swap@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAXAEAV12@@Z
+?swap@?$basic_iostream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_iostream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_istream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IEAAXAEAV12@@Z
+?swap@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IEAAXAEAV12@@Z
+?swap@ios_base@std@@QEAAXAEAV12@@Z
+?sync@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAHXZ
+?sync@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAHXZ
+?sync@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAHXZ
+?sync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?sync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAHXZ
+?sync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAHXZ
+?sync_with_stdio@ios_base@std@@SA_N_N@Z
+?table@?$ctype@D@std@@QEBAPEBFXZ
+?table_size@?$ctype@D@std@@2_KB
+?tellg@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAA?AV?$fpos@U_Mbstatet@@@2@XZ
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAPEAV?$basic_ostream@DU?$char_traits@D@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBAPEAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QEAAPEAV?$basic_ostream@GU?$char_traits@G@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAPEAV?$basic_ostream@GU?$char_traits@G@std@@@2@XZ
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEAAPEAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@PEAV32@@Z
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBAPEAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@XZ
+?tolower@?$ctype@D@std@@QEBADD@Z
+?tolower@?$ctype@D@std@@QEBAPEBDPEADPEBD@Z
+?tolower@?$ctype@G@std@@QEBAGG@Z
+?tolower@?$ctype@G@std@@QEBAPEBGPEAGPEBG@Z
+?tolower@?$ctype@_W@std@@QEBAPEB_WPEA_WPEB_W@Z
+?tolower@?$ctype@_W@std@@QEBA_W_W@Z
+?toupper@?$ctype@D@std@@QEBADD@Z
+?toupper@?$ctype@D@std@@QEBAPEBDPEADPEBD@Z
+?toupper@?$ctype@G@std@@QEBAGG@Z
+?toupper@?$ctype@G@std@@QEBAPEBGPEAGPEBG@Z
+?toupper@?$ctype@_W@std@@QEBAPEB_WPEA_WPEB_W@Z
+?toupper@?$ctype@_W@std@@QEBA_W_W@Z
+?uflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?uflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGXZ
+?uflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGXZ
+?uncaught_exception@std@@YA_NXZ
+?uncaught_exceptions@std@@YAHXZ
+?underflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAAHXZ
+?underflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAAGXZ
+?underflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAAGXZ
+?unget@?$basic_istream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ
+?unget@?$basic_istream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@XZ
+?unget@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@XZ
+?unsetf@ios_base@std@@QEAAXH@Z
+?unshift@?$codecvt@DDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@GDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_SDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_UDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?unshift@?$codecvt@_WDU_Mbstatet@@@std@@QEBAHAEAU_Mbstatet@@PEAD1AEAPEAD@Z
+?wcerr@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcerr@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcin@std@@3V?$basic_istream@GU?$char_traits@G@std@@@1@A
+?wcin@std@@3V?$basic_istream@_WU?$char_traits@_W@std@@@1@A
+?wclog@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wclog@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcout@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcout@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?widen@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADD@Z
+?widen@?$basic_ios@GU?$char_traits@G@std@@@std@@QEBAGD@Z
+?widen@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QEBA_WD@Z
+?widen@?$ctype@D@std@@QEBADD@Z
+?widen@?$ctype@D@std@@QEBAPEBDPEBD0PEAD@Z
+?widen@?$ctype@G@std@@QEBAGD@Z
+?widen@?$ctype@G@std@@QEBAPEBDPEBD0PEAG@Z
+?widen@?$ctype@_W@std@@QEBAPEBDPEBD0PEA_W@Z
+?widen@?$ctype@_W@std@@QEBA_WD@Z
+?width@ios_base@std@@QEAA_J_J@Z
+?width@ios_base@std@@QEBA_JXZ
+?write@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@PEBD_J@Z
+?write@?$basic_ostream@GU?$char_traits@G@std@@@std@@QEAAAEAV12@PEBG_J@Z
+?write@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QEAAAEAV12@PEB_W_J@Z
+?xalloc@ios_base@std@@SAHXZ
+?xsgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JPEAD_J@Z
+?xsgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JPEAG_J@Z
+?xsgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JPEA_W_J@Z
+?xsputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MEAA_JPEBD_J@Z
+?xsputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MEAA_JPEBG_J@Z
+?xsputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MEAA_JPEB_W_J@Z
+_Chmod
+_Close_dir
+_Cnd_broadcast
+_Cnd_destroy
+_Cnd_destroy_in_situ
+_Cnd_do_broadcast_at_thread_exit
+_Cnd_init
+_Cnd_init_in_situ
+_Cnd_register_at_thread_exit
+_Cnd_signal
+_Cnd_timedwait
+_Cnd_unregister_at_thread_exit
+_Cnd_wait
+_Copy_file
+_Cosh
+_Current_get
+_Current_set
+_Denorm
+_Dtest
+_Equivalent
+_Exp
+_FCosh
+_FDenorm
+_FDtest
+_FExp
+_FInf
+_FNan
+_FSinh
+_FSnan
+_File_size
+_Getcoll
+_Getctype
+_Getcvt
+_Getdateorder
+_Getwctype
+_Getwctypes
+_Hard_links
+_Hugeval
+_Inf
+_LCosh
+_LDenorm
+_LDtest
+_LExp
+_LInf
+_LNan
+_LSinh
+_LSnan
+_Last_write_time
+_Link
+_Lock_shared_ptr_spin_lock
+_Lstat
+_Make_dir
+_Mbrtowc
+_Mtx_clear_owner
+_Mtx_current_owns
+_Mtx_destroy
+_Mtx_destroy_in_situ
+_Mtx_getconcrtcs
+_Mtx_init
+_Mtx_init_in_situ
+_Mtx_lock
+_Mtx_reset_owner
+_Mtx_timedlock
+_Mtx_trylock
+_Mtx_unlock
+_Mtxdst
+_Mtxinit
+_Mtxlock
+_Mtxunlock
+_Nan
+_Open_dir
+_Query_perf_counter
+_Query_perf_frequency
+_Read_dir
+_Remove_dir
+_Rename
+_Resize
+_Set_last_write_time
+_Sinh
+_Snan
+_Stat
+_Statvfs
+_Stod
+_Stodx
+_Stof
+_Stofx
+_Stold
+_Stoldx
+_Stoll
+_Stollx
+_Stolx
+_Stoul
+_Stoull
+_Stoullx
+_Stoulx
+_Strcoll
+_Strxfrm
+_Symlink
+_Symlink_get
+_Temp_get
+_Thrd_abort
+_Thrd_create
+_Thrd_current
+_Thrd_detach
+_Thrd_equal
+_Thrd_exit
+_Thrd_hardware_concurrency
+_Thrd_id
+_Thrd_join
+_Thrd_sleep
+_Thrd_start
+_Thrd_yield
+_To_byte
+_To_wide
+_Tolower
+_Toupper
+_Towlower
+_Towupper
+_Unlink
+_Unlock_shared_ptr_spin_lock
+_WStod
+_WStodx
+_WStof
+_WStofx
+_WStold
+_WStoldx
+_Wcrtomb
+_Wcscoll
+_Wcsxfrm
+_Xtime_diff_to_millis
+_Xtime_diff_to_millis2
+_Xtime_get_ticks
+__Wcrtomb_lk
+__crtCompareStringA
+__crtCompareStringW
+__crtIsPackagedApp
+__crtLCMapStringA
+__crtLCMapStringW
+__set_stl_sync_api_mode
+xtime_get
diff --git a/msvc-stl/stl/msbuild/stl_base/dirs.proj b/msvc-stl/stl/msbuild/stl_base/dirs.proj
new file mode 100644
index 0000000..5bfe0aa
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/dirs.proj
@@ -0,0 +1,20 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Condition="'$(CrtBuildMD)'  != 'false'" Include="md\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildMT)'  != 'false'" Include="mt\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildMT)'  != 'false'" Include="mt1\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMT)' != 'false'" Include="xmt\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMT)' != 'false'" Include="xmt0\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMT)' != 'false'" Include="xmt1\dirs.proj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/i386.exports b/msvc-stl/stl/msbuild/stl_base/i386.exports
new file mode 100644
index 0000000..c3980bc
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/i386.exports
@@ -0,0 +1,1515 @@
+??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEX_WABV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEX_WABV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEX_WABV_Locinfo@1@@Z
+??0?$_Yarn@D@std@@QAE@ABV01@@Z
+??0?$_Yarn@D@std@@QAE@PBD@Z
+??0?$_Yarn@D@std@@QAE@XZ
+??0?$_Yarn@G@std@@QAE@ABV01@@Z
+??0?$_Yarn@G@std@@QAE@PBG@Z
+??0?$_Yarn@G@std@@QAE@XZ
+??0?$_Yarn@_W@std@@QAE@ABV01@@Z
+??0?$_Yarn@_W@std@@QAE@PB_W@Z
+??0?$_Yarn@_W@std@@QAE@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@IAE@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@IAE@XZ
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@IAE@XZ
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N1@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@W4_Uninitialized@1@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N1@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@W4_Uninitialized@1@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N1@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@W4_Uninitialized@1@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE@W4_Uninitialized@1@_N@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@ABV01@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@XZ
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@ABV01@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@XZ
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@ABV01@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@XZ
+??0?$codecvt@DDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@DDU_Mbstatet@@@std@@QAE@I@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QAE@I@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@KW4_Codecvt_mode@1@I@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QAE@I@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@KW4_Codecvt_mode@1@I@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QAE@I@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QAE@I@Z
+??0?$ctype@D@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$ctype@D@std@@QAE@PBF_NI@Z
+??0?$ctype@G@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$ctype@G@std@@QAE@I@Z
+??0?$ctype@_W@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$ctype@_W@std@@QAE@I@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z
+??0Init@ios_base@std@@QAE@XZ
+??0_Facet_base@std@@QAE@ABV01@@Z
+??0_Facet_base@std@@QAE@XZ
+??0_Init_locks@std@@QAE@XZ
+??0_Locimp@locale@std@@AAE@ABV012@@Z
+??0_Locimp@locale@std@@AAE@_N@Z
+??0_Locinfo@std@@QAE@HPBD@Z
+??0_Locinfo@std@@QAE@PBD@Z
+??0_Lockit@std@@QAE@H@Z
+??0_Lockit@std@@QAE@XZ
+??0_Timevec@std@@QAE@ABV01@@Z
+??0_Timevec@std@@QAE@PAX@Z
+??0_UShinit@std@@QAE@XZ
+??0_Winit@std@@QAE@XZ
+??0codecvt_base@std@@QAE@I@Z
+??0ctype_base@std@@QAE@I@Z
+??0facet@locale@std@@IAE@I@Z
+??0id@locale@std@@QAE@I@Z
+??0ios_base@std@@IAE@XZ
+??0task_continuation_context@Concurrency@@AAE@XZ
+??0time_base@std@@QAE@I@Z
+??1?$_Yarn@D@std@@QAE@XZ
+??1?$_Yarn@G@std@@QAE@XZ
+??1?$_Yarn@_W@std@@QAE@XZ
+??1?$basic_ios@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_ios@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_ios@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$basic_iostream@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_iostream@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_iostream@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$basic_istream@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_istream@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_istream@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$basic_ostream@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_ostream@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_ostream@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$codecvt@DDU_Mbstatet@@@std@@MAE@XZ
+??1?$codecvt@GDU_Mbstatet@@@std@@MAE@XZ
+??1?$codecvt@_SDU_Mbstatet@@@std@@MAE@XZ
+??1?$codecvt@_UDU_Mbstatet@@@std@@MAE@XZ
+??1?$codecvt@_WDU_Mbstatet@@@std@@MAE@XZ
+??1?$ctype@D@std@@MAE@XZ
+??1?$ctype@G@std@@MAE@XZ
+??1?$ctype@_W@std@@MAE@XZ
+??1?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ
+??1?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ
+??1?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ
+??1?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ
+??1?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ
+??1?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ
+??1?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ
+??1?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ
+??1?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ
+??1?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ
+??1?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ
+??1?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ
+??1Init@ios_base@std@@QAE@XZ
+??1_Facet_base@std@@UAE@XZ
+??1_Init_locks@std@@QAE@XZ
+??1_Locimp@locale@std@@MAE@XZ
+??1_Locinfo@std@@QAE@XZ
+??1_Lockit@std@@QAE@XZ
+??1_Timevec@std@@QAE@XZ
+??1_UShinit@std@@QAE@XZ
+??1_Winit@std@@QAE@XZ
+??1codecvt_base@std@@UAE@XZ
+??1ctype_base@std@@UAE@XZ
+??1facet@locale@std@@MAE@XZ
+??1ios_base@std@@UAE@XZ
+??1time_base@std@@UAE@XZ
+??4?$_Iosb@H@std@@QAEAAV01@$$QAV01@@Z
+??4?$_Iosb@H@std@@QAEAAV01@ABV01@@Z
+??4?$_Yarn@D@std@@QAEAAV01@ABV01@@Z
+??4?$_Yarn@D@std@@QAEAAV01@PBD@Z
+??4?$_Yarn@G@std@@QAEAAV01@ABV01@@Z
+??4?$_Yarn@G@std@@QAEAAV01@PBG@Z
+??4?$_Yarn@_W@std@@QAEAAV01@ABV01@@Z
+??4?$_Yarn@_W@std@@QAEAAV01@PB_W@Z
+??4?$basic_iostream@DU?$char_traits@D@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_iostream@GU?$char_traits@G@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_istream@DU?$char_traits@D@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_istream@GU?$char_traits@G@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_istream@_WU?$char_traits@_W@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_ostream@DU?$char_traits@D@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_ostream@GU?$char_traits@G@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEAAV01@ABV01@@Z
+??4?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEAAV01@ABV01@@Z
+??4?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEAAV01@ABV01@@Z
+??4Init@ios_base@std@@QAEAAV012@ABV012@@Z
+??4_Crt_new_delete@std@@QAEAAU01@$$QAU01@@Z
+??4_Crt_new_delete@std@@QAEAAU01@ABU01@@Z
+??4_Facet_base@std@@QAEAAV01@ABV01@@Z
+??4_Init_locks@std@@QAEAAV01@ABV01@@Z
+??4_Timevec@std@@QAEAAV01@ABV01@@Z
+??4_UShinit@std@@QAEAAV01@ABV01@@Z
+??4_Winit@std@@QAEAAV01@ABV01@@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAF@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAG@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAH@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAI@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAJ@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAK@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAM@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAN@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAO@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAPAX@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_J@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_K@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_N@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@DU?$char_traits@D@std@@@1@AAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAF@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAG@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAH@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAI@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAJ@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAK@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAM@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAN@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAO@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAPAX@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_J@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_K@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_N@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@GU?$char_traits@G@std@@@1@AAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAF@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAG@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAH@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAI@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAJ@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAK@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAM@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAN@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAO@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAPAX@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_J@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_K@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_N@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@F@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@G@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@H@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@I@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@M@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@N@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@O@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@DU?$char_traits@D@std@@@1@AAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@PBX@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@F@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@G@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@H@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@I@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@M@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@O@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@GU?$char_traits@G@std@@@1@AAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@PBX@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@F@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@G@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@H@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@I@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@M@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@O@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PBX@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_N@Z
+??7ios_base@std@@QBE_NXZ
+??Bid@locale@std@@QAEIXZ
+??Bios_base@std@@QBE_NXZ
+??_7?$basic_ios@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ios@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ios@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_iostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_iostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_iostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_istream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_istream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_istream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_ostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_streambuf@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_streambuf@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$codecvt@DDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@GDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_SDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_UDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_WDU_Mbstatet@@@std@@6B@
+??_7?$ctype@D@std@@6B@
+??_7?$ctype@G@std@@6B@
+??_7?$ctype@_W@std@@6B@
+??_7?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7_Facet_base@std@@6B@
+??_7_Locimp@locale@std@@6B@
+??_7codecvt_base@std@@6B@
+??_7ctype_base@std@@6B@
+??_7facet@locale@std@@6B@
+??_7ios_base@std@@6B@
+??_7time_base@std@@6B@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_istream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_ostream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_istream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_ostream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_istream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_ostream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_istream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_istream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_istream@_WU?$char_traits@_W@std@@@std@@7B@
+??_8?$basic_ostream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_ostream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_ostream@_WU?$char_traits@_W@std@@@std@@7B@
+??_D?$basic_iostream@DU?$char_traits@D@std@@@std@@QAEXXZ
+??_D?$basic_iostream@GU?$char_traits@G@std@@@std@@QAEXXZ
+??_D?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+??_D?$basic_istream@DU?$char_traits@D@std@@@std@@QAEXXZ
+??_D?$basic_istream@GU?$char_traits@G@std@@@std@@QAEXXZ
+??_D?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+??_D?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ
+??_D?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ
+??_D?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+??_F?$codecvt@DDU_Mbstatet@@@std@@QAEXXZ
+??_F?$codecvt@GDU_Mbstatet@@@std@@QAEXXZ
+??_F?$codecvt@_SDU_Mbstatet@@@std@@QAEXXZ
+??_F?$codecvt@_UDU_Mbstatet@@@std@@QAEXXZ
+??_F?$codecvt@_WDU_Mbstatet@@@std@@QAEXXZ
+??_F?$ctype@D@std@@QAEXXZ
+??_F?$ctype@G@std@@QAEXXZ
+??_F?$ctype@_W@std@@QAEXXZ
+??_F?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ
+??_F?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ
+??_F?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ
+??_F?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ
+??_F?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ
+??_F?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ
+??_F?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ
+??_F?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ
+??_F?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ
+??_F?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ
+??_F?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ
+??_F?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ
+??_F_Locinfo@std@@QAEXXZ
+??_F_Timevec@std@@QAEXXZ
+??_Fcodecvt_base@std@@QAEXXZ
+??_Fctype_base@std@@QAEXXZ
+??_Ffacet@locale@std@@QAEXXZ
+??_Fid@locale@std@@QAEXXZ
+??_Ftime_base@std@@QAEXXZ
+?CaptureCallstack@platform@details@Concurrency@@YAIPAPAXII@Z
+?GetCurrentThreadId@platform@details@Concurrency@@YAJXZ
+?GetNextAsyncId@platform@details@Concurrency@@YAIXZ
+?ReportUnhandledError@_ExceptionHolder@details@Concurrency@@AAEXXZ
+?_Addcats@_Locinfo@std@@QAEAAV12@HPBD@Z
+?_Addfac@_Locimp@locale@std@@AAEXPAVfacet@23@I@Z
+?_Addstd@ios_base@std@@SAXPAV12@@Z
+?_Assign@_ContextCallback@details@Concurrency@@AAEXPAX@Z
+?_Atexit@@YAXP6AXXZ@Z
+?_BADOFF@std@@3_JB
+?_C_str@?$_Yarn@D@std@@QBEPBDXZ
+?_C_str@?$_Yarn@G@std@@QBEPBGXZ
+?_C_str@?$_Yarn@_W@std@@QBEPB_WXZ
+?_CallInContext@_ContextCallback@details@Concurrency@@QBEXV?$function@$$A6AXXZ@std@@_N@Z
+?_Callfns@ios_base@std@@AAEXW4event@12@@Z
+?_Capture@_ContextCallback@details@Concurrency@@AAEXXZ
+?_Clocptr@_Locimp@locale@std@@0PAV123@A
+?_Decref@facet@locale@std@@UAEPAV_Facet_base@3@XZ
+?_Donarrow@?$ctype@G@std@@IBEDGD@Z
+?_Donarrow@?$ctype@_W@std@@IBED_WD@Z
+?_Dowiden@?$ctype@G@std@@IBEGD@Z
+?_Dowiden@?$ctype@_W@std@@IBE_WD@Z
+?_Empty@?$_Yarn@D@std@@QBE_NXZ
+?_Empty@?$_Yarn@G@std@@QBE_NXZ
+?_Empty@?$_Yarn@_W@std@@QBE_NXZ
+?_Execute_once@std@@YAHAAUonce_flag@1@P6GHPAX1PAPAX@Z1@Z
+?_Ffmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAPADPADDH@Z
+?_Ffmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAPADPADDH@Z
+?_Ffmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAPADPADDH@Z
+?_Findarr@ios_base@std@@AAEAAU_Iosarray@12@H@Z
+?_Fiopen@std@@YAPAU_iobuf@@PBDHH@Z
+?_Fiopen@std@@YAPAU_iobuf@@PBGHH@Z
+?_Fiopen@std@@YAPAU_iobuf@@PB_WHH@Z
+?_Fput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBDI@Z
+?_Fput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBDI@Z
+?_Fput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBDI@Z
+?_Getcat@?$codecvt@DDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$codecvt@GDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$codecvt@_SDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$codecvt@_UDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$codecvt@_WDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$ctype@D@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$ctype@G@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$ctype@_W@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@facet@locale@std@@SAIPAPBV123@PBV23@@Z
+?_Getcoll@_Locinfo@std@@QBE?AU_Collvec@@XZ
+?_Getctype@_Locinfo@std@@QBE?AU_Ctypevec@@XZ
+?_Getcvt@_Locinfo@std@@QBE?AU_Cvtvec@@XZ
+?_Getdateorder@_Locinfo@std@@QBEHXZ
+?_Getdays@_Locinfo@std@@QBEPBDXZ
+?_Getfalse@_Locinfo@std@@QBEPBDXZ
+?_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AAVios_base@2@PAH@Z
+?_Getfmt@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z
+?_Getfmt@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z
+?_Getfmt@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z
+?_Getgloballocale@locale@std@@CAPAV_Locimp@12@XZ
+?_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1HABVlocale@2@@Z
+?_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1HABVlocale@2@@Z
+?_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1HABVlocale@2@@Z
+?_Getint@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@0HHAAHABV?$ctype@D@2@@Z
+?_Getint@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@0HHAAHABV?$ctype@G@2@@Z
+?_Getint@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@0HHAAHABV?$ctype@_W@2@@Z
+?_Getlconv@_Locinfo@std@@QBEPBUlconv@@XZ
+?_Getmonths@_Locinfo@std@@QBEPBDXZ
+?_Getname@_Locinfo@std@@QBEPBDXZ
+?_Getptr@_Timevec@std@@QBEPAXXZ
+?_Gettnames@_Locinfo@std@@QBE?AV_Timevec@2@XZ
+?_Gettrue@_Locinfo@std@@QBEPBDXZ
+?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBE_JXZ
+?_Gnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBE_JXZ
+?_Gnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBE_JXZ
+?_Gndec@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
+?_Gndec@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ
+?_Gndec@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ
+?_Gninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
+?_Gninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ
+?_Gninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ
+?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
+?_Gnpreinc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ
+?_Gnpreinc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ
+?_Id_cnt@id@locale@std@@0HA
+?_Ifmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAPADPADPBDH@Z
+?_Ifmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAPADPADPBDH@Z
+?_Ifmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAPADPADPBDH@Z
+?_Incref@facet@locale@std@@UAEXXZ
+?_Index@ios_base@std@@0HA
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAPAD0PAH001@Z
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXXZ
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAPAG0PAH001@Z
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXXZ
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPAPA_W0PAH001@Z
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXXZ
+?_Init@?$codecvt@DDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$codecvt@GDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$codecvt@_SDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$codecvt@_UDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$codecvt@_WDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$ctype@D@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$ctype@G@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$ctype@_W@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@ios_base@std@@IAEXXZ
+?_Init@locale@std@@CAPAV_Locimp@12@_N@Z
+?_Init_cnt@Init@ios_base@std@@0HA
+?_Init_cnt@_UShinit@std@@0HA
+?_Init_cnt@_Winit@std@@0HA
+?_Init_cnt_func@Init@ios_base@std@@CAAAHXZ
+?_Init_ctor@Init@ios_base@std@@CAXPAV123@@Z
+?_Init_dtor@Init@ios_base@std@@CAXPAV123@@Z
+?_Init_locks_ctor@_Init_locks@std@@CAXPAV12@@Z
+?_Init_locks_dtor@_Init_locks@std@@CAXPAV12@@Z
+?_Ios_base_dtor@ios_base@std@@CAXPAV12@@Z
+?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
+?_Ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_N_N@Z
+?_Ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_N_N@Z
+?_Iput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPADI@Z
+?_Iput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPADI@Z
+?_Iput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPADI@Z
+?_IsCurrentOriginSTA@_ContextCallback@details@Concurrency@@CA_NXZ
+?_IsNonBlockingThread@_Task_impl_base@details@Concurrency@@SA_NXZ
+?_Locimp_Addfac@_Locimp@locale@std@@CAXPAV123@PAVfacet@23@I@Z
+?_Locimp_ctor@_Locimp@locale@std@@CAXPAV123@ABV123@@Z
+?_Locimp_dtor@_Locimp@locale@std@@CAXPAV123@@Z
+?_Locinfo_Addcats@_Locinfo@std@@SAAAV12@PAV12@HPBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPAV12@HPBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPAV12@PBD@Z
+?_Locinfo_dtor@_Locinfo@std@@SAXPAV12@@Z
+?_Lock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAEXXZ
+?_Lock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAEXXZ
+?_Lock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAEXXZ
+?_Lockit_ctor@_Lockit@std@@CAXPAV12@@Z
+?_Lockit_ctor@_Lockit@std@@CAXPAV12@H@Z
+?_Lockit_ctor@_Lockit@std@@SAXH@Z
+?_Lockit_dtor@_Lockit@std@@CAXPAV12@@Z
+?_Lockit_dtor@_Lockit@std@@SAXH@Z
+?_LogCancelTask@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_LogScheduleTask@_TaskEventLogger@details@Concurrency@@QAEX_N@Z
+?_LogTaskCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_LogTaskExecutionCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_LogWorkItemCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_LogWorkItemStarted@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_MP_Add@std@@YAXQA_K_K@Z
+?_MP_Get@std@@YA_KQA_K@Z
+?_MP_Mul@std@@YAXQA_K_K1@Z
+?_MP_Rem@std@@YAXQA_K_K@Z
+?_Makeloc@_Locimp@locale@std@@CAPAV123@ABV_Locinfo@3@HPAV123@PBV23@@Z
+?_Makeushloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z
+?_Makewloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z
+?_Makexloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z
+?_Mtx_delete@threads@stdext@@YAXPAX@Z
+?_Mtx_lock@threads@stdext@@YAXPAX@Z
+?_Mtx_new@threads@stdext@@YAXAAPAX@Z
+?_Mtx_unlock@threads@stdext@@YAXPAX@Z
+?_New_Locimp@_Locimp@locale@std@@CAPAV123@ABV123@@Z
+?_New_Locimp@_Locimp@locale@std@@CAPAV123@_N@Z
+?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ
+?_Osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ
+?_Osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+?_Pnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBE_JXZ
+?_Pnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBE_JXZ
+?_Pnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBE_JXZ
+?_Pninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
+?_Pninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ
+?_Pninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ
+?_Ptr_cerr@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?_Ptr_cin@std@@3PAV?$basic_istream@DU?$char_traits@D@std@@@1@A
+?_Ptr_clog@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?_Ptr_cout@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?_Ptr_wcerr@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?_Ptr_wcerr@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?_Ptr_wcin@std@@3PAV?$basic_istream@GU?$char_traits@G@std@@@1@A
+?_Ptr_wcin@std@@3PAV?$basic_istream@_WU?$char_traits@_W@std@@@1@A
+?_Ptr_wclog@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?_Ptr_wclog@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?_Ptr_wcout@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?_Ptr_wcout@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?_Put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@PBDI@Z
+?_Put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@PBGI@Z
+?_Put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@PB_WI@Z
+?_Raise_handler@std@@3P6AXABVexception@stdext@@@ZA
+?_Random_device@std@@YAIXZ
+?_Release_chore@details@Concurrency@@YAXPAU_Threadpool_chore@12@@Z
+?_Rep@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@DI@Z
+?_Rep@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@GI@Z
+?_Rep@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@_WI@Z
+?_ReportUnobservedException@details@Concurrency@@YAXXZ
+?_Reschedule_chore@details@Concurrency@@YAHPBU_Threadpool_chore@12@@Z
+?_Reset@_ContextCallback@details@Concurrency@@AAEXXZ
+?_Rethrow_future_exception@std@@YAXVexception_ptr@1@@Z
+?_Rng_abort@std@@YAXPBD@Z
+?_Schedule_chore@details@Concurrency@@YAHPAU_Threadpool_chore@12@@Z
+?_Setgloballocale@locale@std@@CAXPAX@Z
+?_Src@?1??_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1HABVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1HABVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1HABVlocale@3@@Z@4QBDB
+?_Sync@ios_base@std@@0_NA
+?_Syserror_map@std@@YAPBDH@Z
+?_Throw_C_error@std@@YAXH@Z
+?_Throw_Cpp_error@std@@YAXH@Z
+?_Throw_future_error@std@@YAXABVerror_code@1@@Z
+?_Tidy@?$_Yarn@D@std@@AAEXXZ
+?_Tidy@?$_Yarn@G@std@@AAEXXZ
+?_Tidy@?$_Yarn@_W@std@@AAEXXZ
+?_Tidy@?$ctype@D@std@@IAEXXZ
+?_Tidy@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AAEXXZ
+?_Tidy@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AAEXXZ
+?_Tidy@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AAEXXZ
+?_Tidy@ios_base@std@@AAEXXZ
+?_Unlock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAEXXZ
+?_Unlock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAEXXZ
+?_Unlock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAEXXZ
+?_W_Getdays@_Locinfo@std@@QBEPBGXZ
+?_W_Getmonths@_Locinfo@std@@QBEPBGXZ
+?_W_Gettnames@_Locinfo@std@@QBE?AV_Timevec@2@XZ
+?_Winerror_map@std@@YAHH@Z
+?_Winerror_message@std@@YAKKPADK@Z
+?_XGetLastError@std@@YAXXZ
+?_XLgamma@std@@YAMM@Z
+?_XLgamma@std@@YANN@Z
+?_XLgamma@std@@YAOO@Z
+?_Xbad_alloc@std@@YAXXZ
+?_Xbad_function_call@std@@YAXXZ
+?_Xinvalid_argument@std@@YAXPBD@Z
+?_Xlength_error@std@@YAXPBD@Z
+?_Xout_of_range@std@@YAXPBD@Z
+?_Xoverflow_error@std@@YAXPBD@Z
+?_Xregex_error@std@@YAXW4error_type@regex_constants@1@@Z
+?_Xruntime_error@std@@YAXPBD@Z
+?__ExceptionPtrAssign@@YAXPAXPBX@Z
+?__ExceptionPtrCompare@@YA_NPBX0@Z
+?__ExceptionPtrCopy@@YAXPAXPBX@Z
+?__ExceptionPtrCopyException@@YAXPAXPBX1@Z
+?__ExceptionPtrCreate@@YAXPAX@Z
+?__ExceptionPtrCurrentException@@YAXPAX@Z
+?__ExceptionPtrDestroy@@YAXPAX@Z
+?__ExceptionPtrRethrow@@YAXPBX@Z
+?__ExceptionPtrSwap@@YAXPAX0@Z
+?__ExceptionPtrToBool@@YA_NPBX@Z
+?always_noconv@codecvt_base@std@@QBE_NXZ
+?bad@ios_base@std@@QBE_NXZ
+?c_str@?$_Yarn@D@std@@QBEPBDXZ
+?c_str@?$_Yarn@G@std@@QBEPBGXZ
+?c_str@?$_Yarn@_W@std@@QBEPB_WXZ
+?cerr@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?cin@std@@3V?$basic_istream@DU?$char_traits@D@std@@@1@A
+?classic@locale@std@@SAABV12@XZ
+?classic_table@?$ctype@D@std@@SAPBFXZ
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXI@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXH_N@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXI@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXH_N@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXI@Z
+?clear@ios_base@std@@QAEXH@Z
+?clear@ios_base@std@@QAEXH_N@Z
+?clear@ios_base@std@@QAEXI@Z
+?clog@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?copyfmt@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEAAV12@ABV12@@Z
+?copyfmt@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEAAV12@ABV12@@Z
+?copyfmt@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEAAV12@ABV12@@Z
+?copyfmt@ios_base@std@@QAEAAV12@ABV12@@Z
+?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ
+?do_always_noconv@?$codecvt@DDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@?$codecvt@GDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@?$codecvt@_SDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@?$codecvt@_UDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@?$codecvt@_WDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@codecvt_base@std@@MBE_NXZ
+?do_date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ
+?do_encoding@?$codecvt@GDU_Mbstatet@@@std@@MBEHXZ
+?do_encoding@?$codecvt@_SDU_Mbstatet@@@std@@MBEHXZ
+?do_encoding@?$codecvt@_UDU_Mbstatet@@@std@@MBEHXZ
+?do_encoding@?$codecvt@_WDU_Mbstatet@@@std@@MBEHXZ
+?do_encoding@codecvt_base@std@@MBEHXZ
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?do_get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?do_get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?do_get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?do_get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_in@?$codecvt@DDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPAD3AAPAD@Z
+?do_in@?$codecvt@GDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPAG3AAPAG@Z
+?do_in@?$codecvt@_SDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPA_S3AAPA_S@Z
+?do_in@?$codecvt@_UDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPA_U3AAPA_U@Z
+?do_in@?$codecvt@_WDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPA_W3AAPA_W@Z
+?do_is@?$ctype@G@std@@MBEPBGPBG0PAF@Z
+?do_is@?$ctype@G@std@@MBE_NFG@Z
+?do_is@?$ctype@_W@std@@MBEPB_WPB_W0PAF@Z
+?do_is@?$ctype@_W@std@@MBE_NF_W@Z
+?do_length@?$codecvt@DDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_length@?$codecvt@GDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_length@?$codecvt@_SDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_length@?$codecvt@_UDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_length@?$codecvt@_WDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_max_length@?$codecvt@GDU_Mbstatet@@@std@@MBEHXZ
+?do_max_length@?$codecvt@_SDU_Mbstatet@@@std@@MBEHXZ
+?do_max_length@?$codecvt@_UDU_Mbstatet@@@std@@MBEHXZ
+?do_max_length@?$codecvt@_WDU_Mbstatet@@@std@@MBEHXZ
+?do_max_length@codecvt_base@std@@MBEHXZ
+?do_narrow@?$ctype@D@std@@MBEDDD@Z
+?do_narrow@?$ctype@D@std@@MBEPBDPBD0DPAD@Z
+?do_narrow@?$ctype@G@std@@MBEDGD@Z
+?do_narrow@?$ctype@G@std@@MBEPBGPBG0DPAD@Z
+?do_narrow@?$ctype@_W@std@@MBED_WD@Z
+?do_narrow@?$ctype@_W@std@@MBEPB_WPB_W0DPAD@Z
+?do_out@?$codecvt@DDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPAD3AAPAD@Z
+?do_out@?$codecvt@GDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBG1AAPBGPAD3AAPAD@Z
+?do_out@?$codecvt@_SDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PB_S1AAPB_SPAD3AAPAD@Z
+?do_out@?$codecvt@_UDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PB_U1AAPB_UPAD3AAPAD@Z
+?do_out@?$codecvt@_WDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PB_W1AAPB_WPAD3AAPAD@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DJ@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DK@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DN@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DO@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBX@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_J@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_K@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_N@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GJ@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GK@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GN@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GO@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBX@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_J@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_K@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_N@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WJ@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WK@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WN@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WO@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBX@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_J@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_K@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_N@Z
+?do_put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@DD@Z
+?do_put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@DD@Z
+?do_put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@DD@Z
+?do_scan_is@?$ctype@G@std@@MBEPBGFPBG0@Z
+?do_scan_is@?$ctype@_W@std@@MBEPB_WFPB_W0@Z
+?do_scan_not@?$ctype@G@std@@MBEPBGFPBG0@Z
+?do_scan_not@?$ctype@_W@std@@MBEPB_WFPB_W0@Z
+?do_tolower@?$ctype@D@std@@MBEDD@Z
+?do_tolower@?$ctype@D@std@@MBEPBDPADPBD@Z
+?do_tolower@?$ctype@G@std@@MBEGG@Z
+?do_tolower@?$ctype@G@std@@MBEPBGPAGPBG@Z
+?do_tolower@?$ctype@_W@std@@MBEPB_WPA_WPB_W@Z
+?do_tolower@?$ctype@_W@std@@MBE_W_W@Z
+?do_toupper@?$ctype@D@std@@MBEDD@Z
+?do_toupper@?$ctype@D@std@@MBEPBDPADPBD@Z
+?do_toupper@?$ctype@G@std@@MBEGG@Z
+?do_toupper@?$ctype@G@std@@MBEPBGPAGPBG@Z
+?do_toupper@?$ctype@_W@std@@MBEPB_WPA_WPB_W@Z
+?do_toupper@?$ctype@_W@std@@MBE_W_W@Z
+?do_unshift@?$codecvt@DDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_unshift@?$codecvt@GDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_unshift@?$codecvt@_SDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_unshift@?$codecvt@_UDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_unshift@?$codecvt@_WDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_widen@?$ctype@D@std@@MBEDD@Z
+?do_widen@?$ctype@D@std@@MBEPBDPBD0PAD@Z
+?do_widen@?$ctype@G@std@@MBEGD@Z
+?do_widen@?$ctype@G@std@@MBEPBDPBD0PAG@Z
+?do_widen@?$ctype@_W@std@@MBEPBDPBD0PA_W@Z
+?do_widen@?$ctype@_W@std@@MBE_WD@Z
+?eback@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?eback@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?eback@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?egptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?egptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?egptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?empty@?$_Yarn@D@std@@QBE_NXZ
+?empty@?$_Yarn@G@std@@QBE_NXZ
+?empty@?$_Yarn@_W@std@@QBE_NXZ
+?empty@locale@std@@SA?AV12@XZ
+?encoding@codecvt_base@std@@QBEHXZ
+?eof@ios_base@std@@QBE_NXZ
+?epptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?epptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?epptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?exceptions@ios_base@std@@QAEXH@Z
+?exceptions@ios_base@std@@QAEXI@Z
+?exceptions@ios_base@std@@QBEHXZ
+?fail@ios_base@std@@QBE_NXZ
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEDD@Z
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDXZ
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEGG@Z
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEGXZ
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE_W_W@Z
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBE_WXZ
+?flags@ios_base@std@@QAEHH@Z
+?flags@ios_base@std@@QBEHXZ
+?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@XZ
+?flush@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@XZ
+?flush@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@XZ
+?gbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXH@Z
+?gbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXH@Z
+?gbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXH@Z
+?gcount@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_JXZ
+?gcount@?$basic_istream@GU?$char_traits@G@std@@@std@@QBE_JXZ
+?gcount@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QBE_JXZ
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAV?$basic_streambuf@DU?$char_traits@D@std@@@2@D@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_JD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAV?$basic_streambuf@GU?$char_traits@G@std@@@2@G@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_JG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEGXZ
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AA_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD4@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBG4@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PB_W4@Z
+?get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_new_handler@std@@YAP6AXXZXZ
+?get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_JD@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_JG@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J_W@Z
+?getloc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QBE?AVlocale@2@XZ
+?getloc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QBE?AVlocale@2@XZ
+?getloc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QBE?AVlocale@2@XZ
+?getloc@ios_base@std@@QBE?AVlocale@2@XZ
+?global@locale@std@@SA?AV12@ABV12@@Z
+?good@ios_base@std@@QBE_NXZ
+?gptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?gptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?gptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?id@?$codecvt@DDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@GDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_WDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$collate@D@std@@2V0locale@2@A
+?id@?$collate@G@std@@2V0locale@2@A
+?id@?$collate@_W@std@@2V0locale@2@A
+?id@?$ctype@D@std@@2V0locale@2@A
+?id@?$ctype@G@std@@2V0locale@2@A
+?id@?$ctype@_W@std@@2V0locale@2@A
+?id@?$messages@D@std@@2V0locale@2@A
+?id@?$messages@G@std@@2V0locale@2@A
+?id@?$messages@_W@std@@2V0locale@2@A
+?id@?$money_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$moneypunct@D$00@std@@2V0locale@2@A
+?id@?$moneypunct@D$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@G$00@std@@2V0locale@2@A
+?id@?$moneypunct@G$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@_W$00@std@@2V0locale@2@A
+?id@?$moneypunct@_W$0A@@std@@2V0locale@2@A
+?id@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$numpunct@D@std@@2V0locale@2@A
+?id@?$numpunct@G@std@@2V0locale@2@A
+?id@?$numpunct@_W@std@@2V0locale@2@A
+?id@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?ignore@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z
+?ignore@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JG@Z
+?ignore@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JG@Z
+?imbue@?$basic_ios@DU?$char_traits@D@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?imbue@?$basic_ios@GU?$char_traits@G@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?imbue@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?imbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEXABVlocale@2@@Z
+?imbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEXABVlocale@2@@Z
+?imbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEXABVlocale@2@@Z
+?imbue@ios_base@std@@QAE?AVlocale@2@ABV32@@Z
+?in@?$codecvt@DDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPAD3AAPAD@Z
+?in@?$codecvt@GDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPAG3AAPAG@Z
+?in@?$codecvt@_SDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPA_S3AAPA_S@Z
+?in@?$codecvt@_UDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPA_U3AAPA_U@Z
+?in@?$codecvt@_WDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPA_W3AAPA_W@Z
+?in_avail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JXZ
+?in_avail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JXZ
+?in_avail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JXZ
+?init@?$basic_ios@DU?$char_traits@D@std@@@std@@IAEXPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@_N@Z
+?init@?$basic_ios@GU?$char_traits@G@std@@@std@@IAEXPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@_N@Z
+?init@?$basic_ios@_WU?$char_traits@_W@std@@@std@@IAEXPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_N@Z
+?intl@?$moneypunct@D$00@std@@2_NB
+?intl@?$moneypunct@D$0A@@std@@2_NB
+?intl@?$moneypunct@G$00@std@@2_NB
+?intl@?$moneypunct@G$0A@@std@@2_NB
+?intl@?$moneypunct@_W$00@std@@2_NB
+?intl@?$moneypunct@_W$0A@@std@@2_NB
+?ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
+?ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_N_N@Z
+?ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_N_N@Z
+?is@?$ctype@D@std@@QBEPBDPBD0PAF@Z
+?is@?$ctype@D@std@@QBE_NFD@Z
+?is@?$ctype@G@std@@QBEPBGPBG0PAF@Z
+?is@?$ctype@G@std@@QBE_NFG@Z
+?is@?$ctype@_W@std@@QBEPB_WPB_W0PAF@Z
+?is@?$ctype@_W@std@@QBE_NF_W@Z
+?isfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEXXZ
+?isfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEXXZ
+?isfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+?iword@ios_base@std@@QAEAAJH@Z
+?length@?$codecvt@DDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?length@?$codecvt@GDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?length@?$codecvt@_SDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?length@?$codecvt@_UDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?length@?$codecvt@_WDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?max_length@codecvt_base@std@@QBEHXZ
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEX$$QAV12@@Z
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXAAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEX$$QAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXAAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEX$$QAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXAAV12@@Z
+?narrow@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDDD@Z
+?narrow@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEDGD@Z
+?narrow@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBED_WD@Z
+?narrow@?$ctype@D@std@@QBEDDD@Z
+?narrow@?$ctype@D@std@@QBEPBDPBD0DPAD@Z
+?narrow@?$ctype@G@std@@QBEDGD@Z
+?narrow@?$ctype@G@std@@QBEPBGPBG0DPAD@Z
+?narrow@?$ctype@_W@std@@QBED_WD@Z
+?narrow@?$ctype@_W@std@@QBEPB_WPB_W0DPAD@Z
+?opfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE_NXZ
+?opfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE_NXZ
+?opfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE_NXZ
+?osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ
+?osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ
+?osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+?out@?$codecvt@DDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPAD3AAPAD@Z
+?out@?$codecvt@GDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBG1AAPBGPAD3AAPAD@Z
+?out@?$codecvt@_SDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PB_S1AAPB_SPAD3AAPAD@Z
+?out@?$codecvt@_UDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PB_U1AAPB_UPAD3AAPAD@Z
+?out@?$codecvt@_WDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PB_W1AAPB_WPAD3AAPAD@Z
+?overflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHH@Z
+?overflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGG@Z
+?overflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGG@Z
+?pbackfail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHH@Z
+?pbackfail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGG@Z
+?pbackfail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGG@Z
+?pbase@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?pbase@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?pbase@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?pbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXH@Z
+?pbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXH@Z
+?pbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXH@Z
+?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
+?peek@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEGXZ
+?peek@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?pptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?pptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?pptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?precision@ios_base@std@@QAE_J_J@Z
+?precision@ios_base@std@@QBE_JXZ
+?pubimbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?pubimbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?pubimbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubsetbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEPAV12@PAD_J@Z
+?pubsetbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEPAV12@PAG_J@Z
+?pubsetbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEPAV12@PA_W_J@Z
+?pubsync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?pubsync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEHXZ
+?pubsync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEHXZ
+?put@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@D@Z
+?put@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@G@Z
+?put@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_W@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DJ@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DK@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DN@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DO@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBX@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_J@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_K@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_N@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GJ@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GK@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GN@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GO@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBX@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_J@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_K@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_N@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WJ@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WK@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WN@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WO@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBX@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_J@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_K@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_N@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@DD@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@PBD3@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@DD@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@PBG3@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@DD@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@PB_W4@Z
+?putback@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@D@Z
+?putback@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@G@Z
+?putback@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_W@Z
+?pword@ios_base@std@@QAEAAPAXH@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@PAV32@@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@PAV32@@Z
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@XZ
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@PAV32@@Z
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBEPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@XZ
+?rdstate@ios_base@std@@QBEHXZ
+?read@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z
+?read@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z
+?read@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z
+?readsome@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_JPAD_J@Z
+?readsome@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_JPAG_J@Z
+?readsome@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_JPA_W_J@Z
+?register_callback@ios_base@std@@QAEXP6AXW4event@12@AAV12@H@ZH@Z
+?resetiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?sbumpc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ
+?sbumpc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?scan_is@?$ctype@D@std@@QBEPBDFPBD0@Z
+?scan_is@?$ctype@G@std@@QBEPBGFPBG0@Z
+?scan_is@?$ctype@_W@std@@QBEPB_WFPB_W0@Z
+?scan_not@?$ctype@D@std@@QBEPBDFPBD0@Z
+?scan_not@?$ctype@G@std@@QBEPBGFPBG0@Z
+?scan_not@?$ctype@_W@std@@QBEPB_WFPB_W0@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JH@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JH@Z
+?seekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JH@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JH@Z
+?seekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?set_new_handler@std@@YAP6AXXZP6AXXZ@Z
+?set_rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?set_rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?set_rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?setbase@std@@YA?AU?$_Smanip@H@1@H@Z
+?setbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEPAV12@PAD_J@Z
+?setbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEPAV12@PAG_J@Z
+?setbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEPAV12@PA_W_J@Z
+?setf@ios_base@std@@QAEHH@Z
+?setf@ios_base@std@@QAEHHH@Z
+?setg@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD00@Z
+?setg@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG00@Z
+?setg@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W00@Z
+?setiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD00@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD0@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG00@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG0@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W00@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W0@Z
+?setprecision@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXI@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXH_N@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXI@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXH_N@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXI@Z
+?setstate@ios_base@std@@QAEXH@Z
+?setstate@ios_base@std@@QAEXH_N@Z
+?setstate@ios_base@std@@QAEXI@Z
+?setw@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?sgetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ
+?sgetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?sgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JPAD_J@Z
+?sgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JPAG_J@Z
+?sgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JPA_W_J@Z
+?showmanyc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JXZ
+?showmanyc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JXZ
+?showmanyc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JXZ
+?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?snextc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ
+?snextc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?sputbackc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHD@Z
+?sputbackc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGG@Z
+?sputbackc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEG_W@Z
+?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHD@Z
+?sputc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGG@Z
+?sputc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEG_W@Z
+?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JPBD_J@Z
+?sputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JPBG_J@Z
+?sputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JPB_W_J@Z
+?stossc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEXXZ
+?stossc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEXXZ
+?stossc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+?sungetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?sungetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ
+?sungetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?swap@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXAAV12@@Z
+?swap@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXAAV12@@Z
+?swap@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXAAV12@@Z
+?swap@?$basic_iostream@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_iostream@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_istream@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_istream@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_istream@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_ostream@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_ostream@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z
+?swap@ios_base@std@@QAEXAAV12@@Z
+?sync@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
+?sync@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEHXZ
+?sync@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEHXZ
+?sync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ
+?sync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEHXZ
+?sync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEHXZ
+?sync_with_stdio@ios_base@std@@SA_N_N@Z
+?table@?$ctype@D@std@@QBEPBFXZ
+?table_size@?$ctype@D@std@@2IB
+?tellg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEPAV?$basic_ostream@DU?$char_traits@D@std@@@2@PAV32@@Z
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEPAV?$basic_ostream@GU?$char_traits@G@std@@@2@PAV32@@Z
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEPAV?$basic_ostream@GU?$char_traits@G@std@@@2@XZ
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEPAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@PAV32@@Z
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBEPAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@XZ
+?tolower@?$ctype@D@std@@QBEDD@Z
+?tolower@?$ctype@D@std@@QBEPBDPADPBD@Z
+?tolower@?$ctype@G@std@@QBEGG@Z
+?tolower@?$ctype@G@std@@QBEPBGPAGPBG@Z
+?tolower@?$ctype@_W@std@@QBEPB_WPA_WPB_W@Z
+?tolower@?$ctype@_W@std@@QBE_W_W@Z
+?toupper@?$ctype@D@std@@QBEDD@Z
+?toupper@?$ctype@D@std@@QBEPBDPADPBD@Z
+?toupper@?$ctype@G@std@@QBEGG@Z
+?toupper@?$ctype@G@std@@QBEPBGPAGPBG@Z
+?toupper@?$ctype@_W@std@@QBEPB_WPA_WPB_W@Z
+?toupper@?$ctype@_W@std@@QBE_W_W@Z
+?uflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ
+?uflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGXZ
+?uflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGXZ
+?uncaught_exception@std@@YA_NXZ
+?uncaught_exceptions@std@@YAHXZ
+?underflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ
+?underflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGXZ
+?underflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGXZ
+?unget@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@XZ
+?unget@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@XZ
+?unget@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@XZ
+?unsetf@ios_base@std@@QAEXH@Z
+?unshift@?$codecvt@DDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?unshift@?$codecvt@GDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?unshift@?$codecvt@_SDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?unshift@?$codecvt@_UDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?unshift@?$codecvt@_WDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?wcerr@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcerr@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcin@std@@3V?$basic_istream@GU?$char_traits@G@std@@@1@A
+?wcin@std@@3V?$basic_istream@_WU?$char_traits@_W@std@@@1@A
+?wclog@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wclog@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcout@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcout@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?widen@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDD@Z
+?widen@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEGD@Z
+?widen@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBE_WD@Z
+?widen@?$ctype@D@std@@QBEDD@Z
+?widen@?$ctype@D@std@@QBEPBDPBD0PAD@Z
+?widen@?$ctype@G@std@@QBEGD@Z
+?widen@?$ctype@G@std@@QBEPBDPBD0PAG@Z
+?widen@?$ctype@_W@std@@QBEPBDPBD0PA_W@Z
+?widen@?$ctype@_W@std@@QBE_WD@Z
+?width@ios_base@std@@QAE_J_J@Z
+?width@ios_base@std@@QBE_JXZ
+?write@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@PBD_J@Z
+?write@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@PBG_J@Z
+?write@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PB_W_J@Z
+?xalloc@ios_base@std@@SAHXZ
+?xsgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JPAD_J@Z
+?xsgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JPAG_J@Z
+?xsgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JPA_W_J@Z
+?xsputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JPBD_J@Z
+?xsputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JPBG_J@Z
+?xsputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JPB_W_J@Z
+_Chmod
+_Close_dir
+_Cnd_broadcast
+_Cnd_destroy
+_Cnd_destroy_in_situ
+_Cnd_do_broadcast_at_thread_exit
+_Cnd_init
+_Cnd_init_in_situ
+_Cnd_register_at_thread_exit
+_Cnd_signal
+_Cnd_timedwait
+_Cnd_unregister_at_thread_exit
+_Cnd_wait
+_Copy_file
+_Cosh
+_Current_get
+_Current_set
+_Denorm
+_Dtest
+_Equivalent
+_Exp
+_FCosh
+_FDenorm
+_FDtest
+_FExp
+_FInf
+_FNan
+_FSinh
+_FSnan
+_File_size
+_Getcoll
+_Getctype
+_Getcvt
+_Getdateorder
+_Getwctype
+_Getwctypes
+_Hard_links
+_Hugeval
+_Inf
+_LCosh
+_LDenorm
+_LDtest
+_LExp
+_LInf
+_LNan
+_LSinh
+_LSnan
+_Last_write_time
+_Link
+_Lock_shared_ptr_spin_lock
+_Lstat
+_Make_dir
+_Mbrtowc
+_Mtx_clear_owner
+_Mtx_current_owns
+_Mtx_destroy
+_Mtx_destroy_in_situ
+_Mtx_getconcrtcs
+_Mtx_init
+_Mtx_init_in_situ
+_Mtx_lock
+_Mtx_reset_owner
+_Mtx_timedlock
+_Mtx_trylock
+_Mtx_unlock
+_Mtxdst
+_Mtxinit
+_Mtxlock
+_Mtxunlock
+_Nan
+_Open_dir
+_Query_perf_counter
+_Query_perf_frequency
+_Read_dir
+_Remove_dir
+_Rename
+_Resize
+_Set_last_write_time
+_Sinh
+_Snan
+_Stat
+_Statvfs
+_Stod
+_Stodx
+_Stof
+_Stofx
+_Stold
+_Stoldx
+_Stoll
+_Stollx
+_Stolx
+_Stoul
+_Stoull
+_Stoullx
+_Stoulx
+_Strcoll
+_Strxfrm
+_Symlink
+_Symlink_get
+_Temp_get
+_Thrd_abort
+_Thrd_create
+_Thrd_current
+_Thrd_detach
+_Thrd_equal
+_Thrd_exit
+_Thrd_hardware_concurrency
+_Thrd_id
+_Thrd_join
+_Thrd_sleep
+_Thrd_start
+_Thrd_yield
+_To_byte
+_To_wide
+_Tolower
+_Toupper
+_Towlower
+_Towupper
+_Unlink
+_Unlock_shared_ptr_spin_lock
+_WStod
+_WStodx
+_WStof
+_WStofx
+_WStold
+_WStoldx
+_Wcrtomb
+_Wcscoll
+_Wcsxfrm
+_Xtime_diff_to_millis
+_Xtime_diff_to_millis2
+_Xtime_get_ticks
+__Wcrtomb_lk
+__crtCloseThreadpoolTimer
+__crtCloseThreadpoolWait
+__crtCompareStringA
+__crtCompareStringEx
+__crtCompareStringW
+__crtCreateEventExW
+__crtCreateSemaphoreExW
+__crtCreateSymbolicLinkW
+__crtCreateThreadpoolTimer
+__crtCreateThreadpoolWait
+__crtFlushProcessWriteBuffers
+__crtFreeLibraryWhenCallbackReturns
+__crtGetCurrentProcessorNumber
+__crtGetFileInformationByHandleEx
+__crtGetLocaleInfoEx
+__crtGetSystemTimePreciseAsFileTime
+__crtGetTickCount64
+__crtInitOnceExecuteOnce
+__crtInitializeCriticalSectionEx
+__crtIsPackagedApp
+__crtLCMapStringA
+__crtLCMapStringEx
+__crtLCMapStringW
+__crtSetFileInformationByHandle
+__crtSetThreadpoolTimer
+__crtSetThreadpoolWait
+__crtWaitForThreadpoolTimerCallbacks
+__set_stl_sync_api_mode
+xtime_get
diff --git a/msvc-stl/stl/msbuild/stl_base/i386_onecore.exports b/msvc-stl/stl/msbuild/stl_base/i386_onecore.exports
new file mode 100644
index 0000000..7045ada
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/i386_onecore.exports
@@ -0,0 +1,1493 @@
+??$_Getvals@_W@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEX_WABV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEX_WABV_Locinfo@1@@Z
+??$_Getvals@_W@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEX_WABV_Locinfo@1@@Z
+??0?$_Yarn@D@std@@QAE@ABV01@@Z
+??0?$_Yarn@D@std@@QAE@PBD@Z
+??0?$_Yarn@D@std@@QAE@XZ
+??0?$_Yarn@G@std@@QAE@ABV01@@Z
+??0?$_Yarn@G@std@@QAE@PBG@Z
+??0?$_Yarn@G@std@@QAE@XZ
+??0?$_Yarn@_W@std@@QAE@ABV01@@Z
+??0?$_Yarn@_W@std@@QAE@PB_W@Z
+??0?$_Yarn@_W@std@@QAE@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@IAE@XZ
+??0?$basic_ios@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@IAE@XZ
+??0?$basic_ios@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@IAE@XZ
+??0?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_iostream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_iostream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N1@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@W4_Uninitialized@1@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N1@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_istream@GU?$char_traits@G@std@@@std@@QAE@W4_Uninitialized@1@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N1@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE@W4_Uninitialized@1@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@_N@Z
+??0?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@_N@Z
+??0?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE@W4_Uninitialized@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IAE@$$QAV01@@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@_N@Z
+??0?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE@W4_Uninitialized@1@_N@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@ABV01@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAE@XZ
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@ABV01@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAE@XZ
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@ABV01@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@W4_Uninitialized@1@@Z
+??0?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAE@XZ
+??0?$codecvt@DDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@DDU_Mbstatet@@@std@@QAE@I@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@GDU_Mbstatet@@@std@@QAE@I@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@KW4_Codecvt_mode@1@I@Z
+??0?$codecvt@_SDU_Mbstatet@@@std@@QAE@I@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@KW4_Codecvt_mode@1@I@Z
+??0?$codecvt@_UDU_Mbstatet@@@std@@QAE@I@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$codecvt@_WDU_Mbstatet@@@std@@QAE@I@Z
+??0?$ctype@D@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$ctype@D@std@@QAE@PBF_NI@Z
+??0?$ctype@G@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$ctype@G@std@@QAE@I@Z
+??0?$ctype@_W@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$ctype@_W@std@@QAE@I@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAE@I@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAE@I@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAE@PBDI@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@ABV_Locinfo@1@I@Z
+??0?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAE@I@Z
+??0Init@ios_base@std@@QAE@XZ
+??0_Facet_base@std@@QAE@ABV01@@Z
+??0_Facet_base@std@@QAE@XZ
+??0_Init_locks@std@@QAE@XZ
+??0_Locimp@locale@std@@AAE@ABV012@@Z
+??0_Locimp@locale@std@@AAE@_N@Z
+??0_Locinfo@std@@QAE@HPBD@Z
+??0_Locinfo@std@@QAE@PBD@Z
+??0_Lockit@std@@QAE@H@Z
+??0_Lockit@std@@QAE@XZ
+??0_Timevec@std@@QAE@ABV01@@Z
+??0_Timevec@std@@QAE@PAX@Z
+??0_UShinit@std@@QAE@XZ
+??0_Winit@std@@QAE@XZ
+??0codecvt_base@std@@QAE@I@Z
+??0ctype_base@std@@QAE@I@Z
+??0facet@locale@std@@IAE@I@Z
+??0id@locale@std@@QAE@I@Z
+??0ios_base@std@@IAE@XZ
+??0task_continuation_context@Concurrency@@AAE@XZ
+??0time_base@std@@QAE@I@Z
+??1?$_Yarn@D@std@@QAE@XZ
+??1?$_Yarn@G@std@@QAE@XZ
+??1?$_Yarn@_W@std@@QAE@XZ
+??1?$basic_ios@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_ios@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_ios@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$basic_iostream@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_iostream@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_iostream@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$basic_istream@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_istream@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_istream@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$basic_ostream@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_ostream@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_ostream@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAE@XZ
+??1?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAE@XZ
+??1?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAE@XZ
+??1?$codecvt@DDU_Mbstatet@@@std@@MAE@XZ
+??1?$codecvt@GDU_Mbstatet@@@std@@MAE@XZ
+??1?$codecvt@_SDU_Mbstatet@@@std@@MAE@XZ
+??1?$codecvt@_UDU_Mbstatet@@@std@@MAE@XZ
+??1?$codecvt@_WDU_Mbstatet@@@std@@MAE@XZ
+??1?$ctype@D@std@@MAE@XZ
+??1?$ctype@G@std@@MAE@XZ
+??1?$ctype@_W@std@@MAE@XZ
+??1?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ
+??1?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ
+??1?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ
+??1?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ
+??1?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ
+??1?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ
+??1?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ
+??1?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ
+??1?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ
+??1?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MAE@XZ
+??1?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MAE@XZ
+??1?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MAE@XZ
+??1Init@ios_base@std@@QAE@XZ
+??1_Facet_base@std@@UAE@XZ
+??1_Init_locks@std@@QAE@XZ
+??1_Locimp@locale@std@@MAE@XZ
+??1_Locinfo@std@@QAE@XZ
+??1_Lockit@std@@QAE@XZ
+??1_Timevec@std@@QAE@XZ
+??1_UShinit@std@@QAE@XZ
+??1_Winit@std@@QAE@XZ
+??1codecvt_base@std@@UAE@XZ
+??1ctype_base@std@@UAE@XZ
+??1facet@locale@std@@MAE@XZ
+??1ios_base@std@@UAE@XZ
+??1time_base@std@@UAE@XZ
+??4?$_Iosb@H@std@@QAEAAV01@$$QAV01@@Z
+??4?$_Iosb@H@std@@QAEAAV01@ABV01@@Z
+??4?$_Yarn@D@std@@QAEAAV01@ABV01@@Z
+??4?$_Yarn@D@std@@QAEAAV01@PBD@Z
+??4?$_Yarn@G@std@@QAEAAV01@ABV01@@Z
+??4?$_Yarn@G@std@@QAEAAV01@PBG@Z
+??4?$_Yarn@_W@std@@QAEAAV01@ABV01@@Z
+??4?$_Yarn@_W@std@@QAEAAV01@PB_W@Z
+??4?$basic_iostream@DU?$char_traits@D@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_iostream@GU?$char_traits@G@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_istream@DU?$char_traits@D@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_istream@GU?$char_traits@G@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_istream@_WU?$char_traits@_W@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_ostream@DU?$char_traits@D@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_ostream@GU?$char_traits@G@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IAEAAV01@$$QAV01@@Z
+??4?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEAAV01@ABV01@@Z
+??4?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEAAV01@ABV01@@Z
+??4?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEAAV01@ABV01@@Z
+??4Init@ios_base@std@@QAEAAV012@ABV012@@Z
+??4_Crt_new_delete@std@@QAEAAU01@$$QAU01@@Z
+??4_Crt_new_delete@std@@QAEAAU01@ABU01@@Z
+??4_Facet_base@std@@QAEAAV01@ABV01@@Z
+??4_Init_locks@std@@QAEAAV01@ABV01@@Z
+??4_Timevec@std@@QAEAAV01@ABV01@@Z
+??4_UShinit@std@@QAEAAV01@ABV01@@Z
+??4_Winit@std@@QAEAAV01@ABV01@@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAF@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAG@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAH@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAI@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAJ@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAK@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAM@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAN@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAO@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AAPAX@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_J@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_K@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@AA_N@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@DU?$char_traits@D@std@@@1@AAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??5?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV01@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAF@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAG@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAH@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAI@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAJ@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAK@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAM@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAN@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAO@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AAPAX@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_J@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_K@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@AA_N@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@GU?$char_traits@G@std@@@1@AAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??5?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV01@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAF@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAG@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAH@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAI@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAJ@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAK@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAM@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAN@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAO@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AAPAX@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_J@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_K@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@AA_N@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??5?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@F@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@G@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@H@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@I@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@M@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@N@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@O@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@DU?$char_traits@D@std@@@1@AAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@PAV?$basic_streambuf@DU?$char_traits@D@std@@@1@@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@PBX@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_J@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_K@Z
+??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@_N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@F@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@G@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@H@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@I@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@M@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@N@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@O@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@GU?$char_traits@G@std@@@1@AAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@PAV?$basic_streambuf@GU?$char_traits@G@std@@@1@@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@PBX@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_J@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_K@Z
+??6?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV01@_N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@F@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@G@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@H@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@I@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@M@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@N@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@O@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAV?$basic_ios@_WU?$char_traits@_W@std@@@1@AAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@P6AAAVios_base@1@AAV21@@Z@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PAV?$basic_streambuf@_WU?$char_traits@_W@std@@@1@@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@PBX@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_J@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_K@Z
+??6?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV01@_N@Z
+??7ios_base@std@@QBE_NXZ
+??Bid@locale@std@@QAEIXZ
+??Bios_base@std@@QBE_NXZ
+??_7?$basic_ios@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ios@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ios@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_iostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_iostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_iostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_istream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_istream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_istream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_ostream@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_ostream@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_ostream@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$basic_streambuf@DU?$char_traits@D@std@@@std@@6B@
+??_7?$basic_streambuf@GU?$char_traits@G@std@@@std@@6B@
+??_7?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@6B@
+??_7?$codecvt@DDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@GDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_SDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_UDU_Mbstatet@@@std@@6B@
+??_7?$codecvt@_WDU_Mbstatet@@@std@@6B@
+??_7?$ctype@D@std@@6B@
+??_7?$ctype@G@std@@6B@
+??_7?$ctype@_W@std@@6B@
+??_7?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@6B@
+??_7?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@6B@
+??_7?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@6B@
+??_7_Facet_base@std@@6B@
+??_7_Locimp@locale@std@@6B@
+??_7codecvt_base@std@@6B@
+??_7ctype_base@std@@6B@
+??_7facet@locale@std@@6B@
+??_7ios_base@std@@6B@
+??_7time_base@std@@6B@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_istream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@DU?$char_traits@D@std@@@std@@7B?$basic_ostream@DU?$char_traits@D@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_istream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@GU?$char_traits@G@std@@@std@@7B?$basic_ostream@GU?$char_traits@G@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_istream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_iostream@_WU?$char_traits@_W@std@@@std@@7B?$basic_ostream@_WU?$char_traits@_W@std@@@1@@
+??_8?$basic_istream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_istream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_istream@_WU?$char_traits@_W@std@@@std@@7B@
+??_8?$basic_ostream@DU?$char_traits@D@std@@@std@@7B@
+??_8?$basic_ostream@GU?$char_traits@G@std@@@std@@7B@
+??_8?$basic_ostream@_WU?$char_traits@_W@std@@@std@@7B@
+??_D?$basic_iostream@DU?$char_traits@D@std@@@std@@QAEXXZ
+??_D?$basic_iostream@GU?$char_traits@G@std@@@std@@QAEXXZ
+??_D?$basic_iostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+??_D?$basic_istream@DU?$char_traits@D@std@@@std@@QAEXXZ
+??_D?$basic_istream@GU?$char_traits@G@std@@@std@@QAEXXZ
+??_D?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+??_D?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ
+??_D?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ
+??_D?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+??_F?$codecvt@DDU_Mbstatet@@@std@@QAEXXZ
+??_F?$codecvt@GDU_Mbstatet@@@std@@QAEXXZ
+??_F?$codecvt@_SDU_Mbstatet@@@std@@QAEXXZ
+??_F?$codecvt@_UDU_Mbstatet@@@std@@QAEXXZ
+??_F?$codecvt@_WDU_Mbstatet@@@std@@QAEXXZ
+??_F?$ctype@D@std@@QAEXXZ
+??_F?$ctype@G@std@@QAEXXZ
+??_F?$ctype@_W@std@@QAEXXZ
+??_F?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ
+??_F?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ
+??_F?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ
+??_F?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ
+??_F?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ
+??_F?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ
+??_F?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ
+??_F?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ
+??_F?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ
+??_F?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QAEXXZ
+??_F?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QAEXXZ
+??_F?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QAEXXZ
+??_F_Locinfo@std@@QAEXXZ
+??_F_Timevec@std@@QAEXXZ
+??_Fcodecvt_base@std@@QAEXXZ
+??_Fctype_base@std@@QAEXXZ
+??_Ffacet@locale@std@@QAEXXZ
+??_Fid@locale@std@@QAEXXZ
+??_Ftime_base@std@@QAEXXZ
+?CaptureCallstack@platform@details@Concurrency@@YAIPAPAXII@Z
+?GetCurrentThreadId@platform@details@Concurrency@@YAJXZ
+?GetNextAsyncId@platform@details@Concurrency@@YAIXZ
+?ReportUnhandledError@_ExceptionHolder@details@Concurrency@@AAEXXZ
+?_Addcats@_Locinfo@std@@QAEAAV12@HPBD@Z
+?_Addfac@_Locimp@locale@std@@AAEXPAVfacet@23@I@Z
+?_Addstd@ios_base@std@@SAXPAV12@@Z
+?_Assign@_ContextCallback@details@Concurrency@@AAEXPAX@Z
+?_Atexit@@YAXP6AXXZ@Z
+?_BADOFF@std@@3_JB
+?_C_str@?$_Yarn@D@std@@QBEPBDXZ
+?_C_str@?$_Yarn@G@std@@QBEPBGXZ
+?_C_str@?$_Yarn@_W@std@@QBEPB_WXZ
+?_CallInContext@_ContextCallback@details@Concurrency@@QBEXV?$function@$$A6AXXZ@std@@_N@Z
+?_Callfns@ios_base@std@@AAEXW4event@12@@Z
+?_Capture@_ContextCallback@details@Concurrency@@AAEXXZ
+?_Clocptr@_Locimp@locale@std@@0PAV123@A
+?_Decref@facet@locale@std@@UAEPAV_Facet_base@3@XZ
+?_Donarrow@?$ctype@G@std@@IBEDGD@Z
+?_Donarrow@?$ctype@_W@std@@IBED_WD@Z
+?_Dowiden@?$ctype@G@std@@IBEGD@Z
+?_Dowiden@?$ctype@_W@std@@IBE_WD@Z
+?_Empty@?$_Yarn@D@std@@QBE_NXZ
+?_Empty@?$_Yarn@G@std@@QBE_NXZ
+?_Empty@?$_Yarn@_W@std@@QBE_NXZ
+?_Execute_once@std@@YAHAAUonce_flag@1@P6GHPAX1PAPAX@Z1@Z
+?_Ffmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAPADPADDH@Z
+?_Ffmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAPADPADDH@Z
+?_Ffmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAPADPADDH@Z
+?_Findarr@ios_base@std@@AAEAAU_Iosarray@12@H@Z
+?_Fiopen@std@@YAPAU_iobuf@@PBDHH@Z
+?_Fiopen@std@@YAPAU_iobuf@@PBGHH@Z
+?_Fiopen@std@@YAPAU_iobuf@@PB_WHH@Z
+?_Fput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBDI@Z
+?_Fput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBDI@Z
+?_Fput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBDI@Z
+?_Getcat@?$codecvt@DDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$codecvt@GDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$codecvt@_SDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$codecvt@_UDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$codecvt@_WDU_Mbstatet@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$ctype@D@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$ctype@G@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$ctype@_W@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@SAIPAPBVfacet@locale@2@PBV42@@Z
+?_Getcat@facet@locale@std@@SAIPAPBV123@PBV23@@Z
+?_Getcoll@_Locinfo@std@@QBE?AU_Collvec@@XZ
+?_Getctype@_Locinfo@std@@QBE?AU_Ctypevec@@XZ
+?_Getcvt@_Locinfo@std@@QBE?AU_Cvtvec@@XZ
+?_Getdateorder@_Locinfo@std@@QBEHXZ
+?_Getdays@_Locinfo@std@@QBEPBDXZ
+?_Getfalse@_Locinfo@std@@QBEPBDXZ
+?_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1AAVios_base@2@PAH@Z
+?_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1AAVios_base@2@PAH@Z
+?_Getfmt@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z
+?_Getfmt@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z
+?_Getfmt@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD@Z
+?_Getgloballocale@locale@std@@CAPAV_Locimp@12@XZ
+?_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@1HABVlocale@2@@Z
+?_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@1HABVlocale@2@@Z
+?_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@1HABVlocale@2@@Z
+?_Getint@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@0HHAAHABV?$ctype@D@2@@Z
+?_Getint@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@0HHAAHABV?$ctype@G@2@@Z
+?_Getint@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@0HHAAHABV?$ctype@_W@2@@Z
+?_Getlconv@_Locinfo@std@@QBEPBUlconv@@XZ
+?_Getmonths@_Locinfo@std@@QBEPBDXZ
+?_Getname@_Locinfo@std@@QBEPBDXZ
+?_Getptr@_Timevec@std@@QBEPAXXZ
+?_Gettnames@_Locinfo@std@@QBE?AV_Timevec@2@XZ
+?_Gettrue@_Locinfo@std@@QBEPBDXZ
+?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBE_JXZ
+?_Gnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBE_JXZ
+?_Gnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBE_JXZ
+?_Gndec@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
+?_Gndec@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ
+?_Gndec@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ
+?_Gninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
+?_Gninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ
+?_Gninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ
+?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
+?_Gnpreinc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ
+?_Gnpreinc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ
+?_Id_cnt@id@locale@std@@0HA
+?_Ifmt@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAPADPADPBDH@Z
+?_Ifmt@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAPADPADPBDH@Z
+?_Ifmt@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAPADPADPBDH@Z
+?_Incref@facet@locale@std@@UAEXXZ
+?_Index@ios_base@std@@0HA
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAPAD0PAH001@Z
+?_Init@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXXZ
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAPAG0PAH001@Z
+?_Init@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXXZ
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPAPA_W0PAH001@Z
+?_Init@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXXZ
+?_Init@?$codecvt@DDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$codecvt@GDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$codecvt@_SDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$codecvt@_UDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$codecvt@_WDU_Mbstatet@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$ctype@D@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$ctype@G@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$ctype@_W@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@IAEXABV_Locinfo@2@@Z
+?_Init@ios_base@std@@IAEXXZ
+?_Init@locale@std@@CAPAV_Locimp@12@_N@Z
+?_Init_cnt@Init@ios_base@std@@0HA
+?_Init_cnt@_UShinit@std@@0HA
+?_Init_cnt@_Winit@std@@0HA
+?_Init_cnt_func@Init@ios_base@std@@CAAAHXZ
+?_Init_ctor@Init@ios_base@std@@CAXPAV123@@Z
+?_Init_dtor@Init@ios_base@std@@CAXPAV123@@Z
+?_Init_locks_ctor@_Init_locks@std@@CAXPAV12@@Z
+?_Init_locks_dtor@_Init_locks@std@@CAXPAV12@@Z
+?_Ios_base_dtor@ios_base@std@@CAXPAV12@@Z
+?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
+?_Ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_N_N@Z
+?_Ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_N_N@Z
+?_Iput@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPADI@Z
+?_Iput@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPADI@Z
+?_Iput@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPADI@Z
+?_IsCurrentOriginSTA@_ContextCallback@details@Concurrency@@CA_NXZ
+?_IsNonBlockingThread@_Task_impl_base@details@Concurrency@@SA_NXZ
+?_Locimp_Addfac@_Locimp@locale@std@@CAXPAV123@PAVfacet@23@I@Z
+?_Locimp_ctor@_Locimp@locale@std@@CAXPAV123@ABV123@@Z
+?_Locimp_dtor@_Locimp@locale@std@@CAXPAV123@@Z
+?_Locinfo_Addcats@_Locinfo@std@@SAAAV12@PAV12@HPBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPAV12@HPBD@Z
+?_Locinfo_ctor@_Locinfo@std@@SAXPAV12@PBD@Z
+?_Locinfo_dtor@_Locinfo@std@@SAXPAV12@@Z
+?_Lock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAEXXZ
+?_Lock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAEXXZ
+?_Lock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAEXXZ
+?_Lockit_ctor@_Lockit@std@@CAXPAV12@@Z
+?_Lockit_ctor@_Lockit@std@@CAXPAV12@H@Z
+?_Lockit_ctor@_Lockit@std@@SAXH@Z
+?_Lockit_dtor@_Lockit@std@@CAXPAV12@@Z
+?_Lockit_dtor@_Lockit@std@@SAXH@Z
+?_LogCancelTask@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_LogScheduleTask@_TaskEventLogger@details@Concurrency@@QAEX_N@Z
+?_LogTaskCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_LogTaskExecutionCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_LogWorkItemCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_LogWorkItemStarted@_TaskEventLogger@details@Concurrency@@QAEXXZ
+?_MP_Add@std@@YAXQA_K_K@Z
+?_MP_Get@std@@YA_KQA_K@Z
+?_MP_Mul@std@@YAXQA_K_K1@Z
+?_MP_Rem@std@@YAXQA_K_K@Z
+?_Makeloc@_Locimp@locale@std@@CAPAV123@ABV_Locinfo@3@HPAV123@PBV23@@Z
+?_Makeushloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z
+?_Makewloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z
+?_Makexloc@_Locimp@locale@std@@CAXABV_Locinfo@3@HPAV123@PBV23@@Z
+?_Mtx_delete@threads@stdext@@YAXPAX@Z
+?_Mtx_lock@threads@stdext@@YAXPAX@Z
+?_Mtx_new@threads@stdext@@YAXAAPAX@Z
+?_Mtx_unlock@threads@stdext@@YAXPAX@Z
+?_New_Locimp@_Locimp@locale@std@@CAPAV123@ABV123@@Z
+?_New_Locimp@_Locimp@locale@std@@CAPAV123@_N@Z
+?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ
+?_Osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ
+?_Osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+?_Pnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBE_JXZ
+?_Pnavail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBE_JXZ
+?_Pnavail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBE_JXZ
+?_Pninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
+?_Pninc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEPAGXZ
+?_Pninc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEPA_WXZ
+?_Ptr_cerr@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?_Ptr_cin@std@@3PAV?$basic_istream@DU?$char_traits@D@std@@@1@A
+?_Ptr_clog@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?_Ptr_cout@std@@3PAV?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?_Ptr_wcerr@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?_Ptr_wcerr@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?_Ptr_wcin@std@@3PAV?$basic_istream@GU?$char_traits@G@std@@@1@A
+?_Ptr_wcin@std@@3PAV?$basic_istream@_WU?$char_traits@_W@std@@@1@A
+?_Ptr_wclog@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?_Ptr_wclog@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?_Ptr_wcout@std@@3PAV?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?_Ptr_wcout@std@@3PAV?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?_Put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@PBDI@Z
+?_Put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@PBGI@Z
+?_Put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@PB_WI@Z
+?_Raise_handler@std@@3P6AXABVexception@stdext@@@ZA
+?_Random_device@std@@YAIXZ
+?_Release_chore@details@Concurrency@@YAXPAU_Threadpool_chore@12@@Z
+?_Rep@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@DI@Z
+?_Rep@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@GI@Z
+?_Rep@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABA?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@_WI@Z
+?_ReportUnobservedException@details@Concurrency@@YAXXZ
+?_Reschedule_chore@details@Concurrency@@YAHPBU_Threadpool_chore@12@@Z
+?_Reset@_ContextCallback@details@Concurrency@@AAEXXZ
+?_Rethrow_future_exception@std@@YAXVexception_ptr@1@@Z
+?_Rng_abort@std@@YAXPBD@Z
+?_Schedule_chore@details@Concurrency@@YAHPAU_Threadpool_chore@12@@Z
+?_Setgloballocale@locale@std@@CAXPAX@Z
+?_Src@?1??_Getffld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getffldx@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1AAVios_base@3@PAH@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@DU?$char_traits@D@std@@@3@1HABVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@GU?$char_traits@G@std@@@3@1HABVlocale@3@@Z@4QBDB
+?_Src@?1??_Getifld@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@ABAHPADAAV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@3@1HABVlocale@3@@Z@4QBDB
+?_Sync@ios_base@std@@0_NA
+?_Syserror_map@std@@YAPBDH@Z
+?_Throw_C_error@std@@YAXH@Z
+?_Throw_Cpp_error@std@@YAXH@Z
+?_Throw_future_error@std@@YAXABVerror_code@1@@Z
+?_Tidy@?$_Yarn@D@std@@AAEXXZ
+?_Tidy@?$_Yarn@G@std@@AAEXXZ
+?_Tidy@?$_Yarn@_W@std@@AAEXXZ
+?_Tidy@?$ctype@D@std@@IAEXXZ
+?_Tidy@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@AAEXXZ
+?_Tidy@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@AAEXXZ
+?_Tidy@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@AAEXXZ
+?_Tidy@ios_base@std@@AAEXXZ
+?_Unlock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@UAEXXZ
+?_Unlock@?$basic_streambuf@GU?$char_traits@G@std@@@std@@UAEXXZ
+?_Unlock@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@UAEXXZ
+?_W_Getdays@_Locinfo@std@@QBEPBGXZ
+?_W_Getmonths@_Locinfo@std@@QBEPBGXZ
+?_W_Gettnames@_Locinfo@std@@QBE?AV_Timevec@2@XZ
+?_Winerror_map@std@@YAHH@Z
+?_Winerror_message@std@@YAKKPADK@Z
+?_XGetLastError@std@@YAXXZ
+?_XLgamma@std@@YAMM@Z
+?_XLgamma@std@@YANN@Z
+?_XLgamma@std@@YAOO@Z
+?_Xbad_alloc@std@@YAXXZ
+?_Xbad_function_call@std@@YAXXZ
+?_Xinvalid_argument@std@@YAXPBD@Z
+?_Xlength_error@std@@YAXPBD@Z
+?_Xout_of_range@std@@YAXPBD@Z
+?_Xoverflow_error@std@@YAXPBD@Z
+?_Xregex_error@std@@YAXW4error_type@regex_constants@1@@Z
+?_Xruntime_error@std@@YAXPBD@Z
+?__ExceptionPtrAssign@@YAXPAXPBX@Z
+?__ExceptionPtrCompare@@YA_NPBX0@Z
+?__ExceptionPtrCopy@@YAXPAXPBX@Z
+?__ExceptionPtrCopyException@@YAXPAXPBX1@Z
+?__ExceptionPtrCreate@@YAXPAX@Z
+?__ExceptionPtrCurrentException@@YAXPAX@Z
+?__ExceptionPtrDestroy@@YAXPAX@Z
+?__ExceptionPtrRethrow@@YAXPBX@Z
+?__ExceptionPtrSwap@@YAXPAX0@Z
+?__ExceptionPtrToBool@@YA_NPBX@Z
+?always_noconv@codecvt_base@std@@QBE_NXZ
+?bad@ios_base@std@@QBE_NXZ
+?c_str@?$_Yarn@D@std@@QBEPBDXZ
+?c_str@?$_Yarn@G@std@@QBEPBGXZ
+?c_str@?$_Yarn@_W@std@@QBEPB_WXZ
+?cerr@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?cin@std@@3V?$basic_istream@DU?$char_traits@D@std@@@1@A
+?classic@locale@std@@SAABV12@XZ
+?classic_table@?$ctype@D@std@@SAPBFXZ
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z
+?clear@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXI@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXH_N@Z
+?clear@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXI@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXH_N@Z
+?clear@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXI@Z
+?clear@ios_base@std@@QAEXH@Z
+?clear@ios_base@std@@QAEXH_N@Z
+?clear@ios_base@std@@QAEXI@Z
+?clog@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?copyfmt@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEAAV12@ABV12@@Z
+?copyfmt@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEAAV12@ABV12@@Z
+?copyfmt@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEAAV12@ABV12@@Z
+?copyfmt@ios_base@std@@QAEAAV12@ABV12@@Z
+?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
+?date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ
+?date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AW4dateorder@time_base@2@XZ
+?do_always_noconv@?$codecvt@DDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@?$codecvt@GDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@?$codecvt@_SDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@?$codecvt@_UDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@?$codecvt@_WDU_Mbstatet@@@std@@MBE_NXZ
+?do_always_noconv@codecvt_base@std@@MBE_NXZ
+?do_date_order@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ
+?do_date_order@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AW4dateorder@time_base@2@XZ
+?do_encoding@?$codecvt@GDU_Mbstatet@@@std@@MBEHXZ
+?do_encoding@?$codecvt@_SDU_Mbstatet@@@std@@MBEHXZ
+?do_encoding@?$codecvt@_UDU_Mbstatet@@@std@@MBEHXZ
+?do_encoding@?$codecvt@_WDU_Mbstatet@@@std@@MBEHXZ
+?do_encoding@codecvt_base@std@@MBEHXZ
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?do_get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?do_get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?do_get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?do_get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?do_get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?do_get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?do_get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?do_in@?$codecvt@DDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPAD3AAPAD@Z
+?do_in@?$codecvt@GDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPAG3AAPAG@Z
+?do_in@?$codecvt@_SDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPA_S3AAPA_S@Z
+?do_in@?$codecvt@_UDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPA_U3AAPA_U@Z
+?do_in@?$codecvt@_WDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPA_W3AAPA_W@Z
+?do_is@?$ctype@G@std@@MBEPBGPBG0PAF@Z
+?do_is@?$ctype@G@std@@MBE_NFG@Z
+?do_is@?$ctype@_W@std@@MBEPB_WPB_W0PAF@Z
+?do_is@?$ctype@_W@std@@MBE_NF_W@Z
+?do_length@?$codecvt@DDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_length@?$codecvt@GDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_length@?$codecvt@_SDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_length@?$codecvt@_UDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_length@?$codecvt@_WDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1I@Z
+?do_max_length@?$codecvt@GDU_Mbstatet@@@std@@MBEHXZ
+?do_max_length@?$codecvt@_SDU_Mbstatet@@@std@@MBEHXZ
+?do_max_length@?$codecvt@_UDU_Mbstatet@@@std@@MBEHXZ
+?do_max_length@?$codecvt@_WDU_Mbstatet@@@std@@MBEHXZ
+?do_max_length@codecvt_base@std@@MBEHXZ
+?do_narrow@?$ctype@D@std@@MBEDDD@Z
+?do_narrow@?$ctype@D@std@@MBEPBDPBD0DPAD@Z
+?do_narrow@?$ctype@G@std@@MBEDGD@Z
+?do_narrow@?$ctype@G@std@@MBEPBGPBG0DPAD@Z
+?do_narrow@?$ctype@_W@std@@MBED_WD@Z
+?do_narrow@?$ctype@_W@std@@MBEPB_WPB_W0DPAD@Z
+?do_out@?$codecvt@DDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBD1AAPBDPAD3AAPAD@Z
+?do_out@?$codecvt@GDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PBG1AAPBGPAD3AAPAD@Z
+?do_out@?$codecvt@_SDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PB_S1AAPB_SPAD3AAPAD@Z
+?do_out@?$codecvt@_UDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PB_U1AAPB_UPAD3AAPAD@Z
+?do_out@?$codecvt@_WDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PB_W1AAPB_WPAD3AAPAD@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DJ@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DK@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DN@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DO@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBX@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_J@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_K@Z
+?do_put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_N@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GJ@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GK@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GN@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GO@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBX@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_J@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_K@Z
+?do_put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_N@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WJ@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WK@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WN@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WO@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBX@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_J@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_K@Z
+?do_put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_N@Z
+?do_put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@DD@Z
+?do_put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@DD@Z
+?do_put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@MBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@DD@Z
+?do_scan_is@?$ctype@G@std@@MBEPBGFPBG0@Z
+?do_scan_is@?$ctype@_W@std@@MBEPB_WFPB_W0@Z
+?do_scan_not@?$ctype@G@std@@MBEPBGFPBG0@Z
+?do_scan_not@?$ctype@_W@std@@MBEPB_WFPB_W0@Z
+?do_tolower@?$ctype@D@std@@MBEDD@Z
+?do_tolower@?$ctype@D@std@@MBEPBDPADPBD@Z
+?do_tolower@?$ctype@G@std@@MBEGG@Z
+?do_tolower@?$ctype@G@std@@MBEPBGPAGPBG@Z
+?do_tolower@?$ctype@_W@std@@MBEPB_WPA_WPB_W@Z
+?do_tolower@?$ctype@_W@std@@MBE_W_W@Z
+?do_toupper@?$ctype@D@std@@MBEDD@Z
+?do_toupper@?$ctype@D@std@@MBEPBDPADPBD@Z
+?do_toupper@?$ctype@G@std@@MBEGG@Z
+?do_toupper@?$ctype@G@std@@MBEPBGPAGPBG@Z
+?do_toupper@?$ctype@_W@std@@MBEPB_WPA_WPB_W@Z
+?do_toupper@?$ctype@_W@std@@MBE_W_W@Z
+?do_unshift@?$codecvt@DDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_unshift@?$codecvt@GDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_unshift@?$codecvt@_SDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_unshift@?$codecvt@_UDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_unshift@?$codecvt@_WDU_Mbstatet@@@std@@MBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?do_widen@?$ctype@D@std@@MBEDD@Z
+?do_widen@?$ctype@D@std@@MBEPBDPBD0PAD@Z
+?do_widen@?$ctype@G@std@@MBEGD@Z
+?do_widen@?$ctype@G@std@@MBEPBDPBD0PAG@Z
+?do_widen@?$ctype@_W@std@@MBEPBDPBD0PA_W@Z
+?do_widen@?$ctype@_W@std@@MBE_WD@Z
+?eback@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?eback@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?eback@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?egptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?egptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?egptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?empty@?$_Yarn@D@std@@QBE_NXZ
+?empty@?$_Yarn@G@std@@QBE_NXZ
+?empty@?$_Yarn@_W@std@@QBE_NXZ
+?empty@locale@std@@SA?AV12@XZ
+?encoding@codecvt_base@std@@QBEHXZ
+?eof@ios_base@std@@QBE_NXZ
+?epptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?epptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?epptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?exceptions@ios_base@std@@QAEXH@Z
+?exceptions@ios_base@std@@QAEXI@Z
+?exceptions@ios_base@std@@QBEHXZ
+?fail@ios_base@std@@QBE_NXZ
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEDD@Z
+?fill@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDXZ
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEGG@Z
+?fill@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEGXZ
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE_W_W@Z
+?fill@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBE_WXZ
+?flags@ios_base@std@@QAEHH@Z
+?flags@ios_base@std@@QBEHXZ
+?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@XZ
+?flush@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@XZ
+?flush@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@XZ
+?gbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXH@Z
+?gbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXH@Z
+?gbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXH@Z
+?gcount@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_JXZ
+?gcount@?$basic_istream@GU?$char_traits@G@std@@@std@@QBE_JXZ
+?gcount@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QBE_JXZ
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@AAV?$basic_streambuf@DU?$char_traits@D@std@@@2@D@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_JD@Z
+?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@AAV?$basic_streambuf@GU?$char_traits@G@std@@@2@G@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_JG@Z
+?get@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEGXZ
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@AA_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J_W@Z
+?get@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?get@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?get@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAG@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAI@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAJ@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAK@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAM@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAN@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAO@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAAPAX@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_J@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_K@Z
+?get@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHAA_N@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?get@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBD4@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?get@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PBG4@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@DD@Z
+?get@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@PB_W4@Z
+?get_date@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_date@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_date@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_monthname@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_monthname@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_monthname@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_new_handler@std@@YAP6AXXZXZ
+?get_time@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_time@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_time@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_weekday@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_weekday@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_weekday@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_year@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@DU?$char_traits@D@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_year@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@GU?$char_traits@G@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?get_year@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@0AAVios_base@2@AAHPAUtm@@@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z
+?getline@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_JD@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z
+?getline@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_JG@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z
+?getline@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J_W@Z
+?getloc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QBE?AVlocale@2@XZ
+?getloc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QBE?AVlocale@2@XZ
+?getloc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QBE?AVlocale@2@XZ
+?getloc@ios_base@std@@QBE?AVlocale@2@XZ
+?global@locale@std@@SA?AV12@ABV12@@Z
+?good@ios_base@std@@QBE_NXZ
+?gptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?gptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?gptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?id@?$codecvt@DDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@GDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_WDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$collate@D@std@@2V0locale@2@A
+?id@?$collate@G@std@@2V0locale@2@A
+?id@?$collate@_W@std@@2V0locale@2@A
+?id@?$ctype@D@std@@2V0locale@2@A
+?id@?$ctype@G@std@@2V0locale@2@A
+?id@?$ctype@_W@std@@2V0locale@2@A
+?id@?$messages@D@std@@2V0locale@2@A
+?id@?$messages@G@std@@2V0locale@2@A
+?id@?$messages@_W@std@@2V0locale@2@A
+?id@?$money_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$money_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$moneypunct@D$00@std@@2V0locale@2@A
+?id@?$moneypunct@D$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@G$00@std@@2V0locale@2@A
+?id@?$moneypunct@G$0A@@std@@2V0locale@2@A
+?id@?$moneypunct@_W$00@std@@2V0locale@2@A
+?id@?$moneypunct@_W$0A@@std@@2V0locale@2@A
+?id@?$num_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$numpunct@D@std@@2V0locale@2@A
+?id@?$numpunct@G@std@@2V0locale@2@A
+?id@?$numpunct@_W@std@@2V0locale@2@A
+?id@?$time_get@DV?$istreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@GV?$istreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_get@_WV?$istreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@2V0locale@2@A
+?id@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@2V0locale@2@A
+?ignore@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z
+?ignore@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JG@Z
+?ignore@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JG@Z
+?imbue@?$basic_ios@DU?$char_traits@D@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?imbue@?$basic_ios@GU?$char_traits@G@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?imbue@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?imbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEXABVlocale@2@@Z
+?imbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEXABVlocale@2@@Z
+?imbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEXABVlocale@2@@Z
+?imbue@ios_base@std@@QAE?AVlocale@2@ABV32@@Z
+?in@?$codecvt@DDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPAD3AAPAD@Z
+?in@?$codecvt@GDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPAG3AAPAG@Z
+?in@?$codecvt@_SDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPA_S3AAPA_S@Z
+?in@?$codecvt@_UDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPA_U3AAPA_U@Z
+?in@?$codecvt@_WDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPA_W3AAPA_W@Z
+?in_avail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JXZ
+?in_avail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JXZ
+?in_avail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JXZ
+?init@?$basic_ios@DU?$char_traits@D@std@@@std@@IAEXPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@_N@Z
+?init@?$basic_ios@GU?$char_traits@G@std@@@std@@IAEXPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@_N@Z
+?init@?$basic_ios@_WU?$char_traits@_W@std@@@std@@IAEXPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@_N@Z
+?intl@?$moneypunct@D$00@std@@2_NB
+?intl@?$moneypunct@D$0A@@std@@2_NB
+?intl@?$moneypunct@G$00@std@@2_NB
+?intl@?$moneypunct@G$0A@@std@@2_NB
+?intl@?$moneypunct@_W$00@std@@2_NB
+?intl@?$moneypunct@_W$0A@@std@@2_NB
+?ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
+?ipfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_N_N@Z
+?ipfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_N_N@Z
+?is@?$ctype@D@std@@QBEPBDPBD0PAF@Z
+?is@?$ctype@D@std@@QBE_NFD@Z
+?is@?$ctype@G@std@@QBEPBGPBG0PAF@Z
+?is@?$ctype@G@std@@QBE_NFG@Z
+?is@?$ctype@_W@std@@QBEPB_WPB_W0PAF@Z
+?is@?$ctype@_W@std@@QBE_NF_W@Z
+?isfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEXXZ
+?isfx@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEXXZ
+?isfx@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+?iword@ios_base@std@@QAEAAJH@Z
+?length@?$codecvt@DDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?length@?$codecvt@GDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?length@?$codecvt@_SDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?length@?$codecvt@_UDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?length@?$codecvt@_WDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1I@Z
+?max_length@codecvt_base@std@@QBEHXZ
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEX$$QAV12@@Z
+?move@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXAAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEX$$QAV12@@Z
+?move@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXAAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEX$$QAV12@@Z
+?move@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXAAV12@@Z
+?narrow@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDDD@Z
+?narrow@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEDGD@Z
+?narrow@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBED_WD@Z
+?narrow@?$ctype@D@std@@QBEDDD@Z
+?narrow@?$ctype@D@std@@QBEPBDPBD0DPAD@Z
+?narrow@?$ctype@G@std@@QBEDGD@Z
+?narrow@?$ctype@G@std@@QBEPBGPBG0DPAD@Z
+?narrow@?$ctype@_W@std@@QBED_WD@Z
+?narrow@?$ctype@_W@std@@QBEPB_WPB_W0DPAD@Z
+?opfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE_NXZ
+?opfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE_NXZ
+?opfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE_NXZ
+?osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEXXZ
+?osfx@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEXXZ
+?osfx@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+?out@?$codecvt@DDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBD1AAPBDPAD3AAPAD@Z
+?out@?$codecvt@GDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PBG1AAPBGPAD3AAPAD@Z
+?out@?$codecvt@_SDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PB_S1AAPB_SPAD3AAPAD@Z
+?out@?$codecvt@_UDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PB_U1AAPB_UPAD3AAPAD@Z
+?out@?$codecvt@_WDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PB_W1AAPB_WPAD3AAPAD@Z
+?overflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHH@Z
+?overflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGG@Z
+?overflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGG@Z
+?pbackfail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHH@Z
+?pbackfail@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGG@Z
+?pbackfail@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGG@Z
+?pbase@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?pbase@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?pbase@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?pbump@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXH@Z
+?pbump@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXH@Z
+?pbump@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXH@Z
+?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
+?peek@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEGXZ
+?peek@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?pptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ
+?pptr@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IBEPAGXZ
+?pptr@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IBEPA_WXZ
+?precision@ios_base@std@@QAE_J_J@Z
+?precision@ios_base@std@@QBE_JXZ
+?pubimbue@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?pubimbue@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?pubimbue@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AVlocale@2@ABV32@@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?pubseekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@_JII@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?pubseekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@V32@I@Z
+?pubsetbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEPAV12@PAD_J@Z
+?pubsetbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEPAV12@PAG_J@Z
+?pubsetbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEPAV12@PA_W_J@Z
+?pubsync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?pubsync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEHXZ
+?pubsync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEHXZ
+?put@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@D@Z
+?put@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@G@Z
+?put@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_W@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DJ@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DK@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DN@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DO@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBX@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_J@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_K@Z
+?put@?$num_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@D_N@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GJ@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GK@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GN@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GO@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBX@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_J@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_K@Z
+?put@?$num_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@G_N@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WJ@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WK@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WN@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WO@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBX@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_J@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_K@Z
+?put@?$num_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_W_N@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@DD@Z
+?put@?$time_put@DV?$ostreambuf_iterator@DU?$char_traits@D@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@DU?$char_traits@D@std@@@2@V32@AAVios_base@2@DPBUtm@@PBD3@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@DD@Z
+?put@?$time_put@GV?$ostreambuf_iterator@GU?$char_traits@G@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@GU?$char_traits@G@std@@@2@V32@AAVios_base@2@GPBUtm@@PBG3@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@DD@Z
+?put@?$time_put@_WV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@std@@@std@@QBE?AV?$ostreambuf_iterator@_WU?$char_traits@_W@std@@@2@V32@AAVios_base@2@_WPBUtm@@PB_W4@Z
+?putback@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@D@Z
+?putback@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@G@Z
+?putback@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_W@Z
+?pword@ios_base@std@@QAEAAPAXH@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@PAV32@@Z
+?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@PAV32@@Z
+?rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@XZ
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@PAV32@@Z
+?rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBEPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@XZ
+?rdstate@ios_base@std@@QBEHXZ
+?read@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@PAD_J@Z
+?read@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@PAG_J@Z
+?read@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PA_W_J@Z
+?readsome@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_JPAD_J@Z
+?readsome@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE_JPAG_J@Z
+?readsome@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE_JPA_W_J@Z
+?register_callback@ios_base@std@@QAEXP6AXW4event@12@AAV12@H@ZH@Z
+?resetiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?sbumpc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ
+?sbumpc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?scan_is@?$ctype@D@std@@QBEPBDFPBD0@Z
+?scan_is@?$ctype@G@std@@QBEPBGFPBG0@Z
+?scan_is@?$ctype@_W@std@@QBEPB_WFPB_W0@Z
+?scan_not@?$ctype@D@std@@QBEPBDFPBD0@Z
+?scan_not@?$ctype@G@std@@QBEPBGFPBG0@Z
+?scan_not@?$ctype@_W@std@@QBEPB_WFPB_W0@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JH@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JH@Z
+?seekoff@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekoff@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@_JHH@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@_JH@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@_JH@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@V?$fpos@U_Mbstatet@@@2@@Z
+?seekp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@_JH@Z
+?seekpos@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?seekpos@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE?AV?$fpos@U_Mbstatet@@@2@V32@H@Z
+?set_new_handler@std@@YAP6AXXZP6AXXZ@Z
+?set_rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@@Z
+?set_rdbuf@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXPAV?$basic_streambuf@GU?$char_traits@G@std@@@2@@Z
+?set_rdbuf@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXPAV?$basic_streambuf@_WU?$char_traits@_W@std@@@2@@Z
+?setbase@std@@YA?AU?$_Smanip@H@1@H@Z
+?setbuf@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEPAV12@PAD_J@Z
+?setbuf@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEPAV12@PAG_J@Z
+?setbuf@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEPAV12@PA_W_J@Z
+?setf@ios_base@std@@QAEHH@Z
+?setf@ios_base@std@@QAEHHH@Z
+?setg@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD00@Z
+?setg@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG00@Z
+?setg@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W00@Z
+?setiosflags@std@@YA?AU?$_Smanip@H@1@H@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD00@Z
+?setp@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXPAD0@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG00@Z
+?setp@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXPAG0@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W00@Z
+?setp@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXPA_W0@Z
+?setprecision@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z
+?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXI@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXH_N@Z
+?setstate@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXI@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXH_N@Z
+?setstate@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXI@Z
+?setstate@ios_base@std@@QAEXH@Z
+?setstate@ios_base@std@@QAEXH_N@Z
+?setstate@ios_base@std@@QAEXI@Z
+?setw@std@@YA?AU?$_Smanip@_J@1@_J@Z
+?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?sgetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ
+?sgetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?sgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JPAD_J@Z
+?sgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JPAG_J@Z
+?sgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JPA_W_J@Z
+?showmanyc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JXZ
+?showmanyc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JXZ
+?showmanyc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JXZ
+?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?snextc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ
+?snextc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?sputbackc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHD@Z
+?sputbackc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGG@Z
+?sputbackc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEG_W@Z
+?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHD@Z
+?sputc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGG@Z
+?sputc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEG_W@Z
+?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAE_JPBD_J@Z
+?sputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAE_JPBG_J@Z
+?sputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAE_JPB_W_J@Z
+?stossc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEXXZ
+?stossc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEXXZ
+?stossc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEXXZ
+?sungetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
+?sungetc@?$basic_streambuf@GU?$char_traits@G@std@@@std@@QAEGXZ
+?sungetc@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@QAEGXZ
+?swap@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXAAV12@@Z
+?swap@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEXAAV12@@Z
+?swap@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEXAAV12@@Z
+?swap@?$basic_iostream@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_iostream@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_iostream@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_istream@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_istream@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_istream@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_ostream@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_ostream@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_streambuf@GU?$char_traits@G@std@@@std@@IAEXAAV12@@Z
+?swap@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@IAEXAAV12@@Z
+?swap@ios_base@std@@QAEXAAV12@@Z
+?sync@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
+?sync@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEHXZ
+?sync@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEHXZ
+?sync@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ
+?sync@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEHXZ
+?sync@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEHXZ
+?sync_with_stdio@ios_base@std@@SA_N_N@Z
+?table@?$ctype@D@std@@QBEPBFXZ
+?table_size@?$ctype@D@std@@2IB
+?tellg@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellg@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tellp@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAE?AV?$fpos@U_Mbstatet@@@2@XZ
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEPAV?$basic_ostream@DU?$char_traits@D@std@@@2@PAV32@@Z
+?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QAEPAV?$basic_ostream@GU?$char_traits@G@std@@@2@PAV32@@Z
+?tie@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEPAV?$basic_ostream@GU?$char_traits@G@std@@@2@XZ
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QAEPAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@PAV32@@Z
+?tie@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBEPAV?$basic_ostream@_WU?$char_traits@_W@std@@@2@XZ
+?tolower@?$ctype@D@std@@QBEDD@Z
+?tolower@?$ctype@D@std@@QBEPBDPADPBD@Z
+?tolower@?$ctype@G@std@@QBEGG@Z
+?tolower@?$ctype@G@std@@QBEPBGPAGPBG@Z
+?tolower@?$ctype@_W@std@@QBEPB_WPA_WPB_W@Z
+?tolower@?$ctype@_W@std@@QBE_W_W@Z
+?toupper@?$ctype@D@std@@QBEDD@Z
+?toupper@?$ctype@D@std@@QBEPBDPADPBD@Z
+?toupper@?$ctype@G@std@@QBEGG@Z
+?toupper@?$ctype@G@std@@QBEPBGPAGPBG@Z
+?toupper@?$ctype@_W@std@@QBEPB_WPA_WPB_W@Z
+?toupper@?$ctype@_W@std@@QBE_W_W@Z
+?uflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ
+?uflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGXZ
+?uflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGXZ
+?uncaught_exception@std@@YA_NXZ
+?uncaught_exceptions@std@@YAHXZ
+?underflow@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAEHXZ
+?underflow@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAEGXZ
+?underflow@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAEGXZ
+?unget@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEAAV12@XZ
+?unget@?$basic_istream@GU?$char_traits@G@std@@@std@@QAEAAV12@XZ
+?unget@?$basic_istream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@XZ
+?unsetf@ios_base@std@@QAEXH@Z
+?unshift@?$codecvt@DDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?unshift@?$codecvt@GDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?unshift@?$codecvt@_SDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?unshift@?$codecvt@_UDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?unshift@?$codecvt@_WDU_Mbstatet@@@std@@QBEHAAU_Mbstatet@@PAD1AAPAD@Z
+?wcerr@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcerr@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcin@std@@3V?$basic_istream@GU?$char_traits@G@std@@@1@A
+?wcin@std@@3V?$basic_istream@_WU?$char_traits@_W@std@@@1@A
+?wclog@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wclog@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?wcout@std@@3V?$basic_ostream@GU?$char_traits@G@std@@@1@A
+?wcout@std@@3V?$basic_ostream@_WU?$char_traits@_W@std@@@1@A
+?widen@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEDD@Z
+?widen@?$basic_ios@GU?$char_traits@G@std@@@std@@QBEGD@Z
+?widen@?$basic_ios@_WU?$char_traits@_W@std@@@std@@QBE_WD@Z
+?widen@?$ctype@D@std@@QBEDD@Z
+?widen@?$ctype@D@std@@QBEPBDPBD0PAD@Z
+?widen@?$ctype@G@std@@QBEGD@Z
+?widen@?$ctype@G@std@@QBEPBDPBD0PAG@Z
+?widen@?$ctype@_W@std@@QBEPBDPBD0PA_W@Z
+?widen@?$ctype@_W@std@@QBE_WD@Z
+?width@ios_base@std@@QAE_J_J@Z
+?width@ios_base@std@@QBE_JXZ
+?write@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@PBD_J@Z
+?write@?$basic_ostream@GU?$char_traits@G@std@@@std@@QAEAAV12@PBG_J@Z
+?write@?$basic_ostream@_WU?$char_traits@_W@std@@@std@@QAEAAV12@PB_W_J@Z
+?xalloc@ios_base@std@@SAHXZ
+?xsgetn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JPAD_J@Z
+?xsgetn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JPAG_J@Z
+?xsgetn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JPA_W_J@Z
+?xsputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@MAE_JPBD_J@Z
+?xsputn@?$basic_streambuf@GU?$char_traits@G@std@@@std@@MAE_JPBG_J@Z
+?xsputn@?$basic_streambuf@_WU?$char_traits@_W@std@@@std@@MAE_JPB_W_J@Z
+_Chmod
+_Close_dir
+_Cnd_broadcast
+_Cnd_destroy
+_Cnd_destroy_in_situ
+_Cnd_do_broadcast_at_thread_exit
+_Cnd_init
+_Cnd_init_in_situ
+_Cnd_register_at_thread_exit
+_Cnd_signal
+_Cnd_timedwait
+_Cnd_unregister_at_thread_exit
+_Cnd_wait
+_Copy_file
+_Cosh
+_Current_get
+_Current_set
+_Denorm
+_Dtest
+_Equivalent
+_Exp
+_FCosh
+_FDenorm
+_FDtest
+_FExp
+_FInf
+_FNan
+_FSinh
+_FSnan
+_File_size
+_Getcoll
+_Getctype
+_Getcvt
+_Getdateorder
+_Getwctype
+_Getwctypes
+_Hard_links
+_Hugeval
+_Inf
+_LCosh
+_LDenorm
+_LDtest
+_LExp
+_LInf
+_LNan
+_LSinh
+_LSnan
+_Last_write_time
+_Link
+_Lock_shared_ptr_spin_lock
+_Lstat
+_Make_dir
+_Mbrtowc
+_Mtx_clear_owner
+_Mtx_current_owns
+_Mtx_destroy
+_Mtx_destroy_in_situ
+_Mtx_getconcrtcs
+_Mtx_init
+_Mtx_init_in_situ
+_Mtx_lock
+_Mtx_reset_owner
+_Mtx_timedlock
+_Mtx_trylock
+_Mtx_unlock
+_Mtxdst
+_Mtxinit
+_Mtxlock
+_Mtxunlock
+_Nan
+_Open_dir
+_Query_perf_counter
+_Query_perf_frequency
+_Read_dir
+_Remove_dir
+_Rename
+_Resize
+_Set_last_write_time
+_Sinh
+_Snan
+_Stat
+_Statvfs
+_Stod
+_Stodx
+_Stof
+_Stofx
+_Stold
+_Stoldx
+_Stoll
+_Stollx
+_Stolx
+_Stoul
+_Stoull
+_Stoullx
+_Stoulx
+_Strcoll
+_Strxfrm
+_Symlink
+_Symlink_get
+_Temp_get
+_Thrd_abort
+_Thrd_create
+_Thrd_current
+_Thrd_detach
+_Thrd_equal
+_Thrd_exit
+_Thrd_hardware_concurrency
+_Thrd_id
+_Thrd_join
+_Thrd_sleep
+_Thrd_start
+_Thrd_yield
+_To_byte
+_To_wide
+_Tolower
+_Toupper
+_Towlower
+_Towupper
+_Unlink
+_Unlock_shared_ptr_spin_lock
+_WStod
+_WStodx
+_WStof
+_WStofx
+_WStold
+_WStoldx
+_Wcrtomb
+_Wcscoll
+_Wcsxfrm
+_Xtime_diff_to_millis
+_Xtime_diff_to_millis2
+_Xtime_get_ticks
+__Wcrtomb_lk
+__crtCompareStringA
+__crtCompareStringW
+__crtIsPackagedApp
+__crtLCMapStringA
+__crtLCMapStringW
+__set_stl_sync_api_mode
+xtime_get
diff --git a/msvc-stl/stl/msbuild/stl_base/libcp.settings.targets b/msvc-stl/stl/msbuild/stl_base/libcp.settings.targets
new file mode 100644
index 0000000..6a9ba43
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/libcp.settings.targets
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <PropertyGroup Label="Configuration">
+        <ConfigurationType>StaticLibrary</ConfigurationType>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <FinalBinary>p</FinalBinary>
+        <TargetAppFamily Condition="'$(MsvcpFlavor)' == 'app'">true</TargetAppFamily>
+        <TargetCoreSystem Condition="'$(MsvcpFlavor)' == 'onecore'">true</TargetCoreSystem>
+        <Arm64CombinedPdb>true</Arm64CombinedPdb>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt_build.settings.targets"/>
+
+    <PropertyGroup>
+        <OutputName Condition="'$(CrtBuildModel)' == 'mt'">libcpmt</OutputName>
+        <OutputName Condition="'$(CrtBuildModel)' == 'mt1'">libcpmt1</OutputName>
+        <OutputName Condition="'$(CrtBuildModel)' == 'xmt'">libcpmtd</OutputName>
+        <OutputName Condition="'$(CrtBuildModel)' == 'xmt0'">libcpmtd0</OutputName>
+        <OutputName Condition="'$(CrtBuildModel)' == 'xmt1'">libcpmtd1</OutputName>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <ClProgramDataBaseFileName>$(OutputLibPdbPath)$(OutputName)$(PdbVerName).pdb</ClProgramDataBaseFileName>
+        <ClDefines>$(ClDefines);_ANNOTATE_STL</ClDefines>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)\stl.files.settings.targets"/>
+
+    <Import Project="$(VCToolsRootPath)\crt\crt_build.targets"/>
+    <Target Name="GetBaseAddress"/>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/md/dirs.proj b/msvc-stl/stl/msbuild/stl_base/md/dirs.proj
new file mode 100644
index 0000000..d43e6ca
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/md/dirs.proj
@@ -0,0 +1,17 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_base_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_base_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_base_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_base_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_app.vcxproj b/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_app.vcxproj
new file mode 100644
index 0000000..32c987d
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{26CFD97A-BD12-4347-ACEA-3B13904E59DA}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_kernel32.vcxproj
new file mode 100644
index 0000000..53af00c
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{00EE32E2-A705-4D07-A967-60092E13F497}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_netfx.vcxproj
new file mode 100644
index 0000000..f7542a6
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{98CE2EB2-F428-4C28-9186-8D614658A1BE}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_onecore.vcxproj
new file mode 100644
index 0000000..7b2ce92
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/md/msvcp_base_md_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3318F9FE-FD4A-4D16-82F6-7DBC8007D1B6}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/msvcp.settings.targets b/msvc-stl/stl/msbuild/stl_base/msvcp.settings.targets
new file mode 100644
index 0000000..dcfdb09
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/msvcp.settings.targets
@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <PropertyGroup Label="Configuration">
+        <ConfigurationType>DynamicLibrary</ConfigurationType>
+        <GenerateImportLib>true</GenerateImportLib>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <FinalBinary>p</FinalBinary>
+
+        <DependsOnVCStartupLib>$(MsvcpFlavor)</DependsOnVCStartupLib>
+        <DependsOnVCRuntimeLib>$(MsvcpFlavor)</DependsOnVCRuntimeLib>
+
+        <TargetAppFamily Condition="'$(MsvcpFlavor)' == 'app'">true</TargetAppFamily>
+        <TargetCoreSystem Condition="'$(MsvcpFlavor)' == 'onecore'">true</TargetCoreSystem>
+        <TargetNetFx Condition="'$(MsvcpFlavor)' == 'netfx'">true</TargetNetFx>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt_build.settings.targets"/>
+
+    <PropertyGroup>
+        <ClrLibSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr</ClrLibSuffix>
+
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'app'">_app</MsvcpFlavorSuffix>
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr$(NetFxVerX)</MsvcpFlavorSuffix>
+
+        <OutputName>msvcp$(VCToolsProdVerSuffix)$(BuildSuffix)$(MsvcpFlavorSuffix)</OutputName>
+        <LibOutputFileName>msvcprt_base$(BuildSuffix)$(ClrLibSuffix)</LibOutputFileName>
+        <LibOutputFile>$(LibOutputFileName).lib</LibOutputFile>
+
+        <ClDefines Condition="'$(MsvcpFlavor)' == 'app'">$(ClDefines);_CRT_APP</ClDefines>
+
+        <UseMsvcrt>false</UseMsvcrt>
+        <RCIntermediateOutputDirectory>$(IntermediateOutputDirectory)</RCIntermediateOutputDirectory>
+        <IntermediateImportLibOutput>$(CrtBuildDir)\msvcprt_base$(BuildSuffix).$(MsvcpFlavor).import_only.lib</IntermediateImportLibOutput>
+        <DllDefName>$(LibOutputFileName).$(MsvcpFlavor)</DllDefName>
+        <DllDef>$(IntermediateOutputDirectory)\$(DllDefName).def</DllDef>
+
+        <LinkGenerateDebugInformation>true</LinkGenerateDebugInformation>
+        <LinkProgramDataBaseFileName>$(OutputPath)\$(OutputName)$(_PDB_VER_NAME_)$(DllPdbFlavorSuffix)</LinkProgramDataBaseFileName>
+        <LinkProgramDataBaseFileName Condition="'$(BuildArchitecture)' =='arm64ec' and '$(Platform)' != '$(BuildArchitecture)'">$(OutputPath)\$(OutputName).arm64$(DllPdbFlavorSuffix)</LinkProgramDataBaseFileName>
+
+        <LinkAdditionalOptions>-debugtype:cv,fixup $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) != 'true'">-opt:ref,icf=3 $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) == 'true'">-opt:ref,noicf $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:libcpmt$(BuildSuffix).lib $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:$(LibOutputFile) $(LinkAdditionalOptions)</LinkAdditionalOptions>
+
+        <LinkGenerateMapFile>true</LinkGenerateMapFile>
+        <LinkRelease>true</LinkRelease>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <CppPreprocess Include="$(CrtRoot)\crtw32\msvcprt.src">
+            <Defines>LIBRARYNAME=$(OutputName.ToUpper());$(DllCppDefines)</Defines>
+        </CppPreprocess>
+        <DefFromI Include="$(IntermediateOutputDirectory)\msvcprt.i">
+            <DestFolder1>$(IntermediateOutputDirectory)</DestFolder1>
+            <DestFolder2>$(IntermediateOutputDirectory)</DestFolder2>
+            <DestFile>$(DllDefName)</DestFile>
+        </DefFromI>
+        <ResourceCompile Include="$(CrtRoot)\crtw32\msvcprt.rc"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(UniversalCRTLib)"/>
+        <TargetLib Condition="'$(BuildArchitecture)' == 'arm64' or '$(BuildArchitecture)' == 'arm64ec'" Include="$(SdkLibPath)\softintrin.lib"/>
+    </ItemGroup>
+
+    <!-- Copy the output dll and pdb to various destinations -->
+    <ItemGroup>
+        <CopyFilesForCrossTools Condition="'$(MsvcpFlavor)' == 'kernel32'" Include="
+           $(LinkOutputFile);
+           $(LinkProgramDataBaseFileName);
+        "/>
+    </ItemGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)\stl.files.settings.targets"/>
+
+    <Import Project="$(VCToolsRootPath)\crt\crt_build.targets"/>
+    <Target Name="GetBaseAddress"/>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/mt/dirs.proj b/msvc-stl/stl/msbuild/stl_base/mt/dirs.proj
new file mode 100644
index 0000000..cbdcba1
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/mt/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="libcpmt_mt_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_mt_onecore.vcxproj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/mt/libcpmt_mt_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_base/mt/libcpmt_mt_kernel32.vcxproj
new file mode 100644
index 0000000..1a207d7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/mt/libcpmt_mt_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B56C39F9-89BF-486F-9C5E-B88FD82E2AA7}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>mt</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/mt/libcpmt_mt_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_base/mt/libcpmt_mt_onecore.vcxproj
new file mode 100644
index 0000000..475cf4a
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/mt/libcpmt_mt_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{5F515BBF-E680-4553-B38E-0C125D2A6455}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>mt</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/mt1/dirs.proj b/msvc-stl/stl/msbuild/stl_base/mt1/dirs.proj
new file mode 100644
index 0000000..bb5db98
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/mt1/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="libcpmt_mt1_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_mt1_onecore.vcxproj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/mt1/libcpmt_mt1_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_base/mt1/libcpmt_mt1_kernel32.vcxproj
new file mode 100644
index 0000000..4672db3
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/mt1/libcpmt_mt1_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{027B5024-5996-4645-BC46-8FEF2E2A4E71}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>mt1</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/mt1/libcpmt_mt1_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_base/mt1/libcpmt_mt1_onecore.vcxproj
new file mode 100644
index 0000000..c338744
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/mt1/libcpmt_mt1_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{0824A200-D996-41C0-87D8-62CF1D7483C6}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>mt1</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/stl.files.settings.targets b/msvc-stl/stl/msbuild/stl_base/stl.files.settings.targets
new file mode 100644
index 0000000..f4a9a13
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/stl.files.settings.targets
@@ -0,0 +1,196 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <ItemGroup>
+        <!-- Objs that exist only in libcpmt[d][01].lib. -->
+        <ClCompile Include="
+            $(CrtRoot)\github\stl\src\atomic_wait.cpp;
+            $(CrtRoot)\github\stl\src\memory_resource.cpp;
+            $(CrtRoot)\github\stl\src\parallel_algorithms.cpp;
+            $(CrtRoot)\github\stl\src\special_math.cpp;
+            $(CrtRoot)\github\stl\src\syncstream.cpp;
+            $(CrtRoot)\github\stl\src\tzdb.cpp;
+            $(CrtRoot)\github\stl\src\ulocale.cpp;
+            ">
+            <LinkCompiled>false</LinkCompiled>
+            <LibCompiled>true</LibCompiled>
+            <ImpLibCompiled>false</ImpLibCompiled>
+        </ClCompile>
+
+        <ClCompile Include="$(CrtRoot)\github\stl\src\excptptr.cpp;">
+          <ExceptionHandling>async</ExceptionHandling>
+        </ClCompile>
+
+        <ClCompile Include="$(CrtRoot)\github\stl\src\StlCompareStringA.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\StlCompareStringW.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\StlLCMapStringA.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\StlLCMapStringW.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\winapinls.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\_tolower.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\_toupper.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\atomic.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\cerr.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\cin.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\clog.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\cout.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\filesys.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\fiopen.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\future.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\iomanip.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\ios.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\iosptrs.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\iostream.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\locale.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\locale0.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\multprec.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\raisehan.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\stdhndlr.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\stdthrow.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\syserror.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\cond.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\cthread.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\mutex.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\pplerror.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\ppltasks.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\taskscheduler.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xnotify.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xtime.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\thread0.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\uncaught_exception.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\uncaught_exceptions.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\ushcerr.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\ushcin.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\ushclog.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\ushcout.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\ushiostr.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\wcerr.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\wcin.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\wclog.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\wcout.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\wiostrea.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\wlocale.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xalloc.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xcosh.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xdateord.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xdtest.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xexp.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xgetwctype.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xlgamma.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xlocale.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xlock.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xmbtowc.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xmtx.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xonce.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xrngabort.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xrngdev.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xsinh.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xstod.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xstof.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xstol.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xstoll.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xstoul.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xstoull.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xstrcoll.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xstrxfrm.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xthrow.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xtowlower.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xtowupper.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xvalues.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xwcscoll.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xwcsxfrm.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xwctomb.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xwstod.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\xwstof.cpp" />
+
+        <ClCompile Include="$(CrtRoot)\github\stl\src\winapisupp.cpp">
+            <HasCrtInitializers>true</HasCrtInitializers>
+        </ClCompile>
+
+        <!-- Objs that exist in both libcpmt[d][01].lib and msvcprt[d].lib
+             (controlled by ExtraImpLibCompiled). -->
+        <ClCompile Include="
+            $(CrtRoot)\github\stl\src\asan_noop.cpp;
+            $(CrtRoot)\github\stl\src\charconv.cpp;
+            $(CrtRoot)\github\stl\src\filesystem.cpp;
+            $(CrtRoot)\github\stl\src\format.cpp;
+            $(CrtRoot)\github\stl\src\locale0_implib.cpp;
+            $(CrtRoot)\github\stl\src\nothrow.cpp;
+            $(CrtRoot)\github\stl\src\print.cpp;
+            $(CrtRoot)\github\stl\src\regex.cpp;
+            $(CrtRoot)\github\stl\src\sharedmutex.cpp;
+            $(CrtRoot)\github\stl\src\stacktrace.cpp;
+            $(CrtRoot)\github\stl\src\syserror_import_lib.cpp;
+            $(CrtRoot)\github\stl\src\vector_algorithms.cpp;
+            $(CrtRoot)\github\stl\src\xcharconv_ryu_tables.cpp;
+            $(CrtRoot)\github\stl\src\xcharconv_tables_double.cpp;
+            $(CrtRoot)\github\stl\src\xcharconv_tables_float.cpp;
+            $(CrtRoot)\github\stl\src\xonce2.cpp;
+            ">
+            <ExtraImpLibCompiled>true</ExtraImpLibCompiled>
+            <PreprocessorDefinitions>$(ClDefines);_ENFORCE_ONLY_CORE_HEADERS</PreprocessorDefinitions>
+        </ClCompile>
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(BuildArchitecture)' == 'i386' or '$(BuildArchitecture)' == 'amd64'">
+        <!-- Objs that exist in both libcpmt[d][01].lib and msvcprt[d].lib
+             (controlled by ExtraImpLibCompiled). -->
+        <BuildFiles Include="
+            $(CrtRoot)\github\stl\src\alias_init_once_begin_initialize.asm;
+            $(CrtRoot)\github\stl\src\alias_init_once_complete.asm;
+            ">
+            <BuildAs>asm</BuildAs>
+            <ExtraImpLibCompiled>true</ExtraImpLibCompiled>
+        </BuildFiles>
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(CrtBuildModelIsDll)' == 'true'">
+        <!-- The following files are linked in msvcpXXX[d][_clr].dll. -->
+        <ClCompile Include="$(CrtRoot)\github\stl\src\dllmain.cpp" />
+        <ClCompile Include="$(CrtRoot)\github\stl\src\instances.cpp" />
+    </ItemGroup>
+
+    <Choose>
+      <When Condition="'$(CrtBuildModel)' != 'md'">
+        <!-- Only check exports of release, DLL, builds -->
+      </When>
+
+      <When Condition="'$(BuildArchitecture)' == 'i386' or '$(BuildArchitecture)' == 'chpe'">
+        <Choose>
+          <When Condition="'$(MsvcpFlavor)' == 'kernel32' or '$(MsvcpFlavor)' == 'netfx'">
+            <PropertyGroup>
+              <ExpectedExportsList>$(MSBuildThisFileDirectory)\i386.exports</ExpectedExportsList>
+            </PropertyGroup>
+          </When>
+          <Otherwise>
+            <PropertyGroup>
+              <ExpectedExportsList>$(MSBuildThisFileDirectory)\i386_onecore.exports</ExpectedExportsList>
+            </PropertyGroup>
+          </Otherwise>
+        </Choose>
+      </When>
+      <When Condition="'$(BuildArchitecture)' == 'amd64' or '$(BuildArchitecture)' == 'arm64ec'">
+        <Choose>
+          <When Condition="'$(MsvcpFlavor)' == 'kernel32' or '$(MsvcpFlavor)' == 'netfx'">
+            <PropertyGroup>
+              <ExpectedExportsList>$(MSBuildThisFileDirectory)\amd64.exports</ExpectedExportsList>
+            </PropertyGroup>
+          </When>
+          <Otherwise>
+            <PropertyGroup>
+              <ExpectedExportsList>$(MSBuildThisFileDirectory)\amd64_onecore.exports</ExpectedExportsList>
+            </PropertyGroup>
+          </Otherwise>
+        </Choose>
+      </When>
+      <When Condition="'$(BuildArchitecture)' == 'arm64'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\arm64.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+    </Choose>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmd/dirs.proj b/msvc-stl/stl/msbuild/stl_base/xmd/dirs.proj
new file mode 100644
index 0000000..1f5c0a0
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmd/dirs.proj
@@ -0,0 +1,20 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_base_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_base_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_base_xmd_onecore.vcxproj" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
+        <ProjectFile Include="msvcp_base_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_app.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_app.vcxproj
new file mode 100644
index 0000000..fda7e64
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3DFFE995-1592-4D71-A088-65B5E90829E3}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_kernel32.vcxproj
new file mode 100644
index 0000000..a3164b7
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{19B72B03-37A8-4ED7-85D9-26031335269E}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_netfx.vcxproj
new file mode 100644
index 0000000..1bd8372
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9E0C069E-C345-4977-9753-16CEE50029D8}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_onecore.vcxproj
new file mode 100644
index 0000000..a906cda
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmd/msvcp_base_xmd_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{617D60ED-BAB2-45FA-8FAF-B0E7F9304403}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt/dirs.proj b/msvc-stl/stl/msbuild/stl_base/xmt/dirs.proj
new file mode 100644
index 0000000..b59f092
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="libcpmt_xmt_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_xmt_onecore.vcxproj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt/libcpmt_xmt_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmt/libcpmt_xmt_kernel32.vcxproj
new file mode 100644
index 0000000..a3ff7bd
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt/libcpmt_xmt_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{ECA62467-8F67-4F70-953D-0916472878AA}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmt</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt/libcpmt_xmt_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmt/libcpmt_xmt_onecore.vcxproj
new file mode 100644
index 0000000..d3be808
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt/libcpmt_xmt_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{02DA6861-AC66-4EA6-B558-9D0E0F1073A8}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmt</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt0/dirs.proj b/msvc-stl/stl/msbuild/stl_base/xmt0/dirs.proj
new file mode 100644
index 0000000..61bdba1
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt0/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="libcpmt_xmt0_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_xmt0_onecore.vcxproj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt0/libcpmt_xmt0_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmt0/libcpmt_xmt0_kernel32.vcxproj
new file mode 100644
index 0000000..07abf59
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt0/libcpmt_xmt0_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C9715C5F-41D3-472B-AC8D-4E374105FD6B}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmt0</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt0/libcpmt_xmt0_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmt0/libcpmt_xmt0_onecore.vcxproj
new file mode 100644
index 0000000..fd3105c
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt0/libcpmt_xmt0_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{5B4429AE-5436-4C16-A6D6-998D76182CF1}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmt0</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt1/dirs.proj b/msvc-stl/stl/msbuild/stl_base/xmt1/dirs.proj
new file mode 100644
index 0000000..8dd8f99
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt1/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="libcpmt_xmt1_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_xmt1_onecore.vcxproj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt1/libcpmt_xmt1_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmt1/libcpmt_xmt1_kernel32.vcxproj
new file mode 100644
index 0000000..69dd482
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt1/libcpmt_xmt1_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C5C4581F-36C6-4327-BB54-6C1DFF52A60F}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmt1</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_base/xmt1/libcpmt_xmt1_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_base/xmt1/libcpmt_xmt1_onecore.vcxproj
new file mode 100644
index 0000000..a80e3a3
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_base/xmt1/libcpmt_xmt1_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{4B156573-7D78-4FDA-B365-320A91AE8916}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmt1</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(libcp.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/amd64.exports b/msvc-stl/stl/msbuild/stl_codecvt_ids/amd64.exports
new file mode 100644
index 0000000..6baaf2e
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/amd64.exports
@@ -0,0 +1,4 @@
+?id@?$codecvt@_SDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_UDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_S_QU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_U_QU_Mbstatet@@@std@@2V0locale@2@A
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/arm64.exports b/msvc-stl/stl/msbuild/stl_codecvt_ids/arm64.exports
new file mode 100644
index 0000000..6baaf2e
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/arm64.exports
@@ -0,0 +1,4 @@
+?id@?$codecvt@_SDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_UDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_S_QU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_U_QU_Mbstatet@@@std@@2V0locale@2@A
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/dirs.proj b/msvc-stl/stl/msbuild/stl_codecvt_ids/dirs.proj
new file mode 100644
index 0000000..e177b7c
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Condition="'$(CrtBuildMD)'  != 'false'" Include="md\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/i386.exports b/msvc-stl/stl/msbuild/stl_codecvt_ids/i386.exports
new file mode 100644
index 0000000..6baaf2e
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/i386.exports
@@ -0,0 +1,4 @@
+?id@?$codecvt@_SDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_UDU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_S_QU_Mbstatet@@@std@@2V0locale@2@A
+?id@?$codecvt@_U_QU_Mbstatet@@@std@@2V0locale@2@A
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/md/dirs.proj b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/dirs.proj
new file mode 100644
index 0000000..de1bf9f
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/dirs.proj
@@ -0,0 +1,17 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_codecvt_ids_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_app.vcxproj b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_app.vcxproj
new file mode 100644
index 0000000..1d1567b
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{CD1E3105-704A-4D91-B49A-4D6E96546ED5}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_codecvt_ids.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_kernel32.vcxproj
new file mode 100644
index 0000000..a0e59af
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{ED7C0741-B3D2-4EAD-AA7E-BDF1B0948ECC}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_codecvt_ids.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_netfx.vcxproj
new file mode 100644
index 0000000..c3e6003
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{5F6F2FF5-EFED-4CF7-8F44-810DB15F32CD}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_codecvt_ids.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_onecore.vcxproj
new file mode 100644
index 0000000..a6cdadf
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{32352E48-0D6E-4BCA-935A-76DAFDD4239D}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_codecvt_ids.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcp_codecvt_ids.settings.targets b/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcp_codecvt_ids.settings.targets
new file mode 100644
index 0000000..5146d0d
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcp_codecvt_ids.settings.targets
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <PropertyGroup Label="Configuration">
+        <ConfigurationType>DynamicLibrary</ConfigurationType>
+        <GenerateImportLib>true</GenerateImportLib>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <FinalBinary>p_codecvt_ids</FinalBinary>
+
+        <TargetAppFamily Condition="'$(MsvcpFlavor)' == 'app'">true</TargetAppFamily>
+        <TargetCoreSystem Condition="'$(MsvcpFlavor)' == 'onecore'">true</TargetCoreSystem>
+        <TargetNetFx Condition="'$(MsvcpFlavor)' == 'netfx'">true</TargetNetFx>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt_build.settings.targets"/>
+
+    <PropertyGroup>
+        <ClrLibSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr</ClrLibSuffix>
+
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'app'">_app</MsvcpFlavorSuffix>
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr$(NetFxVerX)</MsvcpFlavorSuffix>
+
+        <OutputName>msvcp$(VCToolsProdVerSuffix)$(BuildSuffix)_codecvt_ids$(MsvcpFlavorSuffix)</OutputName>
+        <LibOutputFileName>msvcprt$(BuildSuffix)_codecvt_ids$(ClrLibSuffix)</LibOutputFileName>
+        <LibOutputFile>$(LibOutputFileName).lib</LibOutputFile>
+
+        <ClDefines Condition="'$(MsvcpFlavor)' == 'app'">$(ClDefines);_CRT_APP</ClDefines>
+
+        <UseMsvcrt>false</UseMsvcrt>
+        <RCIntermediateOutputDirectory>$(IntermediateOutputDirectory)</RCIntermediateOutputDirectory>
+        <IntermediateImportLibOutput>$(CrtBuildDir)\msvcprt$(BuildSuffix)_codecvt_ids.$(MsvcpFlavor).import_only.lib</IntermediateImportLibOutput>
+        <DllDefName>$(LibOutputFileName).$(MsvcpFlavor)</DllDefName>
+        <DllDef>$(IntermediateOutputDirectory)\$(DllDefName).def</DllDef>
+
+        <LinkGenerateDebugInformation>true</LinkGenerateDebugInformation>
+        <LinkProgramDataBaseFileName>$(OutputPath)\$(OutputName)$(_PDB_VER_NAME_)$(DllPdbFlavorSuffix)</LinkProgramDataBaseFileName>
+
+        <LinkAdditionalOptions>-debugtype:cv,fixup $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) != 'true'">-opt:ref,icf=3 $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) == 'true'">-opt:ref,noicf $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:libcpmt$(BuildSuffix).lib $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:$(LibOutputFile) $(LinkAdditionalOptions)</LinkAdditionalOptions>
+
+        <LinkGenerateMapFile>true</LinkGenerateMapFile>
+        <LinkRelease>true</LinkRelease>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <CppPreprocess Include="$(MSBuildThisFileDirectory)\msvcprt_codecvt_ids.src">
+            <Defines>LIBRARYNAME=$(OutputName.ToUpper());$(DllCppDefines)</Defines>
+        </CppPreprocess>
+        <DefFromI Include="$(IntermediateOutputDirectory)\msvcprt_codecvt_ids.i">
+            <DestFolder1>$(IntermediateOutputDirectory)</DestFolder1>
+            <DestFolder2>$(IntermediateOutputDirectory)</DestFolder2>
+            <DestFile>$(DllDefName)</DestFile>
+        </DefFromI>
+        <ResourceCompile Include="$(MSBuildThisFileDirectory)\msvcprt_codecvt_ids.rc"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <TargetLib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
+        <TargetLib Include="$(UniversalCRTLib)"/>
+    </ItemGroup>
+
+    <!-- Copy the output dll and pdb to various destinations -->
+    <ItemGroup>
+        <CopyFilesForCrossTools Condition="'$(MsvcpFlavor)' == 'kernel32'" Include="
+           $(LinkOutputFile);
+           $(LinkProgramDataBaseFileName);
+        "/>
+    </ItemGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)\stl_codecvt_ids.files.settings.targets"/>
+
+    <Import Project="$(VCToolsRootPath)\crt\crt_build.targets"/>
+    <Target Name="GetBaseAddress"/>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcprt_codecvt_ids.rc b/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcprt_codecvt_ids.rc
new file mode 100644
index 0000000..441c769
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcprt_codecvt_ids.rc
@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+//////////////////////////////////////////////////////////////////////////////////////
+//
+// msvcprt_codecvt_ids.rc : Defines the version resource for the C++ Runtime Library
+// "_codecvt_ids" satellite DLL
+//
+//////////////////////////////////////////////////////////////////////////////////////
+
+#include "winver.h"                       // extract from windows header
+#include "verstamp.h"
+
+#define MKARGSTR2(X) #X
+#define MKARGSTR(X)  MKARGSTR2(X)
+
+#define VER_FILETYPE VFT_DLL
+#define VER_FILESUBTYPE VFT_UNKNOWN
+
+#define VER_FILEDESCRIPTION_STR  "Microsoft\256 C Runtime Library _codecvt_ids\0"
+#define VER_INTERNALNAME_STR     MKARGSTR(SXS_TARGET)
+#define VER_ORIGINALFILENAME_STR MKARGSTR(SXS_TARGET)
+
+#include <common.ver>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcprt_codecvt_ids.src b/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcprt_codecvt_ids.src
new file mode 100644
index 0000000..1a5c960
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/msvcprt_codecvt_ids.src
@@ -0,0 +1,15 @@
+; Copyright (c) Microsoft Corporation.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+;********************************************************************************
+;
+; This is the .DEF file for the Microsoft Visual C++ Run-Time Library
+; "_codecvt_ids" satellite DLL
+; The release version is MSVCPXX_CODECVT_IDS.DLL and the debug version
+; MSVCPXXD_CODECVT_IDS.DLL.
+;
+;********************************************************************************
+
+LIBRARY LIBRARYNAME
+
+EXPORTS
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/stl_codecvt_ids.files.settings.targets b/msvc-stl/stl/msbuild/stl_codecvt_ids/stl_codecvt_ids.files.settings.targets
new file mode 100644
index 0000000..347eccd
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/stl_codecvt_ids.files.settings.targets
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <ItemGroup>
+        <ClCompile Include="$(CrtRoot)\github\stl\src\ulocale.cpp" />
+        <ClCompile Condition="'$(CrtBuildModelIsDll)' == 'true'" Include="$(CrtRoot)\github\stl\src\dllmain_satellite.cpp;" />
+    </ItemGroup>
+
+    <Choose>
+      <When Condition="'$(CrtBuildModel)' != 'md'">
+        <!-- Only check exports of release, DLL, builds -->
+      </When>
+
+      <When Condition="'$(BuildArchitecture)' == 'i386' or '$(BuildArchitecture)' == 'chpe'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\i386.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+      <When Condition="'$(BuildArchitecture)' == 'amd64' or '$(BuildArchitecture)' == 'arm64ec'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\amd64.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+      <When Condition="'$(BuildArchitecture)' == 'arm64'">
+        <PropertyGroup>
+          <ExpectedExportsList>$(MSBuildThisFileDirectory)\arm64.exports</ExpectedExportsList>
+        </PropertyGroup>
+      </When>
+    </Choose>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/dirs.proj b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/dirs.proj
new file mode 100644
index 0000000..77dc722
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/dirs.proj
@@ -0,0 +1,20 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_codecvt_ids_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_xmd_onecore.vcxproj" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
+        <ProjectFile Include="msvcp_codecvt_ids_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe' and '$(BuildArchitecture)' != 'arm64ec'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_app.vcxproj b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_app.vcxproj
new file mode 100644
index 0000000..037f3fe
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{53AB0179-49FF-4620-9D42-45BD8ED71EA8}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_codecvt_ids.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_kernel32.vcxproj
new file mode 100644
index 0000000..d4fb3a6
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9D9D5B21-5342-4726-AA4F-ACDF4D028F28}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_codecvt_ids.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_netfx.vcxproj
new file mode 100644
index 0000000..b407683
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{D561DC89-A909-478B-8566-41640F9F5B53}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_codecvt_ids.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_onecore.vcxproj
new file mode 100644
index 0000000..d9ebb6d
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{10C04DBD-4EB2-4590-BC8D-25DBA780905C}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_codecvt_ids.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/dirs.proj b/msvc-stl/stl/msbuild/stl_post/dirs.proj
new file mode 100644
index 0000000..e177b7c
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/dirs.proj
@@ -0,0 +1,15 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Condition="'$(CrtBuildMD)'  != 'false'" Include="md\dirs.proj" />
+        <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/md/dirs.proj b/msvc-stl/stl/msbuild/stl_post/md/dirs.proj
new file mode 100644
index 0000000..9a4ec8b
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/md/dirs.proj
@@ -0,0 +1,17 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_post_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_post_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_post_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_post_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_app.vcxproj b/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_app.vcxproj
new file mode 100644
index 0000000..894da1b
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{0E89DF6E-E7BA-44A1-841E-E6310F470211}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_kernel32.vcxproj
new file mode 100644
index 0000000..65e9cd8
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{4BC58285-8BF8-4362-BE62-38CCBB34EA57}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_netfx.vcxproj
new file mode 100644
index 0000000..4e60ae4
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9EAC2409-0DE5-465D-BEB2-08DD9221CDC7}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_onecore.vcxproj
new file mode 100644
index 0000000..1b96cff
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/md/msvcp_post_md_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8A1D8A23-DBBA-4356-816E-344F7956D497}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>md</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/msvcp_post.settings.targets b/msvc-stl/stl/msbuild/stl_post/msvcp_post.settings.targets
new file mode 100644
index 0000000..0f211b5
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/msvcp_post.settings.targets
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="Dogfood">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+    <PropertyGroup Label="Configuration">
+        <ConfigurationType>StaticLibrary</ConfigurationType>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <FinalBinary>p_post</FinalBinary>
+
+        <TargetAppFamily Condition="'$(MsvcpFlavor)' == 'app'">true</TargetAppFamily>
+        <TargetCoreSystem Condition="'$(MsvcpFlavor)' == 'onecore'">true</TargetCoreSystem>
+        <TargetNetFx Condition="'$(MsvcpFlavor)' == 'netfx'">true</TargetNetFx>
+    </PropertyGroup>
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\crt_build.settings.targets"/>
+
+    <PropertyGroup>
+        <ClrLibSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr</ClrLibSuffix>
+
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'app'">_app</MsvcpFlavorSuffix>
+        <MsvcpFlavorSuffix Condition="'$(MsvcpFlavor)' == 'netfx'">_clr$(NetFxVerX)</MsvcpFlavorSuffix>
+
+        <LibOutputFileName>msvcprt$(BuildSuffix)$(ClrLibSuffix)</LibOutputFileName>
+        <LibOutputFile>$(LibOutputFileName).lib</LibOutputFile>
+
+        <UseMsvcrt>false</UseMsvcrt>
+
+        <LinkGenerateDebugInformation>true</LinkGenerateDebugInformation>
+        <LinkProgramDataBaseFileName>$(OutputPath)\$(OutputName)$(_PDB_VER_NAME_)$(DllPdbFlavorSuffix)</LinkProgramDataBaseFileName>
+
+        <LinkAdditionalOptions>-debugtype:cv,fixup $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) != 'true'">-opt:ref,icf=3 $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions Condition="$(DebugBuild) == 'true'">-opt:ref,noicf $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:libcpmt$(BuildSuffix).lib $(LinkAdditionalOptions)</LinkAdditionalOptions>
+        <LinkAdditionalOptions>-nodefaultlib:$(LibOutputFile) $(LinkAdditionalOptions)</LinkAdditionalOptions>
+
+        <LinkGenerateMapFile>true</LinkGenerateMapFile>
+        <LinkRelease>true</LinkRelease>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference
+            Include="$(CrtRoot)\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <ProjectReference
+            Include="$(CrtRoot)\github\stl\msbuild\stl_1\$(CrtBuildModel)\msvcp_1_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <ProjectReference
+            Include="$(CrtRoot)\github\stl\msbuild\stl_2\$(CrtBuildModel)\msvcp_2_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <ProjectReference
+            Include="$(CrtRoot)\github\stl\msbuild\stl_codecvt_ids\$(CrtBuildModel)\msvcp_codecvt_ids_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <ProjectReference
+            Include="$(CrtRoot)\github\stl\msbuild\stl_atomic_wait\$(CrtBuildModel)\msvcp_atomic_wait_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
+        <Lib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib">
+            <IncludeInChameleonLib>false</IncludeInChameleonLib>
+        </Lib>
+        <Lib Include="$(CrtLibPath)\msvcprt_1$(BuildSuffix)$(ClrLibSuffix).lib">
+            <IncludeInChameleonLib>false</IncludeInChameleonLib>
+        </Lib>
+        <Lib Include="$(CrtLibPath)\msvcprt_2$(BuildSuffix)$(ClrLibSuffix).lib">
+            <IncludeInChameleonLib>false</IncludeInChameleonLib>
+        </Lib>
+        <Lib Include="$(CrtLibPath)\msvcprt$(BuildSuffix)_codecvt_ids$(ClrLibSuffix).lib">
+            <IncludeInChameleonLib>false</IncludeInChameleonLib>
+        </Lib>
+        <Lib Include="$(CrtLibPath)\msvcprt$(BuildSuffix)_atomic_wait$(ClrLibSuffix).lib">
+            <IncludeInChameleonLib>false</IncludeInChameleonLib>
+        </Lib>
+    </ItemGroup>
+
+    <Import Project="$(VCToolsRootPath)\crt\crt_build.targets"/>
+
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/xmd/dirs.proj b/msvc-stl/stl/msbuild/stl_post/xmd/dirs.proj
new file mode 100644
index 0000000..5b8316f
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/xmd/dirs.proj
@@ -0,0 +1,20 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<!--
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+-->
+
+    <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
+
+    <ItemGroup>
+        <ProjectFile Include="msvcp_post_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_post_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_post_xmd_onecore.vcxproj" />
+    </ItemGroup>
+
+    <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
+        <ProjectFile Include="msvcp_post_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+    </ItemGroup>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_app.vcxproj b/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_app.vcxproj
new file mode 100644
index 0000000..6608c83
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_app.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{687A5106-D6CE-4BC4-8BA1-27D84F895FF5}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>app</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_kernel32.vcxproj b/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_kernel32.vcxproj
new file mode 100644
index 0000000..015e11d
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_kernel32.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{13998FA0-CBA7-4303-9212-879E17F69D53}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>kernel32</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_netfx.vcxproj b/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_netfx.vcxproj
new file mode 100644
index 0000000..677d592
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_netfx.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9FAAE4A7-D6CE-48C8-8B80-6EA96F508545}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>netfx</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_onecore.vcxproj b/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_onecore.vcxproj
new file mode 100644
index 0000000..38621ec
--- /dev/null
+++ b/msvc-stl/stl/msbuild/stl_post/xmd/msvcp_post_xmd_onecore.vcxproj
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--
+  Copyright (c) Microsoft Corporation.
+  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+  -->
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8DA22F7E-CE13-4885-AD01-D97B180E815C}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
+  <PropertyGroup>
+    <CrtBuildModel>xmd</CrtBuildModel>
+    <MsvcpFlavor>onecore</MsvcpFlavor>
+    <Arm64X>true</Arm64X>
+  </PropertyGroup>
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
+</Project>
diff --git a/msvc-stl/stl/set_environment.bat.in b/msvc-stl/stl/set_environment.bat.in
new file mode 100644
index 0000000..b81b1f7
--- /dev/null
+++ b/msvc-stl/stl/set_environment.bat.in
@@ -0,0 +1,6 @@
+:: Copyright (c) Microsoft Corporation.
+:: SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+@set PATH=%~dp0out\bin\@VCLIBS_I386_OR_AMD64@;%PATH%
+@set INCLUDE=%~dp0out\inc;%INCLUDE%
+@set LIB=%~dp0out\lib\@VCLIBS_I386_OR_AMD64@;%LIB%
diff --git a/msvc-stl/stl/set_environment.ps1.in b/msvc-stl/stl/set_environment.ps1.in
new file mode 100644
index 0000000..743820b
--- /dev/null
+++ b/msvc-stl/stl/set_environment.ps1.in
@@ -0,0 +1,6 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+$env:PATH="$PSScriptRoot\out\bin\@VCLIBS_I386_OR_AMD64@;$env:PATH"
+$env:INCLUDE="$PSScriptRoot\out\inc;$env:INCLUDE"
+$env:LIB="$PSScriptRoot\out\lib\@VCLIBS_I386_OR_AMD64@;$env:LIB"
diff --git a/msvc-stl/stl/src/StlCompareStringA.cpp b/msvc-stl/stl/src/StlCompareStringA.cpp
new file mode 100644
index 0000000..459bac6
--- /dev/null
+++ b/msvc-stl/stl/src/StlCompareStringA.cpp
@@ -0,0 +1,148 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <crtdbg.h>
+#include <cstring> // for __strncnt
+#include <internal_shared.h>
+
+#include <Windows.h>
+
+#include "awint.hpp"
+
+// int __cdecl __crtCompareStringA - Get type information about an ANSI string.
+//
+// Purpose:
+//   Internal support function. Assumes info in ANSI string format. Tries
+//   to use NLS API call CompareStringA if available and uses CompareStringW
+//   if it must. If neither is available it fails and returns 0.
+//
+// Entry:
+//   LPCWSTR  LocaleName  - locale context for the comparison.
+//   DWORD    dwCmpFlags  - https://learn.microsoft.com/windows/win32/api/stringapiset/nf-stringapiset-comparestringex
+//   LPCSTR   lpStringn   - multibyte string to be compared
+//   int      cchCountn   - char (byte) count (NOT including null terminator) (-1 if null terminated)
+//   int      code_page   - for MB/WC conversion. If 0, use __lc_codepage
+//
+// Exit:
+//   Success: 1 - if lpString1 <  lpString2
+//            2 - if lpString1 == lpString2
+//            3 - if lpString1 >  lpString2
+//   Failure: 0
+extern "C" _CRTIMP2 int __cdecl __crtCompareStringA(_In_z_ LPCWSTR LocaleName, _In_ DWORD dwCmpFlags,
+    _In_reads_(cchCount1) LPCSTR lpString1, _In_ int cchCount1, _In_reads_(cchCount2) LPCSTR lpString2,
+    _In_ int cchCount2, _In_ int code_page) noexcept {
+    // CompareString will compare past null terminator. Must find null terminator if in string before cchCountn chars.
+    if (cchCount1 > 0) {
+        cchCount1 = static_cast<int>(__strncnt(lpString1, cchCount1));
+    } else if (cchCount1 < -1) {
+        return FALSE;
+    }
+
+    if (cchCount2 > 0) {
+        cchCount2 = static_cast<int>(__strncnt(lpString2, cchCount2));
+    } else if (cchCount2 < -1) {
+        return FALSE;
+    }
+
+    // Special case: at least one count is zero
+    if (!cchCount1 || !cchCount2) {
+        // both strings zero
+        if (cchCount1 == cchCount2) {
+            return 2;
+        }
+
+        // string 1 greater
+        if (cchCount2 > 1) {
+            return 1;
+        }
+
+        // string 2 greater
+        if (cchCount1 > 1) {
+            return 3;
+        }
+
+        // one has zero count, the other has a count of one
+        // - if the one count is a naked lead byte, the strings are equal
+        // - otherwise it is a single character and they are unequal
+        CPINFO cpInfo;
+        if (!GetCPInfo(code_page, &cpInfo)) {
+            return 0;
+        }
+
+        _ASSERTE((cchCount1 == 0 && cchCount2 == 1) || (cchCount1 == 1 && cchCount2 == 0));
+
+        // string 1 has count of 1
+        if (cchCount1 > 0) {
+            if (cpInfo.MaxCharSize < 2) {
+                return 3;
+            }
+
+            for (auto cp = &cpInfo.LeadByte[0]; cp[0] && cp[1]; cp += 2) {
+                const auto ch = static_cast<unsigned char>(*lpString1);
+                if (ch >= cp[0] && ch <= cp[1]) {
+                    return 2;
+                }
+            }
+
+            return 3;
+        }
+
+        // string 2 has count of 1
+        if (cchCount2 > 0) {
+            if (cpInfo.MaxCharSize < 2) {
+                return 1;
+            }
+
+            for (auto cp = &cpInfo.LeadByte[0]; cp[0] && cp[1]; cp += 2) {
+                const auto ch = static_cast<unsigned char>(*lpString2);
+                if (ch >= cp[0] && ch <= cp[1]) {
+                    return 2;
+                }
+            }
+
+            return 1;
+        }
+    }
+
+    // Convert strings and return the requested information.
+
+    // find out how big a buffer we need (includes null terminator if any)
+    const int buff_size1 =
+        MultiByteToWideChar(code_page, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, lpString1, cchCount1, nullptr, 0);
+    if (0 == buff_size1) {
+        return 0;
+    }
+
+    // allocate enough space for chars
+    __crt_scoped_stack_ptr<wchar_t> wbuffer1(_malloca_crt_t(wchar_t, buff_size1));
+    if (wbuffer1.get() == nullptr) {
+        return 0;
+    }
+
+    // do the conversion
+    if (0 == MultiByteToWideChar(code_page, MB_PRECOMPOSED, lpString1, cchCount1, wbuffer1.get(), buff_size1)) {
+        return 0;
+    }
+
+    // find out how big a buffer we need (includes null terminator if any)
+    const int buff_size2 =
+        MultiByteToWideChar(code_page, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, lpString2, cchCount2, nullptr, 0);
+    if (0 == buff_size2) {
+        return 0;
+    }
+
+    // allocate enough space for chars
+    const __crt_scoped_stack_ptr<wchar_t> wbuffer2(_malloca_crt_t(wchar_t, buff_size2));
+    if (wbuffer2.get() == nullptr) {
+        return 0;
+    }
+
+    const int actual_size =
+        MultiByteToWideChar(code_page, MB_PRECOMPOSED, lpString2, cchCount2, wbuffer2.get(), buff_size2);
+    if (actual_size == 0) {
+        return 0;
+    }
+
+    return CompareStringEx(
+        LocaleName, dwCmpFlags, wbuffer1.get(), buff_size1, wbuffer2.get(), buff_size2, nullptr, nullptr, 0);
+}
diff --git a/msvc-stl/stl/src/StlCompareStringW.cpp b/msvc-stl/stl/src/StlCompareStringW.cpp
new file mode 100644
index 0000000..561f6a5
--- /dev/null
+++ b/msvc-stl/stl/src/StlCompareStringW.cpp
@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstring> // for wcsnlen
+
+#include <Windows.h>
+
+#include "awint.hpp"
+
+// int __cdecl __crtCompareStringW - Get type information about a wide string.
+//
+// Purpose:
+//   Internal support function. Assumes info in wide string format.
+//
+// Entry:
+//   LPCWSTR  LocaleName  - locale context for the comparison.
+//   DWORD    dwCmpFlags  - https://learn.microsoft.com/windows/win32/api/stringapiset/nf-stringapiset-comparestringex
+//   LPCWSTR  lpStringn   - wide string to be compared
+//   int      cchCountn   - wide char (word) count (NOT including null terminator) (-1 if null terminated)
+//
+// Exit:
+//   Success: 1 - if lpString1 <  lpString2
+//            2 - if lpString1 == lpString2
+//            3 - if lpString1 >  lpString2
+//   Failure: 0
+extern "C" _CRTIMP2 int __cdecl __crtCompareStringW(_In_z_ LPCWSTR LocaleName, _In_ DWORD dwCmpFlags,
+    _In_reads_(cchCount1) LPCWSTR lpString1, _In_ int cchCount1, _In_reads_(cchCount2) LPCWSTR lpString2,
+    _In_ int cchCount2) noexcept {
+    // CompareString will compare past null terminator. Must find null terminator if in string before cchCountn wide
+    // characters.
+    if (cchCount1 > 0) {
+        cchCount1 = static_cast<int>(wcsnlen(lpString1, cchCount1));
+    }
+
+    if (cchCount2 > 0) {
+        cchCount2 = static_cast<int>(wcsnlen(lpString2, cchCount2));
+    }
+
+    if (!cchCount1 || !cchCount2) {
+        return (cchCount1 - cchCount2 == 0) ? 2 : (cchCount1 - cchCount2 < 0) ? 1 : 3;
+    }
+
+    return CompareStringEx(LocaleName, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2, nullptr, nullptr, 0);
+}
diff --git a/msvc-stl/stl/src/StlLCMapStringA.cpp b/msvc-stl/stl/src/StlLCMapStringA.cpp
new file mode 100644
index 0000000..8a1255d
--- /dev/null
+++ b/msvc-stl/stl/src/StlLCMapStringA.cpp
@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <internal_shared.h>
+
+#include "awint.hpp"
+
+// int __cdecl __crtLCMapStringA - Get type information about an ANSI string.
+//
+// Purpose:
+//        Internal support function. Assumes info in ANSI string format. Tries
+//        to use NLS API call LCMapStringA if available and uses LCMapStringW
+//        if it must. If neither is available it fails and returns 0.
+//
+// Entry:
+//        LPCWSTR  LocaleName  - locale context for the comparison.
+//        DWORD    dwMapFlags  - see https://learn.microsoft.com/windows/win32/api/winnls/nf-winnls-lcmapstringex
+//        LPCSTR   lpSrcStr    - pointer to string to be mapped
+//        int      cchSrc      - wide char (word) count of input string
+//                               (including null terminator if any)
+//                               (-1 if null terminated)
+//        LPSTR    lpDestStr   - pointer to memory to store mapping
+//        int      cchDest     - char (byte) count of buffer (including null terminator)
+//        int      code_page   - for MB/WC conversion. If 0, use __lc_codepage
+//        BOOL     bError      - TRUE if MB_ERR_INVALID_CHARS set on call to MultiByteToWideChar when GetStringTypeW
+//                               used.
+//
+// Exit:
+//        Success: number of chars written to lpDestStr (including null terminator)
+//        Failure: 0
+extern "C" _CRTIMP2 int __cdecl __crtLCMapStringA(_In_opt_z_ LPCWSTR LocaleName, _In_ DWORD dwMapFlags,
+    _In_reads_(cchSrc) LPCSTR lpSrcStr, _In_ int cchSrc, _Out_writes_opt_(cchDest) char* lpDestStr, _In_ int cchDest,
+    _In_ int code_page, _In_ BOOL bError) noexcept {
+    // LCMapString will map past the null terminator.  We must find the null
+    // terminator if it occurs in the string before cchSrc characters
+    // and cap the number of characters to be considered.
+    if (cchSrc > 0) {
+        const int cchSrcCnt = static_cast<int>(__strncnt(lpSrcStr, cchSrc));
+
+        // Include the null terminator if the source string is terminated within
+        // the buffer.
+        if (cchSrcCnt < cchSrc) {
+            cchSrc = cchSrcCnt + 1;
+        } else {
+            cchSrc = cchSrcCnt;
+        }
+    }
+
+    // Convert string and return the requested information. Note that we are converting to a wide string so there is not
+    // a one-to-one correspondence between number of wide chars in the input string and the number of *bytes* in the
+    // buffer. However, there had *better be* a one-to-one correspondence between the number of wide characters and the
+    // number of multibyte characters or the resulting mapped string will be worthless to the user.
+
+    // find out how big a buffer we need (includes null terminator if any)
+    const int inbuff_size = MultiByteToWideChar(
+        code_page, bError ? MB_PRECOMPOSED | MB_ERR_INVALID_CHARS : MB_PRECOMPOSED, lpSrcStr, cchSrc, nullptr, 0);
+    if (0 == inbuff_size) {
+        return 0;
+    }
+
+    // allocate enough space for wide chars
+    const __crt_scoped_stack_ptr<wchar_t> inwbuffer(_malloca_crt_t(wchar_t, inbuff_size));
+    if (!inwbuffer) {
+        return 0;
+    }
+
+    // do the conversion
+    if (0 == MultiByteToWideChar(code_page, MB_PRECOMPOSED, lpSrcStr, cchSrc, inwbuffer.get(), inbuff_size)) {
+        return 0;
+    }
+
+    // get size required for string mapping
+    int retval = LCMapStringEx(LocaleName, dwMapFlags, inwbuffer.get(), inbuff_size, nullptr, 0, nullptr, nullptr, 0);
+    if (0 == retval) {
+        return 0;
+    }
+
+    if (dwMapFlags & LCMAP_SORTKEY) {
+        // retval is size in BYTES
+        if (0 != cchDest) {
+            if (retval > cchDest) {
+                return retval;
+            }
+
+            // CodeQL [SM02986] This cast is correct: LCMAP_SORTKEY stores "an opaque array of bytes".
+            const auto wide_dest = reinterpret_cast<LPWSTR>(lpDestStr);
+
+            // do string mapping
+            if (0
+                == LCMapStringEx(
+                    LocaleName, dwMapFlags, inwbuffer.get(), inbuff_size, wide_dest, cchDest, nullptr, nullptr, 0)) {
+                return retval;
+            }
+        }
+    } else {
+        // retval is size in wide chars
+        int outbuff_size = retval;
+
+        // allocate enough space for wide chars (includes null terminator if any)
+        const __crt_scoped_stack_ptr<wchar_t> outwbuffer(_malloca_crt_t(wchar_t, outbuff_size));
+        if (!outwbuffer) {
+            return retval;
+        }
+
+        // do string mapping
+        if (0
+            == LCMapStringEx(LocaleName, dwMapFlags, inwbuffer.get(), inbuff_size, outwbuffer.get(), outbuff_size,
+                nullptr, nullptr, 0)) {
+            return retval;
+        }
+
+        if (0 == cchDest) {
+            // get size required
+            retval = WideCharToMultiByte(code_page, 0, outwbuffer.get(), outbuff_size, nullptr, 0, nullptr, nullptr);
+        } else {
+            // convert mapping
+            retval =
+                WideCharToMultiByte(code_page, 0, outwbuffer.get(), outbuff_size, lpDestStr, cchDest, nullptr, nullptr);
+        }
+    }
+
+    return retval;
+}
diff --git a/msvc-stl/stl/src/StlLCMapStringW.cpp b/msvc-stl/stl/src/StlLCMapStringW.cpp
new file mode 100644
index 0000000..e68a43b
--- /dev/null
+++ b/msvc-stl/stl/src/StlLCMapStringW.cpp
@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstring> // for wcsnlen
+
+#include "awint.hpp"
+
+// int __cdecl __crtLCMapStringW - Get type information about a wide string.
+//
+// Purpose:
+//        Internal support function. Assumes info in wide string format.
+//
+// Entry:
+//        LPCWSTR  locale_name       - locale context for the comparison.
+//        DWORD    map_flags         - see https://learn.microsoft.com/windows/win32/api/winnls/nf-winnls-lcmapstringex
+//        LPCWSTR  source            - pointer to string to be mapped
+//        int      source_count      - wide char (word) count of input string
+//                                     (including null terminator if any)
+//                                     (-1 if null terminated)
+//        LPWSTR   destination       - pointer to memory to store mapping
+//        int      destination_count - wide char (word) count of buffer (including L'\0')
+//
+//        NOTE:    if LCMAP_SORTKEY is specified, then cchDest refers to number
+//                 of BYTES, not number of wide chars. The return string will be
+//                 a series of bytes with a null terminator.
+//
+// Exit:
+//        Success: if LCMAP_SORTKEY:
+//                    number of bytes written to destination (including null terminator)
+//                 else
+//                    number of wide characters written to destination (including null terminator)
+//        Failure: 0
+extern "C" _CRTIMP2 int __cdecl __crtLCMapStringW(_In_opt_z_ LPCWSTR const locale_name, _In_ DWORD const map_flags,
+    _In_reads_(source_count) LPCWSTR const source, _In_ int source_count,
+    _Out_writes_opt_(destination_count) wchar_t* const destination, _In_ int const destination_count) noexcept {
+    // LCMapString will map past the null terminator.  We must find the null terminator if it occurs in the string
+    // before source_count characters and cap the number of characters to be considered.
+    if (source_count > 0) {
+        const int source_length = static_cast<int>(wcsnlen(source, source_count));
+
+        // Include the null terminator if the source string is terminated within the buffer.
+        if (source_length < source_count) {
+            source_count = source_length + 1;
+        } else {
+            source_count = source_length;
+        }
+    }
+
+    return LCMapStringEx(
+        locale_name, map_flags, source, source_count, destination, destination_count, nullptr, nullptr, 0);
+}
diff --git a/msvc-stl/stl/src/_tolower.cpp b/msvc-stl/stl/src/_tolower.cpp
new file mode 100644
index 0000000..e4984bf
--- /dev/null
+++ b/msvc-stl/stl/src/_tolower.cpp
@@ -0,0 +1,122 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// convert character to lower case
+
+#include <yvals.h>
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cctype>
+#include <clocale>
+#include <cstdlib>
+#include <internal_shared.h>
+
+#include "awint.hpp"
+
+// remove macro definitions of _tolower() and tolower()
+#undef _tolower
+#undef tolower
+
+_EXTERN_C_UNLESS_PURE
+
+// int _Tolower(c) - convert character to lower case
+//
+// Purpose:
+//     _Tolower() is a version of tolower with a locale argument.
+//
+// Entry:
+//     c - int value of character to be converted
+//     const _Ctypevec * = pointer to locale info
+//
+// Exit:
+//     returns int value of lower case representation of c
+//
+// Exceptions:
+//     None.
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Tolower(int c, const _Ctypevec* ploc) noexcept {
+    int size;
+    unsigned char inbuffer[3];
+    unsigned char outbuffer[3];
+
+    UINT codepage;
+    const wchar_t* locale_name;
+
+    if (ploc == nullptr) {
+        locale_name = ___lc_locale_name_func()[LC_CTYPE];
+        codepage    = ___lc_codepage_func();
+    } else {
+        locale_name = ploc->_LocaleName;
+        codepage    = ploc->_Page;
+    }
+
+    if (locale_name == nullptr) {
+        if (c >= 'A' && c <= 'Z') {
+            c = c + ('a' - 'A');
+        }
+
+        return c;
+    }
+
+    // if checking case of c does not require API call, do it
+    if (static_cast<unsigned int>(c) < 256) {
+        if (ploc == nullptr) {
+            if (!isupper(c)) {
+                return c;
+            }
+        } else {
+            if (!(ploc->_Table[c] & _UPPER)) {
+                return c;
+            }
+        }
+    }
+
+    // convert int c to multibyte string
+    if (ploc == nullptr ? _cpp_isleadbyte((c >> 8) & 0xff) : (ploc->_Table[(c >> 8) & 0xff] & _LEADBYTE) != 0) {
+        inbuffer[0] = ((c >> 8) & 0xff);
+        inbuffer[1] = static_cast<unsigned char>(c);
+        inbuffer[2] = 0;
+        size        = 2;
+    } else {
+        inbuffer[0] = static_cast<unsigned char>(c);
+        inbuffer[1] = 0;
+        size        = 1;
+    }
+
+    // convert wide char to lowercase
+    size = __crtLCMapStringA(locale_name, LCMAP_LOWERCASE, reinterpret_cast<const char*>(inbuffer), size,
+        reinterpret_cast<char*>(outbuffer), 3, codepage, TRUE);
+
+    if (size == 0) {
+        return c;
+    }
+
+    // construct integer return value
+    if (size == 1) {
+        return static_cast<int>(outbuffer[0]);
+    } else {
+        return static_cast<int>(outbuffer[1]) | (static_cast<int>(outbuffer[0]) << 8);
+    }
+}
+
+_CRTIMP2_PURE _Ctypevec __CLRCALL_PURE_OR_CDECL _Getctype() noexcept {
+    // get ctype info for current locale
+    _Ctypevec ctype;
+
+    ctype._Page  = ___lc_codepage_func();
+    ctype._Table = static_cast<const short*>(_calloc_crt(256, sizeof(*__pctype_func())));
+    if (ctype._Table != nullptr) {
+        memcpy(const_cast<short*>(ctype._Table), __pctype_func(), 256 * sizeof(*__pctype_func()));
+        ctype._Delfl = 1;
+    } else {
+        ctype._Table = reinterpret_cast<const short*>(__pctype_func());
+        ctype._Delfl = 0;
+    }
+    ctype._LocaleName = ___lc_locale_name_func()[LC_COLLATE];
+    if (ctype._LocaleName) {
+        ctype._LocaleName = _wcsdup_dbg(ctype._LocaleName, _CRT_BLOCK, __FILE__, __LINE__);
+    }
+
+    return ctype;
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/_toupper.cpp b/msvc-stl/stl/src/_toupper.cpp
new file mode 100644
index 0000000..9430b30
--- /dev/null
+++ b/msvc-stl/stl/src/_toupper.cpp
@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// convert character to uppercase
+
+#include <yvals.h>
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cctype>
+#include <clocale>
+#include <cstddef>
+
+#include "awint.hpp"
+
+// remove macro definitions of _toupper() and toupper()
+#undef _toupper
+#undef toupper
+
+_EXTERN_C_UNLESS_PURE
+
+// int _Toupper(c) - convert character to uppercase
+//
+// Purpose:
+//     _Toupper() is a version of toupper with a locale argument.
+//
+// Entry:
+//     c - int value of character to be converted
+//     const _Ctypevec * = pointer to locale info
+//
+// Exit:
+//     returns int value of uppercase representation of c
+//
+// Exceptions:
+//     None.
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Toupper(int c, const _Ctypevec* ploc) noexcept {
+    int size;
+    unsigned char inbuffer[3];
+    unsigned char outbuffer[3];
+
+    const wchar_t* locale_name;
+    UINT codepage;
+
+    if (ploc == nullptr) {
+        locale_name = ___lc_locale_name_func()[LC_CTYPE];
+        codepage    = ___lc_codepage_func();
+    } else {
+        locale_name = ploc->_LocaleName;
+        codepage    = ploc->_Page;
+    }
+
+    if (locale_name == nullptr) {
+        if (c >= 'a' && c <= 'z') {
+            c = c - ('a' - 'A');
+        }
+
+        return c;
+    }
+
+    // if checking case of c does not require API call, do it
+    if (static_cast<unsigned int>(c) < 256) {
+        if (ploc == nullptr) {
+            if (!islower(c)) {
+                return c;
+            }
+        } else {
+            if (!(ploc->_Table[c] & _LOWER)) {
+                return c;
+            }
+        }
+    }
+
+    // convert int c to multibyte string
+    if (ploc == nullptr ? _cpp_isleadbyte((c >> 8) & 0xff) : (ploc->_Table[(c >> 8) & 0xff] & _LEADBYTE) != 0) {
+        inbuffer[0] = ((c >> 8) & 0xff);
+        inbuffer[1] = static_cast<unsigned char>(c);
+        inbuffer[2] = 0;
+        size        = 2;
+    } else {
+        inbuffer[0] = static_cast<unsigned char>(c);
+        inbuffer[1] = 0;
+        size        = 1;
+    }
+
+    // convert wide char to uppercase
+    size = __crtLCMapStringA(locale_name, LCMAP_UPPERCASE, reinterpret_cast<const char*>(inbuffer), size,
+        reinterpret_cast<char*>(outbuffer), 3, codepage, TRUE);
+
+    if (size == 0) {
+        return c;
+    }
+
+    // construct integer return value
+    if (size == 1) {
+        return static_cast<int>(outbuffer[0]);
+    } else {
+        return static_cast<int>(outbuffer[1]) | (static_cast<int>(outbuffer[0]) << 8);
+    }
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/alias_init_once_begin_initialize.asm b/msvc-stl/stl/src/alias_init_once_begin_initialize.asm
new file mode 100644
index 0000000..fcd7556
--- /dev/null
+++ b/msvc-stl/stl/src/alias_init_once_begin_initialize.asm
@@ -0,0 +1,26 @@
+; Copyright (c) Microsoft Corporation.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+; weak symbol aliases
+
+; This checks if we're in x64 mode (using ml64).
+; Note that RAX isn't really an assembler symbol,
+; and this check only works in the IFDEF direction.
+; That is:
+; IFDEF RAX
+;   meow
+; ENDIF
+; will expand to meow on only x64 systems, however:
+; IFNDEF RAX
+;   meow
+; ENDIF
+; will expand to meow on _BOTH_ x64 and x86 systems.
+IFDEF RAX
+    EXTERN __imp_InitOnceBeginInitialize : PROC
+    ALIAS <__imp___std_init_once_begin_initialize> = <__imp_InitOnceBeginInitialize>
+ELSE
+    EXTERN __imp__InitOnceBeginInitialize@16 : PROC
+    ALIAS <__imp____std_init_once_begin_initialize@16> = <__imp__InitOnceBeginInitialize@16>
+ENDIF
+
+END
diff --git a/msvc-stl/stl/src/alias_init_once_complete.asm b/msvc-stl/stl/src/alias_init_once_complete.asm
new file mode 100644
index 0000000..d48de54
--- /dev/null
+++ b/msvc-stl/stl/src/alias_init_once_complete.asm
@@ -0,0 +1,26 @@
+; Copyright (c) Microsoft Corporation.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+; weak symbol aliases
+
+; This checks if we're in x64 mode (using ml64).
+; Note that RAX isn't really an assembler symbol,
+; and this check only works in the IFDEF direction.
+; That is:
+; IFDEF RAX
+;   meow
+; ENDIF
+; will expand to meow on only x64 systems, however:
+; IFNDEF RAX
+;   meow
+; ENDIF
+; will expand to meow on _BOTH_ x64 and x86 systems.
+IFDEF RAX
+    EXTERN __imp_InitOnceComplete : PROC
+    ALIAS <__imp___std_init_once_complete> = <__imp_InitOnceComplete>
+ELSE
+    EXTERN __imp__InitOnceComplete@12 : PROC
+    ALIAS <__imp____std_init_once_complete@12> = <__imp__InitOnceComplete@12>
+ENDIF
+
+END
diff --git a/msvc-stl/stl/src/asan.cpp b/msvc-stl/stl/src/asan.cpp
new file mode 100644
index 0000000..e49b05f
--- /dev/null
+++ b/msvc-stl/stl/src/asan.cpp
@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+namespace std {
+    extern "C" {
+    extern const bool _Asan_string_should_annotate   = true;
+    extern const bool _Asan_vector_should_annotate   = true;
+    extern const bool _Asan_optional_should_annotate = true;
+    } // extern "C"
+} // namespace std
diff --git a/msvc-stl/stl/src/asan_noop.cpp b/msvc-stl/stl/src/asan_noop.cpp
new file mode 100644
index 0000000..88eca40
--- /dev/null
+++ b/msvc-stl/stl/src/asan_noop.cpp
@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+extern "C" {
+extern const bool _Asan_string_should_annotate_default   = false;
+extern const bool _Asan_vector_should_annotate_default   = false;
+extern const bool _Asan_optional_should_annotate_default = false;
+
+void __cdecl __asan_poison_memory_region_default(const volatile void*, size_t) {}
+void __cdecl __asan_unpoison_memory_region_default(const volatile void*, size_t) {}
+
+void __cdecl __sanitizer_annotate_contiguous_container_default(
+    const void*, const void*, const void*, const void*) noexcept {}
+} // extern "C"
diff --git a/msvc-stl/stl/src/atomic.cpp b/msvc-stl/stl/src/atomic.cpp
new file mode 100644
index 0000000..0aab168
--- /dev/null
+++ b/msvc-stl/stl/src/atomic.cpp
@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// implement shared_ptr spin lock
+
+#include <yvals.h>
+
+#include <Windows.h>
+
+namespace {
+    SRWLOCK _Shared_ptr_lock = SRWLOCK_INIT;
+} // unnamed namespace
+
+extern "C" {
+
+_CRTIMP2_PURE void __cdecl _Lock_shared_ptr_spin_lock() noexcept { // TRANSITION, ABI: "spin_lock" name is outdated
+    AcquireSRWLockExclusive(&_Shared_ptr_lock);
+}
+
+_CRTIMP2_PURE void __cdecl _Unlock_shared_ptr_spin_lock() noexcept { // release previously obtained lock
+    _Analysis_assume_lock_held_(_Shared_ptr_lock);
+    ReleaseSRWLockExclusive(&_Shared_ptr_lock);
+}
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/atomic_wait.cpp b/msvc-stl/stl/src/atomic_wait.cpp
new file mode 100644
index 0000000..b20c6f5
--- /dev/null
+++ b/msvc-stl/stl/src/atomic_wait.cpp
@@ -0,0 +1,260 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// implement atomic wait / notify_one / notify_all
+
+#include <atomic>
+#include <cstdint>
+#include <cstdlib>
+#include <new>
+#include <thread>
+
+#include <Windows.h>
+
+#pragma comment(lib, "synchronization")
+
+namespace {
+    constexpr unsigned long long _Atomic_wait_no_deadline = 0xFFFF'FFFF'FFFF'FFFF;
+
+    constexpr size_t _Wait_table_size_power = 8;
+    constexpr size_t _Wait_table_size       = 1 << _Wait_table_size_power;
+    constexpr size_t _Wait_table_index_mask = _Wait_table_size - 1;
+
+    struct _Wait_context {
+        const void* _Storage; // Pointer to wait on
+        _Wait_context* _Next;
+        _Wait_context* _Prev;
+        CONDITION_VARIABLE _Condition;
+    };
+
+    struct [[nodiscard]] _Guarded_wait_context : _Wait_context {
+        _Guarded_wait_context(const void* _Storage_, _Wait_context* const _Head) noexcept
+            : _Wait_context{_Storage_, _Head, _Head->_Prev, CONDITION_VARIABLE_INIT} {
+            _Prev->_Next = this;
+            _Next->_Prev = this;
+        }
+
+        ~_Guarded_wait_context() {
+            const auto _Next_local = _Next;
+            const auto _Prev_local = _Prev;
+            _Next->_Prev           = _Prev_local;
+            _Prev->_Next           = _Next_local;
+        }
+
+        _Guarded_wait_context(const _Guarded_wait_context&)            = delete;
+        _Guarded_wait_context& operator=(const _Guarded_wait_context&) = delete;
+    };
+
+    class [[nodiscard]] _SrwLock_guard {
+    public:
+        explicit _SrwLock_guard(SRWLOCK& _Locked_) noexcept : _Locked(&_Locked_) {
+            AcquireSRWLockExclusive(_Locked);
+        }
+
+        ~_SrwLock_guard() {
+            ReleaseSRWLockExclusive(_Locked);
+        }
+
+        _SrwLock_guard(const _SrwLock_guard&)            = delete;
+        _SrwLock_guard& operator=(const _SrwLock_guard&) = delete;
+
+    private:
+        SRWLOCK* _Locked;
+    };
+
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+    struct alignas(_STD hardware_destructive_interference_size) _Wait_table_entry {
+        SRWLOCK _Lock = SRWLOCK_INIT;
+        // Initialize to all zeros, self-link lazily to optimize for space.
+        // Since _Wait_table_entry is initialized to all zero bytes,
+        // _Atomic_wait_table_entry::wait_table will also be all zero bytes.
+        // It can thus can be stored in the .bss section, and not in the actual binary.
+        _Wait_context _Wait_list_head = {nullptr, nullptr, nullptr, CONDITION_VARIABLE_INIT};
+
+        constexpr _Wait_table_entry() noexcept = default;
+    };
+#pragma warning(pop)
+
+    [[nodiscard]] _Wait_table_entry& _Atomic_wait_table_entry(const void* const _Storage) noexcept {
+        static _Wait_table_entry wait_table[_Wait_table_size];
+        auto index = reinterpret_cast<_STD uintptr_t>(_Storage);
+        index ^= index >> (_Wait_table_size_power * 2);
+        index ^= index >> _Wait_table_size_power;
+        return wait_table[index & _Wait_table_index_mask];
+    }
+
+    void _Assume_timeout() noexcept {
+#ifdef _DEBUG
+        if (GetLastError() != ERROR_TIMEOUT) {
+            _CSTD abort();
+        }
+#endif // defined(_DEBUG)
+    }
+} // unnamed namespace
+
+extern "C" {
+int __stdcall __std_atomic_wait_direct(const void* const _Storage, void* const _Comparand, const size_t _Size,
+    const unsigned long _Remaining_timeout) noexcept {
+    const auto _Result =
+        WaitOnAddress(const_cast<volatile void*>(_Storage), const_cast<void*>(_Comparand), _Size, _Remaining_timeout);
+
+    if (!_Result) {
+        _Assume_timeout();
+    }
+    return _Result;
+}
+
+void __stdcall __std_atomic_notify_one_direct(const void* const _Storage) noexcept {
+    WakeByAddressSingle(const_cast<void*>(_Storage));
+}
+
+void __stdcall __std_atomic_notify_all_direct(const void* const _Storage) noexcept {
+    WakeByAddressAll(const_cast<void*>(_Storage));
+}
+
+void __stdcall __std_atomic_notify_one_indirect(const void* const _Storage) noexcept {
+    auto& _Entry = _Atomic_wait_table_entry(_Storage);
+    _SrwLock_guard _Guard(_Entry._Lock);
+    _Wait_context* _Context = _Entry._Wait_list_head._Next;
+
+    if (_Context == nullptr) {
+        return;
+    }
+
+    for (; _Context != &_Entry._Wait_list_head; _Context = _Context->_Next) {
+        if (_Context->_Storage == _Storage) {
+            // Can't move wake outside SRWLOCKed section: SRWLOCK also protects the _Context itself
+            WakeAllConditionVariable(&_Context->_Condition);
+            break;
+        }
+    }
+}
+
+void __stdcall __std_atomic_notify_all_indirect(const void* const _Storage) noexcept {
+    auto& _Entry = _Atomic_wait_table_entry(_Storage);
+    _SrwLock_guard _Guard(_Entry._Lock);
+    _Wait_context* _Context = _Entry._Wait_list_head._Next;
+
+    if (_Context == nullptr) {
+        return;
+    }
+
+    for (; _Context != &_Entry._Wait_list_head; _Context = _Context->_Next) {
+        if (_Context->_Storage == _Storage) {
+            // Can't move wake outside SRWLOCKed section: SRWLOCK also protects the _Context itself
+            WakeAllConditionVariable(&_Context->_Condition);
+        }
+    }
+}
+
+int __stdcall __std_atomic_wait_indirect(const void* _Storage, void* _Comparand, size_t _Size, void* _Param,
+    _Atomic_wait_indirect_equal_callback_t _Are_equal, unsigned long _Remaining_timeout) noexcept {
+    auto& _Entry = _Atomic_wait_table_entry(_Storage);
+
+    _SrwLock_guard _Guard(_Entry._Lock);
+
+    if (_Entry._Wait_list_head._Next == nullptr) {
+        _Entry._Wait_list_head._Next = &_Entry._Wait_list_head;
+        _Entry._Wait_list_head._Prev = &_Entry._Wait_list_head;
+    }
+
+    _Guarded_wait_context _Context{_Storage, &_Entry._Wait_list_head};
+    for (;;) {
+        if (!_Are_equal(_Storage, _Comparand, _Size, _Param)) { // note: under lock to prevent lost wakes
+            return TRUE;
+        }
+
+        if (!SleepConditionVariableSRW(&_Context._Condition, &_Entry._Lock, _Remaining_timeout, 0)) {
+            _Assume_timeout();
+            return FALSE;
+        }
+
+        if (_Remaining_timeout != __std_atomic_wait_no_timeout) {
+            // spurious wake to recheck the clock
+            return TRUE;
+        }
+    }
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+unsigned long long __stdcall __std_atomic_wait_get_deadline(const unsigned long long _Timeout) noexcept {
+    if (_Timeout == _Atomic_wait_no_deadline) {
+        return _Atomic_wait_no_deadline;
+    } else {
+        return GetTickCount64() + _Timeout;
+    }
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+unsigned long __stdcall __std_atomic_wait_get_remaining_timeout(unsigned long long _Deadline) noexcept {
+    static_assert(__std_atomic_wait_no_timeout == INFINITE,
+        "__std_atomic_wait_no_timeout is passed directly to underlying API, so should match it");
+
+    if (_Deadline == _Atomic_wait_no_deadline) {
+        return INFINITE;
+    }
+
+    const unsigned long long _Current_time = GetTickCount64();
+    if (_Current_time >= _Deadline) {
+        return 0;
+    }
+
+    unsigned long long _Remaining     = _Deadline - _Current_time;
+    constexpr unsigned long _Ten_days = 864'000'000;
+    if (_Remaining > _Ten_days) {
+        return _Ten_days;
+    }
+    return static_cast<unsigned long>(_Remaining);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+enum class __std_atomic_api_level : unsigned long { __not_set, __detecting, __has_srwlock, __has_wait_on_address };
+__std_atomic_api_level __stdcall __std_atomic_set_api_level(__std_atomic_api_level) noexcept {
+    return __std_atomic_api_level::__has_wait_on_address;
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+_Smtx_t* __stdcall __std_atomic_get_mutex(const void* const _Key) noexcept {
+    constexpr size_t _Table_size_power = 8;
+    constexpr size_t _Table_size       = 1 << _Table_size_power;
+    constexpr size_t _Table_index_mask = _Table_size - 1;
+
+    struct alignas(std::hardware_destructive_interference_size) _Table_entry {
+        _Smtx_t _Mutex;
+    };
+
+    static _Table_entry _Table[_Table_size]{};
+
+    auto _Index = reinterpret_cast<std::uintptr_t>(_Key);
+    _Index ^= _Index >> (_Table_size_power * 2);
+    _Index ^= _Index >> _Table_size_power;
+    return &_Table[_Index & _Table_index_mask]._Mutex;
+}
+#pragma warning(pop)
+
+// TRANSITION, ABI: preserved for binary compatibility
+[[nodiscard]] unsigned char __stdcall __std_atomic_compare_exchange_128(_Inout_bytecount_(16) long long* _Destination,
+    _In_ long long _ExchangeHigh, _In_ long long _ExchangeLow,
+    _Inout_bytecount_(16) long long* _ComparandResult) noexcept {
+#ifdef _WIN64
+    return _InterlockedCompareExchange128(_Destination, _ExchangeHigh, _ExchangeLow, _ComparandResult);
+#else // ^^^ 64-bit / 32-bit vvv
+    (void) _Destination;
+    (void) _ExchangeHigh;
+    (void) _ExchangeLow;
+    (void) _ComparandResult;
+    _CSTD abort();
+#endif // ^^^ 32-bit ^^^
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+[[nodiscard]] char __stdcall __std_atomic_has_cmpxchg16b() noexcept {
+#ifdef _WIN64
+    return true;
+#else
+    _CSTD abort();
+#endif
+}
+} // extern "C"
diff --git a/msvc-stl/stl/src/awint.hpp b/msvc-stl/stl/src/awint.hpp
new file mode 100644
index 0000000..da88c79
--- /dev/null
+++ b/msvc-stl/stl/src/awint.hpp
@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Internal definitions for A&W Win32 wrapper routines.
+
+// This file is compiled into the import library (via regex.cpp => awint.hpp).
+// MAJOR LIMITATIONS apply to what can be included here!
+// Before editing this file, read: /docs/import_library.md
+
+#pragma once
+
+#include <yvals.h>
+
+#include <sdkddkver.h>
+
+#include <Windows.h>
+
+#define _cpp_isleadbyte(c) (__pctype_func()[static_cast<unsigned char>(c)] & _LEADBYTE)
+
+_CRT_BEGIN_C_HEADER
+
+_CRTIMP2 int __cdecl __crtCompareStringA(_In_z_ LPCWSTR _LocaleName, _In_ DWORD _DwCmpFlags,
+    _In_reads_(_CchCount1) LPCSTR _LpString1, _In_ int _CchCount1, _In_reads_(_CchCount2) LPCSTR _LpString2,
+    _In_ int _CchCount2, _In_ int _CodePage) noexcept;
+
+_CRTIMP2 int __cdecl __crtCompareStringW(_In_z_ LPCWSTR _LocaleName, _In_ DWORD _DwCmpFlags,
+    _In_reads_(_CchCount1) LPCWSTR _LpString1, _In_ int _CchCount1, _In_reads_(_CchCount2) LPCWSTR _LpString2,
+    _In_ int _CchCount2) noexcept;
+
+_CRTIMP2 int __cdecl __crtLCMapStringA(_In_opt_z_ LPCWSTR _LocaleName, _In_ DWORD _DwMapFlag,
+    _In_reads_(_CchSrc) LPCSTR _LpSrcStr, _In_ int _CchSrc, _Out_writes_opt_(_CchDest) char* _LpDestStr,
+    _In_ int _CchDest, _In_ int _CodePage, _In_ BOOL _BError) noexcept;
+
+_CRTIMP2 int __cdecl __crtLCMapStringW(_In_opt_z_ LPCWSTR _LocaleName, _In_ DWORD _DWMapFlag,
+    _In_reads_(_CchSrc) LPCWSTR _LpSrcStr, _In_ int _CchSrc, _Out_writes_opt_(_CchDest) wchar_t* _LpDestStr,
+    _In_ int _CchDest) noexcept;
+
+_CRT_END_C_HEADER
diff --git a/msvc-stl/stl/src/cerr.cpp b/msvc-stl/stl/src/cerr.cpp
new file mode 100644
index 0000000..27439ee
--- /dev/null
+++ b/msvc-stl/stl/src/cerr.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard error stream
+
+#include <fstream>
+#include <iostream>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL static filebuf ferr(stderr);
+
+#if defined(_M_CEE_PURE)
+__PURE_APPDOMAIN_GLOBAL extern ostream cerr(&ferr);
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream cerr(&ferr);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+struct _Init_cerr { // ensures that cerr is initialized
+    __CLR_OR_THIS_CALL _Init_cerr() { // initialize cerr
+        _Ptr_cerr = &cerr;
+        cerr.tie(_Ptr_cout);
+        cerr.setf(ios_base::unitbuf);
+    }
+};
+
+__PURE_APPDOMAIN_GLOBAL static _Init_cerr init_cerr;
+
+_STD_END
diff --git a/msvc-stl/stl/src/charconv.cpp b/msvc-stl/stl/src/charconv.cpp
new file mode 100644
index 0000000..cae8561
--- /dev/null
+++ b/msvc-stl/stl/src/charconv.cpp
@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstdint>
+
+// Generated by /tools/scripts/charconv_generate.cpp
+
+namespace std {
+
+    extern const uint32_t _Large_power_data[578] = {0x540be400, 0x00000002, 0x63100000, 0x6bc75e2d, 0x00000005,
+        0x40000000, 0x4674edea, 0x9f2c9cd0, 0x0000000c, 0xb9f56100, 0x5ca4bfab, 0x6329f1c3, 0x0000001d, 0xb5640000,
+        0xc40534fd, 0x926687d2, 0x6c3b15f9, 0x00000044, 0x10000000, 0x946590d9, 0xd762422c, 0x9a224501, 0x4f272617,
+        0x0000009f, 0x07950240, 0x245689c1, 0xc5faa71c, 0x73c86d67, 0xebad6ddc, 0x00000172, 0xcec10000, 0x63a22764,
+        0xefa418ca, 0xcdd17b25, 0x6bdfef70, 0x9dea3e1f, 0x0000035f, 0xe4000000, 0xcdc3fe6e, 0x66bc0c6a, 0x2e391f32,
+        0x5a450203, 0x71d2f825, 0xc3c24a56, 0x000007da, 0xa82e8f10, 0xaab24308, 0x8e211a7c, 0xf38ace40, 0x84c4ce0b,
+        0x7ceb0b27, 0xad2594c3, 0x00001249, 0xdd1a4000, 0xcc9f54da, 0xdc5961bf, 0xc75cabab, 0xf505440c, 0xd1bc1667,
+        0xfbb7af52, 0x608f8d29, 0x00002a94, 0x21000000, 0x17bb8a0c, 0x56af8ea4, 0x06479fa9, 0x5d4bb236, 0x80dc5fe0,
+        0xf0feaa0a, 0xa88ed940, 0x6b1a80d0, 0x00006323, 0x324c3864, 0x8357c796, 0xe44a42d5, 0xd9a92261, 0xbd3c103d,
+        0x91e5f372, 0xc0591574, 0xec1da60d, 0x102ad96c, 0x0000e6d3, 0x1e851000, 0x6e4f615b, 0x187b2a69, 0x0450e21c,
+        0x2fdd342b, 0x635027ee, 0xa6c97199, 0x8e4ae916, 0x17082e28, 0x1a496e6f, 0x0002196e, 0x32400000, 0x04ad4026,
+        0xf91e7250, 0x2994d1d5, 0x665bcdbb, 0xa23b2e96, 0x65fa7ddb, 0x77de53ac, 0xb020a29b, 0xc6bff953, 0x4b9425ab,
+        0x0004e34d, 0xfbc32d81, 0x5222d0f4, 0xb70f2850, 0x5713f2f3, 0xdc421413, 0xd6395d7d, 0xf8591999, 0x0092381c,
+        0x86b314d6, 0x7aa577b9, 0x12b7fe61, 0x000b616a, 0x1d11e400, 0x56c3678d, 0x3a941f20, 0x9b09368b, 0xbd706908,
+        0x207665be, 0x9b26c4eb, 0x1567e89d, 0x9d15096e, 0x7132f22b, 0xbe485113, 0x45e5a2ce, 0x001a7f52, 0xbb100000,
+        0x02f79478, 0x8c1b74c0, 0xb0f05d00, 0xa9dbc675, 0xe2d9b914, 0x650f72df, 0x77284b4c, 0x6df6e016, 0x514391c2,
+        0x2795c9cf, 0xd6e2ab55, 0x9ca8e627, 0x003db1a6, 0x40000000, 0xf4ecd04a, 0x7f2388f0, 0x580a6dc5, 0x43bf046f,
+        0xf82d5dc3, 0xee110848, 0xfaa0591c, 0xcdf4f028, 0x192ea53f, 0xbcd671a0, 0x7d694487, 0x10f96e01, 0x791a569d,
+        0x008fa475, 0xb9b2e100, 0x8288753c, 0xcd3f1693, 0x89b43a6b, 0x089e87de, 0x684d4546, 0xfddba60c, 0xdf249391,
+        0x3068ec13, 0x99b44427, 0xb68141ee, 0x5802cac3, 0xd96851f1, 0x7d7625a2, 0x014e718d, 0xfb640000, 0xf25a83e6,
+        0x9457ad0f, 0x0080b511, 0x2029b566, 0xd7c5d2cf, 0xa53f6d7d, 0xcdb74d1c, 0xda9d70de, 0xb716413d, 0x71d0ca4e,
+        0xd7e41398, 0x4f403a90, 0xf9ab3fe2, 0x264d776f, 0x030aafe6, 0x10000000, 0x09ab5531, 0xa60c58d2, 0x566126cb,
+        0x6a1c8387, 0x7587f4c1, 0x2c44e876, 0x41a047cf, 0xc908059e, 0xa0ba063e, 0xe7cfc8e8, 0xe1fac055, 0xef0144b2,
+        0x24207eb0, 0xd1722573, 0xe4b8f981, 0x071505ae, 0x7a3b6240, 0xcea45d4f, 0x4fe24133, 0x210f6d6d, 0xe55633f2,
+        0x25c11356, 0x28ebd797, 0xd396eb84, 0x1e493b77, 0x471f2dae, 0x96ad3820, 0x8afaced1, 0x4edecddb, 0x5568c086,
+        0xb2695da1, 0x24123c89, 0x107d4571, 0x1c410000, 0x6e174a27, 0xec62ae57, 0xef2289aa, 0xb6a2fbdd, 0x17e1efe4,
+        0x3366bdf2, 0x37b48880, 0xbfb82c3e, 0x19acde91, 0xd4f46408, 0x35ff6a4e, 0x67566a0e, 0x40dbb914, 0x782a3bca,
+        0x6b329b68, 0xf5afc5d9, 0x266469bc, 0xe4000000, 0xfb805ff4, 0xed55d1af, 0x9b4a20a8, 0xab9757f8, 0x01aefe0a,
+        0x4a2ca67b, 0x1ebf9569, 0xc7c41c29, 0xd8d5d2aa, 0xd136c776, 0x93da550c, 0x9ac79d90, 0x254bcba8, 0x0df07618,
+        0xf7a88809, 0x3a1f1074, 0xe54811fc, 0x59638ead, 0x97cbe710, 0x26d769e8, 0xb4e4723e, 0x5b90aa86, 0x9c333922,
+        0x4b7a0775, 0x2d47e991, 0x9a6ef977, 0x160b40e7, 0x0c92f8c4, 0xf25ff010, 0x25c36c11, 0xc9f98b42, 0x730b919d,
+        0x05ff7caf, 0xb0432d85, 0x2d2b7569, 0xa657842c, 0xd01fef10, 0xc77a4000, 0xe8b862e5, 0x10d8886a, 0xc8cd98e5,
+        0x108955c5, 0xd059b655, 0x58fbbed4, 0x03b88231, 0x034c4519, 0x194dc939, 0x1fc500ac, 0x794cc0e2, 0x3bc980a1,
+        0xe9b12dd1, 0x5e6d22f8, 0x7b38899a, 0xce7919d8, 0x78c67672, 0x79e5b99f, 0xe494034e, 0x00000001, 0xa1000000,
+        0x6c5cd4e9, 0x9be47d6f, 0xf93bd9e7, 0x77626fa1, 0xc68b3451, 0xde2b59e8, 0xcf3cde58, 0x2246ff58, 0xa8577c15,
+        0x26e77559, 0x17776753, 0xebe6b763, 0xe3fd0a5f, 0x33e83969, 0xa805a035, 0xf631b987, 0x211f0f43, 0xd85a43db,
+        0xab1bf596, 0x683f19a2, 0x00000004, 0xbe7dfe64, 0x4bc9042f, 0xe1f5edb0, 0x8fa14eda, 0xe409db73, 0x674fee9c,
+        0xa9159f0d, 0xf6b5b5d6, 0x7338960e, 0xeb49c291, 0x5f2b97cc, 0x0f383f95, 0x2091b3f6, 0xd1783714, 0xc1d142df,
+        0x153e22de, 0x8aafdf57, 0x77f5e55f, 0xa3e7ca8b, 0x032f525b, 0x42e74f3d, 0x0000000a, 0xf4dd1000, 0x5d450952,
+        0xaeb442e1, 0xa3b3342e, 0x3fcda36f, 0xb4287a6e, 0x4bc177f7, 0x67d2c8d0, 0xaea8f8e0, 0xadc93b67, 0x6cc856b3,
+        0x959d9d0b, 0x5b48c100, 0x4abe8a3d, 0x52d936f4, 0x71dbe84d, 0xf91c21c5, 0x4a458109, 0xd7aad86a, 0x08e14c7c,
+        0x759ba59c, 0xe43c8800, 0x00000017, 0x92400000, 0x04f110d4, 0x186472be, 0x8736c10c, 0x1478abfb, 0xfc51af29,
+        0x25eb9739, 0x4c2b3015, 0xa1030e0b, 0x28fe3c3b, 0x7788fcba, 0xb89e4358, 0x733de4a4, 0x7c46f2c2, 0x8f746298,
+        0xdb19210f, 0x2ea3b6ae, 0xaa5014b2, 0xea39ab8d, 0x97963442, 0x01dfdfa9, 0xd2f3d3fe, 0xa0790280, 0x00000037,
+        0x509c9b01, 0xc7dcadf1, 0x383dad2c, 0x73c64d37, 0xea6d67d0, 0x519ba806, 0xc403f2f8, 0xa052e1a2, 0xd710233a,
+        0x448573a9, 0xcf12d9ba, 0x70871803, 0x52dc3a9b, 0xe5b252e8, 0x0717fb4e, 0xbe4da62f, 0x0aabd7e1, 0x8c62ed4f,
+        0xceb9ec7b, 0xd4664021, 0xa1158300, 0xcce375e6, 0x842f29f2, 0x00000081, 0x7717e400, 0xd3f5fb64, 0xa0763d71,
+        0x7d142fe9, 0x33f44c66, 0xf3b8f12e, 0x130f0d8e, 0x734c9469, 0x60260fa8, 0x3c011340, 0xcc71880a, 0x37a52d21,
+        0x8adac9ef, 0x42bb31b4, 0xd6f94c41, 0xc88b056c, 0xe20501b8, 0x5297ed7c, 0x62c361c4, 0x87dad8aa, 0xb833eade,
+        0x94f06861, 0x13cc9abd, 0x8dc1d56a, 0x0000012d, 0x13100000, 0xc67a36e8, 0xf416299e, 0xf3493f0a, 0x77a5a6cf,
+        0xa4be23a3, 0xcca25b82, 0x3510722f, 0xbe9d447f, 0xa8c213b8, 0xc94c324e, 0xbc9e33ad, 0x76acfeba, 0x2e4c2132,
+        0x3e13cd32, 0x70fe91b4, 0xbb5cd936, 0x42149785, 0x46cc1afd, 0xe638ddf8, 0x690787d2, 0x1a02d117, 0x3eb5f1fe,
+        0xc3b9abae, 0x1c08ee6f, 0x000002be, 0x40000000, 0x8140c2aa, 0x2cf877d9, 0x71e1d73d, 0xd5e72f98, 0x72516309,
+        0xafa819dd, 0xd62a5a46, 0x2a02dcce, 0xce46ddfe, 0x2713248d, 0xb723d2ad, 0xc404bb19, 0xb706cc2b, 0x47b1ebca,
+        0x9d094bdc, 0xc5dc02ca, 0x31e6518e, 0x8ec35680, 0x342f58a8, 0x8b041e42, 0xfebfe514, 0x05fffc13, 0x6763790f,
+        0x66d536fd, 0xb9e15076, 0x00000662, 0x67b06100, 0xd2010a1a, 0xd005e1c0, 0xdb12733b, 0xa39f2e3f, 0x61b29de2,
+        0x2a63dce2, 0x942604bc, 0x6170d59b, 0xc2e32596, 0x140b75b9, 0x1f1d2c21, 0xb8136a60, 0x89d23ba2, 0x60f17d73,
+        0xc6cad7df, 0x0669df2b, 0x24b88737, 0x669306ed, 0x19496eeb, 0x938ddb6f, 0x5e748275, 0xc56e9a36, 0x3690b731,
+        0xc82842c5, 0x24ae798e, 0x00000ede, 0x41640000, 0xd5889ac1, 0xd9432c99, 0xa280e71a, 0x6bf63d2e, 0x8249793d,
+        0x79e7a943, 0x22fde64a, 0xe0d6709a, 0x05cacfef, 0xbd8da4d7, 0xe364006c, 0xa54edcb3, 0xa1a8086e, 0x748f459e,
+        0xfc8e54c8, 0xcc74c657, 0x42b8c3d4, 0x57d9636e, 0x35b55bcc, 0x6c13fee9, 0x1ac45161, 0xb595badb, 0xa1f14e9d,
+        0xdcf9e750, 0x07637f71, 0xde2f9f2b, 0x0000229d, 0x10000000, 0x3c5ebd89, 0xe3773756, 0x3dcba338, 0x81d29e4f,
+        0xa4f79e2c, 0xc3f9c774, 0x6a1ce797, 0xac5fe438, 0x07f38b9c, 0xd588ecfa, 0x3e5ac1ac, 0x85afccce, 0x9d1f3f70,
+        0xe82d6dd3, 0x177d180c, 0x5e69946f, 0x648e2ce1, 0x95a13948, 0x340fe011, 0xb4173c58, 0x2748f694, 0x7c2657bd,
+        0x758bda2e, 0x3b8090a0, 0x2ddbb613, 0x6dcf4890, 0x24e4047e, 0x00005099};
+
+} // namespace std
diff --git a/msvc-stl/stl/src/cin.cpp b/msvc-stl/stl/src/cin.cpp
new file mode 100644
index 0000000..63c0351
--- /dev/null
+++ b/msvc-stl/stl/src/cin.cpp
@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard input stream
+
+#include <fstream>
+#include <iostream>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL static filebuf fin(stdin);
+
+#if defined(_M_CEE_PURE)
+__PURE_APPDOMAIN_GLOBAL extern istream cin(&fin);
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT istream cin(&fin);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+struct _Init_cin { // ensures that cin is initialized
+    __CLR_OR_THIS_CALL _Init_cin() { // initialize cin
+        _Ptr_cin = &cin;
+        cin.tie(_Ptr_cout);
+    }
+};
+
+__PURE_APPDOMAIN_GLOBAL static _Init_cin init_cin;
+
+_STD_END
diff --git a/msvc-stl/stl/src/clog.cpp b/msvc-stl/stl/src/clog.cpp
new file mode 100644
index 0000000..5a1d22a
--- /dev/null
+++ b/msvc-stl/stl/src/clog.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard log stream
+
+#include <fstream>
+#include <iostream>
+
+#include "init_locks.hpp"
+
+#ifndef MRTDLL
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+#endif // MRTDLL
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL static filebuf flog(stderr);
+
+#if defined(_M_CEE_PURE)
+__PURE_APPDOMAIN_GLOBAL extern ostream clog(&flog);
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream clog(&flog);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+struct _Init_clog { // ensures that clog is initialized
+    __CLR_OR_THIS_CALL _Init_clog() { // initialize clog
+        _Ptr_clog = &clog;
+    }
+};
+
+__PURE_APPDOMAIN_GLOBAL static _Init_clog init_clog;
+
+_STD_END
diff --git a/msvc-stl/stl/src/cond.cpp b/msvc-stl/stl/src/cond.cpp
new file mode 100644
index 0000000..040e696
--- /dev/null
+++ b/msvc-stl/stl/src/cond.cpp
@@ -0,0 +1,112 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstdlib>
+#include <internal_shared.h>
+#include <new>
+#include <type_traits>
+#include <xthreads.h>
+#include <xtimec.h>
+
+#include "primitives.hpp"
+
+extern "C" {
+
+// TRANSITION, ABI: preserved for binary compatibility (and _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
+_CRTIMP2_PURE void __cdecl _Cnd_init_in_situ(const _Cnd_t cond) noexcept { // initialize condition variable in situ
+    new (cond) _Cnd_internal_imp_t;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE void __cdecl _Cnd_destroy_in_situ(_Cnd_t) noexcept {} // destroy condition variable in situ
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_init(_Cnd_t* const pcond) noexcept { // initialize
+    *pcond = nullptr;
+
+    const auto cond = static_cast<_Cnd_t>(_calloc_crt(1, sizeof(_Cnd_internal_imp_t)));
+    if (cond == nullptr) {
+        return _Thrd_result::_Nomem; // report alloc failed
+    }
+
+    _Cnd_init_in_situ(cond);
+    *pcond = cond;
+    return _Thrd_result::_Success;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE void __cdecl _Cnd_destroy(const _Cnd_t cond) noexcept { // clean up
+    if (cond) { // something to do, do it
+        _free_crt(cond);
+    }
+}
+
+// TRANSITION, ABI: should be static; dllexported for binary compatibility
+_CRTIMP2_PURE void __cdecl _Mtx_clear_owner(_Mtx_t mtx) noexcept { // set owner to nobody
+    mtx->_Thread_id = -1;
+    --mtx->_Count;
+}
+
+// TRANSITION, ABI: should be static; dllexported for binary compatibility
+_CRTIMP2_PURE void __cdecl _Mtx_reset_owner(_Mtx_t mtx) noexcept { // set owner to current thread
+    mtx->_Thread_id = static_cast<long>(GetCurrentThreadId());
+    ++mtx->_Count;
+}
+
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_wait(const _Cnd_t cond, const _Mtx_t mtx) noexcept { // wait until signaled
+    _Mtx_clear_owner(mtx);
+    _Primitive_wait(cond, mtx);
+    _Mtx_reset_owner(mtx);
+    return _Thrd_result::_Success; // TRANSITION, ABI: Always succeeds
+}
+
+// TRANSITION, ABI: preserved for compatibility; wait until signaled or timeout
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_timedwait(
+    const _Cnd_t cond, const _Mtx_t mtx, const _timespec64* const target) noexcept {
+    _Thrd_result res = _Thrd_result::_Success;
+    if (target == nullptr) { // no target time specified, wait on mutex
+        _Mtx_clear_owner(mtx);
+        _Primitive_wait(cond, mtx);
+        _Mtx_reset_owner(mtx);
+    } else { // target time specified, wait for it
+        _timespec64 now;
+        _Timespec64_get_sys(&now);
+        _Mtx_clear_owner(mtx);
+        if (!_Primitive_wait_for(cond, mtx, _Xtime_diff_to_millis2(target, &now))) { // report timeout
+            _Timespec64_get_sys(&now);
+            if (_Xtime_diff_to_millis2(target, &now) == 0) {
+                res = _Thrd_result::_Timedout;
+            }
+        }
+        _Mtx_reset_owner(mtx);
+    }
+    return res;
+}
+
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_signal(const _Cnd_t cond) noexcept { // release one waiting thread
+    _Primitive_notify_one(cond);
+    return _Thrd_result::_Success; // TRANSITION, ABI: Always succeeds
+}
+
+_CRTIMP2_PURE _Thrd_result __cdecl _Cnd_broadcast(const _Cnd_t cond) noexcept { // release all waiting threads
+    _Primitive_notify_all(cond);
+    return _Thrd_result::_Success; // TRANSITION, ABI: Always succeeds
+}
+
+} // extern "C"
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/msvc-stl/stl/src/cout.cpp b/msvc-stl/stl/src/cout.cpp
new file mode 100644
index 0000000..3a4058c
--- /dev/null
+++ b/msvc-stl/stl/src/cout.cpp
@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard output stream
+
+#include <fstream>
+#include <iostream>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL static filebuf fout(stdout);
+
+#if defined(_M_CEE_PURE)
+__PURE_APPDOMAIN_GLOBAL extern ostream cout(&fout);
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream cout(&fout);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+struct _Init_cout { // ensures that cout is initialized
+    __CLR_OR_THIS_CALL _Init_cout() { // initialize cout
+        _Ptr_cout = &cout;
+        if (_Ptr_cin != nullptr) {
+            _Ptr_cin->tie(_Ptr_cout);
+        }
+
+        if (_Ptr_cerr != nullptr) {
+            _Ptr_cerr->tie(_Ptr_cout);
+        }
+    }
+};
+
+__PURE_APPDOMAIN_GLOBAL static _Init_cout init_cout;
+
+_STD_END
diff --git a/msvc-stl/stl/src/cthread.cpp b/msvc-stl/stl/src/cthread.cpp
new file mode 100644
index 0000000..3c1c49d
--- /dev/null
+++ b/msvc-stl/stl/src/cthread.cpp
@@ -0,0 +1,200 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <bit>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <process.h>
+#include <xthreads.h>
+
+#include <Windows.h>
+
+namespace {
+    using _Thrd_start_t = int (*)(void*);
+
+    struct _Thrd_binder { // bind function pointer and data to pass to thread entry point
+        _Thrd_start_t func;
+        void* data;
+        _Cnd_t* cond;
+        _Mtx_t* mtx;
+        int* started;
+    };
+
+    using _Thrd_callback_t = unsigned int(__stdcall*)(void*);
+
+    unsigned int __stdcall _Thrd_runner(void* d) { // call thread function
+        _Thrd_binder b = *static_cast<_Thrd_binder*>(d);
+        _Mtx_lock(*b.mtx);
+        *b.started = 1;
+        _Cnd_signal(*b.cond);
+        _Mtx_unlock(*b.mtx);
+        const unsigned int res = b.func(b.data);
+        _Cnd_do_broadcast_at_thread_exit();
+        return res;
+    }
+} // unnamed namespace
+
+extern "C" {
+
+// TRANSITION, ABI: _Thrd_exit() is preserved for binary compatibility
+[[noreturn]] _CRTIMP2_PURE void __cdecl _Thrd_exit(int res) noexcept { // terminate execution of calling thread
+    _endthreadex(res);
+}
+
+// TRANSITION, ABI: _Thrd_start() is preserved for binary compatibility
+_CRTIMP2_PURE _Thrd_result __cdecl _Thrd_start(_Thrd_t* thr, _Thrd_callback_t func, void* b) noexcept {
+    // start a thread
+    thr->_Hnd = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0, func, b, 0, &thr->_Id));
+    return thr->_Hnd == nullptr ? _Thrd_result::_Error : _Thrd_result::_Success;
+}
+
+_CRTIMP2_PURE _Thrd_result __cdecl _Thrd_join(_Thrd_t thr, int* code) noexcept { // returns when thread terminates
+    if (WaitForSingleObjectEx(thr._Hnd, INFINITE, FALSE) == WAIT_FAILED) {
+        return _Thrd_result::_Error;
+    }
+
+    if (code) { // TRANSITION, ABI: code is preserved for binary compatibility
+        unsigned long res;
+        if (!GetExitCodeThread(thr._Hnd, &res)) {
+            return _Thrd_result::_Error;
+        }
+        *code = static_cast<int>(res);
+    }
+
+    return CloseHandle(thr._Hnd) ? _Thrd_result::_Success : _Thrd_result::_Error;
+}
+
+_CRTIMP2_PURE _Thrd_result __cdecl _Thrd_detach(_Thrd_t thr) noexcept {
+    // tell OS to release thread's resources when it terminates
+    return CloseHandle(thr._Hnd) ? _Thrd_result::_Success : _Thrd_result::_Error;
+}
+
+// TRANSITION, ABI: _Thrd_sleep() is preserved for binary compatibility
+_CRTIMP2_PURE void __cdecl _Thrd_sleep(const _timespec64* xt) noexcept { // suspend thread until time xt
+    _timespec64 now;
+    _Timespec64_get_sys(&now);
+    do { // sleep and check time
+        Sleep(_Xtime_diff_to_millis2(xt, &now));
+        _Timespec64_get_sys(&now);
+    } while (now.tv_sec < xt->tv_sec || now.tv_sec == xt->tv_sec && now.tv_nsec < xt->tv_nsec);
+}
+
+_CRTIMP2_PURE void __cdecl _Thrd_yield() noexcept { // surrender remainder of timeslice
+    SwitchToThread();
+}
+
+// TRANSITION, ABI: _Thrd_equal() is preserved for binary compatibility
+_CRTIMP2_PURE int __cdecl _Thrd_equal(_Thrd_t thr0, _Thrd_t thr1) noexcept {
+    // return 1 if thr0 and thr1 identify same thread
+    return thr0._Id == thr1._Id;
+}
+
+// TRANSITION, ABI: _Thrd_current() is preserved for binary compatibility
+_CRTIMP2_PURE _Thrd_t __cdecl _Thrd_current() noexcept { // return _Thrd_t identifying current thread
+    _Thrd_t result;
+    result._Hnd = nullptr;
+    result._Id  = GetCurrentThreadId();
+    return result;
+}
+
+_CRTIMP2_PURE _Thrd_id_t __cdecl _Thrd_id() noexcept { // return unique id for current thread
+    return GetCurrentThreadId();
+}
+
+_CRTIMP2_PURE unsigned int __cdecl _Thrd_hardware_concurrency() noexcept { // return number of processors
+    // Most devices have only one processor group and thus have the same buffer_size.
+#ifdef _WIN64
+    constexpr int stack_buffer_size = 48; // 16 bytes per group
+#else // ^^^ 64-bit / 32-bit vvv
+    constexpr int stack_buffer_size = 44; // 12 bytes per group
+#endif // ^^^ 32-bit ^^^
+
+    alignas(SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX) unsigned char stack_buffer[stack_buffer_size];
+    unsigned char* buffer_ptr = stack_buffer;
+    DWORD buffer_size         = stack_buffer_size;
+    _STD unique_ptr<unsigned char[]> new_buffer;
+
+    // https://learn.microsoft.com/windows/win32/api/sysinfoapi/nf-sysinfoapi-getlogicalprocessorinformationex
+    // The buffer "receives a sequence of variable-sized SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX structures".
+    for (;;) {
+        if (GetLogicalProcessorInformationEx(RelationProcessorPackage,
+                reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(buffer_ptr), &buffer_size)) {
+            unsigned int logical_processors = 0;
+
+            while (buffer_size > 0) {
+                // Each structure in the buffer describes a processor package (aka socket)...
+                const auto structure_ptr  = reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(buffer_ptr);
+                const auto structure_size = structure_ptr->Size;
+
+                // ... which contains one or more processor groups.
+                for (WORD i = 0; i != structure_ptr->Processor.GroupCount; ++i) {
+                    logical_processors += _STD popcount(structure_ptr->Processor.GroupMask[i].Mask);
+                }
+
+                // Step forward to the next structure in the buffer.
+                buffer_ptr += structure_size;
+                buffer_size -= structure_size;
+            }
+
+            return logical_processors;
+        }
+
+        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+            return 0; // API failure
+        }
+
+        new_buffer.reset(::new (_STD nothrow) unsigned char[buffer_size]);
+
+        if (!new_buffer) {
+            return 0; // allocation failure
+        }
+
+        buffer_ptr = new_buffer.get();
+    }
+}
+
+// TRANSITION, ABI: _Thrd_create() is preserved for binary compatibility
+_CRTIMP2_PURE _Thrd_result __cdecl _Thrd_create(_Thrd_t* thr, _Thrd_start_t func, void* d) noexcept { // create thread
+    _Thrd_result res;
+    _Thrd_binder b;
+    int started = 0;
+    _Cnd_internal_imp_t cond_var{};
+    _Cnd_t cond = &cond_var;
+    _Mtx_internal_imp_t mtx_var{};
+    _Mtx_t mtx = &mtx_var;
+    _Mtx_init_in_situ(mtx, _Mtx_plain);
+    b.func    = func;
+    b.data    = d;
+    b.cond    = &cond;
+    b.mtx     = &mtx;
+    b.started = &started;
+    _Mtx_lock(mtx);
+    if ((res = _Thrd_start(thr, _Thrd_runner, &b)) == _Thrd_result::_Success) { // wait for handshake
+        while (!started) {
+            _Cnd_wait(cond, mtx);
+        }
+    }
+    _Mtx_unlock(mtx);
+    return res;
+}
+
+} // extern "C"
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/msvc-stl/stl/src/dllmain.cpp b/msvc-stl/stl/src/dllmain.cpp
new file mode 100644
index 0000000..3b1c647
--- /dev/null
+++ b/msvc-stl/stl/src/dllmain.cpp
@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <internal_shared.h>
+
+#include <Windows.h>
+
+extern "C" BOOL APIENTRY DllMain(HMODULE, DWORD, LPVOID) noexcept {
+    return TRUE;
+}
diff --git a/msvc-stl/stl/src/dllmain_satellite.cpp b/msvc-stl/stl/src/dllmain_satellite.cpp
new file mode 100644
index 0000000..8e8f845
--- /dev/null
+++ b/msvc-stl/stl/src/dllmain_satellite.cpp
@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <Windows.h>
+
+// DllMain for 'satellite' DLLs which don't need TLS.
+
+extern "C" BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID) noexcept {
+    if (ul_reason_for_call == DLL_PROCESS_ATTACH) {
+        if (!DisableThreadLibraryCalls(hModule)) {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
diff --git a/msvc-stl/stl/src/excptptr.cpp b/msvc-stl/stl/src/excptptr.cpp
new file mode 100644
index 0000000..ca601c5
--- /dev/null
+++ b/msvc-stl/stl/src/excptptr.cpp
@@ -0,0 +1,535 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This implementation communicates with the EH runtime though vcruntime's per-thread-data structure; see
+// _pCurrentException in <trnsctrl.h>.
+//
+// As a result, normal EH runtime services (such as noexcept functions) are safe to use in this file.
+
+#ifndef _VCRT_ALLOW_INTERNALS
+#define _VCRT_ALLOW_INTERNALS
+#endif
+
+#include <Unknwn.h>
+#include <cstdlib> // for abort
+#include <cstring> // for memcpy
+#include <eh.h>
+#include <ehdata.h>
+#include <exception>
+#include <internal_shared.h>
+#include <malloc.h>
+#include <memory>
+#include <new>
+#include <stdexcept>
+#include <trnsctrl.h>
+#include <xcall_once.h>
+
+#include <Windows.h>
+
+// Pre-V4 managed exception code
+#define MANAGED_EXCEPTION_CODE 0xE0434F4D
+
+// V4 and later managed exception code
+#define MANAGED_EXCEPTION_CODE_V4 0xE0434352
+
+extern "C" _CRTIMP2 void* __cdecl __AdjustPointer(void*, const PMD&); // defined in frame.cpp
+
+using namespace std;
+
+namespace {
+#if defined(_M_CEE_PURE)
+    template <class _Ty>
+    _Ty& _Immortalize() { // return a reference to an object that will live forever
+        /* MAGIC */ static _Immortalizer_impl<_Ty> _Static;
+        return reinterpret_cast<_Ty&>(_Static._Storage);
+    }
+#elif !defined(_M_CEE)
+    template <class _Ty>
+    struct _Constexpr_excptptr_immortalize_impl {
+        union {
+            _Ty _Storage;
+        };
+
+        constexpr _Constexpr_excptptr_immortalize_impl() noexcept : _Storage{} {}
+
+        _Constexpr_excptptr_immortalize_impl(const _Constexpr_excptptr_immortalize_impl&)            = delete;
+        _Constexpr_excptptr_immortalize_impl& operator=(const _Constexpr_excptptr_immortalize_impl&) = delete;
+
+        _MSVC_NOOP_DTOR ~_Constexpr_excptptr_immortalize_impl() {
+            // do nothing, allowing _Ty to be used during shutdown
+        }
+    };
+
+    template <class _Ty>
+    _Constexpr_excptptr_immortalize_impl<_Ty> _Immortalize_impl;
+
+    template <class _Ty>
+    [[nodiscard]] _Ty& _Immortalize() noexcept {
+        return _Immortalize_impl<_Ty>._Storage;
+    }
+#else // ^^^ !defined(_M_CEE) / defined(_M_CEE), TRANSITION, VSO-1153256 vvv
+    template <class _Ty>
+    _Ty& _Immortalize() { // return a reference to an object that will live forever
+        static once_flag _Flag;
+        alignas(_Ty) static unsigned char _Storage[sizeof(_Ty)];
+        call_once(_Flag, [&_Storage] { ::new (static_cast<void*>(&_Storage)) _Ty(); });
+        return reinterpret_cast<_Ty&>(_Storage);
+    }
+#endif // ^^^ !defined(_M_CEE_PURE) && defined(_M_CEE), TRANSITION, VSO-1153256 ^^^
+
+    void _PopulateCppExceptionRecord(
+        _EXCEPTION_RECORD& _Record, const void* const _PExcept, ThrowInfo* _PThrow) noexcept {
+        _Record.ExceptionCode           = EH_EXCEPTION_NUMBER;
+        _Record.ExceptionFlags          = EXCEPTION_NONCONTINUABLE;
+        _Record.ExceptionRecord         = nullptr; // no SEH to chain
+        _Record.ExceptionAddress        = nullptr; // Address of exception. Will be overwritten by OS
+        _Record.NumberParameters        = EH_EXCEPTION_PARAMETERS;
+        _Record.ExceptionInformation[0] = EH_MAGIC_NUMBER1; // params.magicNumber
+        _Record.ExceptionInformation[1] = reinterpret_cast<ULONG_PTR>(_PExcept); // params.pExceptionObject
+
+        if (_PThrow && (_PThrow->attributes & TI_IsWinRT)) {
+            // The pointer to the ExceptionInfo structure is stored sizeof(void*) in front of each WinRT Exception Info.
+            const auto _PWei = (*static_cast<WINRTEXCEPTIONINFO** const*>(_PExcept))[-1];
+            _PThrow          = _PWei->throwInfo;
+        }
+
+        _Record.ExceptionInformation[2] = reinterpret_cast<ULONG_PTR>(_PThrow); // params.pThrowInfo
+
+#if _EH_RELATIVE_TYPEINFO
+        void* _ThrowImageBase =
+            _PThrow ? RtlPcToFileHeader(const_cast<void*>(static_cast<const void*>(_PThrow)), &_ThrowImageBase)
+                    : nullptr;
+        _Record.ExceptionInformation[3] = reinterpret_cast<ULONG_PTR>(_ThrowImageBase); // params.pThrowImageBase
+#endif // _EH_RELATIVE_TYPEINFO
+
+        // If the throw info indicates this throw is from a pure region,
+        // set the magic number to the Pure one, so only a pure-region
+        // catch will see it.
+        //
+        // Also use the Pure magic number on 64-bit platforms if we were unable to
+        // determine an image base, since that was the old way to determine
+        // a pure throw, before the TI_IsPure bit was added to the FuncInfo
+        // attributes field.
+        if (_PThrow
+            && ((_PThrow->attributes & TI_IsPure)
+#if _EH_RELATIVE_TYPEINFO
+                || !_ThrowImageBase
+#endif // _EH_RELATIVE_TYPEINFO
+                )) {
+            _Record.ExceptionInformation[0] = EH_PURE_MAGIC_NUMBER1;
+        }
+    }
+
+    void _CopyExceptionRecord(_EXCEPTION_RECORD& _Dest, const _EXCEPTION_RECORD& _Src) noexcept {
+        _Dest.ExceptionCode = _Src.ExceptionCode;
+        // we force EXCEPTION_NONCONTINUABLE because rethrow_exception is [[noreturn]]
+        _Dest.ExceptionFlags   = _Src.ExceptionFlags | EXCEPTION_NONCONTINUABLE;
+        _Dest.ExceptionRecord  = nullptr; // We don't chain SEH exceptions
+        _Dest.ExceptionAddress = nullptr; // Useless field to copy. It will be overwritten by RaiseException()
+        const auto _Parameters = _Src.NumberParameters;
+        _Dest.NumberParameters = _Parameters;
+
+        // copy the number of parameters in use
+        constexpr auto _Max_parameters = static_cast<DWORD>(EXCEPTION_MAXIMUM_PARAMETERS);
+        const auto _In_use             = (_STD min) (_Parameters, _Max_parameters);
+        _CSTD memcpy(_Dest.ExceptionInformation, _Src.ExceptionInformation, _In_use * sizeof(ULONG_PTR));
+        _CSTD memset(&_Dest.ExceptionInformation[_In_use], 0, (_Max_parameters - _In_use) * sizeof(ULONG_PTR));
+    }
+
+    void _CopyExceptionObject(void* _Dest, const void* _Src, const CatchableType* const _PType
+#if _EH_RELATIVE_TYPEINFO
+        ,
+        const uintptr_t _ThrowImageBase
+#endif // _EH_RELATIVE_TYPEINFO
+    ) {
+        // copy an object of type denoted by *_PType from _Src to _Dest; throws whatever the copy ctor of the type
+        // denoted by *_PType throws
+        if ((_PType->properties & CT_IsSimpleType) || _PType->copyFunction == 0) {
+            memcpy(_Dest, _Src, _PType->sizeOrOffset);
+
+            if (_PType->properties & CT_IsWinRTHandle) {
+                const auto _PUnknown = *static_cast<IUnknown* const*>(_Src);
+                if (_PUnknown) {
+                    _PUnknown->AddRef();
+                }
+            }
+            return;
+        }
+
+#if _EH_RELATIVE_TYPEINFO
+        const auto _CopyFunc = reinterpret_cast<void*>(_ThrowImageBase + _PType->copyFunction);
+#else // ^^^ _EH_RELATIVE_TYPEINFO / !_EH_RELATIVE_TYPEINFO vvv
+        const auto _CopyFunc = _PType->copyFunction;
+#endif // ^^^ !_EH_RELATIVE_TYPEINFO ^^^
+
+        const auto _Adjusted = __AdjustPointer(const_cast<void*>(_Src), _PType->thisDisplacement);
+        if (_PType->properties & CT_HasVirtualBase) {
+#ifdef _M_CEE_PURE
+            reinterpret_cast<void(__clrcall*)(void*, void*, int)>(_CopyFunc)(_Dest, _Adjusted, 1);
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+            _CallMemberFunction2(_Dest, _CopyFunc, _Adjusted, 1);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+        } else {
+#ifdef _M_CEE_PURE
+            reinterpret_cast<void(__clrcall*)(void*, void*)>(_CopyFunc)(_Dest, _Adjusted);
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+            _CallMemberFunction1(_Dest, _CopyFunc, _Adjusted);
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+        }
+    }
+} // unnamed namespace
+
+// All exception_ptr implementations are out-of-line because <memory> depends on <exception>,
+// which means <exception> cannot include <memory> -- and shared_ptr is defined in <memory>.
+// To workaround this, we created a dummy class exception_ptr, which is structurally identical to shared_ptr.
+
+_STD_BEGIN
+struct _Exception_ptr_access {
+    template <class _Ty, class _Ty2>
+    static void _Set_ptr_rep(_Ptr_base<_Ty>& _This, _Ty2* _Px, _Ref_count_base* _Rx) noexcept {
+        _This._Ptr = _Px;
+        _This._Rep = _Rx;
+    }
+};
+_STD_END
+
+static_assert(sizeof(exception_ptr) == sizeof(shared_ptr<const _EXCEPTION_RECORD>)
+                  && alignof(exception_ptr) == alignof(shared_ptr<const _EXCEPTION_RECORD>),
+    "std::exception_ptr and std::shared_ptr<const _EXCEPTION_RECORD> must have the same layout.");
+
+namespace {
+    template <class _StaticEx>
+    class _ExceptionPtr_static final : public _Ref_count_base {
+        // reference count control block for special "never allocates" exceptions like the bad_alloc or bad_exception
+        // exception_ptrs
+    private:
+        void _Destroy() noexcept override {
+            // intentionally does nothing
+        }
+
+        void _Delete_this() noexcept override {
+            // intentionally does nothing
+        }
+
+    public:
+        // constexpr, TRANSITION P1064
+        explicit _ExceptionPtr_static() noexcept : _Ref_count_base() {
+            _PopulateCppExceptionRecord(_ExRecord, &_Ex, static_cast<ThrowInfo*>(__GetExceptionInfo(_Ex)));
+        }
+
+        static shared_ptr<const _EXCEPTION_RECORD> _Get() noexcept {
+            auto& _Instance = _Immortalize<_ExceptionPtr_static>();
+            shared_ptr<const _EXCEPTION_RECORD> _Ret;
+            _Instance._Incref();
+            _Exception_ptr_access::_Set_ptr_rep(_Ret, &_Instance._ExRecord, &_Instance);
+            return _Ret;
+        }
+
+        _EXCEPTION_RECORD _ExRecord;
+        _StaticEx _Ex;
+    };
+
+    class _ExceptionPtr_normal final : public _Ref_count_base {
+        // reference count control block for exception_ptrs; the exception object is stored at
+        // reinterpret_cast<unsigned char*>(this) + sizeof(_ExceptionPtr_normal)
+    private:
+        void _Destroy() noexcept override {
+            // call the destructor for a stored pure or native C++ exception if necessary
+            const auto& _CppEhRecord = reinterpret_cast<EHExceptionRecord&>(_ExRecord);
+
+            if (!PER_IS_MSVC_PURE_OR_NATIVE_EH(&_CppEhRecord)) {
+                return;
+            }
+
+            const auto _PThrow = _CppEhRecord.params.pThrowInfo;
+            if (!_PThrow) {
+                // No ThrowInfo exists. If this was a C++ exception, something must have corrupted it.
+                _CSTD abort();
+            }
+
+            if (!_CppEhRecord.params.pExceptionObject) {
+                return;
+            }
+
+#if _EH_RELATIVE_TYPEINFO
+            const auto _ThrowImageBase     = reinterpret_cast<uintptr_t>(_CppEhRecord.params.pThrowImageBase);
+            const auto _CatchableTypeArray = reinterpret_cast<const CatchableTypeArray*>(
+                static_cast<uintptr_t>(_PThrow->pCatchableTypeArray) + _ThrowImageBase);
+            const auto _PType = reinterpret_cast<CatchableType*>(
+                static_cast<uintptr_t>(_CatchableTypeArray->arrayOfCatchableTypes[0]) + _ThrowImageBase);
+#else // ^^^ _EH_RELATIVE_TYPEINFO / !_EH_RELATIVE_TYPEINFO vvv
+            const auto _PType = _PThrow->pCatchableTypeArray->arrayOfCatchableTypes[0];
+#endif // ^^^ !_EH_RELATIVE_TYPEINFO ^^^
+
+            if (_PThrow->pmfnUnwind) {
+                // The exception was a user defined type with a nontrivial destructor, call it
+#if defined(_M_CEE_PURE)
+                reinterpret_cast<void(__clrcall*)(void*)>(_PThrow->pmfnUnwind)(_CppEhRecord.params.pExceptionObject);
+#elif _EH_RELATIVE_TYPEINFO
+                _CallMemberFunction0(_CppEhRecord.params.pExceptionObject,
+                    reinterpret_cast<void*>(_PThrow->pmfnUnwind + _ThrowImageBase));
+#else // ^^^ _EH_RELATIVE_TYPEINFO && !defined(_M_CEE_PURE) / !_EH_RELATIVE_TYPEINFO && !defined(_M_CEE_PURE) vvv
+                _CallMemberFunction0(_CppEhRecord.params.pExceptionObject, _PThrow->pmfnUnwind);
+#endif // ^^^ !_EH_RELATIVE_TYPEINFO && !defined(_M_CEE_PURE) ^^^
+            } else if (_PType->properties & CT_IsWinRTHandle) {
+                const auto _PUnknown = *static_cast<IUnknown* const*>(_CppEhRecord.params.pExceptionObject);
+                if (_PUnknown) {
+                    _PUnknown->Release();
+                }
+            }
+        }
+
+        void _Delete_this() noexcept override {
+            free(this);
+        }
+
+    public:
+        explicit _ExceptionPtr_normal(const _EXCEPTION_RECORD& _Record) noexcept : _Ref_count_base() {
+            _CopyExceptionRecord(_ExRecord, _Record);
+        }
+
+        _EXCEPTION_RECORD _ExRecord;
+        void* _Unused_alignment_padding{};
+    };
+
+    // We aren't using alignas because this file might be compiled with _M_CEE_PURE
+    static_assert(sizeof(_ExceptionPtr_normal) % __STDCPP_DEFAULT_NEW_ALIGNMENT__ == 0,
+        "Exception in exception_ptr would be constructed with the wrong alignment");
+
+    void _Assign_seh_exception_ptr_from_record(
+        shared_ptr<const _EXCEPTION_RECORD>& _Dest, const _EXCEPTION_RECORD& _Record, void* const _RxRaw) noexcept {
+        // in the memory _RxRaw, constructs a reference count control block for a SEH exception denoted by _Record
+        // if _RxRaw is nullptr, assigns bad_alloc instead
+        if (!_RxRaw) {
+            _Dest = _ExceptionPtr_static<bad_alloc>::_Get();
+            return;
+        }
+
+        const auto _Rx = ::new (_RxRaw) _ExceptionPtr_normal(_Record);
+        _Exception_ptr_access::_Set_ptr_rep(_Dest, &_Rx->_ExRecord, _Rx);
+    }
+
+    void _Assign_cpp_exception_ptr_from_record(
+        shared_ptr<const _EXCEPTION_RECORD>& _Dest, const EHExceptionRecord& _Record) noexcept {
+        // construct a reference count control block for the C++ exception recorded by _Record, and bind it to _Dest
+        // if allocating memory for the reference count control block fails, sets _Dest to bad_alloc
+        // if copying the exception object referred to _Record throws, constructs a reference count control block for
+        //      that exception instead
+        // if copying the exception object thrown by copying the original exception object throws, sets _Dest to
+        //      bad_exception
+        const auto _PThrow = _Record.params.pThrowInfo;
+#if _EH_RELATIVE_TYPEINFO
+        const auto _ThrowImageBase     = reinterpret_cast<uintptr_t>(_Record.params.pThrowImageBase);
+        const auto _CatchableTypeArray = reinterpret_cast<const CatchableTypeArray*>(
+            static_cast<uintptr_t>(_PThrow->pCatchableTypeArray) + _ThrowImageBase);
+        const auto _PType = reinterpret_cast<CatchableType*>(
+            static_cast<uintptr_t>(_CatchableTypeArray->arrayOfCatchableTypes[0]) + _ThrowImageBase);
+#else // ^^^ _EH_RELATIVE_TYPEINFO / !_EH_RELATIVE_TYPEINFO vvv
+        const auto _PType = _PThrow->pCatchableTypeArray->arrayOfCatchableTypes[0];
+#endif // ^^^ !_EH_RELATIVE_TYPEINFO ^^^
+
+        const auto _ExceptionObjectSize = static_cast<size_t>(_PType->sizeOrOffset);
+        const auto _AllocSize           = sizeof(_ExceptionPtr_normal) + _ExceptionObjectSize;
+        _Analysis_assume_(_AllocSize >= sizeof(_ExceptionPtr_normal));
+        auto _RxRaw = malloc(_AllocSize);
+        if (!_RxRaw) {
+            _Dest = _ExceptionPtr_static<bad_alloc>::_Get();
+            return;
+        }
+
+        try {
+            _CopyExceptionObject(static_cast<_ExceptionPtr_normal*>(_RxRaw) + 1, _Record.params.pExceptionObject, _PType
+#if _EH_RELATIVE_TYPEINFO
+                ,
+                _ThrowImageBase
+#endif // _EH_RELATIVE_TYPEINFO
+            );
+
+            const auto _Rx = ::new (_RxRaw) _ExceptionPtr_normal(reinterpret_cast<const _EXCEPTION_RECORD&>(_Record));
+            reinterpret_cast<EHExceptionRecord&>(_Rx->_ExRecord).params.pExceptionObject =
+                static_cast<_ExceptionPtr_normal*>(_RxRaw) + 1;
+            _Exception_ptr_access::_Set_ptr_rep(_Dest, &_Rx->_ExRecord, _Rx);
+        } catch (...) { // copying the exception object threw an exception
+            const auto& _InnerRecord = *_pCurrentException; // exception thrown by the original exception's copy ctor
+            if (_InnerRecord.ExceptionCode == MANAGED_EXCEPTION_CODE
+                || _InnerRecord.ExceptionCode == MANAGED_EXCEPTION_CODE_V4) {
+                // we don't support managed exceptions and don't want to say there's no active exception, so give up and
+                // say bad_exception
+                free(_RxRaw);
+                _Dest = _ExceptionPtr_static<bad_exception>::_Get();
+                return;
+            }
+
+            if (!PER_IS_MSVC_PURE_OR_NATIVE_EH(&_InnerRecord)) { // catching a non-C++ exception depends on /EHa
+                _Assign_seh_exception_ptr_from_record(
+                    _Dest, reinterpret_cast<const _EXCEPTION_RECORD&>(_InnerRecord), _RxRaw);
+                return;
+            }
+
+            const auto _PInnerThrow = _InnerRecord.params.pThrowInfo;
+#if _EH_RELATIVE_TYPEINFO
+            const auto _InnerThrowImageBase     = reinterpret_cast<uintptr_t>(_InnerRecord.params.pThrowImageBase);
+            const auto _InnerCatchableTypeArray = reinterpret_cast<const CatchableTypeArray*>(
+                static_cast<uintptr_t>(_PInnerThrow->pCatchableTypeArray) + _InnerThrowImageBase);
+            const auto _PInnerType = reinterpret_cast<CatchableType*>(
+                static_cast<uintptr_t>(_InnerCatchableTypeArray->arrayOfCatchableTypes[0]) + _InnerThrowImageBase);
+#else // ^^^ _EH_RELATIVE_TYPEINFO / !_EH_RELATIVE_TYPEINFO vvv
+            const auto _PInnerType = _PInnerThrow->pCatchableTypeArray->arrayOfCatchableTypes[0];
+#endif // ^^^ !_EH_RELATIVE_TYPEINFO ^^^
+
+            const auto _InnerExceptionSize = static_cast<size_t>(_PInnerType->sizeOrOffset);
+            const auto _InnerAllocSize     = sizeof(_ExceptionPtr_normal) + _InnerExceptionSize;
+            if (_InnerAllocSize > _AllocSize) {
+                free(_RxRaw);
+                _RxRaw = malloc(_InnerAllocSize);
+                if (!_RxRaw) {
+                    _Dest = _ExceptionPtr_static<bad_alloc>::_Get();
+                    return;
+                }
+            }
+
+            try {
+                _CopyExceptionObject(
+                    static_cast<_ExceptionPtr_normal*>(_RxRaw) + 1, _InnerRecord.params.pExceptionObject, _PInnerType
+#if _EH_RELATIVE_TYPEINFO
+                    ,
+                    _ThrowImageBase
+#endif // _EH_RELATIVE_TYPEINFO
+                );
+            } catch (...) { // copying the exception emitted while copying the original exception also threw, give up
+                free(_RxRaw);
+                _Dest = _ExceptionPtr_static<bad_exception>::_Get();
+                return;
+            }
+
+            // this next block must be duplicated inside the catch (even though it looks identical to the block in the
+            // try) so that _InnerRecord is held alive; exiting the catch will destroy it
+            const auto _Rx =
+                ::new (_RxRaw) _ExceptionPtr_normal(reinterpret_cast<const _EXCEPTION_RECORD&>(_InnerRecord));
+            reinterpret_cast<EHExceptionRecord&>(_Rx->_ExRecord).params.pExceptionObject =
+                static_cast<_ExceptionPtr_normal*>(_RxRaw) + 1;
+            _Exception_ptr_access::_Set_ptr_rep(_Dest, &_Rx->_ExRecord, _Rx);
+        }
+    }
+} // unnamed namespace
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void* _Ptr) noexcept {
+    ::new (_Ptr) shared_ptr<const _EXCEPTION_RECORD>();
+}
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void* _Ptr) noexcept {
+    static_cast<shared_ptr<const _EXCEPTION_RECORD>*>(_Ptr)->~shared_ptr<const _EXCEPTION_RECORD>();
+}
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void* _Dest, _In_ const void* _Src) noexcept {
+    ::new (_Dest) shared_ptr<const _EXCEPTION_RECORD>(*static_cast<const shared_ptr<const _EXCEPTION_RECORD>*>(_Src));
+}
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrAssign(_Inout_ void* _Dest, _In_ const void* _Src) noexcept {
+    *static_cast<shared_ptr<const _EXCEPTION_RECORD>*>(_Dest) =
+        *static_cast<const shared_ptr<const _EXCEPTION_RECORD>*>(_Src);
+}
+
+_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrCompare(
+    _In_ const void* _Lhs, _In_ const void* _Rhs) noexcept {
+    return *static_cast<const shared_ptr<const _EXCEPTION_RECORD>*>(_Lhs)
+        == *static_cast<const shared_ptr<const _EXCEPTION_RECORD>*>(_Rhs);
+}
+
+_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL __ExceptionPtrToBool(_In_ const void* _Ptr) noexcept {
+    return static_cast<bool>(*static_cast<const shared_ptr<const _EXCEPTION_RECORD>*>(_Ptr));
+}
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(_Inout_ void* _Lhs, _Inout_ void* _Rhs) noexcept {
+    static_cast<shared_ptr<const _EXCEPTION_RECORD>*>(_Lhs)->swap(
+        *static_cast<shared_ptr<const _EXCEPTION_RECORD>*>(_Rhs));
+}
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCurrentException(void* _Ptr) noexcept {
+    const auto _PRecord = _pCurrentException; // nontrivial FLS cost, pay it once
+    if (!_PRecord || _PRecord->ExceptionCode == MANAGED_EXCEPTION_CODE
+        || _PRecord->ExceptionCode == MANAGED_EXCEPTION_CODE_V4) {
+        return; // no current exception, or we don't support managed exceptions
+    }
+
+    auto& _Dest = *static_cast<shared_ptr<const _EXCEPTION_RECORD>*>(_Ptr);
+    if (PER_IS_MSVC_PURE_OR_NATIVE_EH(_PRecord)) {
+        _Assign_cpp_exception_ptr_from_record(_Dest, *_PRecord);
+    } else {
+        // _Assign_seh_exception_ptr_from_record handles failed malloc
+        _Assign_seh_exception_ptr_from_record(
+            _Dest, reinterpret_cast<_EXCEPTION_RECORD&>(*_PRecord), malloc(sizeof(_ExceptionPtr_normal)));
+    }
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrRethrow(_In_ const void* _PtrRaw) {
+    const shared_ptr<const _EXCEPTION_RECORD>* _Ptr = static_cast<const shared_ptr<const _EXCEPTION_RECORD>*>(_PtrRaw);
+    // throwing a bad_exception if they give us a nullptr exception_ptr
+    if (!*_Ptr) {
+        throw bad_exception();
+    }
+
+    auto _RecordCopy = **_Ptr;
+    auto& _CppRecord = reinterpret_cast<EHExceptionRecord&>(_RecordCopy);
+    if (PER_IS_MSVC_PURE_OR_NATIVE_EH(&_CppRecord)) {
+        // This is a C++ exception.
+        // We need to build the exception on the stack because the current exception mechanism assumes the exception
+        // object is on the stack and will call the appropriate destructor (if there's a nontrivial one).
+        const auto _PThrow = _CppRecord.params.pThrowInfo;
+        if (!_CppRecord.params.pExceptionObject || !_PThrow || !_PThrow->pCatchableTypeArray) {
+            // Missing or corrupt ThrowInfo. If this was a C++ exception, something must have corrupted it.
+            _CSTD abort();
+        }
+
+#if _EH_RELATIVE_TYPEINFO
+        const auto _ThrowImageBase = reinterpret_cast<uintptr_t>(_CppRecord.params.pThrowImageBase);
+        const auto _CatchableTypeArray =
+            reinterpret_cast<const CatchableTypeArray*>(_ThrowImageBase + _PThrow->pCatchableTypeArray);
+#else // ^^^ _EH_RELATIVE_TYPEINFO / !_EH_RELATIVE_TYPEINFO vvv
+        const auto _CatchableTypeArray = _PThrow->pCatchableTypeArray;
+#endif // ^^^ !_EH_RELATIVE_TYPEINFO ^^^
+
+        if (_CatchableTypeArray->nCatchableTypes <= 0) {
+            // Ditto corrupted.
+            _CSTD abort();
+        }
+
+        // we finally got the type info we want
+#if _EH_RELATIVE_TYPEINFO
+        const auto _PType = reinterpret_cast<CatchableType*>(
+            static_cast<uintptr_t>(_CatchableTypeArray->arrayOfCatchableTypes[0]) + _ThrowImageBase);
+#else // ^^^ _EH_RELATIVE_TYPEINFO / !_EH_RELATIVE_TYPEINFO vvv
+        const auto _PType = _PThrow->pCatchableTypeArray->arrayOfCatchableTypes[0];
+#endif // ^^^ !_EH_RELATIVE_TYPEINFO ^^^
+
+        // Alloc memory on stack for exception object. This might cause a stack overflow SEH exception, or another C++
+        // exception when copying the C++ exception object. In that case, we just let that become the thrown exception.
+
+#pragma warning(push)
+#pragma warning(disable : 6255) //  _alloca indicates failure by raising a stack overflow exception
+        void* _PExceptionBuffer = alloca(_PType->sizeOrOffset);
+#pragma warning(pop)
+        _CopyExceptionObject(_PExceptionBuffer, _CppRecord.params.pExceptionObject, _PType
+#if _EH_RELATIVE_TYPEINFO
+            ,
+            _ThrowImageBase
+#endif // _EH_RELATIVE_TYPEINFO
+        );
+
+        _CppRecord.params.pExceptionObject = _PExceptionBuffer;
+    } else {
+        // this is a SEH exception, no special handling is required
+    }
+
+    _Analysis_assume_(_RecordCopy.NumberParameters <= EXCEPTION_MAXIMUM_PARAMETERS);
+    RaiseException(_RecordCopy.ExceptionCode, _RecordCopy.ExceptionFlags, _RecordCopy.NumberParameters,
+        _RecordCopy.ExceptionInformation);
+}
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopyException(
+    _Inout_ void* _Ptr, _In_ const void* _PExceptRaw, _In_ const void* _PThrowRaw) noexcept {
+    _EXCEPTION_RECORD _Record;
+    _PopulateCppExceptionRecord(_Record, _PExceptRaw, static_cast<ThrowInfo*>(_PThrowRaw));
+    _Assign_cpp_exception_ptr_from_record(
+        *static_cast<shared_ptr<const _EXCEPTION_RECORD>*>(_Ptr), reinterpret_cast<const EHExceptionRecord&>(_Record));
+}
diff --git a/msvc-stl/stl/src/filesys.cpp b/msvc-stl/stl/src/filesys.cpp
new file mode 100644
index 0000000..67aace3
--- /dev/null
+++ b/msvc-stl/stl/src/filesys.cpp
@@ -0,0 +1,500 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// filesys.cpp -- <experimental/filesystem> implementation
+// (see filesystem.cpp for C++17 <filesystem> implementation)
+
+// TRANSITION, ABI: Everything in this file is preserved for binary compatibility.
+
+#include <yvals.h>
+
+#include <cstdint>
+#include <cstring>
+#include <direct.h>
+#include <io.h>
+#include <string>
+
+#include <Windows.h>
+
+#define _MAX_FILESYS_NAME 260 // longest Windows or Posix filename + 1
+
+#define _FS_BEGIN              \
+    _STD_BEGIN                 \
+    namespace experimental {   \
+        namespace filesystem { \
+            inline namespace v1 {
+
+#define _FS_END \
+    }           \
+    }           \
+    }           \
+    _STD_END
+
+#ifdef _M_CEE_PURE
+#define __crtGetTempPath2W(BufferLength, Buffer) GetTempPathW(BufferLength, Buffer)
+#else // vvv !defined(_M_CEE_PURE) vvv
+extern "C" _Success_(return > 0 && return < BufferLength) DWORD __stdcall __crtGetTempPath2W(
+    _In_ DWORD BufferLength, _Out_writes_to_opt_(BufferLength, return +1) LPWSTR Buffer) noexcept;
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+_FS_BEGIN
+
+enum class file_type { // names for file types
+    not_found = -1,
+    none,
+    regular,
+    directory,
+    symlink,
+    block,
+    character,
+    fifo,
+    socket,
+    unknown
+};
+
+enum class perms { // names for permissions
+    none             = 0,
+    owner_read       = 0400, // S_IRUSR
+    owner_write      = 0200, // S_IWUSR
+    owner_exec       = 0100, // S_IXUSR
+    owner_all        = 0700, // S_IRWXU
+    group_read       = 040, // S_IRGRP
+    group_write      = 020, // S_IWGRP
+    group_exec       = 010, // S_IXGRP
+    group_all        = 070, // S_IRWXG
+    others_read      = 04, // S_IROTH
+    others_write     = 02, // S_IWOTH
+    others_exec      = 01, // S_IXOTH
+    others_all       = 07, // S_IRWXO
+    all              = 0777,
+    set_uid          = 04000, // S_ISUID
+    set_gid          = 02000, // S_ISGID
+    sticky_bit       = 01000, // S_ISVTX
+    mask             = 07777,
+    unknown          = 0xFFFF,
+    add_perms        = 0x10000,
+    remove_perms     = 0x20000,
+    resolve_symlinks = 0x40000
+};
+
+_BITMASK_OPS(_EMPTY_ARGUMENT, perms)
+
+struct space_info { // space information for a file
+    uintmax_t capacity;
+    uintmax_t free;
+    uintmax_t available;
+};
+
+static file_type _Map_mode(int _Mode) { // map Windows file attributes to file_status
+    constexpr int _File_attribute_regular =
+        FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_HIDDEN
+        | FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED | FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_READONLY
+        | FILE_ATTRIBUTE_SPARSE_FILE | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_TEMPORARY;
+
+    if ((_Mode & FILE_ATTRIBUTE_DIRECTORY) != 0) {
+        return file_type::directory;
+    } else if ((_Mode & _File_attribute_regular) != 0) {
+        return file_type::regular;
+    } else {
+        return file_type::unknown;
+    }
+}
+
+extern "C" _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Close_dir(void* _Handle) noexcept { // close a directory
+    FindClose(_Handle);
+}
+
+static wchar_t* _Strcpy(wchar_t (&_Dest)[_MAX_FILESYS_NAME], const wchar_t* _Src) { // copy an NTCTS
+    ::wcscpy_s(_Dest, _MAX_FILESYS_NAME, _Src);
+    return _Dest;
+}
+
+static HANDLE _FilesysOpenFile(const wchar_t* _Fname, DWORD _Desired_access, DWORD _Flags) {
+    CREATEFILE2_EXTENDED_PARAMETERS _Create_file_parameters = {};
+    _Create_file_parameters.dwSize                          = sizeof(_Create_file_parameters);
+    _Create_file_parameters.dwFileFlags                     = _Flags;
+
+    return CreateFile2(_Fname, _Desired_access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, OPEN_EXISTING,
+        &_Create_file_parameters);
+}
+
+extern "C" _CRTIMP2_PURE wchar_t* __CLRCALL_PURE_OR_CDECL _Read_dir(
+    wchar_t (&_Dest)[_MAX_FILESYS_NAME], void* _Handle, file_type& _Ftype) noexcept { // read a directory entry
+    WIN32_FIND_DATAW _Dentry;
+
+    while (FindNextFileW(_Handle, &_Dentry)) {
+        if (_Dentry.cFileName[0] != L'.'
+            || (_Dentry.cFileName[1] != L'\0'
+                && (_Dentry.cFileName[1] != L'.'
+                    || _Dentry.cFileName[2] != L'\0'))) { // not "." or "..", get file type and return name
+            _Ftype = _Map_mode(_Dentry.dwFileAttributes);
+            return _Strcpy(_Dest, &_Dentry.cFileName[0]);
+        }
+    }
+
+    _Ftype = file_type::unknown;
+    return _Strcpy(_Dest, L"");
+}
+
+static unsigned int _Filesys_code_page() { // determine appropriate code page
+    if (AreFileApisANSI()) {
+        return CP_ACP;
+    } else {
+        return CP_OEMCP;
+    }
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _To_wide(const char* _Bsrc, wchar_t* _Wdest) noexcept {
+    // return nonzero on success
+    return MultiByteToWideChar(_Filesys_code_page(), 0, _Bsrc, -1, _Wdest, _MAX_FILESYS_NAME);
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _To_byte(const wchar_t* _Wsrc, char* _Bdest) noexcept {
+    // return nonzero on success
+    return WideCharToMultiByte(_Filesys_code_page(), 0, _Wsrc, -1, _Bdest, _MAX_FILESYS_NAME, nullptr, nullptr);
+}
+
+extern "C" _CRTIMP2_PURE void* __CLRCALL_PURE_OR_CDECL _Open_dir(
+    wchar_t (&_Dest)[_MAX_FILESYS_NAME], const wchar_t* _Dirname, int& _Errno, file_type& _Ftype) noexcept {
+    // open a directory for reading
+    WIN32_FIND_DATAW _Dentry;
+    wstring _Wildname(_Dirname);
+    if (!_Wildname.empty()) {
+        _Wildname.append(L"\\*");
+    }
+
+    void* _Handle =
+        FindFirstFileExW(_Wildname.c_str(), FindExInfoStandard, &_Dentry, FindExSearchNameMatch, nullptr, 0);
+    if (_Handle == INVALID_HANDLE_VALUE) { // report failure
+        _Errno = ERROR_BAD_PATHNAME;
+        *_Dest = L'\0';
+        return nullptr;
+    }
+
+    // success, get first directory entry
+    _Errno = 0;
+    if (_Dentry.cFileName[0] == L'.'
+        && (_Dentry.cFileName[1] == L'\0'
+            || _Dentry.cFileName[1] == L'.' && _Dentry.cFileName[2] == L'\0')) { // skip "." and ".."
+        _Read_dir(_Dest, _Handle, _Ftype);
+        if (_Dest[0] == L'\0') {
+            // no entries, release handle
+            _Close_dir(_Handle);
+            return nullptr;
+        }
+        return _Handle;
+    }
+
+    // get file type and return handle
+    _Strcpy(_Dest, _Dentry.cFileName);
+    _Ftype = _Map_mode(_Dentry.dwFileAttributes);
+    return _Handle;
+}
+
+extern "C" _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL _Current_get(wchar_t (&_Dest)[_MAX_FILESYS_NAME]) noexcept {
+    // get current working directory
+    _Strcpy(_Dest, L"");
+    return _wgetcwd(_Dest, _MAX_FILESYS_NAME) != nullptr;
+}
+
+extern "C" _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL _Current_set(const wchar_t* _Dirname) noexcept {
+    // set current working directory
+    return _wchdir(_Dirname) == 0;
+}
+
+extern "C" _CRTIMP2_PURE wchar_t* __CLRCALL_PURE_OR_CDECL _Symlink_get(
+    wchar_t (&_Dest)[_MAX_FILESYS_NAME], const wchar_t*) noexcept {
+    // get symlink -- DUMMY
+    _Dest[0] = L'\0';
+    return _Dest;
+}
+
+extern "C" _CRTIMP2_PURE wchar_t* __CLRCALL_PURE_OR_CDECL _Temp_get(wchar_t (&_Dest)[_MAX_FILESYS_NAME]) noexcept {
+    // get temp directory
+    wchar_t _Dentry[MAX_PATH];
+    return _Strcpy(_Dest, __crtGetTempPath2W(MAX_PATH, _Dentry) != 0 ? _Dentry : L".");
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Make_dir(const wchar_t* _Fname, const wchar_t*) noexcept {
+    // make a new directory (ignore attributes)
+    if (CreateDirectoryW(_Fname, nullptr)) {
+        return 1;
+    } else if (GetLastError() == ERROR_ALREADY_EXISTS) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+extern "C" _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL _Remove_dir(
+    const wchar_t* _Fname) noexcept { // remove a directory
+    return _wrmdir(_Fname) != -1;
+}
+
+extern "C" _CRTIMP2_PURE file_type __CLRCALL_PURE_OR_CDECL _Stat(
+    const wchar_t* _Fname, perms* _Pmode) noexcept { // get file status
+    WIN32_FILE_ATTRIBUTE_DATA _Data;
+
+    if (GetFileAttributesExW(_Fname, GetFileExInfoStandard, &_Data)) {
+        // get file type and return permissions
+        if (_Pmode != nullptr) {
+            constexpr perms _Write_perms    = perms::owner_write | perms::group_write | perms::others_write;
+            constexpr perms _Readonly_perms = perms::all & ~_Write_perms;
+
+            *_Pmode = (_Data.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0u ? _Readonly_perms : perms::all;
+        }
+
+        return _Map_mode(_Data.dwFileAttributes);
+    }
+
+    // invalid, get error code
+    switch (GetLastError()) {
+    case ERROR_FILE_NOT_FOUND:
+    case ERROR_PATH_NOT_FOUND:
+    case ERROR_INVALID_NAME:
+    case ERROR_INVALID_DRIVE:
+    case ERROR_INVALID_PARAMETER:
+    case ERROR_BAD_NETPATH:
+    case ERROR_BAD_PATHNAME:
+        return file_type::not_found;
+    default:
+        return file_type::unknown;
+    }
+}
+
+extern "C" _CRTIMP2_PURE file_type __CLRCALL_PURE_OR_CDECL _Lstat(const wchar_t* _Fname, perms* _Pmode) noexcept {
+    // get symlink file status
+    return _Stat(_Fname, _Pmode); // symlink not supported
+}
+
+extern "C" _CRTIMP2_PURE uintmax_t __CLRCALL_PURE_OR_CDECL _Hard_links(const wchar_t* _Fname) noexcept {
+    // get hard link count
+    HANDLE _Handle = _FilesysOpenFile(_Fname, FILE_READ_ATTRIBUTES, FILE_FLAG_BACKUP_SEMANTICS);
+
+    if (_Handle == INVALID_HANDLE_VALUE) {
+        return static_cast<uintmax_t>(-1);
+    }
+
+    FILE_STANDARD_INFO _Info = {0};
+
+    // get file info
+    const auto _Ok = GetFileInformationByHandleEx(_Handle, FileStandardInfo, &_Info, sizeof(_Info));
+    CloseHandle(_Handle);
+    return _Ok ? _Info.NumberOfLinks : static_cast<uintmax_t>(-1);
+}
+
+extern "C" _CRTIMP2_PURE uintmax_t __CLRCALL_PURE_OR_CDECL _File_size(const wchar_t* _Fname) noexcept { // get file size
+    WIN32_FILE_ATTRIBUTE_DATA _Data;
+
+    if (GetFileAttributesExW(_Fname, GetFileExInfoStandard, &_Data)) {
+        return static_cast<uintmax_t>(_Data.nFileSizeHigh) << 32 | _Data.nFileSizeLow;
+    } else {
+        return static_cast<uintmax_t>(-1);
+    }
+}
+
+// 3 centuries with 24 leap years each:
+// 1600 is excluded, 1700/1800 are not leap years
+// 1 partial century with 17 leap years:
+// 1900 is not a leap year
+// 1904 is leap year number 1
+// 1908 is leap year number 2
+// 1968 is leap year number 17
+
+constexpr uint64_t _Win_ticks_per_second = 10000000ULL;
+constexpr uint64_t _Win_ticks_from_epoch = ((1970 - 1601) * 365 + 3 * 24 + 17) * 86400ULL * _Win_ticks_per_second;
+
+extern "C" _CRTIMP2_PURE int64_t __CLRCALL_PURE_OR_CDECL _Last_write_time(
+    const wchar_t* _Fname) noexcept { // get last write time
+    WIN32_FILE_ATTRIBUTE_DATA _Data;
+
+    if (!GetFileAttributesExW(_Fname, GetFileExInfoStandard, &_Data)) {
+        return -1;
+    }
+
+    // success, convert time
+    uint64_t _Wtime =
+        static_cast<uint64_t>(_Data.ftLastWriteTime.dwHighDateTime) << 32 | _Data.ftLastWriteTime.dwLowDateTime;
+    return static_cast<int64_t>(_Wtime - _Win_ticks_from_epoch);
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Set_last_write_time(
+    const wchar_t* _Fname, int64_t _When) noexcept {
+    // set last write time
+    HANDLE _Handle = _FilesysOpenFile(_Fname, FILE_WRITE_ATTRIBUTES, FILE_FLAG_BACKUP_SEMANTICS);
+
+    if (_Handle == INVALID_HANDLE_VALUE) {
+        return 0;
+    }
+
+    // convert to FILETIME and set
+    uint64_t _Wtime = static_cast<uint64_t>(_When) + _Win_ticks_from_epoch;
+    FILETIME _Ft;
+    _Ft.dwLowDateTime  = static_cast<DWORD>(_Wtime & 0xFFFFFFFFUL);
+    _Ft.dwHighDateTime = static_cast<DWORD>(_Wtime >> 32);
+    int _Result        = SetFileTime(_Handle, nullptr, nullptr, &_Ft);
+    CloseHandle(_Handle);
+    return _Result;
+}
+
+extern "C" _CRTIMP2_PURE space_info __CLRCALL_PURE_OR_CDECL _Statvfs(const wchar_t* _Fname) noexcept {
+    // get space information for volume
+    space_info _Ans  = {static_cast<uintmax_t>(-1), static_cast<uintmax_t>(-1), static_cast<uintmax_t>(-1)};
+    wstring _Devname = _Fname;
+
+    if (_Devname.empty() || _Devname.back() != L'/' && _Devname.back() != L'\\') {
+        _Devname.push_back(L'/');
+    }
+
+    _ULARGE_INTEGER _Available;
+    _ULARGE_INTEGER _Capacity;
+    _ULARGE_INTEGER _Free;
+
+    if (GetDiskFreeSpaceExW(_Devname.c_str(), &_Available, &_Capacity, &_Free)) { // convert values
+        _Ans.capacity  = _Capacity.QuadPart;
+        _Ans.free      = _Free.QuadPart;
+        _Ans.available = _Available.QuadPart;
+    }
+    return _Ans;
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Equivalent(
+    const wchar_t* _Fname1, const wchar_t* _Fname2) noexcept { // test for equivalent file names
+    // See GH-3571: File IDs are only guaranteed to be unique and stable while handles remain open
+    HANDLE _Handle1 = _FilesysOpenFile(_Fname1, FILE_READ_ATTRIBUTES, FILE_FLAG_BACKUP_SEMANTICS);
+    HANDLE _Handle2 = _FilesysOpenFile(_Fname2, FILE_READ_ATTRIBUTES, FILE_FLAG_BACKUP_SEMANTICS);
+
+    bool _Ok1   = false;
+    bool _Ok2   = false;
+    int _Result = -1; // negative indicates error
+
+    {
+        // If we can get FILE_ID_INFO, use that as the source of truth.
+        _FILE_ID_INFO _Info1 = {0};
+        _FILE_ID_INFO _Info2 = {0};
+
+        if (_Handle1 != INVALID_HANDLE_VALUE) {
+            _Ok1 = GetFileInformationByHandleEx(_Handle1, FileIdInfo, &_Info1, sizeof(_Info1)) != 0;
+        }
+
+        if (_Handle2 != INVALID_HANDLE_VALUE) {
+            _Ok2 = GetFileInformationByHandleEx(_Handle2, FileIdInfo, &_Info2, sizeof(_Info2)) != 0;
+        }
+
+        if (_Ok1 && _Ok2) { // test existing files for equivalence
+            _Result = memcmp(&_Info1, &_Info2, sizeof(_FILE_ID_INFO)) == 0 ? 1 : 0;
+        } else if (_Ok1 || _Ok2) { // one file exists, the other doesn't
+            _Result = 0;
+        }
+    }
+
+    if (_Result < 0) {
+        // Some filesystems don't support FILE_ID_INFO's 128-bit file identifiers.
+        // Try GetFileInformationByHandle() as a fallback.
+        BY_HANDLE_FILE_INFORMATION _Info1 = {0};
+        BY_HANDLE_FILE_INFORMATION _Info2 = {0};
+
+        if (_Handle1 != INVALID_HANDLE_VALUE) {
+            _Ok1 = GetFileInformationByHandle(_Handle1, &_Info1) != 0;
+        }
+
+        if (_Handle2 != INVALID_HANDLE_VALUE) {
+            _Ok2 = GetFileInformationByHandle(_Handle2, &_Info2) != 0;
+        }
+
+        if (_Ok1 && _Ok2) { // test existing files for equivalence
+            _Result = static_cast<int>(_Info1.dwVolumeSerialNumber == _Info2.dwVolumeSerialNumber
+                                       && _Info1.nFileIndexHigh == _Info2.nFileIndexHigh
+                                       && _Info1.nFileIndexLow == _Info2.nFileIndexLow);
+        } else if (_Ok1 || _Ok2) { // one file exists, the other doesn't
+            _Result = 0;
+        }
+    }
+
+    if (_Handle1 != INVALID_HANDLE_VALUE) {
+        CloseHandle(_Handle1);
+    }
+
+    if (_Handle2 != INVALID_HANDLE_VALUE) {
+        CloseHandle(_Handle2);
+    }
+
+    return _Result;
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Link(const wchar_t* _Fname1, const wchar_t* _Fname2) noexcept {
+    // link _Fname2 to _Fname1
+    return CreateHardLinkW(_Fname2, _Fname1, nullptr) ? 0 : GetLastError();
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Symlink(const wchar_t* _Fname1, const wchar_t* _Fname2) noexcept {
+    // link _Fname2 to _Fname1
+    return CreateSymbolicLinkW(_Fname2, _Fname1, 0) ? 0 : GetLastError();
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Rename(const wchar_t* _Fname1, const wchar_t* _Fname2) noexcept {
+    // rename _Fname1 as _Fname2
+    return _wrename(_Fname1, _Fname2) == 0 ? 0 : GetLastError();
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Resize(
+    const wchar_t* _Fname, uintmax_t _Newsize) noexcept { // change file size
+
+    HANDLE _Handle = _FilesysOpenFile(_Fname, FILE_GENERIC_WRITE, 0);
+
+    if (_Handle == INVALID_HANDLE_VALUE) {
+        return GetLastError();
+    }
+
+    FILE_END_OF_FILE_INFO _File_info;
+    _File_info.EndOfFile.QuadPart = static_cast<LONGLONG>(_Newsize);
+
+    const auto _Ok = SetFileInformationByHandle(_Handle, FileEndOfFileInfo, &_File_info, sizeof(_File_info));
+
+    CloseHandle(_Handle);
+    return _Ok ? 0 : GetLastError();
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Unlink(const wchar_t* _Fname) noexcept { // unlink _Fname
+    return _wremove(_Fname) == 0 ? 0 : GetLastError();
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Copy_file(
+    const wchar_t* _Fname1, const wchar_t* _Fname2) noexcept {
+    // copy _Fname1 to _Fname2
+    COPYFILE2_EXTENDED_PARAMETERS _Params = {0};
+    _Params.dwSize                        = sizeof(COPYFILE2_EXTENDED_PARAMETERS);
+    _Params.dwCopyFlags                   = 0;
+
+    const HRESULT _Copy_result = CopyFile2(_Fname1, _Fname2, &_Params);
+    if (SUCCEEDED(_Copy_result)) {
+        return 0;
+    }
+
+    // take lower bits to undo HRESULT_FROM_WIN32
+    return _Copy_result & 0x0000FFFFU;
+}
+
+extern "C" _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Chmod(const wchar_t* _Fname, perms _Newmode) noexcept {
+    // change file mode to _Newmode
+    WIN32_FILE_ATTRIBUTE_DATA _Data;
+
+    if (!GetFileAttributesExW(_Fname, GetFileExInfoStandard, &_Data)) {
+        return -1;
+    }
+
+    // got mode, alter readonly bit
+    DWORD _Oldmode = _Data.dwFileAttributes;
+    DWORD _Mode    = _Oldmode;
+
+    constexpr perms _Write_perms = perms::owner_write | perms::group_write | perms::others_write;
+
+    if ((_Newmode & _Write_perms) == perms::none) {
+        _Mode |= FILE_ATTRIBUTE_READONLY;
+    } else {
+        _Mode &= ~FILE_ATTRIBUTE_READONLY;
+    }
+
+    return _Mode == _Oldmode || SetFileAttributesW(_Fname, _Mode) ? 0 : -1;
+}
+_FS_END
diff --git a/msvc-stl/stl/src/filesystem.cpp b/msvc-stl/stl/src/filesystem.cpp
new file mode 100644
index 0000000..a59fc42
--- /dev/null
+++ b/msvc-stl/stl/src/filesystem.cpp
@@ -0,0 +1,1039 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// filesystem.cpp -- C++17 <filesystem> implementation
+
+#include <clocale>
+#include <corecrt_terminate.h>
+#include <cstdlib>
+#include <cstring>
+#include <internal_shared.h>
+#include <xfilesystem_abi.h>
+
+#include <Windows.h>
+#include <winioctl.h>
+
+// We have several switches that do not have case statements for every possible enum value.
+// Hence, disabling this warning.
+#pragma warning(disable : 4061) // enumerator '__std_win_error::_Success' in switch of enum
+                                // '__std_win_error' is not explicitly handled by a case label
+
+static_assert(__std_code_page::_Utf8 == __std_code_page{CP_UTF8});
+
+namespace {
+    HANDLE __stdcall __vcp_CreateFile(const wchar_t* const _File_name, const unsigned long _Desired_access,
+        const unsigned long _Share, SECURITY_ATTRIBUTES* const _Security_attributes,
+        const unsigned long _Creation_disposition, const unsigned long _Flags_and_attributes,
+        const HANDLE _Template_file) noexcept {
+        CREATEFILE2_EXTENDED_PARAMETERS _Create_file_parameters{};
+        _Create_file_parameters.dwSize               = sizeof(_Create_file_parameters);
+        _Create_file_parameters.dwFileAttributes     = _Flags_and_attributes & 0x0000FFFFU;
+        _Create_file_parameters.dwFileFlags          = _Flags_and_attributes & 0xFFFF0000U;
+        _Create_file_parameters.lpSecurityAttributes = _Security_attributes;
+        _Create_file_parameters.hTemplateFile        = _Template_file;
+        return CreateFile2(_File_name, _Desired_access, _Share, _Creation_disposition, &_Create_file_parameters);
+    }
+
+    [[nodiscard]] __std_win_error __stdcall _Translate_CreateFile_last_error(const HANDLE _Handle) {
+        if (_Handle != INVALID_HANDLE_VALUE) {
+            return __std_win_error::_Success;
+        }
+
+        return __std_win_error{GetLastError()};
+    }
+
+    [[nodiscard]] __std_fs_copy_file_result __stdcall __vcp_Copyfile(
+        const wchar_t* const _Source, const wchar_t* const _Target, const bool _Fail_if_exists) noexcept {
+        COPYFILE2_EXTENDED_PARAMETERS _Params{};
+        _Params.dwSize      = sizeof(_Params);
+        _Params.dwCopyFlags = _Fail_if_exists ? COPY_FILE_FAIL_IF_EXISTS : 0;
+
+        const HRESULT _Copy_result = CopyFile2(_Source, _Target, &_Params);
+        if (SUCCEEDED(_Copy_result)) {
+            return {true, __std_win_error::_Success};
+        }
+
+        // take lower bits to undo HRESULT_FROM_WIN32
+        return {false, __std_win_error{_Copy_result & 0x0000FFFFU}};
+    }
+
+    [[nodiscard]] __std_win_error __stdcall _Create_symlink(
+        const wchar_t* const _Symlink_file_name, const wchar_t* const _Target_file_name, const DWORD _Flags) noexcept {
+        if (CreateSymbolicLinkW(
+                _Symlink_file_name, _Target_file_name, _Flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE)) {
+            return __std_win_error::_Success;
+        }
+
+        DWORD _Last_error = GetLastError();
+        if (_Last_error == ERROR_INVALID_PARAMETER) {
+            if (CreateSymbolicLinkW(_Symlink_file_name, _Target_file_name, _Flags)) {
+                return __std_win_error::_Success;
+            }
+
+            _Last_error = GetLastError();
+        }
+
+        return __std_win_error{_Last_error};
+    }
+
+    [[nodiscard]] __std_win_error __stdcall _Translate_not_found_to_success(const __std_win_error _Err) noexcept {
+        if (__std_is_file_not_found(_Err)) {
+            return __std_win_error::_Success;
+        }
+
+        return _Err;
+    }
+
+    [[nodiscard]] __std_win_error __stdcall _Get_last_write_time_by_handle(
+        const HANDLE _Handle, long long* const _Last_write_filetime) {
+        // read the last write time from _Handle and store it in _Last_write_filetime
+        FILE_BASIC_INFO _Ex_info;
+        if (GetFileInformationByHandleEx(_Handle, FileBasicInfo, &_Ex_info, sizeof(_Ex_info))) {
+            *_Last_write_filetime = _Ex_info.LastWriteTime.QuadPart;
+            return __std_win_error::_Success;
+        }
+
+        return __std_win_error{GetLastError()};
+    }
+
+    [[nodiscard]] __std_win_error __stdcall _Get_file_id_by_handle(
+        const HANDLE _Handle, _Out_ FILE_ID_INFO* const _Id) noexcept {
+        if (GetFileInformationByHandleEx(_Handle, FileIdInfo, _Id, sizeof(*_Id))) {
+            // if we could get FILE_ID_INFO, use that as the source of truth
+            return __std_win_error::_Success;
+        }
+
+        __std_win_error _Last_error{GetLastError()};
+
+        switch (_Last_error) {
+        case __std_win_error::_Not_supported:
+        case __std_win_error::_Invalid_parameter:
+            break; // try more things
+        default:
+            return _Last_error; // real error, bail to the caller
+        }
+
+        // Some filesystems don't support FILE_ID_INFO's 128-bit file identifiers.
+        // Try GetFileInformationByHandle() as a fallback.
+        BY_HANDLE_FILE_INFORMATION _Info;
+        if (GetFileInformationByHandle(_Handle, &_Info)) {
+            _Id->VolumeSerialNumber = _Info.dwVolumeSerialNumber;
+            _CSTD memcpy(&_Id->FileId.Identifier[0], &_Info.nFileIndexHigh, 4);
+            _CSTD memcpy(&_Id->FileId.Identifier[4], &_Info.nFileIndexLow, 4);
+            _CSTD memset(&_Id->FileId.Identifier[8], 0, 8);
+            return __std_win_error::_Success;
+        }
+
+        _Last_error = __std_win_error{GetLastError()};
+
+        return _Last_error;
+    }
+
+    [[nodiscard]] _Success_(return == __std_win_error::_Success) __std_win_error __stdcall _Set_delete_flag(
+        _In_ __std_fs_file_handle _Handle) {
+
+        // See minwinbase.h and WinBase.h.
+        FILE_DISPOSITION_INFO_EX _Info_ex{FILE_DISPOSITION_FLAG_DELETE | FILE_DISPOSITION_FLAG_POSIX_SEMANTICS};
+        if (SetFileInformationByHandle(
+                reinterpret_cast<HANDLE>(_Handle), FileDispositionInfoEx, &_Info_ex, sizeof(_Info_ex))) {
+            return __std_win_error::_Success;
+        }
+
+        const __std_win_error _Last_error{GetLastError()};
+        switch (_Last_error) {
+        case __std_win_error::_Invalid_parameter: // Older Windows versions
+        case __std_win_error::_Invalid_function: // Windows 10 1607
+        case __std_win_error::_Not_supported: // POSIX delete not supported by the file system
+            break; // try non-POSIX delete below
+        case __std_win_error::_Access_denied: // This might be due to the read-only bit, try to clear it and try again
+        default:
+            return _Last_error;
+        }
+
+        FILE_DISPOSITION_INFO _Info{/* .Delete= */ TRUE};
+        if (SetFileInformationByHandle(reinterpret_cast<HANDLE>(_Handle), FileDispositionInfo, &_Info, sizeof(_Info))) {
+            return __std_win_error::_Success;
+        }
+
+        return __std_win_error{GetLastError()};
+    }
+
+    [[nodiscard]] unsigned long long _Merge_to_ull(DWORD _High, DWORD _Low) noexcept {
+        return (static_cast<unsigned long long>(_High) << 32) | static_cast<unsigned long long>(_Low);
+    }
+} // unnamed namespace
+
+extern "C" {
+
+[[nodiscard]] __std_ulong_and_error __stdcall __std_fs_get_full_path_name(_In_z_ const wchar_t* _Source,
+    _In_ unsigned long _Target_size, _Out_writes_z_(_Target_size) wchar_t* _Target) noexcept { // calls GetFullPathNameW
+    const auto _Result = GetFullPathNameW(_Source, _Target_size, _Target, nullptr);
+    return {_Result, _Result == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_open_handle(_Out_ __std_fs_file_handle* const _Handle,
+    _In_z_ const wchar_t* const _File_name, _In_ const __std_access_rights _Desired_access,
+    _In_ const __std_fs_file_flags _Flags) noexcept { // calls CreateFile2 or CreateFileW
+    const HANDLE _Result = __vcp_CreateFile(_File_name, static_cast<unsigned long>(_Desired_access),
+        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING,
+        static_cast<unsigned long>(_Flags), nullptr);
+    *_Handle             = static_cast<__std_fs_file_handle>(reinterpret_cast<intptr_t>(_Result));
+    return _Translate_CreateFile_last_error(_Result);
+}
+
+void __stdcall __std_fs_close_handle(const __std_fs_file_handle _Handle) noexcept { // calls CloseHandle
+    if (_Handle != __std_fs_file_handle::_Invalid && !CloseHandle(reinterpret_cast<HANDLE>(_Handle))) {
+        _CSTD abort();
+    }
+}
+
+[[nodiscard]] _Success_(return == __std_win_error::_Success) __std_win_error __stdcall
+    __std_fs_get_file_attributes_by_handle(
+        _In_ const __std_fs_file_handle _Handle, _Out_ unsigned long* const _File_attributes) noexcept {
+    // read the attributes from _Handle and store it in _File_attributes
+    const HANDLE _As_plain_handle = reinterpret_cast<HANDLE>(_Handle);
+
+    FILE_BASIC_INFO _Ex_info;
+    if (GetFileInformationByHandleEx(_As_plain_handle, FileBasicInfo, &_Ex_info, sizeof(_Ex_info))) {
+        *_File_attributes = _Ex_info.FileAttributes;
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] __std_ulong_and_error __stdcall __std_fs_get_final_path_name_by_handle(
+    _In_ const __std_fs_file_handle _Handle, _Out_writes_z_(_Target_size) wchar_t* const _Target,
+    _In_ const unsigned long _Target_size,
+    _In_ const __std_fs_volume_name_kind _Flags) noexcept { // calls GetFinalPathNameByHandleW
+    const auto _Result = GetFinalPathNameByHandleW(
+        reinterpret_cast<HANDLE>(_Handle), _Target, _Target_size, static_cast<unsigned long>(_Flags));
+    return {_Result, _Result == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success};
+}
+
+static_assert(sizeof(WIN32_FIND_DATAW) == sizeof(__std_fs_find_data));
+static_assert(alignof(WIN32_FIND_DATAW) == alignof(__std_fs_find_data));
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_directory_iterator_open(_In_z_ const wchar_t* const _Path_spec,
+    _Inout_ __std_fs_dir_handle* const _Handle, _Out_ __std_fs_find_data* const _Results) noexcept {
+    __std_fs_directory_iterator_close(*_Handle);
+    *_Handle = __std_fs_dir_handle{reinterpret_cast<intptr_t>(
+        FindFirstFileExW(_Path_spec, FindExInfoBasic, _Results, FindExSearchNameMatch, nullptr, 0))};
+    if (*_Handle != __std_fs_dir_handle::_Invalid) {
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+void __stdcall __std_fs_directory_iterator_close(_In_ const __std_fs_dir_handle _Handle) noexcept {
+    if (_Handle != __std_fs_dir_handle::_Invalid && !FindClose(reinterpret_cast<HANDLE>(_Handle))) {
+        _CSTD abort();
+    }
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_directory_iterator_advance(
+    _In_ const __std_fs_dir_handle _Handle, _Out_ __std_fs_find_data* const _Results) noexcept {
+    if (FindNextFileW(reinterpret_cast<HANDLE>(_Handle), reinterpret_cast<WIN32_FIND_DATAW*>(_Results))) {
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] __std_code_page __stdcall __std_fs_code_page() noexcept {
+    if (___lc_codepage_func() == CP_UTF8) {
+        return __std_code_page{CP_UTF8};
+    }
+
+    if (!AreFileApisANSI()) {
+        return __std_code_page{CP_OEMCP};
+    }
+
+    return __std_code_page{CP_ACP};
+}
+
+[[nodiscard]] __std_fs_convert_result __stdcall __std_fs_convert_narrow_to_wide(_In_ const __std_code_page _Code_page,
+    _In_reads_(_Input_len) const char* const _Input_str, _In_ const int _Input_len,
+    _Out_writes_opt_(_Output_len) wchar_t* const _Output_str, _In_ const int _Output_len) noexcept {
+    const int _Len = MultiByteToWideChar(
+        static_cast<unsigned int>(_Code_page), MB_ERR_INVALID_CHARS, _Input_str, _Input_len, _Output_str, _Output_len);
+    return {_Len, _Len == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success};
+}
+
+[[nodiscard]] __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow(_In_ const __std_code_page _Code_page,
+    _In_reads_(_Input_len) const wchar_t* const _Input_str, _In_ const int _Input_len,
+    _Out_writes_opt_(_Output_len) char* const _Output_str, _In_ const int _Output_len) noexcept {
+    __std_fs_convert_result _Result;
+
+    if (_Code_page == __std_code_page{CP_UTF8} || _Code_page == __std_code_page{54936}) {
+        // For UTF-8 or GB18030, attempt to use WC_ERR_INVALID_CHARS. (These codepages can't use WC_NO_BEST_FIT_CHARS
+        // below, and other codepages can't use WC_ERR_INVALID_CHARS.)
+        _Result._Len = WideCharToMultiByte(static_cast<unsigned int>(_Code_page), WC_ERR_INVALID_CHARS, _Input_str,
+            _Input_len, _Output_str, _Output_len, nullptr, nullptr);
+    } else { // For other codepages, attempt to use WC_NO_BEST_FIT_CHARS.
+             // Codepages that don't support this will activate the ERROR_INVALID_FLAGS fallback below.
+        BOOL _Used_default_char = FALSE;
+
+        _Result._Len = WideCharToMultiByte(static_cast<unsigned int>(_Code_page), WC_NO_BEST_FIT_CHARS, _Input_str,
+            _Input_len, _Output_str, _Output_len, nullptr, &_Used_default_char);
+
+        if (_Used_default_char) { // Report round-tripping failure with ERROR_NO_UNICODE_TRANSLATION,
+                                  // "No mapping for the Unicode character exists in the target multi-byte code page."
+            return {0, __std_win_error{ERROR_NO_UNICODE_TRANSLATION}};
+        }
+    }
+
+    _Result._Err = _Result._Len == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success;
+
+    if (_Result._Err == __std_win_error{ERROR_INVALID_FLAGS}) { // Fall back to a non-strict conversion.
+        _Result._Len = WideCharToMultiByte(static_cast<unsigned int>(_Code_page), 0, _Input_str, _Input_len,
+            _Output_str, _Output_len, nullptr, nullptr);
+
+        _Result._Err = _Result._Len == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success;
+    }
+
+    return _Result;
+}
+
+[[nodiscard]] __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow_replace_chars(
+    _In_ const __std_code_page _Code_page, _In_reads_(_Input_len) const wchar_t* const _Input_str,
+    _In_ const int _Input_len, _Out_writes_opt_(_Output_len) char* const _Output_str,
+    _In_ const int _Output_len) noexcept {
+    __std_fs_convert_result _Result;
+
+    _Result._Len = WideCharToMultiByte(static_cast<unsigned int>(_Code_page), WC_NO_BEST_FIT_CHARS, _Input_str,
+        _Input_len, _Output_str, _Output_len, nullptr, nullptr);
+
+    _Result._Err = _Result._Len == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success;
+
+    // Some codepages don't support WC_NO_BEST_FIT_CHARS, fall back to default conversion.
+    if (_Result._Err == __std_win_error{ERROR_INVALID_FLAGS}) {
+        _Result._Len = WideCharToMultiByte(static_cast<unsigned int>(_Code_page), 0, _Input_str, _Input_len,
+            _Output_str, _Output_len, nullptr, nullptr);
+
+        _Result._Err = _Result._Len == 0 ? __std_win_error{GetLastError()} : __std_win_error::_Success;
+    }
+
+    return _Result;
+}
+
+[[nodiscard]] __std_fs_copy_file_result __stdcall __std_fs_copy_file(_In_z_ const wchar_t* const _Source,
+    _In_z_ const wchar_t* const _Target, _In_ __std_fs_copy_options _Options) noexcept { // copy _Source to _Target
+    _Options &= __std_fs_copy_options::_Existing_mask;
+    if (_Options != __std_fs_copy_options::_Overwrite_existing) {
+        const __std_fs_copy_file_result _First_try_result =
+            __vcp_Copyfile(_Source, _Target, /* _Fail_if_exists = */ true);
+        if (_First_try_result._Error != __std_win_error::_File_exists // successful copy or I/O error
+            || _Options == __std_fs_copy_options::_None) { // caller requested fail if exists behavior
+            return _First_try_result;
+        }
+
+        // At this point, the target exists, and we are `skip_existing` or `update_existing`.
+        // To resolve either, we need to open handles to test `equivalent()` and `last_write_time()`.
+        // We allow other programs to have these files open in read-only mode,
+        // since that doesn't affect the last-write-check.
+        // We also allow `FILE_SHARE_WRITE` when `skip_existing`, since that doesn't affect anything.
+        {
+            DWORD _Share_mode = FILE_SHARE_READ;
+            if (_Options == __std_fs_copy_options::_Skip_existing) {
+                _Share_mode |= FILE_SHARE_WRITE;
+            }
+
+            const _STD _Fs_file _Source_handle(
+                __vcp_CreateFile(_Source, FILE_READ_ATTRIBUTES, _Share_mode, nullptr, OPEN_EXISTING, 0, nullptr));
+            __std_win_error _Last_error = _Translate_CreateFile_last_error(_Source_handle._Get());
+            if (_Last_error != __std_win_error::_Success) {
+                return {false, _Last_error};
+            }
+
+            const _STD _Fs_file _Target_handle(
+                __vcp_CreateFile(_Target, FILE_READ_ATTRIBUTES, _Share_mode, nullptr, OPEN_EXISTING, 0, nullptr));
+            _Last_error = _Translate_CreateFile_last_error(_Target_handle._Get());
+            if (_Last_error != __std_win_error::_Success) {
+                return {false, _Last_error};
+            }
+
+            bool _Do_copy = false;
+            if (_Options == __std_fs_copy_options::_Update_existing) {
+                long long _Source_last_write_time;
+                _Last_error = _Get_last_write_time_by_handle(_Source_handle._Get(), &_Source_last_write_time);
+                if (_Last_error != __std_win_error::_Success) {
+                    return {false, _Last_error};
+                }
+
+                long long _Target_last_write_time;
+                _Last_error = _Get_last_write_time_by_handle(_Target_handle._Get(), &_Target_last_write_time);
+                if (_Last_error != __std_win_error::_Success) {
+                    return {false, _Last_error};
+                }
+
+                if (_Target_last_write_time < _Source_last_write_time) { // _Source is newer, so update_existing
+                    _Do_copy = true;
+                }
+            }
+
+            if (!_Do_copy) {
+                // We only need to test `equivalent()` if we _aren't_ going to `CopyFile2()`,
+                // since that call will fail with an `ERROR_SHARING_VIOLATION` anyways.
+                FILE_ID_INFO _Source_id;
+                _Last_error = _Get_file_id_by_handle(_Source_handle._Get(), &_Source_id);
+                if (_Last_error != __std_win_error::_Success) {
+                    return {false, _Last_error};
+                }
+                FILE_ID_INFO _Target_id;
+                _Last_error = _Get_file_id_by_handle(_Target_handle._Get(), &_Target_id);
+                if (_Last_error != __std_win_error::_Success) {
+                    return {false, _Last_error};
+                }
+
+                if (_CSTD memcmp(&_Source_id, &_Target_id, sizeof(FILE_ID_INFO)) == 0) {
+                    // the files are equivalent
+                    return {false, __std_win_error::_Sharing_violation};
+                }
+
+                return {false, __std_win_error::_Success};
+            }
+
+            // if we get here, we've decided we want to overwrite the destination due to update_existing,
+            // so fall through to the overwrite_existing path below
+        } // close handles
+    } // !_Overwrite_existing
+
+    // The following errors were observed through experimentation:
+    // is_regular_file(from) is false => ERROR_ACCESS_DENIED
+    // exists(to) is true and is_regular_file(to) is false => ERROR_ACCESS_DENIED
+    // exists(to) is true and equivalent(from, to) is true => ERROR_SHARING_VIOLATION
+    return __vcp_Copyfile(_Source, _Target, /* _Fail_if_exists = */ false);
+}
+
+struct __std_fs_file_id { // typedef struct _FILE_ID_INFO {
+    unsigned long long _Volume_serial_number; //    ULONGLONG VolumeSerialNumber;
+    unsigned char _Id[16]; //    FILE_ID_128 FileId;
+}; // } FILE_ID_INFO, ...;
+
+// TRANSITION, ABI: preserved for binary compatibility
+[[nodiscard]] _Success_(return == __std_win_error::_Success) __std_win_error __stdcall __std_fs_get_file_id(
+    _Out_ __std_fs_file_id* const _Id, _In_z_ const wchar_t* const _Path) noexcept {
+    __std_win_error _Last_error;
+    const _STD _Fs_file _Handle(
+        _Path, __std_access_rights::_File_read_attributes, __std_fs_file_flags::_Backup_semantics, &_Last_error);
+    if (_Last_error != __std_win_error::_Success) {
+        return _Last_error;
+    }
+
+    static_assert(sizeof(FILE_ID_INFO) == sizeof(__std_fs_file_id));
+    static_assert(alignof(FILE_ID_INFO) == alignof(__std_fs_file_id));
+    return _Get_file_id_by_handle(_Handle._Get(), reinterpret_cast<FILE_ID_INFO*>(_Id));
+}
+
+[[nodiscard]] __std_fs_equivalent_result __stdcall __std_fs_equivalent(
+    _In_z_ const wchar_t* const _Left_path, _In_z_ const wchar_t* const _Right_path) noexcept {
+    // See GH-3571: File IDs are only guaranteed to be unique and stable while handles remain open
+    __std_win_error _Last_error;
+    const _STD _Fs_file _Left_handle(
+        _Left_path, __std_access_rights::_File_read_attributes, __std_fs_file_flags::_Backup_semantics, &_Last_error);
+    if (_Last_error != __std_win_error::_Success) {
+        return {false, _Last_error};
+    }
+
+    FILE_ID_INFO _Left_info;
+    _Last_error = _Get_file_id_by_handle(_Left_handle._Get(), &_Left_info);
+    if (_Last_error != __std_win_error::_Success) {
+        return {false, _Last_error};
+    }
+
+    const _STD _Fs_file _Right_handle(
+        _Right_path, __std_access_rights::_File_read_attributes, __std_fs_file_flags::_Backup_semantics, &_Last_error);
+    if (_Last_error != __std_win_error::_Success) {
+        return {false, _Last_error};
+    }
+
+    FILE_ID_INFO _Right_info;
+    _Last_error = _Get_file_id_by_handle(_Right_handle._Get(), &_Right_info);
+    if (_Last_error != __std_win_error::_Success) {
+        return {false, _Last_error};
+    }
+
+    return {_CSTD memcmp(&_Left_info, &_Right_info, sizeof(FILE_ID_INFO)) == 0, __std_win_error::_Success};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_create_directory_symbolic_link(
+    _In_z_ const wchar_t* const _Symlink_file_name, _In_z_ const wchar_t* const _Target_file_name) noexcept {
+    return _Create_symlink(_Symlink_file_name, _Target_file_name, SYMBOLIC_LINK_FLAG_DIRECTORY);
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_create_hard_link(
+    _In_z_ const wchar_t* const _File_name, _In_z_ const wchar_t* const _Existing_file_name) noexcept {
+    if (CreateHardLinkW(_File_name, _Existing_file_name, nullptr)) {
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_create_symbolic_link(
+    _In_z_ const wchar_t* const _Symlink_file_name, _In_z_ const wchar_t* const _Target_file_name) noexcept {
+    return _Create_symlink(_Symlink_file_name, _Target_file_name, 0);
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_read_reparse_data_buffer(_In_ const __std_fs_file_handle _Handle,
+    _Out_writes_bytes_(_Buffer_size) void* const _Buffer, _In_ const unsigned long _Buffer_size) noexcept {
+    unsigned long _Bytes_returned;
+    if (DeviceIoControl(reinterpret_cast<HANDLE>(_Handle), FSCTL_GET_REPARSE_POINT, nullptr, 0, _Buffer, _Buffer_size,
+            &_Bytes_returned, nullptr)) {
+        return __std_win_error::_Success;
+    }
+
+    // If DeviceIoControl fails, _Bytes_returned is 0.
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_write_reparse_data_buffer(
+    _In_ const __std_fs_file_handle _Handle, _In_ const __std_fs_reparse_data_buffer* const _Buffer) noexcept {
+    constexpr unsigned long _Reparse_data_buffer_header_size = 8; // REPARSE_DATA_BUFFER_HEADER_SIZE
+    const auto _Buffer_size = _Reparse_data_buffer_header_size + _Buffer->_Reparse_data_length;
+    if (DeviceIoControl(reinterpret_cast<HANDLE>(_Handle), FSCTL_SET_REPARSE_POINT,
+            const_cast<__std_fs_reparse_data_buffer*>(_Buffer), _Buffer_size, nullptr, 0, nullptr, nullptr)) {
+        return __std_win_error::_Success;
+    }
+
+    // If DeviceIoControl fails, _Bytes_returned is 0.
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] bool __stdcall __std_fs_is_junction_from_reparse_data_buffer(
+    _In_ const __std_fs_reparse_data_buffer* const _Buffer) noexcept {
+    return _Buffer->_Reparse_tag == IO_REPARSE_TAG_MOUNT_POINT;
+}
+
+[[nodiscard]] _Success_(return == __std_win_error::_Success) __std_win_error __stdcall
+    __std_fs_read_name_from_reparse_data_buffer(_In_ __std_fs_reparse_data_buffer* const _Buffer,
+        _Out_ wchar_t** const _Offset, _Out_ unsigned short* const _Length) noexcept {
+    if (_Buffer->_Reparse_tag == IO_REPARSE_TAG_SYMLINK) {
+        auto& _Symlink_buffer             = _Buffer->_Symbolic_link_reparse_buffer;
+        const unsigned short _Temp_length = _Symlink_buffer._Print_name_length / sizeof(wchar_t);
+
+        if (_Temp_length == 0) {
+            *_Length = _Symlink_buffer._Substitute_name_length / sizeof(wchar_t);
+            *_Offset = &_Symlink_buffer._Path_buffer[_Symlink_buffer._Substitute_name_offset / sizeof(wchar_t)];
+        } else {
+            *_Length = _Temp_length;
+            *_Offset = &_Symlink_buffer._Path_buffer[_Symlink_buffer._Print_name_offset / sizeof(wchar_t)];
+        }
+    } else if (_Buffer->_Reparse_tag == IO_REPARSE_TAG_MOUNT_POINT) {
+        // junction
+        auto& _Junction_buffer            = _Buffer->_Mount_point_reparse_buffer;
+        const unsigned short _Temp_length = _Junction_buffer._Print_name_length / sizeof(wchar_t);
+
+        if (_Temp_length == 0) {
+            *_Length = _Junction_buffer._Substitute_name_length / sizeof(wchar_t);
+            *_Offset = &_Junction_buffer._Path_buffer[_Junction_buffer._Substitute_name_offset / sizeof(wchar_t)];
+        } else {
+            *_Length = _Temp_length;
+            *_Offset = &_Junction_buffer._Path_buffer[_Junction_buffer._Print_name_offset / sizeof(wchar_t)];
+        }
+    } else {
+        return __std_win_error::_Reparse_tag_invalid;
+    }
+
+    return __std_win_error::_Success;
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_set_last_write_time(
+    _In_ const long long _Last_write_filetime, _In_z_ const wchar_t* const _Path) noexcept {
+    __std_win_error _Last_error;
+    const _STD _Fs_file _Handle(
+        _Path, __std_access_rights::_File_write_attributes, __std_fs_file_flags::_Backup_semantics, &_Last_error);
+    if (_Last_error != __std_win_error::_Success) {
+        return _Last_error;
+    }
+
+    if (SetFileTime(_Handle._Get(), nullptr, nullptr, reinterpret_cast<const FILETIME*>(&_Last_write_filetime))) {
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] __std_fs_remove_result __stdcall __std_fs_remove(_In_z_ const wchar_t* const _Target) noexcept {
+    // remove _Target without caring whether _Target is a file or directory
+    __std_win_error _Last_error;
+    bool _Able_to_change_attributes = false;
+
+    constexpr auto _Flags = __std_fs_file_flags::_Backup_semantics | __std_fs_file_flags::_Open_reparse_point;
+    _STD _Fs_file _Handle(_Target,
+        __std_access_rights::_Delete | __std_access_rights::_File_read_attributes
+            | __std_access_rights::_File_write_attributes,
+        _Flags, &_Last_error);
+    if (_Last_error == __std_win_error::_Success) {
+        _Able_to_change_attributes = true;
+    } else if (_Last_error == __std_win_error::_Access_denied) {
+        // change the underlying HANDLE of _Handle
+        _Last_error = __std_fs_open_handle(&_Handle._Raw, _Target, __std_access_rights::_Delete, _Flags);
+        if (_Last_error != __std_win_error::_Success) {
+            return {false, _Last_error};
+        }
+    } else {
+        return {false, _Translate_not_found_to_success(_Last_error)};
+    }
+
+    // See minwinbase.h and WinBase.h.
+    // Windows 10 1809 added support for FILE_DISPOSITION_FLAG_IGNORE_READONLY_ATTRIBUTE.
+    FILE_DISPOSITION_INFO_EX _Info_ex{FILE_DISPOSITION_FLAG_DELETE | FILE_DISPOSITION_FLAG_POSIX_SEMANTICS
+                                      | FILE_DISPOSITION_FLAG_IGNORE_READONLY_ATTRIBUTE};
+    if (SetFileInformationByHandle(_Handle._Get(), FileDispositionInfoEx, &_Info_ex, sizeof(_Info_ex))) {
+        return {true, __std_win_error::_Success};
+    }
+
+    _Last_error = __std_win_error{GetLastError()};
+    switch (_Last_error) {
+    // Windows versions older than 1809
+    case __std_win_error::_Invalid_parameter:
+    case __std_win_error::_Invalid_function:
+    case __std_win_error::_Not_supported:
+        break;
+    default:
+        // If we fail for reasons other than those mentioned above just return to the caller
+        return {false, _Last_error};
+    }
+
+    // code path for versions older than 1809
+    _Last_error = _Set_delete_flag(_Handle._Raw);
+    if (_Last_error == __std_win_error::_Success) {
+        return {true, __std_win_error::_Success};
+    }
+
+    if (_Last_error == __std_win_error::_Access_denied && _Able_to_change_attributes) {
+        FILE_BASIC_INFO _Basic_info;
+        if (!GetFileInformationByHandleEx(_Handle._Get(), FileBasicInfo, &_Basic_info, sizeof(_Basic_info))) {
+            return {false, __std_win_error{GetLastError()}};
+        }
+        // check if FILE_ATTRIBUTE_READONLY is set
+        if ((_Basic_info.FileAttributes & FILE_ATTRIBUTE_READONLY) != 0u) {
+            // try to remove FILE_ATTRIBUTE_READONLY
+            _Basic_info.FileAttributes ^= FILE_ATTRIBUTE_READONLY;
+            if (!SetFileInformationByHandle(_Handle._Get(), FileBasicInfo, &_Basic_info, sizeof(_Basic_info))) {
+                return {false, __std_win_error{GetLastError()}};
+            }
+            // removed FILE_ATTRIBUTE_READONLY, now try to set the delete flag again
+            _Last_error = _Set_delete_flag(_Handle._Raw);
+            if (_Last_error == __std_win_error::_Success) {
+                return {true, __std_win_error::_Success};
+            } else if (_Last_error == __std_win_error::_Access_denied) {
+                // looks like we failed to set the delete flag, after clearing the FILE_ATTRIBUTE_READONLY flag
+                // perform rollback
+                _Basic_info.FileAttributes |= FILE_ATTRIBUTE_READONLY;
+                if (!SetFileInformationByHandle(_Handle._Get(), FileBasicInfo, &_Basic_info, sizeof(_Basic_info))) {
+                    return {false, __std_win_error{GetLastError()}};
+                }
+                return {false, _Last_error};
+            }
+        } else {
+            return {false, _Last_error};
+        }
+    } else {
+        return {false, _Last_error};
+    }
+
+    return {false, __std_win_error{GetLastError()}};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_change_permissions(
+    _In_z_ const wchar_t* const _Path, _In_ const bool _Follow_symlinks, _In_ const bool _Readonly) noexcept {
+    const DWORD _Old_attributes = GetFileAttributesW(_Path);
+    if (_Old_attributes == INVALID_FILE_ATTRIBUTES) {
+        return __std_win_error{GetLastError()};
+    }
+
+    const DWORD _Readonly_test = _Readonly ? FILE_ATTRIBUTE_READONLY : 0;
+    if ((_Old_attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0u && _Follow_symlinks) {
+        __std_win_error _Err;
+        _STD _Fs_file _Handle(_Path,
+            __std_access_rights::_File_read_attributes | __std_access_rights::_File_write_attributes,
+            __std_fs_file_flags::_Backup_semantics, &_Err);
+
+        if (_Err != __std_win_error::_Success) {
+            return _Err;
+        }
+
+        FILE_BASIC_INFO _Basic_info;
+        if (!GetFileInformationByHandleEx(_Handle._Get(), FileBasicInfo, &_Basic_info, sizeof(_Basic_info))) {
+            return __std_win_error{GetLastError()};
+        }
+
+        if ((_Basic_info.FileAttributes & FILE_ATTRIBUTE_READONLY) == _Readonly_test) { // nothing to do
+            return __std_win_error::_Success;
+        }
+
+        _Basic_info.FileAttributes ^= FILE_ATTRIBUTE_READONLY;
+        if (SetFileInformationByHandle(_Handle._Get(), FileBasicInfo, &_Basic_info, sizeof(_Basic_info))) {
+            return __std_win_error::_Success;
+        }
+
+        return __std_win_error{GetLastError()};
+    }
+
+    if ((_Old_attributes & FILE_ATTRIBUTE_READONLY) == _Readonly_test) { // nothing to do
+        return __std_win_error::_Success;
+    }
+
+    if (SetFileAttributesW(_Path, _Old_attributes ^ FILE_ATTRIBUTE_READONLY)) {
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_rename(
+    _In_z_ const wchar_t* const _Source, _In_z_ const wchar_t* const _Target) noexcept {
+    if (MoveFileExW(_Source, _Target, MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING)) {
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_resize_file(
+    _In_z_ const wchar_t* const _Target, const uintmax_t _New_size) noexcept {
+    __std_win_error _Err;
+    const _STD _Fs_file _Handle(_Target, __std_access_rights::_File_generic_write, __std_fs_file_flags::_None, &_Err);
+    if (_Err != __std_win_error::_Success) {
+        return _Err;
+    }
+
+    FILE_END_OF_FILE_INFO _File_info;
+    _File_info.EndOfFile.QuadPart = static_cast<LONGLONG>(_New_size);
+
+    if (SetFileInformationByHandle(_Handle._Get(), FileEndOfFileInfo, &_File_info, sizeof(_File_info))) {
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_space(_In_z_ const wchar_t* const _Target,
+    _Out_ uintmax_t* const _Available, _Out_ uintmax_t* const _Total_bytes,
+    _Out_ uintmax_t* const _Free_bytes) noexcept {
+    // get capacity information for the volume on which the file _Target resides
+    static_assert(sizeof(uintmax_t) == sizeof(ULARGE_INTEGER) && alignof(uintmax_t) == alignof(ULARGE_INTEGER),
+        "Size and alignment must match for reinterpret_cast<PULARGE_INTEGER>");
+    const auto _Available_c   = reinterpret_cast<PULARGE_INTEGER>(_Available);
+    const auto _Total_bytes_c = reinterpret_cast<PULARGE_INTEGER>(_Total_bytes);
+    const auto _Free_bytes_c  = reinterpret_cast<PULARGE_INTEGER>(_Free_bytes);
+    if (GetDiskFreeSpaceExW(_Target, _Available_c, _Total_bytes_c, _Free_bytes_c)) {
+        return __std_win_error::_Success;
+    }
+
+    __std_win_error _Last_error{GetLastError()};
+    _Available_c->QuadPart   = ~0ull;
+    _Total_bytes_c->QuadPart = ~0ull;
+    _Free_bytes_c->QuadPart  = ~0ull;
+    if (_Last_error != __std_win_error::_Directory_name_is_invalid) {
+        return _Last_error;
+    }
+
+    // Input could have been a file; canonicalize and remove the last component.
+    // We use VOLUME_NAME_NT because it always has a mapping available and we don't care about the canonical path
+    // being "ugly" due to needing the _Dos_to_nt_prefix.
+    static constexpr wchar_t _Dos_to_nt_prefix[] = LR"(\\?\GLOBALROOT)";
+    constexpr size_t _Dos_to_nt_prefix_count     = sizeof(_Dos_to_nt_prefix) / sizeof(wchar_t) - 1;
+    __crt_unique_heap_ptr<wchar_t> _Buf;
+    DWORD _Actual_length;
+    {
+        const _STD _Fs_file _Handle(
+            _Target, __std_access_rights::_File_read_attributes, __std_fs_file_flags::_Backup_semantics, &_Last_error);
+        if (_Last_error != __std_win_error::_Success) {
+            return _Last_error;
+        }
+
+        DWORD _Buf_count = MAX_PATH;
+        for (;;) {
+            _Buf = _malloc_crt_t(wchar_t, _Buf_count);
+            if (!_Buf) {
+                return __std_win_error::_Not_enough_memory;
+            }
+
+            _Actual_length = GetFinalPathNameByHandleW(_Handle._Get(), _Buf.get() + _Dos_to_nt_prefix_count,
+                _Buf_count - _Dos_to_nt_prefix_count, FILE_NAME_NORMALIZED | VOLUME_NAME_NT);
+            if (_Actual_length == 0) {
+                return __std_win_error{GetLastError()};
+            }
+
+            _Actual_length += _Dos_to_nt_prefix_count;
+            if (_Actual_length <= _Buf_count) {
+                break;
+            }
+
+            _Buf_count = _Actual_length;
+        }
+    } // close _Handle
+
+    const auto _Ptr = _Buf.get();
+
+    memcpy(_Ptr, _Dos_to_nt_prefix, _Dos_to_nt_prefix_count * sizeof(wchar_t));
+
+    // insert null terminator at the last slash
+    auto _Cursor = _Ptr + _Actual_length;
+    do {
+        --_Cursor; // cannot run off start because _Dos_to_nt_prefix contains a backslash
+    } while (*_Cursor != L'\\');
+
+    *_Cursor = L'\0';
+    if (GetDiskFreeSpaceExW(_Ptr, _Available_c, _Total_bytes_c, _Free_bytes_c)) {
+        return __std_win_error::_Success;
+    }
+
+    _Available_c->QuadPart   = ~0ull;
+    _Total_bytes_c->QuadPart = ~0ull;
+    _Free_bytes_c->QuadPart  = ~0ull;
+    return __std_win_error{GetLastError()};
+}
+
+namespace {
+    _Success_(return > 0 && return < nBufferLength) DWORD WINAPI _Stl_GetTempPath2W(
+        _In_ DWORD nBufferLength, _Out_writes_to_opt_(nBufferLength, return +1) LPWSTR lpBuffer) noexcept {
+        // See GH-3011: This is intentionally not attempting to cache the function pointer.
+        // TRANSITION, ABI: This should use __crtGetTempPath2W after this code is moved into the STL's DLL.
+
+        // use GetTempPath2W if it is available (only on Windows 11+)...
+        const auto _Kernel32 = ::GetModuleHandleW(L"kernel32.dll");
+        _Analysis_assume_(_Kernel32);
+        const auto _Pf = reinterpret_cast<decltype(&::GetTempPath2W)>(::GetProcAddress(_Kernel32, "GetTempPath2W"));
+        if (_Pf) {
+            return _Pf(nBufferLength, lpBuffer);
+        }
+
+        // ...otherwise use GetTempPathW.
+        return GetTempPathW(nBufferLength, lpBuffer);
+    }
+} // unnamed namespace
+
+[[nodiscard]] _Success_(return._Error == __std_win_error::_Success) __std_ulong_and_error __stdcall
+    __std_fs_get_temp_path(_Out_writes_z_(__std_fs_temp_path_max) wchar_t* const _Target) noexcept {
+    // calls GetTempPath2W if available (Win11+), else calls GetTempPathW
+    // If getting the path failed, returns 0 size; otherwise, returns the size of the
+    // expected directory. If the path could be resolved to an existing directory,
+    // returns __std_win_error::_Success; otherwise, returns __std_win_error::_Max.
+    const auto _Size = _Stl_GetTempPath2W(__std_fs_temp_path_max, _Target);
+    if (_Size == 0) {
+        return {0, __std_win_error{GetLastError()}};
+    }
+
+    // Effects: If exists(p) is false or is_directory(p) is false, an error is reported
+    const DWORD _Attributes = GetFileAttributesW(_Target);
+    if (_Attributes == INVALID_FILE_ATTRIBUTES || (_Attributes & FILE_ATTRIBUTE_DIRECTORY) == 0u) {
+        return {_Size, __std_win_error::_Max};
+    }
+
+    if ((_Attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0u) {
+        __std_fs_file_handle _Handle;
+        const auto _Last_error = __std_fs_open_handle(
+            &_Handle, _Target, __std_access_rights::_File_read_attributes, __std_fs_file_flags::_Backup_semantics);
+        __std_fs_close_handle(_Handle);
+        if (_Last_error != __std_win_error::_Success) {
+            return {_Size, __std_win_error::_Max};
+        }
+    }
+
+    return {_Size, __std_win_error::_Success};
+}
+
+[[nodiscard]] _Success_(return == __std_win_error::_Success) __std_win_error __stdcall __std_fs_get_stats(
+    _In_z_ const wchar_t* const _Path, __std_fs_stats* const _Stats, _In_ __std_fs_stats_flags _Flags,
+    _In_ const __std_fs_file_attr _Symlink_attribute_hint) noexcept {
+    const bool _Follow_symlinks = _STD _Bitmask_includes_any(_Flags, __std_fs_stats_flags::_Follow_symlinks);
+    _Flags &= ~__std_fs_stats_flags::_Follow_symlinks;
+    if (_Follow_symlinks && _STD _Bitmask_includes_any(_Flags, __std_fs_stats_flags::_Reparse_tag)) {
+        return __std_win_error::_Invalid_parameter;
+    }
+
+    if (_STD _Bitmask_includes_any(_Flags, __std_fs_stats_flags::_Attributes)
+        && _Symlink_attribute_hint != __std_fs_file_attr::_Invalid
+        && (!_STD _Bitmask_includes_any(_Symlink_attribute_hint, __std_fs_file_attr::_Reparse_point)
+            || !_Follow_symlinks)) { // if the hint can't be a symlink, we already have the attributes
+        _Flags &= ~__std_fs_stats_flags::_Attributes;
+        _Stats->_Attributes = _Symlink_attribute_hint;
+    }
+
+    if (_Flags == __std_fs_stats_flags::_None) { // no more data to get, report success
+        return __std_win_error::_Success;
+    }
+
+    constexpr auto _Get_file_attributes_data =
+        __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_File_size | __std_fs_stats_flags::_Last_write_time;
+    if (_STD _Bitmask_includes_any(_Flags, _Get_file_attributes_data)) {
+        // caller wants something GetFileAttributesExW/FindFirstFileW might provide
+        if (_Symlink_attribute_hint == __std_fs_file_attr::_Invalid
+            || !_STD _Bitmask_includes_any(_Symlink_attribute_hint, __std_fs_file_attr::_Reparse_point)
+            || !_Follow_symlinks) { // we might not be a symlink or not following symlinks, so
+                                    // GetFileAttributesExW/FindFirstFileW would return the right answer
+
+            WIN32_FILE_ATTRIBUTE_DATA _Data;
+            if (!GetFileAttributesExW(_Path, GetFileExInfoStandard, &_Data)) {
+                // In some cases, ERROR_SHARING_VIOLATION is returned from GetFileAttributesExW;
+                // FindFirstFileW will work in those cases if we have read permissions on the directory.
+                if (const __std_win_error _Last_error{GetLastError()};
+                    _Last_error != __std_win_error::_Sharing_violation) {
+                    return _Last_error;
+                }
+
+                // Note that FindFirstFileW does allow globbing characters and has extra behavior with them
+                // that we don't want. However, GetFileAttributesExW would've failed with ERROR_INVALID_NAME
+                // if there were any globbing characters in _Path.
+                WIN32_FIND_DATAW _Find_data;
+                {
+                    HANDLE _Find_handle = FindFirstFileW(_Path, &_Find_data);
+                    if (_Find_handle == INVALID_HANDLE_VALUE) {
+                        return __std_win_error{GetLastError()};
+                    }
+                    FindClose(_Find_handle);
+                }
+
+                _Data.dwFileAttributes = _Find_data.dwFileAttributes;
+                _Data.nFileSizeHigh    = _Find_data.nFileSizeHigh;
+                _Data.nFileSizeLow     = _Find_data.nFileSizeLow;
+                _Data.ftLastWriteTime  = _Find_data.ftLastWriteTime;
+            }
+
+            const __std_fs_file_attr _Attributes{_Data.dwFileAttributes};
+            if (!_Follow_symlinks || !_STD _Bitmask_includes_any(_Attributes, __std_fs_file_attr::_Reparse_point)) {
+                // if we aren't following symlinks or can't be a symlink, that data was useful, record
+                _Stats->_Attributes      = _Attributes;
+                _Stats->_File_size       = _Merge_to_ull(_Data.nFileSizeHigh, _Data.nFileSizeLow);
+                _Stats->_Last_write_time = static_cast<long long>(
+                    _Merge_to_ull(_Data.ftLastWriteTime.dwHighDateTime, _Data.ftLastWriteTime.dwLowDateTime));
+
+                _Flags &= ~_Get_file_attributes_data;
+            }
+
+            if (!_STD _Bitmask_includes_any(_Attributes, __std_fs_file_attr::_Reparse_point)
+                && _STD _Bitmask_includes_any(_Flags, __std_fs_stats_flags::_Reparse_tag)) {
+                // if reparse tag is requested by caller but the file is not a reparse point, set tag to _None
+                _Stats->_Reparse_point_tag = __std_fs_reparse_tag::_None;
+                _Flags &= ~__std_fs_stats_flags::_Reparse_tag;
+            }
+        }
+    }
+
+    if (_Flags == __std_fs_stats_flags::_None) { // no more data to get, report success
+        return __std_win_error::_Success;
+    }
+
+    // Let's try to open the file (either reparse point or destination).
+    __std_win_error _Last_error;
+    const auto _File_flags = _Follow_symlinks
+                               ? __std_fs_file_flags::_Backup_semantics
+                               : __std_fs_file_flags::_Backup_semantics | __std_fs_file_flags::_Open_reparse_point;
+    const _STD _Fs_file _Handle(_Path, __std_access_rights::_File_read_attributes, _File_flags, &_Last_error);
+    if (_Last_error != __std_win_error::_Success) {
+        return _Last_error;
+    }
+
+    constexpr auto _Basic_info_data    = __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Last_write_time;
+    constexpr auto _Standard_info_data = __std_fs_stats_flags::_File_size | __std_fs_stats_flags::_Link_count;
+
+    if (_STD _Bitmask_includes_any(_Flags, _Basic_info_data | __std_fs_stats_flags::_Reparse_tag)) {
+        FILE_BASIC_INFO _Info;
+        if (!GetFileInformationByHandleEx(_Handle._Get(), FileBasicInfo, &_Info, sizeof(_Info))) {
+            return __std_win_error{GetLastError()};
+        }
+
+        _Stats->_Attributes      = __std_fs_file_attr{_Info.FileAttributes};
+        _Stats->_Last_write_time = _Info.LastWriteTime.QuadPart;
+        _Flags &= ~_Basic_info_data;
+        if (_STD _Bitmask_includes_any(_Flags, __std_fs_stats_flags::_Reparse_tag)) {
+            // Calling GetFileInformationByHandleEx with FileAttributeTagInfo fails on FAT file system with
+            // ERROR_INVALID_PARAMETER. We avoid calling this for non-reparse-points.
+            if ((_Info.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0u) {
+                FILE_ATTRIBUTE_TAG_INFO _TagInfo;
+                if (!GetFileInformationByHandleEx(_Handle._Get(), FileAttributeTagInfo, &_TagInfo, sizeof(_TagInfo))) {
+                    return __std_win_error{GetLastError()};
+                }
+
+                _Stats->_Reparse_point_tag = __std_fs_reparse_tag{_TagInfo.ReparseTag};
+            } else {
+                _Stats->_Reparse_point_tag = __std_fs_reparse_tag::_None;
+            }
+            _Flags &= ~__std_fs_stats_flags::_Reparse_tag;
+        }
+    }
+
+    if (_STD _Bitmask_includes_any(_Flags, _Standard_info_data)) {
+        FILE_STANDARD_INFO _Info;
+        if (!GetFileInformationByHandleEx(_Handle._Get(), FileStandardInfo, &_Info, sizeof(_Info))) {
+            return __std_win_error{GetLastError()};
+        }
+
+        _Stats->_File_size  = _Info.EndOfFile.QuadPart;
+        _Stats->_Link_count = _Info.NumberOfLinks;
+        _Flags &= ~_Standard_info_data;
+    }
+
+    if (_Flags == __std_fs_stats_flags::_None) { // no more data to get, report success
+        return __std_win_error::_Success;
+    }
+
+    // somehow the caller asked for more data than we yet know about, maybe new headers
+    // targeting old separately compiled bits
+    return __std_win_error::_Not_supported;
+}
+
+[[nodiscard]] __std_fs_create_directory_result __stdcall __std_fs_create_directory(
+    _In_z_ const wchar_t* const _New_directory) noexcept {
+    if (CreateDirectoryW(_New_directory, nullptr)) {
+        return {true, __std_win_error::_Success};
+    }
+
+    __std_win_error _Last_error{GetLastError()};
+    if (_Last_error == __std_win_error::_Already_exists) {
+        __std_fs_stats _Stats;
+        _Last_error = __std_fs_get_stats(
+            _New_directory, &_Stats, __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Follow_symlinks);
+        if (_Last_error == __std_win_error::_Success
+            && !_STD _Bitmask_includes_any(_Stats._Attributes, __std_fs_file_attr::_Directory)) {
+            _Last_error = __std_win_error::_Already_exists;
+        }
+    }
+
+    return {false, _Last_error};
+}
+
+// TRANSITION, ABI: __std_fs_create_directory_template() is preserved for binary compatibility
+[[nodiscard]] __std_fs_create_directory_result __stdcall __std_fs_create_directory_template(
+    _In_z_ const wchar_t* const _Template_directory, _In_z_ const wchar_t* const _New_directory) noexcept {
+    if (CreateDirectoryExW(_Template_directory, _New_directory, nullptr)) {
+        return {true, __std_win_error::_Success};
+    }
+
+    __std_win_error _Last_error{GetLastError()};
+    if (_Last_error == __std_win_error::_Already_exists) {
+        _Last_error = __std_win_error::_Success;
+    }
+
+    return {false, _Last_error};
+}
+
+[[nodiscard]] _Success_(return._Error == __std_win_error::_Success) __std_ulong_and_error __stdcall
+    __std_fs_get_current_path(
+        _In_ const unsigned long _Target_size, _Out_writes_z_(_Target_size) wchar_t* const _Target) noexcept {
+    // If getting the path failed, GetCurrentDirectoryW returns 0; otherwise, returns the size of the expected
+    // directory.
+    const auto _Size = GetCurrentDirectoryW(_Target_size, _Target);
+    if (_Size != 0 && _Size <= _Target_size) {
+        return {_Size, __std_win_error::_Success};
+    }
+
+    return {_Size, __std_win_error{GetLastError()}};
+}
+
+[[nodiscard]] __std_win_error __stdcall __std_fs_set_current_path(_In_z_ const wchar_t* const _Target) noexcept {
+    // If setting the path failed, SetCurrentDirectoryW returns 0; otherwise returns non-zero.
+    if (SetCurrentDirectoryW(_Target)) {
+        return __std_win_error::_Success;
+    }
+
+    return __std_win_error{GetLastError()};
+}
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/fiopen.cpp b/msvc-stl/stl/src/fiopen.cpp
new file mode 100644
index 0000000..e880639
--- /dev/null
+++ b/msvc-stl/stl/src/fiopen.cpp
@@ -0,0 +1,105 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// _Fiopen(const char */const wchar_t *, ios_base::openmode)
+
+#include <fstream>
+
+namespace {
+    using _STD ios_base;
+
+    FILE* _Xfsopen(_In_z_ const char* filename, _In_ int mode, _In_ int prot) {
+        static const char* const mods[] = {// fopen mode strings corresponding to valid[i]
+            "r", "w", "w", "a", "rb", "wb", "wb", "ab", "r+", "w+", "a+", "r+b", "w+b", "a+b", "wx", "wx", "w+x", "wbx",
+            "wbx", "w+bx", nullptr};
+
+        return _fsopen(filename, mods[mode], prot);
+    }
+
+    FILE* _Xfsopen(_In_z_ const wchar_t* filename, _In_ int mode, _In_ int prot) {
+        static const wchar_t* const mods[] = {// fopen mode strings corresponding to valid[i]
+            L"r", L"w", L"w", L"a", L"rb", L"wb", L"wb", L"ab", L"r+", L"w+", L"a+", L"r+b", L"w+b", L"a+b", L"wx",
+            L"wx", L"w+x", L"wbx", L"wbx", L"w+bx", nullptr};
+
+        return _wfsopen(filename, mods[mode], prot);
+    }
+
+    template <class CharT>
+    FILE* _Xfiopen(const CharT* filename, ios_base::openmode mode, int prot) {
+        static const ios_base::openmode valid[] = {
+            // valid combinations of open flags
+            ios_base::in,
+            ios_base::out,
+            ios_base::out | ios_base::trunc,
+            ios_base::out | ios_base::app,
+            ios_base::in | ios_base::binary,
+            ios_base::out | ios_base::binary,
+            ios_base::out | ios_base::trunc | ios_base::binary,
+            ios_base::out | ios_base::app | ios_base::binary,
+            ios_base::in | ios_base::out,
+            ios_base::in | ios_base::out | ios_base::trunc,
+            ios_base::in | ios_base::out | ios_base::app,
+            ios_base::in | ios_base::out | ios_base::binary,
+            ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary,
+            ios_base::in | ios_base::out | ios_base::app | ios_base::binary,
+            ios_base::out | ios_base::_Noreplace,
+            ios_base::out | ios_base::trunc | ios_base::_Noreplace,
+            ios_base::out | ios_base::in | ios_base::trunc | ios_base::_Noreplace,
+            ios_base::out | ios_base::binary | ios_base::_Noreplace,
+            ios_base::out | ios_base::binary | ios_base::trunc | ios_base::_Noreplace,
+            ios_base::out | ios_base::in | ios_base::trunc | ios_base::binary | ios_base::_Noreplace,
+        };
+
+        FILE* fp          = nullptr;
+        const bool at_end = (mode & ios_base::ate) != 0;
+
+        if (mode & ios_base::_Nocreate) {
+            mode |= ios_base::in; // file must exist
+        }
+
+        if (mode & ios_base::app) {
+            mode |= ios_base::out; // extension -- app implies out
+        }
+
+        mode &= ~(ios_base::ate | ios_base::_Nocreate);
+
+        // look for a valid mode
+        int n = 0;
+        while (valid[n] != mode) {
+            if (++n == static_cast<int>(_STD size(valid))) {
+                return nullptr; // no valid mode
+            }
+        }
+
+        if ((fp = _Xfsopen(filename, n, prot)) == nullptr) {
+            return nullptr; // open failed
+        }
+
+        if (at_end && fseek(fp, 0, SEEK_END) != 0) {
+            fclose(fp); // can't position at end
+            return nullptr;
+        }
+
+        return fp; // no need to seek to end, or seek succeeded
+    }
+} // unnamed namespace
+
+_STD_BEGIN
+
+_CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(
+    const char* filename, ios_base::openmode mode, int prot) { // open wide-named file with byte name
+    return _Xfiopen(filename, mode, prot);
+}
+
+_CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(
+    const wchar_t* filename, ios_base::openmode mode, int prot) { // open a file with native name
+    return _Xfiopen(filename, mode, prot);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE FILE* __CLRCALL_PURE_OR_CDECL _Fiopen(
+    const unsigned short* _Filename, ios_base::openmode _Mode, int _Prot) { // open file with wide name
+    return _Fiopen(reinterpret_cast<const wchar_t*>(_Filename), _Mode, _Prot);
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/format.cpp b/msvc-stl/stl/src/format.cpp
new file mode 100644
index 0000000..d639183
--- /dev/null
+++ b/msvc-stl/stl/src/format.cpp
@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Implements a win32 API wrapper for <format>
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <xfilesystem_abi.h>
+
+#include <Windows.h>
+
+static_assert(__std_code_page::_Acp == __std_code_page{CP_ACP});
+
+extern "C" [[nodiscard]] __std_win_error __stdcall __std_get_cvt(
+    const __std_code_page _Codepage, _Cvtvec* const _Pcvt) noexcept {
+    // get conversion info for an arbitrary codepage
+    *_Pcvt = {};
+
+    CPINFOEXW _Info{};
+    const DWORD _Flags = 0; // reserved, must be zero
+    if (!GetCPInfoExW(static_cast<UINT>(_Codepage), _Flags, &_Info)) {
+        // NB: the only documented failure mode for GetCPInfoExW is ERROR_INVALID_PARAMETER,
+        // so in practice it should never fail for CP_ACP.
+        return __std_win_error{GetLastError()};
+    }
+
+    _Pcvt->_Page     = _Info.CodePage;
+    _Pcvt->_Mbcurmax = _Info.MaxCharSize;
+
+    for (int _Idx = 0; _Idx < MAX_LEADBYTES; _Idx += 2) {
+        if (_Info.LeadByte[_Idx] == 0 && _Info.LeadByte[_Idx + 1] == 0) {
+            break;
+        }
+
+        for (unsigned int _First = _Info.LeadByte[_Idx], _Last = _Info.LeadByte[_Idx + 1]; _First <= _Last; ++_First) {
+            _Pcvt->_Isleadbyte[_First >> 3] |= 1u << (_First & 0b111u);
+        }
+    }
+
+    return __std_win_error::_Success;
+}
diff --git a/msvc-stl/stl/src/future.cpp b/msvc-stl/stl/src/future.cpp
new file mode 100644
index 0000000..4f7a8d4
--- /dev/null
+++ b/msvc-stl/stl/src/future.cpp
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <exception>
+#include <future>
+
+_STD_BEGIN
+
+// TRANSITION, ABI: preserved for binary compatibility
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Throw_future_error(const error_code& _Code) {
+    _THROW(future_error(_Code));
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Rethrow_future_exception(exception_ptr _Ptr) {
+    _STD rethrow_exception(_Ptr);
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/init_locks.hpp b/msvc-stl/stl/src/init_locks.hpp
new file mode 100644
index 0000000..737ad5a
--- /dev/null
+++ b/msvc-stl/stl/src/init_locks.hpp
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <yvals.h>
+
+_STD_BEGIN
+
+class _CRTIMP2_PURE_IMPORT _Init_locks { // initialize mutexes
+public:
+#ifdef _M_CEE_PURE
+    __CLR_OR_THIS_CALL _Init_locks() noexcept {
+        _Init_locks_ctor(this);
+    }
+
+    __CLR_OR_THIS_CALL ~_Init_locks() noexcept {
+        _Init_locks_dtor(this);
+    }
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+    __thiscall _Init_locks() noexcept;
+    __thiscall ~_Init_locks() noexcept;
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+
+private:
+    static void __cdecl _Init_locks_ctor(_Init_locks*) noexcept;
+    static void __cdecl _Init_locks_dtor(_Init_locks*) noexcept;
+};
+
+_STD_END
diff --git a/msvc-stl/stl/src/instances.cpp b/msvc-stl/stl/src/instances.cpp
new file mode 100644
index 0000000..96a8ded
--- /dev/null
+++ b/msvc-stl/stl/src/instances.cpp
@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// force DLL instances
+
+#define __FORCE_INSTANCE
+
+#include <ios>
+#include <istream>
+#include <locale>
+#include <ostream>
+#include <streambuf>
+#include <xlocale>
+#include <xlocmes>
+#include <xlocmon>
+#include <xlocnum>
+#include <xloctime>
+
+_STD_BEGIN
+
+template class _CRTIMP2_PURE_IMPORT _Yarn<char>;
+template class _CRTIMP2_PURE_IMPORT _Yarn<wchar_t>;
+template class _CRTIMP2_PURE_IMPORT _Yarn<unsigned short>;
+
+_STD_END
diff --git a/msvc-stl/stl/src/iomanip.cpp b/msvc-stl/stl/src/iomanip.cpp
new file mode 100644
index 0000000..29ffd32
--- /dev/null
+++ b/msvc-stl/stl/src/iomanip.cpp
@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// instantiations of iomanip
+
+#include <iomanip>
+_STD_BEGIN
+static void __cdecl rsfun(ios_base& iostr, ios_base::fmtflags mask) { // reset specified format flags
+    iostr.setf(ios_base::_Fmtzero, mask);
+}
+
+static void __cdecl sifun(ios_base& iostr, ios_base::fmtflags mask) { // set specified format flags
+    iostr.setf(ios_base::_Fmtmask, mask);
+}
+
+static void __cdecl sbfun(ios_base& iostr, int base) { // set base
+    iostr.setf(base == 8    ? ios_base::oct
+               : base == 10 ? ios_base::dec
+               : base == 16 ? ios_base::hex
+                            : ios_base::_Fmtzero,
+        ios_base::basefield);
+}
+
+static void __cdecl spfun(ios_base& iostr, streamsize prec) { // set precision
+    iostr.precision(prec);
+}
+
+static void __cdecl swfun(ios_base& iostr, streamsize wide) { // set width
+    iostr.width(wide);
+}
+
+_MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl resetiosflags(
+    ios_base::fmtflags mask) { // manipulator to reset format flags
+    return _Smanip<ios_base::fmtflags>(&rsfun, mask);
+}
+
+_MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl setiosflags(ios_base::fmtflags mask) { // manipulator to set format flags
+    return _Smanip<ios_base::fmtflags>(&sifun, mask);
+}
+
+_MRTIMP2 _Smanip<int> __cdecl setbase(int base) { // manipulator to set base
+    return _Smanip<int>(&sbfun, base);
+}
+
+_MRTIMP2 _Smanip<streamsize> __cdecl setprecision(streamsize prec) { // manipulator to set precision
+    return _Smanip<streamsize>(&spfun, prec);
+}
+
+_MRTIMP2 _Smanip<streamsize> __cdecl setw(streamsize wide) { // manipulator to set width
+    return _Smanip<streamsize>(&swfun, wide);
+}
+_STD_END
diff --git a/msvc-stl/stl/src/ios.cpp b/msvc-stl/stl/src/ios.cpp
new file mode 100644
index 0000000..aae748f
--- /dev/null
+++ b/msvc-stl/stl/src/ios.cpp
@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// ios_base basic members
+
+#include <xiosbase>
+_STD_BEGIN
+
+constexpr int _Nstdstr = 8; // cin, wcin, cout, wcout, cerr, wcerr, clog, wclog
+
+// TRANSITION, ABI: _BADOFF is preserved for binary compatibility
+#if defined(_M_CEE_PURE)
+extern const streamoff _BADOFF;
+const streamoff _BADOFF = -1;
+#else
+extern _CRTDATA2_IMPORT _PGLOBAL const streamoff _BADOFF;
+_PGLOBAL _CRTDATA2_IMPORT const streamoff _BADOFF = -1; // initialize constant for bad file offset
+#endif
+
+__PURE_APPDOMAIN_GLOBAL int ios_base::_Index = 0; // initialize source of unique indexes
+__PURE_APPDOMAIN_GLOBAL bool ios_base::_Sync = true; // initialize synchronization flag
+
+__PURE_APPDOMAIN_GLOBAL static ios_base* stdstr[_Nstdstr + 2] = {
+    nullptr}; // [1, _Nstdstr] hold pointers to standard streams
+__PURE_APPDOMAIN_GLOBAL static char stdopens[_Nstdstr + 2] = {0}; // [1, _Nstdstr] hold open counts for standard streams
+
+void __CLRCALL_PURE_OR_CDECL ios_base::_Ios_base_dtor(ios_base* _This) { // destroy the object
+    if (0 < _This->_Stdstr && 0 < --stdopens[_This->_Stdstr]) {
+        return;
+    }
+
+    _This->_Tidy();
+
+    delete _This->_Ploc;
+}
+
+void __CLRCALL_PURE_OR_CDECL ios_base::_Addstd(ios_base* _This) { // add standard stream to destructor list
+    _BEGIN_LOCK(_LOCK_STREAM)
+    for (_This->_Stdstr = 1; _This->_Stdstr < _Nstdstr; ++_This->_Stdstr) {
+        if (stdstr[_This->_Stdstr] == nullptr || stdstr[_This->_Stdstr] == _This) {
+            break; // found a candidate
+        }
+    }
+
+    stdstr[_This->_Stdstr] = _This;
+    ++stdopens[_This->_Stdstr];
+    _END_LOCK()
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/iosptrs.cpp b/msvc-stl/stl/src/iosptrs.cpp
new file mode 100644
index 0000000..c70342f
--- /dev/null
+++ b/msvc-stl/stl/src/iosptrs.cpp
@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// iostream object pointers
+
+#ifdef _M_CEE_PURE
+#error This file cannot be built with /clr:pure.
+#endif
+
+#include <iostream>
+
+#include <Windows.h>
+
+#include "init_locks.hpp"
+
+_STD_BEGIN
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+_PGLOBAL static std::_Init_locks initlocks;
+
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT istream* _Ptr_cin  = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream* _Ptr_cout = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream* _Ptr_cerr = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT ostream* _Ptr_clog = nullptr;
+
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wistream* _Ptr_wcin  = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wcout = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wcerr = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wclog = nullptr;
+_STD_END
+
+constexpr int _Nats = 10; // fclose, xgetloc, locks, facet free, etc.
+
+__PURE_APPDOMAIN_GLOBAL static void(__cdecl* atfuns_cdecl[_Nats])() = {};
+__PURE_APPDOMAIN_GLOBAL static size_t atcount_cdecl                 = _Nats;
+_MRTIMP2 void __cdecl _Atexit(void(__cdecl* pf)()) { // add to wrapup list
+    if (atcount_cdecl == 0) {
+        _CSTD abort(); // stack full, give up
+    } else {
+        atfuns_cdecl[--atcount_cdecl] = reinterpret_cast<void(__cdecl*)()>(EncodePointer(reinterpret_cast<void*>(pf)));
+    }
+}
+
+struct _Init_atexit { // controller for atexit processing
+    __CLR_OR_THIS_CALL ~_Init_atexit() noexcept { // process wrapup functions
+        while (atcount_cdecl < _Nats) {
+            const auto pf = reinterpret_cast<void(__cdecl*)()>(
+                DecodePointer(reinterpret_cast<void*>(atfuns_cdecl[atcount_cdecl++])));
+            if (pf) {
+                pf();
+            }
+        }
+    }
+};
+
+__PURE_APPDOMAIN_GLOBAL static _Init_atexit init_atexit;
diff --git a/msvc-stl/stl/src/iostream.cpp b/msvc-stl/stl/src/iostream.cpp
new file mode 100644
index 0000000..1d4bbf8
--- /dev/null
+++ b/msvc-stl/stl/src/iostream.cpp
@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// ios::Init members
+
+#include <iostream>
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL int ios_base::Init::_Init_cnt = -1;
+int& ios_base::Init::_Init_cnt_func() {
+    return ios_base::Init::_Init_cnt;
+}
+
+_CRTIMP2_PURE void __cdecl ios_base::Init::_Init_ctor(ios_base::Init*) { // initialize standard streams first time
+    if (0 <= _Init_cnt) {
+        ++_Init_cnt;
+    } else {
+        _Init_cnt = 1;
+    }
+}
+
+_CRTIMP2_PURE void __cdecl ios_base::Init::_Init_dtor(ios_base::Init*) { // flush standard streams last time
+    if (--_Init_cnt == 0) { // flush standard streams
+        if (_Ptr_cerr != nullptr) {
+            _Ptr_cerr->flush();
+        }
+
+        if (_Ptr_clog != nullptr) {
+            _Ptr_clog->flush();
+        }
+
+        if (_Ptr_cout != nullptr) {
+            _Ptr_cout->flush();
+        }
+    }
+}
+_STD_END
diff --git a/msvc-stl/stl/src/locale.cpp b/msvc-stl/stl/src/locale.cpp
new file mode 100644
index 0000000..75d55c6
--- /dev/null
+++ b/msvc-stl/stl/src/locale.cpp
@@ -0,0 +1,177 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// class locale member functions
+
+#if !defined(STDCPP_IMPLIB)
+#define STDCPP_IMPLIB 0
+#endif
+
+#include <cstdlib>
+#include <internal_shared.h>
+#include <istream>
+#include <xlocale>
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+
+_STD_BEGIN
+
+_MRTIMP2_PURE locale __CLRCALL_PURE_OR_CDECL locale::global(const locale& loc) { // change global locale
+    locale _Oldglobal;
+    _BEGIN_LOCK(_LOCK_LOCALE)
+    locale::_Locimp* ptr = _Getgloballocale();
+
+    if (ptr != loc._Ptr) { // set new global locale
+        delete ptr->_Decref();
+        _Setgloballocale(ptr = loc._Ptr);
+        ptr->_Incref();
+        category _Cmask = ptr->_Catmask & all;
+        if (_Cmask == all) {
+            setlocale(LC_ALL, ptr->_Name._C_str());
+        } else {
+            for (int catindex = 0; catindex <= _X_MAX; ++catindex) {
+                if ((_CATMASK(catindex) & _Cmask) != 0) {
+                    setlocale(catindex, ptr->_Name._C_str());
+                }
+            }
+        }
+    }
+    return _Oldglobal;
+    _END_LOCK()
+}
+
+#if STDCPP_IMPLIB || !defined(_M_CEE_PURE)
+// facets associated with C categories
+#define ADDFAC(Facet, cat, ptrimp, ptrloc)                                                                  \
+    if ((_CATMASK(Facet::_Getcat()) & cat) == 0) {                                                          \
+        ;                                                                                                   \
+    } else if (ptrloc == nullptr) {                                                                         \
+        ptrimp->_Addfac(new Facet(lobj), Facet::id._Get_index());                                           \
+    } else {                                                                                                \
+        ptrimp->_Addfac(                                                                                    \
+            const_cast<locale::facet*>(static_cast<const locale::facet*>(&_STD use_facet<Facet>(*ptrloc))), \
+            Facet::id._Get_index());                                                                        \
+    }
+
+using _Tc1 = ctype<char>;
+using _Tc2 = num_get<char>;
+using _Tc3 = num_put<char>;
+using _Tc4 = numpunct<char>;
+using _Tc5 = codecvt<char, char, _Mbstatet>;
+// others moved to wlocale and xlocale to ease subsetting
+
+locale::_Locimp* __CLRCALL_OR_CDECL locale::_Locimp::_Makeloc(
+    const _Locinfo& lobj, locale::category cat, _Locimp* ptrimp, const locale* ptrloc) { // setup a new locale
+    ADDFAC(_Tc1, cat, ptrimp, ptrloc);
+    ADDFAC(_Tc2, cat, ptrimp, ptrloc);
+    ADDFAC(_Tc3, cat, ptrimp, ptrloc);
+    ADDFAC(_Tc4, cat, ptrimp, ptrloc);
+    ADDFAC(_Tc5, cat, ptrimp, ptrloc);
+    _Locimp::_Makexloc(lobj, cat, ptrimp, ptrloc);
+    _Locimp::_Makewloc(lobj, cat, ptrimp, ptrloc);
+    _Locimp::_Makeushloc(lobj, cat, ptrimp, ptrloc);
+    ptrimp->_Catmask |= cat;
+    ptrimp->_Name = lobj._Getname();
+    return ptrimp;
+}
+
+void __CLRCALL_PURE_OR_CDECL locale::_Locimp::_Locimp_ctor(
+    locale::_Locimp* _This, const locale::_Locimp& imp) { // construct a _Locimp from a copy
+    if (&imp == _Clocptr) {
+        _BEGIN_LOCINFO(_Lobj)
+        _Makeloc(_Lobj, locale::all, _This, nullptr);
+        _END_LOCINFO()
+    } else { // lock to keep facets from disappearing
+        _BEGIN_LOCK(_LOCK_LOCALE)
+        if (0 < _This->_Facetcount) { // copy over nonempty facet vector
+            _This->_Facetvec = static_cast<locale::facet**>(_malloc_crt(_This->_Facetcount * sizeof(locale::facet*)));
+            if (_This->_Facetvec == nullptr) { // report no memory
+                _Xbad_alloc();
+            }
+
+            for (size_t count = _This->_Facetcount; 0 < count;) { // copy over facet pointers
+                locale::facet* ptrfac = imp._Facetvec[--count];
+                if ((_This->_Facetvec[count] = ptrfac) != nullptr) {
+                    ptrfac->_Incref();
+                }
+            }
+        }
+        _END_LOCK()
+    }
+}
+#endif // STDCPP_IMPLIB || !defined(_M_CEE_PURE)
+
+void __CLRCALL_PURE_OR_CDECL locale::_Locimp::_Locimp_Addfac(
+    _Locimp* _This, locale::facet* ptrfac, size_t id) { // add a facet to a locale
+    _BEGIN_LOCK(_LOCK_LOCALE)
+    const size_t MINCAT = 40; // minimum number of facets in a locale
+
+    if (_This->_Facetcount <= id) { // make facet vector larger
+        size_t count = id + 1;
+        if (count < MINCAT) {
+            count = MINCAT;
+        }
+
+        locale::facet** ptrnewvec =
+            static_cast<locale::facet**>(_realloc_crt(_This->_Facetvec, count * sizeof(locale::facet**)));
+        if (ptrnewvec == nullptr) { // report no memory
+            _Xbad_alloc();
+        }
+        _This->_Facetvec = ptrnewvec;
+        for (; _This->_Facetcount < count; ++_This->_Facetcount) {
+            _This->_Facetvec[_This->_Facetcount] = nullptr;
+        }
+    }
+    ptrfac->_Incref();
+#pragma warning(push)
+#pragma warning(disable : 6001) // PREfast isn't following through _realloc_crt here
+    if (_This->_Facetvec[id] != nullptr) {
+#pragma warning(pop)
+        delete _This->_Facetvec[id]->_Decref();
+    }
+
+    _This->_Facetvec[id] = ptrfac;
+    _END_LOCK()
+}
+
+void __CLRCALL_PURE_OR_CDECL _Locinfo::_Locinfo_ctor(
+    _Locinfo* pLocinfo, int cat, const char* locname) { // capture a named locale
+    pLocinfo->_Oldlocname._From_wide(_wsetlocale(LC_ALL, nullptr));
+    _Locinfo_Addcats(pLocinfo, cat, locname);
+}
+
+_Locinfo& __CLRCALL_PURE_OR_CDECL _Locinfo::_Locinfo_Addcats(
+    _Locinfo* pLocinfo, int cat, const char* locname) { // merge in another named locale
+    const char* oldlocname = nullptr;
+
+    if (locname == nullptr) {
+        _Xruntime_error("bad locale name");
+    }
+
+    if (locname[0] != '*' || locname[1] != '\0') {
+        if (cat == 0) {
+            oldlocname = setlocale(LC_ALL, nullptr);
+        } else if (cat == _M_ALL) {
+            oldlocname = setlocale(LC_ALL, locname);
+        } else { // alter selected categories
+            for (int catindex = 0; catindex <= _X_MAX; ++catindex) {
+                if ((_CATMASK(catindex) & cat) != 0) {
+                    setlocale(catindex, locname);
+                }
+            }
+
+            oldlocname = setlocale(LC_ALL, locname);
+        }
+    }
+
+    if (oldlocname == nullptr) {
+        pLocinfo->_Newlocname = "*";
+    } else if (strcmp(pLocinfo->_Newlocname._C_str(), "*") != 0) {
+        pLocinfo->_Newlocname = oldlocname;
+    }
+
+    return *pLocinfo;
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/locale0.cpp b/msvc-stl/stl/src/locale0.cpp
new file mode 100644
index 0000000..7b176a1
--- /dev/null
+++ b/msvc-stl/stl/src/locale0.cpp
@@ -0,0 +1,245 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// class locale basic member functions
+
+// This file is compiled into the import library (via locale0_implib.cpp => locale0.cpp).
+// MAJOR LIMITATIONS apply to what can be included here!
+// Before editing this file, read: /docs/import_library.md
+
+#undef _ENFORCE_ONLY_CORE_HEADERS // TRANSITION, <xfacet> should be a core header
+
+#include <crtdbg.h>
+#include <internal_shared.h>
+#include <xatomic.h>
+#include <xfacet>
+
+// This should probably go to a compiler section just after the locks - unfortunately we have per-appdomain
+// and per-process variables to initialize
+#pragma warning(disable : 4073)
+#pragma init_seg(lib)
+
+_STD_BEGIN
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc();
+
+struct _Fac_node { // node for lazy facet recording
+    _Fac_node(_Fac_node* _Nextarg, _Facet_base* _Facptrarg)
+        : _Next(_Nextarg), _Facptr(_Facptrarg) {} // construct a node with value
+
+    ~_Fac_node() noexcept { // destroy a facet
+        delete _Facptr->_Decref();
+    }
+
+    void* operator new(size_t _Size) { // replace operator new
+        void* _Ptr = _malloc_dbg(_Size > 0 ? _Size : 1, _CRT_BLOCK, __FILE__, __LINE__);
+        if (!_Ptr) {
+            _Xbad_alloc();
+        }
+
+        return _Ptr;
+    }
+
+    void operator delete(void* _Ptr) noexcept { // replace operator delete
+        _free_dbg(_Ptr, _CRT_BLOCK);
+    }
+
+    _Fac_node* _Next;
+    _Facet_base* _Facptr;
+};
+
+__PURE_APPDOMAIN_GLOBAL static _Fac_node* _Fac_head = nullptr;
+
+struct _Fac_tidy_reg_t {
+    ~_Fac_tidy_reg_t() noexcept { // destroy lazy facets
+        while (_Fac_head != nullptr) { // destroy a lazy facet node
+            _Fac_node* nodeptr = _Fac_head;
+            _Fac_head          = nodeptr->_Next;
+            delete nodeptr;
+        }
+    }
+};
+
+__PURE_APPDOMAIN_GLOBAL const _Fac_tidy_reg_t _Fac_tidy_reg;
+
+#if defined(_M_CEE)
+void __CLRCALL_OR_CDECL _Facet_Register_m(_Facet_base* _This)
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+void __CLRCALL_OR_CDECL _Facet_Register(_Facet_base* _This)
+#endif // ^^^ !defined(_M_CEE) ^^^
+{ // queue up lazy facet for destruction
+    _Fac_head = new _Fac_node(_Fac_head, _This);
+}
+_STD_END
+
+#if !STDCPP_IMPLIB || defined(_M_CEE_PURE)
+
+#include <cstdlib>
+#include <locale>
+
+extern "C" {
+
+void __CLRCALL_OR_CDECL _Deletegloballocale(void* ptr) noexcept { // delete a global locale reference
+    std::locale::_Locimp* locptr = *static_cast<std::locale::_Locimp**>(ptr);
+    if (locptr != nullptr) {
+        delete locptr->_Decref();
+    }
+}
+
+__PURE_APPDOMAIN_GLOBAL static std::locale::_Locimp* global_locale = nullptr; // pointer to current locale
+
+static void __CLRCALL_PURE_OR_CDECL tidy_global() noexcept { // delete static global locale reference
+    _BEGIN_LOCK(_LOCK_LOCALE) // prevent double delete
+    _Deletegloballocale(&global_locale);
+    global_locale = nullptr;
+    _END_LOCK()
+}
+
+} // extern "C"
+
+_MRTIMP2 void __cdecl _Atexit(void(__cdecl*)());
+
+_STD_BEGIN
+
+_MRTIMP2_PURE std::locale::_Locimp* __CLRCALL_PURE_OR_CDECL
+    std::locale::_Getgloballocale() { // return pointer to current locale
+    return global_locale;
+}
+
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL std::locale::_Setgloballocale(void* ptr) { // alter pointer to current locale
+    __PURE_APPDOMAIN_GLOBAL static bool registered = false;
+
+    if (!registered) { // register cleanup first time
+        registered = true;
+#if !defined(_M_CEE_PURE)
+        ::_Atexit(&tidy_global);
+#else
+        _atexit_m_appdomain(tidy_global);
+#endif
+    }
+    global_locale = static_cast<std::locale::_Locimp*>(ptr);
+}
+
+__PURE_APPDOMAIN_GLOBAL static locale classic_locale(_Noinit); // "C" locale object, uninitialized
+
+__PURE_APPDOMAIN_GLOBAL locale::_Locimp* locale::_Locimp::_Clocptr = nullptr; // pointer to classic_locale
+
+__PURE_APPDOMAIN_GLOBAL int locale::id::_Id_cnt = 0; // unique id counter for facets
+
+__PURE_APPDOMAIN_GLOBAL locale::id ctype<char>::id{};
+
+__PURE_APPDOMAIN_GLOBAL locale::id ctype<wchar_t>::id{};
+
+__PURE_APPDOMAIN_GLOBAL locale::id codecvt<wchar_t, char, mbstate_t>::id{};
+
+__PURE_APPDOMAIN_GLOBAL locale::id ctype<unsigned short>::id{};
+
+__PURE_APPDOMAIN_GLOBAL locale::id codecvt<unsigned short, char, mbstate_t>::id{};
+
+_MRTIMP2_PURE const locale& __CLRCALL_PURE_OR_CDECL locale::classic() { // get reference to "C" locale
+#if !defined(_M_CEE_PURE)
+    const auto mem = reinterpret_cast<const intptr_t*>(&locale::_Locimp::_Clocptr);
+    intptr_t as_bytes;
+#ifdef _WIN64
+    as_bytes = __iso_volatile_load64(mem);
+#else // ^^^ 64-bit / 32-bit vvv
+    as_bytes = __iso_volatile_load32(mem);
+#endif // ^^^ 32-bit ^^^
+    _Compiler_or_memory_barrier();
+    const auto ptr = reinterpret_cast<locale::_Locimp*>(as_bytes);
+    if (ptr == nullptr)
+#endif // !defined(_M_CEE_PURE)
+    {
+        _Init();
+    }
+
+    return classic_locale;
+}
+
+// TRANSITION, ABI: non-Standard locale::empty() is preserved for binary compatibility
+_MRTIMP2_PURE locale __CLRCALL_PURE_OR_CDECL locale::empty() { // make empty transparent locale
+    _Init();
+    return locale{_Secret_locale_construct_tag{}, _Locimp::_New_Locimp(true)};
+}
+
+_MRTIMP2_PURE locale::_Locimp* __CLRCALL_PURE_OR_CDECL locale::_Init(bool _Do_incref) { // setup global and "C" locales
+    locale::_Locimp* ptr = nullptr;
+
+    _BEGIN_LOCK(_LOCK_LOCALE) // prevent double initialization
+
+    ptr = _Getgloballocale();
+
+    if (ptr == nullptr) { // create new locales
+        _Setgloballocale(ptr = _Locimp::_New_Locimp());
+        ptr->_Catmask = all; // set current locale to "C"
+        ptr->_Name    = "C";
+
+        // set classic to match
+        ptr->_Incref();
+        ::new (&classic_locale) locale{_Secret_locale_construct_tag{}, ptr};
+#if defined(_M_CEE_PURE)
+        locale::_Locimp::_Clocptr = ptr;
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+        const auto mem      = reinterpret_cast<volatile intptr_t*>(&locale::_Locimp::_Clocptr);
+        const auto as_bytes = reinterpret_cast<intptr_t>(ptr);
+        _Compiler_or_memory_barrier();
+#ifdef _WIN64
+        __iso_volatile_store64(mem, as_bytes);
+#else // ^^^ 64-bit / 32-bit vvv
+        __iso_volatile_store32(mem, as_bytes);
+#endif // ^^^ 32-bit ^^^
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
+    }
+
+    if (_Do_incref) {
+        ptr->_Incref();
+    }
+
+    _END_LOCK()
+
+    return ptr;
+}
+
+locale::_Locimp* __CLRCALL_PURE_OR_CDECL locale::_Locimp::_New_Locimp(bool _Transparent) {
+    return new _Locimp(_Transparent);
+}
+
+locale::_Locimp* __CLRCALL_PURE_OR_CDECL locale::_Locimp::_New_Locimp(const _Locimp& _Right) {
+    return new _Locimp(_Right);
+}
+
+void __CLRCALL_PURE_OR_CDECL locale::_Locimp::_Locimp_dtor(_Locimp* _This) { // destruct a _Locimp
+    _BEGIN_LOCK(_LOCK_LOCALE) // prevent double delete
+    for (size_t count = _This->_Facetcount; 0 < count;) {
+        if (_This->_Facetvec[--count] != nullptr) {
+            delete _This->_Facetvec[count]->_Decref();
+        }
+    }
+
+    free(_This->_Facetvec);
+    _END_LOCK()
+}
+
+void __CLRCALL_PURE_OR_CDECL _Locinfo::_Locinfo_ctor(
+    _Locinfo* pLocinfo, const char* locname) { // switch to a named locale
+    pLocinfo->_Oldlocname._From_wide(_wsetlocale(LC_ALL, nullptr));
+
+    if (locname != nullptr) {
+        locname = setlocale(LC_ALL, locname);
+    }
+
+    pLocinfo->_Newlocname = locname == nullptr ? "*" : locname;
+}
+
+void __CLRCALL_PURE_OR_CDECL _Locinfo::_Locinfo_dtor(_Locinfo* pLocinfo) { // destroy a _Locinfo object, revert locale
+    if (pLocinfo->_Oldlocname._Empty()) {
+        // `pLocinfo->_Oldlocname._C_str()` points to a single `char` of value 0 in this case,
+        // so reinterpret_cast is not reliable.
+        _wsetlocale(LC_ALL, L"");
+    } else {
+        // CodeQL [SM02986] We are intentionally storing `wchar_t*` as `char*` due to ABI, see GH-5781
+        _wsetlocale(LC_ALL, reinterpret_cast<const wchar_t*>(pLocinfo->_Oldlocname._C_str()));
+    }
+}
+_STD_END
+
+#endif // !STDCPP_IMPLIB || defined(_M_CEE_PURE)
diff --git a/msvc-stl/stl/src/locale0_implib.cpp b/msvc-stl/stl/src/locale0_implib.cpp
new file mode 100644
index 0000000..1e433b4
--- /dev/null
+++ b/msvc-stl/stl/src/locale0_implib.cpp
@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#if defined(_DLL)
+#ifdef CRTDLL2
+#undef CRTDLL2
+#endif
+
+#ifdef MRTDLL
+#undef MRTDLL
+#endif
+
+#define STDCPP_IMPLIB 1
+
+// When building for msvcmrt.lib, inject a dependency to the msvcp DLL.
+#if defined(_M_CEE) && !defined(_M_CEE_PURE)
+#ifdef _CRTBLD
+#define _CRTBLD_WAS_DEFINED
+#undef _CRTBLD
+#endif
+#include <use_ansi.h>
+#ifdef _CRTBLD_WAS_DEFINED
+#define _CRTBLD
+#undef _CRTBLD_WAS_DEFINED
+#endif
+#endif
+
+#include "locale0.cpp"
+
+#endif // defined(_DLL)
diff --git a/msvc-stl/stl/src/locale_implib_pure.cpp b/msvc-stl/stl/src/locale_implib_pure.cpp
new file mode 100644
index 0000000..fd689ec
--- /dev/null
+++ b/msvc-stl/stl/src/locale_implib_pure.cpp
@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#define STDCPP_IMPLIB 1
+#include "locale.cpp"
diff --git a/msvc-stl/stl/src/memory_resource.cpp b/msvc-stl/stl/src/memory_resource.cpp
new file mode 100644
index 0000000..01642a6
--- /dev/null
+++ b/msvc-stl/stl/src/memory_resource.cpp
@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <internal_shared.h>
+#include <memory_resource>
+#include <system_error>
+
+_STD_BEGIN
+namespace pmr {
+
+    static memory_resource* _Default_resource{nullptr};
+
+    extern "C" _CRT_SATELLITE_1 _Aligned_new_delete_resource_impl* __cdecl _Aligned_new_delete_resource() noexcept {
+        return &const_cast<_Aligned_new_delete_resource_impl&>(
+            _Immortalize_memcpy_image<_Aligned_new_delete_resource_impl>());
+    }
+
+    extern "C" _CRT_SATELLITE_1 _Unaligned_new_delete_resource_impl* __cdecl _Unaligned_new_delete_resource() noexcept {
+        return &const_cast<_Unaligned_new_delete_resource_impl&>(
+            _Immortalize_memcpy_image<_Unaligned_new_delete_resource_impl>());
+    }
+
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Aligned_get_default_resource() noexcept {
+        memory_resource* const _Temp = __crt_interlocked_read_pointer(&_Default_resource);
+        if (_Temp) {
+            return _Temp;
+        }
+
+        return _Aligned_new_delete_resource();
+    }
+
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Unaligned_get_default_resource() noexcept {
+        memory_resource* const _Temp = __crt_interlocked_read_pointer(&_Default_resource);
+        if (_Temp) {
+            return _Temp;
+        }
+
+        return _Unaligned_new_delete_resource();
+    }
+
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Aligned_set_default_resource(
+        memory_resource* const _Resource) noexcept {
+        memory_resource* const _Temp = __crt_interlocked_exchange_pointer(&_Default_resource, _Resource);
+        if (_Temp) {
+            return _Temp;
+        }
+
+        return _Aligned_new_delete_resource();
+    }
+
+    extern "C" _CRT_SATELLITE_1 memory_resource* __cdecl _Unaligned_set_default_resource(
+        memory_resource* const _Resource) noexcept {
+        memory_resource* const _Temp = __crt_interlocked_exchange_pointer(&_Default_resource, _Resource);
+        if (_Temp) {
+            return _Temp;
+        }
+
+        return _Unaligned_new_delete_resource();
+    }
+
+    extern "C" [[nodiscard]] _CRT_SATELLITE_1 memory_resource* __cdecl null_memory_resource() noexcept {
+        class _Null_resource final : public _Identity_equal_resource {
+            void* do_allocate(size_t, size_t) override { // Sorry, OOM!
+                _Xbad_alloc();
+            }
+            void do_deallocate(void*, size_t, size_t) override {} // Nothing to do
+        };
+
+        return &const_cast<_Null_resource&>(_Immortalize_memcpy_image<_Null_resource>());
+    }
+
+} // namespace pmr
+_STD_END
diff --git a/msvc-stl/stl/src/mexcptptr.cpp b/msvc-stl/stl/src/mexcptptr.cpp
new file mode 100644
index 0000000..bc168e0
--- /dev/null
+++ b/msvc-stl/stl/src/mexcptptr.cpp
@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// The /clr:pure exception_ptr implementation.
+#ifdef CRTDLL
+#undef CRTDLL
+#endif
+
+#ifdef MRTDLL
+#undef MRTDLL
+#endif
+
+#ifndef _DLL
+#define _DLL
+#endif
+
+#include "excptptr.cpp"
diff --git a/msvc-stl/stl/src/mpiostream.cpp b/msvc-stl/stl/src/mpiostream.cpp
new file mode 100644
index 0000000..12db878
--- /dev/null
+++ b/msvc-stl/stl/src/mpiostream.cpp
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This file is built into msvcurt.lib
+#if !defined(_M_CEE_PURE)
+#error This file must be built with /clr:pure.
+#endif
+
+#include <iostream>
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL extern istream* _Ptr_cin  = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern ostream* _Ptr_cout = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern ostream* _Ptr_cerr = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern ostream* _Ptr_clog = nullptr;
+
+__PURE_APPDOMAIN_GLOBAL extern wistream* _Ptr_wcin  = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wcout = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wcerr = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wclog = nullptr;
+
+__PURE_APPDOMAIN_GLOBAL int ios_base::Init::_Init_cnt = -1;
+_STD_END
diff --git a/msvc-stl/stl/src/msvcp_atomic_wait.src b/msvc-stl/stl/src/msvcp_atomic_wait.src
new file mode 100644
index 0000000..d156a3c
--- /dev/null
+++ b/msvc-stl/stl/src/msvcp_atomic_wait.src
@@ -0,0 +1,44 @@
+; Copyright (c) Microsoft Corporation.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+; atomic wait satellite DLL definition
+
+; NOTE: "LIBRARYNAME" is just a placeholder. It gets dynamically replaced with the generated
+; DLL name during the CMake build. (See the generate_satellite_def() function in
+; stl\CMakeLists.txt.) Doing this instead of using, e.g., CMake variable substitution allows
+; for file preprocessing via "cl /DLIBRARYNAME=..."
+LIBRARY LIBRARYNAME
+
+EXPORTS
+    __std_acquire_shared_mutex_for_instance
+    __std_atomic_compare_exchange_128
+    __std_atomic_get_mutex
+    __std_atomic_has_cmpxchg16b
+    __std_atomic_notify_all_direct
+    __std_atomic_notify_all_indirect
+    __std_atomic_notify_one_direct
+    __std_atomic_notify_one_indirect
+    __std_atomic_set_api_level
+    __std_atomic_wait_direct
+    __std_atomic_wait_get_deadline
+    __std_atomic_wait_get_remaining_timeout
+    __std_atomic_wait_indirect
+    __std_bulk_submit_threadpool_work
+    __std_calloc_crt
+    __std_close_threadpool_work
+    __std_create_threadpool_work
+    __std_execution_wait_on_uchar
+    __std_execution_wake_by_address_all
+    __std_free_crt
+    __std_parallel_algorithms_hw_threads
+    __std_release_shared_mutex_for_instance
+    __std_submit_threadpool_work
+    __std_tzdb_delete_current_zone
+    __std_tzdb_delete_leap_seconds
+    __std_tzdb_delete_sys_info
+    __std_tzdb_delete_time_zones
+    __std_tzdb_get_current_zone
+    __std_tzdb_get_leap_seconds
+    __std_tzdb_get_sys_info
+    __std_tzdb_get_time_zones
+    __std_wait_for_threadpool_work_callbacks
diff --git a/msvc-stl/stl/src/multprec.cpp b/msvc-stl/stl/src/multprec.cpp
new file mode 100644
index 0000000..ccf5cb3
--- /dev/null
+++ b/msvc-stl/stl/src/multprec.cpp
@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Once upon a time, this implemented multiprecision math for linear_congruential_engine.
+
+#include <yvals.h>
+
+#include <__msvc_int128.hpp>
+#include <cstdint>
+
+namespace {
+    using _STD _Unsigned128;
+
+    using _MP_arr = uint64_t[5]; // Stores a 128-bit value in four 32-bit parts.
+    // Each part was uint64_t for intermediate computations (now unused) and the fifth part was always unused.
+
+    [[nodiscard]] _Unsigned128 _Get_u128_from_mp(_MP_arr _Wx) noexcept {
+        const uint64_t _Lo = (_Wx[1] << 32) + _Wx[0];
+        const uint64_t _Hi = (_Wx[3] << 32) + _Wx[2];
+
+        return _Unsigned128{_Lo, _Hi};
+    }
+
+    void _Assign_mp_from_u128(_MP_arr _Wx, const _Unsigned128 _Result) noexcept {
+        const uint64_t _Lo = _Result._Word[0];
+        const uint64_t _Hi = _Result._Word[1];
+
+        _Wx[0] = static_cast<uint32_t>(_Lo);
+        _Wx[1] = _Lo >> 32;
+        _Wx[2] = static_cast<uint32_t>(_Hi);
+        _Wx[3] = _Hi >> 32;
+        _Wx[4] = 0; // unused, but zeroed out to preserve behavior exactly
+    }
+} // unnamed namespace
+
+_STD_BEGIN
+// TRANSITION, ABI: preserved for binary compatibility
+[[nodiscard]] _CRTIMP2_PURE uint64_t __CLRCALL_PURE_OR_CDECL _MP_Get(_MP_arr _Wx) noexcept {
+    // convert multi-word value to scalar value; always called with a value that won't exceed 64 bits
+    return (_Wx[1] << 32) + _Wx[0];
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Add(_MP_arr _Wx, const uint64_t _Cx) noexcept {
+    // perform "_Wx += _Cx"; always called with values that won't overflow 128 bits
+    const auto _Result = _Get_u128_from_mp(_Wx) + _Cx;
+    _Assign_mp_from_u128(_Wx, _Result);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Mul(_MP_arr _Wx, const uint64_t _Prev, const uint64_t _Ax) noexcept {
+    // set _Wx to the 128-bit product of _Prev and _Ax
+    const auto _Result = _Unsigned128{_Prev} * _Ax;
+    _Assign_mp_from_u128(_Wx, _Result);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _MP_Rem(_MP_arr _Wx, const uint64_t _Mx) noexcept {
+    // perform "_Wx %= _Mx"
+    const auto _Result = _Get_u128_from_mp(_Wx) % _Mx;
+    _Assign_mp_from_u128(_Wx, _Result);
+}
+_STD_END
diff --git a/msvc-stl/stl/src/mutex.cpp b/msvc-stl/stl/src/mutex.cpp
new file mode 100644
index 0000000..735aa8f
--- /dev/null
+++ b/msvc-stl/stl/src/mutex.cpp
@@ -0,0 +1,211 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstdio>
+#include <cstdlib>
+#include <internal_shared.h>
+#include <mutex>
+#include <new>
+#include <type_traits>
+#include <xthreads.h>
+#include <xtimec.h>
+
+extern "C" {
+
+// TRANSITION, ABI: exported only for ABI compat
+[[noreturn]] _CRTIMP2_PURE void __cdecl _Thrd_abort(const char* msg) noexcept { // abort on precondition failure
+    fputs(msg, stderr);
+    fputc('\n', stderr);
+    abort();
+}
+
+#ifdef _DEBUG
+#define _THREAD_QUOTX(x)          #x
+#define _THREAD_QUOT(x)           _THREAD_QUOTX(x)
+#define _THREAD_ASSERT(expr, msg) ((expr) ? (void) 0 : _Thrd_abort(__FILE__ "(" _THREAD_QUOT(__LINE__) "): " msg))
+#else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
+#define _THREAD_ASSERT(expr, msg) ((void) 0)
+#endif // ^^^ !defined(_DEBUG) ^^^
+
+// TRANSITION, ABI: preserved for binary compatibility
+enum class __stl_sync_api_modes_enum { normal, win7, vista, concrt };
+_CRTIMP2 void __cdecl __set_stl_sync_api_mode(__stl_sync_api_modes_enum) noexcept {}
+
+[[nodiscard]] static PSRWLOCK get_srw_lock(_Mtx_t mtx) noexcept {
+    return reinterpret_cast<PSRWLOCK>(&mtx->_Critical_section._M_srw_lock);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility (and _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR)
+_CRTIMP2_PURE void __cdecl _Mtx_init_in_situ(_Mtx_t mtx, int type) noexcept { // initialize mutex in situ
+    new (&mtx->_Critical_section) _Stl_critical_section;
+    mtx->_Thread_id = -1;
+    mtx->_Type      = type;
+    mtx->_Count     = 0;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE void __cdecl _Mtx_destroy_in_situ(_Mtx_t mtx) noexcept { // destroy mutex in situ
+    _THREAD_ASSERT(mtx->_Count == 0, "mutex destroyed while busy");
+    (void) mtx;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_init(_Mtx_t* mtx, int type) noexcept { // initialize mutex
+    *mtx = nullptr;
+
+    _Mtx_t mutex = static_cast<_Mtx_t>(_calloc_crt(1, sizeof(_Mtx_internal_imp_t)));
+
+    if (mutex == nullptr) {
+        return _Thrd_result::_Nomem; // report alloc failed
+    }
+
+    _Mtx_init_in_situ(mutex, type);
+
+    *mtx = mutex;
+    return _Thrd_result::_Success;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE void __cdecl _Mtx_destroy(_Mtx_t mtx) noexcept { // destroy mutex
+    if (mtx) { // something to do, do it
+        _Mtx_destroy_in_situ(mtx);
+        _free_crt(mtx);
+    }
+}
+
+static _Thrd_result mtx_do_lock(_Mtx_t mtx, const _timespec64* target) noexcept { // lock mutex
+    // TRANSITION, ABI: the use of `const _timespec64*` is preserved for `_Mtx_timedlock`
+    const auto current_thread_id = static_cast<long>(GetCurrentThreadId());
+    if ((mtx->_Type & ~_Mtx_recursive) == _Mtx_plain) { // set the lock
+        // TRANSITION, ABI: this branch is preserved for `_Thrd_create`
+
+        if (mtx->_Thread_id != current_thread_id) { // not current thread, do lock
+            AcquireSRWLockExclusive(get_srw_lock(mtx));
+            mtx->_Thread_id = current_thread_id;
+        }
+        ++mtx->_Count;
+
+        return _Thrd_result::_Success;
+    } else { // handle timed or recursive mutex
+        int res = WAIT_TIMEOUT;
+        if (target == nullptr) { // no target --> plain wait (i.e. infinite timeout)
+            if (mtx->_Thread_id != current_thread_id) {
+                AcquireSRWLockExclusive(get_srw_lock(mtx));
+            }
+
+            res = WAIT_OBJECT_0;
+
+        } else if (target->tv_sec < 0 || (target->tv_sec == 0 && target->tv_nsec <= 0)) {
+            // target time <= 0 --> plain trylock or timed wait for time that has passed; try to lock with 0 timeout
+            if (mtx->_Thread_id != current_thread_id) { // not this thread, lock it
+                if (TryAcquireSRWLockExclusive(get_srw_lock(mtx)) != 0) {
+                    res = WAIT_OBJECT_0;
+                }
+            } else {
+                res = WAIT_OBJECT_0;
+            }
+
+        } else { // check timeout
+            // TRANSITION, ABI: this branch is preserved for `_Mtx_timedlock`
+            _timespec64 now;
+            _Timespec64_get_sys(&now);
+            while (now.tv_sec < target->tv_sec || (now.tv_sec == target->tv_sec && now.tv_nsec < target->tv_nsec)) {
+                // time has not expired
+                if (mtx->_Thread_id == current_thread_id
+                    || TryAcquireSRWLockExclusive(get_srw_lock(mtx)) != 0) { // stop waiting
+                    res = WAIT_OBJECT_0;
+                    break;
+                }
+
+                _Timespec64_get_sys(&now);
+            }
+        }
+
+        if (res == WAIT_OBJECT_0) {
+            if (1 < ++mtx->_Count) { // check count
+                if ((mtx->_Type & _Mtx_recursive) != _Mtx_recursive) { // not recursive, fixup count
+                    --mtx->_Count;
+                    res = WAIT_TIMEOUT;
+                }
+            } else {
+                mtx->_Thread_id = current_thread_id;
+            }
+        }
+
+        if (res == WAIT_OBJECT_0) {
+            return _Thrd_result::_Success;
+        }
+
+        // res is WAIT_TIMEOUT here
+
+        if (target == nullptr || (target->tv_sec == 0 && target->tv_nsec == 0)) {
+            return _Thrd_result::_Busy;
+        }
+
+        return _Thrd_result::_Timedout;
+    }
+}
+
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_unlock(_Mtx_t mtx) noexcept { // unlock mutex
+    _THREAD_ASSERT(mtx->_Count > 0, "unlock of unowned mutex");
+    _THREAD_ASSERT(
+        mtx->_Thread_id == static_cast<long>(GetCurrentThreadId()), "unlock of mutex not owned by the current thread");
+
+    if (--mtx->_Count == 0) { // leave critical section
+        mtx->_Thread_id = -1;
+
+        auto srw_lock = get_srw_lock(mtx);
+        _Analysis_assume_lock_held_(*srw_lock);
+        ReleaseSRWLockExclusive(srw_lock);
+    }
+    return _Thrd_result::_Success; // TRANSITION, ABI: Always succeeds
+}
+
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_lock(_Mtx_t mtx) noexcept { // lock mutex
+    return mtx_do_lock(mtx, nullptr);
+}
+
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_trylock(_Mtx_t mtx) noexcept { // attempt to lock try_mutex
+    _timespec64 xt;
+    _THREAD_ASSERT((mtx->_Type & (_Mtx_try | _Mtx_timed)) != 0, "trylock not supported by mutex");
+    xt.tv_sec  = 0;
+    xt.tv_nsec = 0;
+    return mtx_do_lock(mtx, &xt);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE _Thrd_result __cdecl _Mtx_timedlock(_Mtx_t mtx, const _timespec64* xt) noexcept {
+    // attempt to lock timed mutex
+    _Thrd_result res;
+
+    _THREAD_ASSERT((mtx->_Type & _Mtx_timed) != 0, "timedlock not supported by mutex");
+    res = mtx_do_lock(mtx, xt);
+    return res == _Thrd_result::_Busy ? _Thrd_result::_Timedout : res;
+}
+
+_CRTIMP2_PURE int __cdecl _Mtx_current_owns(_Mtx_t mtx) noexcept { // test if current thread owns mutex
+    return mtx->_Count != 0 && mtx->_Thread_id == static_cast<long>(GetCurrentThreadId());
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE void* __cdecl _Mtx_getconcrtcs(_Mtx_t mtx) noexcept { // get internal cs impl
+    return &mtx->_Critical_section;
+}
+
+} // extern "C"
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/msvc-stl/stl/src/nothrow.cpp b/msvc-stl/stl/src/nothrow.cpp
new file mode 100644
index 0000000..9124a15
--- /dev/null
+++ b/msvc-stl/stl/src/nothrow.cpp
@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// define nothrow object
+
+#ifdef CRTDLL2
+#undef CRTDLL2
+#endif
+
+#ifdef MRTDLL
+#undef MRTDLL
+#endif
+
+#include <yvals_core.h>
+
+#include <vcruntime_new.h>
+
+_STD_BEGIN
+const nothrow_t nothrow = nothrow_t();
+_STD_END
diff --git a/msvc-stl/stl/src/parallel_algorithms.cpp b/msvc-stl/stl/src/parallel_algorithms.cpp
new file mode 100644
index 0000000..5c94490
--- /dev/null
+++ b/msvc-stl/stl/src/parallel_algorithms.cpp
@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// support for <execution>
+
+#include <internal_shared.h>
+#include <thread>
+#include <xatomic_wait.h>
+
+extern "C" {
+
+[[nodiscard]] unsigned int __stdcall __std_parallel_algorithms_hw_threads() noexcept {
+    static int _Cached_hw_concurrency = -1;
+    int _Hw_concurrency               = __iso_volatile_load32(&_Cached_hw_concurrency);
+    if (_Hw_concurrency == -1) {
+        _Hw_concurrency = static_cast<int>(_STD thread::hardware_concurrency());
+        __iso_volatile_store32(&_Cached_hw_concurrency, _Hw_concurrency);
+    }
+
+    return static_cast<unsigned int>(_Hw_concurrency);
+}
+
+[[nodiscard]] PTP_WORK __stdcall __std_create_threadpool_work(
+    PTP_WORK_CALLBACK _Callback, void* _Context, PTP_CALLBACK_ENVIRON _Callback_environ) noexcept {
+    return CreateThreadpoolWork(_Callback, _Context, _Callback_environ);
+}
+
+void __stdcall __std_submit_threadpool_work(PTP_WORK _Work) noexcept {
+    SubmitThreadpoolWork(_Work);
+}
+
+void __stdcall __std_bulk_submit_threadpool_work(PTP_WORK _Work, const size_t _Submissions) noexcept {
+    for (size_t _Idx = 0; _Idx < _Submissions; ++_Idx) {
+        SubmitThreadpoolWork(_Work);
+    }
+}
+
+void __stdcall __std_close_threadpool_work(PTP_WORK _Work) noexcept {
+    CloseThreadpoolWork(_Work);
+}
+
+void __stdcall __std_wait_for_threadpool_work_callbacks(PTP_WORK _Work, BOOL _Cancel) noexcept {
+    WaitForThreadpoolWorkCallbacks(_Work, _Cancel);
+}
+
+void __stdcall __std_execution_wait_on_uchar(const volatile unsigned char* _Address, unsigned char _Compare) noexcept {
+    __std_atomic_wait_direct(const_cast<const unsigned char*>(_Address), &_Compare, 1, __std_atomic_wait_no_timeout);
+}
+
+void __stdcall __std_execution_wake_by_address_all(const volatile void* _Address) noexcept {
+    __std_atomic_notify_all_direct(const_cast<const void*>(_Address));
+}
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/pplerror.cpp b/msvc-stl/stl/src/pplerror.cpp
new file mode 100644
index 0000000..c3fd445
--- /dev/null
+++ b/msvc-stl/stl/src/pplerror.cpp
@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _VCRT_ALLOW_INTERNALS
+#define _VCRT_ALLOW_INTERNALS
+#endif
+
+#include <ppltasks.h>
+
+#if defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT)
+
+#include <RestrictedErrorInfo.h>
+#include <ehdata.h>
+#include <exception>
+#include <roerrorapi.h>
+#include <trnsctrl.h>
+
+extern "C" void* __GetPlatformExceptionInfo(int*);
+
+#endif // ^^^ defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT) ^^^
+
+namespace Concurrency {
+    namespace details {
+
+        _CRTIMP2 void __thiscall _ExceptionHolder::ReportUnhandledError() {
+#if defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT)
+            if (_M_stdException) {
+                try {
+                    std::rethrow_exception(_M_stdException);
+                } catch (...) {
+                    int isBadAlloc;
+                    auto info = static_cast<WINRTEXCEPTIONINFO*>(__GetPlatformExceptionInfo(&isBadAlloc));
+                    // If it is a winrt exception
+                    if (!isBadAlloc && info != nullptr) {
+                        auto restrictedInfo(static_cast<IRestrictedErrorInfo*>(info->restrictedInfo));
+                        if (restrictedInfo != nullptr) {
+#ifndef _M_ARM64 // CRT_REFACTOR TODO
+                            ::RoReportUnhandledError(restrictedInfo);
+#endif // !defined(_M_ARM64)
+
+                            // IRestrictedErrorInfo should be put back
+                            // to make sure that RoFailFastWithErrorContext can extract the information
+                            ::SetRestrictedErrorInfo(restrictedInfo);
+                        }
+                        ::RoFailFastWithErrorContext(info->hr);
+                    }
+                }
+            }
+#endif // ^^^ defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT) ^^^
+        }
+
+    } // namespace details
+} // namespace Concurrency
diff --git a/msvc-stl/stl/src/ppltasks.cpp b/msvc-stl/stl/src/ppltasks.cpp
new file mode 100644
index 0000000..56108ac
--- /dev/null
+++ b/msvc-stl/stl/src/ppltasks.cpp
@@ -0,0 +1,199 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <crtdefs.h>
+#include <pplinterface.h>
+#include <ppltasks.h>
+
+#include <Windows.h>
+
+#if defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT)
+#ifndef UNDOCKED_WINDOWS_UCRT
+#pragma warning(push)
+#pragma warning(disable : 4265) // non-virtual destructor in base class
+#endif // ^^^ !defined(UNDOCKED_WINDOWS_UCRT) ^^^
+#include <wrl.h>
+#ifndef UNDOCKED_WINDOWS_UCRT
+#pragma warning(pop)
+#endif // ^^^ !defined(UNDOCKED_WINDOWS_UCRT) ^^^
+#include <ctxtcall.h>
+#include <functional>
+#include <stdexcept>
+#include <windows.foundation.diagnostics.h>
+#endif // ^^^ defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT) ^^^
+
+namespace Concurrency {
+
+    namespace details {
+        [[noreturn]] _CRTIMP2 void __cdecl _ReportUnobservedException() {
+            __fastfail(FAST_FAIL_INVALID_ARG);
+        }
+
+        namespace platform {
+
+            _CRTIMP2 long __cdecl GetCurrentThreadId() {
+                return static_cast<long>(::GetCurrentThreadId());
+            }
+
+            /// <summary>
+            ///     CRT CaptureStackBackTrace API wrapper
+            /// </summary>
+            _CRTIMP2 size_t __cdecl CaptureCallstack(void** stackData, size_t skipFrames, size_t captureFrames) {
+                return RtlCaptureStackBackTrace(
+                    static_cast<DWORD>(skipFrames + 1), static_cast<DWORD>(captureFrames), stackData, nullptr);
+            }
+
+            static unsigned int s_asyncId = 0;
+
+            _CRTIMP2 unsigned int __cdecl GetNextAsyncId() {
+                return static_cast<unsigned int>(::_InterlockedIncrement(reinterpret_cast<volatile LONG*>(&s_asyncId)));
+            }
+
+        } // namespace platform
+
+        _CRTIMP2 void __thiscall _TaskEventLogger::_LogScheduleTask(bool) {}
+
+        _CRTIMP2 void __thiscall _TaskEventLogger::_LogTaskCompleted() {}
+
+        _CRTIMP2 void __thiscall _TaskEventLogger::_LogCancelTask() {}
+
+        _CRTIMP2 void __thiscall _TaskEventLogger::_LogTaskExecutionCompleted() {}
+
+        _CRTIMP2 void __thiscall _TaskEventLogger::_LogWorkItemStarted() {}
+
+        _CRTIMP2 void __thiscall _TaskEventLogger::_LogWorkItemCompleted() {}
+
+#if defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT)
+        using namespace ABI::Windows::Foundation;
+        using namespace ABI::Windows::Foundation::Diagnostics;
+        using namespace Microsoft::WRL;
+        using namespace Microsoft::WRL::Wrappers;
+
+        // This IID is exported by ole32.dll; we cannot depend on ole32.dll.
+        static GUID const Local_IID_ICallbackWithNoReentrancyToApplicationSTA = {
+            0x0A299774, 0x3E4E, 0xFC42, {0x1D, 0x9D, 0x72, 0xCE, 0xE1, 0x05, 0xCA, 0x57}};
+
+        static HRESULT __stdcall _PPLTaskContextCallbackBridge(ComCallData* _PParam) {
+            auto pFunc = static_cast<std::function<void()>*>(_PParam->pUserDefined);
+            (*pFunc)();
+            return S_OK;
+        }
+        _CRTIMP2 void __thiscall _ContextCallback::_CallInContext(
+            _CallbackFunction _Func, bool _IgnoreDisconnect) const {
+            if (!_HasCapturedContext()) {
+                _Func();
+            } else {
+                ComCallData callData;
+                ZeroMemory(&callData, sizeof(callData));
+                callData.pUserDefined = &_Func;
+
+                HRESULT hresult = static_cast<IContextCallback*>(_M_context._M_pContextCallback)
+                                      ->ContextCallback(&_PPLTaskContextCallbackBridge, &callData,
+                                          Local_IID_ICallbackWithNoReentrancyToApplicationSTA, 5, nullptr);
+                if (FAILED(hresult) && !(_IgnoreDisconnect && _IsHRCOMDisconnected(hresult))) {
+                    throw std::runtime_error("Context callback failed.");
+                }
+            }
+        }
+        _CRTIMP2 void __thiscall _ContextCallback::_Capture() {
+            HRESULT _Hr = CoGetObjectContext(__uuidof(IContextCallback), &_M_context._M_pContextCallback);
+            if (FAILED(_Hr)) {
+                _M_context._M_pContextCallback = nullptr;
+            }
+        }
+
+        _CRTIMP2 void __thiscall _ContextCallback::_Reset() {
+            if (_M_context._M_captureMethod != _S_captureDeferred && _M_context._M_pContextCallback != nullptr) {
+                static_cast<IContextCallback*>(_M_context._M_pContextCallback)->Release();
+            }
+        }
+
+        _CRTIMP2 void __thiscall _ContextCallback::_Assign(void* _PContextCallback) {
+            _M_context._M_pContextCallback = _PContextCallback;
+            if (_M_context._M_captureMethod != _S_captureDeferred && _M_context._M_pContextCallback != nullptr) {
+                static_cast<IContextCallback*>(_M_context._M_pContextCallback)->AddRef();
+            }
+        }
+
+        _CRTIMP2 bool __cdecl _ContextCallback::_IsCurrentOriginSTA() {
+            APTTYPE _AptType;
+            APTTYPEQUALIFIER _AptTypeQualifier;
+
+            HRESULT hr = CoGetApartmentType(&_AptType, &_AptTypeQualifier);
+            if (SUCCEEDED(hr)) {
+                // We determine the origin of a task continuation by looking at where .then is called, so we can tell
+                // whether to need to marshal the continuation back to the originating apartment. If an STA thread is in
+                // executing in a neutral apartment when it schedules a continuation, we will not marshal continuations
+                // back to the STA, since variables used within a neutral apartment are expected to be apartment
+                // neutral.
+                switch (_AptType) {
+                case APTTYPE_MAINSTA:
+                case APTTYPE_STA:
+                    return true;
+                default:
+                    break;
+                }
+            }
+            return false;
+        }
+
+        _CRTIMP2 bool __cdecl _Task_impl_base::_IsNonBlockingThread() {
+            APTTYPE _AptType;
+            APTTYPEQUALIFIER _AptTypeQualifier;
+
+            HRESULT hr = CoGetApartmentType(&_AptType, &_AptTypeQualifier);
+            //
+            // If it failed, it's not a Windows Runtime/COM initialized thread. This is not a failure.
+            //
+            if (SUCCEEDED(hr)) {
+                switch (_AptType) {
+                case APTTYPE_STA:
+                case APTTYPE_MAINSTA:
+                    return true;
+                case APTTYPE_NA:
+                    switch (_AptTypeQualifier) {
+                        // A thread executing in a neutral apartment is either STA or MTA. To find out if this thread is
+                        // allowed to wait, we check the app qualifier. If it is an STA thread executing in a neutral
+                        // apartment, waiting is illegal, because the thread is responsible for pumping messages and
+                        // waiting on a task could take the thread out of circulation for a while.
+                    case APTTYPEQUALIFIER_NA_ON_STA:
+                    case APTTYPEQUALIFIER_NA_ON_MAINSTA:
+                        return true;
+                    }
+                    break;
+                }
+            }
+            return false;
+        }
+
+#else // ^^^ defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT)
+      //                                         / !defined(_CRT_APP) && !defined(UNDOCKED_WINDOWS_UCRT) vvv
+        _CRTIMP2 void __thiscall _ContextCallback::_CallInContext(_CallbackFunction _Func, bool) const {
+            _Func();
+        }
+
+        _CRTIMP2 void __thiscall _ContextCallback::_Capture() {}
+
+        _CRTIMP2 void __thiscall _ContextCallback::_Reset() {}
+
+        _CRTIMP2 void __thiscall _ContextCallback::_Assign(void*) {}
+
+        _CRTIMP2 bool __cdecl _ContextCallback::_IsCurrentOriginSTA() {
+            return false;
+        }
+
+        _CRTIMP2 bool __cdecl _Task_impl_base::_IsNonBlockingThread() {
+            return false;
+        }
+#endif // ^^^ !defined(_CRT_APP) && !defined(UNDOCKED_WINDOWS_UCRT) ^^^
+    } // namespace details
+
+#ifdef _CRT_APP
+    _CRTIMP2 __thiscall task_continuation_context::task_continuation_context()
+        : _ContextCallback(true), _M_RunInline(false) {}
+#else // ^^^ defined(_CRT_APP) / !defined(_CRT_APP) vvv
+    _CRTIMP2 __thiscall task_continuation_context::task_continuation_context()
+        : _ContextCallback(false), _M_RunInline(false) {}
+#endif // ^^^ !defined(_CRT_APP) ^^^
+
+} // namespace Concurrency
diff --git a/msvc-stl/stl/src/primitives.hpp b/msvc-stl/stl/src/primitives.hpp
new file mode 100644
index 0000000..3cba95a
--- /dev/null
+++ b/msvc-stl/stl/src/primitives.hpp
@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <__msvc_threads_core.hpp>
+#include <cstdlib>
+
+#include <Windows.h>
+
+inline bool _Primitive_wait_for(const _Cnd_t cond, const _Mtx_t mtx, const unsigned int timeout) noexcept {
+    const auto pcv  = reinterpret_cast<PCONDITION_VARIABLE>(&cond->_Stl_cv._Win_cv);
+    const auto psrw = reinterpret_cast<PSRWLOCK>(&mtx->_Critical_section._M_srw_lock);
+    return SleepConditionVariableSRW(pcv, psrw, timeout, 0) != 0;
+}
+
+inline void _Primitive_wait(const _Cnd_t cond, const _Mtx_t mtx) noexcept {
+    if (!_Primitive_wait_for(cond, mtx, INFINITE)) {
+        _CSTD abort();
+    }
+}
+
+inline void _Primitive_notify_one(const _Cnd_t cond) noexcept {
+    const auto pcv = reinterpret_cast<PCONDITION_VARIABLE>(&cond->_Stl_cv._Win_cv);
+    WakeConditionVariable(pcv);
+}
+
+inline void _Primitive_notify_all(const _Cnd_t cond) noexcept {
+    const auto pcv = reinterpret_cast<PCONDITION_VARIABLE>(&cond->_Stl_cv._Win_cv);
+    WakeAllConditionVariable(pcv);
+}
diff --git a/msvc-stl/stl/src/print.cpp b/msvc-stl/stl/src/print.cpp
new file mode 100644
index 0000000..da711fc
--- /dev/null
+++ b/msvc-stl/stl/src/print.cpp
@@ -0,0 +1,317 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// print.cpp -- C++23 <print> implementation
+
+#include <__msvc_print.hpp>
+#include <cstdio>
+#include <cstdlib>
+#include <internal_shared.h>
+#include <io.h>
+#include <type_traits>
+
+#include <Windows.h>
+
+extern "C" {
+
+[[nodiscard]] _Success_(return._Error == __std_win_error::_Success) __std_unicode_console_retrieval_result __stdcall
+    __std_get_unicode_console_handle_from_file_stream(_In_ FILE* const _Stream) noexcept {
+    if (_Stream == nullptr) {
+        return __std_unicode_console_retrieval_result{._Error = __std_win_error::_Invalid_parameter};
+    }
+
+    const int _Fd = _fileno(_Stream);
+
+    if (_Fd == -2) {
+        // According to https://learn.microsoft.com/cpp/c-runtime-library/reference/fileno ,
+        // _fileno() returns -2 if _Stream refers to either stdout or stderr and there is no associated output stream.
+        // In that case, there is also no associated console HANDLE. (We haven't observed this happening in practice.)
+        return __std_unicode_console_retrieval_result{._Error = __std_win_error::_Not_supported};
+    } else if (_Fd == -1) {
+        return __std_unicode_console_retrieval_result{._Error = __std_win_error::_Invalid_parameter};
+    }
+
+    const HANDLE _Console_handle = reinterpret_cast<HANDLE>(_get_osfhandle(_Fd));
+
+    if (_Console_handle == INVALID_HANDLE_VALUE) {
+        return __std_unicode_console_retrieval_result{._Error = __std_win_error::_Invalid_parameter};
+    }
+
+    // We can check if _Console_handle actually refers to a console or not by checking the
+    // return value of GetConsoleMode().
+    DWORD _Console_mode;
+    const bool _Is_unicode_console = GetConsoleMode(_Console_handle, &_Console_mode) != 0;
+
+    if (!_Is_unicode_console) {
+        return __std_unicode_console_retrieval_result{._Error = __std_win_error::_File_not_found};
+    }
+
+    return __std_unicode_console_retrieval_result{
+        ._Console_handle = static_cast<__std_unicode_console_handle>(
+            reinterpret_cast<_STD underlying_type_t<__std_unicode_console_handle>>(_Console_handle)),
+        ._Error = __std_win_error::_Success};
+}
+
+} // extern "C"
+
+namespace {
+    class _Allocated_string {
+    public:
+        _Allocated_string() noexcept {
+            _Buffer[0] = L'\0'; // Activate _Buffer
+        }
+
+        ~_Allocated_string() {
+            if (_Using_heap()) {
+                _Str.~_Heap_string();
+            }
+        }
+
+        [[nodiscard]] wchar_t* _Data() noexcept {
+            return _Using_heap() ? _Str.get() : _Buffer;
+        }
+
+        [[nodiscard]] size_t _Capacity() const noexcept {
+            return _Str_capacity;
+        }
+
+        [[nodiscard]] bool _Grow(const size_t _Capacity) noexcept {
+            if (_Capacity <= _Str_capacity) {
+                return true;
+            }
+
+            if (_Using_heap()) {
+                _Str.~_Heap_string();
+                // We must not throw until restoring the invariant that:
+                // (_Str_capacity == _Buffer_size && _Buffer is active) ||
+                // (_Str_capacity > _Buffer_size && _Str is active)
+            }
+
+            ::new (&_Str) _Heap_string(_malloc_crt_t(wchar_t, _Capacity)); // Activate _Str
+
+            if (!_Str) {
+                _Str_capacity = _Buffer_size;
+                _Buffer[0]    = L'\0'; // Activate _Buffer
+                return false;
+            }
+
+            _Str_capacity = _Capacity;
+            return true;
+        }
+
+    private:
+        using _Heap_string = __crt_unique_heap_ptr<wchar_t>;
+
+        // Allows small formatted strings, such as those from _Print_to_unicode_console_it, to not allocate any extra
+        // internal transcoding buffer
+        static constexpr size_t _Buffer_size = 2048;
+
+        [[nodiscard]] bool _Using_heap() const noexcept {
+            return _Str_capacity > _Buffer_size;
+        }
+
+        size_t _Str_capacity = _Buffer_size;
+        union {
+            wchar_t _Buffer[_Buffer_size];
+            _Heap_string _Str;
+        };
+    };
+
+    template <class _Char_type>
+    class _Really_basic_string_view {
+    public:
+        _Really_basic_string_view() = default;
+
+        explicit _Really_basic_string_view(const _Char_type* const _Other_str, const size_t _Other_size) noexcept
+            : _Str(_Other_str), _Str_size(_Other_size) {}
+
+        [[nodiscard]] const _Char_type* _Data() const noexcept {
+            return _Str;
+        }
+
+        [[nodiscard]] size_t _Size() const noexcept {
+            return _Str_size;
+        }
+
+        [[nodiscard]] bool _Empty() const noexcept {
+            return _Str_size == 0;
+        }
+
+    private:
+        const _Char_type* _Str = nullptr;
+        size_t _Str_size       = 0;
+    };
+
+    using _Minimal_string_view  = _Really_basic_string_view<char>;
+    using _Minimal_wstring_view = _Really_basic_string_view<wchar_t>;
+
+    [[nodiscard]] _Minimal_string_view _Get_next_utf8_string_segment(
+        const char* const _Str, const size_t _Str_size) noexcept {
+        constexpr size_t _Max_str_segment_size = 8192;
+
+        if (_Str_size <= _Max_str_segment_size) {
+            return _Minimal_string_view{_Str, _Str_size};
+        }
+
+        // Let's refer to _Max_str_segment_size as M.
+        // Now we know _Str_size > M, so we can read _Str[M].
+        // We might need to shrink this segment down to M - 3 bytes, in this worst case scenario:
+
+        //  Values:        [byte1][byte2][byte3] | [byte4]
+        // Indices: [M - 4][M - 3][M - 2][M - 1] | [  M  ]
+        //   Sizes: [M - 3][M - 2][M - 1][  M  ] | [M + 1]
+        //              Maximum segment boundary ^
+
+        for (size_t _Shrink = 0; _Shrink < 3; ++_Shrink) {
+            const size_t _Kx = _Max_str_segment_size - _Shrink; // consider a segment of _Kx bytes
+
+            // The first byte after the segment is at index _Kx, which we can read (see above).
+            // If _Str[_Kx] is a non-trailing byte, then it's the beginning of a code point.
+            const bool _Trailing_byte = (static_cast<unsigned char>(_Str[_Kx]) >> 6) == 0b10;
+
+            if (!_Trailing_byte) {
+                return _Minimal_string_view{_Str, _Kx}; // found a boundary between code points
+            }
+        }
+
+        return _Minimal_string_view{_Str, _Max_str_segment_size - 3}; // worst case scenario
+    }
+
+    class _Transcode_result {
+    public:
+        _Transcode_result() noexcept : _Transcoded_str(), _Successful(true) {}
+
+        _Transcode_result(_Minimal_wstring_view _Result_str) noexcept
+            : _Transcoded_str(_Result_str), _Successful(true) {}
+
+        _Transcode_result(__std_win_error _Result_error) noexcept : _Win_error(_Result_error), _Successful(false) {}
+
+        [[nodiscard]] bool _Has_value() const noexcept {
+            return _Successful;
+        }
+
+        [[nodiscard]] _Minimal_wstring_view _Value() const noexcept {
+            return _Transcoded_str;
+        }
+
+        [[nodiscard]] __std_win_error _Error() const noexcept {
+            return _Win_error;
+        }
+
+    private:
+        union {
+            _Minimal_wstring_view _Transcoded_str;
+            __std_win_error _Win_error;
+        };
+
+        bool _Successful;
+    };
+
+    [[nodiscard]] _Transcode_result _Transcode_utf8_string(
+        _Allocated_string& _Dst_str, const _Minimal_string_view _Src_str) noexcept {
+        // MultiByteToWideChar() fails if strLength == 0.
+        if (_Src_str._Empty()) {
+            return {};
+        }
+
+        // For vprint_unicode(), N4950 [ostream.formatted.print]/4 suggests replacing invalid code units with U+FFFD.
+        // This is done automatically by MultiByteToWideChar(), so long as we do not use the MB_ERR_INVALID_CHARS flag.
+        // We transcode up to 8,192 bytes per segment, which easily fits in an int.
+        const int32_t _Num_chars_required =
+            MultiByteToWideChar(CP_UTF8, 0, _Src_str._Data(), static_cast<int>(_Src_str._Size()), nullptr, 0);
+
+        if (_Num_chars_required == 0) {
+            return static_cast<__std_win_error>(GetLastError());
+        }
+
+        const bool _Has_space = _Dst_str._Grow(static_cast<size_t>(_Num_chars_required));
+        if (!_Has_space) {
+            return __std_win_error::_Not_enough_memory;
+        }
+
+        const int32_t _Conversion_result = MultiByteToWideChar(CP_UTF8, 0, _Src_str._Data(),
+            static_cast<int>(_Src_str._Size()), _Dst_str._Data(), static_cast<int>(_Dst_str._Capacity()));
+
+        if (_Conversion_result == 0) {
+            // This shouldn't happen...
+            _CSTD abort();
+        }
+
+        return _Minimal_wstring_view{_Dst_str._Data(), static_cast<size_t>(_Conversion_result)};
+    }
+
+    [[nodiscard]] __std_win_error _Write_console(
+        const HANDLE _Console_handle, const _Minimal_wstring_view _Wide_str) noexcept {
+        const BOOL _Write_result =
+            WriteConsoleW(_Console_handle, _Wide_str._Data(), static_cast<DWORD>(_Wide_str._Size()), nullptr, nullptr);
+
+        if (!_Write_result) {
+            return static_cast<__std_win_error>(GetLastError());
+        }
+
+        return __std_win_error::_Success;
+    }
+} // unnamed namespace
+
+extern "C" {
+
+[[nodiscard]] _Success_(return == __std_win_error::_Success) __std_win_error __stdcall __std_print_to_unicode_console(
+    _In_ const __std_unicode_console_handle _Console_handle, _In_reads_(_Str_size) const char* const _Str,
+    _In_ const size_t _Str_size) noexcept {
+    if (_Console_handle == __std_unicode_console_handle::_Invalid || _Str == nullptr) {
+        return __std_win_error::_Invalid_parameter;
+    }
+
+    const HANDLE _Actual_console_handle = reinterpret_cast<HANDLE>(_Console_handle);
+
+    // We transcode in fairly large segments of 8,192 bytes per segment,
+    // so one iteration should handle the vast majority of strings.
+    const char* _Remaining_str = _Str;
+    size_t _Remaining_str_size = _Str_size;
+
+    _Minimal_string_view _Curr_str_segment{};
+    _Allocated_string _Allocated_str{};
+    _Transcode_result _Transcoded_str{};
+
+    for (;;) {
+        _Curr_str_segment = _Get_next_utf8_string_segment(_Remaining_str, _Remaining_str_size);
+        _Transcoded_str   = _Transcode_utf8_string(_Allocated_str, _Curr_str_segment);
+
+        if (!_Transcoded_str._Has_value()) {
+            return _Transcoded_str._Error();
+        }
+
+        const __std_win_error _Write_result = _Write_console(_Actual_console_handle, _Transcoded_str._Value());
+
+        if (_Write_result != __std_win_error::_Success) {
+            return _Write_result;
+        }
+
+        _Remaining_str_size -= _Curr_str_segment._Size();
+
+        if (_Remaining_str_size == 0) {
+            return __std_win_error::_Success;
+        }
+
+        _Remaining_str += _Curr_str_segment._Size();
+    }
+}
+
+[[nodiscard]] _Success_(return == __std_win_error::_Success) __std_win_error __stdcall
+    __std_print_newline_only_to_unicode_console(_In_ const __std_unicode_console_handle _Console_handle) noexcept {
+    if (_Console_handle == __std_unicode_console_handle::_Invalid) {
+        return __std_win_error::_Invalid_parameter;
+    }
+
+    const auto _Actual_console_handle = reinterpret_cast<HANDLE>(_Console_handle);
+
+    const BOOL _Write_result = WriteConsoleW(_Actual_console_handle, L"\n", 1, nullptr, nullptr);
+
+    if (!_Write_result) {
+        return static_cast<__std_win_error>(GetLastError());
+    }
+
+    return __std_win_error::_Success;
+}
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/raisehan.cpp b/msvc-stl/stl/src/raisehan.cpp
new file mode 100644
index 0000000..b6c99d1
--- /dev/null
+++ b/msvc-stl/stl/src/raisehan.cpp
@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// pointer to raise handler
+
+#ifndef _M_CEE_PURE
+#define _HAS_EXCEPTIONS 0
+#endif // !defined(_M_CEE_PURE)
+#include <exception>
+_STD_BEGIN
+
+_Prhand _Raise_handler = nullptr; // define raise handler pointer
+
+_STD_END
diff --git a/msvc-stl/stl/src/regex.cpp b/msvc-stl/stl/src/regex.cpp
new file mode 100644
index 0000000..6ecd774
--- /dev/null
+++ b/msvc-stl/stl/src/regex.cpp
@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This file is compiled into the import library.
+// MAJOR LIMITATIONS apply to what can be included here!
+// Before editing this file, read: /docs/import_library.md
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <clocale>
+#include <crtdefs.h>
+#include <cstdlib>
+#include <cstring>
+#include <internal_shared.h>
+
+#include <Windows.h>
+
+#undef _ENFORCE_ONLY_CORE_HEADERS
+#include "awint.hpp"
+
+extern "C" {
+
+// derived from xstrxfrm.cpp
+size_t __stdcall __std_regex_transform_primary_char(
+    _Out_writes_(end1 - string1) _Post_readable_size_(return) char* string1, char* end1,
+    _In_reads_(end2 - string2) const char* string2, const char* end2, _In_opt_ const _Collvec* ploc) noexcept {
+    size_t n1     = end1 - string1;
+    size_t n2     = end2 - string2;
+    size_t retval = static_cast<size_t>(-1);
+    UINT codepage;
+    const wchar_t* locale_name;
+
+    if (ploc == nullptr) {
+        locale_name = ___lc_locale_name_func()[LC_COLLATE];
+        codepage    = ___lc_collate_cp_func();
+    } else {
+        locale_name = ploc->_LocaleName;
+        codepage    = ploc->_Page;
+    }
+
+    if (locale_name == nullptr && codepage == CP_ACP) {
+        if (n2 <= n1) {
+            memcpy(string1, string2, n2);
+        }
+        retval = n2;
+    } else {
+        // Inquire size of dst string in BYTES
+        const int dstlen = __crtLCMapStringA(locale_name,
+            LCMAP_SORTKEY | LINGUISTIC_IGNORECASE | LINGUISTIC_IGNOREDIACRITIC | NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH,
+            string2, static_cast<int>(n2), nullptr, 0, codepage, TRUE);
+
+        if (dstlen != 0) {
+            retval = dstlen;
+
+            // if not enough room, return amount needed
+            if (dstlen <= static_cast<int>(n1)) {
+                // Map src string to dst string
+                __crtLCMapStringA(locale_name,
+                    LCMAP_SORTKEY | LINGUISTIC_IGNORECASE | LINGUISTIC_IGNOREDIACRITIC | NORM_IGNOREKANATYPE
+                        | NORM_IGNOREWIDTH,
+                    string2, static_cast<int>(n2), string1, static_cast<int>(n1), codepage, TRUE);
+            }
+        }
+    }
+
+    return retval;
+}
+
+// derived from xwcsxfrm.cpp
+size_t __stdcall __std_regex_transform_primary_wchar_t(
+    _Out_writes_(end1 - string1) _Post_readable_size_(return) wchar_t* string1, wchar_t* end1,
+    _In_reads_(end2 - string2) const wchar_t* string2, const wchar_t* end2, _In_opt_ const _Collvec* ploc) noexcept {
+    size_t n1   = end1 - string1;
+    size_t n2   = end2 - string2;
+    size_t size = static_cast<size_t>(-1);
+    const wchar_t* locale_name;
+
+    if (ploc == nullptr) {
+        locale_name = ___lc_locale_name_func()[LC_COLLATE];
+    } else {
+        locale_name = ploc->_LocaleName;
+    }
+
+    if (locale_name == nullptr) {
+        if (n2 <= n1) {
+            memcpy(string1, string2, n2 * sizeof(wchar_t));
+        }
+        size = n2;
+    } else {
+        // When using LCMAP_SORTKEY, LCMapStringW handles BYTES not wide
+        // chars. We use a byte buffer to hold bytes and then convert the
+        // byte string to a wide char string and return this so it can be
+        // compared using wcscmp(). User's buffer is n1 wide chars, so
+        // use an internal buffer of n1 bytes.
+
+        auto bbuffer = _malloc_crt_t(unsigned char, n1);
+
+        if (bbuffer) {
+#pragma warning(push)
+#pragma warning(disable : 6386) // PREfast doesn't understand LCMAP_SORTKEY
+            size = __crtLCMapStringW(locale_name,
+                LCMAP_SORTKEY | LINGUISTIC_IGNORECASE | LINGUISTIC_IGNOREDIACRITIC | NORM_IGNOREKANATYPE
+                    | NORM_IGNOREWIDTH,
+                string2, static_cast<int>(n2), reinterpret_cast<wchar_t*>(bbuffer.get()), static_cast<int>(n1));
+#pragma warning(pop)
+
+            if (size == 0) {
+                // buffer not big enough, get size required.
+                size = __crtLCMapStringW(locale_name,
+                    LCMAP_SORTKEY | LINGUISTIC_IGNORECASE | LINGUISTIC_IGNOREDIACRITIC | NORM_IGNOREKANATYPE
+                        | NORM_IGNOREWIDTH,
+                    string2, static_cast<int>(n2), nullptr, 0);
+
+                if (size == 0) {
+                    size = static_cast<size_t>(-1); // default error
+                }
+            } else {
+                // string successfully mapped, convert to wide char
+
+                for (size_t i = 0; i < size; ++i) {
+                    string1[i] = static_cast<wchar_t>(bbuffer.get()[i]);
+                }
+            }
+        }
+    }
+
+    return size;
+}
+} // extern "C"
diff --git a/msvc-stl/stl/src/sharedmutex.cpp b/msvc-stl/stl/src/sharedmutex.cpp
new file mode 100644
index 0000000..45d7f45
--- /dev/null
+++ b/msvc-stl/stl/src/sharedmutex.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <__msvc_threads_core.hpp>
+
+#include <Windows.h>
+
+#include "primitives.hpp"
+
+// these declarations must be in sync with those in xthreads.h
+
+extern "C" {
+static_assert(sizeof(_Smtx_t) == sizeof(SRWLOCK), "_Smtx_t must be the same size as SRWLOCK.");
+static_assert(alignof(_Smtx_t) == alignof(SRWLOCK), "_Smtx_t must be the same alignment as SRWLOCK.");
+
+void __cdecl _Smtx_lock_exclusive(_Smtx_t* smtx) noexcept { // lock shared mutex exclusively
+    AcquireSRWLockExclusive(reinterpret_cast<PSRWLOCK>(smtx));
+}
+
+void __cdecl _Smtx_lock_shared(_Smtx_t* smtx) noexcept { // lock shared mutex non-exclusively
+    AcquireSRWLockShared(reinterpret_cast<PSRWLOCK>(smtx));
+}
+
+int __cdecl _Smtx_try_lock_exclusive(_Smtx_t* smtx) noexcept { // try to lock shared mutex exclusively
+    return TryAcquireSRWLockExclusive(reinterpret_cast<PSRWLOCK>(smtx));
+}
+
+int __cdecl _Smtx_try_lock_shared(_Smtx_t* smtx) noexcept { // try to lock shared mutex non-exclusively
+    return TryAcquireSRWLockShared(reinterpret_cast<PSRWLOCK>(smtx));
+}
+
+void __cdecl _Smtx_unlock_exclusive(_Smtx_t* smtx) noexcept { // unlock exclusive shared mutex
+    _Analysis_assume_lock_held_(*reinterpret_cast<PSRWLOCK>(smtx));
+    ReleaseSRWLockExclusive(reinterpret_cast<PSRWLOCK>(smtx));
+}
+
+void __cdecl _Smtx_unlock_shared(_Smtx_t* smtx) noexcept { // unlock non-exclusive shared mutex
+    ReleaseSRWLockShared(reinterpret_cast<PSRWLOCK>(smtx));
+}
+
+void __stdcall _Thrd_sleep_for(const unsigned long ms) noexcept { // suspend current thread for `ms` milliseconds
+    Sleep(ms);
+}
+
+namespace {
+    _Thrd_result __stdcall _Cnd_timedwait_for_impl(
+        const _Cnd_t cond, const _Mtx_t mtx, const unsigned int target_ms, const bool checked) noexcept {
+        _Thrd_result res            = _Thrd_result::_Success;
+        unsigned long long start_ms = 0;
+
+        if (checked) {
+            start_ms = GetTickCount64();
+        }
+
+        // TRANSITION: replace with _Mtx_clear_owner(mtx);
+        mtx->_Thread_id = -1;
+        --mtx->_Count;
+
+        if (!_Primitive_wait_for(cond, mtx, target_ms)) { // report timeout
+            if (!checked || GetTickCount64() - start_ms >= target_ms) {
+                res = _Thrd_result::_Timedout;
+            }
+        }
+        // TRANSITION: replace with _Mtx_reset_owner(mtx);
+        mtx->_Thread_id = static_cast<long>(GetCurrentThreadId());
+        ++mtx->_Count;
+
+        return res;
+    }
+} // unnamed namespace
+
+// TRANSITION, ABI: preserved for compatibility
+_Thrd_result __stdcall _Cnd_timedwait_for(const _Cnd_t cond, const _Mtx_t mtx, const unsigned int target_ms) noexcept {
+    return _Cnd_timedwait_for_impl(cond, mtx, target_ms, true);
+}
+
+_Thrd_result __stdcall _Cnd_timedwait_for_unchecked(
+    const _Cnd_t cond, const _Mtx_t mtx, const unsigned int target_ms) noexcept {
+    return _Cnd_timedwait_for_impl(cond, mtx, target_ms, false);
+}
+
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/special_math.cpp b/msvc-stl/stl/src/special_math.cpp
new file mode 100644
index 0000000..0903f91
--- /dev/null
+++ b/msvc-stl/stl/src/special_math.cpp
@@ -0,0 +1,524 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cerrno>
+#include <cmath>
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+#pragma warning(push)
+#pragma warning(disable : 4702) // unreachable code
+#pragma warning(disable : 4714) // function marked as __forceinline not inlined
+
+#define BOOST_MATH_DOMAIN_ERROR_POLICY   errno_on_error
+#define BOOST_MATH_OVERFLOW_ERROR_POLICY ignore_error
+
+// Avoid SSE intrinsics in EC
+#if defined(_M_ARM64EC)
+// need to include intrinsics to ensure that x64 definitions in intrin0.h are not lost
+#include <intrin.h>
+#undef _M_AMD64
+#undef _M_X64
+#define _M_ARM64
+#endif // defined(_M_ARM64EC)
+
+// Using headers from Boost.Math
+#include <boost/math/special_functions/bessel.hpp>
+#include <boost/math/special_functions/beta.hpp>
+#include <boost/math/special_functions/ellint_1.hpp>
+#include <boost/math/special_functions/ellint_2.hpp>
+#include <boost/math/special_functions/ellint_3.hpp>
+#include <boost/math/special_functions/expint.hpp>
+#include <boost/math/special_functions/hermite.hpp>
+#include <boost/math/special_functions/laguerre.hpp>
+#include <boost/math/special_functions/legendre.hpp>
+#include <boost/math/special_functions/spherical_harmonic.hpp>
+#include <boost/math/special_functions/zeta.hpp>
+#include <boost/math/tools/config.hpp>
+#include <boost/math/tools/precision.hpp>
+
+#if defined(_M_ARM64EC)
+#undef _M_ARM64
+#define _M_AMD64
+#define _M_X64
+#endif // defined(_M_ARM64EC)
+
+#pragma warning(pop)
+
+namespace {
+    template <class _Func>
+    [[nodiscard]] auto _Boost_call(const _Func& _Fn) noexcept {
+        _TRY_BEGIN
+        return _Fn();
+        _CATCH_ALL
+        errno     = EDOM;
+        using _Ty = _STD decay_t<decltype(_Fn())>;
+        return _STD numeric_limits<_Ty>::quiet_NaN();
+        _CATCH_END
+    }
+} // unnamed namespace
+
+extern "C" {
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_assoc_laguerre(
+    const unsigned int _Pn, const unsigned int _Pm, const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::laguerre(_Pn, _Pm, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_assoc_laguerref(
+    const unsigned int _Pn, const unsigned int _Pm, const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::laguerre(_Pn, _Pm, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_assoc_legendre(
+    const unsigned int _Pl, const unsigned int _Pm, const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] {
+        auto _Result = ::boost::math::legendre_p(_Pl, _Pm, _Px);
+        // Boost includes the Condon-Shortley phase term (-1)^m, std does not
+        if ((_Pm & 1u) != 0) {
+            _Result = -_Result;
+        }
+        return _Result;
+    });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_assoc_legendref(
+    const unsigned int _Pl, const unsigned int _Pm, const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] {
+        auto _Result = ::boost::math::legendre_p(_Pl, _Pm, _Px);
+        // Boost includes the Condon-Shortley phase term (-1)^m, std does not
+        if ((_Pm & 1u) != 0) {
+            _Result = -_Result;
+        }
+        return _Result;
+    });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_beta(const double _Px, const double _Py) noexcept {
+    return _Boost_call([=] { return ::boost::math::beta(_Px, _Py); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_betaf(const float _Px, const float _Py) noexcept {
+    return _Boost_call([=] { return ::boost::math::beta(_Px, _Py); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_comp_ellint_1(const double _Pk) noexcept {
+    return _Boost_call([=] { return ::boost::math::ellint_1(_Pk); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_comp_ellint_1f(const float _Pk) noexcept {
+    return _Boost_call([=] { return ::boost::math::ellint_1(_Pk); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_comp_ellint_2(const double _Pk) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_2(_Pk); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_comp_ellint_2f(const float _Pk) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_2(_Pk); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_comp_ellint_3(const double _Pk, const double _Pnu) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_3(_Pk, _Pnu); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_comp_ellint_3f(const float _Pk, const float _Pnu) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_3(_Pk, _Pnu); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_cyl_bessel_i(const double _Pnu, const double _Px) noexcept {
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::cyl_bessel_i(_Pnu, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_cyl_bessel_if(const float _Pnu, const float _Px) noexcept {
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::cyl_bessel_i(_Pnu, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_cyl_bessel_j(const double _Pnu, const double _Px) noexcept {
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::cyl_bessel_j(_Pnu, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_cyl_bessel_jf(const float _Pnu, const float _Px) noexcept {
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::cyl_bessel_j(_Pnu, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_cyl_bessel_k(const double _Pnu, const double _Px) noexcept {
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::cyl_bessel_k(_Pnu, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_cyl_bessel_kf(const float _Pnu, const float _Px) noexcept {
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::cyl_bessel_k(_Pnu, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_cyl_neumann(const double _Pnu, const double _Px) noexcept {
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::cyl_neumann(_Pnu, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_cyl_neumannf(const float _Pnu, const float _Px) noexcept {
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::cyl_neumann(_Pnu, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_ellint_1(const double _Pk, const double _Pphi) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    if (_STD isnan(_Pphi)) {
+        return _Pphi;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_1(_Pk, _Pphi); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_ellint_1f(const float _Pk, const float _Pphi) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    if (_STD isnan(_Pphi)) {
+        return _Pphi;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_1(_Pk, _Pphi); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_ellint_2(const double _Pk, const double _Pphi) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    if (_STD isnan(_Pphi)) {
+        return _Pphi;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_2(_Pk, _Pphi); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_ellint_2f(const float _Pk, const float _Pphi) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    if (_STD isnan(_Pphi)) {
+        return _Pphi;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_2(_Pk, _Pphi); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_ellint_3(
+    const double _Pk, const double _Pnu, const double _Pphi) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Pphi)) {
+        return _Pphi;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_3(_Pk, _Pnu, _Pphi); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_ellint_3f(
+    const float _Pk, const float _Pnu, const float _Pphi) noexcept {
+    if (_STD isnan(_Pk)) {
+        return _Pk;
+    }
+
+    if (_STD isnan(_Pnu)) {
+        return _Pnu;
+    }
+
+    if (_STD isnan(_Pphi)) {
+        return _Pphi;
+    }
+
+    return _Boost_call([=] { return ::boost::math::ellint_3(_Pk, _Pnu, _Pphi); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_expint(const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::expint(_Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_expintf(const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::expint(_Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_hermite(const unsigned int _Pn, const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::hermite(_Pn, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_hermitef(const unsigned int _Pn, const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::hermite(_Pn, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_laguerre(const unsigned int _Pn, const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::laguerre(_Pn, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_laguerref(const unsigned int _Pn, const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::laguerre(_Pn, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_legendre(const unsigned int _Pl, const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::legendre_p(_Pl, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_legendref(const unsigned int _Pl, const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::legendre_p(_Pl, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_riemann_zeta(const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::zeta(_Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_riemann_zetaf(const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::zeta(_Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_sph_bessel(
+    const unsigned int _Pn, const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::sph_bessel(_Pn, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_sph_besself(const unsigned int _Pn, const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::sph_bessel(_Pn, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_sph_legendre(
+    const unsigned int _Pl, const unsigned int _Pm, const double _Ptheta) noexcept {
+    if (_STD isnan(_Ptheta)) {
+        return _Ptheta;
+    }
+
+    return _Boost_call([=] { return ::boost::math::spherical_harmonic_r(_Pl, _Pm, _Ptheta, 0.0); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_sph_legendref(
+    const unsigned int _Pl, const unsigned int _Pm, const float _Ptheta) noexcept {
+    if (_STD isnan(_Ptheta)) {
+        return _Ptheta;
+    }
+
+    return _Boost_call([=] { return ::boost::math::spherical_harmonic_r(_Pl, _Pm, _Ptheta, 0.0f); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_sph_neumann(
+    const unsigned int _Pn, const double _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::sph_neumann(_Pn, _Px); });
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_sph_neumannf(
+    const unsigned int _Pn, const float _Px) noexcept {
+    if (_STD isnan(_Px)) {
+        return _Px;
+    }
+
+    return _Boost_call([=] { return ::boost::math::sph_neumann(_Pn, _Px); });
+}
+} // extern "C"
+
+namespace {
+    template <class _Ty>
+    [[nodiscard]] _Ty _Hypot3(_Ty _Dx, _Ty _Dy, _Ty _Dz) noexcept { // type-oblivious backend for 3-arg hypot
+        static_assert(_STD is_floating_point_v<_Ty>);
+        _Dx = _STD abs(_Dx);
+        _Dy = _STD abs(_Dy);
+        _Dz = _STD abs(_Dz);
+
+        constexpr _Ty _Infinity = _STD numeric_limits<_Ty>::infinity();
+        if (_Dx == _Infinity || _Dy == _Infinity || _Dz == _Infinity) {
+            return _Infinity;
+        }
+
+        if (_Dy > _Dx) {
+            _STD swap(_Dx, _Dy);
+        }
+
+        if (_Dz > _Dx) {
+            _STD swap(_Dx, _Dz);
+        }
+
+        constexpr _Ty _Eps = ::boost::math::tools::epsilon<_Ty>();
+        if (_Dx * _Eps >= _Dy && _Dx * _Eps >= _Dz) {
+            return _Dx;
+        }
+
+        const auto _DyDx = _Dy / _Dx;
+        const auto _DzDx = _Dz / _Dx;
+
+        return _Dx * _STD sqrt(1 + _DyDx * _DyDx + _DzDx * _DzDx);
+    }
+} // unnamed namespace
+
+extern "C" {
+[[nodiscard]] _CRT_SATELLITE_2 double __stdcall __std_smf_hypot3(
+    const double _Dx, const double _Dy, const double _Dz) noexcept {
+    return _Hypot3(_Dx, _Dy, _Dz);
+}
+
+[[nodiscard]] _CRT_SATELLITE_2 float __stdcall __std_smf_hypot3f(
+    const float _Dx, const float _Dy, const float _Dz) noexcept {
+    return _Hypot3(_Dx, _Dy, _Dz);
+}
+} // extern "C"
diff --git a/msvc-stl/stl/src/stacktrace.cpp b/msvc-stl/stl/src/stacktrace.cpp
new file mode 100644
index 0000000..8aec759
--- /dev/null
+++ b/msvc-stl/stl/src/stacktrace.cpp
@@ -0,0 +1,333 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstdio>
+#include <cstdlib>
+
+#include <initguid.h>
+#include <DbgEng.h>
+#include <DbgHelp.h>
+#include <Shlwapi.h>
+
+// The below function pointer types must be in sync with <stacktrace>
+
+extern "C" {
+using _Stacktrace_string_fill_callback = size_t(__stdcall*)(char* _Data, size_t _Size, void* _Context) _NOEXCEPT_FNPTR;
+
+using _Stacktrace_string_fill = size_t(__stdcall*)(
+    size_t _Size, void* _String, void* _Context, _Stacktrace_string_fill_callback _Callback);
+} // extern "C"
+
+namespace {
+    template <class F>
+    size_t string_fill(const _Stacktrace_string_fill callback, const size_t size, void* const str, F f) {
+        return callback(size, str, &f,
+            [](char* s, size_t sz, void* context) noexcept -> size_t { return (*static_cast<F*>(context))(s, sz); });
+    }
+
+    // TRANSITION, GH-2285. Use SRWLOCK instead of std::mutex to avoid nontrivial constructor and nontrivial destructor
+    void lock_and_uninitialize() noexcept;
+
+    class [[nodiscard]] dbg_eng_data {
+    public:
+        dbg_eng_data() noexcept {
+            AcquireSRWLockExclusive(&srw);
+        }
+
+        ~dbg_eng_data() {
+            ReleaseSRWLockExclusive(&srw);
+        }
+
+        dbg_eng_data(const dbg_eng_data&)            = delete;
+        dbg_eng_data& operator=(const dbg_eng_data&) = delete;
+
+        void uninitialize() noexcept {
+            // "Phoenix singleton" - destroy and set to null, so that it can be initialized later again
+
+            if (debug_client != nullptr) {
+                if (attached) {
+                    (void) debug_client->DetachProcesses();
+                    attached = false;
+                }
+
+                debug_client->Release();
+                debug_client = nullptr;
+            }
+
+            if (debug_control != nullptr) {
+                debug_control->Release();
+                debug_control = nullptr;
+            }
+
+            if (debug_symbols != nullptr) {
+                debug_symbols->Release();
+                debug_symbols = nullptr;
+            }
+
+            if (dbgeng != nullptr) {
+                (void) FreeLibrary(dbgeng);
+                dbgeng = nullptr;
+            }
+
+            initialize_attempted = false;
+        }
+
+        [[nodiscard]] bool try_initialize() noexcept {
+            if (!initialize_attempted) {
+                initialize_attempted = true;
+
+                if (std::atexit(lock_and_uninitialize) != 0) {
+                    return false;
+                }
+
+                dbgeng = LoadLibraryExW(L"dbgeng.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
+
+                if (dbgeng != nullptr) {
+                    const auto debug_create =
+                        reinterpret_cast<decltype(&DebugCreate)>(GetProcAddress(dbgeng, "DebugCreate"));
+
+                    // Deliberately not calling CoInitialize[Ex]. DbgEng.h API works fine without it.
+                    // COM initialization may have undesired interference with user's code.
+                    if (debug_create != nullptr
+                        && SUCCEEDED(debug_create(IID_IDebugClient, reinterpret_cast<void**>(&debug_client)))
+                        && SUCCEEDED(
+                            debug_client->QueryInterface(IID_IDebugSymbols, reinterpret_cast<void**>(&debug_symbols)))
+                        && SUCCEEDED(debug_client->QueryInterface(
+                            IID_IDebugControl, reinterpret_cast<void**>(&debug_control)))) {
+                        attached = SUCCEEDED(debug_client->AttachProcess(
+                            0, GetCurrentProcessId(), DEBUG_ATTACH_NONINVASIVE | DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND));
+                        if (attached) {
+                            (void) debug_control->WaitForEvent(0, INFINITE);
+                        }
+
+                        constexpr ULONG add_options = SYMOPT_CASE_INSENSITIVE | SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS
+                                                    | SYMOPT_LOAD_LINES | SYMOPT_OMAP_FIND_NEAREST
+                                                    | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_AUTO_PUBLICS
+                                                    | SYMOPT_NO_PROMPTS;
+
+                        constexpr ULONG remove_options = SYMOPT_NO_CPP | SYMOPT_LOAD_ANYTHING
+                                                       | SYMOPT_NO_UNQUALIFIED_LOADS | SYMOPT_EXACT_SYMBOLS
+                                                       | SYMOPT_IGNORE_NT_SYMPATH | SYMOPT_PUBLICS_ONLY
+                                                       | SYMOPT_NO_PUBLICS | SYMOPT_NO_IMAGE_SEARCH;
+
+                        (void) debug_symbols->AddSymbolOptions(add_options);
+                        (void) debug_symbols->RemoveSymbolOptions(remove_options);
+                    }
+                }
+            }
+
+            return attached;
+        }
+
+        size_t get_description(
+            const void* const address, void* const str, size_t off, const _Stacktrace_string_fill fill) {
+            // Initially pass the current capacity, will retry with bigger buffer if it fails.
+            size_t size          = fill(0, str, nullptr, nullptr) - off;
+            HRESULT hr           = E_UNEXPECTED;
+            ULONG64 displacement = 0;
+
+            for (;;) {
+                ULONG new_size = 0;
+
+                const size_t new_off = string_fill(
+                    fill, off + size, str, [address, off, size, &new_size, &hr, &displacement](char* s, size_t) {
+                        hr = debug_symbols->GetNameByOffset(reinterpret_cast<uintptr_t>(address), s + off,
+                            static_cast<ULONG>(size + 1), &new_size, &displacement);
+
+                        return (hr == S_OK) ? off + new_size - 1 : off;
+                    });
+
+                if (hr == S_OK) {
+                    off = new_off;
+                    break;
+                } else if (hr == S_FALSE) {
+                    size = new_size - 1; // retry with bigger buffer
+                } else {
+                    return off;
+                }
+            }
+
+            if (displacement != 0) {
+                constexpr size_t max_disp_num = sizeof("+0x1122334455667788") - 1; // maximum possible offset
+
+                off = string_fill(fill, off + max_disp_num, str, [displacement, off](char* s, size_t) {
+                    const int ret = std::snprintf(s + off, max_disp_num + 1, "+0x%llX", displacement);
+                    if (ret <= 0) {
+                        std::abort(); // formatting error
+                    }
+                    return off + ret;
+                });
+            }
+
+            return off;
+        }
+
+        size_t source_file(const void* const address, void* const str, size_t off, ULONG* const line,
+            const _Stacktrace_string_fill fill) {
+            // Initially pass the current capacity, will retry with bigger buffer if fails.
+            size_t size = fill(0, str, nullptr, nullptr) - off;
+            HRESULT hr  = E_UNEXPECTED;
+
+            for (;;) {
+                ULONG new_size = 0;
+
+                const size_t new_off =
+                    string_fill(fill, off + size, str, [address, off, size, line, &new_size, &hr](char* s, size_t) {
+                        hr = debug_symbols->GetLineByOffset(reinterpret_cast<uintptr_t>(address), line, s + off,
+                            static_cast<ULONG>(size + 1), &new_size, nullptr);
+
+                        return (hr == S_OK) ? off + new_size - 1 : off;
+                    });
+
+                if (hr == S_OK) {
+                    off = new_off;
+                    break;
+                } else if (hr == S_FALSE) {
+                    size = new_size - 1; // retry with bigger buffer
+                } else {
+                    if (line) {
+                        *line = 0;
+                    }
+
+                    return off;
+                }
+            }
+
+            return off;
+        }
+
+        [[nodiscard]] unsigned int source_line(const void* const address) noexcept {
+            ULONG line = 0;
+
+            if (FAILED(debug_symbols->GetLineByOffset(
+                    reinterpret_cast<uintptr_t>(address), &line, nullptr, 0, nullptr, nullptr))) {
+                return 0;
+            }
+
+            return line;
+        }
+
+        size_t address_to_string(
+            const void* const address, void* const str, size_t off, const _Stacktrace_string_fill fill) {
+            ULONG line = 0;
+
+            off = source_file(address, str, off, &line, fill);
+
+            if (line != 0) {
+                constexpr size_t max_line_num = sizeof("(4294967295): ") - 1; // maximum possible line number
+
+                off = string_fill(fill, off + max_line_num, str, [line, off](char* s, size_t) {
+                    const int ret = std::snprintf(s + off, max_line_num + 1, "(%u): ", line);
+                    if (ret <= 0) {
+                        std::abort(); // formatting error
+                    }
+                    return off + ret;
+                });
+            }
+
+            return get_description(address, str, off, fill);
+        }
+
+    private:
+        inline static SRWLOCK srw                  = SRWLOCK_INIT;
+        inline static IDebugClient* debug_client   = nullptr;
+        inline static IDebugSymbols* debug_symbols = nullptr;
+        inline static IDebugControl* debug_control = nullptr;
+        inline static bool attached                = false;
+        inline static bool initialize_attempted    = false;
+        inline static HMODULE dbgeng               = nullptr;
+    };
+
+    void lock_and_uninitialize() noexcept {
+        dbg_eng_data locked_data;
+
+        locked_data.uninitialize();
+    }
+} // unnamed namespace
+
+extern "C" {
+#pragma optimize("", off) // inhibit tail call optimization to have consistent _Frames_to_skip adjustment here
+[[nodiscard]] unsigned short __stdcall __std_stacktrace_capture(unsigned long _Frames_to_skip,
+    const unsigned long _Frames_to_capture, void** const _Back_trace, unsigned long* const _Back_trace_hash) noexcept {
+    return CaptureStackBackTrace(_Frames_to_skip + 1, _Frames_to_capture, _Back_trace, _Back_trace_hash);
+}
+#pragma optimize("", on) // end inhibit tail call optimization
+
+// Some of these functions may throw (They would propagate bad_alloc potentially thrown from
+// string::resize_and_overwrite)
+
+void __stdcall __std_stacktrace_description(
+    const void* const _Address, void* const _Str, const _Stacktrace_string_fill _Fill) noexcept(false) {
+    dbg_eng_data locked_data;
+
+    if (!locked_data.try_initialize()) {
+        return;
+    }
+
+    locked_data.get_description(_Address, _Str, 0, _Fill);
+}
+
+void __stdcall __std_stacktrace_source_file(
+    const void* const _Address, void* const _Str, const _Stacktrace_string_fill _Fill) noexcept(false) {
+    dbg_eng_data locked_data;
+
+    if (!locked_data.try_initialize()) {
+        return;
+    }
+
+    locked_data.source_file(_Address, _Str, 0, nullptr, _Fill);
+}
+
+[[nodiscard]] unsigned int __stdcall __std_stacktrace_source_line(const void* const _Address) noexcept {
+    dbg_eng_data locked_data;
+
+    if (!locked_data.try_initialize()) {
+        return 0;
+    }
+
+    return locked_data.source_line(_Address);
+}
+
+void __stdcall __std_stacktrace_address_to_string(
+    const void* const _Address, void* const _Str, const _Stacktrace_string_fill _Fill) noexcept(false) {
+    dbg_eng_data locked_data;
+
+    if (!locked_data.try_initialize()) {
+        return;
+    }
+
+    locked_data.address_to_string(_Address, _Str, 0, _Fill);
+}
+
+void __stdcall __std_stacktrace_to_string(const void* const* const _Addresses, const size_t _Size, void* const _Str,
+    const _Stacktrace_string_fill _Fill) noexcept(false) {
+    dbg_eng_data locked_data;
+
+    if (!locked_data.try_initialize()) {
+        return;
+    }
+
+    size_t off = 0;
+
+    for (size_t i = 0; i != _Size; ++i) {
+        if (off != 0) {
+            off = string_fill(_Fill, off + 1, _Str, [](char* s, size_t sz) {
+                s[sz - 1] = '\n';
+                return sz;
+            });
+        }
+
+        constexpr size_t max_entry_num = sizeof("65536> ") - 1; // maximum possible entry number
+
+        off = string_fill(_Fill, off + max_entry_num, _Str, [off, i](char* s, size_t) {
+            const int ret = std::snprintf(s + off, max_entry_num + 1, "%u> ", static_cast<unsigned int>(i));
+            if (ret <= 0) {
+                std::abort(); // formatting error
+            }
+            return off + ret;
+        });
+
+        off = locked_data.address_to_string(_Addresses[i], _Str, off, _Fill);
+    }
+}
+} // extern "C"
diff --git a/msvc-stl/stl/src/stdhndlr.cpp b/msvc-stl/stl/src/stdhndlr.cpp
new file mode 100644
index 0000000..a57e73b
--- /dev/null
+++ b/msvc-stl/stl/src/stdhndlr.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// set_new_handler
+
+#include <mutex>
+#include <new.h>
+#include <new>
+
+namespace {
+    _STD new_handler _New_handler;
+    constinit _STD mutex _New_handler_mutex;
+
+    int __cdecl _New_handler_interface(size_t) { // interface to existing Microsoft _callnewh mechanism
+        _New_handler();
+        return 1;
+    }
+} // unnamed namespace
+
+_STD_BEGIN
+
+_CRTIMP2 new_handler __cdecl set_new_handler(_In_opt_ new_handler pnew) noexcept { // remove current handler
+    lock_guard _Lock{_New_handler_mutex};
+    new_handler pold = _New_handler;
+    _New_handler     = pnew;
+    _set_new_handler(pnew ? _New_handler_interface : nullptr);
+    return pold;
+}
+
+_CRTIMP2 new_handler __cdecl get_new_handler() noexcept { // get current new handler
+    lock_guard _Lock{_New_handler_mutex};
+    return _New_handler;
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/stdthrow.cpp b/msvc-stl/stl/src/stdthrow.cpp
new file mode 100644
index 0000000..efa5312
--- /dev/null
+++ b/msvc-stl/stl/src/stdthrow.cpp
@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <yvals.h>
+
+_STD_BEGIN
+// TRANSITION, ABI: _Debug_message() overloads are preserved for binary compatibility
+
+#ifdef _DEBUG
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Debug_message(
+    const wchar_t* message, const wchar_t* file, unsigned int line) { // report error and die
+    if (::_CrtDbgReportW(_CRT_ASSERT, file, line, nullptr, L"%ls", message) == 1) {
+        ::_CrtDbgBreak();
+    }
+}
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Debug_message(
+    const unsigned short* message, const unsigned short* file, unsigned int line) { // report error and die
+    _Debug_message(reinterpret_cast<const wchar_t*>(message), reinterpret_cast<const wchar_t*>(file), line);
+}
+#endif // ^^^ defined(_DEBUG) ^^^
+_STD_END
diff --git a/msvc-stl/stl/src/syncstream.cpp b/msvc-stl/stl/src/syncstream.cpp
new file mode 100644
index 0000000..a0b9c23
--- /dev/null
+++ b/msvc-stl/stl/src/syncstream.cpp
@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize syncstream mutex map
+
+#include <__msvc_tzdb.hpp>
+#include <functional>
+#include <map>
+#include <mutex>
+#include <new>
+#include <shared_mutex>
+#include <utility>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+
+namespace {
+    struct _Mutex_count_pair {
+        _STD shared_mutex _Mutex;
+        size_t _Ref_count = 0;
+    };
+
+    using _Map_alloc = _STD _Crt_allocator<_STD pair<void* const, _Mutex_count_pair>>;
+    using _Map_type  = _STD map<void*, _Mutex_count_pair, _STD less<void*>, _Map_alloc>;
+
+    _Map_type _Lookup_map;
+    _STD shared_mutex _Lookup_mutex;
+} // unnamed namespace
+
+extern "C" {
+
+// TRANSITION, ABI: This returns a pointer to a C++ type.
+// A flat C interface would return an opaque handle and would provide separate functions for locking and unlocking.
+[[nodiscard]] _STD shared_mutex* __stdcall __std_acquire_shared_mutex_for_instance(void* _Ptr) noexcept {
+    try {
+        _STD scoped_lock _Guard(_Lookup_mutex);
+        auto& [_Mutex, _Refs] = _Lookup_map.try_emplace(_Ptr).first->second;
+        ++_Refs;
+        return &_Mutex;
+    } catch (...) {
+        return nullptr;
+    }
+}
+
+void __stdcall __std_release_shared_mutex_for_instance(void* _Ptr) noexcept {
+    _STD scoped_lock _Guard(_Lookup_mutex);
+    const auto _Instance_mutex_iter = _Lookup_map.find(_Ptr);
+    _ASSERT_EXPR(_Instance_mutex_iter != _Lookup_map.end(), "No mutex exists for given instance!");
+    auto& _Refs = _Instance_mutex_iter->second._Ref_count;
+    if (--_Refs == 0) {
+        _Lookup_map.erase(_Instance_mutex_iter);
+    }
+}
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/syserror.cpp b/msvc-stl/stl/src/syserror.cpp
new file mode 100644
index 0000000..c2a14dc
--- /dev/null
+++ b/msvc-stl/stl/src/syserror.cpp
@@ -0,0 +1,245 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// system_error message mapping
+
+#define _SILENCE_CXX23_UNIX_STREAMS_DEPRECATION_WARNING
+
+#include <algorithm>
+#include <functional>
+#include <system_error>
+
+#include <Windows.h>
+
+// TRANSITION, MSBuild
+// MSBuild has a hard requirement against including the same file in both a DLL and its import lib, so we include
+// the import lib .cpp here to make those functions available for internal use by other parts of our DLL.
+#ifdef _DLL
+#include "syserror_import_lib.cpp"
+#endif
+
+namespace {
+    using _STD errc;
+
+    struct _Win_errtab_t { // maps Windows error to Posix error
+        int _Windows;
+        errc _Posix;
+    };
+
+    constexpr _Win_errtab_t _Win_errtab[] = {
+        // table of Windows/Posix pairs
+        {ERROR_INVALID_FUNCTION, errc::function_not_supported},
+        {ERROR_FILE_NOT_FOUND, errc::no_such_file_or_directory},
+        {ERROR_PATH_NOT_FOUND, errc::no_such_file_or_directory},
+        {ERROR_TOO_MANY_OPEN_FILES, errc::too_many_files_open},
+        {ERROR_ACCESS_DENIED, errc::permission_denied},
+        {ERROR_INVALID_HANDLE, errc::invalid_argument},
+        {ERROR_NOT_ENOUGH_MEMORY, errc::not_enough_memory},
+        {ERROR_INVALID_ACCESS, errc::permission_denied},
+        {ERROR_OUTOFMEMORY, errc::not_enough_memory},
+        {ERROR_INVALID_DRIVE, errc::no_such_device},
+        {ERROR_CURRENT_DIRECTORY, errc::permission_denied},
+        {ERROR_NOT_SAME_DEVICE, errc::cross_device_link},
+        {ERROR_WRITE_PROTECT, errc::permission_denied},
+        {ERROR_BAD_UNIT, errc::no_such_device},
+        {ERROR_NOT_READY, errc::resource_unavailable_try_again},
+        {ERROR_SEEK, errc::io_error},
+        {ERROR_WRITE_FAULT, errc::io_error},
+        {ERROR_READ_FAULT, errc::io_error},
+        {ERROR_SHARING_VIOLATION, errc::permission_denied},
+        {ERROR_LOCK_VIOLATION, errc::no_lock_available},
+        {ERROR_HANDLE_DISK_FULL, errc::no_space_on_device},
+        {ERROR_NOT_SUPPORTED, errc::not_supported},
+        {ERROR_BAD_NETPATH, errc::no_such_file_or_directory},
+        {ERROR_DEV_NOT_EXIST, errc::no_such_device},
+        {ERROR_BAD_NET_NAME, errc::no_such_file_or_directory},
+        {ERROR_FILE_EXISTS, errc::file_exists},
+        {ERROR_CANNOT_MAKE, errc::permission_denied},
+        {ERROR_INVALID_PARAMETER, errc::invalid_argument},
+        {ERROR_BROKEN_PIPE, errc::broken_pipe},
+        {ERROR_OPEN_FAILED, errc::io_error},
+        {ERROR_BUFFER_OVERFLOW, errc::filename_too_long},
+        {ERROR_DISK_FULL, errc::no_space_on_device},
+        {ERROR_SEM_TIMEOUT, errc::timed_out},
+        {ERROR_INVALID_NAME, errc::no_such_file_or_directory},
+        {ERROR_NEGATIVE_SEEK, errc::invalid_argument},
+        {ERROR_BUSY_DRIVE, errc::device_or_resource_busy},
+        {ERROR_DIR_NOT_EMPTY, errc::directory_not_empty},
+        {ERROR_BUSY, errc::device_or_resource_busy},
+        {ERROR_ALREADY_EXISTS, errc::file_exists},
+        {ERROR_FILENAME_EXCED_RANGE, errc::filename_too_long},
+        {ERROR_LOCKED, errc::no_lock_available},
+        {WAIT_TIMEOUT, errc::timed_out},
+        {ERROR_DIRECTORY, errc::invalid_argument},
+        {ERROR_OPERATION_ABORTED, errc::operation_canceled},
+        {ERROR_NOACCESS, errc::permission_denied},
+        {ERROR_CANTOPEN, errc::io_error},
+        {ERROR_CANTREAD, errc::io_error},
+        {ERROR_CANTWRITE, errc::io_error},
+        {ERROR_RETRY, errc::resource_unavailable_try_again},
+        {ERROR_TIMEOUT, errc::timed_out},
+        {ERROR_OPEN_FILES, errc::device_or_resource_busy},
+        {ERROR_DEVICE_IN_USE, errc::device_or_resource_busy},
+        {ERROR_REPARSE_TAG_INVALID, errc::invalid_argument},
+        {WSAEINTR, errc::interrupted},
+        {WSAEBADF, errc::bad_file_descriptor},
+        {WSAEACCES, errc::permission_denied},
+        {WSAEFAULT, errc::bad_address},
+        {WSAEINVAL, errc::invalid_argument},
+        {WSAEMFILE, errc::too_many_files_open},
+        {WSAEWOULDBLOCK, errc::operation_would_block},
+        {WSAEINPROGRESS, errc::operation_in_progress},
+        {WSAEALREADY, errc::connection_already_in_progress},
+        {WSAENOTSOCK, errc::not_a_socket},
+        {WSAEDESTADDRREQ, errc::destination_address_required},
+        {WSAEMSGSIZE, errc::message_size},
+        {WSAEPROTOTYPE, errc::wrong_protocol_type},
+        {WSAENOPROTOOPT, errc::no_protocol_option},
+        {WSAEPROTONOSUPPORT, errc::protocol_not_supported},
+        {WSAEOPNOTSUPP, errc::operation_not_supported},
+        {WSAEAFNOSUPPORT, errc::address_family_not_supported},
+        {WSAEADDRINUSE, errc::address_in_use},
+        {WSAEADDRNOTAVAIL, errc::address_not_available},
+        {WSAENETDOWN, errc::network_down},
+        {WSAENETUNREACH, errc::network_unreachable},
+        {WSAENETRESET, errc::network_reset},
+        {WSAECONNABORTED, errc::connection_aborted},
+        {WSAECONNRESET, errc::connection_reset},
+        {WSAENOBUFS, errc::no_buffer_space},
+        {WSAEISCONN, errc::already_connected},
+        {WSAENOTCONN, errc::not_connected},
+        {WSAETIMEDOUT, errc::timed_out},
+        {WSAECONNREFUSED, errc::connection_refused},
+        {WSAENAMETOOLONG, errc::filename_too_long},
+        {WSAEHOSTUNREACH, errc::host_unreachable},
+    };
+
+#ifndef _M_CEE_PURE
+    static_assert(
+        _RANGES adjacent_find(_Win_errtab, _RANGES greater_equal{}, &_Win_errtab_t::_Windows) == _STD end(_Win_errtab),
+        "The Windows error codes in _Win_errtab should be numerically sorted and unique.");
+#endif // !defined(_M_CEE_PURE)
+
+    struct _Sys_errtab_t { // maps error_code to NTBS
+        errc _Errcode;
+        const char* _Name;
+    };
+
+    constexpr _Sys_errtab_t _Sys_errtab[] = {
+        // table of Posix code/name pairs
+        {static_cast<errc>(0), "success"},
+        {errc::address_family_not_supported, "address family not supported"},
+        {errc::address_in_use, "address in use"},
+        {errc::address_not_available, "address not available"},
+        {errc::already_connected, "already connected"},
+        {errc::argument_list_too_long, "argument list too long"},
+        {errc::argument_out_of_domain, "argument out of domain"},
+        {errc::bad_address, "bad address"},
+        {errc::bad_file_descriptor, "bad file descriptor"},
+        {errc::bad_message, "bad message"},
+        {errc::broken_pipe, "broken pipe"},
+        {errc::connection_aborted, "connection aborted"},
+        {errc::connection_already_in_progress, "connection already in progress"},
+        {errc::connection_refused, "connection refused"},
+        {errc::connection_reset, "connection reset"},
+        {errc::cross_device_link, "cross device link"},
+        {errc::destination_address_required, "destination address required"},
+        {errc::device_or_resource_busy, "device or resource busy"},
+        {errc::directory_not_empty, "directory not empty"},
+        {errc::executable_format_error, "executable format error"},
+        {errc::file_exists, "file exists"},
+        {errc::file_too_large, "file too large"},
+        {errc::filename_too_long, "filename too long"},
+        {errc::function_not_supported, "function not supported"},
+        {errc::host_unreachable, "host unreachable"},
+        {errc::identifier_removed, "identifier removed"},
+        {errc::illegal_byte_sequence, "illegal byte sequence"},
+        {errc::inappropriate_io_control_operation, "inappropriate io control operation"},
+        {errc::interrupted, "interrupted"},
+        {errc::invalid_argument, "invalid argument"},
+        {errc::invalid_seek, "invalid seek"},
+        {errc::io_error, "io error"},
+        {errc::is_a_directory, "is a directory"},
+        {errc::message_size, "message size"},
+        {errc::network_down, "network down"},
+        {errc::network_reset, "network reset"},
+        {errc::network_unreachable, "network unreachable"},
+        {errc::no_buffer_space, "no buffer space"},
+        {errc::no_child_process, "no child process"},
+        {errc::no_link, "no link"},
+        {errc::no_lock_available, "no lock available"},
+        {errc::no_message_available, "no message available"},
+        {errc::no_message, "no message"},
+        {errc::no_protocol_option, "no protocol option"},
+        {errc::no_space_on_device, "no space on device"},
+        {errc::no_stream_resources, "no stream resources"},
+        {errc::no_such_device_or_address, "no such device or address"},
+        {errc::no_such_device, "no such device"},
+        {errc::no_such_file_or_directory, "no such file or directory"},
+        {errc::no_such_process, "no such process"},
+        {errc::not_a_directory, "not a directory"},
+        {errc::not_a_socket, "not a socket"},
+        {errc::not_a_stream, "not a stream"},
+        {errc::not_connected, "not connected"},
+        {errc::not_enough_memory, "not enough memory"},
+        {errc::not_supported, "not supported"},
+        {errc::operation_canceled, "operation canceled"},
+        {errc::operation_in_progress, "operation in progress"},
+        {errc::operation_not_permitted, "operation not permitted"},
+        {errc::operation_not_supported, "operation not supported"},
+        {errc::operation_would_block, "operation would block"},
+        {errc::owner_dead, "owner dead"},
+        {errc::permission_denied, "permission denied"},
+        {errc::protocol_error, "protocol error"},
+        {errc::protocol_not_supported, "protocol not supported"},
+        {errc::read_only_file_system, "read only file system"},
+        {errc::resource_deadlock_would_occur, "resource deadlock would occur"},
+        {errc::resource_unavailable_try_again, "resource unavailable try again"},
+        {errc::result_out_of_range, "result out of range"},
+        {errc::state_not_recoverable, "state not recoverable"},
+        {errc::stream_timeout, "stream timeout"},
+        {errc::text_file_busy, "text file busy"},
+        {errc::timed_out, "timed out"},
+        {errc::too_many_files_open_in_system, "too many files open in system"},
+        {errc::too_many_files_open, "too many files open"},
+        {errc::too_many_links, "too many links"},
+        {errc::too_many_symbolic_link_levels, "too many symbolic link levels"},
+        {errc::value_too_large, "value too large"},
+        {errc::wrong_protocol_type, "wrong protocol type"},
+    };
+} // unnamed namespace
+
+_STD_BEGIN
+
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Winerror_map(int _Errcode) {
+    // convert Windows error to Posix error if possible, otherwise 0
+    for (const auto& _Entry : _Win_errtab) {
+        if (_Entry._Windows == _Errcode) {
+            return static_cast<int>(_Entry._Posix);
+        }
+    }
+
+    return 0;
+}
+
+// TRANSITION, ABI: _Winerror_message() is preserved for binary compatibility
+_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Winerror_message(
+    unsigned long _Message_id, char* _Narrow, unsigned long _Size) {
+    // convert to name of Windows error, return 0 for failure, otherwise return number of chars written
+    // pre: _Size < INT_MAX
+    const unsigned long _Chars = FormatMessageA(
+        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, _Message_id, 0, _Narrow, _Size, nullptr);
+
+    return static_cast<unsigned long>(_CSTD __std_get_string_size_without_trailing_whitespace(_Narrow, _Chars));
+}
+
+_CRTIMP2_PURE const char* __CLRCALL_PURE_OR_CDECL _Syserror_map(int _Errcode) { // convert to name of generic error
+    for (const auto& _Entry : _Sys_errtab) {
+        if (static_cast<int>(_Entry._Errcode) == _Errcode) {
+            return _Entry._Name;
+        }
+    }
+
+    return "unknown error";
+}
+_STD_END
diff --git a/msvc-stl/stl/src/syserror_import_lib.cpp b/msvc-stl/stl/src/syserror_import_lib.cpp
new file mode 100644
index 0000000..b111662
--- /dev/null
+++ b/msvc-stl/stl/src/syserror_import_lib.cpp
@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <__msvc_system_error_abi.hpp>
+
+#include <Windows.h>
+
+namespace {
+    struct _Whitespace_bitmap_t {
+        bool _Is_whitespace[256];
+
+        constexpr _Whitespace_bitmap_t() noexcept : _Is_whitespace{} {
+            _Is_whitespace[' ']  = true;
+            _Is_whitespace['\n'] = true;
+            _Is_whitespace['\r'] = true;
+            _Is_whitespace['\t'] = true;
+            _Is_whitespace['\0'] = true;
+        }
+
+        [[nodiscard]] constexpr bool _Test(const char _Ch) const noexcept {
+            return _Is_whitespace[static_cast<unsigned char>(_Ch)];
+        }
+    };
+
+    constexpr _Whitespace_bitmap_t _Whitespace_bitmap;
+} // unnamed namespace
+
+extern "C" {
+[[nodiscard]] size_t __CLRCALL_PURE_OR_STDCALL __std_get_string_size_without_trailing_whitespace(
+    const char* const _Str, size_t _Size) noexcept {
+    while (_Size != 0 && _Whitespace_bitmap._Test(_Str[_Size - 1])) {
+        --_Size;
+    }
+
+    return _Size;
+}
+
+[[nodiscard]] size_t __CLRCALL_PURE_OR_STDCALL __std_system_error_allocate_message(
+    const unsigned long _Message_id, char** const _Ptr_str) noexcept {
+    // convert to name of Windows error, return 0 for failure, otherwise return number of chars in buffer
+    // __std_system_error_deallocate_message should be called even if 0 is returned
+    // pre: *_Ptr_str == nullptr
+
+    // We start by requesting US English for system_category() messages. (See GH-2451 and GH-3254 for the history.)
+    // This is consistent with generic_category(), which uses a table of US English strings in the STL.
+    // In general, system_error messages aren't directly useful to end-users - they're meant for programmer-users.
+    // Of course, the programmer-user might not speak US English, but machine translation of the message
+    // (and the numeric value of the error code) should help them understand the error.
+
+    constexpr auto _Flags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
+
+    DWORD _Lang_id = 0;
+    DWORD _Chars   = 0;
+
+    for (int _Attempt = 0; _Attempt < 3 && _Chars == 0; ++_Attempt) {
+        if (_Attempt == 0) {
+            _Lang_id = 0x0409; // 1033 decimal, "en-US" locale
+        } else if (_Attempt == 1) {
+            const int _Ret = GetLocaleInfoEx(LOCALE_NAME_SYSTEM_DEFAULT, LOCALE_ILANGUAGE | LOCALE_RETURN_NUMBER,
+                reinterpret_cast<LPWSTR>(&_Lang_id), sizeof(_Lang_id) / sizeof(wchar_t));
+            if (_Ret == 0) {
+                continue; // If we can't get the system locale's language ID, skip this attempt
+            }
+        } else {
+            _Lang_id = 0;
+        }
+
+        _Chars = FormatMessageA(_Flags, nullptr, _Message_id, _Lang_id, reinterpret_cast<char*>(_Ptr_str), 0, nullptr);
+    }
+
+    return _CSTD __std_get_string_size_without_trailing_whitespace(*_Ptr_str, _Chars);
+}
+
+void __CLRCALL_PURE_OR_STDCALL __std_system_error_deallocate_message(char* const _Str) noexcept {
+    LocalFree(_Str);
+}
+} // extern "C"
diff --git a/msvc-stl/stl/src/taskscheduler.cpp b/msvc-stl/stl/src/taskscheduler.cpp
new file mode 100644
index 0000000..41815d8
--- /dev/null
+++ b/msvc-stl/stl/src/taskscheduler.cpp
@@ -0,0 +1,164 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <condition_variable>
+#include <cstddef> // for size_t
+#include <mutex>
+#include <ppltaskscheduler.h>
+
+#include <Windows.h>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+
+static std::_Init_locks initlocks;
+
+extern "C" IMAGE_DOS_HEADER __ImageBase;
+
+namespace Concurrency {
+    namespace details {
+        namespace {
+            // When the CRT and STL are statically linked into an EXE, their uninitialization will take place
+            // inside of the call to exit(), before ExitProcess() is called.  This means that their
+            // uninitialization occurs before other threads in the process are terminated.  We block the exit
+            // from proceeding until all outstanding tasks have completed, to ensure that they do not run after
+            // we destroy the STL's internal locks.
+
+            // When the CRT and STL are hosted in DLLs (either in their own DLLs or statically linked into a
+            // user DLL), they are uninitialized when the DLL is notified for DLL_PROCESS_DETACH before it is
+            // unloaded.  Termination unload occurs after all other threads in the process have been terminated,
+            // so there is no risk of other threads touching internal STL state.  We prevent non-termination
+            // unload from occurring while there are outstanding tasks, by having each task own a reference to
+            // the DLL in which the callback is located.
+
+            HMODULE _Call_get_module_handle_ex(DWORD _Flags, LPCWSTR _Addr) {
+                HMODULE _Result;
+                if (!GetModuleHandleExW(_Flags, _Addr, &_Result)) {
+                    return nullptr;
+                }
+
+                return _Result;
+            }
+
+            enum class _STL_host_status { _Exe, _Dll, _Unknown };
+
+            _STL_host_status _Get_STL_host_status() {
+#ifdef CRTDLL2
+                return _STL_host_status::_Dll;
+#else // ^^^ defined(CRTDLL2) / !defined(CRTDLL2) vvv
+                HANDLE _HExe = _Call_get_module_handle_ex(GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, nullptr);
+                if (_HExe == nullptr) {
+                    return _STL_host_status::_Unknown;
+                } else if (_HExe == reinterpret_cast<HMODULE>(&__ImageBase)) {
+                    return _STL_host_status::_Exe;
+                } else {
+                    return _STL_host_status::_Dll;
+                }
+#endif // ^^^ !defined(CRTDLL2) ^^^
+            }
+
+#ifdef CRTDLL2
+            // If the STL is a DLL, no reference counting is necessary, because the CRT shutdown is
+            // always through DLL_PROCESS_DETACH, so keeping the owning reference to the callback
+            // code is sufficient.
+            void _Increment_outstanding() {}
+            void _Decrement_outstanding() {}
+#else // ^^^ defined(CRTDLL2) / !defined(CRTDLL2) vvv
+            size_t _Outstanding_tasks = 0;
+            _STD mutex _Task_cv_mutex;
+            _STD condition_variable _Task_cv;
+
+            void _Increment_outstanding() { // block shutdown
+                if (_Get_STL_host_status() == _STL_host_status::_Dll) {
+                    return;
+                }
+
+                _STD lock_guard<_STD mutex> _Lg(_Task_cv_mutex);
+                ++_Outstanding_tasks;
+            }
+
+            void _Decrement_outstanding() { // release shutdown
+                if (_Get_STL_host_status() == _STL_host_status::_Dll) {
+                    return;
+                }
+
+                size_t _Dec_outstanding;
+                {
+                    _STD lock_guard<_STD mutex> _Lg(_Task_cv_mutex);
+                    _Dec_outstanding = --_Outstanding_tasks;
+                }
+
+                if (_Dec_outstanding == 0) {
+                    _Task_cv.notify_all();
+                }
+            }
+
+            struct _Task_scheduler_main_block {
+                _Task_scheduler_main_block()                                             = default;
+                _Task_scheduler_main_block(const _Task_scheduler_main_block&)            = delete;
+                _Task_scheduler_main_block& operator=(const _Task_scheduler_main_block&) = delete;
+                ~_Task_scheduler_main_block() noexcept { // block shutdown of the CRT until std::async shutdown has
+                                                         // completed
+                    _STD unique_lock<_STD mutex> _Lck(_Task_cv_mutex);
+                    _Task_cv.wait(_Lck, [] { return _Outstanding_tasks == 0; });
+                }
+            };
+            _Task_scheduler_main_block _Task_scheduler_main_block_instance;
+#endif // ^^^ !defined(CRTDLL2) ^^^
+
+            void CALLBACK _Task_scheduler_callback(PTP_CALLBACK_INSTANCE _Pci, PVOID _Args, PTP_WORK) noexcept {
+                _Increment_outstanding();
+                const auto _Chore = static_cast<_Threadpool_chore*>(_Args);
+                if (_Get_STL_host_status() != _STL_host_status::_Exe) { // ensure user code held alive by
+                                                                        // _Reschedule_chore is freed when we're done
+                    const HMODULE _Callback_dll = _Call_get_module_handle_ex(
+                        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+                        reinterpret_cast<LPCWSTR>(_Chore->_M_callback));
+
+                    if (_Callback_dll != nullptr) {
+                        FreeLibraryWhenCallbackReturns(_Pci, _Callback_dll);
+                    }
+                }
+
+                _Chore->_M_callback(_Chore->_M_data);
+                _Decrement_outstanding();
+            }
+        } // unnamed namespace
+
+        _CRTIMP2 void __cdecl _Release_chore(_Threadpool_chore* _Chore) {
+            if (_Chore->_M_work != nullptr) {
+                CloseThreadpoolWork(static_cast<PTP_WORK>(_Chore->_M_work));
+                _Chore->_M_work = nullptr;
+            }
+        }
+
+        _CRTIMP2 int __cdecl _Reschedule_chore(const _Threadpool_chore* _Chore) {
+            _ASSERT(_Chore->_M_work);
+
+            // Adds a reference to the DLL with the code to execute on async; the callback will
+            // FreeLibraryWhenCallbackReturns this DLL once it starts running.
+            if (_Get_STL_host_status() != _STL_host_status::_Exe) {
+                (void) _Call_get_module_handle_ex(
+                    GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, reinterpret_cast<LPCWSTR>(_Chore->_M_callback));
+            }
+
+            SubmitThreadpoolWork(static_cast<PTP_WORK>(_Chore->_M_work));
+            return 0;
+        }
+
+        _CRTIMP2 int __cdecl _Schedule_chore(_Threadpool_chore* _Chore) {
+            _ASSERT(_Chore->_M_work == nullptr);
+            _ASSERT(_Chore->_M_callback != nullptr);
+
+            _Chore->_M_work = CreateThreadpoolWork(_Task_scheduler_callback, _Chore, nullptr);
+
+            if (_Chore->_M_work) {
+                return _Reschedule_chore(_Chore);
+            } else {
+                return static_cast<int>(GetLastError()); // LastError won't be 0 when it's in error state
+            }
+        }
+    } // namespace details
+} // namespace Concurrency
diff --git a/msvc-stl/stl/src/thread0.cpp b/msvc-stl/stl/src/thread0.cpp
new file mode 100644
index 0000000..23b098d
--- /dev/null
+++ b/msvc-stl/stl/src/thread0.cpp
@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstdlib>
+#include <system_error>
+#include <xthreads.h>
+
+_STD_BEGIN
+
+static constexpr const char* msgs[] = {
+    // error messages
+    "device or resource busy",
+    "invalid argument",
+    "no such process",
+    "not enough memory",
+    "operation not permitted",
+    "resource deadlock would occur",
+    "resource unavailable try again",
+};
+
+static constexpr errc codes[] = {
+    // system_error codes
+    errc::device_or_resource_busy,
+    errc::invalid_argument,
+    errc::no_such_process,
+    errc::not_enough_memory,
+    errc::operation_not_permitted,
+    errc::resource_deadlock_would_occur,
+    errc::resource_unavailable_try_again,
+};
+
+[[noreturn]] _CRTIMP2_PURE void __cdecl _Throw_Cpp_error(int code) { // throw error object
+    _THROW(system_error(static_cast<int>(codes[code]), _STD generic_category(), msgs[code]));
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+[[noreturn]] _CRTIMP2_PURE void __cdecl _Throw_C_error(int code) { // throw error object for C error
+    switch (static_cast<_Thrd_result>(code)) { // select the exception
+    case _Thrd_result::_Nomem:
+    case _Thrd_result::_Timedout:
+        _Throw_Cpp_error(_RESOURCE_UNAVAILABLE_TRY_AGAIN);
+
+    case _Thrd_result::_Busy:
+        _Throw_Cpp_error(_DEVICE_OR_RESOURCE_BUSY);
+
+    case _Thrd_result::_Error:
+        _Throw_Cpp_error(_INVALID_ARGUMENT);
+
+    default:
+        _CSTD abort();
+    }
+}
+_STD_END
diff --git a/msvc-stl/stl/src/tzdb.cpp b/msvc-stl/stl/src/tzdb.cpp
new file mode 100644
index 0000000..d3f2fe6
--- /dev/null
+++ b/msvc-stl/stl/src/tzdb.cpp
@@ -0,0 +1,655 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <__msvc_tzdb.hpp>
+#include <atomic>
+#include <functional>
+#include <icu.h>
+#include <internal_shared.h>
+#include <memory>
+#include <string_view>
+#include <xfilesystem_abi.h>
+
+#include <Windows.h>
+
+#pragma comment(lib, "Advapi32")
+
+namespace {
+    enum class _Icu_api_level : unsigned long {
+        _Not_set,
+        _Detecting,
+        _Has_failed,
+        _Has_icu_addresses,
+    };
+
+    struct _Icu_functions_table {
+        _STD atomic<decltype(&::ucal_close)> _Pfn_ucal_close{nullptr};
+        _STD atomic<decltype(&::ucal_get)> _Pfn_ucal_get{nullptr};
+        _STD atomic<decltype(&::ucal_getCanonicalTimeZoneID)> _Pfn_ucal_getCanonicalTimeZoneID{nullptr};
+        _STD atomic<decltype(&::ucal_getDefaultTimeZone)> _Pfn_ucal_getDefaultTimeZone{nullptr};
+        _STD atomic<decltype(&::ucal_getTimeZoneDisplayName)> _Pfn_ucal_getTimeZoneDisplayName{nullptr};
+        _STD atomic<decltype(&::ucal_getTimeZoneTransitionDate)> _Pfn_ucal_getTimeZoneTransitionDate{nullptr};
+        _STD atomic<decltype(&::ucal_getTZDataVersion)> _Pfn_ucal_getTZDataVersion{nullptr};
+        _STD atomic<decltype(&::ucal_open)> _Pfn_ucal_open{nullptr};
+        _STD atomic<decltype(&::ucal_openTimeZoneIDEnumeration)> _Pfn_ucal_openTimeZoneIDEnumeration{nullptr};
+        _STD atomic<decltype(&::ucal_setMillis)> _Pfn_ucal_setMillis{nullptr};
+        _STD atomic<decltype(&::uenum_close)> _Pfn_uenum_close{nullptr};
+        _STD atomic<decltype(&::uenum_count)> _Pfn_uenum_count{nullptr};
+        _STD atomic<decltype(&::uenum_unext)> _Pfn_uenum_unext{nullptr};
+        _STD atomic<_Icu_api_level> _Api_level{_Icu_api_level::_Not_set};
+    };
+
+    _Icu_functions_table _Icu_functions;
+
+    template <class _Ty>
+    void _Load_address(
+        const HMODULE _Module, _STD atomic<_Ty>& _Stored_Pfn, LPCSTR _Fn_name, DWORD& _Last_error) noexcept {
+        const auto _Pfn = reinterpret_cast<_Ty>(GetProcAddress(_Module, _Fn_name));
+        if (_Pfn != nullptr) {
+            _Stored_Pfn.store(_Pfn, _STD memory_order_relaxed);
+        } else {
+            _Last_error = GetLastError();
+        }
+    }
+
+    [[nodiscard]] _Icu_api_level _Init_icu_functions(_Icu_api_level _Level) noexcept {
+        while (!_Icu_functions._Api_level.compare_exchange_weak(
+            _Level, _Icu_api_level::_Detecting, _STD memory_order_acq_rel)) {
+            if (_Level > _Icu_api_level::_Detecting) {
+                return _Level;
+            }
+        }
+
+        _Level = _Icu_api_level::_Has_failed;
+
+        const HMODULE _Icu_module = LoadLibraryExW(L"icu.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
+        if (_Icu_module != nullptr) {
+            // collect at least one error if any GetProcAddress call fails
+            DWORD _Last_error{ERROR_SUCCESS};
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_close, "ucal_close", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_get, "ucal_get", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_getCanonicalTimeZoneID, "ucal_getCanonicalTimeZoneID",
+                _Last_error);
+            _Load_address(
+                _Icu_module, _Icu_functions._Pfn_ucal_getDefaultTimeZone, "ucal_getDefaultTimeZone", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_getTimeZoneDisplayName, "ucal_getTimeZoneDisplayName",
+                _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_getTimeZoneTransitionDate,
+                "ucal_getTimeZoneTransitionDate", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_getTZDataVersion, "ucal_getTZDataVersion", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_open, "ucal_open", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_openTimeZoneIDEnumeration,
+                "ucal_openTimeZoneIDEnumeration", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_ucal_setMillis, "ucal_setMillis", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_uenum_close, "uenum_close", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_uenum_count, "uenum_count", _Last_error);
+            _Load_address(_Icu_module, _Icu_functions._Pfn_uenum_unext, "uenum_unext", _Last_error);
+            if (_Last_error == ERROR_SUCCESS) {
+                _Level = _Icu_api_level::_Has_icu_addresses;
+            } else {
+                // reset last error code for thread in case a later GetProcAddress resets it
+                SetLastError(_Last_error);
+            }
+        }
+
+        _Icu_functions._Api_level.store(_Level, _STD memory_order_release);
+        return _Level;
+    }
+
+    [[nodiscard]] _Icu_api_level _Acquire_icu_functions() noexcept {
+        auto _Level = _Icu_functions._Api_level.load(_STD memory_order_acquire);
+        if (_Level <= _Icu_api_level::_Detecting) {
+            _Level = _Init_icu_functions(_Level);
+        }
+
+        return _Level;
+    }
+
+    void __icu_ucal_close(UCalendar* cal) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_close.load(_STD memory_order_relaxed);
+        _Fun(cal);
+    }
+
+    [[nodiscard]] int32_t __icu_ucal_get(const UCalendar* cal, UCalendarDateFields field, UErrorCode* status) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_get.load(_STD memory_order_relaxed);
+        return _Fun(cal, field, status);
+    }
+
+    [[nodiscard]] int32_t __icu_ucal_getCanonicalTimeZoneID(const UChar* id, int32_t len, UChar* result,
+        int32_t resultCapacity, UBool* isSystemID, UErrorCode* status) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_getCanonicalTimeZoneID.load(_STD memory_order_relaxed);
+        return _Fun(id, len, result, resultCapacity, isSystemID, status);
+    }
+
+    [[nodiscard]] int32_t __icu_ucal_getDefaultTimeZone(
+        UChar* result, int32_t resultCapacity, UErrorCode* ec) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_getDefaultTimeZone.load(_STD memory_order_relaxed);
+        return _Fun(result, resultCapacity, ec);
+    }
+
+    [[nodiscard]] int32_t __icu_ucal_getTimeZoneDisplayName(const UCalendar* cal, UCalendarDisplayNameType type,
+        const char* locale, UChar* result, int32_t resultLength, UErrorCode* status) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_getTimeZoneDisplayName.load(_STD memory_order_relaxed);
+        return _Fun(cal, type, locale, result, resultLength, status);
+    }
+
+    [[nodiscard]] UBool __icu_ucal_getTimeZoneTransitionDate(
+        const UCalendar* cal, UTimeZoneTransitionType type, UDate* transition, UErrorCode* status) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_getTimeZoneTransitionDate.load(_STD memory_order_relaxed);
+        return _Fun(cal, type, transition, status);
+    }
+
+    [[nodiscard]] const char* __icu_ucal_getTZDataVersion(UErrorCode* status) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_getTZDataVersion.load(_STD memory_order_relaxed);
+        return _Fun(status);
+    }
+
+    [[nodiscard]] UCalendar* __icu_ucal_open(
+        const UChar* zoneID, int32_t len, const char* locale, UCalendarType type, UErrorCode* status) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_open.load(_STD memory_order_relaxed);
+        return _Fun(zoneID, len, locale, type, status);
+    }
+
+    [[nodiscard]] UEnumeration* __icu_ucal_openTimeZoneIDEnumeration(
+        USystemTimeZoneType zoneType, const char* region, const int32_t* rawOffset, UErrorCode* ec) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_openTimeZoneIDEnumeration.load(_STD memory_order_relaxed);
+        return _Fun(zoneType, region, rawOffset, ec);
+    }
+
+    void __icu_ucal_setMillis(UCalendar* cal, UDate dateTime, UErrorCode* status) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_ucal_setMillis.load(_STD memory_order_relaxed);
+        _Fun(cal, dateTime, status);
+    }
+
+    void __icu_uenum_close(UEnumeration* en) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_uenum_close.load(_STD memory_order_relaxed);
+        _Fun(en);
+    }
+
+    [[nodiscard]] int32_t __icu_uenum_count(UEnumeration* en, UErrorCode* ec) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_uenum_count.load(_STD memory_order_relaxed);
+        return _Fun(en, ec);
+    }
+
+    [[nodiscard]] const UChar* __icu_uenum_unext(UEnumeration* en, int32_t* resultLength, UErrorCode* status) noexcept {
+        const auto _Fun = _Icu_functions._Pfn_uenum_unext.load(_STD memory_order_relaxed);
+        return _Fun(en, resultLength, status);
+    }
+
+    struct _UEnumeration_deleter {
+        void operator()(UEnumeration* _En) const noexcept {
+            __icu_uenum_close(_En);
+        }
+    };
+
+    struct _UCalendar_deleter {
+        void operator()(UCalendar* _Cal) const noexcept {
+            __icu_ucal_close(_Cal);
+        }
+    };
+
+    [[nodiscard]] const char* _Allocate_wide_to_narrow(
+        const char16_t* const _Input, const int _Input_len, __std_tzdb_error& _Err) noexcept {
+        const auto _Code_page      = __std_fs_code_page();
+        const auto _Input_as_wchar = reinterpret_cast<const wchar_t*>(_Input);
+        const auto _Count_result = __std_fs_convert_wide_to_narrow(_Code_page, _Input_as_wchar, _Input_len, nullptr, 0);
+        if (_Count_result._Err != __std_win_error::_Success) {
+            SetLastError(static_cast<DWORD>(_Count_result._Err));
+            _Err = __std_tzdb_error::_Win_error;
+            return nullptr;
+        }
+
+        _STD unique_ptr<char[]> _Data{new (_STD nothrow) char[_Count_result._Len + 1]};
+        if (_Data == nullptr) {
+            return nullptr;
+        }
+
+        _Data[_Count_result._Len] = '\0';
+
+        const auto _Result =
+            __std_fs_convert_wide_to_narrow(_Code_page, _Input_as_wchar, _Input_len, _Data.get(), _Count_result._Len);
+        if (_Result._Err != __std_win_error::_Success) {
+            SetLastError(static_cast<DWORD>(_Result._Err));
+            _Err = __std_tzdb_error::_Win_error;
+            return nullptr;
+        }
+
+        return _Data.release();
+    }
+
+    [[nodiscard]] _STD unique_ptr<const char16_t[]> _Allocate_narrow_to_wide(
+        const char* const _Input, const int _Input_len, __std_tzdb_error& _Err) noexcept {
+        const auto _Code_page = __std_fs_code_page();
+        const auto _Count     = __std_fs_convert_narrow_to_wide(_Code_page, _Input, _Input_len, nullptr, 0);
+        if (_Count._Err != __std_win_error::_Success) {
+            _Err = __std_tzdb_error::_Win_error;
+            return nullptr;
+        }
+
+        _STD unique_ptr<char16_t[]> _Data{new (_STD nothrow) char16_t[_Count._Len + 1]};
+        if (_Data == nullptr) {
+            return nullptr;
+        }
+
+        _Data[_Count._Len]          = u'\0';
+        const auto _Output_as_wchar = reinterpret_cast<wchar_t*>(_Data.get());
+
+        const auto _Result =
+            __std_fs_convert_narrow_to_wide(_Code_page, _Input, _Input_len, _Output_as_wchar, _Count._Len);
+        if (_Result._Err != __std_win_error::_Success) {
+            _Err = __std_tzdb_error::_Win_error;
+            return nullptr;
+        }
+
+        return _Data;
+    }
+
+    template <class _Function>
+    [[nodiscard]] _STD unique_ptr<const char16_t[]> _Get_icu_string_impl(const _Function _Icu_fn,
+        const int32_t _Initial_buf_len, int32_t& _Result_len, __std_tzdb_error& _Err) noexcept {
+        _STD unique_ptr<char16_t[]> _Str_buf{new (_STD nothrow) char16_t[_Initial_buf_len]};
+        if (_Str_buf == nullptr) {
+            return nullptr;
+        }
+
+        UErrorCode _UErr{U_ZERO_ERROR};
+        _Result_len = _Icu_fn(_Str_buf.get(), _Initial_buf_len, &_UErr);
+        if (_UErr == U_BUFFER_OVERFLOW_ERROR && _Result_len > 0) {
+            _Str_buf.reset(new (_STD nothrow) char16_t[_Result_len + 1]);
+            if (_Str_buf == nullptr) {
+                return nullptr;
+            }
+
+            _UErr       = U_ZERO_ERROR; // reset error.
+            _Result_len = _Icu_fn(_Str_buf.get(), _Result_len, &_UErr);
+            if (U_FAILURE(_UErr)) {
+                _Err = __std_tzdb_error::_Icu_error;
+                return nullptr;
+            }
+        } else if (U_FAILURE(_UErr) || _Result_len <= 0) {
+            _Err = __std_tzdb_error::_Icu_error;
+            return nullptr;
+        }
+
+        return _Str_buf;
+    }
+
+    [[nodiscard]] _STD unique_ptr<const char16_t[]> _Get_canonical_id(
+        const char16_t* _Id, const int32_t _Len, int32_t& _Result_len, __std_tzdb_error& _Err) noexcept {
+        const auto _Icu_fn = [_Id, _Len](UChar* _Result, int32_t _Result_capacity, UErrorCode* _UErr) {
+            UBool _Is_system{};
+            return __icu_ucal_getCanonicalTimeZoneID(_Id, _Len, _Result, _Result_capacity, &_Is_system, _UErr);
+        };
+        return _Get_icu_string_impl(_Icu_fn, 32, _Result_len, _Err);
+    }
+
+    [[nodiscard]] _STD unique_ptr<const char16_t[]> _Get_default_timezone(
+        int32_t& _Result_len, __std_tzdb_error& _Err) noexcept {
+        const auto _Icu_fn = [](UChar* _Result, int32_t _Result_capacity, UErrorCode* _UErr) {
+            return __icu_ucal_getDefaultTimeZone(_Result, _Result_capacity, _UErr);
+        };
+        return _Get_icu_string_impl(_Icu_fn, 32, _Result_len, _Err);
+    }
+
+    [[nodiscard]] _STD unique_ptr<const char16_t[]> _Get_timezone_short_id(
+        UCalendar* const _Cal, const bool _Is_daylight, int32_t& _Result_len, __std_tzdb_error& _Err) noexcept {
+        const auto _Display_type =
+            _Is_daylight ? UCalendarDisplayNameType::UCAL_SHORT_DST : UCalendarDisplayNameType::UCAL_SHORT_STANDARD;
+        const auto _Icu_fn = [_Cal, _Display_type](UChar* _Result, int32_t _Result_capacity, UErrorCode* _UErr) {
+            return __icu_ucal_getTimeZoneDisplayName(_Cal, _Display_type, nullptr, _Result, _Result_capacity, _UErr);
+        };
+        return _Get_icu_string_impl(_Icu_fn, 12, _Result_len, _Err);
+    }
+
+    [[nodiscard]] _STD unique_ptr<UCalendar, _UCalendar_deleter> _Get_cal(
+        const char* _Tz, const size_t _Tz_len, __std_tzdb_error& _Err) noexcept {
+        const auto _Tz_name = _Allocate_narrow_to_wide(_Tz, static_cast<int>(_Tz_len), _Err);
+        if (_Tz_name == nullptr) {
+            return nullptr;
+        }
+
+        UErrorCode _UErr{U_ZERO_ERROR};
+        _STD unique_ptr<UCalendar, _UCalendar_deleter> _Cal{
+            __icu_ucal_open(_Tz_name.get(), -1, nullptr, UCalendarType::UCAL_DEFAULT, &_UErr)};
+        if (U_FAILURE(_UErr)) {
+            _Err = __std_tzdb_error::_Icu_error;
+        }
+
+        return _Cal;
+    }
+
+    template <class _Ty, class _Dx>
+    [[nodiscard]] _Ty* _Report_error(_STD unique_ptr<_Ty, _Dx>& _Info, const __std_tzdb_error _Err) noexcept {
+        _Info->_Err = _Err;
+        return _Info.release();
+    }
+
+    template <class _Ty, class _Dx>
+    [[nodiscard]] _Ty* _Propagate_error(_STD unique_ptr<_Ty, _Dx>& _Info) noexcept {
+        // a bad_alloc returns nullptr and does not set __std_tzdb_error
+        return _Info->_Err == __std_tzdb_error::_Success ? nullptr : _Info.release();
+    }
+} // unnamed namespace
+
+extern "C" {
+
+[[nodiscard]] __std_tzdb_time_zones_info* __stdcall __std_tzdb_get_time_zones() noexcept {
+    // On exit---
+    //    _Info == nullptr          --> bad_alloc
+    //    _Info->_Err == _Win_error --> failed, call GetLastError()
+    //    _Info->_Err == _Icu_error --> runtime_error interacting with ICU
+#pragma warning(push)
+#pragma warning(disable : 28182) // TRANSITION, VSO-1558277: Dereferencing NULL pointer.
+    _STD unique_ptr<__std_tzdb_time_zones_info, _STD _Tzdb_deleter<__std_tzdb_time_zones_info>> _Info{
+        new (_STD nothrow) __std_tzdb_time_zones_info{}};
+#pragma warning(pop)
+    if (_Info == nullptr) {
+        return nullptr;
+    }
+
+    if (_Acquire_icu_functions() < _Icu_api_level::_Has_icu_addresses) {
+        return _Report_error(_Info, __std_tzdb_error::_Win_error);
+    }
+
+    UErrorCode _UErr{U_ZERO_ERROR};
+    _Info->_Version = __icu_ucal_getTZDataVersion(&_UErr);
+    if (U_FAILURE(_UErr)) {
+        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+    }
+
+    _STD unique_ptr<UEnumeration, _UEnumeration_deleter> _Enum{
+        __icu_ucal_openTimeZoneIDEnumeration(USystemTimeZoneType::UCAL_ZONE_TYPE_ANY, nullptr, nullptr, &_UErr)};
+    if (U_FAILURE(_UErr)) {
+        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+    }
+
+    // uenum_count may be expensive but is required to pre-allocate arrays.
+    const int32_t _Num_time_zones = __icu_uenum_count(_Enum.get(), &_UErr);
+    if (U_FAILURE(_UErr)) {
+        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+    }
+
+    _Info->_Num_time_zones = static_cast<size_t>(_Num_time_zones);
+    // value-init to ensure __std_tzdb_delete_time_zones() cleanup is valid
+    if (const auto _Names = new (_STD nothrow) const char*[_Info->_Num_time_zones]{}) {
+        _Info->_Names = _Names;
+    } else {
+        return nullptr;
+    }
+
+    // value-init to ensure __std_tzdb_delete_time_zones() cleanup is valid
+    if (const auto _Links = new (_STD nothrow) const char*[_Info->_Num_time_zones]{}) {
+        _Info->_Links = _Links;
+    } else {
+        return nullptr;
+    }
+
+    for (size_t _Name_idx = 0; _Name_idx < _Info->_Num_time_zones; ++_Name_idx) {
+        int32_t _Elem_len{};
+        const auto _Elem = __icu_uenum_unext(_Enum.get(), &_Elem_len, &_UErr);
+        if (U_FAILURE(_UErr) || _Elem == nullptr) {
+            return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+        }
+
+        _Info->_Names[_Name_idx] = _Allocate_wide_to_narrow(_Elem, _Elem_len, _Info->_Err);
+        if (_Info->_Names[_Name_idx] == nullptr) {
+            return _Propagate_error(_Info);
+        }
+
+        int32_t _Link_len{};
+        const auto _Link = _Get_canonical_id(_Elem, _Elem_len, _Link_len, _Info->_Err);
+        if (_Link == nullptr) {
+            return _Propagate_error(_Info);
+        }
+
+        if (_STD u16string_view{_Elem, static_cast<size_t>(_Elem_len)}
+            != _STD u16string_view{_Link.get(), static_cast<size_t>(_Link_len)}) {
+            _Info->_Links[_Name_idx] = _Allocate_wide_to_narrow(_Link.get(), _Link_len, _Info->_Err);
+            if (_Info->_Links[_Name_idx] == nullptr) {
+                return _Propagate_error(_Info);
+            }
+        }
+    }
+
+    return _Info.release();
+}
+
+void __stdcall __std_tzdb_delete_time_zones(__std_tzdb_time_zones_info* const _Info) noexcept {
+    if (_Info != nullptr) {
+        if (_Info->_Names != nullptr) {
+            for (size_t _Idx = 0; _Idx < _Info->_Num_time_zones; ++_Idx) {
+                delete[] _Info->_Names[_Idx];
+            }
+
+            delete[] _Info->_Names;
+        }
+
+        if (_Info->_Links != nullptr) {
+            for (size_t _Idx = 0; _Idx < _Info->_Num_time_zones; ++_Idx) {
+                delete[] _Info->_Links[_Idx];
+            }
+
+            delete[] _Info->_Links;
+        }
+
+        delete _Info;
+    }
+}
+
+[[nodiscard]] __std_tzdb_current_zone_info* __stdcall __std_tzdb_get_current_zone() noexcept {
+    // On exit---
+    //    _Info == nullptr          --> bad_alloc
+    //    _Info->_Err == _Win_error --> failed, call GetLastError()
+    //    _Info->_Err == _Icu_error --> runtime_error interacting with ICU
+#pragma warning(push)
+#pragma warning(disable : 28182) // TRANSITION, VSO-1558277: Dereferencing NULL pointer.
+    _STD unique_ptr<__std_tzdb_current_zone_info, _STD _Tzdb_deleter<__std_tzdb_current_zone_info>> _Info{
+        new (_STD nothrow) __std_tzdb_current_zone_info{}};
+#pragma warning(pop)
+    if (_Info == nullptr) {
+        return nullptr;
+    }
+
+    if (_Acquire_icu_functions() < _Icu_api_level::_Has_icu_addresses) {
+        return _Report_error(_Info, __std_tzdb_error::_Win_error);
+    }
+
+    int32_t _Id_len{};
+    const auto _Id_name = _Get_default_timezone(_Id_len, _Info->_Err);
+    if (_Id_name == nullptr) {
+        return _Propagate_error(_Info);
+    }
+
+    _Info->_Tz_name = _Allocate_wide_to_narrow(_Id_name.get(), _Id_len, _Info->_Err);
+    if (_Info->_Tz_name == nullptr) {
+        return _Propagate_error(_Info);
+    }
+
+    return _Info.release();
+}
+
+void __stdcall __std_tzdb_delete_current_zone(__std_tzdb_current_zone_info* const _Info) noexcept {
+    if (_Info) {
+        delete[] _Info->_Tz_name;
+
+        delete _Info;
+    }
+}
+
+[[nodiscard]] __std_tzdb_sys_info* __stdcall __std_tzdb_get_sys_info(
+    const char* _Tz, const size_t _Tz_len, __std_tzdb_epoch_milli _Sys) noexcept {
+    // On exit---
+    //    _Info == nullptr          --> bad_alloc
+    //    _Info->_Err == _Win_error --> failed, call GetLastError()
+    //    _Info->_Err == _Icu_error --> runtime_error interacting with ICU
+#pragma warning(push)
+#pragma warning(disable : 28182) // TRANSITION, VSO-1558277: Dereferencing NULL pointer.
+    _STD unique_ptr<__std_tzdb_sys_info, _STD _Tzdb_deleter<__std_tzdb_sys_info>> _Info{
+        new (_STD nothrow) __std_tzdb_sys_info{}};
+#pragma warning(pop)
+    if (_Info == nullptr) {
+        return nullptr;
+    }
+
+    if (_Acquire_icu_functions() < _Icu_api_level::_Has_icu_addresses) {
+        return _Report_error(_Info, __std_tzdb_error::_Win_error);
+    }
+
+    // Get the option stored after the time zone name. If there's no option, _Tz[_Tz_len] is the null terminator in the
+    // std::string, and will be treated the same as __std_tzdb_sys_info_type::_Full.
+    const auto _Type = static_cast<__std_tzdb_sys_info_type>(_Tz[_Tz_len]);
+
+    // TRANSITION, ABI
+    // Profiling shows that _Get_cal is a hot path. Its result should be cached (preferably in the time_zone object).
+    const auto _Cal = _Get_cal(_Tz, _Tz_len, _Info->_Err);
+    if (_Cal == nullptr) {
+        return _Propagate_error(_Info);
+    }
+
+    UErrorCode _UErr{};
+    __icu_ucal_setMillis(_Cal.get(), _Sys, &_UErr);
+    if (U_FAILURE(_UErr)) {
+        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+    }
+
+    _Info->_Save = __icu_ucal_get(_Cal.get(), UCalendarDateFields::UCAL_DST_OFFSET, &_UErr);
+    if (U_FAILURE(_UErr)) {
+        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+    }
+
+    _Info->_Offset = __icu_ucal_get(_Cal.get(), UCalendarDateFields::UCAL_ZONE_OFFSET, &_UErr) + _Info->_Save;
+    if (U_FAILURE(_UErr)) {
+        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+    }
+
+    if (_Type == __std_tzdb_sys_info_type::_Offset_only) {
+        return _Info.release();
+    }
+
+    UDate _Transition{};
+    _Info->_Begin = __icu_ucal_getTimeZoneTransitionDate(_Cal.get(),
+                        UTimeZoneTransitionType::UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE, &_Transition, &_UErr)
+                      ? _Transition
+                      : U_DATE_MIN;
+    if (U_FAILURE(_UErr)) {
+        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+    }
+
+    _Info->_End = __icu_ucal_getTimeZoneTransitionDate(
+                      _Cal.get(), UTimeZoneTransitionType::UCAL_TZ_TRANSITION_NEXT, &_Transition, &_UErr)
+                    ? _Transition
+                    : U_DATE_MAX;
+    if (U_FAILURE(_UErr)) {
+        return _Report_error(_Info, __std_tzdb_error::_Icu_error);
+    }
+
+    if (_Type == __std_tzdb_sys_info_type::_Offset_and_range) {
+        return _Info.release();
+    }
+
+    int32_t _Abbrev_len{};
+    const auto _Abbrev = _Get_timezone_short_id(_Cal.get(), _Info->_Save != 0, _Abbrev_len, _Info->_Err);
+    if (_Abbrev == nullptr) {
+        return _Propagate_error(_Info);
+    }
+
+    _Info->_Abbrev = _Allocate_wide_to_narrow(_Abbrev.get(), _Abbrev_len, _Info->_Err);
+    if (_Info->_Abbrev == nullptr) {
+        const auto _Abs_offset        = _Info->_Offset < 0 ? -_Info->_Offset : _Info->_Offset;
+        const auto _Offset_in_minutes = _Abs_offset / (60 * 1000);
+        const auto _Hours             = _Offset_in_minutes / 60;
+        const auto _Mins              = _Offset_in_minutes % 60;
+
+        _STD unique_ptr<char[]> _Fallback_abbrev{new (_STD nothrow) char[_Mins == 0 ? 4 : 6]};
+
+        if (_Fallback_abbrev == nullptr) {
+            return nullptr;
+        }
+
+        _Fallback_abbrev[0] = _Info->_Offset < 0 ? '-' : '+';
+        _Fallback_abbrev[1] = static_cast<char>('0' + _Hours / 10);
+        _Fallback_abbrev[2] = static_cast<char>('0' + _Hours % 10);
+
+        if (_Mins == 0) {
+            _Fallback_abbrev[3] = '\0';
+        } else {
+            _Fallback_abbrev[3] = static_cast<char>('0' + _Mins / 10);
+            _Fallback_abbrev[4] = static_cast<char>('0' + _Mins % 10);
+            _Fallback_abbrev[5] = '\0';
+        }
+
+        _Info->_Err    = __std_tzdb_error::_Success;
+        _Info->_Abbrev = _Fallback_abbrev.release();
+    }
+
+    return _Info.release();
+}
+
+void __stdcall __std_tzdb_delete_sys_info(__std_tzdb_sys_info* const _Info) noexcept {
+    if (_Info) {
+        delete[] _Info->_Abbrev;
+
+        delete _Info;
+    }
+}
+
+[[nodiscard]] __std_tzdb_leap_info* __stdcall __std_tzdb_get_leap_seconds(
+    const size_t prev_reg_ls_size, size_t* const current_reg_ls_size) noexcept {
+    // On exit---
+    //    *current_reg_ls_size <= prev_reg_ls_size, reg_ls_data == nullptr --> no new data
+    //    *current_reg_ls_size >  prev_reg_ls_size, reg_ls_data != nullptr --> new data, successfully read
+    //    *current_reg_ls_size == 0,                reg_ls_data != nullptr --> new data, failed reading
+    //    *current_reg_ls_size >  prev_reg_ls_size, reg_ls_data == nullptr --> new data, failed allocation
+
+    constexpr auto reg_key_name    = LR"(SYSTEM\CurrentControlSet\Control\LeapSecondInformation)";
+    constexpr auto reg_subkey_name = L"LeapSeconds";
+    *current_reg_ls_size           = 0;
+    HKEY leap_sec_key              = nullptr;
+
+    LSTATUS status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, reg_key_name, 0, KEY_READ, &leap_sec_key);
+    if (status != ERROR_SUCCESS) {
+        // May not exist on older systems. Treat this as equivalent to the key existing but with no data.
+        return nullptr;
+    }
+
+    DWORD byte_size = 0;
+    status          = RegQueryValueExW(leap_sec_key, reg_subkey_name, nullptr, nullptr, nullptr, &byte_size);
+    static_assert(sizeof(__std_tzdb_leap_info) == 12);
+    const auto ls_size   = byte_size / 12;
+    *current_reg_ls_size = ls_size;
+
+    __std_tzdb_leap_info* reg_ls_data = nullptr;
+    if ((status == ERROR_SUCCESS || status == ERROR_MORE_DATA) && ls_size > prev_reg_ls_size) {
+        try {
+            reg_ls_data = new __std_tzdb_leap_info[ls_size];
+
+            status = RegQueryValueExW(
+                leap_sec_key, reg_subkey_name, nullptr, nullptr, reinterpret_cast<LPBYTE>(reg_ls_data), &byte_size);
+            if (status != ERROR_SUCCESS) {
+                *current_reg_ls_size = 0;
+            }
+        } catch (...) {
+        }
+    }
+
+    RegCloseKey(leap_sec_key);
+    if (status != ERROR_SUCCESS) {
+        SetLastError(status);
+    }
+
+    return reg_ls_data;
+}
+
+void __stdcall __std_tzdb_delete_leap_seconds(__std_tzdb_leap_info* _Info) noexcept {
+    delete[] _Info;
+}
+
+[[nodiscard]] void* __stdcall __std_calloc_crt(const size_t count, const size_t size) noexcept {
+    return _calloc_crt(count, size);
+}
+
+void __stdcall __std_free_crt(void* p) noexcept {
+    _free_crt(p);
+}
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/ulocale.cpp b/msvc-stl/stl/src/ulocale.cpp
new file mode 100644
index 0000000..de31c30
--- /dev/null
+++ b/msvc-stl/stl/src/ulocale.cpp
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Machinery for the UTF-8 codecvt facets
+
+#if !defined(_DLL) || defined(_BUILDING_SATELLITE_CODECVT_IDS)
+#include <xlocale>
+
+#ifdef _DLL
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+_STD_BEGIN
+EXPORT locale::id codecvt<char16_t, char8_t, mbstate_t>::id;
+EXPORT locale::id codecvt<char32_t, char8_t, mbstate_t>::id;
+
+// These specializations are exported from msvcp140, *except* for their ids
+EXPORT locale::id codecvt<char16_t, char, mbstate_t>::id;
+EXPORT locale::id codecvt<char32_t, char, mbstate_t>::id;
+_STD_END
+#endif // !defined(_DLL) || defined(_BUILDING_SATELLITE_CODECVT_IDS)
diff --git a/msvc-stl/stl/src/uncaught_exception.cpp b/msvc-stl/stl/src/uncaught_exception.cpp
new file mode 100644
index 0000000..df21b68
--- /dev/null
+++ b/msvc-stl/stl/src/uncaught_exception.cpp
@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <eh.h>
+#include <exception>
+_STD_BEGIN
+
+_CXX17_DEPRECATE_UNCAUGHT_EXCEPTION _NODISCARD _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
+    uncaught_exception() noexcept {
+    return __uncaught_exception();
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/uncaught_exceptions.cpp b/msvc-stl/stl/src/uncaught_exceptions.cpp
new file mode 100644
index 0000000..2977b8e
--- /dev/null
+++ b/msvc-stl/stl/src/uncaught_exceptions.cpp
@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <eh.h>
+#include <exception>
+_STD_BEGIN
+
+_NODISCARD _CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL uncaught_exceptions() noexcept {
+    return __uncaught_exceptions();
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/ushcerr.cpp b/msvc-stl/stl/src/ushcerr.cpp
new file mode 100644
index 0000000..bcdf212
--- /dev/null
+++ b/msvc-stl/stl/src/ushcerr.cpp
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard wide error stream (unsigned short version)
+
+#include <fstream>
+
+_STD_BEGIN
+
+using ushistream = basic_istream<unsigned short, char_traits<unsigned short>>;
+using ushostream = basic_ostream<unsigned short, char_traits<unsigned short>>;
+using ushfilebuf = basic_filebuf<unsigned short, char_traits<unsigned short>>;
+
+_STD_END
+
+#define wistream    ushistream
+#define wostream    ushostream
+#define wfilebuf    ushfilebuf
+#define _Init_wcerr _Init_ushcerr
+#define init_wcerr  init_ushcerr
+#define _Winit      _UShinit
+
+#include "wcerr.cpp"
diff --git a/msvc-stl/stl/src/ushcin.cpp b/msvc-stl/stl/src/ushcin.cpp
new file mode 100644
index 0000000..9545255
--- /dev/null
+++ b/msvc-stl/stl/src/ushcin.cpp
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard wide input stream (unsigned short version)
+
+#include <fstream>
+
+_STD_BEGIN
+
+using ushistream = basic_istream<unsigned short, char_traits<unsigned short>>;
+using ushostream = basic_ostream<unsigned short, char_traits<unsigned short>>;
+using ushfilebuf = basic_filebuf<unsigned short, char_traits<unsigned short>>;
+
+_STD_END
+
+#define wistream   ushistream
+#define wostream   ushostream
+#define wfilebuf   ushfilebuf
+#define _Init_wcin _Init_ushcin
+#define init_wcin  init_ushcin
+#define _Winit     _UShinit
+
+#include "wcin.cpp"
diff --git a/msvc-stl/stl/src/ushclog.cpp b/msvc-stl/stl/src/ushclog.cpp
new file mode 100644
index 0000000..6870245
--- /dev/null
+++ b/msvc-stl/stl/src/ushclog.cpp
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard wide log stream (unsigned short version)
+
+#include <fstream>
+
+_STD_BEGIN
+
+using ushistream = basic_istream<unsigned short, char_traits<unsigned short>>;
+using ushostream = basic_ostream<unsigned short, char_traits<unsigned short>>;
+using ushfilebuf = basic_filebuf<unsigned short, char_traits<unsigned short>>;
+
+_STD_END
+
+#define wistream    ushistream
+#define wostream    ushostream
+#define wfilebuf    ushfilebuf
+#define _Init_wclog _Init_ushclog
+#define init_wclog  init_ushclog
+#define _Winit      _UShinit
+
+#include "wclog.cpp"
diff --git a/msvc-stl/stl/src/ushcout.cpp b/msvc-stl/stl/src/ushcout.cpp
new file mode 100644
index 0000000..93a96cd
--- /dev/null
+++ b/msvc-stl/stl/src/ushcout.cpp
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard wide output stream (unsigned short version)
+
+#include <fstream>
+
+_STD_BEGIN
+
+using ushistream = basic_istream<unsigned short, char_traits<unsigned short>>;
+using ushostream = basic_ostream<unsigned short, char_traits<unsigned short>>;
+using ushfilebuf = basic_filebuf<unsigned short, char_traits<unsigned short>>;
+
+_STD_END
+
+#define wistream    ushistream
+#define wostream    ushostream
+#define wfilebuf    ushfilebuf
+#define _Init_wcout _Init_ushcout
+#define init_wcout  init_ushcout
+#define _Winit      _UShinit
+
+#include "wcout.cpp"
diff --git a/msvc-stl/stl/src/ushiostr.cpp b/msvc-stl/stl/src/ushiostr.cpp
new file mode 100644
index 0000000..220aa16
--- /dev/null
+++ b/msvc-stl/stl/src/ushiostr.cpp
@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// _UShinit members (unsigned short version)
+
+#include <fstream>
+
+_STD_BEGIN
+
+using ushistream = basic_istream<unsigned short, char_traits<unsigned short>>;
+using ushostream = basic_ostream<unsigned short, char_traits<unsigned short>>;
+using ushfilebuf = basic_filebuf<unsigned short, char_traits<unsigned short>>;
+
+_STD_END
+
+#define wistream ushistream
+#define wostream ushostream
+#define wfilebuf ushfilebuf
+#define _Winit   _UShinit
+
+#include <iostream>
+
+#if defined(_M_CEE_PURE)
+_STD_BEGIN
+__PURE_APPDOMAIN_GLOBAL extern wistream* _Ptr_wcin  = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wcout = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wcerr = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern wostream* _Ptr_wclog = nullptr;
+_STD_END
+#else // ^^^ defined(_M_CEE_PURE) / !defined(_M_CEE_PURE) vvv
+_STD_BEGIN
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wistream* _Ptr_wcin  = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wcout = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wcerr = nullptr;
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream* _Ptr_wclog = nullptr;
+_STD_END
+#include "wiostrea.cpp"
+#endif // ^^^ !defined(_M_CEE_PURE) ^^^
diff --git a/msvc-stl/stl/src/vector_algorithms.cpp b/msvc-stl/stl/src/vector_algorithms.cpp
new file mode 100644
index 0000000..d2518cc
--- /dev/null
+++ b/msvc-stl/stl/src/vector_algorithms.cpp
@@ -0,0 +1,11846 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifdef _M_CEE_PURE
+#error _M_CEE_PURE should not be defined when compiling vector_algorithms.cpp.
+#endif
+
+#include <__msvc_minmax.hpp>
+#include <cstdint>
+#include <cstring>
+#include <cwchar>
+#include <type_traits>
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+#include <arm64_neon.h>
+
+#include <Windows.h>
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+#include <intrin.h>
+#include <isa_availability.h>
+
+extern "C" long __isa_enabled;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+namespace {
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+    [[nodiscard]] bool _Use_avx2() noexcept {
+        return __check_arch_support(__IA_SUPPORT_VECTOR256, 0) || (__isa_enabled & (1 << __ISA_AVAILABLE_AVX2));
+    }
+
+    [[nodiscard]] bool _Use_sse42() noexcept {
+        return __check_arch_support(__IA_SUPPORT_SSE42, 0) || (__isa_enabled & (1 << __ISA_AVAILABLE_SSE42));
+    }
+
+    struct [[nodiscard]] _Zeroupper_on_exit { // TRANSITION, DevCom-10331414
+        _Zeroupper_on_exit() = default;
+
+        _Zeroupper_on_exit(const _Zeroupper_on_exit&)            = delete;
+        _Zeroupper_on_exit& operator=(const _Zeroupper_on_exit&) = delete;
+
+        ~_Zeroupper_on_exit() {
+            _mm256_zeroupper();
+        }
+    };
+
+    __m256i _Avx2_tail_mask_32(const size_t _Count_in_bytes) noexcept {
+        // _Count_in_bytes must be within [0, 32].
+        static constexpr unsigned int _Tail_masks[16] = {
+            ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, 0, 0, 0, 0, 0, 0, 0, 0};
+        return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(
+            reinterpret_cast<const unsigned char*>(_Tail_masks) + (32 - _Count_in_bytes)));
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    bool _Use_FEAT_DotProd() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_V82_DP_INSTRUCTIONS_AVAILABLE);
+    }
+
+    bool _Use_FEAT_I8MM() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_V82_I8MM_INSTRUCTIONS_AVAILABLE);
+    }
+
+    bool _Use_FEAT_SHA3() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_SHA3_INSTRUCTIONS_AVAILABLE);
+    }
+
+    bool _Use_FEAT_SVE() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_SVE_INSTRUCTIONS_AVAILABLE);
+    }
+
+    bool _Use_FEAT_SVE2() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_SVE2_INSTRUCTIONS_AVAILABLE);
+    }
+
+    bool _Use_FEAT_SVE2p1() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_SVE2_1_INSTRUCTIONS_AVAILABLE);
+    }
+
+    bool _Use_FEAT_SVE_SHA3() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_SVE_SHA3_INSTRUCTIONS_AVAILABLE);
+    }
+
+    bool _Use_FEAT_AES() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_SVE_AES_INSTRUCTIONS_AVAILABLE);
+    }
+
+    bool _Use_FEAT_BitPerm() noexcept {
+        return IsProcessorFeaturePresent(PF_ARM_SVE_BITPERM_INSTRUCTIONS_AVAILABLE);
+    }
+#endif // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) ^^^
+
+    size_t _Byte_length(const void* const _First, const void* const _Last) noexcept {
+        return static_cast<const unsigned char*>(_Last) - static_cast<const unsigned char*>(_First);
+    }
+
+    void _Rewind_bytes(void*& _Target, const size_t _Offset) noexcept {
+        _Target = static_cast<unsigned char*>(_Target) - _Offset;
+    }
+
+    void _Rewind_bytes(const void*& _Target, const size_t _Offset) noexcept {
+        _Target = static_cast<const unsigned char*>(_Target) - _Offset;
+    }
+
+    template <class _Integral>
+    void _Advance_bytes(void*& _Target, const _Integral _Offset) noexcept {
+        _Target = static_cast<unsigned char*>(_Target) + _Offset;
+    }
+
+    template <class _Integral>
+    void _Advance_bytes(const void*& _Target, const _Integral _Offset) noexcept {
+        _Target = static_cast<const unsigned char*>(_Target) + _Offset;
+    }
+} // unnamed namespace
+
+extern "C" {
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+__declspec(noalias) void __cdecl __std_swap_ranges_trivially_swappable_noalias(
+    void* _First1, void* const _Last1, void* _First2) noexcept {
+    if (_Byte_length(_First1, _Last1) >= 64) {
+        constexpr size_t _Mask_64 = ~((static_cast<size_t>(1) << 6) - 1);
+        const void* _Stop_at      = _First1;
+        _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_64);
+        do {
+            const uint8x16_t _Left1  = vld1q_u8(static_cast<uint8_t*>(_First1) + 0);
+            const uint8x16_t _Left2  = vld1q_u8(static_cast<uint8_t*>(_First1) + 16);
+            const uint8x16_t _Left3  = vld1q_u8(static_cast<uint8_t*>(_First1) + 32);
+            const uint8x16_t _Left4  = vld1q_u8(static_cast<uint8_t*>(_First1) + 48);
+            const uint8x16_t _Right1 = vld1q_u8(static_cast<uint8_t*>(_First2) + 0);
+            const uint8x16_t _Right2 = vld1q_u8(static_cast<uint8_t*>(_First2) + 16);
+            const uint8x16_t _Right3 = vld1q_u8(static_cast<uint8_t*>(_First2) + 32);
+            const uint8x16_t _Right4 = vld1q_u8(static_cast<uint8_t*>(_First2) + 48);
+            vst1q_u8(static_cast<uint8_t*>(_First1) + 0, _Right1);
+            vst1q_u8(static_cast<uint8_t*>(_First1) + 16, _Right2);
+            vst1q_u8(static_cast<uint8_t*>(_First1) + 32, _Right3);
+            vst1q_u8(static_cast<uint8_t*>(_First1) + 48, _Right4);
+            vst1q_u8(static_cast<uint8_t*>(_First2) + 0, _Left1);
+            vst1q_u8(static_cast<uint8_t*>(_First2) + 16, _Left2);
+            vst1q_u8(static_cast<uint8_t*>(_First2) + 32, _Left3);
+            vst1q_u8(static_cast<uint8_t*>(_First2) + 48, _Left4);
+            _Advance_bytes(_First1, 64);
+            _Advance_bytes(_First2, 64);
+        } while (_First1 != _Stop_at);
+    }
+
+    if (_Byte_length(_First1, _Last1) >= 32) {
+        const uint8x16_t _Left1  = vld1q_u8(static_cast<uint8_t*>(_First1) + 0);
+        const uint8x16_t _Left2  = vld1q_u8(static_cast<uint8_t*>(_First1) + 16);
+        const uint8x16_t _Right1 = vld1q_u8(static_cast<uint8_t*>(_First2) + 0);
+        const uint8x16_t _Right2 = vld1q_u8(static_cast<uint8_t*>(_First2) + 16);
+        vst1q_u8(static_cast<uint8_t*>(_First1) + 0, _Right1);
+        vst1q_u8(static_cast<uint8_t*>(_First1) + 16, _Right2);
+        vst1q_u8(static_cast<uint8_t*>(_First2) + 0, _Left1);
+        vst1q_u8(static_cast<uint8_t*>(_First2) + 16, _Left2);
+        _Advance_bytes(_First1, 32);
+        _Advance_bytes(_First2, 32);
+    }
+
+    if (_Byte_length(_First1, _Last1) >= 16) {
+        const uint8x16_t _Left  = vld1q_u8(static_cast<uint8_t*>(_First1));
+        const uint8x16_t _Right = vld1q_u8(static_cast<uint8_t*>(_First2));
+        vst1q_u8(static_cast<uint8_t*>(_First1), _Right);
+        vst1q_u8(static_cast<uint8_t*>(_First2), _Left);
+        _Advance_bytes(_First1, 16);
+        _Advance_bytes(_First2, 16);
+    }
+
+    if (_Byte_length(_First1, _Last1) >= 8) {
+        const uint8x8_t _Left  = vld1_u8(static_cast<uint8_t*>(_First1));
+        const uint8x8_t _Right = vld1_u8(static_cast<uint8_t*>(_First2));
+        vst1_u8(static_cast<uint8_t*>(_First1), _Right);
+        vst1_u8(static_cast<uint8_t*>(_First2), _Left);
+        _Advance_bytes(_First1, 8);
+        _Advance_bytes(_First2, 8);
+    }
+
+    if (_Byte_length(_First1, _Last1) >= 4) {
+        uint32x2_t _Left  = vdup_n_u32(0);
+        uint32x2_t _Right = vdup_n_u32(0);
+        _Left             = vld1_lane_u32(static_cast<uint32_t*>(_First1), _Left, 0);
+        _Right            = vld1_lane_u32(static_cast<uint32_t*>(_First2), _Right, 0);
+        vst1_lane_u32(static_cast<uint32_t*>(_First1), _Right, 0);
+        vst1_lane_u32(static_cast<uint32_t*>(_First2), _Left, 0);
+        _Advance_bytes(_First1, 4);
+        _Advance_bytes(_First2, 4);
+    }
+
+    auto _First1c = static_cast<unsigned char*>(_First1);
+    auto _First2c = static_cast<unsigned char*>(_First2);
+    for (; _First1c != _Last1; ++_First1c, ++_First2c) {
+        const unsigned char _Ch = *_First1c;
+        *_First1c               = *_First2c;
+        *_First2c               = _Ch;
+    }
+}
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+__declspec(noalias) void __cdecl __std_swap_ranges_trivially_swappable_noalias(
+    void* _First1, void* const _Last1, void* _First2) noexcept {
+    constexpr size_t _Mask_32 = ~((static_cast<size_t>(1) << 5) - 1);
+    if (_Byte_length(_First1, _Last1) >= 32 && _Use_avx2()) {
+        const void* _Stop_at = _First1;
+        _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_32);
+        do {
+            const __m256i _Left  = _mm256_loadu_si256(static_cast<__m256i*>(_First1));
+            const __m256i _Right = _mm256_loadu_si256(static_cast<__m256i*>(_First2));
+            _mm256_storeu_si256(static_cast<__m256i*>(_First1), _Right);
+            _mm256_storeu_si256(static_cast<__m256i*>(_First2), _Left);
+            _Advance_bytes(_First1, 32);
+            _Advance_bytes(_First2, 32);
+        } while (_First1 != _Stop_at);
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    }
+
+    constexpr size_t _Mask_16 = ~((static_cast<size_t>(1) << 4) - 1);
+    if (_Byte_length(_First1, _Last1) >= 16 && _Use_sse42()) {
+        const void* _Stop_at = _First1;
+        _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_16);
+        do {
+            const __m128i _Left  = _mm_loadu_si128(static_cast<__m128i*>(_First1));
+            const __m128i _Right = _mm_loadu_si128(static_cast<__m128i*>(_First2));
+            _mm_storeu_si128(static_cast<__m128i*>(_First1), _Right);
+            _mm_storeu_si128(static_cast<__m128i*>(_First2), _Left);
+            _Advance_bytes(_First1, 16);
+            _Advance_bytes(_First2, 16);
+        } while (_First1 != _Stop_at);
+    }
+
+#ifdef _WIN64
+    constexpr size_t _Mask_8 = ~((static_cast<size_t>(1) << 3) - 1);
+    if (_Byte_length(_First1, _Last1) >= 8) {
+        const void* _Stop_at = _First1;
+        _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_8);
+        do {
+            unsigned long long _Left;
+            unsigned long long _Right;
+            memcpy(&_Left, _First1, 8);
+            memcpy(&_Right, _First2, 8);
+            memcpy(_First1, &_Right, 8);
+            memcpy(_First2, &_Left, 8);
+            _Advance_bytes(_First1, 8);
+            _Advance_bytes(_First2, 8);
+        } while (_First1 != _Stop_at);
+    }
+#else // ^^^ 64-bit / 32-bit vvv
+    constexpr size_t _Mask_4 = ~((static_cast<size_t>(1) << 2) - 1);
+    if (_Byte_length(_First1, _Last1) >= 4) {
+        const void* _Stop_at = _First1;
+        _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_4);
+        do {
+            unsigned long _Left;
+            unsigned long _Right;
+            memcpy(&_Left, _First1, 4);
+            memcpy(&_Right, _First2, 4);
+            memcpy(_First1, &_Right, 4);
+            memcpy(_First2, &_Left, 4);
+            _Advance_bytes(_First1, 4);
+            _Advance_bytes(_First2, 4);
+        } while (_First1 != _Stop_at);
+    }
+#endif // ^^^ 32-bit ^^^
+
+    auto _First1c = static_cast<unsigned char*>(_First1);
+    auto _First2c = static_cast<unsigned char*>(_First2);
+    for (; _First1c != _Last1; ++_First1c, ++_First2c) {
+        const unsigned char _Ch = *_First1c;
+        *_First1c               = *_First2c;
+        *_First2c               = _Ch;
+    }
+}
+
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+#ifndef _M_ARM64
+// TRANSITION, ABI: __std_swap_ranges_trivially_swappable() is preserved for binary compatibility (x64/x86/ARM64EC)
+void* __cdecl __std_swap_ranges_trivially_swappable(
+    void* const _First1, void* const _Last1, void* const _First2) noexcept {
+    __std_swap_ranges_trivially_swappable_noalias(_First1, _Last1, _First2);
+    return static_cast<char*>(_First2) + (static_cast<char*>(_Last1) - static_cast<char*>(_First1));
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+} // extern "C"
+
+namespace {
+    namespace _Rotating {
+        // The 'rotate' algorithm can be implemented:
+        //  - using 'reverse' on the parts and the whole
+        //  - using 'swap_ranges' repeatedly
+        // If both are vectorized, the latter is generally faster, due to avoiding extra swizzling.
+        //
+        // On top of 'swap_ranges' the following optimizations are made:
+        //  - using a temporary buffer (on the stack), if one of the parts is small enough
+        //  - 'swap_ranges' with more than two ranges
+        //
+        // When swapping multiple ranges, the more ranges the fewer operations, however:
+        //  - determining the number of ranges at runtime will require more instructions to manage it
+        //  - adding more code paths will spend more instruction cache and will fail branch prediction more often
+        //  - going way too far with the number of ranges may interfere with prefetching
+        //
+        // We implement the 'swap_ranges' approach with a small temporary buffer and swapping three ranges.
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        void __forceinline _Swap_3_ranges(void* _First1, void* const _Last1, void* _First2, void* _First3) noexcept {
+            if (_Byte_length(_First1, _Last1) >= 64) {
+                constexpr size_t _Mask_64 = ~((static_cast<size_t>(1) << 6) - 1);
+                const void* _Stop_at      = _First1;
+                _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_64);
+                do {
+                    const uint8x16_t _Val1Lo1 = vld1q_u8(static_cast<uint8_t*>(_First1) + 0);
+                    const uint8x16_t _Val1Lo2 = vld1q_u8(static_cast<uint8_t*>(_First1) + 16);
+                    const uint8x16_t _Val1Hi1 = vld1q_u8(static_cast<uint8_t*>(_First1) + 32);
+                    const uint8x16_t _Val1Hi2 = vld1q_u8(static_cast<uint8_t*>(_First1) + 48);
+                    const uint8x16_t _Val2Lo1 = vld1q_u8(static_cast<uint8_t*>(_First2) + 0);
+                    const uint8x16_t _Val2Lo2 = vld1q_u8(static_cast<uint8_t*>(_First2) + 16);
+                    const uint8x16_t _Val2Hi1 = vld1q_u8(static_cast<uint8_t*>(_First2) + 32);
+                    const uint8x16_t _Val2Hi2 = vld1q_u8(static_cast<uint8_t*>(_First2) + 48);
+                    const uint8x16_t _Val3Lo1 = vld1q_u8(static_cast<uint8_t*>(_First3) + 0);
+                    const uint8x16_t _Val3Lo2 = vld1q_u8(static_cast<uint8_t*>(_First3) + 16);
+                    const uint8x16_t _Val3Hi1 = vld1q_u8(static_cast<uint8_t*>(_First3) + 32);
+                    const uint8x16_t _Val3Hi2 = vld1q_u8(static_cast<uint8_t*>(_First3) + 48);
+                    vst1q_u8(static_cast<uint8_t*>(_First1) + 0, _Val2Lo1);
+                    vst1q_u8(static_cast<uint8_t*>(_First1) + 16, _Val2Lo2);
+                    vst1q_u8(static_cast<uint8_t*>(_First1) + 32, _Val2Hi1);
+                    vst1q_u8(static_cast<uint8_t*>(_First1) + 48, _Val2Hi2);
+                    vst1q_u8(static_cast<uint8_t*>(_First2) + 0, _Val3Lo1);
+                    vst1q_u8(static_cast<uint8_t*>(_First2) + 16, _Val3Lo2);
+                    vst1q_u8(static_cast<uint8_t*>(_First2) + 32, _Val3Hi1);
+                    vst1q_u8(static_cast<uint8_t*>(_First2) + 48, _Val3Hi2);
+                    vst1q_u8(static_cast<uint8_t*>(_First3) + 0, _Val1Lo1);
+                    vst1q_u8(static_cast<uint8_t*>(_First3) + 16, _Val1Lo2);
+                    vst1q_u8(static_cast<uint8_t*>(_First3) + 32, _Val1Hi1);
+                    vst1q_u8(static_cast<uint8_t*>(_First3) + 48, _Val1Hi2);
+                    _Advance_bytes(_First1, 64);
+                    _Advance_bytes(_First2, 64);
+                    _Advance_bytes(_First3, 64);
+                } while (_First1 != _Stop_at);
+            }
+
+            if (_Byte_length(_First1, _Last1) >= 32) {
+                const uint8x16_t _Val1Lo = vld1q_u8(static_cast<uint8_t*>(_First1) + 0);
+                const uint8x16_t _Val1Hi = vld1q_u8(static_cast<uint8_t*>(_First1) + 16);
+                const uint8x16_t _Val2Lo = vld1q_u8(static_cast<uint8_t*>(_First2) + 0);
+                const uint8x16_t _Val2Hi = vld1q_u8(static_cast<uint8_t*>(_First2) + 16);
+                const uint8x16_t _Val3Lo = vld1q_u8(static_cast<uint8_t*>(_First3) + 0);
+                const uint8x16_t _Val3Hi = vld1q_u8(static_cast<uint8_t*>(_First3) + 16);
+                vst1q_u8(static_cast<uint8_t*>(_First1) + 0, _Val2Lo);
+                vst1q_u8(static_cast<uint8_t*>(_First1) + 16, _Val2Hi);
+                vst1q_u8(static_cast<uint8_t*>(_First2) + 0, _Val3Lo);
+                vst1q_u8(static_cast<uint8_t*>(_First2) + 16, _Val3Hi);
+                vst1q_u8(static_cast<uint8_t*>(_First3) + 0, _Val1Lo);
+                vst1q_u8(static_cast<uint8_t*>(_First3) + 16, _Val1Hi);
+                _Advance_bytes(_First1, 32);
+                _Advance_bytes(_First2, 32);
+                _Advance_bytes(_First3, 32);
+            }
+
+            if (_Byte_length(_First1, _Last1) >= 16) {
+                const uint8x16_t _Val1 = vld1q_u8(static_cast<uint8_t*>(_First1));
+                const uint8x16_t _Val2 = vld1q_u8(static_cast<uint8_t*>(_First2));
+                const uint8x16_t _Val3 = vld1q_u8(static_cast<uint8_t*>(_First3));
+                vst1q_u8(static_cast<uint8_t*>(_First1), _Val2);
+                vst1q_u8(static_cast<uint8_t*>(_First2), _Val3);
+                vst1q_u8(static_cast<uint8_t*>(_First3), _Val1);
+                _Advance_bytes(_First1, 16);
+                _Advance_bytes(_First2, 16);
+                _Advance_bytes(_First3, 16);
+            }
+
+            if (_Byte_length(_First1, _Last1) >= 8) {
+                const uint8x8_t _Val1 = vld1_u8(static_cast<uint8_t*>(_First1));
+                const uint8x8_t _Val2 = vld1_u8(static_cast<uint8_t*>(_First2));
+                const uint8x8_t _Val3 = vld1_u8(static_cast<uint8_t*>(_First3));
+                vst1_u8(static_cast<uint8_t*>(_First1), _Val2);
+                vst1_u8(static_cast<uint8_t*>(_First2), _Val3);
+                vst1_u8(static_cast<uint8_t*>(_First3), _Val1);
+                _Advance_bytes(_First1, 8);
+                _Advance_bytes(_First2, 8);
+                _Advance_bytes(_First3, 8);
+            }
+
+            if (_Byte_length(_First1, _Last1) >= 4) {
+                uint32x2_t _Val1 = vdup_n_u32(0);
+                uint32x2_t _Val2 = vdup_n_u32(0);
+                uint32x2_t _Val3 = vdup_n_u32(0);
+                _Val1            = vld1_lane_u32(static_cast<uint32_t*>(_First1), _Val1, 0);
+                _Val2            = vld1_lane_u32(static_cast<uint32_t*>(_First2), _Val2, 0);
+                _Val3            = vld1_lane_u32(static_cast<uint32_t*>(_First3), _Val3, 0);
+                vst1_lane_u32(static_cast<uint32_t*>(_First1), _Val2, 0);
+                vst1_lane_u32(static_cast<uint32_t*>(_First2), _Val3, 0);
+                vst1_lane_u32(static_cast<uint32_t*>(_First3), _Val1, 0);
+                _Advance_bytes(_First1, 4);
+                _Advance_bytes(_First2, 4);
+                _Advance_bytes(_First3, 4);
+            }
+
+            auto _First1c = static_cast<unsigned char*>(_First1);
+            auto _First2c = static_cast<unsigned char*>(_First2);
+            auto _First3c = static_cast<unsigned char*>(_First3);
+            for (; _First1c != _Last1; ++_First1c, ++_First2c, ++_First3c) {
+                const unsigned char _Ch = *_First1c;
+                *_First1c               = *_First2c;
+                *_First2c               = *_First3c;
+                *_First3c               = _Ch;
+            }
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        void _Swap_3_ranges(void* _First1, void* const _Last1, void* _First2, void* _First3) noexcept {
+            constexpr size_t _Mask_32 = ~((static_cast<size_t>(1) << 5) - 1);
+            if (_Byte_length(_First1, _Last1) >= 32 && _Use_avx2()) {
+                const void* _Stop_at = _First1;
+                _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_32);
+                do {
+                    const __m256i _Val1 = _mm256_loadu_si256(static_cast<__m256i*>(_First1));
+                    const __m256i _Val2 = _mm256_loadu_si256(static_cast<__m256i*>(_First2));
+                    const __m256i _Val3 = _mm256_loadu_si256(static_cast<__m256i*>(_First3));
+                    _mm256_storeu_si256(static_cast<__m256i*>(_First1), _Val2);
+                    _mm256_storeu_si256(static_cast<__m256i*>(_First2), _Val3);
+                    _mm256_storeu_si256(static_cast<__m256i*>(_First3), _Val1);
+                    _Advance_bytes(_First1, 32);
+                    _Advance_bytes(_First2, 32);
+                    _Advance_bytes(_First3, 32);
+                } while (_First1 != _Stop_at);
+
+                _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+            }
+
+            constexpr size_t _Mask_16 = ~((static_cast<size_t>(1) << 4) - 1);
+            if (_Byte_length(_First1, _Last1) >= 16 && _Use_sse42()) {
+                const void* _Stop_at = _First1;
+                _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_16);
+                do {
+                    const __m128i _Val1 = _mm_loadu_si128(static_cast<__m128i*>(_First1));
+                    const __m128i _Val2 = _mm_loadu_si128(static_cast<__m128i*>(_First2));
+                    const __m128i _Val3 = _mm_loadu_si128(static_cast<__m128i*>(_First3));
+                    _mm_storeu_si128(static_cast<__m128i*>(_First1), _Val2);
+                    _mm_storeu_si128(static_cast<__m128i*>(_First2), _Val3);
+                    _mm_storeu_si128(static_cast<__m128i*>(_First3), _Val1);
+                    _Advance_bytes(_First1, 16);
+                    _Advance_bytes(_First2, 16);
+                    _Advance_bytes(_First3, 16);
+                } while (_First1 != _Stop_at);
+            }
+
+#ifdef _WIN64
+            constexpr size_t _Mask_8 = ~((static_cast<size_t>(1) << 3) - 1);
+            if (_Byte_length(_First1, _Last1) >= 8) {
+                const void* _Stop_at = _First1;
+                _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_8);
+                do {
+                    unsigned long long _Val1;
+                    unsigned long long _Val2;
+                    unsigned long long _Val3;
+                    memcpy(&_Val1, _First1, 8);
+                    memcpy(&_Val2, _First2, 8);
+                    memcpy(&_Val3, _First3, 8);
+                    memcpy(_First1, &_Val2, 8);
+                    memcpy(_First2, &_Val3, 8);
+                    memcpy(_First3, &_Val1, 8);
+                    _Advance_bytes(_First1, 8);
+                    _Advance_bytes(_First2, 8);
+                    _Advance_bytes(_First3, 8);
+                } while (_First1 != _Stop_at);
+            }
+#else // ^^^ 64-bit / 32-bit vvv
+            constexpr size_t _Mask_4 = ~((static_cast<size_t>(1) << 2) - 1);
+            if (_Byte_length(_First1, _Last1) >= 4) {
+                const void* _Stop_at = _First1;
+                _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_4);
+                do {
+                    unsigned long _Val1;
+                    unsigned long _Val2;
+                    unsigned long _Val3;
+                    memcpy(&_Val1, _First1, 4);
+                    memcpy(&_Val2, _First2, 4);
+                    memcpy(&_Val3, _First3, 4);
+                    memcpy(_First1, &_Val2, 4);
+                    memcpy(_First2, &_Val3, 4);
+                    memcpy(_First3, &_Val1, 4);
+                    _Advance_bytes(_First1, 4);
+                    _Advance_bytes(_First2, 4);
+                    _Advance_bytes(_First3, 4);
+                } while (_First1 != _Stop_at);
+            }
+#endif // ^^^ 32-bit ^^^
+
+            auto _First1c = static_cast<unsigned char*>(_First1);
+            auto _First2c = static_cast<unsigned char*>(_First2);
+            auto _First3c = static_cast<unsigned char*>(_First3);
+            for (; _First1c != _Last1; ++_First1c, ++_First2c, ++_First3c) {
+                const unsigned char _Ch = *_First1c;
+                *_First1c               = *_First2c;
+                *_First2c               = *_First3c;
+                *_First3c               = _Ch;
+            }
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        constexpr size_t _Buf_size = 512;
+
+        bool _Use_buffer(const size_t _Smaller, const size_t _Larger) noexcept {
+            return _Smaller <= _Buf_size && (_Smaller <= 128 || _Larger >= _Smaller * 2);
+        }
+    } // namespace _Rotating
+} // unnamed namespace
+
+extern "C" {
+
+__declspec(noalias) void __stdcall __std_rotate(void* _First, void* const _Mid, void* _Last) noexcept {
+    unsigned char _Buf[_Rotating::_Buf_size];
+
+    for (;;) {
+        const size_t _Left  = _Byte_length(_First, _Mid);
+        const size_t _Right = _Byte_length(_Mid, _Last);
+
+        if (_Left <= _Right) {
+            if (_Left == 0) {
+                break;
+            }
+
+            if (_Rotating::_Use_buffer(_Left, _Right)) {
+                memcpy(_Buf, _First, _Left);
+                memmove(_First, _Mid, _Right);
+                _Advance_bytes(_First, _Right);
+                memcpy(_First, _Buf, _Left);
+                break;
+            }
+
+            void* _Mid2 = _Last;
+            _Rewind_bytes(_Mid2, _Left);
+            if (_Left * 2 > _Right) {
+                __std_swap_ranges_trivially_swappable_noalias(_Mid2, _Last, _First);
+                _Last = _Mid2;
+            } else {
+                void* _Mid3 = _Mid2;
+                _Rewind_bytes(_Mid3, _Left);
+                _Rotating::_Swap_3_ranges(_Mid2, _Last, _First, _Mid3);
+                _Last = _Mid3;
+            }
+        } else {
+            if (_Right == 0) {
+                break;
+            }
+
+            if (_Rotating::_Use_buffer(_Right, _Left)) {
+                _Rewind_bytes(_Last, _Right);
+                memcpy(_Buf, _Last, _Right);
+                void* _Mid2 = _First;
+                _Advance_bytes(_Mid2, _Right);
+                memmove(_Mid2, _First, _Left);
+                memcpy(_First, _Buf, _Right);
+                break;
+            }
+
+            if (_Right * 2 > _Left) {
+                __std_swap_ranges_trivially_swappable_noalias(_Mid, _Last, _First);
+                _Advance_bytes(_First, _Right);
+            } else {
+                void* _Mid2 = _First;
+                _Advance_bytes(_Mid2, _Right);
+                _Rotating::_Swap_3_ranges(_Mid, _Last, _Mid2, _First);
+                _Advance_bytes(_First, _Right * 2);
+            }
+        }
+    }
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Reversing {
+        template <class _BidIt>
+        void _Reverse_tail(_BidIt _First, _BidIt _Last) noexcept {
+            for (; _First != _Last && _First != --_Last; ++_First) {
+                const auto _Temp = *_First;
+                *_First          = *_Last;
+                *_Last           = _Temp;
+            }
+        }
+
+        template <class _BidIt, class _OutIt>
+        void _Reverse_copy_tail(const _BidIt _First, _BidIt _Last, _OutIt _Dest) noexcept {
+            while (_First != _Last) {
+                *_Dest++ = *--_Last;
+            }
+        }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_1 {
+            static uint8x8_t _Rev(const uint8x8_t _Val) noexcept {
+                return vrev64_u8(_Val);
+            }
+
+            static uint8x16_t _Rev(const uint8x16_t _Val) noexcept {
+                static constexpr uint8_t _Idx_arr[16] = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+                const auto _Idx                       = vld1q_u8(_Idx_arr);
+                return vqtbl1q_u8(_Val, _Idx);
+            }
+        };
+
+        struct _Traits_2 {
+            static uint8x8_t _Rev(const uint8x8_t _Val) noexcept {
+                return vreinterpret_u8_u16(vrev64_u16(vreinterpret_u16_u8(_Val)));
+            }
+
+            static uint8x16_t _Rev(const uint8x16_t _Val) noexcept {
+                static constexpr uint8_t _Idx_arr[16] = {14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1};
+                const auto _Idx                       = vld1q_u8(_Idx_arr);
+                return vqtbl1q_u8(_Val, _Idx);
+            }
+        };
+
+        struct _Traits_4 {
+            static uint8x8_t _Rev(const uint8x8_t _Val) noexcept {
+                return vreinterpret_u8_u32(vrev64_u32(vreinterpret_u32_u8(_Val)));
+            }
+
+            static uint8x16_t _Rev(const uint8x16_t _Val) noexcept {
+                static constexpr uint8_t _Idx_arr[16] = {12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3};
+                const auto _Idx                       = vld1q_u8(_Idx_arr);
+                return vqtbl1q_u8(_Val, _Idx);
+            }
+        };
+
+        struct _Traits_8 {
+            static uint8x8_t _Rev(const uint8x8_t _Val) noexcept {
+                return _Val;
+            }
+
+            static uint8x16_t _Rev(const uint8x16_t _Val) noexcept {
+                return vextq_u8(_Val, _Val, 8);
+            }
+        };
+
+        template <class _Traits, class _Ty>
+        __declspec(noalias) void __cdecl _Reverse_impl(void* _First, void* _Last) noexcept {
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 64) {
+                const void* _Stop_at      = _First;
+                constexpr size_t _Mask_32 = ~((static_cast<size_t>(1) << 5) - 1);
+                _Advance_bytes(_Stop_at, (_Length >> 1) & _Mask_32);
+                do {
+                    _Advance_bytes(_Last, -32);
+
+                    const uint8x16_t _Left1  = vld1q_u8(static_cast<uint8_t*>(_First) + 0);
+                    const uint8x16_t _Left2  = vld1q_u8(static_cast<uint8_t*>(_First) + 16);
+                    const uint8x16_t _Right1 = vld1q_u8(static_cast<uint8_t*>(_Last) + 0);
+                    const uint8x16_t _Right2 = vld1q_u8(static_cast<uint8_t*>(_Last) + 16);
+
+                    const uint8x16_t _Left1_reversed  = _Traits::_Rev(_Left1);
+                    const uint8x16_t _Left2_reversed  = _Traits::_Rev(_Left2);
+                    const uint8x16_t _Right1_reversed = _Traits::_Rev(_Right1);
+                    const uint8x16_t _Right2_reversed = _Traits::_Rev(_Right2);
+
+                    vst1q_u8(static_cast<uint8_t*>(_First) + 0, _Right2_reversed);
+                    vst1q_u8(static_cast<uint8_t*>(_First) + 16, _Right1_reversed);
+                    vst1q_u8(static_cast<uint8_t*>(_Last) + 0, _Left2_reversed);
+                    vst1q_u8(static_cast<uint8_t*>(_Last) + 16, _Left1_reversed);
+
+                    _Advance_bytes(_First, 32);
+                } while (_First != _Stop_at);
+            }
+
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 32) {
+                _Advance_bytes(_Last, -16);
+                const uint8x16_t _Left  = vld1q_u8(static_cast<uint8_t*>(_First));
+                const uint8x16_t _Right = vld1q_u8(static_cast<uint8_t*>(_Last));
+
+                const uint8x16_t _Left_reversed  = _Traits::_Rev(_Left);
+                const uint8x16_t _Right_reversed = _Traits::_Rev(_Right);
+
+                vst1q_u8(static_cast<uint8_t*>(_First), _Right_reversed);
+                vst1q_u8(static_cast<uint8_t*>(_Last), _Left_reversed);
+                _Advance_bytes(_First, 16);
+            }
+
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 16) {
+                _Advance_bytes(_Last, -8);
+                const uint8x8_t _Left  = vld1_u8(static_cast<uint8_t*>(_First));
+                const uint8x8_t _Right = vld1_u8(static_cast<uint8_t*>(_Last));
+
+                const uint8x8_t _Left_reversed  = _Traits::_Rev(_Left);
+                const uint8x8_t _Right_reversed = _Traits::_Rev(_Right);
+
+                vst1_u8(static_cast<uint8_t*>(_First), _Right_reversed);
+                vst1_u8(static_cast<uint8_t*>(_Last), _Left_reversed);
+                _Advance_bytes(_First, 8);
+            }
+
+            if constexpr (sizeof(_Ty) < 8) {
+                if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 8) {
+                    _Advance_bytes(_Last, -8);
+
+                    // Intentional overlapped loads/stores: read both sides first, then write.
+                    const uint8x8_t _Left  = vld1_u8(static_cast<uint8_t*>(_First));
+                    const uint8x8_t _Right = vld1_u8(static_cast<uint8_t*>(_Last));
+
+                    const uint8x8_t _Left_reversed  = _Traits::_Rev(_Left);
+                    const uint8x8_t _Right_reversed = _Traits::_Rev(_Right);
+
+                    vst1_u8(static_cast<uint8_t*>(_First), _Right_reversed);
+                    vst1_u8(static_cast<uint8_t*>(_Last), _Left_reversed);
+
+                    // Overlapped stores cover any 8-15B remainder, so do not fall through to scalar tail.
+                    return;
+                }
+            }
+
+            if constexpr (sizeof(_Ty) < 4) {
+                _Reverse_tail(static_cast<_Ty*>(_First), static_cast<_Ty*>(_Last));
+            }
+        }
+
+        template <class _Traits, class _Ty>
+        __declspec(noalias) void __cdecl _Reverse_copy_impl(
+            const void* _First, const void* _Last, void* _Dest) noexcept {
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 64) {
+                const void* _Stop_at      = _Dest;
+                constexpr size_t _Mask_64 = ~((static_cast<size_t>(1) << 6) - 1);
+                _Advance_bytes(_Stop_at, _Length & _Mask_64);
+                do {
+                    _Advance_bytes(_Last, -64);
+                    const uint8x16_t _Block1 = vld1q_u8(static_cast<const uint8_t*>(_Last) + 0);
+                    const uint8x16_t _Block2 = vld1q_u8(static_cast<const uint8_t*>(_Last) + 16);
+                    const uint8x16_t _Block3 = vld1q_u8(static_cast<const uint8_t*>(_Last) + 32);
+                    const uint8x16_t _Block4 = vld1q_u8(static_cast<const uint8_t*>(_Last) + 48);
+
+                    const uint8x16_t _Block1_reversed = _Traits::_Rev(_Block1);
+                    const uint8x16_t _Block2_reversed = _Traits::_Rev(_Block2);
+                    const uint8x16_t _Block3_reversed = _Traits::_Rev(_Block3);
+                    const uint8x16_t _Block4_reversed = _Traits::_Rev(_Block4);
+
+                    vst1q_u8(static_cast<uint8_t*>(_Dest) + 0, _Block4_reversed);
+                    vst1q_u8(static_cast<uint8_t*>(_Dest) + 16, _Block3_reversed);
+                    vst1q_u8(static_cast<uint8_t*>(_Dest) + 32, _Block2_reversed);
+                    vst1q_u8(static_cast<uint8_t*>(_Dest) + 48, _Block1_reversed);
+                    _Advance_bytes(_Dest, 64);
+                } while (_Dest != _Stop_at);
+            }
+
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 32) {
+                _Advance_bytes(_Last, -32);
+                const uint8x16_t _Block1 = vld1q_u8(static_cast<const uint8_t*>(_Last) + 0);
+                const uint8x16_t _Block2 = vld1q_u8(static_cast<const uint8_t*>(_Last) + 16);
+
+                const uint8x16_t _Block1_reversed = _Traits::_Rev(_Block1);
+                const uint8x16_t _Block2_reversed = _Traits::_Rev(_Block2);
+
+                vst1q_u8(static_cast<uint8_t*>(_Dest) + 0, _Block2_reversed);
+                vst1q_u8(static_cast<uint8_t*>(_Dest) + 16, _Block1_reversed);
+                _Advance_bytes(_Dest, 32);
+            }
+
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 16) {
+                _Advance_bytes(_Last, -16);
+                const uint8x16_t _Block          = vld1q_u8(static_cast<const uint8_t*>(_Last));
+                const uint8x16_t _Block_reversed = _Traits::_Rev(_Block);
+                vst1q_u8(static_cast<uint8_t*>(_Dest), _Block_reversed);
+                _Advance_bytes(_Dest, 16);
+            }
+
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 8) {
+                _Advance_bytes(_Last, -8);
+                const uint8x8_t _Block          = vld1_u8(static_cast<const uint8_t*>(_Last));
+                const uint8x8_t _Block_reversed = _Traits::_Rev(_Block);
+                vst1_u8(static_cast<uint8_t*>(_Dest), _Block_reversed);
+                _Advance_bytes(_Dest, 8);
+            }
+
+            if constexpr (sizeof(_Ty) < 8) {
+                _Reverse_copy_tail(
+                    static_cast<const _Ty*>(_First), static_cast<const _Ty*>(_Last), static_cast<_Ty*>(_Dest));
+            }
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_1 {
+            static __m256i _Rev_avx(const __m256i _Val) noexcept {
+                const __m256i _Reverse_char_lanes_avx = _mm256_set_epi8( //
+                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, //
+                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+
+                const __m256i _Perm = _mm256_permute4x64_epi64(_Val, _MM_SHUFFLE(1, 0, 3, 2));
+                return _mm256_shuffle_epi8(_Perm, _Reverse_char_lanes_avx);
+            }
+
+            static __m128i _Rev_sse(const __m128i _Val) noexcept {
+                const __m128i _Reverse_char_sse = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+                return _mm_shuffle_epi8(_Val, _Reverse_char_sse);
+            }
+        };
+
+        struct _Traits_2 {
+            static __m256i _Rev_avx(const __m256i _Val) noexcept {
+                const __m256i _Reverse_short_lanes_avx = _mm256_set_epi8( //
+                    1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14, //
+                    1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+
+                const __m256i _Perm = _mm256_permute4x64_epi64(_Val, _MM_SHUFFLE(1, 0, 3, 2));
+                return _mm256_shuffle_epi8(_Perm, _Reverse_short_lanes_avx);
+            }
+
+            static __m128i _Rev_sse(const __m128i _Val) noexcept {
+                const __m128i _Reverse_short_sse = _mm_set_epi8(1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+                return _mm_shuffle_epi8(_Val, _Reverse_short_sse);
+            }
+        };
+
+        struct _Traits_4 {
+            static __m256i _Rev_avx(const __m256i _Val) noexcept {
+                const __m256i _Shuf = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
+                return _mm256_permutevar8x32_epi32(_Val, _Shuf);
+            }
+
+            static __m128i _Rev_sse(const __m128i _Val) noexcept {
+                return _mm_shuffle_epi32(_Val, _MM_SHUFFLE(0, 1, 2, 3));
+            }
+        };
+
+        struct _Traits_8 {
+            static __m256i _Rev_avx(const __m256i _Val) noexcept {
+                return _mm256_permute4x64_epi64(_Val, _MM_SHUFFLE(0, 1, 2, 3));
+            }
+
+            static __m128i _Rev_sse(const __m128i _Val) noexcept {
+                return _mm_shuffle_epi32(_Val, _MM_SHUFFLE(1, 0, 3, 2));
+            }
+        };
+
+        __m256i _Avx2_rev_tail_mask_32(const size_t _Count_in_bytes) noexcept {
+            // _Count_in_bytes must be within [0, 32].
+            static constexpr unsigned int _Tail_masks[16] = {
+                0, 0, 0, 0, 0, 0, 0, 0, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u};
+            return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(
+                reinterpret_cast<const unsigned char*>(_Tail_masks) + _Count_in_bytes));
+        }
+
+        template <class _Traits, class _Ty>
+        __declspec(noalias) void __cdecl _Reverse_impl(void* _First, void* _Last) noexcept {
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 64 && _Use_avx2()) {
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, (_Length >> 1) & ~size_t{0x1F});
+                do {
+                    _Advance_bytes(_Last, -32);
+                    const __m256i _Left           = _mm256_loadu_si256(static_cast<__m256i*>(_First));
+                    const __m256i _Right          = _mm256_loadu_si256(static_cast<__m256i*>(_Last));
+                    const __m256i _Left_reversed  = _Traits::_Rev_avx(_Left);
+                    const __m256i _Right_reversed = _Traits::_Rev_avx(_Right);
+                    _mm256_storeu_si256(static_cast<__m256i*>(_First), _Right_reversed);
+                    _mm256_storeu_si256(static_cast<__m256i*>(_Last), _Left_reversed);
+                    _Advance_bytes(_First, 32);
+                } while (_First != _Stop_at);
+
+                _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+            }
+
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 32 && _Use_sse42()) {
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, (_Length >> 1) & ~size_t{0xF});
+                do {
+                    _Advance_bytes(_Last, -16);
+                    const __m128i _Left           = _mm_loadu_si128(static_cast<__m128i*>(_First));
+                    const __m128i _Right          = _mm_loadu_si128(static_cast<__m128i*>(_Last));
+                    const __m128i _Left_reversed  = _Traits::_Rev_sse(_Left);
+                    const __m128i _Right_reversed = _Traits::_Rev_sse(_Right);
+                    _mm_storeu_si128(static_cast<__m128i*>(_First), _Right_reversed);
+                    _mm_storeu_si128(static_cast<__m128i*>(_Last), _Left_reversed);
+                    _Advance_bytes(_First, 16);
+                } while (_First != _Stop_at);
+            }
+
+            _Reverse_tail(static_cast<_Ty*>(_First), static_cast<_Ty*>(_Last));
+        }
+
+        template <class _Traits, class _Ty>
+        __declspec(noalias) void __cdecl _Reverse_copy_impl(
+            const void* _First, const void* _Last, void* _Dest) noexcept {
+            if (const size_t _Length = _Byte_length(_First, _Last); _Length >= 32 && _Use_avx2()) {
+                const void* _Stop_at = _Dest;
+                _Advance_bytes(_Stop_at, _Length & ~size_t{0x1F});
+                do {
+                    _Advance_bytes(_Last, -32);
+                    const __m256i _Block          = _mm256_loadu_si256(static_cast<const __m256i*>(_Last));
+                    const __m256i _Block_reversed = _Traits::_Rev_avx(_Block);
+                    _mm256_storeu_si256(static_cast<__m256i*>(_Dest), _Block_reversed);
+                    _Advance_bytes(_Dest, 32);
+                } while (_Dest != _Stop_at);
+
+                if (const size_t _Avx_tail = _Length & 0x1C; _Avx_tail != 0) {
+                    _Advance_bytes(_Last, -32);
+                    const __m256i _Mask           = _Avx2_tail_mask_32(_Avx_tail);
+                    const __m256i _Rev_mask       = _Avx2_rev_tail_mask_32(_Avx_tail);
+                    const __m256i _Block          = _mm256_maskload_epi32(static_cast<const int*>(_Last), _Rev_mask);
+                    const __m256i _Block_reversed = _Traits::_Rev_avx(_Block);
+                    _mm256_maskstore_epi32(static_cast<int*>(_Dest), _Mask, _Block_reversed);
+                    if constexpr (sizeof(_Ty) < 4) {
+                        _Advance_bytes(_Dest, _Avx_tail);
+                        _Advance_bytes(_Last, 32 - _Avx_tail);
+                    }
+                }
+
+                _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return;
+                }
+            } else if (_Length >= 16 && _Use_sse42()) {
+                const void* _Stop_at = _Dest;
+                _Advance_bytes(_Stop_at, _Length & ~size_t{0xF});
+                do {
+                    _Advance_bytes(_Last, -16);
+                    const __m128i _Block          = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
+                    const __m128i _Block_reversed = _Traits::_Rev_sse(_Block);
+                    _mm_storeu_si128(static_cast<__m128i*>(_Dest), _Block_reversed);
+                    _Advance_bytes(_Dest, 16);
+                } while (_Dest != _Stop_at);
+            }
+
+            _Reverse_copy_tail(
+                static_cast<const _Ty*>(_First), static_cast<const _Ty*>(_Last), static_cast<_Ty*>(_Dest));
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+    } // namespace _Reversing
+} // unnamed namespace
+
+extern "C" {
+
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_1(void* _First, void* _Last) noexcept {
+    _Reversing::_Reverse_impl<_Reversing::_Traits_1, uint8_t>(_First, _Last);
+}
+
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_2(void* _First, void* _Last) noexcept {
+    _Reversing::_Reverse_impl<_Reversing::_Traits_2, uint16_t>(_First, _Last);
+}
+
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_4(void* _First, void* _Last) noexcept {
+    _Reversing::_Reverse_impl<_Reversing::_Traits_4, uint32_t>(_First, _Last);
+}
+
+__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_8(void* _First, void* _Last) noexcept {
+    _Reversing::_Reverse_impl<_Reversing::_Traits_8, uint64_t>(_First, _Last);
+}
+
+__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_1(
+    const void* _First, const void* _Last, void* _Dest) noexcept {
+    _Reversing::_Reverse_copy_impl<_Reversing::_Traits_1, uint8_t>(_First, _Last, _Dest);
+}
+
+__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_2(
+    const void* _First, const void* _Last, void* _Dest) noexcept {
+    _Reversing::_Reverse_copy_impl<_Reversing::_Traits_2, uint16_t>(_First, _Last, _Dest);
+}
+
+__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_4(
+    const void* _First, const void* _Last, void* _Dest) noexcept {
+    _Reversing::_Reverse_copy_impl<_Reversing::_Traits_4, uint32_t>(_First, _Last, _Dest);
+}
+
+__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_8(
+    const void* _First, const void* _Last, void* _Dest) noexcept {
+    _Reversing::_Reverse_copy_impl<_Reversing::_Traits_8, uint64_t>(_First, _Last, _Dest);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Sorting {
+        // The 'minmax' and 'minmax_element' algorithms first compare vectors against other vectors
+        // ("vertical" comparisons), then elements of the same vector ("horizontal" comparisons).
+        // For 'minmax' that's it.
+        //
+        // 'minmax_element' needs to track element positions, so it has a vector of integers that is incremented,
+        // and min/max indices vectors.
+        // Since small integer indices for small elements may overflow, we sometimes have to do the horizontal part
+        // more often than just once at the end.
+
+        enum _Min_max_mode {
+            _Mode_min  = 1 << 0,
+            _Mode_max  = 1 << 1,
+            _Mode_both = _Mode_min | _Mode_max,
+        };
+
+        template <class _Base>
+        struct _Traits_scalar : _Base {
+            static constexpr bool _Vectorized       = false;
+            static constexpr size_t _Tail_mask      = 0;
+            static constexpr bool _Has_unsigned_cmp = false;
+            using _Vec_t                            = void;
+        };
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_neon_base {
+            using _Guard                            = char;
+            static constexpr bool _Vectorized       = true;
+            static constexpr size_t _Vec_size       = 16;
+            static constexpr size_t _Vec_mask       = 0xF;
+            static constexpr size_t _Tail_mask      = 0;
+            static constexpr bool _Has_unsigned_cmp = true;
+
+            static void _Exit_vectorized() noexcept {}
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_sse_base {
+            using _Guard                            = char;
+            static constexpr bool _Vectorized       = true;
+            static constexpr size_t _Vec_size       = 16;
+            static constexpr size_t _Vec_mask       = 0xF;
+            static constexpr size_t _Tail_mask      = 0;
+            static constexpr bool _Has_unsigned_cmp = false;
+            using _Vec_t                            = __m128i;
+
+            static __m128i _Zero() noexcept {
+                return _mm_setzero_si128();
+            }
+
+            static __m128i _All_ones() noexcept {
+                return _mm_set1_epi8(static_cast<char>(0xFF));
+            }
+
+            static __m128i _Blend(const __m128i _Px1, const __m128i _Px2, const __m128i _Msk) noexcept {
+                return _mm_blendv_epi8(_Px1, _Px2, _Msk);
+            }
+
+            static unsigned long _Mask(const __m128i _Val) noexcept {
+                return _mm_movemask_epi8(_Val);
+            }
+
+            static void _Exit_vectorized() noexcept {}
+
+            static unsigned long _Get_first_h_pos(const unsigned long _Mask) noexcept {
+                unsigned long _H_pos;
+                // CodeQL [SM02313] _H_pos is always initialized: element exists, so _Mask != 0.
+                _BitScanForward(&_H_pos, _Mask);
+                return _H_pos;
+            }
+
+            static unsigned long _Get_last_h_pos(const unsigned long _Mask) noexcept {
+                unsigned long _H_pos;
+                // CodeQL [SM02313] _H_pos is always initialized: element exists, so _Mask != 0.
+                _BitScanReverse(&_H_pos, _Mask);
+                return _H_pos;
+            }
+        };
+
+        struct _Traits_avx_base {
+            using _Guard                            = _Zeroupper_on_exit;
+            static constexpr bool _Vectorized       = true;
+            static constexpr size_t _Vec_size       = 32;
+            static constexpr size_t _Vec_mask       = 0x1F;
+            static constexpr bool _Has_unsigned_cmp = false;
+
+            static __m256i _Zero() noexcept {
+                return _mm256_setzero_si256();
+            }
+
+            static __m256i _All_ones() noexcept {
+                return _mm256_set1_epi8(static_cast<char>(0xFF));
+            }
+
+            static __m256i _Blend(const __m256i _Px1, const __m256i _Px2, const __m256i _Msk) noexcept {
+                return _mm256_blendv_epi8(_Px1, _Px2, _Msk);
+            }
+
+            static unsigned long _Mask(const __m256i _Val) noexcept {
+                return _mm256_movemask_epi8(_Val);
+            }
+
+            static void _Exit_vectorized() noexcept {
+                _mm256_zeroupper();
+            }
+
+            static unsigned long _Get_first_h_pos(const unsigned long _Mask) noexcept {
+                return _tzcnt_u32(_Mask);
+            }
+
+            static unsigned long _Get_last_h_pos(const unsigned long _Mask) noexcept {
+                return 31 - _lzcnt_u32(_Mask);
+            }
+        };
+
+        struct _Traits_avx_i_base : _Traits_avx_base {
+            static constexpr size_t _Tail_mask = 0x1C;
+            using _Vec_t                       = __m256i;
+
+            static __m256i _Blendval(const __m256i _Px1, const __m256i _Px2, const __m256i _Msk) noexcept {
+                return _mm256_blendv_epi8(_Px1, _Px2, _Msk);
+            }
+
+            static __m256i _Load_mask(const void* const _Src, const __m256i _Mask) noexcept {
+                return _mm256_maskload_epi32(reinterpret_cast<const int*>(_Src), _Mask);
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        struct _Traits_1_base {
+            static constexpr bool _Is_floating = false;
+
+            using _Signed_t   = int8_t;
+            using _Unsigned_t = uint8_t;
+
+            static constexpr _Signed_t _Init_min_val = static_cast<_Signed_t>(0x7F);
+            static constexpr _Signed_t _Init_max_val = static_cast<_Signed_t>(0x80);
+
+            using _Minmax_i_t = _Min_max_1i;
+            using _Minmax_u_t = _Min_max_1u;
+
+            static constexpr bool _Has_portion_max = true;
+            static constexpr size_t _Portion_max   = 256;
+        };
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_1_neon : _Traits_1_base, _Traits_neon_base {
+            using _Vec_t = int8x16_t;
+
+            static _Vec_t _Sign_correction(const _Vec_t _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static _Vec_t _Zero() noexcept {
+                return vdupq_n_s8(0);
+            }
+
+            static _Vec_t _All_ones() noexcept {
+                return vdupq_n_s8(static_cast<int8_t>(0xFF));
+            }
+
+            static _Vec_t _Blend(const _Vec_t _Px1, const _Vec_t _Px2, const _Vec_t _Msk) noexcept {
+                return vbslq_s8(vreinterpretq_u8_s8(_Msk), _Px2, _Px1);
+            }
+
+            // Compresses a 128-bit Mask of 16 8-bit values into a 64-bit Mask of 16 4-bit values.
+            static uint64_t _Mask(const _Vec_t _Val) noexcept {
+                const uint8x8_t _Res = vshrn_n_u16(vreinterpretq_u16_s8(_Val), 4);
+                return vget_lane_u64(vreinterpret_u64_u8(_Res), 0);
+            }
+
+            static uint64_t _Match_mask(const _Vec_t _Val_lo, const _Vec_t _Val_hi) noexcept {
+                const uint64x2_t _Val = vreinterpretq_u64_s8(vorrq_s8(_Val_lo, _Val_hi));
+                return vgetq_lane_u64(vpaddq_u64(_Val, _Val), 0);
+            }
+
+            static unsigned long _Get_first_h_pos(const uint64_t _Mask) noexcept {
+                return _CountTrailingZeros64(_Mask) >> 2;
+            }
+
+            static unsigned long _Get_last_h_pos(const uint64_t _Mask) noexcept {
+                return 15 - (_CountLeadingZeros64(_Mask) >> 2);
+            }
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_s8(reinterpret_cast<const int8_t*>(_Src));
+            }
+
+            static _Vec_t _Inc(const _Vec_t _Idx) noexcept {
+                return vaddq_s8(_Idx, vdupq_n_s8(1));
+            }
+
+            static _Vec_t _H_min(const _Vec_t _Cur) noexcept {
+                return vdupq_n_s8(vminvq_s8(_Cur));
+            }
+
+            static _Vec_t _H_max(const _Vec_t _Cur) noexcept {
+                return vdupq_n_s8(vmaxvq_s8(_Cur));
+            }
+
+            static _Vec_t _H_min_u(const _Vec_t _Cur) noexcept {
+                const uint8_t _Mx = vminvq_u8(vreinterpretq_u8_s8(_Cur));
+                return vreinterpretq_s8_u8(vdupq_n_u8(_Mx));
+            }
+
+            static _Vec_t _H_max_u(const _Vec_t _Cur) noexcept {
+                const uint8_t _Mx = vmaxvq_u8(vreinterpretq_u8_s8(_Cur));
+                return vreinterpretq_s8_u8(vdupq_n_u8(_Mx));
+            }
+
+            static _Signed_t _Get_any(const _Vec_t _Cur) noexcept {
+                return static_cast<_Signed_t>(vgetq_lane_s8(_Cur, 0));
+            }
+
+            static _Unsigned_t _Get_v_pos(const _Vec_t _Cur) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Cur));
+            }
+
+            static _Vec_t _Cmp_eq(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s8_u8(vceqq_s8(_First, _Second));
+            }
+
+            static _Vec_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s8_u8(vcgtq_s8(_First, _Second));
+            }
+
+            static _Vec_t _Cmp_gt_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s8_u8(vcgtq_u8(vreinterpretq_u8_s8(_First), vreinterpretq_u8_s8(_Second)));
+            }
+
+            static _Vec_t _Cmp_eq_idx(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Cmp_eq(_First, _Second);
+            }
+
+            static _Vec_t _Min(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s8(0)) noexcept {
+                return vminq_s8(_First, _Second);
+            }
+
+            static _Vec_t _Max(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s8(0)) noexcept {
+                return vmaxq_s8(_First, _Second);
+            }
+
+            static _Vec_t _Min_u(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s8(0)) noexcept {
+                const uint8x16_t _Rx = vminq_u8(vreinterpretq_u8_s8(_First), vreinterpretq_u8_s8(_Second));
+                return vreinterpretq_s8_u8(_Rx);
+            }
+
+            static _Vec_t _Max_u(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s8(0)) noexcept {
+                const uint8x16_t _Rx = vmaxq_u8(vreinterpretq_u8_s8(_First), vreinterpretq_u8_s8(_Second));
+                return vreinterpretq_s8_u8(_Rx);
+            }
+
+            static _Vec_t _Mask_cast(const _Vec_t _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_1_sse : _Traits_1_base, _Traits_sse_base {
+            static __m128i _Load(const void* const _Src) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
+            }
+
+            static __m128i _Sign_correction(const __m128i _Val, const bool _Sign) noexcept {
+                alignas(16) static constexpr _Unsigned_t _Sign_corrections[2][16] = {
+                    {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80},
+                    {}};
+                return _mm_sub_epi8(_Val, _mm_load_si128(reinterpret_cast<const __m128i*>(_Sign_corrections[_Sign])));
+            }
+
+            static __m128i _Inc(const __m128i _Idx) noexcept {
+                return _mm_add_epi8(_Idx, _mm_set1_epi8(1));
+            }
+
+            template <class _Fn>
+            static __m128i _H_func(const __m128i _Cur, const _Fn _Funct) noexcept {
+                const __m128i _Shuf_b = _mm_set_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1);
+                const __m128i _Shuf_w = _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2);
+
+                __m128i _H_min_val = _Cur;
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_w));
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_b));
+                return _H_min_val;
+            }
+
+            static __m128i _H_min(const __m128i _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_min_epi8(_Val1, _Val2); });
+            }
+
+            static __m128i _H_max(const __m128i _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_max_epi8(_Val1, _Val2); });
+            }
+
+            static __m128i _H_min_u(const __m128i _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_min_epu8(_Val1, _Val2); });
+            }
+
+            static __m128i _H_max_u(const __m128i _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_max_epu8(_Val1, _Val2); });
+            }
+
+            static _Signed_t _Get_any(const __m128i _Cur) noexcept {
+                return static_cast<_Signed_t>(_mm_cvtsi128_si32(_Cur));
+            }
+
+            static _Unsigned_t _Get_v_pos(const __m128i _Idx) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Idx));
+            }
+
+            static __m128i _Cmp_eq(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi8(_First, _Second);
+            }
+
+            static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpgt_epi8(_First, _Second);
+            }
+
+            static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi8(_First, _Second);
+            }
+
+            static __m128i _Min(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
+                return _mm_min_epi8(_First, _Second);
+            }
+
+            static __m128i _Max(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
+                return _mm_max_epi8(_First, _Second);
+            }
+
+            static __m128i _Min_u(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_min_epu8(_First, _Second);
+            }
+
+            static __m128i _Max_u(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_max_epu8(_First, _Second);
+            }
+
+            static __m128i _Mask_cast(const __m128i _Mask) noexcept {
+                return _Mask;
+            }
+        };
+
+        struct _Traits_1_avx : _Traits_1_base, _Traits_avx_i_base {
+            static __m256i _Load(const void* const _Src) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+            }
+
+            static __m256i _Sign_correction(const __m256i _Val, const bool _Sign) noexcept {
+                alignas(32) static constexpr _Unsigned_t _Sign_corrections[2][32] = {
+                    {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+                        0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80},
+                    {}};
+                return _mm256_sub_epi8(
+                    _Val, _mm256_load_si256(reinterpret_cast<const __m256i*>(_Sign_corrections[_Sign])));
+            }
+
+            static __m256i _Inc(const __m256i _Idx) noexcept {
+                return _mm256_add_epi8(_Idx, _mm256_set1_epi8(1));
+            }
+
+            template <class _Fn>
+            static __m256i _H_func(const __m256i _Cur, const _Fn _Funct) noexcept {
+                const __m128i _Shuf_b = _mm_set_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1);
+                const __m128i _Shuf_w = _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2);
+
+                __m256i _H_min_val = _Cur;
+                _H_min_val         = _Funct(_H_min_val, _mm256_permute4x64_epi64(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
+                _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi8(_H_min_val, _mm256_broadcastsi128_si256(_Shuf_w)));
+                _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi8(_H_min_val, _mm256_broadcastsi128_si256(_Shuf_b)));
+                return _H_min_val;
+            }
+
+            static __m256i _H_min(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_min_epi8(_Val1, _Val2); });
+            }
+
+            static __m256i _H_max(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_max_epi8(_Val1, _Val2); });
+            }
+
+            static __m256i _H_min_u(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_min_epu8(_Val1, _Val2); });
+            }
+
+            static __m256i _H_max_u(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_max_epu8(_Val1, _Val2); });
+            }
+
+            static _Signed_t _Get_any(const __m256i _Cur) noexcept {
+                return static_cast<_Signed_t>(_mm256_cvtsi256_si32(_Cur));
+            }
+
+            static _Unsigned_t _Get_v_pos(const __m256i _Idx) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Idx));
+            }
+
+            static __m256i _Cmp_eq(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi8(_First, _Second);
+            }
+
+            static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpgt_epi8(_First, _Second);
+            }
+
+            static __m256i _Cmp_eq_idx(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi8(_First, _Second);
+            }
+
+            static __m256i _Min(
+                const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
+                return _mm256_min_epi8(_First, _Second);
+            }
+
+            static __m256i _Max(
+                const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
+                return _mm256_max_epi8(_First, _Second);
+            }
+
+            static __m256i _Min_u(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_min_epu8(_First, _Second);
+            }
+
+            static __m256i _Max_u(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_max_epu8(_First, _Second);
+            }
+
+            static __m256i _Mask_cast(const __m256i _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        struct _Traits_2_base {
+            static constexpr bool _Is_floating = false;
+
+            using _Signed_t   = int16_t;
+            using _Unsigned_t = uint16_t;
+
+            static constexpr _Signed_t _Init_min_val = static_cast<_Signed_t>(0x7FFF);
+            static constexpr _Signed_t _Init_max_val = static_cast<_Signed_t>(0x8000);
+
+            using _Minmax_i_t = _Min_max_2i;
+            using _Minmax_u_t = _Min_max_2u;
+
+            static constexpr bool _Has_portion_max = true;
+            static constexpr size_t _Portion_max   = 65536;
+        };
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_2_neon : _Traits_2_base, _Traits_neon_base {
+            using _Vec_t = int16x8_t;
+
+            static _Vec_t _Sign_correction(const _Vec_t _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static _Vec_t _Zero() noexcept {
+                return vdupq_n_s16(0);
+            }
+
+            static _Vec_t _All_ones() noexcept {
+                return vreinterpretq_s16_s8(vdupq_n_s8(static_cast<int8_t>(0xFF)));
+            }
+
+            static _Vec_t _Blend(const _Vec_t _Px1, const _Vec_t _Px2, const _Vec_t _Msk) noexcept {
+                return vbslq_s16(vreinterpretq_u16_s16(_Msk), _Px2, _Px1);
+            }
+
+            // Compresses a 128-bit Mask of 8 16-bit values into a 64-bit Mask of 8 8-bit values.
+            static uint64_t _Mask(const _Vec_t _Val) noexcept {
+                const uint16x4_t _Res = vshrn_n_u32(vreinterpretq_u32_s16(_Val), 8);
+                return vget_lane_u64(vreinterpret_u64_u16(_Res), 0);
+            }
+
+            static uint64_t _Match_mask(const _Vec_t _Val_lo, const _Vec_t _Val_hi) noexcept {
+                const int8x8_t _Val = vaddhn_s16(_Val_lo, _Val_hi);
+                return vget_lane_u64(vreinterpret_u64_s8(_Val), 0);
+            }
+
+            static unsigned long _Get_first_h_pos(const uint64_t _Mask) noexcept {
+                return _CountTrailingZeros64(_Mask) >> 2;
+            }
+
+            static unsigned long _Get_last_h_pos(const uint64_t _Mask) noexcept {
+                return 15 - (_CountLeadingZeros64(_Mask) >> 2);
+            }
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_s16(reinterpret_cast<const int16_t*>(_Src));
+            }
+
+            static _Vec_t _Inc(const _Vec_t _Idx) noexcept {
+                return vaddq_s16(_Idx, vdupq_n_s16(1));
+            }
+
+            static _Vec_t _H_min(const _Vec_t _Cur) noexcept {
+                return vdupq_n_s16(vminvq_s16(_Cur));
+            }
+
+            static _Vec_t _H_max(const _Vec_t _Cur) noexcept {
+                return vdupq_n_s16(vmaxvq_s16(_Cur));
+            }
+
+            static _Vec_t _H_min_u(const _Vec_t _Cur) noexcept {
+                const uint16_t _Mx = vminvq_u16(vreinterpretq_u16_s16(_Cur));
+                return vreinterpretq_s16_u16(vdupq_n_u16(_Mx));
+            }
+
+            static _Vec_t _H_max_u(const _Vec_t _Cur) noexcept {
+                const uint16_t _Mx = vmaxvq_u16(vreinterpretq_u16_s16(_Cur));
+                return vreinterpretq_s16_u16(vdupq_n_u16(_Mx));
+            }
+
+            static _Signed_t _Get_any(const _Vec_t _Cur) noexcept {
+                return static_cast<_Signed_t>(vgetq_lane_s16(_Cur, 0));
+            }
+
+            static _Unsigned_t _Get_v_pos(const _Vec_t _Cur) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Cur));
+            }
+
+            static _Vec_t _Cmp_eq(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s16_u16(vceqq_s16(_First, _Second));
+            }
+
+            static _Vec_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s16_u16(vcgtq_s16(_First, _Second));
+            }
+
+            static _Vec_t _Cmp_gt_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s16_u16(vcgtq_u16(vreinterpretq_u16_s16(_First), vreinterpretq_u16_s16(_Second)));
+            }
+
+            static _Vec_t _Cmp_eq_idx(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Cmp_eq(_First, _Second);
+            }
+
+            static _Vec_t _Min(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s16(0)) noexcept {
+                return vminq_s16(_First, _Second);
+            }
+
+            static _Vec_t _Max(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s16(0)) noexcept {
+                return vmaxq_s16(_First, _Second);
+            }
+
+            static _Vec_t _Min_u(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s16(0)) noexcept {
+                const uint16x8_t _Rx = vminq_u16(vreinterpretq_u16_s16(_First), vreinterpretq_u16_s16(_Second));
+                return vreinterpretq_s16_u16(_Rx);
+            }
+
+            static _Vec_t _Max_u(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s16(0)) noexcept {
+                const uint16x8_t _Rx = vmaxq_u16(vreinterpretq_u16_s16(_First), vreinterpretq_u16_s16(_Second));
+                return vreinterpretq_s16_u16(_Rx);
+            }
+
+            static _Vec_t _Mask_cast(const _Vec_t _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_2_sse : _Traits_2_base, _Traits_sse_base {
+            static __m128i _Load(const void* const _Src) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
+            }
+
+            static __m128i _Sign_correction(const __m128i _Val, const bool _Sign) noexcept {
+                alignas(16) static constexpr _Unsigned_t _Sign_corrections[2][8] = {
+                    0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, {}};
+                return _mm_sub_epi16(_Val, _mm_load_si128(reinterpret_cast<const __m128i*>(_Sign_corrections[_Sign])));
+            }
+
+            static __m128i _Inc(const __m128i _Idx) noexcept {
+                return _mm_add_epi16(_Idx, _mm_set1_epi16(1));
+            }
+
+            template <class _Fn>
+            static __m128i _H_func(const __m128i _Cur, const _Fn _Funct) noexcept {
+                const __m128i _Shuf_w = _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2);
+
+                __m128i _H_min_val = _Cur;
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_w));
+                return _H_min_val;
+            }
+
+            static __m128i _H_min(const __m128i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_min_epi16(_Val1, _Val2); });
+            }
+
+            static __m128i _H_max(const __m128i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_max_epi16(_Val1, _Val2); });
+            }
+
+            static __m128i _H_min_u(const __m128i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_min_epu16(_Val1, _Val2); });
+            }
+
+            static __m128i _H_max_u(const __m128i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_max_epu16(_Val1, _Val2); });
+            }
+
+            static _Signed_t _Get_any(const __m128i _Cur) noexcept {
+                return static_cast<_Signed_t>(_mm_cvtsi128_si32(_Cur));
+            }
+
+            static _Unsigned_t _Get_v_pos(const __m128i _Idx) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Idx));
+            }
+
+            static __m128i _Cmp_eq(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi16(_First, _Second);
+            }
+
+            static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpgt_epi16(_First, _Second);
+            }
+
+            static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi16(_First, _Second);
+            }
+
+            static __m128i _Min(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
+                return _mm_min_epi16(_First, _Second);
+            }
+
+            static __m128i _Max(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
+                return _mm_max_epi16(_First, _Second);
+            }
+
+            static __m128i _Min_u(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_min_epu16(_First, _Second);
+            }
+
+            static __m128i _Max_u(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_max_epu16(_First, _Second);
+            }
+
+            static __m128i _Mask_cast(const __m128i _Mask) noexcept {
+                return _Mask;
+            }
+        };
+
+        struct _Traits_2_avx : _Traits_2_base, _Traits_avx_i_base {
+            static __m256i _Load(const void* const _Src) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+            }
+
+            static __m256i _Sign_correction(const __m256i _Val, const bool _Sign) noexcept {
+                alignas(32) static constexpr _Unsigned_t _Sign_corrections[2][16] = {0x8000, 0x8000, 0x8000, 0x8000,
+                    0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, {}};
+                return _mm256_sub_epi16(
+                    _Val, _mm256_load_si256(reinterpret_cast<const __m256i*>(_Sign_corrections[_Sign])));
+            }
+
+            static __m256i _Inc(const __m256i _Idx) noexcept {
+                return _mm256_add_epi16(_Idx, _mm256_set1_epi16(1));
+            }
+
+            template <class _Fn>
+            static __m256i _H_func(const __m256i _Cur, const _Fn _Funct) noexcept {
+                const __m128i _Shuf_w = _mm_set_epi8(13, 12, 15, 14, 9, 8, 11, 10, 5, 4, 7, 6, 1, 0, 3, 2);
+
+                __m256i _H_min_val = _Cur;
+                _H_min_val         = _Funct(_H_min_val, _mm256_permute4x64_epi64(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
+                _H_min_val = _Funct(_H_min_val, _mm256_shuffle_epi8(_H_min_val, _mm256_broadcastsi128_si256(_Shuf_w)));
+                return _H_min_val;
+            }
+
+            static __m256i _H_min(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_min_epi16(_Val1, _Val2); });
+            }
+
+            static __m256i _H_max(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_max_epi16(_Val1, _Val2); });
+            }
+
+            static __m256i _H_min_u(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_min_epu16(_Val1, _Val2); });
+            }
+
+            static __m256i _H_max_u(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_max_epu16(_Val1, _Val2); });
+            }
+
+            static _Signed_t _Get_any(const __m256i _Cur) noexcept {
+                return static_cast<_Signed_t>(_mm256_cvtsi256_si32(_Cur));
+            }
+
+            static _Unsigned_t _Get_v_pos(const __m256i _Idx) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Idx));
+            }
+
+            static __m256i _Cmp_eq(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi16(_First, _Second);
+            }
+
+            static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpgt_epi16(_First, _Second);
+            }
+
+            static __m256i _Cmp_eq_idx(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi16(_First, _Second);
+            }
+
+            static __m256i _Min(
+                const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
+                return _mm256_min_epi16(_First, _Second);
+            }
+
+            static __m256i _Max(
+                const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
+                return _mm256_max_epi16(_First, _Second);
+            }
+
+            static __m256i _Min_u(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_min_epu16(_First, _Second);
+            }
+
+            static __m256i _Max_u(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_max_epu16(_First, _Second);
+            }
+
+            static __m256i _Mask_cast(const __m256i _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        struct _Traits_4_base {
+            static constexpr bool _Is_floating = false;
+
+            using _Signed_t   = int32_t;
+            using _Unsigned_t = uint32_t;
+
+            using _Minmax_i_t = _Min_max_4i;
+            using _Minmax_u_t = _Min_max_4u;
+
+            static constexpr _Signed_t _Init_min_val = static_cast<_Signed_t>(0x7FFF'FFFFUL);
+            static constexpr _Signed_t _Init_max_val = static_cast<_Signed_t>(0x8000'0000UL);
+
+#ifdef _WIN64
+            static constexpr bool _Has_portion_max = true;
+            static constexpr size_t _Portion_max   = 0x1'0000'0000ULL;
+#else // ^^^ 64-bit / 32-bit vvv
+            static constexpr bool _Has_portion_max = false;
+#endif // ^^^ 32-bit ^^^
+        };
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_4_neon : _Traits_4_base, _Traits_neon_base {
+            using _Vec_t = int32x4_t;
+
+            static _Vec_t _Sign_correction(const _Vec_t _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static _Vec_t _Zero() noexcept {
+                return vdupq_n_s32(0);
+            }
+
+            static _Vec_t _All_ones() noexcept {
+                return vreinterpretq_s32_s8(vdupq_n_s8(static_cast<int8_t>(0xFF)));
+            }
+
+            static _Vec_t _Blend(const _Vec_t _Px1, const _Vec_t _Px2, const _Vec_t _Msk) noexcept {
+                return vbslq_s32(vreinterpretq_u32_s32(_Msk), _Px2, _Px1);
+            }
+
+            // Compresses a 128-bit Mask of 4 32-bit values into a 64-bit Mask of 4 16-bit values.
+            static uint64_t _Mask(const int32x4_t _Val) noexcept {
+                const uint32x2_t _Res = vshrn_n_u64(vreinterpretq_u64_s32(_Val), 16);
+                return vget_lane_u64(vreinterpret_u64_u32(_Res), 0);
+            }
+
+            static uint64_t _Match_mask(const _Vec_t _Val_lo, const _Vec_t _Val_hi) noexcept {
+                const int8x8_t _Val = vaddhn_s16(vreinterpretq_s16_s32(_Val_lo), vreinterpretq_s16_s32(_Val_hi));
+                return vget_lane_u64(vreinterpret_u64_s8(_Val), 0);
+            }
+
+            static unsigned long _Get_first_h_pos(const uint64_t _Mask) noexcept {
+                return _CountTrailingZeros64(_Mask) >> 2;
+            }
+
+            static unsigned long _Get_last_h_pos(const uint64_t _Mask) noexcept {
+                return 15 - (_CountLeadingZeros64(_Mask) >> 2);
+            }
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_s32(reinterpret_cast<const int32_t*>(_Src));
+            }
+
+            static _Vec_t _Inc(const _Vec_t _Idx) noexcept {
+                return vaddq_s32(_Idx, vdupq_n_s32(1));
+            }
+
+            static _Vec_t _H_min(const _Vec_t _Cur) noexcept {
+                return vdupq_n_s32(vminvq_s32(_Cur));
+            }
+
+            static _Vec_t _H_max(const _Vec_t _Cur) noexcept {
+                return vdupq_n_s32(vmaxvq_s32(_Cur));
+            }
+
+            static _Vec_t _H_min_u(const _Vec_t _Cur) noexcept {
+                const uint32_t _Mx = vminvq_u32(vreinterpretq_u32_s32(_Cur));
+                return vreinterpretq_s32_u32(vdupq_n_u32(_Mx));
+            }
+
+            static _Vec_t _H_max_u(const _Vec_t _Cur) noexcept {
+                const uint32_t _Mx = vmaxvq_u32(vreinterpretq_u32_s32(_Cur));
+                return vreinterpretq_s32_u32(vdupq_n_u32(_Mx));
+            }
+
+            static _Signed_t _Get_any(const _Vec_t _Cur) noexcept {
+                return static_cast<_Signed_t>(vgetq_lane_s32(_Cur, 0));
+            }
+
+            static _Unsigned_t _Get_v_pos(const _Vec_t _Cur) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Cur));
+            }
+
+            static _Vec_t _Cmp_eq(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s32_u32(vceqq_s32(_First, _Second));
+            }
+
+            static _Vec_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s32_u32(vcgtq_s32(_First, _Second));
+            }
+
+            static _Vec_t _Cmp_gt_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s32_u32(vcgtq_u32(vreinterpretq_u32_s32(_First), vreinterpretq_u32_s32(_Second)));
+            }
+
+            static _Vec_t _Cmp_eq_idx(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Cmp_eq(_First, _Second);
+            }
+
+            static _Vec_t _Min(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s32(0)) noexcept {
+                return vminq_s32(_First, _Second);
+            }
+
+            static _Vec_t _Max(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s32(0)) noexcept {
+                return vmaxq_s32(_First, _Second);
+            }
+
+            static _Vec_t _Min_u(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s32(0)) noexcept {
+                const uint32x4_t _Rx = vminq_u32(vreinterpretq_u32_s32(_First), vreinterpretq_u32_s32(_Second));
+                return vreinterpretq_s32_u32(_Rx);
+            }
+
+            static _Vec_t _Max_u(const _Vec_t _First, const _Vec_t _Second, _Vec_t = vdupq_n_s32(0)) noexcept {
+                const uint32x4_t _Rx = vmaxq_u32(vreinterpretq_u32_s32(_First), vreinterpretq_u32_s32(_Second));
+                return vreinterpretq_s32_u32(_Rx);
+            }
+
+            static _Vec_t _Mask_cast(const _Vec_t _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_4_sse : _Traits_4_base, _Traits_sse_base {
+            static __m128i _Load(const void* const _Src) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
+            }
+
+            static __m128i _Sign_correction(const __m128i _Val, const bool _Sign) noexcept {
+                alignas(16) static constexpr _Unsigned_t _Sign_corrections[2][4] = {
+                    0x8000'0000UL, 0x8000'0000UL, 0x8000'0000UL, 0x8000'0000UL, {}};
+                return _mm_sub_epi32(_Val, _mm_load_si128(reinterpret_cast<const __m128i*>(_Sign_corrections[_Sign])));
+            }
+
+            static __m128i _Inc(const __m128i _Idx) noexcept {
+                return _mm_add_epi32(_Idx, _mm_set1_epi32(1));
+            }
+
+            template <class _Fn>
+            static __m128i _H_func(const __m128i _Cur, const _Fn _Funct) noexcept {
+                __m128i _H_min_val = _Cur;
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
+                return _H_min_val;
+            }
+
+            static __m128i _H_min(const __m128i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_min_epi32(_Val1, _Val2); });
+            }
+
+            static __m128i _H_max(const __m128i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_max_epi32(_Val1, _Val2); });
+            }
+
+            static __m128i _H_min_u(const __m128i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_min_epu32(_Val1, _Val2); });
+            }
+
+            static __m128i _H_max_u(const __m128i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m128i _Val1, const __m128i _Val2) noexcept { return _mm_max_epu32(_Val1, _Val2); });
+            }
+
+            static _Signed_t _Get_any(const __m128i _Cur) noexcept {
+                return static_cast<_Signed_t>(_mm_cvtsi128_si32(_Cur));
+            }
+
+            static _Unsigned_t _Get_v_pos(const __m128i _Idx) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Idx));
+            }
+
+            static __m128i _Cmp_eq(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi32(_First, _Second);
+            }
+
+            static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpgt_epi32(_First, _Second);
+            }
+
+            static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi32(_First, _Second);
+            }
+
+            static __m128i _Min(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
+                return _mm_min_epi32(_First, _Second);
+            }
+
+            static __m128i _Max(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
+                return _mm_max_epi32(_First, _Second);
+            }
+
+            static __m128i _Min_u(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_min_epu32(_First, _Second);
+            }
+
+            static __m128i _Max_u(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_max_epu32(_First, _Second);
+            }
+
+            static __m128i _Mask_cast(const __m128i _Mask) noexcept {
+                return _Mask;
+            }
+        };
+
+        struct _Traits_4_avx : _Traits_4_base, _Traits_avx_i_base {
+            static __m256i _Load(const void* const _Src) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+            }
+
+            static __m256i _Sign_correction(const __m256i _Val, const bool _Sign) noexcept {
+                alignas(32) static constexpr _Unsigned_t _Sign_corrections[2][8] = {0x8000'0000UL, 0x8000'0000UL,
+                    0x8000'0000UL, 0x8000'0000UL, 0x8000'0000UL, 0x8000'0000UL, 0x8000'0000UL, 0x8000'0000UL, {}};
+                return _mm256_sub_epi32(
+                    _Val, _mm256_load_si256(reinterpret_cast<const __m256i*>(_Sign_corrections[_Sign])));
+            }
+
+            static __m256i _Inc(const __m256i _Idx) noexcept {
+                return _mm256_add_epi32(_Idx, _mm256_set1_epi32(1));
+            }
+
+            template <class _Fn>
+            static __m256i _H_func(const __m256i _Cur, const _Fn _Funct) noexcept {
+                __m256i _H_min_val = _Cur;
+                _H_min_val         = _Funct(_H_min_val, _mm256_permute4x64_epi64(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
+                _H_min_val         = _Funct(_H_min_val, _mm256_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
+                return _H_min_val;
+            }
+
+            static __m256i _H_min(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_min_epi32(_Val1, _Val2); });
+            }
+
+            static __m256i _H_max(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_max_epi32(_Val1, _Val2); });
+            }
+
+            static __m256i _H_min_u(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_min_epu32(_Val1, _Val2); });
+            }
+
+            static __m256i _H_max_u(const __m256i _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256i _Val1, const __m256i _Val2) noexcept { return _mm256_max_epu32(_Val1, _Val2); });
+            }
+
+            static _Signed_t _Get_any(const __m256i _Cur) noexcept {
+                return static_cast<_Signed_t>(_mm256_cvtsi256_si32(_Cur));
+            }
+
+            static _Unsigned_t _Get_v_pos(const __m256i _Idx) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Idx));
+            }
+
+            static __m256i _Cmp_eq(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi32(_First, _Second);
+            }
+
+            static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpgt_epi32(_First, _Second);
+            }
+
+            static __m256i _Cmp_eq_idx(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi32(_First, _Second);
+            }
+
+            static __m256i _Min(
+                const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
+                return _mm256_min_epi32(_First, _Second);
+            }
+
+            static __m256i _Max(
+                const __m256i _First, const __m256i _Second, __m256i = _mm256_undefined_si256()) noexcept {
+                return _mm256_max_epi32(_First, _Second);
+            }
+
+            static __m256i _Min_u(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_min_epu32(_First, _Second);
+            }
+
+            static __m256i _Max_u(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_max_epu32(_First, _Second);
+            }
+
+            static __m256i _Mask_cast(const __m256i _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        struct _Traits_8_base {
+            static constexpr bool _Is_floating = false;
+
+            using _Signed_t   = int64_t;
+            using _Unsigned_t = uint64_t;
+
+            static constexpr _Signed_t _Init_min_val = static_cast<_Signed_t>(0x7FFF'FFFF'FFFF'FFFFULL);
+            static constexpr _Signed_t _Init_max_val = static_cast<_Signed_t>(0x8000'0000'0000'0000ULL);
+
+            using _Minmax_i_t = _Min_max_8i;
+            using _Minmax_u_t = _Min_max_8u;
+
+            static constexpr bool _Has_portion_max = false;
+        };
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_8_neon : _Traits_8_base, _Traits_neon_base {
+            using _Vec_t = int64x2_t;
+
+            static _Vec_t _Sign_correction(const _Vec_t _Val, bool) noexcept {
+                return _Val;
+            }
+
+            // Compresses a 128-bit Mask of 2 64-bit values into a 64-bit Mask of 2 32-bit values.
+            static uint64_t _Mask(const _Vec_t _Val) noexcept {
+                const uint32x2_t _Res = vreinterpret_u32_s32(vmovn_s64(_Val));
+                return vget_lane_u64(vreinterpret_u64_u32(_Res), 0);
+            }
+
+            static uint64_t _Match_mask(const _Vec_t _Val_lo, const _Vec_t _Val_hi) noexcept {
+                const int8x8_t _Val = vaddhn_s16(vreinterpretq_s16_s64(_Val_lo), vreinterpretq_s16_s64(_Val_hi));
+                return vget_lane_u64(vreinterpret_u64_s8(_Val), 0);
+            }
+
+            static unsigned long _Get_first_h_pos(const uint64_t _Mask) noexcept {
+                return _CountTrailingZeros64(_Mask) >> 2;
+            }
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_s64(reinterpret_cast<const int64_t*>(_Src));
+            }
+
+            static _Vec_t _H_min(const _Vec_t _Cur) noexcept {
+                const int64x2_t _Swapped  = vextq_s64(_Cur, _Cur, 1);
+                const uint64x2_t _Mask_lt = vcltq_s64(_Swapped, _Cur);
+                return vbslq_s64(_Mask_lt, _Swapped, _Cur);
+            }
+
+            static _Vec_t _H_max(const _Vec_t _Cur) noexcept {
+                const int64x2_t _Swapped  = vextq_s64(_Cur, _Cur, 1);
+                const uint64x2_t _Mask_gt = vcgtq_s64(_Swapped, _Cur);
+                return vbslq_s64(_Mask_gt, _Swapped, _Cur);
+            }
+
+            static _Vec_t _H_min_u(const _Vec_t _Cur) noexcept {
+                const uint64x2_t _Cur_u   = vreinterpretq_u64_s64(_Cur);
+                const uint64x2_t _Swapped = vextq_u64(_Cur_u, _Cur_u, 1);
+                const uint64x2_t _Mask_lt = vcltq_u64(_Swapped, _Cur_u);
+                return vreinterpretq_s64_u64(vbslq_u64(_Mask_lt, _Swapped, _Cur_u));
+            }
+
+            static _Vec_t _H_max_u(const _Vec_t _Cur) noexcept {
+                const uint64x2_t _Cur_u   = vreinterpretq_u64_s64(_Cur);
+                const uint64x2_t _Swapped = vextq_u64(_Cur_u, _Cur_u, 1);
+                const uint64x2_t _Mask_gt = vcgtq_u64(_Swapped, _Cur_u);
+                return vreinterpretq_s64_u64(vbslq_u64(_Mask_gt, _Swapped, _Cur_u));
+            }
+
+            static _Signed_t _Get_any(const _Vec_t _Cur) noexcept {
+                return static_cast<_Signed_t>(vgetq_lane_s64(_Cur, 0));
+            }
+
+            static _Vec_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s64_u64(vcgtq_s64(_First, _Second));
+            }
+
+            static _Vec_t _Cmp_gt_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s64_u64(vcgtq_u64(vreinterpretq_u64_s64(_First), vreinterpretq_u64_s64(_Second)));
+            }
+
+            static _Vec_t _Min(const _Vec_t _First, const _Vec_t _Second, const _Vec_t _Mask) noexcept {
+                return vbslq_s64(vreinterpretq_u64_s64(_Mask), _Second, _First);
+            }
+
+            static _Vec_t _Min(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Min(_First, _Second, _Cmp_gt(_First, _Second));
+            }
+
+            static _Vec_t _Min_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Min(_First, _Second, _Cmp_gt_u(_First, _Second));
+            }
+
+            static _Vec_t _Max(const _Vec_t _First, const _Vec_t _Second, const _Vec_t _Mask) noexcept {
+                return vbslq_s64(vreinterpretq_u64_s64(_Mask), _Second, _First);
+            }
+
+            static _Vec_t _Max(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Max(_First, _Second, _Cmp_gt(_Second, _First));
+            }
+
+            static _Vec_t _Max_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Max(_First, _Second, _Cmp_gt_u(_Second, _First));
+            }
+
+            static _Vec_t _Mask_cast(const _Vec_t _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_8_sse : _Traits_8_base, _Traits_sse_base {
+            static __m128i _Load(const void* const _Src) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
+            }
+
+            static __m128i _Sign_correction(const __m128i _Val, const bool _Sign) noexcept {
+                alignas(16) static constexpr _Unsigned_t _Sign_corrections[2][2] = {
+                    0x8000'0000'0000'0000ULL, 0x8000'0000'0000'0000ULL, {}};
+                return _mm_sub_epi64(_Val, _mm_load_si128(reinterpret_cast<const __m128i*>(_Sign_corrections[_Sign])));
+            }
+
+            static __m128i _Inc(const __m128i _Idx) noexcept {
+                return _mm_add_epi64(_Idx, _mm_set1_epi64x(1));
+            }
+
+            template <class _Fn>
+            static __m128i _H_func(const __m128i _Cur, const _Fn _Funct) noexcept {
+                _Signed_t _H_min_a       = _Get_any(_Cur);
+                const _Signed_t _H_min_b = _Get_any(_mm_bsrli_si128(_Cur, 8));
+                if (_Funct(_H_min_b, _H_min_a)) {
+                    _H_min_a = _H_min_b;
+                }
+                return _mm_set1_epi64x(_H_min_a);
+            }
+
+            static __m128i _H_min(const __m128i _Cur) noexcept {
+                return _H_func(_Cur, [](const _Signed_t _Lhs, const _Signed_t _Rhs) noexcept { return _Lhs < _Rhs; });
+            }
+
+            static __m128i _H_max(const __m128i _Cur) noexcept {
+                return _H_func(_Cur, [](const _Signed_t _Lhs, const _Signed_t _Rhs) noexcept { return _Lhs > _Rhs; });
+            }
+
+            static __m128i _H_min_u(const __m128i _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const _Unsigned_t _Lhs, const _Unsigned_t _Rhs) noexcept { return _Lhs < _Rhs; });
+            }
+
+            static __m128i _H_max_u(const __m128i _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const _Unsigned_t _Lhs, const _Unsigned_t _Rhs) noexcept { return _Lhs > _Rhs; });
+            }
+
+            static _Signed_t _Get_any(const __m128i _Cur) noexcept {
+                // With optimizations enabled, compiles into register movement, rather than an actual stack spill.
+                // Works around the absence of _mm_cvtsi128_si64 on 32-bit.
+                _Signed_t _Array[2];
+                _mm_storeu_si128(reinterpret_cast<__m128i*>(&_Array), _Cur);
+                return _Array[0];
+            }
+
+            static _Unsigned_t _Get_v_pos(const __m128i _Idx) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Idx));
+            }
+
+            static __m128i _Cmp_eq(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi64(_First, _Second);
+            }
+
+            static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpgt_epi64(_First, _Second);
+            }
+
+            static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi64(_First, _Second);
+            }
+
+            static __m128i _Min(const __m128i _First, const __m128i _Second, const __m128i _Mask) noexcept {
+                return _mm_blendv_epi8(_First, _Second, _Mask);
+            }
+
+            static __m128i _Max(const __m128i _First, const __m128i _Second, const __m128i _Mask) noexcept {
+                return _mm_blendv_epi8(_First, _Second, _Mask);
+            }
+
+            static __m128i _Min(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_blendv_epi8(_First, _Second, _Cmp_gt(_First, _Second));
+            }
+
+            static __m128i _Max(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_blendv_epi8(_First, _Second, _Cmp_gt(_Second, _First));
+            }
+
+            static __m128i _Mask_cast(const __m128i _Mask) noexcept {
+                return _Mask;
+            }
+        };
+
+        struct _Traits_8_avx : _Traits_8_base, _Traits_avx_i_base {
+            static __m256i _Load(const void* const _Src) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+            }
+
+            static __m256i _Sign_correction(const __m256i _Val, const bool _Sign) noexcept {
+                alignas(32) static constexpr _Unsigned_t _Sign_corrections[2][4] = {0x8000'0000'0000'0000ULL,
+                    0x8000'0000'0000'0000ULL, 0x8000'0000'0000'0000ULL, 0x8000'0000'0000'0000ULL, {}};
+                return _mm256_sub_epi64(
+                    _Val, _mm256_load_si256(reinterpret_cast<const __m256i*>(_Sign_corrections[_Sign])));
+            }
+
+            static __m256i _Inc(const __m256i _Idx) noexcept {
+                return _mm256_add_epi64(_Idx, _mm256_set1_epi64x(1));
+            }
+
+            template <class _Fn>
+            static __m256i _H_func(const __m256i _Cur, const _Fn _Funct) noexcept {
+                alignas(32) _Signed_t _Array[4];
+                _mm256_store_si256(reinterpret_cast<__m256i*>(_Array), _Cur);
+
+                _Signed_t _H_min_v = _Array[0];
+
+                if (_Funct(_Array[1], _H_min_v)) {
+                    _H_min_v = _Array[1];
+                }
+
+                if (_Funct(_Array[2], _H_min_v)) {
+                    _H_min_v = _Array[2];
+                }
+
+                if (_Funct(_Array[3], _H_min_v)) {
+                    _H_min_v = _Array[3];
+                }
+
+                return _mm256_set1_epi64x(_H_min_v);
+            }
+
+            static __m256i _H_min(const __m256i _Cur) noexcept {
+                return _H_func(_Cur, [](const _Signed_t _Lhs, const _Signed_t _Rhs) noexcept { return _Lhs < _Rhs; });
+            }
+
+            static __m256i _H_max(const __m256i _Cur) noexcept {
+                return _H_func(_Cur, [](const _Signed_t _Lhs, const _Signed_t _Rhs) noexcept { return _Lhs > _Rhs; });
+            }
+
+            static __m256i _H_min_u(const __m256i _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const _Unsigned_t _Lhs, const _Unsigned_t _Rhs) noexcept { return _Lhs < _Rhs; });
+            }
+
+            static __m256i _H_max_u(const __m256i _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const _Unsigned_t _Lhs, const _Unsigned_t _Rhs) noexcept { return _Lhs > _Rhs; });
+            }
+
+            static _Signed_t _Get_any(const __m256i _Cur) noexcept {
+                return _Traits_8_sse::_Get_any(_mm256_castsi256_si128(_Cur));
+            }
+
+            static _Unsigned_t _Get_v_pos(const __m256i _Idx) noexcept {
+                return static_cast<_Unsigned_t>(_Get_any(_Idx));
+            }
+
+            static __m256i _Cmp_eq(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi64(_First, _Second);
+            }
+
+            static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpgt_epi64(_First, _Second);
+            }
+
+            static __m256i _Cmp_eq_idx(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi64(_First, _Second);
+            }
+
+            static __m256i _Min(const __m256i _First, const __m256i _Second, const __m256i _Mask) noexcept {
+                return _mm256_blendv_epi8(_First, _Second, _Mask);
+            }
+
+            static __m256i _Max(const __m256i _First, const __m256i _Second, const __m256i _Mask) noexcept {
+                return _mm256_blendv_epi8(_First, _Second, _Mask);
+            }
+
+            static __m256i _Min(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_blendv_epi8(_First, _Second, _Cmp_gt(_First, _Second));
+            }
+
+            static __m256i _Max(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_blendv_epi8(_First, _Second, _Cmp_gt(_Second, _First));
+            }
+
+            static __m256i _Mask_cast(const __m256i _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        struct _Traits_f_base {
+            static constexpr bool _Is_floating = true;
+
+            using _Signed_t   = float;
+            using _Unsigned_t = void;
+
+            static constexpr _Signed_t _Init_min_val = __builtin_huge_valf();
+            static constexpr _Signed_t _Init_max_val = -__builtin_huge_valf();
+
+            using _Minmax_i_t = _Min_max_f;
+            using _Minmax_u_t = void;
+
+#ifdef _WIN64
+            static constexpr bool _Has_portion_max = true;
+            static constexpr size_t _Portion_max   = 0x1'0000'0000ULL;
+#else // ^^^ 64-bit / 32-bit vvv
+            static constexpr bool _Has_portion_max = false;
+#endif // ^^^ 32-bit ^^^
+        };
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_f_neon : _Traits_f_base, _Traits_neon_base {
+            using _Vec_t                            = float32x4_t;
+            using _Idx_t                            = int32x4_t;
+            static constexpr bool _Has_unsigned_cmp = false;
+
+            static _Vec_t _Sign_correction(const _Vec_t _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static _Idx_t _Zero() noexcept {
+                return vdupq_n_s32(0);
+            }
+
+            static _Idx_t _All_ones() noexcept {
+                return vreinterpretq_s32_s8(vdupq_n_s8(static_cast<int8_t>(0xFF)));
+            }
+
+            static _Idx_t _Blend(const _Idx_t _Px1, const _Idx_t _Px2, const _Idx_t _Msk) noexcept {
+                return vbslq_s32(vreinterpretq_u32_s32(_Msk), _Px2, _Px1);
+            }
+
+            static uint64_t _Mask(const _Idx_t _Val) noexcept {
+                return _Traits_4_neon::_Mask(_Val);
+            }
+
+            static uint64_t _Match_mask(const _Idx_t _Val_lo, const _Idx_t _Val_hi) noexcept {
+                return _Traits_4_neon::_Match_mask(_Val_lo, _Val_hi);
+            }
+
+            static unsigned long _Get_first_h_pos(const uint64_t _Mask) noexcept {
+                return _Traits_4_neon::_Get_first_h_pos(_Mask);
+            }
+
+            static unsigned long _Get_last_h_pos(const uint64_t _Mask) noexcept {
+                return _Traits_4_neon::_Get_last_h_pos(_Mask);
+            }
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_f32(reinterpret_cast<const float32_t*>(_Src));
+            }
+
+            static _Idx_t _Inc(const _Idx_t _Idx) noexcept {
+                return _Traits_4_neon::_Inc(_Idx);
+            }
+
+            static _Vec_t _H_min(const _Vec_t _Cur) noexcept {
+                return vdupq_n_f32(vminvq_f32(_Cur));
+            }
+
+            static _Vec_t _H_max(const _Vec_t _Cur) noexcept {
+                return vdupq_n_f32(vmaxvq_f32(_Cur));
+            }
+
+            static _Idx_t _H_min_u(const _Idx_t _Cur) noexcept {
+                return _Traits_4_neon::_H_min_u(_Cur);
+            }
+
+            static _Idx_t _H_max_u(const _Idx_t _Cur) noexcept {
+                return _Traits_4_neon::_H_max_u(_Cur);
+            }
+
+            static float _Get_any(const _Vec_t _Cur) noexcept {
+                return vgetq_lane_f32(_Cur, 0);
+            }
+
+            static _Traits_4_neon::_Unsigned_t _Get_v_pos(const _Idx_t _Cur) noexcept {
+                return _Traits_4_neon::_Get_v_pos(_Cur);
+            }
+
+            static _Idx_t _Cmp_eq(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s32_u32(vceqq_f32(_First, _Second));
+            }
+
+            static _Idx_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s32_u32(vcgtq_f32(_First, _Second));
+            }
+
+            static _Idx_t _Cmp_eq_idx(const _Idx_t _First, const _Idx_t _Second) noexcept {
+                return _Traits_4_neon::_Cmp_eq_idx(_First, _Second);
+            }
+
+            static _Vec_t _Min(const _Vec_t _First, const _Vec_t _Second, _Idx_t = vdupq_n_s32(0)) noexcept {
+                return vminq_f32(_First, _Second);
+            }
+
+            static _Vec_t _Max(const _Vec_t _First, const _Vec_t _Second, _Idx_t = vdupq_n_s32(0)) noexcept {
+                return vmaxq_f32(_First, _Second);
+            }
+
+            static _Idx_t _Mask_cast(const _Idx_t _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_f_sse : _Traits_f_base, _Traits_sse_base {
+            using _Vec_t = __m128;
+
+            static __m128 _Load(const void* const _Src) noexcept {
+                return _mm_loadu_ps(reinterpret_cast<const float*>(_Src));
+            }
+
+            static __m128 _Sign_correction(const __m128 _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static __m128i _Inc(const __m128i _Idx) noexcept {
+                return _mm_add_epi32(_Idx, _mm_set1_epi32(1));
+            }
+
+            template <class _Fn>
+            static __m128 _H_func(const __m128 _Cur, const _Fn _Funct) noexcept {
+                __m128 _H_min_val = _Cur;
+                _H_min_val        = _Funct(_mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)), _H_min_val);
+                _H_min_val        = _Funct(_mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);
+                return _H_min_val;
+            }
+
+            static __m128 _H_min(const __m128 _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m128 _Val1, const __m128 _Val2) noexcept { return _mm_min_ps(_Val1, _Val2); });
+            }
+
+            static __m128 _H_max(const __m128 _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m128 _Val1, const __m128 _Val2) noexcept { return _mm_max_ps(_Val1, _Val2); });
+            }
+
+            static __m128i _H_min_u(const __m128i _Cur) noexcept {
+                return _Traits_4_sse::_H_min_u(_Cur);
+            }
+
+            static __m128i _H_max_u(const __m128i _Cur) noexcept {
+                return _Traits_4_sse::_H_max_u(_Cur);
+            }
+
+            static float _Get_any(const __m128 _Cur) noexcept {
+                return _mm_cvtss_f32(_Cur);
+            }
+
+            static uint32_t _Get_v_pos(const __m128i _Idx) noexcept {
+                return _Traits_4_sse::_Get_v_pos(_Idx);
+            }
+
+            static __m128 _Cmp_eq(const __m128 _First, const __m128 _Second) noexcept {
+                return _mm_cmpeq_ps(_First, _Second);
+            }
+
+            static __m128 _Cmp_gt(const __m128 _First, const __m128 _Second) noexcept {
+                return _mm_cmpgt_ps(_First, _Second);
+            }
+
+            static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi32(_First, _Second);
+            }
+
+            static __m128 _Min(const __m128 _First, const __m128 _Second, __m128 = _mm_undefined_ps()) noexcept {
+                return _mm_min_ps(_Second, _First);
+            }
+
+            static __m128 _Max(const __m128 _First, const __m128 _Second, __m128 = _mm_undefined_ps()) noexcept {
+                return _mm_max_ps(_Second, _First);
+            }
+
+            static __m128i _Mask_cast(const __m128 _Mask) noexcept {
+                return _mm_castps_si128(_Mask);
+            }
+        };
+
+        struct _Traits_f_avx : _Traits_f_base, _Traits_avx_base {
+            static constexpr size_t _Tail_mask = 0x1C;
+            using _Vec_t                       = __m256;
+
+            static __m256 _Blendval(const __m256 _Px1, const __m256 _Px2, const __m256i _Msk) noexcept {
+                return _mm256_blendv_ps(_Px1, _Px2, _mm256_castsi256_ps(_Msk));
+            }
+
+            static __m256 _Load(const void* const _Src) noexcept {
+                return _mm256_loadu_ps(reinterpret_cast<const float*>(_Src));
+            }
+
+            static __m256 _Load_mask(const void* const _Src, const __m256i _Mask) noexcept {
+                return _mm256_maskload_ps(reinterpret_cast<const float*>(_Src), _Mask);
+            }
+
+            static __m256 _Sign_correction(const __m256 _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static __m256i _Inc(const __m256i _Idx) noexcept {
+                return _mm256_add_epi32(_Idx, _mm256_set1_epi32(1));
+            }
+
+            template <class _Fn>
+            static __m256 _H_func(const __m256 _Cur, const _Fn _Funct) noexcept {
+                __m256 _H_min_val = _Cur;
+                _H_min_val = _Funct(_mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)), _H_min_val);
+                _H_min_val = _Funct(_mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);
+                _H_min_val = _Funct(_mm256_permute2f128_ps(_H_min_val, _mm256_undefined_ps(), 0x01), _H_min_val);
+                return _H_min_val;
+            }
+
+            static __m256 _H_min(const __m256 _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m256 _Val1, const __m256 _Val2) noexcept { return _mm256_min_ps(_Val1, _Val2); });
+            }
+
+            static __m256 _H_max(const __m256 _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m256 _Val1, const __m256 _Val2) noexcept { return _mm256_max_ps(_Val1, _Val2); });
+            }
+
+            static __m256i _H_min_u(const __m256i _Cur) noexcept {
+                return _Traits_4_avx::_H_min_u(_Cur);
+            }
+
+            static __m256i _H_max_u(const __m256i _Cur) noexcept {
+                return _Traits_4_avx::_H_max_u(_Cur);
+            }
+
+            static float _Get_any(const __m256 _Cur) noexcept {
+                return _mm256_cvtss_f32(_Cur);
+            }
+
+            static uint32_t _Get_v_pos(const __m256i _Idx) noexcept {
+                return _Traits_4_avx::_Get_v_pos(_Idx);
+            }
+
+            static __m256 _Cmp_eq(const __m256 _First, const __m256 _Second) noexcept {
+                return _mm256_cmp_ps(_First, _Second, _CMP_EQ_OQ);
+            }
+
+            static __m256 _Cmp_gt(const __m256 _First, const __m256 _Second) noexcept {
+                return _mm256_cmp_ps(_First, _Second, _CMP_GT_OQ);
+            }
+
+            static __m256i _Cmp_eq_idx(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi32(_First, _Second);
+            }
+
+            static __m256 _Min(const __m256 _First, const __m256 _Second, __m256 = _mm256_undefined_ps()) noexcept {
+                return _mm256_min_ps(_Second, _First);
+            }
+
+            static __m256 _Max(const __m256 _First, const __m256 _Second, __m256 = _mm256_undefined_ps()) noexcept {
+                return _mm256_max_ps(_Second, _First);
+            }
+
+            static __m256i _Mask_cast(const __m256 _Mask) noexcept {
+                return _mm256_castps_si256(_Mask);
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        struct _Traits_d_base {
+            static constexpr bool _Is_floating = true;
+
+            using _Signed_t   = double;
+            using _Unsigned_t = void;
+
+            static constexpr _Signed_t _Init_min_val = __builtin_huge_val();
+            static constexpr _Signed_t _Init_max_val = -__builtin_huge_val();
+
+            using _Minmax_i_t = _Min_max_d;
+            using _Minmax_u_t = void;
+
+            static constexpr bool _Has_portion_max = false;
+        };
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_d_neon : _Traits_d_base, _Traits_neon_base {
+            using _Vec_t                            = float64x2_t;
+            using _Idx_t                            = int64x2_t;
+            static constexpr bool _Has_unsigned_cmp = false;
+
+            static _Vec_t _Sign_correction(const _Vec_t _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static _Idx_t _Zero() noexcept {
+                return vdupq_n_s64(0);
+            }
+
+            static _Idx_t _All_ones() noexcept {
+                return vreinterpretq_s64_s8(vdupq_n_s8(static_cast<int8_t>(0xFF)));
+            }
+
+            static _Idx_t _Blend(const _Idx_t _Px1, const _Idx_t _Px2, const _Idx_t _Msk) noexcept {
+                return vbslq_s64(vreinterpretq_u64_s64(_Msk), _Px2, _Px1);
+            }
+
+            // Compresses a 128-bit Mask of 2 64-bit values into a 64-bit Mask of 2 32-bit values.
+            static uint64_t _Mask(const int64x2_t _Val) noexcept {
+                return _Traits_8_neon::_Mask(_Val);
+            }
+
+            static uint64_t _Match_mask(const _Idx_t _Val_lo, const _Idx_t _Val_hi) noexcept {
+                return _Traits_8_neon::_Match_mask(_Val_lo, _Val_hi);
+            }
+
+            static unsigned long _Get_first_h_pos(const uint64_t _Mask) noexcept {
+                return _Traits_8_neon::_Get_first_h_pos(_Mask);
+            }
+
+            static unsigned long _Get_last_h_pos(const uint64_t _Mask) noexcept {
+                return 15 - (_CountLeadingZeros64(_Mask) >> 2);
+            }
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_f64(reinterpret_cast<const float64_t*>(_Src));
+            }
+
+            static _Idx_t _Inc(const _Idx_t _Idx) noexcept {
+                return vaddq_s64(_Idx, vdupq_n_s64(1));
+            }
+
+            static _Vec_t _H_min(const _Vec_t _Cur) noexcept {
+                return vdupq_n_f64(vminvq_f64(_Cur));
+            }
+
+            static _Vec_t _H_max(const _Vec_t _Cur) noexcept {
+                return vdupq_n_f64(vmaxvq_f64(_Cur));
+            }
+
+            static _Idx_t _H_min_u(const _Idx_t _Cur) noexcept {
+                return _Traits_8_neon::_H_min_u(_Cur);
+            }
+
+            static _Idx_t _H_max_u(const _Idx_t _Cur) noexcept {
+                return _Traits_8_neon::_H_max_u(_Cur);
+            }
+
+            static double _Get_any(const _Vec_t _Cur) noexcept {
+                return vgetq_lane_f64(_Cur, 0);
+            }
+
+            static _Traits_8_base::_Unsigned_t _Get_v_pos(const _Idx_t _Cur) noexcept {
+                return static_cast<_Traits_8_base::_Unsigned_t>(vgetq_lane_s64(_Cur, 0));
+            }
+
+            static _Idx_t _Cmp_eq(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s64_u64(vceqq_f64(_First, _Second));
+            }
+
+            static _Idx_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return vreinterpretq_s64_u64(vcgtq_f64(_First, _Second));
+            }
+
+            static _Idx_t _Cmp_eq_idx(const _Idx_t _First, const _Idx_t _Second) noexcept {
+                return vreinterpretq_s64_u64(vceqq_s64(_First, _Second));
+            }
+
+            static _Vec_t _Min(const _Vec_t _First, const _Vec_t _Second, _Idx_t = vdupq_n_s64(0)) noexcept {
+                return vminq_f64(_First, _Second);
+            }
+
+            static _Vec_t _Max(const _Vec_t _First, const _Vec_t _Second, _Idx_t = vdupq_n_s64(0)) noexcept {
+                return vmaxq_f64(_First, _Second);
+            }
+
+            static _Idx_t _Mask_cast(const _Idx_t _Mask) noexcept {
+                return _Mask;
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_d_sse : _Traits_d_base, _Traits_sse_base {
+            using _Vec_t = __m128d;
+
+            static __m128d _Load(const void* const _Src) noexcept {
+                return _mm_loadu_pd(reinterpret_cast<const double*>(_Src));
+            }
+
+            static __m128d _Sign_correction(const __m128d _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static __m128i _Inc(const __m128i _Idx) noexcept {
+                return _mm_add_epi64(_Idx, _mm_set1_epi64x(1));
+            }
+
+            template <class _Fn>
+            static __m128d _H_func(const __m128d _Cur, const _Fn _Funct) noexcept {
+                __m128d _H_min_val = _Cur;
+                _H_min_val         = _Funct(_mm_shuffle_pd(_H_min_val, _H_min_val, 1), _H_min_val);
+                return _H_min_val;
+            }
+
+            static __m128d _H_min(const __m128d _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m128d _Val1, const __m128d _Val2) noexcept { return _mm_min_pd(_Val1, _Val2); });
+            }
+
+            static __m128d _H_max(const __m128d _Cur) noexcept {
+                return _H_func(
+                    _Cur, [](const __m128d _Val1, const __m128d _Val2) noexcept { return _mm_max_pd(_Val1, _Val2); });
+            }
+
+            static __m128i _H_min_u(const __m128i _Cur) noexcept {
+                return _Traits_8_sse::_H_min_u(_Cur);
+            }
+
+            static __m128i _H_max_u(const __m128i _Cur) noexcept {
+                return _Traits_8_sse::_H_max_u(_Cur);
+            }
+            static double _Get_any(const __m128d _Cur) noexcept {
+                return _mm_cvtsd_f64(_Cur);
+            }
+
+            static uint64_t _Get_v_pos(const __m128i _Idx) noexcept {
+                return _Traits_8_sse::_Get_v_pos(_Idx);
+            }
+
+            static __m128d _Cmp_eq(const __m128d _First, const __m128d _Second) noexcept {
+                return _mm_cmpeq_pd(_First, _Second);
+            }
+
+            static __m128d _Cmp_gt(const __m128d _First, const __m128d _Second) noexcept {
+                return _mm_cmpgt_pd(_First, _Second);
+            }
+
+            static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpeq_epi64(_First, _Second);
+            }
+
+            static __m128d _Min(const __m128d _First, const __m128d _Second, __m128d = _mm_undefined_pd()) noexcept {
+                return _mm_min_pd(_Second, _First);
+            }
+
+            static __m128d _Max(const __m128d _First, const __m128d _Second, __m128d = _mm_undefined_pd()) noexcept {
+                return _mm_max_pd(_Second, _First);
+            }
+
+            static __m128i _Mask_cast(const __m128d _Mask) noexcept {
+                return _mm_castpd_si128(_Mask);
+            }
+        };
+
+        struct _Traits_d_avx : _Traits_d_base, _Traits_avx_base {
+            static constexpr size_t _Tail_mask = 0x18;
+            using _Vec_t                       = __m256d;
+
+            static __m256d _Blendval(const __m256d _Px1, const __m256d _Px2, const __m256i _Msk) noexcept {
+                return _mm256_blendv_pd(_Px1, _Px2, _mm256_castsi256_pd(_Msk));
+            }
+
+            static __m256d _Load(const void* const _Src) noexcept {
+                return _mm256_loadu_pd(reinterpret_cast<const double*>(_Src));
+            }
+
+            static __m256d _Load_mask(const void* const _Src, const __m256i _Mask) noexcept {
+                return _mm256_maskload_pd(reinterpret_cast<const double*>(_Src), _Mask);
+            }
+
+            static __m256d _Sign_correction(const __m256d _Val, bool) noexcept {
+                return _Val;
+            }
+
+            static __m256i _Inc(const __m256i _Idx) noexcept {
+                return _mm256_add_epi64(_Idx, _mm256_set1_epi64x(1));
+            }
+
+            template <class _Fn>
+            static __m256d _H_func(const __m256d _Cur, const _Fn _Funct) noexcept {
+                __m256d _H_min_val = _Cur;
+                _H_min_val         = _Funct(_mm256_shuffle_pd(_H_min_val, _H_min_val, 0b0101), _H_min_val);
+                _H_min_val         = _Funct(_mm256_permute4x64_pd(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);
+                return _H_min_val;
+            }
+
+            static __m256d _H_min(const __m256d _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256d _Val1, const __m256d _Val2) noexcept { return _mm256_min_pd(_Val1, _Val2); });
+            }
+
+            static __m256d _H_max(const __m256d _Cur) noexcept {
+                return _H_func(_Cur,
+                    [](const __m256d _Val1, const __m256d _Val2) noexcept { return _mm256_max_pd(_Val1, _Val2); });
+            }
+
+            static __m256i _H_min_u(const __m256i _Cur) noexcept {
+                return _Traits_8_avx::_H_min_u(_Cur);
+            }
+
+            static __m256i _H_max_u(const __m256i _Cur) noexcept {
+                return _Traits_8_avx::_H_max_u(_Cur);
+            }
+
+            static double _Get_any(const __m256d _Cur) noexcept {
+                return _mm256_cvtsd_f64(_Cur);
+            }
+
+            static uint64_t _Get_v_pos(const __m256i _Idx) noexcept {
+                return _Traits_8_avx::_Get_v_pos(_Idx);
+            }
+
+            static __m256d _Cmp_eq(const __m256d _First, const __m256d _Second) noexcept {
+                return _mm256_cmp_pd(_First, _Second, _CMP_EQ_OQ);
+            }
+
+            static __m256d _Cmp_gt(const __m256d _First, const __m256d _Second) noexcept {
+                return _mm256_cmp_pd(_First, _Second, _CMP_GT_OQ);
+            }
+
+            static __m256i _Cmp_eq_idx(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpeq_epi64(_First, _Second);
+            }
+
+            static __m256d _Min(const __m256d _First, const __m256d _Second, __m256d = _mm256_undefined_pd()) noexcept {
+                return _mm256_min_pd(_Second, _First);
+            }
+
+            static __m256d _Max(const __m256d _First, const __m256d _Second, __m256d = _mm256_undefined_pd()) noexcept {
+                return _mm256_max_pd(_Second, _First);
+            }
+
+            static __m256i _Mask_cast(const __m256d _Mask) noexcept {
+                return _mm256_castpd_si256(_Mask);
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        struct _Traits_1 {
+            using _Scalar = _Traits_scalar<_Traits_1_base>;
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_1_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_1_sse;
+            using _Avx = _Traits_1_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        struct _Traits_2 {
+            using _Scalar = _Traits_scalar<_Traits_2_base>;
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_2_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_2_sse;
+            using _Avx = _Traits_2_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        struct _Traits_4 {
+            using _Scalar = _Traits_scalar<_Traits_4_base>;
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_4_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_4_sse;
+            using _Avx = _Traits_4_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        struct _Traits_8 {
+            using _Scalar = _Traits_scalar<_Traits_8_base>;
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_8_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_8_sse;
+            using _Avx = _Traits_8_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        struct _Traits_f {
+            using _Scalar = _Traits_scalar<_Traits_f_base>;
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_f_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_f_sse;
+            using _Avx = _Traits_f_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        struct _Traits_d {
+            using _Scalar = _Traits_scalar<_Traits_d_base>;
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_d_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_d_sse;
+            using _Avx = _Traits_d_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        template <class _Ty>
+        const void* _Min_tail(const void* const _First, const void* const _Last, const void* _Res, _Ty _Cur) noexcept {
+            for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
+                if (*_Ptr < _Cur) {
+                    _Res = _Ptr;
+                    _Cur = *_Ptr;
+                }
+            }
+
+            return _Res;
+        }
+
+        template <class _Ty>
+        const void* _Max_tail(const void* const _First, const void* const _Last, const void* _Res, _Ty _Cur) noexcept {
+            for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
+                if (_Cur < *_Ptr) {
+                    _Res = _Ptr;
+                    _Cur = *_Ptr;
+                }
+            }
+
+            return _Res;
+        }
+
+        template <class _Ty>
+        _Min_max_element_t _Both_tail(const void* const _First, const void* const _Last, _Min_max_element_t& _Res,
+            _Ty _Cur_min, _Ty _Cur_max) noexcept {
+            for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
+                if (*_Ptr < _Cur_min) {
+                    _Res._Min = _Ptr;
+                    _Cur_min  = *_Ptr;
+                }
+                // Not else!
+                // * Needed for correctness if start with maximum, as we don't handle specially the first element.
+                // * Promote branchless code generation.
+                if (_Cur_max <= *_Ptr) {
+                    _Res._Max = _Ptr;
+                    _Cur_max  = *_Ptr;
+                }
+            }
+
+            return _Res;
+        }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        template <_Min_max_mode _Mode, class _Traits, bool _Sign>
+        auto _Minmax_element_impl(const void* _First, const void* const _Last) noexcept {
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        template <_Min_max_mode _Mode, class _Traits>
+        auto _Minmax_element_impl(const void* _First, const void* const _Last, const bool _Sign) noexcept {
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+            _Min_max_element_t _Res = {_First, _First};
+            auto _Cur_min_val       = _Traits::_Init_min_val;
+            auto _Cur_max_val       = _Traits::_Init_max_val;
+
+            if constexpr (_Traits::_Vectorized) {
+                auto _Base                = static_cast<const char*>(_First);
+                size_t _Portion_byte_size = _Byte_length(_First, _Last) & ~_Traits::_Vec_mask;
+
+                if constexpr (_Traits::_Has_portion_max) {
+                    // vector of indices will wrap around at exactly this size
+                    constexpr size_t _Max_portion_byte_size = _Traits::_Portion_max * _Traits::_Vec_size;
+                    if (_Portion_byte_size > _Max_portion_byte_size) {
+                        _Portion_byte_size = _Max_portion_byte_size;
+                    }
+                }
+
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, _Portion_byte_size);
+
+                // Load values and if unsigned adjust them to be signed (for signed vector comparisons)
+                auto _Cur_vals     = _Traits::_Sign_correction(_Traits::_Load(_First), _Sign);
+                auto _Cur_vals_min = _Cur_vals; // vector of vertical minimum values
+                auto _Cur_idx_min  = _Traits::_Zero(); // vector of vertical minimum indices
+                auto _Cur_vals_max = _Cur_vals; // vector of vertical maximum values
+                auto _Cur_idx_max  = _Traits::_Zero(); // vector of vertical maximum indices
+                auto _Cur_idx      = _Traits::_Zero(); // current vector of indices
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+                const auto _Cmp_gt_wrap = [](const auto _First, const auto _Second) noexcept {
+                    if constexpr (_Sign || !_Traits::_Has_unsigned_cmp) {
+                        return _Traits::_Cmp_gt(_First, _Second);
+                    } else {
+                        return _Traits::_Cmp_gt_u(_First, _Second);
+                    }
+                };
+                const auto _Min_wrap = [](const auto _First, const auto _Second, const auto _Mask) noexcept {
+                    if constexpr (_Sign || !_Traits::_Has_unsigned_cmp) {
+                        return _Traits::_Min(_First, _Second, _Mask);
+                    } else {
+                        return _Traits::_Min_u(_First, _Second, _Mask);
+                    }
+                };
+                const auto _Max_wrap = [](const auto _First, const auto _Second, const auto _Mask) noexcept {
+                    if constexpr (_Sign || !_Traits::_Has_unsigned_cmp) {
+                        return _Traits::_Max(_First, _Second, _Mask);
+                    } else {
+                        return _Traits::_Max_u(_First, _Second, _Mask);
+                    }
+                };
+                const auto _H_min_wrap = [](const auto _Vals) noexcept {
+                    if constexpr (_Sign || !_Traits::_Has_unsigned_cmp) {
+                        return _Traits::_H_min(_Vals);
+                    } else {
+                        return _Traits::_H_min_u(_Vals);
+                    }
+                };
+                const auto _H_max_wrap = [](const auto _Vals) noexcept {
+                    if constexpr (_Sign || !_Traits::_Has_unsigned_cmp) {
+                        return _Traits::_H_max(_Vals);
+                    } else {
+                        return _Traits::_H_max_u(_Vals);
+                    }
+                };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+                const auto _Cmp_gt_wrap = [](const auto _First, const auto _Second) noexcept {
+                    return _Traits::_Cmp_gt(_First, _Second);
+                };
+                const auto _Min_wrap = [](const auto _First, const auto _Second, const auto _Mask) noexcept {
+                    return _Traits::_Min(_First, _Second, _Mask);
+                };
+                const auto _Max_wrap = [](const auto _First, const auto _Second, const auto _Mask) noexcept {
+                    return _Traits::_Max(_First, _Second, _Mask);
+                };
+                const auto _H_min_wrap = [](const auto _Vals) noexcept { return _Traits::_H_min(_Vals); };
+                const auto _H_max_wrap = [](const auto _Vals) noexcept { return _Traits::_H_max(_Vals); };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+                const auto _Update_min_max = [&](const auto _Cur_vals, [[maybe_unused]] const auto _Blend_idx_0,
+                                                 const auto _Blend_idx_1) noexcept {
+                    if constexpr ((_Mode & _Mode_min) != 0) {
+                        // Looking for the first occurrence of minimum, don't overwrite with newly found occurrences
+                        const auto _Is_less = _Cmp_gt_wrap(_Cur_vals_min, _Cur_vals); // _Cur_vals < _Cur_vals_min
+                        // Remember their vertical indices
+                        _Cur_idx_min  = _Blend_idx_1(_Cur_idx_min, _Cur_idx, _Traits::_Mask_cast(_Is_less));
+                        _Cur_vals_min = _Min_wrap(_Cur_vals_min, _Cur_vals, _Is_less); // Update the current minimum
+                    }
+
+                    if constexpr (_Mode == _Mode_max) {
+                        // Looking for the first occurrence of maximum, don't overwrite with newly found occurrences
+                        // _Cur_vals > _Cur_vals_max
+                        const auto _Is_greater = _Cmp_gt_wrap(_Cur_vals, _Cur_vals_max);
+                        // Remember their vertical indices
+                        _Cur_idx_max = _Blend_idx_1(_Cur_idx_max, _Cur_idx, _Traits::_Mask_cast(_Is_greater));
+                        // Update the current maximum
+                        _Cur_vals_max = _Max_wrap(_Cur_vals_max, _Cur_vals, _Is_greater);
+                    } else if constexpr (_Mode == _Mode_both) {
+                        // Looking for the last occurrence of maximum, do overwrite with newly found occurrences
+                        // !(_Cur_vals >= _Cur_vals_max)
+                        const auto _Is_less = _Cmp_gt_wrap(_Cur_vals_max, _Cur_vals);
+                        // Remember their vertical indices
+                        _Cur_idx_max  = _Blend_idx_0(_Cur_idx_max, _Cur_idx, _Traits::_Mask_cast(_Is_less));
+                        _Cur_vals_max = _Max_wrap(_Cur_vals, _Cur_vals_max, _Is_less); // Update the current maximum
+                    }
+                };
+
+                const auto _Blend_idx_0 = [](const auto _Prev, const auto _Cur, const auto _Mask) noexcept {
+                    return _Traits::_Blend(_Cur, _Prev, _Mask);
+                };
+
+                const auto _Blend_idx_1 = [](const auto _Prev, const auto _Cur, const auto _Mask) noexcept {
+                    return _Traits::_Blend(_Prev, _Cur, _Mask);
+                };
+
+                for (;;) {
+                    _Advance_bytes(_First, _Traits::_Vec_size);
+
+                    // Increment vertical indices. Will stop at exactly wrap around, if not reach the end before
+                    _Cur_idx = _Traits::_Inc(_Cur_idx);
+
+                    if (_First != _Stop_at) {
+                        // This is the main part, finding vertical minimum/maximum
+
+                        // Load values and if unsigned adjust them to be signed (for signed vector comparisons)
+                        _Cur_vals = _Traits::_Sign_correction(_Traits::_Load(_First), _Sign);
+
+                        _Update_min_max(_Cur_vals, _Blend_idx_0, _Blend_idx_1);
+                    } else {
+                        if constexpr (_Traits::_Tail_mask != 0) {
+                            const size_t _Remaining_byte_size = _Byte_length(_First, _Last);
+                            bool _Last_portion;
+
+                            if constexpr (_Traits::_Has_portion_max) {
+                                _Last_portion = (_Remaining_byte_size & ~_Traits::_Vec_mask) == 0;
+                            } else {
+                                _Last_portion = true;
+                            }
+
+                            const size_t _Tail_byte_size = _Remaining_byte_size & _Traits::_Tail_mask;
+
+                            if (_Last_portion && _Tail_byte_size != 0) {
+                                const auto _Tail_mask = _Avx2_tail_mask_32(_Tail_byte_size);
+                                const auto _Tail_vals =
+                                    _Traits::_Sign_correction(_Traits::_Load_mask(_First, _Tail_mask), _Sign);
+                                _Cur_vals = _Traits::_Blendval(_Cur_vals, _Tail_vals, _Tail_mask);
+
+                                const auto _Blend_idx_0_mask = [_Tail_mask](const auto _Prev, const auto _Cur,
+                                                                   const auto _Mask) noexcept {
+                                    return _Traits::_Blend(_Prev, _Cur, _mm256_andnot_si256(_Mask, _Tail_mask));
+                                };
+
+                                const auto _Blend_idx_1_mask = [_Tail_mask](const auto _Prev, const auto _Cur,
+                                                                   const auto _Mask) noexcept {
+                                    return _Traits::_Blend(_Prev, _Cur, _mm256_and_si256(_Tail_mask, _Mask));
+                                };
+
+                                _Update_min_max(_Cur_vals, _Blend_idx_0_mask, _Blend_idx_1_mask);
+                                _Advance_bytes(_First, _Tail_byte_size);
+                            }
+                        }
+
+                        // Reached end or indices wrap around point.
+                        // Compute horizontal min and/or max. Determine horizontal and vertical position of it.
+
+                        if constexpr ((_Mode & _Mode_min) != 0) {
+                            // Vector populated by the smallest element
+                            const auto _H_min     = _H_min_wrap(_Cur_vals_min);
+                            const auto _H_min_val = _Traits::_Get_any(_H_min); // Get any element of it
+
+                            if (_H_min_val < _Cur_min_val) { // Current horizontal min is less than the old
+                                _Cur_min_val = _H_min_val; // update min
+                                // Mask of all elems eq to min
+                                const auto _Eq_mask = _Traits::_Cmp_eq(_H_min, _Cur_vals_min);
+                                auto _Mask          = _Traits::_Mask(_Traits::_Mask_cast(_Eq_mask));
+                                // Indices of minimum elements or the greatest index if none
+                                const auto _Idx_min_val =
+                                    _Traits::_Blend(_Traits::_All_ones(), _Cur_idx_min, _Traits::_Mask_cast(_Eq_mask));
+                                auto _Idx_min = _Traits::_H_min_u(_Idx_min_val); // The smallest indices
+                                // Select the smallest vertical indices from the smallest element mask
+                                _Mask &= _Traits::_Mask(_Traits::_Cmp_eq_idx(_Idx_min, _Idx_min_val));
+
+                                // Find the smallest horizontal index
+                                const unsigned long _H_pos = _Traits::_Get_first_h_pos(_Mask);
+
+                                // Extract its vertical index
+                                const auto _V_pos = _Traits::_Get_v_pos(_Idx_min);
+                                // Finally, compute the pointer
+                                _Res._Min = _Base + static_cast<size_t>(_V_pos) * _Traits::_Vec_size + _H_pos;
+                            }
+                        }
+
+                        if constexpr ((_Mode & _Mode_max) != 0) {
+                            // Vector populated by the largest element
+                            const auto _H_max     = _H_max_wrap(_Cur_vals_max);
+                            const auto _H_max_val = _Traits::_Get_any(_H_max); // Get any element of it
+
+                            if (_Mode == _Mode_both && _Cur_max_val <= _H_max_val
+                                || _Mode == _Mode_max && _Cur_max_val < _H_max_val) {
+                                // max_element: current horizontal max is greater than the old, update max
+                                // minmax_element: current horizontal max is not less than the old, update max
+                                _Cur_max_val = _H_max_val;
+
+                                // Mask of all elems eq to max
+                                const auto _Eq_mask = _Traits::_Cmp_eq(_H_max, _Cur_vals_max);
+                                auto _Mask          = _Traits::_Mask(_Traits::_Mask_cast(_Eq_mask));
+
+                                unsigned long _H_pos;
+                                size_t _V_pos;
+                                if constexpr (_Mode == _Mode_both) {
+                                    // Looking for the last occurrence of maximum
+                                    // Indices of maximum elements or zero if none
+                                    const auto _Idx_max_val =
+                                        _Traits::_Blend(_Traits::_Zero(), _Cur_idx_max, _Traits::_Mask_cast(_Eq_mask));
+                                    const auto _Idx_max = _Traits::_H_max_u(_Idx_max_val); // The greatest indices
+                                    // Select the greatest vertical indices from the largest element mask
+                                    _Mask &= _Traits::_Mask(_Traits::_Cmp_eq_idx(_Idx_max, _Idx_max_val));
+
+                                    // Find the largest horizontal index
+                                    _H_pos = _Traits::_Get_last_h_pos(_Mask);
+                                    _H_pos -= sizeof(_Cur_max_val) - 1; // Correct from highest val bit to lowest
+
+                                    // Extract its vertical index
+                                    _V_pos = static_cast<size_t>(_Traits::_Get_v_pos(_Idx_max));
+                                } else {
+                                    // Looking for the first occurrence of maximum
+                                    // Indices of maximum elements or the greatest index if none
+                                    const auto _Idx_max_val = _Traits::_Blend(
+                                        _Traits::_All_ones(), _Cur_idx_max, _Traits::_Mask_cast(_Eq_mask));
+                                    const auto _Idx_max = _Traits::_H_min_u(_Idx_max_val); // The smallest indices
+
+                                    // Select the smallest vertical indices from the largest element mask
+                                    _Mask &= _Traits::_Mask(_Traits::_Cmp_eq_idx(_Idx_max, _Idx_max_val));
+
+                                    // Find the smallest horizontal index
+                                    _H_pos = _Traits::_Get_first_h_pos(_Mask);
+
+                                    // Extract its vertical index
+                                    _V_pos = static_cast<size_t>(_Traits::_Get_v_pos(_Idx_max));
+                                }
+
+                                // Finally, compute the pointer
+                                _Res._Max = _Base + _V_pos * _Traits::_Vec_size + _H_pos;
+                            }
+                        }
+                        // Horizontal part done, results are saved, now need to see if there is another portion.
+
+                        if constexpr (_Traits::_Has_portion_max) {
+                            // Either the last portion or wrapping point reached, need to determine
+                            _Portion_byte_size = _Byte_length(_First, _Last) & ~_Traits::_Vec_mask;
+                            if (_Portion_byte_size == 0) {
+                                break; // That was the last portion
+                            }
+                            // Start next portion to handle the wrapping indices. Assume _Cur_idx is zero
+                            constexpr size_t _Max_portion_byte_size = _Traits::_Portion_max * _Traits::_Vec_size;
+                            if (_Portion_byte_size > _Max_portion_byte_size) {
+                                _Portion_byte_size = _Max_portion_byte_size;
+                            }
+
+                            _Advance_bytes(_Stop_at, _Portion_byte_size);
+                            // Indices will be relative to the new base
+                            _Base = static_cast<const char*>(_First);
+                            // Load values and if unsigned adjust them to be signed (for signed vector comparisons)
+                            _Cur_vals = _Traits::_Sign_correction(_Traits::_Load(_First), _Sign);
+
+                            if constexpr ((_Mode & _Mode_min) != 0) {
+                                _Cur_vals_min = _Cur_vals;
+                                _Cur_idx_min  = _Traits::_Zero();
+                            }
+
+                            if constexpr ((_Mode & _Mode_max) != 0) {
+                                _Cur_vals_max = _Cur_vals;
+                                _Cur_idx_max  = _Traits::_Zero();
+                            }
+                        } else {
+                            break; // No wrapping, so it was the only portion
+                        }
+                    }
+                }
+
+                _Traits::_Exit_vectorized(); // TRANSITION, DevCom-10331414
+            }
+
+            if constexpr (_Traits::_Is_floating) {
+                if constexpr (_Mode == _Mode_min) {
+                    return _Min_tail(_First, _Last, _Res._Min, _Cur_min_val);
+                } else if constexpr (_Mode == _Mode_max) {
+                    return _Max_tail(_First, _Last, _Res._Max, _Cur_max_val);
+                } else {
+                    return _Both_tail(_First, _Last, _Res, _Cur_min_val, _Cur_max_val);
+                }
+            } else {
+                using _STy = _Traits::_Signed_t;
+                using _UTy = _Traits::_Unsigned_t;
+
+                constexpr _UTy _Correction = _Traits::_Has_unsigned_cmp ? 0 : _UTy{1} << (sizeof(_UTy) * 8 - 1);
+
+                if constexpr (_Mode == _Mode_min) {
+                    if (_Sign) {
+                        return _Min_tail(_First, _Last, _Res._Min, static_cast<_STy>(_Cur_min_val));
+                    } else {
+                        return _Min_tail(_First, _Last, _Res._Min, static_cast<_UTy>(_Cur_min_val + _Correction));
+                    }
+                } else if constexpr (_Mode == _Mode_max) {
+                    if (_Sign) {
+                        return _Max_tail(_First, _Last, _Res._Max, static_cast<_STy>(_Cur_max_val));
+                    } else {
+                        return _Max_tail(_First, _Last, _Res._Max, static_cast<_UTy>(_Cur_max_val + _Correction));
+                    }
+                } else {
+                    if (_Sign) {
+                        return _Both_tail(
+                            _First, _Last, _Res, static_cast<_STy>(_Cur_min_val), static_cast<_STy>(_Cur_max_val));
+                    } else {
+                        return _Both_tail(_First, _Last, _Res, static_cast<_UTy>(_Cur_min_val + _Correction),
+                            static_cast<_UTy>(_Cur_max_val + _Correction));
+                    }
+                }
+            }
+        }
+
+        template <_Min_max_mode _Mode, class _Traits, bool _Sign>
+        auto __stdcall _Minmax_element_disp(const void* const _First, const void* const _Last) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            if constexpr (!std::is_same_v<typename _Traits::_Neon, _Traits_8_neon>) {
+                if (_Byte_length(_First, _Last) >= 16) {
+                    return _Minmax_element_impl<_Mode, typename _Traits::_Neon, _Sign>(_First, _Last);
+                }
+            }
+
+            return _Minmax_element_impl<_Mode, typename _Traits::_Scalar, _Sign>(_First, _Last);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            if (_Byte_length(_First, _Last) >= 32 && _Use_avx2()) {
+                return _Minmax_element_impl<_Mode, typename _Traits::_Avx>(_First, _Last, _Sign);
+            }
+
+            if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
+                return _Minmax_element_impl<_Mode, typename _Traits::_Sse>(_First, _Last, _Sign);
+            }
+            return _Minmax_element_impl<_Mode, typename _Traits::_Scalar>(_First, _Last, _Sign);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        }
+
+        template <_Min_max_mode _Mode, class _Traits, bool _Sign, bool _Unrolled = false>
+        auto _Minmax_impl(const void* _First, const void* const _Last) noexcept {
+            using _Ty    = std::conditional_t<_Sign, typename _Traits::_Signed_t, typename _Traits::_Unsigned_t>;
+            using _VecTy = _Traits::_Vec_t;
+
+            _Ty _Cur_min_val; // initialized in both of the branches below
+            _Ty _Cur_max_val; // initialized in both of the branches below
+
+            if constexpr (_Traits::_Vectorized) {
+                constexpr size_t _Lanes          = _Unrolled ? 2 : 1;
+                constexpr size_t _Bytes_per_iter = _Lanes * _Traits::_Vec_size;
+
+                const size_t _Total_size_bytes = _Byte_length(_First, _Last);
+                const size_t _Vec_byte_size    = _Total_size_bytes & ~(_Bytes_per_iter - 1);
+
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, _Vec_byte_size);
+
+                // We don't have unsigned 64-bit stuff, so we'll use sign correction just for that case
+                constexpr bool _Sign_correction = sizeof(_Ty) == 8 && !_Sign && !_Traits::_Has_unsigned_cmp;
+
+                _VecTy _Cur_vals[_Lanes];
+                _VecTy _Cur_vals_min[_Lanes]; // vector of vertical minimum values
+                _VecTy _Cur_vals_max[_Lanes]; // vector of vertical maximum values
+                for (size_t _Lane = 0; _Lane < _Lanes; ++_Lane) {
+                    _Cur_vals[_Lane] = _Traits::_Load(static_cast<const uint8_t*>(_First) + _Lane * _Traits::_Vec_size);
+                    if constexpr (_Sign_correction) {
+                        _Cur_vals[_Lane] = _Traits::_Sign_correction(_Cur_vals[_Lane], false);
+                    }
+                    _Cur_vals_min[_Lane] = _Cur_vals[_Lane];
+                    _Cur_vals_max[_Lane] = _Cur_vals[_Lane];
+                }
+
+                const auto _Update_min_max = [&](const auto _Cur_vals, size_t _Lane = 0) noexcept {
+                    if constexpr ((_Mode & _Mode_min) != 0) {
+                        if constexpr (_Sign || _Sign_correction) {
+                            _Cur_vals_min[_Lane] =
+                                _Traits::_Min(_Cur_vals_min[_Lane], _Cur_vals); // Update the current minimum
+                        } else {
+                            _Cur_vals_min[_Lane] =
+                                _Traits::_Min_u(_Cur_vals_min[_Lane], _Cur_vals); // Update the current minimum
+                        }
+                    }
+
+                    if constexpr ((_Mode & _Mode_max) != 0) {
+                        if constexpr (_Sign || _Sign_correction) {
+                            _Cur_vals_max[_Lane] =
+                                _Traits::_Max(_Cur_vals_max[_Lane], _Cur_vals); // Update the current maximum
+                        } else {
+                            _Cur_vals_max[_Lane] =
+                                _Traits::_Max_u(_Cur_vals_max[_Lane], _Cur_vals); // Update the current maximum
+                        }
+                    }
+                };
+
+                for (;;) {
+                    _Advance_bytes(_First, _Bytes_per_iter);
+
+                    if (_First != _Stop_at) {
+                        // This is the main part, finding vertical minimum/maximum
+
+                        for (size_t _Lane = 0; _Lane < _Lanes; ++_Lane) {
+                            _Cur_vals[_Lane] =
+                                _Traits::_Load(static_cast<const uint8_t*>(_First) + _Lane * _Traits::_Vec_size);
+
+                            if constexpr (_Sign_correction) {
+                                _Cur_vals[_Lane] = _Traits::_Sign_correction(_Cur_vals[_Lane], false);
+                            }
+
+                            _Update_min_max(_Cur_vals[_Lane], _Lane);
+                        }
+                    } else {
+                        if constexpr (_Unrolled) {
+                            const bool _Has_vec_tail = (_Byte_length(_First, _Last) & ~_Traits::_Vec_mask) != 0;
+
+                            if (_Has_vec_tail) {
+                                _Cur_vals[0] = _Traits::_Load(_First);
+
+                                if constexpr (_Sign_correction) {
+                                    _Cur_vals[0] = _Traits::_Sign_correction(_Cur_vals[0], false);
+                                }
+
+                                _Update_min_max(_Cur_vals[0], 0);
+
+                                _Advance_bytes(_First, _Traits::_Vec_size);
+                            }
+                        }
+
+                        if constexpr (_Traits::_Tail_mask != 0) {
+                            const size_t _Tail_byte_size = _Total_size_bytes & _Traits::_Tail_mask;
+                            if (_Tail_byte_size != 0) {
+                                const auto _Tail_mask = _Avx2_tail_mask_32(_Tail_byte_size);
+                                auto _Tail_vals       = _Traits::_Load_mask(_First, _Tail_mask);
+
+                                if constexpr (_Sign_correction) {
+                                    _Tail_vals = _Traits::_Sign_correction(_Tail_vals, false);
+                                }
+
+                                _Tail_vals = _Traits::_Blendval(_Cur_vals[0], _Tail_vals, _Tail_mask);
+
+                                _Update_min_max(_Tail_vals);
+
+                                _Advance_bytes(_First, _Tail_byte_size);
+                            }
+                        }
+
+                        // Reached end. Compute horizontal min and/or max.
+
+                        if constexpr ((_Mode & _Mode_min) != 0) {
+                            if constexpr (_Sign || _Sign_correction) {
+                                if constexpr (_Unrolled) {
+                                    for (size_t _Lane = 1; _Lane < _Lanes; ++_Lane) {
+                                        _Cur_vals_min[0] = _Traits::_Min(_Cur_vals_min[0], _Cur_vals_min[_Lane]);
+                                    }
+                                }
+
+                                // Vector populated by the smallest element
+                                const auto _H_min = _Traits::_H_min(_Cur_vals_min[0]);
+                                _Cur_min_val      = _Traits::_Get_any(_H_min); // Get any element of it
+                            } else {
+                                if constexpr (_Unrolled) {
+                                    for (size_t _Lane = 1; _Lane < _Lanes; ++_Lane) {
+                                        _Cur_vals_min[0] = _Traits::_Min_u(_Cur_vals_min[0], _Cur_vals_min[_Lane]);
+                                    }
+                                }
+
+                                // Vector populated by the smallest element
+                                const auto _H_min = _Traits::_H_min_u(_Cur_vals_min[0]);
+                                _Cur_min_val      = _Traits::_Get_any(_H_min); // Get any element of it
+                            }
+                        }
+
+                        if constexpr ((_Mode & _Mode_max) != 0) {
+                            if constexpr (_Sign || _Sign_correction) {
+                                if constexpr (_Unrolled) {
+                                    for (size_t _Lane = 1; _Lane < _Lanes; ++_Lane) {
+                                        _Cur_vals_max[0] = _Traits::_Max(_Cur_vals_max[0], _Cur_vals_max[_Lane]);
+                                    }
+                                }
+
+                                // Vector populated by the largest element
+                                const auto _H_max = _Traits::_H_max(_Cur_vals_max[0]);
+                                _Cur_max_val      = _Traits::_Get_any(_H_max); // Get any element of it
+                            } else {
+                                if constexpr (_Unrolled) {
+                                    for (size_t _Lane = 1; _Lane < _Lanes; ++_Lane) {
+                                        _Cur_vals_max[0] = _Traits::_Max_u(_Cur_vals_max[0], _Cur_vals_max[_Lane]);
+                                    }
+                                }
+
+                                // Vector populated by the largest element
+                                const auto _H_max = _Traits::_H_max_u(_Cur_vals_max[0]);
+                                _Cur_max_val      = _Traits::_Get_any(_H_max); // Get any element of it
+                            }
+                        }
+
+                        if constexpr (_Sign_correction) {
+                            constexpr _Ty _Correction = _Ty{1} << (sizeof(_Ty) * 8 - 1);
+
+                            if constexpr ((_Mode & _Mode_min) != 0) {
+                                _Cur_min_val += _Correction;
+                            }
+
+                            if constexpr ((_Mode & _Mode_max) != 0) {
+                                _Cur_max_val += _Correction;
+                            }
+                        }
+
+                        break;
+                    }
+                }
+
+                _Traits::_Exit_vectorized(); // TRANSITION, DevCom-10331414
+            } else {
+                _Cur_min_val = *reinterpret_cast<const _Ty*>(_First);
+                _Cur_max_val = *reinterpret_cast<const _Ty*>(_First);
+
+                _Advance_bytes(_First, sizeof(_Ty));
+            }
+
+// Avoid auto-vectorization of the scalar tail, as this is not beneficial for performance.
+#pragma loop(no_vector)
+            for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
+                if constexpr ((_Mode & _Mode_min) != 0) {
+                    if (*_Ptr < _Cur_min_val) {
+                        _Cur_min_val = *_Ptr;
+                    }
+                }
+
+                if constexpr ((_Mode & _Mode_max) != 0) {
+                    if (_Cur_max_val < *_Ptr) {
+                        _Cur_max_val = *_Ptr;
+                    }
+                }
+
+                // _Mode_both could have been handled separately with 'else'.
+                // We have _Cur_min_val / _Cur_max_val initialized by processing at least one element,
+                // so the 'else' would be correct here.
+                // But still separate 'if' statements promote branchless codegen.
+            }
+
+            if constexpr (_Mode == _Mode_min) {
+                return _Cur_min_val;
+            } else if constexpr (_Mode == _Mode_max) {
+                return _Cur_max_val;
+            } else {
+                using _Rx = std::conditional_t<_Sign, typename _Traits::_Minmax_i_t, typename _Traits::_Minmax_u_t>;
+                return _Rx{_Cur_min_val, _Cur_max_val};
+            }
+        }
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+        // TRANSITION, DevCom-10767462
+        template <_Min_max_mode _Mode, class _Traits, bool _Sign>
+        auto _Minmax_impl_wrap(const void* const _First, const void* const _Last) noexcept {
+            auto _Rx = _Minmax_impl<_Mode, _Traits, _Sign>(_First, _Last);
+            _mm256_zeroupper();
+            return _Rx;
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        template <_Min_max_mode _Mode, class _Traits, bool _Sign>
+        auto __stdcall _Minmax_disp(const void* const _First, const void* const _Last) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            if (_Byte_length(_First, _Last) >= 32) {
+                return _Minmax_impl<_Mode, typename _Traits::_Neon, _Sign, true>(_First, _Last);
+            }
+
+            if (_Byte_length(_First, _Last) >= 16) {
+                return _Minmax_impl<_Mode, typename _Traits::_Neon, _Sign, false>(_First, _Last);
+            }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            if (_Byte_length(_First, _Last) >= 32 && _Use_avx2()) {
+                if constexpr (_Traits::_Avx::_Is_floating) {
+                    return _Minmax_impl_wrap<_Mode, typename _Traits::_Avx, _Sign>(_First, _Last);
+                } else {
+                    return _Minmax_impl<_Mode, typename _Traits::_Avx, _Sign>(_First, _Last);
+                }
+            }
+
+            if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
+                return _Minmax_impl<_Mode, typename _Traits::_Sse, _Sign>(_First, _Last);
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+            return _Minmax_impl<_Mode, typename _Traits::_Scalar, _Sign>(_First, _Last);
+        }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        template <class _Traits, class _Ty>
+        const void* _Is_sorted_until_impl(const void* _First, const void* const _Last, const bool _Greater) noexcept {
+            const ptrdiff_t _Left_off  = 0 - static_cast<ptrdiff_t>(_Greater);
+            const ptrdiff_t _Right_off = static_cast<ptrdiff_t>(_Greater) - 1;
+
+            if constexpr (_Traits::_Vectorized) {
+                const size_t _Total_size_bytes = _Byte_length(_First, _Last);
+
+                const auto _Cmp_gt_wrap = [](const auto _Right, const auto _Left) noexcept {
+                    constexpr bool _Unsigned = static_cast<_Ty>(-1) > _Ty{0};
+
+                    if constexpr (_Unsigned && _Traits::_Has_unsigned_cmp) {
+                        return _Traits::_Cmp_gt_u(_Right, _Left);
+                    } else {
+                        return _Traits::_Cmp_gt(_Right, _Left);
+                    }
+                };
+
+                if (_Total_size_bytes >= 32) {
+                    constexpr size_t _Bytes_per_iter = 2 * _Traits::_Vec_size;
+                    const size_t _Vec_byte_size      = _Total_size_bytes & ~(_Bytes_per_iter - 1);
+                    const void* _Stop_at             = _First;
+                    _Advance_bytes(_Stop_at, _Vec_byte_size);
+
+                    do {
+                        const void* const _Next = static_cast<const uint8_t*>(_First) + _Traits::_Vec_size;
+
+                        const auto _Left_lo  = _Traits::_Load(static_cast<const _Ty*>(_First) + _Left_off);
+                        const auto _Right_lo = _Traits::_Load(static_cast<const _Ty*>(_First) + _Right_off);
+                        const auto _Left_hi  = _Traits::_Load(static_cast<const _Ty*>(_Next) + _Left_off);
+                        const auto _Right_hi = _Traits::_Load(static_cast<const _Ty*>(_Next) + _Right_off);
+
+                        const auto _Is_less_lo = _Cmp_gt_wrap(_Right_lo, _Left_lo);
+                        const auto _Is_less_hi = _Cmp_gt_wrap(_Right_hi, _Left_hi);
+                        const auto _Any_match  = _Traits::_Match_mask(_Is_less_lo, _Is_less_hi);
+
+                        if (_Any_match != 0) {
+                            const auto _Mask_lo = _Traits::_Mask(_Is_less_lo);
+                            if (_Mask_lo != 0) {
+                                const unsigned long _H_pos = _Traits::_Get_first_h_pos(_Mask_lo);
+                                _Advance_bytes(_First, _H_pos);
+                                return _First;
+                            }
+
+                            const auto _Mask_hi        = _Traits::_Mask(_Is_less_hi);
+                            const unsigned long _H_pos = _Traits::_Get_first_h_pos(_Mask_hi) + _Traits::_Vec_size;
+                            _Advance_bytes(_First, _H_pos);
+                            return _First;
+                        }
+
+                        _Advance_bytes(_First, 2 * _Traits::_Vec_size);
+                    } while (_First != _Stop_at);
+                }
+
+                const size_t _Has_vec_tail = (_Byte_length(_First, _Last) & ~_Traits::_Vec_mask) != 0;
+                if (_Has_vec_tail) {
+                    const auto _Left  = _Traits::_Load(static_cast<const _Ty*>(_First) + _Left_off);
+                    const auto _Right = _Traits::_Load(static_cast<const _Ty*>(_First) + _Right_off);
+
+                    const auto _Is_less = _Cmp_gt_wrap(_Right, _Left);
+                    const auto _Mask    = _Traits::_Mask(_Traits::_Mask_cast(_Is_less));
+
+                    if (_Mask != 0) {
+                        const unsigned long _H_pos = _Traits::_Get_first_h_pos(_Mask);
+                        _Advance_bytes(_First, _H_pos);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, _Traits::_Vec_size);
+                }
+            }
+
+            for (const _Ty* _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
+                if (_Ptr[_Left_off] < _Ptr[_Right_off]) {
+                    return _Ptr;
+                }
+            }
+
+            return _Last;
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        template <class _Traits, class _Ty>
+        const void* _Is_sorted_until_impl(const void* _First, const void* const _Last, const bool _Greater) noexcept {
+            const ptrdiff_t _Left_off  = 0 - static_cast<ptrdiff_t>(_Greater);
+            const ptrdiff_t _Right_off = static_cast<ptrdiff_t>(_Greater) - 1;
+
+            if constexpr (_Traits::_Vectorized) {
+                [[maybe_unused]] typename _Traits::_Guard _Guard; // TRANSITION, DevCom-10331414
+
+                constexpr bool _Sign_cor = static_cast<_Ty>(-1) > _Ty{0};
+
+                const size_t _Total_size_bytes = _Byte_length(_First, _Last);
+                const size_t _Vec_byte_size    = _Total_size_bytes & ~_Traits::_Vec_mask;
+
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, _Vec_byte_size);
+
+                do {
+                    auto _Left  = _Traits::_Load(static_cast<const _Ty*>(_First) + _Left_off);
+                    auto _Right = _Traits::_Load(static_cast<const _Ty*>(_First) + _Right_off);
+
+                    if constexpr (_Sign_cor) {
+                        _Left  = _Traits::_Sign_correction(_Left, false);
+                        _Right = _Traits::_Sign_correction(_Right, false);
+                    }
+
+                    const auto _Is_less = _Traits::_Cmp_gt(_Right, _Left);
+                    const auto _Mask    = _Traits::_Mask(_Traits::_Mask_cast(_Is_less));
+
+                    if (_Mask != 0) {
+                        const unsigned long _H_pos = _Traits::_Get_first_h_pos(_Mask);
+                        _Advance_bytes(_First, _H_pos);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, _Traits::_Vec_size);
+                } while (_First != _Stop_at);
+
+                if constexpr (_Traits::_Tail_mask != 0) {
+                    const size_t _Tail_byte_size = _Total_size_bytes & _Traits::_Tail_mask;
+                    if (_Tail_byte_size != 0) {
+                        const auto _Tail_mask = _Avx2_tail_mask_32(_Tail_byte_size);
+
+                        auto _Left  = _Traits::_Load_mask(static_cast<const _Ty*>(_First) + _Left_off, _Tail_mask);
+                        auto _Right = _Traits::_Load_mask(static_cast<const _Ty*>(_First) + _Right_off, _Tail_mask);
+
+                        if constexpr (_Sign_cor) {
+                            _Left  = _Traits::_Sign_correction(_Left, false);
+                            _Right = _Traits::_Sign_correction(_Right, false);
+                        }
+
+                        const auto _Is_less = _Traits::_Cmp_gt(_Right, _Left);
+                        const auto _Mask = _Traits::_Mask(_mm256_and_si256(_Traits::_Mask_cast(_Is_less), _Tail_mask));
+
+                        if (_Mask != 0) {
+                            const unsigned long _H_pos = _Traits::_Get_first_h_pos(_Mask);
+                            _Advance_bytes(_First, _H_pos);
+                            return _First;
+                        }
+
+                        _Advance_bytes(_First, _Tail_byte_size);
+                    }
+                }
+            }
+
+            if constexpr ((_Traits::_Tail_mask & sizeof(_Ty)) != sizeof(_Ty)) {
+                for (const _Ty* _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
+                    if (_Ptr[_Left_off] < _Ptr[_Right_off]) {
+                        return _Ptr;
+                    }
+                }
+            }
+
+            return _Last;
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        template <class _Traits, class _Ty>
+        const void* __stdcall _Is_sorted_until_disp(
+            const void* _First, const void* const _Last, const bool _Greater) noexcept {
+            if (_First == _Last) {
+                return _First;
+            }
+
+            _Advance_bytes(_First, sizeof(_Ty));
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            if (_Byte_length(_First, _Last) >= 16) {
+                return _Is_sorted_until_impl<typename _Traits::_Neon, _Ty>(_First, _Last, _Greater);
+            }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            if (_Byte_length(_First, _Last) >= 32 && _Use_avx2()) {
+                return _Is_sorted_until_impl<typename _Traits::_Avx, _Ty>(_First, _Last, _Greater);
+            }
+
+            if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
+                return _Is_sorted_until_impl<typename _Traits::_Sse, _Ty>(_First, _Last, _Greater);
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+            return _Is_sorted_until_impl<typename _Traits::_Scalar, _Ty>(_First, _Last, _Greater);
+        }
+    } // namespace _Sorting
+} // unnamed namespace
+
+extern "C" {
+
+const void* __stdcall __std_min_element_1i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_1, true>(_First, _Last);
+}
+
+const void* __stdcall __std_min_element_1u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_1, false>(_First, _Last);
+}
+
+const void* __stdcall __std_min_element_2i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_2, true>(_First, _Last);
+}
+
+const void* __stdcall __std_min_element_2u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_2, false>(_First, _Last);
+}
+
+const void* __stdcall __std_min_element_4i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_4, true>(_First, _Last);
+}
+
+const void* __stdcall __std_min_element_4u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_4, false>(_First, _Last);
+}
+
+#ifndef _M_ARM64
+const void* __stdcall __std_min_element_8i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_8, true>(_First, _Last);
+}
+
+const void* __stdcall __std_min_element_8u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_8, false>(_First, _Last);
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+const void* __stdcall __std_min_element_f_(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_f, false>(_First, _Last);
+}
+
+const void* __stdcall __std_min_element_d_(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_min, _Sorting::_Traits_d, false>(_First, _Last);
+}
+
+#ifndef _M_ARM64
+// TRANSITION, ABI: __std_min_element_1() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_min_element_1(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_min_element_1i(_First, _Last);
+    } else {
+        return __std_min_element_1u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_min_element_2() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_min_element_2(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_min_element_2i(_First, _Last);
+    } else {
+        return __std_min_element_2u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_min_element_4() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_min_element_4(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_min_element_4i(_First, _Last);
+    } else {
+        return __std_min_element_4u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_min_element_8() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_min_element_8(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_min_element_8i(_First, _Last);
+    } else {
+        return __std_min_element_8u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_min_element_f() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_min_element_f(const void* const _First, const void* const _Last, bool) noexcept {
+    return __std_min_element_f_(_First, _Last);
+}
+
+// TRANSITION, ABI: __std_min_element_d() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_min_element_d(const void* const _First, const void* const _Last, bool) noexcept {
+    return __std_min_element_d_(_First, _Last);
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+const void* __stdcall __std_max_element_1i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_1, true>(_First, _Last);
+}
+
+const void* __stdcall __std_max_element_1u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_1, false>(_First, _Last);
+}
+
+const void* __stdcall __std_max_element_2i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_2, true>(_First, _Last);
+}
+
+const void* __stdcall __std_max_element_2u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_2, false>(_First, _Last);
+}
+
+const void* __stdcall __std_max_element_4i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_4, true>(_First, _Last);
+}
+
+const void* __stdcall __std_max_element_4u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_4, false>(_First, _Last);
+}
+
+#ifndef _M_ARM64
+const void* __stdcall __std_max_element_8i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_8, true>(_First, _Last);
+}
+
+const void* __stdcall __std_max_element_8u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_8, false>(_First, _Last);
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+const void* __stdcall __std_max_element_f_(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_f, false>(_First, _Last);
+}
+
+const void* __stdcall __std_max_element_d_(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_max, _Sorting::_Traits_d, false>(_First, _Last);
+}
+
+#ifndef _M_ARM64
+// TRANSITION, ABI: __std_max_element_1() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_max_element_1(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_max_element_1i(_First, _Last);
+    } else {
+        return __std_max_element_1u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_max_element_2() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_max_element_2(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_max_element_2i(_First, _Last);
+    } else {
+        return __std_max_element_2u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_max_element_4() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_max_element_4(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_max_element_4i(_First, _Last);
+    } else {
+        return __std_max_element_4u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_max_element_8() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_max_element_8(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_max_element_8i(_First, _Last);
+    } else {
+        return __std_max_element_8u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_max_element_f() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_max_element_f(const void* const _First, const void* const _Last, bool) noexcept {
+    return __std_max_element_f_(_First, _Last);
+}
+
+// TRANSITION, ABI: __std_max_element_d() is preserved for binary compatibility (x64/x86/ARM64EC)
+const void* __stdcall __std_max_element_d(const void* const _First, const void* const _Last, bool) noexcept {
+    return __std_max_element_d_(_First, _Last);
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+_Min_max_element_t __stdcall __std_minmax_element_1i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_1, true>(_First, _Last);
+}
+
+_Min_max_element_t __stdcall __std_minmax_element_1u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_1, false>(_First, _Last);
+}
+
+_Min_max_element_t __stdcall __std_minmax_element_2i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_2, true>(_First, _Last);
+}
+
+_Min_max_element_t __stdcall __std_minmax_element_2u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_2, false>(_First, _Last);
+}
+
+_Min_max_element_t __stdcall __std_minmax_element_4i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_4, true>(_First, _Last);
+}
+
+_Min_max_element_t __stdcall __std_minmax_element_4u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_4, false>(_First, _Last);
+}
+
+#ifndef _M_ARM64
+_Min_max_element_t __stdcall __std_minmax_element_8i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_8, true>(_First, _Last);
+}
+
+_Min_max_element_t __stdcall __std_minmax_element_8u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_8, false>(_First, _Last);
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+_Min_max_element_t __stdcall __std_minmax_element_f_(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_f, false>(_First, _Last);
+}
+
+_Min_max_element_t __stdcall __std_minmax_element_d_(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_element_disp<_Sorting::_Mode_both, _Sorting::_Traits_d, false>(_First, _Last);
+}
+
+#ifndef _M_ARM64
+// TRANSITION, ABI: __std_minmax_element_1() is preserved for binary compatibility (x64/x86/ARM64EC)
+_Min_max_element_t __stdcall __std_minmax_element_1(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_minmax_element_1i(_First, _Last);
+    } else {
+        return __std_minmax_element_1u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_minmax_element_2() is preserved for binary compatibility (x64/x86/ARM64EC)
+_Min_max_element_t __stdcall __std_minmax_element_2(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_minmax_element_2i(_First, _Last);
+    } else {
+        return __std_minmax_element_2u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_minmax_element_4() is preserved for binary compatibility (x64/x86/ARM64EC)
+_Min_max_element_t __stdcall __std_minmax_element_4(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_minmax_element_4i(_First, _Last);
+    } else {
+        return __std_minmax_element_4u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_minmax_element_8() is preserved for binary compatibility (x64/x86/ARM64EC)
+_Min_max_element_t __stdcall __std_minmax_element_8(
+    const void* const _First, const void* const _Last, const bool _Signed) noexcept {
+    if (_Signed) {
+        return __std_minmax_element_8i(_First, _Last);
+    } else {
+        return __std_minmax_element_8u(_First, _Last);
+    }
+}
+
+// TRANSITION, ABI: __std_minmax_element_f() is preserved for binary compatibility (x64/x86/ARM64EC)
+_Min_max_element_t __stdcall __std_minmax_element_f(const void* const _First, const void* const _Last, bool) noexcept {
+    return __std_minmax_element_f_(_First, _Last);
+}
+
+// TRANSITION, ABI: __std_minmax_element_d() is preserved for binary compatibility (x64/x86/ARM64EC)
+_Min_max_element_t __stdcall __std_minmax_element_d(const void* const _First, const void* const _Last, bool) noexcept {
+    return __std_minmax_element_d_(_First, _Last);
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+__declspec(noalias) int8_t __stdcall __std_min_1i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_1, true>(_First, _Last);
+}
+
+__declspec(noalias) uint8_t __stdcall __std_min_1u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_1, false>(_First, _Last);
+}
+
+__declspec(noalias) int16_t __stdcall __std_min_2i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_2, true>(_First, _Last);
+}
+
+__declspec(noalias) uint16_t __stdcall __std_min_2u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_2, false>(_First, _Last);
+}
+
+__declspec(noalias) int32_t __stdcall __std_min_4i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_4, true>(_First, _Last);
+}
+
+__declspec(noalias) uint32_t __stdcall __std_min_4u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_4, false>(_First, _Last);
+}
+
+__declspec(noalias) int64_t __stdcall __std_min_8i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_8, true>(_First, _Last);
+}
+
+__declspec(noalias) uint64_t __stdcall __std_min_8u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_8, false>(_First, _Last);
+}
+
+__declspec(noalias) float __stdcall __std_min_f(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_f, true>(_First, _Last);
+}
+
+__declspec(noalias) double __stdcall __std_min_d(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_min, _Sorting::_Traits_d, true>(_First, _Last);
+}
+
+__declspec(noalias) int8_t __stdcall __std_max_1i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_1, true>(_First, _Last);
+}
+
+__declspec(noalias) uint8_t __stdcall __std_max_1u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_1, false>(_First, _Last);
+}
+
+__declspec(noalias) int16_t __stdcall __std_max_2i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_2, true>(_First, _Last);
+}
+
+__declspec(noalias) uint16_t __stdcall __std_max_2u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_2, false>(_First, _Last);
+}
+
+__declspec(noalias) int32_t __stdcall __std_max_4i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_4, true>(_First, _Last);
+}
+
+__declspec(noalias) uint32_t __stdcall __std_max_4u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_4, false>(_First, _Last);
+}
+
+__declspec(noalias) int64_t __stdcall __std_max_8i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_8, true>(_First, _Last);
+}
+
+__declspec(noalias) uint64_t __stdcall __std_max_8u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_8, false>(_First, _Last);
+}
+
+__declspec(noalias) float __stdcall __std_max_f(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_f, true>(_First, _Last);
+}
+
+__declspec(noalias) double __stdcall __std_max_d(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_max, _Sorting::_Traits_d, true>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_1i __stdcall __std_minmax_1i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_1, true>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_1u __stdcall __std_minmax_1u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_1, false>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_2i __stdcall __std_minmax_2i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_2, true>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_2u __stdcall __std_minmax_2u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_2, false>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_4i __stdcall __std_minmax_4i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_4, true>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_4u __stdcall __std_minmax_4u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_4, false>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_8i __stdcall __std_minmax_8i(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_8, true>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_8u __stdcall __std_minmax_8u(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_8, false>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_f __stdcall __std_minmax_f(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_f, true>(_First, _Last);
+}
+
+__declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* const _First, const void* const _Last) noexcept {
+    return _Sorting::_Minmax_disp<_Sorting::_Mode_both, _Sorting::_Traits_d, true>(_First, _Last);
+}
+
+const void* __stdcall __std_is_sorted_until_1i(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_1, int8_t>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_1u(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_1, uint8_t>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_2i(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_2, int16_t>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_2u(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_2, uint16_t>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_4i(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_4, int32_t>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_4u(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_4, uint32_t>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_8i(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_8, int64_t>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_8u(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_8, uint64_t>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_f(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_f, float>(_First, _Last, _Greater);
+}
+
+const void* __stdcall __std_is_sorted_until_d(
+    const void* const _First, const void* const _Last, const bool _Greater) noexcept {
+    return _Sorting::_Is_sorted_until_disp<_Sorting::_Traits_d, double>(_First, _Last, _Greater);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Finding {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Find_traits_1 {
+            static uint8x16_t _Load_q(const void* const _Ptr) noexcept {
+                return vld1q_u8(static_cast<const uint8_t*>(_Ptr));
+            }
+
+            static uint8x8_t _Load(const void* const _Ptr) noexcept {
+                return vld1_u8(static_cast<const uint8_t*>(_Ptr));
+            }
+
+            static void _Store_q(void* const _Ptr, const uint8x16_t _Val) noexcept {
+                vst1q_u8(static_cast<uint8_t*>(_Ptr), _Val);
+            }
+
+            static void _Store(void* const _Ptr, const uint8x8_t _Val) noexcept {
+                vst1_u8(static_cast<uint8_t*>(_Ptr), _Val);
+            }
+
+            static uint8x16_t _Set_neon_q(const uint8_t _Val) noexcept {
+                return vdupq_n_u8(_Val);
+            }
+
+            static uint8x8_t _Set_neon(const uint8_t _Val) noexcept {
+                return vdup_n_u8(_Val);
+            }
+
+            static uint8x16_t _Cmp_neon_q(const uint8x16_t _Lhs, const uint8x16_t _Rhs) noexcept {
+                return vceqq_u8(_Lhs, _Rhs);
+            }
+
+            static uint8x8_t _Cmp_neon(const uint8x8_t _Lhs, const uint8x8_t _Rhs) noexcept {
+                return vceq_u8(_Lhs, _Rhs);
+            }
+
+            // Compresses a 128-bit Mask of 16 8-bit values into a 64-bit Mask of 16 4-bit values.
+            static uint64_t _Mask_q(const uint8x16_t _Val) noexcept {
+                const uint8x8_t _Res = vshrn_n_u16(vreinterpretq_u16_u8(_Val), 4);
+                return vget_lane_u64(vreinterpret_u64_u8(_Res), 0);
+            }
+
+            static uint64_t _Mask(const uint8x8_t _Val) noexcept {
+                return vget_lane_u64(vreinterpret_u64_u8(_Val), 0);
+            }
+
+            static uint64_t _Match_mask_eq(const uint8x16_t _Cmp_lo, const uint8x16_t _Cmp_hi) noexcept {
+                const auto _Cmp = vreinterpretq_u64_u8(vorrq_u8(_Cmp_lo, _Cmp_hi));
+                return vgetq_lane_u64(vpaddq_u64(_Cmp, _Cmp), 0);
+            }
+
+            static uint64_t _Match_mask_ne(const uint8x16_t _Cmp_lo, const uint8x16_t _Cmp_hi) noexcept {
+                const auto _Cmp  = vminq_u8(_Cmp_lo, _Cmp_hi);
+                const auto _Comb = vreinterpretq_u64_u8(vpminq_u8(_Cmp, _Cmp));
+                return vgetq_lane_u64(_Comb, 0) ^ 0xFFFF'FFFF'FFFF'FFFF;
+            }
+
+            static uint8x16_t _Blend_q(const uint8x16_t _Px1, const uint8x16_t _Px2, const uint8x16_t _Msk) noexcept {
+                return vbslq_u8(_Msk, _Px2, _Px1);
+            }
+
+            static uint8x8_t _Blend(const uint8x8_t _Px1, const uint8x8_t _Px2, const uint8x8_t _Msk) noexcept {
+                return vbsl_u8(_Msk, _Px2, _Px1);
+            }
+
+            static uint64_t _Nibble_mask(const uint8x16_t _Val) noexcept {
+                return _Mask_q(_Val);
+            }
+        };
+
+        struct _Find_traits_2 {
+            static uint16x8_t _Load_q(const void* const _Ptr) noexcept {
+                return vld1q_u16(static_cast<const uint16_t*>(_Ptr));
+            }
+
+            static uint16x4_t _Load(const void* const _Ptr) noexcept {
+                return vld1_u16(static_cast<const uint16_t*>(_Ptr));
+            }
+
+            static void _Store_q(void* const _Ptr, const uint16x8_t _Val) noexcept {
+                vst1q_u16(static_cast<uint16_t*>(_Ptr), _Val);
+            }
+
+            static void _Store(void* const _Ptr, const uint16x4_t _Val) noexcept {
+                vst1_u16(static_cast<uint16_t*>(_Ptr), _Val);
+            }
+
+            static uint16x8_t _Set_neon_q(const uint16_t _Val) noexcept {
+                return vdupq_n_u16(_Val);
+            }
+
+            static uint16x4_t _Set_neon(const uint16_t _Val) noexcept {
+                return vdup_n_u16(_Val);
+            }
+
+            static uint16x8_t _Cmp_neon_q(const uint16x8_t _Lhs, const uint16x8_t _Rhs) noexcept {
+                return vceqq_u16(_Lhs, _Rhs);
+            }
+
+            static uint16x4_t _Cmp_neon(const uint16x4_t _Lhs, const uint16x4_t _Rhs) noexcept {
+                return vceq_u16(_Lhs, _Rhs);
+            }
+
+            // Compresses a 128-bit Mask of 8 16-bit values into a 64-bit Mask of 8 8-bit values.
+            static uint64_t _Mask_q(const uint16x8_t _Val) noexcept {
+                const uint16x4_t _Res = vshrn_n_u32(vreinterpretq_u32_u16(_Val), 8);
+                return vget_lane_u64(vreinterpret_u64_u16(_Res), 0);
+            }
+
+            static uint64_t _Mask(const uint16x4_t _Val) noexcept {
+                return vget_lane_u64(vreinterpret_u64_u16(_Val), 0);
+            }
+
+            static uint64_t _Match_mask_eq(const uint16x8_t _Cmp_lo, const uint16x8_t _Cmp_hi) noexcept {
+                const uint8x8_t _Cmp = vaddhn_u16(_Cmp_lo, _Cmp_hi);
+                return vget_lane_u64(vreinterpret_u64_u8(_Cmp), 0);
+            }
+
+            static uint64_t _Match_mask_ne(const uint16x8_t _Cmp_lo, const uint16x8_t _Cmp_hi) noexcept {
+                const auto _Cmp  = vminq_u16(_Cmp_lo, _Cmp_hi);
+                const auto _Comb = vreinterpretq_u64_u16(vpminq_u16(_Cmp, _Cmp));
+                return vgetq_lane_u64(_Comb, 0) ^ 0xFFFF'FFFF'FFFF'FFFF;
+            }
+
+            static uint16x8_t _Blend_q(const uint16x8_t _Px1, const uint16x8_t _Px2, const uint16x8_t _Msk) noexcept {
+                return vbslq_u16(_Msk, _Px2, _Px1);
+            }
+
+            static uint16x4_t _Blend(const uint16x4_t _Px1, const uint16x4_t _Px2, const uint16x4_t _Msk) noexcept {
+                return vbsl_u16(_Msk, _Px2, _Px1);
+            }
+
+            static uint64_t _Nibble_mask(const uint16x8_t _Val) noexcept {
+                return _Find_traits_1::_Nibble_mask(vreinterpretq_u8_u16(_Val));
+            }
+        };
+
+        struct _Find_traits_4 {
+            static uint32x4_t _Load_q(const void* const _Ptr) noexcept {
+                return vld1q_u32(static_cast<const uint32_t*>(_Ptr));
+            }
+
+            static uint32x2_t _Load(const void* const _Ptr) noexcept {
+                return vld1_u32(static_cast<const uint32_t*>(_Ptr));
+            }
+
+            static void _Store_q(void* const _Ptr, const uint32x4_t _Val) noexcept {
+                vst1q_u32(static_cast<uint32_t*>(_Ptr), _Val);
+            }
+
+            static void _Store(void* const _Ptr, const uint32x2_t _Val) noexcept {
+                vst1_u32(static_cast<uint32_t*>(_Ptr), _Val);
+            }
+
+            static uint32x4_t _Set_neon_q(const uint32_t _Val) noexcept {
+                return vdupq_n_u32(_Val);
+            }
+
+            static uint32x2_t _Set_neon(const uint32_t _Val) noexcept {
+                return vdup_n_u32(_Val);
+            }
+
+            static uint32x4_t _Cmp_neon_q(const uint32x4_t _Lhs, const uint32x4_t _Rhs) noexcept {
+                return vceqq_u32(_Lhs, _Rhs);
+            }
+
+            static uint32x2_t _Cmp_neon(const uint32x2_t _Lhs, const uint32x2_t _Rhs) noexcept {
+                return vceq_u32(_Lhs, _Rhs);
+            }
+
+            // Compresses a 128-bit Mask of 4 32-bit values into a 64-bit Mask of 4 16-bit values.
+            static uint64_t _Mask_q(const uint32x4_t _Val) noexcept {
+                const uint32x2_t _Res = vshrn_n_u64(vreinterpretq_u64_u32(_Val), 16);
+                return vget_lane_u64(vreinterpret_u64_u32(_Res), 0);
+            }
+
+            static uint64_t _Mask(const uint32x2_t _Val) noexcept {
+                return vget_lane_u64(vreinterpret_u64_u32(_Val), 0);
+            }
+
+            static uint64_t _Match_mask_eq(const uint32x4_t _Cmp_lo, const uint32x4_t _Cmp_hi) noexcept {
+                const uint8x8_t _Cmp = vaddhn_u16(vreinterpretq_u16_u32(_Cmp_lo), vreinterpretq_u16_u32(_Cmp_hi));
+                return vget_lane_u64(vreinterpret_u64_u8(_Cmp), 0);
+            }
+
+            static uint64_t _Match_mask_ne(const uint32x4_t _Cmp_lo, const uint32x4_t _Cmp_hi) noexcept {
+                const auto _Cmp  = vminq_u32(_Cmp_lo, _Cmp_hi);
+                const auto _Comb = vreinterpretq_u64_u32(vpminq_u32(_Cmp, _Cmp));
+                return vgetq_lane_u64(_Comb, 0) ^ 0xFFFF'FFFF'FFFF'FFFF;
+            }
+
+            static uint32x4_t _Blend_q(const uint32x4_t _Px1, const uint32x4_t _Px2, const uint32x4_t _Msk) noexcept {
+                return vbslq_u32(_Msk, _Px2, _Px1);
+            }
+
+            static uint32x2_t _Blend(const uint32x2_t _Px1, const uint32x2_t _Px2, const uint32x2_t _Msk) noexcept {
+                return vbsl_u32(_Msk, _Px2, _Px1);
+            }
+
+            static uint64_t _Nibble_mask(const uint32x4_t _Val) noexcept {
+                return _Find_traits_1::_Nibble_mask(vreinterpretq_u8_u32(_Val));
+            }
+        };
+
+        struct _Find_traits_8 {
+            static uint64x2_t _Load_q(const void* const _Ptr) noexcept {
+                return vld1q_u64(static_cast<const uint64_t*>(_Ptr));
+            }
+
+            static void _Store_q(void* const _Ptr, const uint64x2_t _Val) noexcept {
+                vst1q_u64(static_cast<uint64_t*>(_Ptr), _Val);
+            }
+
+            static uint64x2_t _Set_neon_q(const uint64_t _Val) noexcept {
+                return vdupq_n_u64(_Val);
+            }
+
+            static uint64x2_t _Cmp_neon_q(const uint64x2_t _Lhs, const uint64x2_t _Rhs) noexcept {
+                return vceqq_u64(_Lhs, _Rhs);
+            }
+
+            // Compresses a 128-bit Mask of 2 64-bit values into a 64-bit Mask of 2 32-bit values.
+            static uint64_t _Mask_q(const uint64x2_t _Val) noexcept {
+                const uint32x2_t _Res = vmovn_u64(_Val);
+                return vget_lane_u64(vreinterpret_u64_u32(_Res), 0);
+            }
+
+            static uint64_t _Match_mask_eq(const uint64x2_t _Cmp_lo, const uint64x2_t _Cmp_hi) noexcept {
+                const uint8x8_t _Cmp = vaddhn_u16(vreinterpretq_u16_u64(_Cmp_lo), vreinterpretq_u16_u64(_Cmp_hi));
+                return vget_lane_u64(vreinterpret_u64_u8(_Cmp), 0);
+            }
+
+            static uint64_t _Match_mask_ne(const uint64x2_t _Cmp_lo, const uint64x2_t _Cmp_hi) noexcept {
+                return _Mask_q(vandq_u64(_Cmp_lo, _Cmp_hi)) ^ 0xFFFF'FFFF'FFFF'FFFF;
+            }
+
+            static uint64x2_t _Blend_q(const uint64x2_t _Px1, const uint64x2_t _Px2, const uint64x2_t _Msk) noexcept {
+                return vbslq_u64(_Msk, _Px2, _Px1);
+            }
+
+            static uint64_t _Nibble_mask(const uint64x2_t _Val) noexcept {
+                return _Find_traits_1::_Nibble_mask(vreinterpretq_u8_u64(_Val));
+            }
+        };
+
+        unsigned long _Get_first_h_pos_q(const uint64_t _Mask) noexcept {
+            return _CountTrailingZeros64(_Mask) >> 2;
+        }
+
+        unsigned long _Get_first_h_pos_d(const uint64_t _Mask) noexcept {
+            return _CountTrailingZeros64(_Mask) >> 3;
+        }
+
+        unsigned long _Get_last_h_pos_q(const uint64_t _Mask) noexcept {
+            return 15 - (_CountLeadingZeros64(_Mask) >> 2);
+        }
+
+        unsigned long _Get_last_h_pos_d(const uint64_t _Mask) noexcept {
+            return 7 - (_CountLeadingZeros64(_Mask) >> 3);
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Find_traits_1 {
+            static __m256i _Set_avx(const uint8_t _Val) noexcept {
+                return _mm256_set1_epi8(_Val);
+            }
+
+            static __m128i _Set_sse(const uint8_t _Val) noexcept {
+                return _mm_shuffle_epi8(_mm_cvtsi32_si128(_Val), _mm_setzero_si128());
+            }
+
+            static __m256i _Cmp_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_cmpeq_epi8(_Lhs, _Rhs);
+            }
+
+            static __m128i _Cmp_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_cmpeq_epi8(_Lhs, _Rhs);
+            }
+        };
+
+        struct _Find_traits_2 {
+            static __m256i _Set_avx(const uint16_t _Val) noexcept {
+                return _mm256_set1_epi16(_Val);
+            }
+
+            static __m128i _Set_sse(const uint16_t _Val) noexcept {
+                return _mm_set1_epi16(_Val);
+            }
+
+            static __m256i _Cmp_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_cmpeq_epi16(_Lhs, _Rhs);
+            }
+
+            static __m128i _Cmp_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_cmpeq_epi16(_Lhs, _Rhs);
+            }
+        };
+
+        struct _Find_traits_4 {
+            static __m256i _Set_avx(const uint32_t _Val) noexcept {
+                return _mm256_set1_epi32(_Val);
+            }
+
+            static __m128i _Set_sse(const uint32_t _Val) noexcept {
+                return _mm_set1_epi32(_Val);
+            }
+
+            static __m256i _Cmp_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_cmpeq_epi32(_Lhs, _Rhs);
+            }
+
+            static __m128i _Cmp_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_cmpeq_epi32(_Lhs, _Rhs);
+            }
+        };
+
+        struct _Find_traits_8 {
+            static __m256i _Set_avx(const uint64_t _Val) noexcept {
+                return _mm256_set1_epi64x(_Val);
+            }
+
+            static __m128i _Set_sse(const uint64_t _Val) noexcept {
+                return _mm_set1_epi64x(_Val);
+            }
+
+            static __m256i _Cmp_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_cmpeq_epi64(_Lhs, _Rhs);
+            }
+
+            static __m128i _Cmp_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_cmpeq_epi64(_Lhs, _Rhs);
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+#ifndef _M_ARM64
+        // TRANSITION, ABI: used only in functions preserved for binary compatibility
+        template <class _Ty>
+        const void* __stdcall _Find_unsized_impl(const void* const _First, const _Ty _Val) noexcept {
+            auto _Ptr = static_cast<const _Ty*>(_First);
+            while (*_Ptr != _Val) {
+                ++_Ptr;
+            }
+            return _Ptr;
+        }
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+        enum class _Predicate { _Equal, _Not_equal };
+
+        template <_Predicate _Pred, class _Ty>
+        const void* _Find_scalar_tail(const void* const _First, const void* const _Last, const _Ty _Val) noexcept {
+            auto _Ptr = static_cast<const _Ty*>(_First);
+            if constexpr (_Pred == _Predicate::_Not_equal) {
+                while (_Ptr != _Last && *_Ptr == _Val) {
+                    ++_Ptr;
+                }
+            } else {
+                while (_Ptr != _Last && *_Ptr != _Val) {
+                    ++_Ptr;
+                }
+            }
+            return _Ptr;
+        }
+
+        template <_Predicate _Pred, class _Ty>
+        const void* _Find_last_scalar_tail(
+            const void* const _First, const void* const _Last, const void* const _Real_last, const _Ty _Val) noexcept {
+            auto _Ptr = static_cast<const _Ty*>(_Last);
+
+            while (_Ptr != _First) {
+                --_Ptr;
+                if constexpr (_Pred == _Predicate::_Not_equal) {
+                    if (*_Ptr != _Val) {
+                        return _Ptr;
+                    }
+                } else {
+                    if (*_Ptr == _Val) {
+                        return _Ptr;
+                    }
+                }
+            }
+
+            return _Real_last;
+        }
+
+        // The below functions have exactly the same signature as the extern "C" functions, up to calling convention.
+        // This makes sure the template specialization can be fused with the extern "C" function.
+        // In optimized builds it avoids an extra call, as these functions are too large to inline.
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        template <class _Traits, _Predicate _Pred, class _Ty>
+        const void* __stdcall _Find_impl(const void* _First, const void* const _Last, const _Ty _Val) noexcept {
+            const size_t _Size_bytes = _Byte_length(_First, _Last);
+
+            if (const size_t _Neon_size = _Size_bytes & ~size_t{0x1F}; _Neon_size != 0) {
+                const auto _Comparand = _Traits::_Set_neon_q(_Val);
+                const void* _Stop_at  = _First;
+                _Advance_bytes(_Stop_at, _Neon_size);
+
+                do {
+                    const auto _Data_lo = _Traits::_Load_q(static_cast<const uint8_t*>(_First) + 0);
+                    const auto _Data_hi = _Traits::_Load_q(static_cast<const uint8_t*>(_First) + 16);
+
+                    const auto _Comparison_lo = _Traits::_Cmp_neon_q(_Data_lo, _Comparand);
+                    const auto _Comparison_hi = _Traits::_Cmp_neon_q(_Data_hi, _Comparand);
+
+                    // Use a fast check for the termination condition.
+                    uint64_t _Any_match = 0;
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Any_match = _Traits::_Match_mask_ne(_Comparison_lo, _Comparison_hi);
+                    } else {
+                        _Any_match = _Traits::_Match_mask_eq(_Comparison_lo, _Comparison_hi);
+                    }
+
+                    if (_Any_match != 0) {
+                        auto _Mask_lo = _Traits::_Mask_q(_Comparison_lo);
+                        if constexpr (_Pred == _Predicate::_Not_equal) {
+                            _Mask_lo ^= 0xFFFF'FFFF'FFFF'FFFF;
+                        }
+
+                        if (_Mask_lo != 0) {
+                            const auto _Offset = _Get_first_h_pos_q(_Mask_lo);
+                            _Advance_bytes(_First, _Offset);
+                            return _First;
+                        }
+
+                        auto _Mask_hi = _Traits::_Mask_q(_Comparison_hi);
+                        if constexpr (_Pred == _Predicate::_Not_equal) {
+                            _Mask_hi ^= 0xFFFF'FFFF'FFFF'FFFF;
+                        }
+
+                        const auto _Offset = _Get_first_h_pos_q(_Mask_hi) + 16;
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, 32);
+                } while (_First != _Stop_at);
+            }
+
+            if ((_Size_bytes & size_t{0x10}) != 0) { // use original _Size_bytes; we've read only 32-byte chunks
+                const auto _Comparand = _Traits::_Set_neon_q(_Val);
+                const auto _Data      = _Traits::_Load_q(_First);
+
+                const auto _Comparison = _Traits::_Cmp_neon_q(_Data, _Comparand);
+
+                auto _Match = _Traits::_Mask_q(_Comparison);
+                if constexpr (_Pred == _Predicate::_Not_equal) {
+                    _Match ^= 0xFFFF'FFFF'FFFF'FFFF;
+                }
+
+                if (_Match != 0) {
+                    const auto _Offset = _Get_first_h_pos_q(_Match);
+                    _Advance_bytes(_First, _Offset);
+                    return _First;
+                }
+
+                _Advance_bytes(_First, 16);
+            }
+
+            if constexpr (sizeof(_Ty) < 8) {
+                if ((_Size_bytes & size_t{0x08}) != 0) { // use original _Size_bytes; we've read only 16/32-byte chunks
+                    const auto _Comparand = _Traits::_Set_neon(_Val);
+                    const auto _Data      = _Traits::_Load(_First);
+
+                    const auto _Comparison = _Traits::_Cmp_neon(_Data, _Comparand);
+
+                    auto _Match = _Traits::_Mask(_Comparison);
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Match ^= 0xFFFF'FFFF'FFFF'FFFF;
+                    }
+
+                    if (_Match != 0) {
+                        const auto _Offset = _Get_first_h_pos_d(_Match);
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, 8);
+                }
+            }
+
+            return _Find_scalar_tail<_Pred>(_First, _Last, _Val);
+        }
+
+        template <class _Traits, _Predicate _Pred, class _Ty>
+        const void* __stdcall _Find_last_impl(const void* const _First, const void* _Last, const _Ty _Val) noexcept {
+            const void* const _Real_last = _Last;
+            const size_t _Size_bytes     = _Byte_length(_First, _Last);
+
+            if (const size_t _Neon_size = _Size_bytes & ~size_t{0x1F}; _Neon_size != 0) {
+                const auto _Comparand = _Traits::_Set_neon_q(_Val);
+                const void* _Stop_at  = _Last;
+                _Rewind_bytes(_Stop_at, _Neon_size);
+
+                do {
+                    _Rewind_bytes(_Last, 32);
+                    const auto _Data_lo = _Traits::_Load_q(static_cast<const uint8_t*>(_Last) + 0);
+                    const auto _Data_hi = _Traits::_Load_q(static_cast<const uint8_t*>(_Last) + 16);
+
+                    const auto _Comparison_lo = _Traits::_Cmp_neon_q(_Data_lo, _Comparand);
+                    const auto _Comparison_hi = _Traits::_Cmp_neon_q(_Data_hi, _Comparand);
+
+                    // Use a fast check for the termination condition.
+                    uint64_t _Any_match = 0;
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Any_match = _Traits::_Match_mask_ne(_Comparison_lo, _Comparison_hi);
+                    } else {
+                        _Any_match = _Traits::_Match_mask_eq(_Comparison_lo, _Comparison_hi);
+                    }
+
+                    if (_Any_match != 0) {
+                        auto _Mask_hi = _Traits::_Mask_q(_Comparison_hi);
+                        if constexpr (_Pred == _Predicate::_Not_equal) {
+                            _Mask_hi ^= 0xFFFF'FFFF'FFFF'FFFF;
+                        }
+
+                        if (_Mask_hi != 0) {
+                            const auto _Offset = _Get_last_h_pos_q(_Mask_hi) + 16;
+                            _Advance_bytes(_Last, _Offset - (sizeof(_Ty) - 1));
+                            return _Last;
+                        }
+
+                        auto _Mask_lo = _Traits::_Mask_q(_Comparison_lo);
+                        if constexpr (_Pred == _Predicate::_Not_equal) {
+                            _Mask_lo ^= 0xFFFF'FFFF'FFFF'FFFF;
+                        }
+
+                        const auto _Offset = _Get_last_h_pos_q(_Mask_lo);
+                        _Advance_bytes(_Last, _Offset - (sizeof(_Ty) - 1));
+                        return _Last;
+                    }
+                } while (_Last != _Stop_at);
+            }
+
+            if ((_Size_bytes & size_t{0x10}) != 0) { // use original _Size_bytes; we've read only 32-byte chunks
+                const auto _Comparand = _Traits::_Set_neon_q(_Val);
+                _Rewind_bytes(_Last, 16);
+                const auto _Data = _Traits::_Load_q(_Last);
+
+                const auto _Comparison = _Traits::_Cmp_neon_q(_Data, _Comparand);
+
+                auto _Match = _Traits::_Mask_q(_Comparison);
+                if constexpr (_Pred == _Predicate::_Not_equal) {
+                    _Match ^= 0xFFFF'FFFF'FFFF'FFFF;
+                }
+
+                if (_Match != 0) {
+                    const auto _Offset = _Get_last_h_pos_q(_Match);
+                    _Advance_bytes(_Last, _Offset - (sizeof(_Ty) - 1));
+                    return _Last;
+                }
+            }
+
+            if constexpr (sizeof(_Ty) < 8) {
+                if ((_Size_bytes & size_t{0x08}) != 0) { // use original _Size_bytes; we've read only 16/32-byte chunks
+                    const auto _Comparand = _Traits::_Set_neon(_Val);
+                    _Rewind_bytes(_Last, 8);
+                    const auto _Data = _Traits::_Load(_Last);
+
+                    const auto _Comparison = _Traits::_Cmp_neon(_Data, _Comparand);
+
+                    auto _Match = _Traits::_Mask(_Comparison);
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Match ^= 0xFFFF'FFFF'FFFF'FFFF;
+                    }
+
+                    if (_Match != 0) {
+                        const auto _Offset = _Get_last_h_pos_d(_Match);
+                        _Advance_bytes(_Last, _Offset - (sizeof(_Ty) - 1));
+                        return _Last;
+                    }
+                }
+            }
+
+            return _Find_last_scalar_tail<_Pred>(_First, _Last, _Real_last, _Val);
+        }
+
+        template <class _Traits, class _Ty>
+        const void* __stdcall _Adjacent_find_impl(const void* _First, const void* const _Last) noexcept {
+            if (_First == _Last) {
+                return _Last;
+            }
+
+            const size_t _Size_bytes = _Byte_length(_First, _Last) - sizeof(_Ty);
+
+            if (const size_t _Neon_size = _Size_bytes & ~size_t{0x1F}; _Neon_size != 0) {
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, _Neon_size);
+
+                do {
+                    const void* _Next = _First;
+                    _Advance_bytes(_Next, sizeof(_Ty));
+
+                    const auto _Data_lo      = _Traits::_Load_q(static_cast<const uint8_t*>(_First) + 0);
+                    const auto _Data_hi      = _Traits::_Load_q(static_cast<const uint8_t*>(_First) + 16);
+                    const auto _Comparand_lo = _Traits::_Load_q(static_cast<const uint8_t*>(_Next) + 0);
+                    const auto _Comparand_hi = _Traits::_Load_q(static_cast<const uint8_t*>(_Next) + 16);
+
+                    const auto _Comparison_lo = _Traits::_Cmp_neon_q(_Data_lo, _Comparand_lo);
+                    const auto _Comparison_hi = _Traits::_Cmp_neon_q(_Data_hi, _Comparand_hi);
+
+                    // Use a fast check for the termination condition.
+                    const uint64_t _Any_match = _Traits::_Match_mask_eq(_Comparison_lo, _Comparison_hi);
+
+                    if (_Any_match != 0) {
+                        const auto _Mask_lo = _Traits::_Mask_q(_Comparison_lo);
+                        if (_Mask_lo != 0) {
+                            const auto _Offset = _Get_first_h_pos_q(_Mask_lo);
+                            _Advance_bytes(_First, _Offset);
+                            return _First;
+                        }
+
+                        const auto _Mask_hi = _Traits::_Mask_q(_Comparison_hi);
+                        const auto _Offset  = _Get_first_h_pos_q(_Mask_hi) + 16;
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, 32);
+                } while (_First != _Stop_at);
+            }
+
+            if ((_Size_bytes & size_t{0x10}) != 0) { // use original _Size_bytes; we've read only 32-byte chunks
+                const void* _Next = _First;
+                _Advance_bytes(_Next, sizeof(_Ty));
+
+                const auto _Data      = _Traits::_Load_q(_First);
+                const auto _Comparand = _Traits::_Load_q(_Next);
+
+                const auto _Comparison = _Traits::_Cmp_neon_q(_Data, _Comparand);
+
+                const auto _Match = _Traits::_Mask_q(_Comparison);
+                if (_Match != 0) {
+                    const auto _Offset = _Get_first_h_pos_q(_Match);
+                    _Advance_bytes(_First, _Offset);
+                    return _First;
+                }
+
+                _Advance_bytes(_First, 16);
+            }
+
+            if constexpr (sizeof(_Ty) < 8) {
+                if ((_Size_bytes & size_t{0x08}) != 0) { // use original _Size_bytes; we've read only 16/32-byte chunks
+                    const void* _Next = _First;
+                    _Advance_bytes(_Next, sizeof(_Ty));
+
+                    const auto _Data      = _Traits::_Load(_First);
+                    const auto _Comparand = _Traits::_Load(_Next);
+
+                    const auto _Comparison = _Traits::_Cmp_neon(_Data, _Comparand);
+
+                    const auto _Match = _Traits::_Mask(_Comparison);
+                    if (_Match != 0) {
+                        const auto _Offset = _Get_first_h_pos_d(_Match);
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, 8);
+                }
+            }
+
+            auto _Ptr  = static_cast<const _Ty*>(_First);
+            auto _Next = _Ptr + 1;
+            for (; _Next != _Last; ++_Ptr, ++_Next) {
+                if (*_Ptr == *_Next) {
+                    return _Ptr;
+                }
+            }
+
+            return _Last;
+        }
+
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        template <class _Traits, _Predicate _Pred, class _Ty>
+        const void* __stdcall _Find_impl(const void* _First, const void* const _Last, const _Ty _Val) noexcept {
+            const size_t _Size_bytes = _Byte_length(_First, _Last);
+
+            if (const size_t _Avx_size = _Size_bytes & ~size_t{0x1F}; _Avx_size != 0 && _Use_avx2()) {
+                _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
+
+                const __m256i _Comparand = _Traits::_Set_avx(_Val);
+                const void* _Stop_at     = _First;
+                _Advance_bytes(_Stop_at, _Avx_size);
+
+                do {
+                    const __m256i _Data = _mm256_loadu_si256(static_cast<const __m256i*>(_First));
+                    unsigned int _Bingo = _mm256_movemask_epi8(_Traits::_Cmp_avx(_Data, _Comparand));
+
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Bingo ^= 0xFFFF'FFFF;
+                    }
+
+                    if (_Bingo != 0) {
+                        const unsigned long _Offset = _tzcnt_u32(_Bingo);
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, 32);
+                } while (_First != _Stop_at);
+
+                if (const size_t _Avx_tail_size = _Size_bytes & 0x1C; _Avx_tail_size != 0) {
+                    const __m256i _Tail_mask = _Avx2_tail_mask_32(_Avx_tail_size);
+                    const __m256i _Data      = _mm256_maskload_epi32(static_cast<const int*>(_First), _Tail_mask);
+                    const __m256i _Cmp       = _Traits::_Cmp_avx(_Data, _Comparand);
+                    unsigned int _Bingo      = _mm256_movemask_epi8(_mm256_and_si256(_Cmp, _Tail_mask));
+
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Bingo ^= (1 << _Avx_tail_size) - 1;
+                    }
+
+                    if (_Bingo != 0) {
+                        const unsigned long _Offset = _tzcnt_u32(_Bingo);
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, _Avx_tail_size);
+                }
+
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return _First;
+                }
+            } else if (const size_t _Sse_size = _Size_bytes & ~size_t{0xF}; _Sse_size != 0 && _Use_sse42()) {
+                const __m128i _Comparand = _Traits::_Set_sse(_Val);
+                const void* _Stop_at     = _First;
+                _Advance_bytes(_Stop_at, _Sse_size);
+
+                do {
+                    const __m128i _Data = _mm_loadu_si128(static_cast<const __m128i*>(_First));
+                    unsigned int _Bingo = _mm_movemask_epi8(_Traits::_Cmp_sse(_Data, _Comparand));
+
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Bingo ^= 0xFFFF;
+                    }
+
+                    if (_Bingo != 0) {
+                        unsigned long _Offset;
+                        // CodeQL [SM02313] _Offset is always initialized: we just tested `if (_Bingo != 0)`.
+                        _BitScanForward(&_Offset, _Bingo);
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, 16);
+                } while (_First != _Stop_at);
+            }
+
+            return _Find_scalar_tail<_Pred>(_First, _Last, _Val);
+        }
+
+        template <class _Traits, _Predicate _Pred, class _Ty>
+        const void* __stdcall _Find_last_impl(const void* const _First, const void* _Last, const _Ty _Val) noexcept {
+            const void* const _Real_last = _Last;
+
+            const size_t _Size_bytes = _Byte_length(_First, _Last);
+
+            if (const size_t _Avx_size = _Size_bytes & ~size_t{0x1F}; _Avx_size != 0 && _Use_avx2()) {
+                _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
+
+                const __m256i _Comparand = _Traits::_Set_avx(_Val);
+                const void* _Stop_at     = _Last;
+                _Rewind_bytes(_Stop_at, _Avx_size);
+
+                do {
+                    _Rewind_bytes(_Last, 32);
+                    const __m256i _Data = _mm256_loadu_si256(static_cast<const __m256i*>(_Last));
+                    unsigned int _Bingo = _mm256_movemask_epi8(_Traits::_Cmp_avx(_Data, _Comparand));
+
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Bingo ^= 0xFFFF'FFFF;
+                    }
+
+                    if (_Bingo != 0) {
+                        const unsigned long _Offset = _lzcnt_u32(_Bingo);
+                        _Advance_bytes(_Last, (31 - _Offset) - (sizeof(_Ty) - 1));
+                        return _Last;
+                    }
+                } while (_Last != _Stop_at);
+
+                if (const size_t _Avx_tail_size = _Size_bytes & 0x1C; _Avx_tail_size != 0) {
+                    _Rewind_bytes(_Last, _Avx_tail_size);
+                    const __m256i _Tail_mask = _Avx2_tail_mask_32(_Avx_tail_size);
+                    const __m256i _Data      = _mm256_maskload_epi32(static_cast<const int*>(_Last), _Tail_mask);
+                    const __m256i _Cmp       = _Traits::_Cmp_avx(_Data, _Comparand);
+                    unsigned int _Bingo      = _mm256_movemask_epi8(_mm256_and_si256(_Cmp, _Tail_mask));
+
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Bingo ^= (1 << _Avx_tail_size) - 1;
+                    }
+
+                    if (_Bingo != 0) {
+                        const unsigned long _Offset = _lzcnt_u32(_Bingo);
+                        _Advance_bytes(_Last, (31 - _Offset) - (sizeof(_Ty) - 1));
+                        return _Last;
+                    }
+                }
+
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return _Real_last;
+                }
+            } else if (const size_t _Sse_size = _Size_bytes & ~size_t{0xF}; _Sse_size != 0 && _Use_sse42()) {
+                const __m128i _Comparand = _Traits::_Set_sse(_Val);
+                const void* _Stop_at     = _Last;
+                _Rewind_bytes(_Stop_at, _Sse_size);
+
+                do {
+                    _Rewind_bytes(_Last, 16);
+                    const __m128i _Data = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
+                    unsigned int _Bingo = _mm_movemask_epi8(_Traits::_Cmp_sse(_Data, _Comparand));
+
+                    if constexpr (_Pred == _Predicate::_Not_equal) {
+                        _Bingo ^= 0xFFFF;
+                    }
+
+                    if (_Bingo != 0) {
+                        unsigned long _Offset;
+                        // CodeQL [SM02313] _Offset is always initialized: we just tested `if (_Bingo != 0)`.
+                        _BitScanReverse(&_Offset, _Bingo);
+                        _Advance_bytes(_Last, _Offset - (sizeof(_Ty) - 1));
+                        return _Last;
+                    }
+                } while (_Last != _Stop_at);
+            }
+            return _Find_last_scalar_tail<_Pred>(_First, _Last, _Real_last, _Val);
+        }
+
+        template <class _Traits, class _Ty>
+        const void* __stdcall _Adjacent_find_impl(const void* _First, const void* const _Last) noexcept {
+            if (_First == _Last) {
+                return _Last;
+            }
+
+            const size_t _Size_bytes = _Byte_length(_First, _Last) - sizeof(_Ty);
+
+            if (const size_t _Avx_size = _Size_bytes & ~size_t{0x1F}; _Avx_size != 0 && _Use_avx2()) {
+                _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
+
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, _Avx_size);
+
+                do {
+                    const void* _Next = _First;
+                    _Advance_bytes(_Next, sizeof(_Ty));
+
+                    const __m256i _Data       = _mm256_loadu_si256(static_cast<const __m256i*>(_First));
+                    const __m256i _Comparand  = _mm256_loadu_si256(static_cast<const __m256i*>(_Next));
+                    const unsigned int _Bingo = _mm256_movemask_epi8(_Traits::_Cmp_avx(_Data, _Comparand));
+
+                    if (_Bingo != 0) {
+                        const unsigned long _Offset = _tzcnt_u32(_Bingo);
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, 32);
+                } while (_First != _Stop_at);
+
+                if (const size_t _Avx_tail_size = _Size_bytes & 0x1C; _Avx_tail_size != 0) {
+                    const void* _Next = _First;
+                    _Advance_bytes(_Next, sizeof(_Ty));
+
+                    const __m256i _Tail_mask  = _Avx2_tail_mask_32(_Avx_tail_size);
+                    const __m256i _Data       = _mm256_maskload_epi32(static_cast<const int*>(_First), _Tail_mask);
+                    const __m256i _Comparand  = _mm256_maskload_epi32(static_cast<const int*>(_Next), _Tail_mask);
+                    const __m256i _Cmp        = _Traits::_Cmp_avx(_Data, _Comparand);
+                    const unsigned int _Bingo = _mm256_movemask_epi8(_mm256_and_si256(_Cmp, _Tail_mask));
+
+                    if (_Bingo != 0) {
+                        const unsigned long _Offset = _tzcnt_u32(_Bingo);
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, _Avx_tail_size);
+                }
+
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return _Last;
+                }
+            } else if (const size_t _Sse_size = _Size_bytes & ~size_t{0xF}; _Sse_size != 0 && _Use_sse42()) {
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, _Sse_size);
+
+                do {
+                    const void* _Next = _First;
+                    _Advance_bytes(_Next, sizeof(_Ty));
+
+                    const __m128i _Data       = _mm_loadu_si128(static_cast<const __m128i*>(_First));
+                    const __m128i _Comparand  = _mm_loadu_si128(static_cast<const __m128i*>(_Next));
+                    const unsigned int _Bingo = _mm_movemask_epi8(_Traits::_Cmp_sse(_Data, _Comparand));
+
+                    if (_Bingo != 0) {
+                        unsigned long _Offset;
+                        // CodeQL [SM02313] _Offset is always initialized: we just tested `if (_Bingo != 0)`.
+                        _BitScanForward(&_Offset, _Bingo);
+                        _Advance_bytes(_First, _Offset);
+                        return _First;
+                    }
+
+                    _Advance_bytes(_First, 16);
+                } while (_First != _Stop_at);
+            }
+
+            auto _Ptr  = static_cast<const _Ty*>(_First);
+            auto _Next = _Ptr + 1;
+            for (; _Next != _Last; ++_Ptr, ++_Next) {
+                if (*_Ptr == *_Next) {
+                    return _Ptr;
+                }
+            }
+
+            return _Last;
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        template <class _Ty>
+        const void* _Search_n_tail(const void* const _First, const void* const _Last, const size_t _Count,
+            const _Ty* _Mid1, const _Ty _Val) noexcept {
+            auto _Match_start    = static_cast<const _Ty*>(_First);
+            const auto _Last_ptr = static_cast<const _Ty*>(_Last);
+
+            if (static_cast<size_t>(_Last_ptr - _Match_start) < _Count) {
+                return _Last_ptr;
+            }
+
+            auto _Match_end = _Match_start + _Count;
+            auto _Mid2      = _Match_end;
+            for (;;) {
+                // Invariants: _Match_end - _Match_start == _Count, [_Match_start, _Mid1) and [_Mid2, _Match_end) match
+                // _Val:
+                //
+                // _Match_start  _Mid1    _Mid2    _Match_end
+                // |=============|????????|========|??????????...
+
+                --_Mid2;
+                if (*_Mid2 == _Val) { // match;
+                    if (_Mid1 == _Mid2) { // [_Mid1, _Mid2) is empty, so [_Match_start, _Match_end) all match
+                        return _Match_start;
+                    }
+                } else { // mismatch; skip past it
+                    _Match_start = _Mid2 + 1;
+
+                    if (static_cast<size_t>(_Last_ptr - _Match_start) < _Count) { // not enough space left
+                        return _Last_ptr;
+                    }
+
+                    _Mid1      = _Match_end;
+                    _Match_end = _Match_start + _Count;
+                    _Mid2      = _Match_end;
+                }
+            }
+        }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        template <class _Traits, class _Ty>
+        const void* __stdcall _Search_n_impl(
+            const void* _First, const void* const _Last, const size_t _Count, const _Ty _Val) noexcept {
+            if (_Count == 0) {
+                return _First;
+            } else if (_Count == 1) {
+                return _Find_impl<_Traits, _Predicate::_Equal>(_First, _Last, _Val);
+            }
+
+            auto _Mid1           = static_cast<const _Ty*>(_First);
+            const size_t _Length = _Byte_length(_First, _Last);
+            if (_Count <= 8 / sizeof(_Ty) && _Length >= 16) {
+                // We use 64-bit masks, consisting of 4-bits per byte of the input element.
+                constexpr size_t _Bits_per_element = sizeof(_Ty) << 2;
+                const size_t _Count_bits           = _Count * _Bits_per_element;
+                const size_t _Sh1                  = sizeof(_Ty) != 1 ? 0 : (_Count_bits < 16 ? _Count_bits - 8 : 8);
+                const size_t _Sh2                  = sizeof(_Ty) >= 4 ? 0
+                                                   : _Count_bits < 16 ? 0
+                                                                      : (_Count_bits < 32 ? _Count_bits - 16 : 16);
+
+                const auto _Comparand = _Traits::_Set_neon_q(_Val);
+
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, _Length & ~size_t{0xF});
+
+                uint64_t _Carry = 0;
+                do {
+                    const auto _Data = _Traits::_Load_q(_First);
+
+                    const auto _Cmp      = _Traits::_Cmp_neon_q(_Comparand, _Data);
+                    const uint64_t _Mask = _Traits::_Nibble_mask(_Cmp);
+
+                    if (_Carry != 0) {
+                        const uint64_t _Tail_bits   = _CountLeadingZeros64(~_Carry);
+                        const uint64_t _Need        = _Count_bits - _Tail_bits;
+                        const uint64_t _Prefix_mask = (uint64_t{1} << _Need) - 1;
+                        if ((_Mask & _Prefix_mask) == _Prefix_mask) {
+                            _Rewind_bytes(_First, _Tail_bits >> 2);
+                            return _First;
+                        }
+                    }
+
+                    uint64_t _MskX = _Mask;
+
+                    _MskX = (_MskX >> _Bits_per_element) & _MskX;
+
+                    if constexpr (sizeof(_Ty) == 1) {
+                        _MskX = (_MskX >> _Sh1) & _MskX;
+                    }
+
+                    if constexpr (sizeof(_Ty) < 4) {
+                        _MskX = (_MskX >> _Sh2) & _MskX;
+                    }
+
+                    if (_MskX != 0) {
+                        const auto _Pos = _CountTrailingZeros64(_MskX) >> 2;
+                        _Advance_bytes(_First, _Pos);
+                        return _First;
+                    }
+
+                    _Carry = _Mask;
+
+                    _Advance_bytes(_First, 16);
+                } while (_First != _Stop_at);
+
+                _Mid1 = static_cast<const _Ty*>(_First);
+
+                const auto _Tail_run = _CountLeadingZeros64(~_Carry) >> 2;
+                _Rewind_bytes(_First, _Tail_run);
+            }
+
+            return _Search_n_tail(_First, _Last, _Count, _Mid1, _Val);
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        template <class _Traits, class _Ty>
+        const void* __stdcall _Search_n_impl(
+            const void* _First, const void* const _Last, const size_t _Count, const _Ty _Val) noexcept {
+            if (_Count == 0) {
+                return _First;
+            } else if (_Count == 1) {
+                return _Find_impl<_Traits, _Predicate::_Equal>(_First, _Last, _Val);
+            }
+
+            auto _Mid1           = static_cast<const _Ty*>(_First);
+            const size_t _Length = _Byte_length(_First, _Last);
+            if (_Count <= 16 / sizeof(_Ty) && _Length >= 32 && _Use_avx2()) {
+                _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
+
+                const int _Bytes_count = static_cast<int>(_Count * sizeof(_Ty));
+                const int _Sh1         = sizeof(_Ty) != 1 ? 0 : (_Bytes_count < 4 ? _Bytes_count - 2 : 2);
+                const int _Sh2         = sizeof(_Ty) >= 4 ? 0
+                                       : _Bytes_count < 4 ? 0
+                                                          : (_Bytes_count < 8 ? _Bytes_count - 4 : 4);
+                const int _Sh3         = sizeof(_Ty) == 8 ? 0 : (_Bytes_count < 8 ? 0 : _Bytes_count - 8);
+
+                const __m256i _Comparand = _Traits::_Set_avx(_Val);
+
+                const void* _Stop_at = _First;
+                _Advance_bytes(_Stop_at, _Length & ~size_t{0x1F});
+
+                uint32_t _Carry = 0;
+                do {
+                    const __m256i _Data = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First));
+
+                    const __m256i _Cmp   = _Traits::_Cmp_avx(_Comparand, _Data);
+                    const uint32_t _Mask = _mm256_movemask_epi8(_Cmp);
+
+                    uint64_t _MskX = uint64_t{_Carry} | (uint64_t{_Mask} << 32);
+
+                    _MskX = (_MskX >> sizeof(_Ty)) & _MskX;
+
+                    // Use __ull_rshift for better codegen in 32-bit mode, assuming the shifts are small.
+                    // In 64-bit mode, __ull_rshift works exactly the same as the right shift operator.
+
+                    if constexpr (sizeof(_Ty) == 1) {
+                        _MskX = __ull_rshift(_MskX, _Sh1) & _MskX;
+                    }
+
+                    if constexpr (sizeof(_Ty) < 4) {
+                        _MskX = __ull_rshift(_MskX, _Sh2) & _MskX;
+                    }
+
+                    if constexpr (sizeof(_Ty) < 8) {
+                        _MskX = __ull_rshift(_MskX, _Sh3) & _MskX;
+                    }
+
+                    if (_MskX != 0) {
+#ifdef _WIN64
+                        const long long _Shift = static_cast<long long>(_tzcnt_u64(_MskX)) - 32;
+#else // ^^^ 64-bit / 32-bit vvv
+                        const uint32_t _MskLow = static_cast<uint32_t>(_MskX);
+
+                        const int _Shift = _MskLow != 0
+                                             ? static_cast<int>(_tzcnt_u32(_MskLow)) - 32
+                                             : static_cast<int>(_tzcnt_u32(static_cast<uint32_t>(_MskX >> 32)));
+#endif // ^^^ 32-bit ^^^
+                        _Advance_bytes(_First, _Shift);
+                        return _First;
+                    }
+
+                    _Carry = _Mask;
+
+                    _Advance_bytes(_First, 32);
+                } while (_First != _Stop_at);
+
+                if (const size_t _Tail = _Length & 0x1C; _Tail != 0) {
+                    const __m256i _Tail_mask = _Avx2_tail_mask_32(_Tail);
+                    const __m256i _Data      = _mm256_maskload_epi32(reinterpret_cast<const int*>(_First), _Tail_mask);
+
+                    const __m256i _Cmp   = _Traits::_Cmp_avx(_Comparand, _Data);
+                    const uint32_t _Mask = _mm256_movemask_epi8(_mm256_and_si256(_Cmp, _Tail_mask));
+
+                    const uint64_t _Msk_with_carry = uint64_t{_Carry} | (uint64_t{_Mask} << 32);
+                    uint64_t _MskX                 = _Msk_with_carry;
+
+                    _MskX = (_MskX >> sizeof(_Ty)) & _MskX;
+
+                    if constexpr (sizeof(_Ty) == 1) {
+                        _MskX = __ull_rshift(_MskX, _Sh1) & _MskX;
+                    }
+
+                    if constexpr (sizeof(_Ty) < 4) {
+                        _MskX = __ull_rshift(_MskX, _Sh2) & _MskX;
+                    }
+
+                    if constexpr (sizeof(_Ty) < 8) {
+                        _MskX = __ull_rshift(_MskX, _Sh3) & _MskX;
+                    }
+
+                    if (_MskX != 0) {
+#ifdef _WIN64
+                        const long long _Shift = static_cast<long long>(_tzcnt_u64(_MskX)) - 32;
+#else // ^^^ 64-bit / 32-bit vvv
+                        const uint32_t _MskLow = static_cast<uint32_t>(_MskX);
+
+                        const int _Shift = _MskLow != 0
+                                             ? static_cast<int>(_tzcnt_u32(_MskLow)) - 32
+                                             : static_cast<int>(_tzcnt_u32(static_cast<uint32_t>(_MskX >> 32)));
+#endif // ^^^ 32-bit ^^^
+                        _Advance_bytes(_First, _Shift);
+                        return _First;
+                    }
+
+                    _Carry = static_cast<uint32_t>(__ull_rshift(_Msk_with_carry, static_cast<int>(_Tail)));
+
+                    _Advance_bytes(_First, _Tail);
+                }
+
+                _Mid1 = static_cast<const _Ty*>(_First);
+                _Rewind_bytes(_First, _lzcnt_u32(~_Carry));
+            } else if constexpr (sizeof(_Ty) < 8) {
+                if (_Count <= 8 / sizeof(_Ty) && _Length >= 16 && _Use_sse42()) {
+                    const int _Bytes_count = static_cast<int>(_Count * sizeof(_Ty));
+                    const int _Sh1         = sizeof(_Ty) != 1 ? 0 : (_Bytes_count < 4 ? _Bytes_count - 2 : 2);
+                    const int _Sh2         = sizeof(_Ty) >= 4 ? 0
+                                           : _Bytes_count < 4 ? 0
+                                                              : (_Bytes_count < 8 ? _Bytes_count - 4 : 4);
+
+                    const __m128i _Comparand = _Traits::_Set_sse(_Val);
+
+                    const void* _Stop_at = _First;
+                    _Advance_bytes(_Stop_at, _Length & ~size_t{0xF});
+
+                    uint32_t _Carry = 0;
+                    do {
+                        const __m128i _Data = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_First));
+
+                        const __m128i _Cmp   = _Traits::_Cmp_sse(_Comparand, _Data);
+                        const uint32_t _Mask = _mm_movemask_epi8(_Cmp);
+
+                        uint32_t _MskX = _Carry | (_Mask << 16);
+
+                        _MskX = (_MskX >> sizeof(_Ty)) & _MskX;
+
+                        if constexpr (sizeof(_Ty) == 1) {
+                            _MskX = (_MskX >> _Sh1) & _MskX;
+                        }
+
+                        if constexpr (sizeof(_Ty) < 4) {
+                            _MskX = (_MskX >> _Sh2) & _MskX;
+                        }
+
+                        if (_MskX != 0) {
+                            unsigned long _Pos;
+                            // CodeQL [SM02313] _Pos is always initialized: _MskX != 0 was checked right above.
+                            _BitScanForward(&_Pos, _MskX);
+                            _Advance_bytes(_First, static_cast<ptrdiff_t>(_Pos) - 16);
+                            return _First;
+                        }
+
+                        _Carry = _Mask;
+
+                        _Advance_bytes(_First, 16);
+                    } while (_First != _Stop_at);
+
+                    _Mid1 = static_cast<const _Ty*>(_First);
+
+                    unsigned long _Carry_pos;
+                    // Here, _Carry can't be 0xFFFF, because that would have been a match. Therefore:
+                    // CodeQL [SM02313] _Carry_pos is always initialized: `(_Carry ^ 0xFFFF) != 0` is always true.
+                    _BitScanReverse(&_Carry_pos, _Carry ^ 0xFFFF);
+                    _Rewind_bytes(_First, 15 - static_cast<ptrdiff_t>(_Carry_pos));
+                }
+            }
+
+            return _Search_n_tail(_First, _Last, _Count, _Mid1, _Val);
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        template <class _Traits, _Predicate _Pred, class _Ty>
+        size_t __stdcall _Find_last_pos_impl(
+            const void* const _First, const void* const _Last, const _Ty _Val) noexcept {
+            const void* const _Result = _Find_last_impl<_Traits, _Pred>(_First, _Last, _Val);
+            if (_Result == _Last) {
+                return static_cast<size_t>(-1);
+            } else {
+                return _Byte_length(_First, _Result) / sizeof(_Ty);
+            }
+        }
+    } // namespace _Finding
+} // unnamed namespace
+
+extern "C" {
+
+#ifndef _M_ARM64
+// TRANSITION, ABI: preserved for binary compatibility
+const void* __stdcall __std_find_trivial_unsized_1(const void* const _First, const uint8_t _Val) noexcept {
+    // C23 7.27.5.2 "The memchr generic function"/2 says "The implementation shall behave as if
+    // it reads the characters sequentially and stops as soon as a matching character is found."
+    return memchr(_First, _Val, SIZE_MAX);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+const void* __stdcall __std_find_trivial_unsized_2(const void* const _First, const uint16_t _Val) noexcept {
+    // C23 7.27.5.2 "The memchr generic function"/2 says "The implementation shall behave as if
+    // it reads the characters sequentially and stops as soon as a matching character is found."
+    // C23 7.32.4.6.9 "The wmemchr generic function"/2 lacks such wording,
+    // so we don't use wmemchr(), avoiding issues with unreachable_sentinel_t.
+    return _Finding::_Find_unsized_impl(_First, _Val);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+const void* __stdcall __std_find_trivial_unsized_4(const void* const _First, const uint32_t _Val) noexcept {
+    return _Finding::_Find_unsized_impl(_First, _Val);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+const void* __stdcall __std_find_trivial_unsized_8(const void* const _First, const uint64_t _Val) noexcept {
+    return _Finding::_Find_unsized_impl(_First, _Val);
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+const void* __stdcall __std_find_trivial_1(
+    const void* const _First, const void* const _Last, const uint8_t _Val) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    auto _Result = memchr(_First, _Val, _Byte_length(_First, _Last));
+    return _Result ? _Result : _Last;
+#else
+    return _Finding::_Find_impl<_Finding::_Find_traits_1, _Finding::_Predicate::_Equal>(_First, _Last, _Val);
+#endif
+}
+
+const void* __stdcall __std_find_trivial_2(
+    const void* const _First, const void* const _Last, const uint16_t _Val) noexcept {
+    return _Finding::_Find_impl<_Finding::_Find_traits_2, _Finding::_Predicate::_Equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_trivial_4(
+    const void* const _First, const void* const _Last, const uint32_t _Val) noexcept {
+    return _Finding::_Find_impl<_Finding::_Find_traits_4, _Finding::_Predicate::_Equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_trivial_8(
+    const void* const _First, const void* const _Last, const uint64_t _Val) noexcept {
+    return _Finding::_Find_impl<_Finding::_Find_traits_8, _Finding::_Predicate::_Equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_last_trivial_1(
+    const void* const _First, const void* const _Last, const uint8_t _Val) noexcept {
+    return _Finding::_Find_last_impl<_Finding::_Find_traits_1, _Finding::_Predicate::_Equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_last_trivial_2(
+    const void* const _First, const void* const _Last, const uint16_t _Val) noexcept {
+    return _Finding::_Find_last_impl<_Finding::_Find_traits_2, _Finding::_Predicate::_Equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_last_trivial_4(
+    const void* const _First, const void* const _Last, const uint32_t _Val) noexcept {
+    return _Finding::_Find_last_impl<_Finding::_Find_traits_4, _Finding::_Predicate::_Equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_last_trivial_8(
+    const void* const _First, const void* const _Last, const uint64_t _Val) noexcept {
+    return _Finding::_Find_last_impl<_Finding::_Find_traits_8, _Finding::_Predicate::_Equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_not_ch_1(
+    const void* const _First, const void* const _Last, const uint8_t _Val) noexcept {
+    return _Finding::_Find_impl<_Finding::_Find_traits_1, _Finding::_Predicate::_Not_equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_not_ch_2(
+    const void* const _First, const void* const _Last, const uint16_t _Val) noexcept {
+    return _Finding::_Find_impl<_Finding::_Find_traits_2, _Finding::_Predicate::_Not_equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_not_ch_4(
+    const void* const _First, const void* const _Last, const uint32_t _Val) noexcept {
+    return _Finding::_Find_impl<_Finding::_Find_traits_4, _Finding::_Predicate::_Not_equal>(_First, _Last, _Val);
+}
+
+const void* __stdcall __std_find_not_ch_8(
+    const void* const _First, const void* const _Last, const uint64_t _Val) noexcept {
+    return _Finding::_Find_impl<_Finding::_Find_traits_8, _Finding::_Predicate::_Not_equal>(_First, _Last, _Val);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_1(
+    const void* const _First, const void* const _Last, const uint8_t _Val) noexcept {
+    return _Finding::_Find_last_pos_impl<_Finding::_Find_traits_1, _Finding::_Predicate::_Not_equal>(
+        _First, _Last, _Val);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_2(
+    const void* const _First, const void* const _Last, const uint16_t _Val) noexcept {
+    return _Finding::_Find_last_pos_impl<_Finding::_Find_traits_2, _Finding::_Predicate::_Not_equal>(
+        _First, _Last, _Val);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_4(
+    const void* const _First, const void* const _Last, const uint32_t _Val) noexcept {
+    return _Finding::_Find_last_pos_impl<_Finding::_Find_traits_4, _Finding::_Predicate::_Not_equal>(
+        _First, _Last, _Val);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_last_not_ch_pos_8(
+    const void* const _First, const void* const _Last, const uint64_t _Val) noexcept {
+    return _Finding::_Find_last_pos_impl<_Finding::_Find_traits_8, _Finding::_Predicate::_Not_equal>(
+        _First, _Last, _Val);
+}
+
+const void* __stdcall __std_adjacent_find_1(const void* const _First, const void* const _Last) noexcept {
+    return _Finding::_Adjacent_find_impl<_Finding::_Find_traits_1, uint8_t>(_First, _Last);
+}
+
+const void* __stdcall __std_adjacent_find_2(const void* const _First, const void* const _Last) noexcept {
+    return _Finding::_Adjacent_find_impl<_Finding::_Find_traits_2, uint16_t>(_First, _Last);
+}
+
+const void* __stdcall __std_adjacent_find_4(const void* const _First, const void* const _Last) noexcept {
+    return _Finding::_Adjacent_find_impl<_Finding::_Find_traits_4, uint32_t>(_First, _Last);
+}
+
+const void* __stdcall __std_adjacent_find_8(const void* const _First, const void* const _Last) noexcept {
+    return _Finding::_Adjacent_find_impl<_Finding::_Find_traits_8, uint64_t>(_First, _Last);
+}
+
+const void* __stdcall __std_search_n_1(
+    const void* const _First, const void* const _Last, const size_t _Count, const uint8_t _Value) noexcept {
+    return _Finding::_Search_n_impl<_Finding::_Find_traits_1>(_First, _Last, _Count, _Value);
+}
+
+const void* __stdcall __std_search_n_2(
+    const void* const _First, const void* const _Last, const size_t _Count, const uint16_t _Value) noexcept {
+    return _Finding::_Search_n_impl<_Finding::_Find_traits_2>(_First, _Last, _Count, _Value);
+}
+
+const void* __stdcall __std_search_n_4(
+    const void* const _First, const void* const _Last, const size_t _Count, const uint32_t _Value) noexcept {
+    return _Finding::_Search_n_impl<_Finding::_Find_traits_4>(_First, _Last, _Count, _Value);
+}
+
+const void* __stdcall __std_search_n_8(
+    const void* const _First, const void* const _Last, const size_t _Count, const uint64_t _Value) noexcept {
+    return _Finding::_Search_n_impl<_Finding::_Find_traits_8>(_First, _Last, _Count, _Value);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Counting {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Count_traits_8 : _Finding::_Find_traits_8 {
+            static uint64x2_t _Sub(const uint64x2_t _Lhs, const uint64x2_t _Rhs) noexcept {
+                return vsubq_u64(_Lhs, _Rhs);
+            }
+
+            static size_t _Reduce(const uint64x2_t _Val) noexcept {
+                return vgetq_lane_u64(vpaddq_u64(_Val, _Val), 0);
+            }
+
+            static size_t _Reduce(const uint64x2_t _Val_lo, const uint64x2_t _Val_hi) noexcept {
+                return _Reduce(vaddq_u64(_Val_lo, _Val_hi));
+            }
+        };
+
+        struct _Count_traits_4 : _Finding::_Find_traits_4 {
+            // Max value that will fit in 32-bit counters without overflow.
+            static constexpr size_t _Max_count = 0xFFFFFFFF;
+
+            static uint32x4_t _Sub(const uint32x4_t _Lhs, const uint32x4_t _Rhs) noexcept {
+                return vsubq_u32(_Lhs, _Rhs);
+            }
+
+            static size_t _Reduce(const uint32x4_t _Val) noexcept {
+                return vaddlvq_u32(_Val);
+            }
+
+            static size_t _Reduce(const uint32x4_t _Val_lo, const uint32x4_t _Val_hi) noexcept {
+                uint64x2_t _Sum = vpaddlq_u32(_Val_lo);
+                _Sum            = vpadalq_u32(_Sum, _Val_hi);
+                return _Count_traits_8::_Reduce(_Sum);
+            }
+        };
+
+        struct _Count_traits_2 : _Finding::_Find_traits_2 {
+            // Max value that will fit in 16-bit counters without overflow.
+            static constexpr size_t _Max_count = 0xFFFF;
+
+            static uint16x8_t _Sub(const uint16x8_t _Lhs, const uint16x8_t _Rhs) noexcept {
+                return vsubq_u16(_Lhs, _Rhs);
+            }
+
+            static size_t _Reduce(const uint16x8_t _Val) noexcept {
+                return vaddlvq_u16(_Val);
+            }
+
+            static size_t _Reduce(const uint16x8_t _Val_lo, const uint16x8_t _Val_hi) noexcept {
+                uint32x4_t _Sum = vpaddlq_u16(_Val_lo);
+                _Sum            = vpadalq_u16(_Sum, _Val_hi);
+                return _Count_traits_4::_Reduce(_Sum);
+            }
+        };
+
+        struct _Count_traits_1 : _Finding::_Find_traits_1 {
+            // Max value that will fit in 8-bit counters without overflow.
+            static constexpr size_t _Max_count = 0xFF;
+
+            static uint8x16_t _Sub(const uint8x16_t _Lhs, const uint8x16_t _Rhs) noexcept {
+                return vsubq_u8(_Lhs, _Rhs);
+            }
+
+            static size_t _Reduce(const uint8x16_t _Val) noexcept {
+                return vaddlvq_u8(_Val);
+            }
+
+            static size_t _Reduce(const uint8x16_t _Val_lo, const uint8x16_t _Val_hi) noexcept {
+                uint16x8_t _Sum = vpaddlq_u8(_Val_lo);
+                _Sum            = vpadalq_u8(_Sum, _Val_hi);
+                return _Count_traits_2::_Reduce(_Sum);
+            }
+        };
+
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Count_traits_8 : _Finding::_Find_traits_8 {
+            static __m256i _Sub_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_sub_epi64(_Lhs, _Rhs);
+            }
+
+            static __m128i _Sub_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_sub_epi64(_Lhs, _Rhs);
+            }
+
+            static size_t _Reduce_avx(const __m256i _Val) noexcept {
+                const __m128i _Lo64 = _mm256_extracti128_si256(_Val, 0);
+                const __m128i _Hi64 = _mm256_extracti128_si256(_Val, 1);
+                const __m128i _Rx8  = _mm_add_epi64(_Lo64, _Hi64);
+                return _Reduce_sse(_Rx8);
+            }
+
+            static size_t _Reduce_sse(const __m128i _Val) noexcept {
+#ifdef _WIN64
+                return _mm_cvtsi128_si64(_Val) + _mm_extract_epi64(_Val, 1);
+#else // ^^^ 64-bit / 32-bit vvv
+                return static_cast<uint32_t>(_mm_cvtsi128_si32(_Val))
+                     + static_cast<uint32_t>(_mm_extract_epi32(_Val, 2));
+#endif // ^^^ 32-bit ^^^
+            }
+        };
+
+        struct _Count_traits_4 : _Finding::_Find_traits_4 {
+            // For AVX2, we use hadd_epi32 three times to combine pairs of 32-bit counters into 32-bit results.
+            // Therefore, _Max_count is 0x1FFF'FFFF, which is 0xFFFF'FFF8 when doubled three times; any more would
+            // overflow.
+
+            // For SSE4.2, we use hadd_epi32 twice. This would allow a larger limit,
+            // but it's simpler to use the smaller limit for both codepaths.
+
+            static constexpr size_t _Max_count = 0x1FFF'FFFF;
+
+            static __m256i _Sub_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_sub_epi32(_Lhs, _Rhs);
+            }
+
+            static __m128i _Sub_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_sub_epi32(_Lhs, _Rhs);
+            }
+
+            static size_t _Reduce_avx(const __m256i _Val) noexcept {
+                constexpr auto _Shuf = _MM_SHUFFLE(3, 1, 2, 0); // Cross lane, to reduce further on low lane
+                const __m256i _Rx4   = _mm256_hadd_epi32(_Val, _mm256_setzero_si256()); // (0+1),(2+3),0,0 per lane
+                const __m256i _Rx5   = _mm256_permute4x64_epi64(_Rx4, _Shuf); // low lane  (0+1),(2+3),(4+5),(6+7)
+                const __m256i _Rx6   = _mm256_hadd_epi32(_Rx5, _mm256_setzero_si256()); // (0+...+3),(4+...+7),0,0
+                const __m256i _Rx7   = _mm256_hadd_epi32(_Rx6, _mm256_setzero_si256()); // (0+...+7),0,0,0
+                return static_cast<uint32_t>(_mm_cvtsi128_si32(_mm256_castsi256_si128(_Rx7)));
+            }
+
+            static size_t _Reduce_sse(const __m128i _Val) noexcept {
+                const __m128i _Rx4 = _mm_hadd_epi32(_Val, _mm_setzero_si128()); // (0+1),(2+3),0,0
+                const __m128i _Rx5 = _mm_hadd_epi32(_Rx4, _mm_setzero_si128()); // (0+...+3),0,0,0
+                return static_cast<uint32_t>(_mm_cvtsi128_si32(_Rx5));
+            }
+        };
+
+        struct _Count_traits_2 : _Finding::_Find_traits_2 {
+            // For both AVX2 and SSE4.2, we use hadd_epi16 once to combine pairs of 16-bit counters into 16-bit results.
+            // Therefore, _Max_count is 0x7FFF, which is 0xFFFE when doubled; any more would overflow.
+
+            static constexpr size_t _Max_count = 0x7FFF;
+
+            static __m256i _Sub_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_sub_epi16(_Lhs, _Rhs);
+            }
+
+            static __m128i _Sub_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_sub_epi16(_Lhs, _Rhs);
+            }
+
+            static size_t _Reduce_avx(const __m256i _Val) noexcept {
+                const __m256i _Rx2 = _mm256_hadd_epi16(_Val, _mm256_setzero_si256());
+                const __m256i _Rx3 = _mm256_unpacklo_epi16(_Rx2, _mm256_setzero_si256());
+                return _Count_traits_4::_Reduce_avx(_Rx3);
+            }
+
+            static size_t _Reduce_sse(const __m128i _Val) noexcept {
+                const __m128i _Rx2 = _mm_hadd_epi16(_Val, _mm_setzero_si128());
+                const __m128i _Rx3 = _mm_unpacklo_epi16(_Rx2, _mm_setzero_si128());
+                return _Count_traits_4::_Reduce_sse(_Rx3);
+            }
+        };
+
+        struct _Count_traits_1 : _Finding::_Find_traits_1 {
+            // For AVX2, _Max_portion_size below is _Max_count * 32 bytes, and we have 1-byte elements.
+            // We're using packed 8-bit counters, and 32 of those fit in 256 bits.
+
+            // For SSE4.2, _Max_portion_size below is _Max_count * 16 bytes, and we have 1-byte elements.
+            // We're using packed 8-bit counters, and 16 of those fit in 128 bits.
+
+            // For both codepaths, this is why _Max_count is the maximum unsigned 8-bit integer.
+            // (The reduction steps aren't the limiting factor here.)
+
+            static constexpr size_t _Max_count = 0xFF;
+
+            static __m256i _Sub_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_sub_epi8(_Lhs, _Rhs);
+            }
+
+            static __m128i _Sub_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_sub_epi8(_Lhs, _Rhs);
+            }
+
+            static size_t _Reduce_avx(const __m256i _Val) noexcept {
+                const __m256i _Rx1 = _mm256_sad_epu8(_Val, _mm256_setzero_si256());
+                return _Count_traits_8::_Reduce_avx(_Rx1);
+            }
+
+            static size_t _Reduce_sse(const __m128i _Val) noexcept {
+                const __m128i _Rx1 = _mm_sad_epu8(_Val, _mm_setzero_si128());
+                return _Count_traits_8::_Reduce_sse(_Rx1);
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        template <class _Traits, class _Ty>
+        __declspec(noalias) size_t __stdcall _Count_impl(
+            const void* _First, const void* const _Last, const _Ty _Val) noexcept {
+            size_t _Result           = 0;
+            const size_t _Size_bytes = _Byte_length(_First, _Last);
+
+            if (size_t _Size = _Size_bytes & ~size_t{0x1F}; _Size != 0) {
+                const auto _Comparand = _Traits::_Set_neon_q(_Val);
+                const void* _Stop_at  = _First;
+
+                for (;;) {
+                    if constexpr (sizeof(_Ty) >= sizeof(size_t)) {
+                        _Advance_bytes(_Stop_at, _Size);
+                    } else {
+                        constexpr size_t _Max_portion_size = _Traits::_Max_count * 32;
+                        const size_t _Portion_size         = _Size < _Max_portion_size ? _Size : _Max_portion_size;
+                        _Advance_bytes(_Stop_at, _Portion_size);
+                        _Size -= _Portion_size;
+                    }
+
+                    auto _Count_lo = _Traits::_Set_neon_q(0);
+                    auto _Count_hi = _Traits::_Set_neon_q(0);
+
+                    do {
+                        const auto _Data_lo = _Traits::_Load_q(static_cast<const uint8_t*>(_First) + 0);
+                        const auto _Data_hi = _Traits::_Load_q(static_cast<const uint8_t*>(_First) + 16);
+
+                        const auto _Mask_lo = _Traits::_Cmp_neon_q(_Data_lo, _Comparand);
+                        const auto _Mask_hi = _Traits::_Cmp_neon_q(_Data_hi, _Comparand);
+                        _Count_lo           = _Traits::_Sub(_Count_lo, _Mask_lo);
+                        _Count_hi           = _Traits::_Sub(_Count_hi, _Mask_hi);
+                        _Advance_bytes(_First, 32);
+                    } while (_First != _Stop_at);
+
+                    _Result += _Traits::_Reduce(_Count_lo, _Count_hi);
+
+                    if constexpr (sizeof(_Ty) >= sizeof(size_t)) {
+                        break;
+                    } else {
+                        if (_Size == 0) {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if ((_Size_bytes & size_t{0x10}) != 0) { // use original _Size_bytes; we've read only 32-byte chunks
+                const auto _Comparand = _Traits::_Set_neon_q(_Val);
+                auto _Count_vector    = _Traits::_Set_neon_q(0);
+
+                const auto _Data = _Traits::_Load_q(_First);
+                const auto _Mask = _Traits::_Cmp_neon_q(_Data, _Comparand);
+                _Count_vector    = _Traits::_Sub(_Count_vector, _Mask);
+                _Result += _Traits::_Reduce(_Count_vector);
+
+                _Advance_bytes(_First, 16);
+            }
+
+// Avoid auto-vectorization of the scalar tail, as this is not beneficial for performance.
+#pragma loop(no_vector)
+            for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
+                if (*_Ptr == _Val) {
+                    ++_Result;
+                }
+            }
+            return _Result;
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        template <class _Traits, class _Ty>
+        __declspec(noalias) size_t __stdcall _Count_impl(
+            const void* _First, const void* const _Last, const _Ty _Val) noexcept {
+            size_t _Result = 0;
+
+            const size_t _Size_bytes = _Byte_length(_First, _Last);
+
+            if (size_t _Avx_size = _Size_bytes & ~size_t{0x1F}; _Avx_size != 0 && _Use_avx2()) {
+                const __m256i _Comparand = _Traits::_Set_avx(_Val);
+                const void* _Stop_at     = _First;
+
+                for (;;) {
+                    if constexpr (sizeof(_Ty) >= sizeof(size_t)) {
+                        _Advance_bytes(_Stop_at, _Avx_size);
+                    } else {
+                        constexpr size_t _Max_portion_size = _Traits::_Max_count * 32;
+                        const size_t _Portion_size = _Avx_size < _Max_portion_size ? _Avx_size : _Max_portion_size;
+                        _Advance_bytes(_Stop_at, _Portion_size);
+                        _Avx_size -= _Portion_size;
+                    }
+
+                    __m256i _Count_vector = _mm256_setzero_si256();
+
+                    do {
+                        const __m256i _Data = _mm256_loadu_si256(static_cast<const __m256i*>(_First));
+                        const __m256i _Mask = _Traits::_Cmp_avx(_Data, _Comparand);
+                        _Count_vector       = _Traits::_Sub_avx(_Count_vector, _Mask);
+                        _Advance_bytes(_First, 32);
+                    } while (_First != _Stop_at);
+
+                    _Result += _Traits::_Reduce_avx(_Count_vector);
+
+                    if constexpr (sizeof(_Ty) >= sizeof(size_t)) {
+                        break;
+                    } else {
+                        if (_Avx_size == 0) {
+                            break;
+                        }
+                    }
+                }
+
+                if (const size_t _Avx_tail_size = _Size_bytes & 0x1C; _Avx_tail_size != 0) {
+                    const __m256i _Tail_mask  = _Avx2_tail_mask_32(_Avx_tail_size);
+                    const __m256i _Data       = _mm256_maskload_epi32(static_cast<const int*>(_First), _Tail_mask);
+                    const __m256i _Mask       = _mm256_and_si256(_Traits::_Cmp_avx(_Data, _Comparand), _Tail_mask);
+                    const unsigned int _Bingo = _mm256_movemask_epi8(_Mask);
+                    const size_t _Tail_count  = __popcnt(_Bingo); // Assume available with SSE4.2
+                    _Result += _Tail_count / sizeof(_Ty);
+                    _Advance_bytes(_First, _Avx_tail_size);
+                }
+
+                _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return _Result;
+                }
+            } else if (size_t _Sse_size = _Size_bytes & ~size_t{0xF}; _Sse_size != 0 && _Use_sse42()) {
+                const __m128i _Comparand = _Traits::_Set_sse(_Val);
+                const void* _Stop_at     = _First;
+
+                for (;;) {
+                    if constexpr (sizeof(_Ty) >= sizeof(size_t)) {
+                        _Advance_bytes(_Stop_at, _Sse_size);
+                    } else {
+                        constexpr size_t _Max_portion_size = _Traits::_Max_count * 16;
+                        const size_t _Portion_size = _Sse_size < _Max_portion_size ? _Sse_size : _Max_portion_size;
+                        _Advance_bytes(_Stop_at, _Portion_size);
+                        _Sse_size -= _Portion_size;
+                    }
+
+                    __m128i _Count_vector = _mm_setzero_si128();
+
+                    do {
+                        const __m128i _Data = _mm_loadu_si128(static_cast<const __m128i*>(_First));
+                        const __m128i _Mask = _Traits::_Cmp_sse(_Data, _Comparand);
+                        _Count_vector       = _Traits::_Sub_sse(_Count_vector, _Mask);
+                        _Advance_bytes(_First, 16);
+                    } while (_First != _Stop_at);
+
+                    _Result += _Traits::_Reduce_sse(_Count_vector);
+
+                    if constexpr (sizeof(_Ty) >= sizeof(size_t)) {
+                        break;
+                    } else {
+                        if (_Sse_size == 0) {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
+                if (*_Ptr == _Val) {
+                    ++_Result;
+                }
+            }
+            return _Result;
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+    } // namespace _Counting
+} // unnamed namespace
+
+extern "C" {
+
+__declspec(noalias) size_t __stdcall __std_count_trivial_1(
+    const void* const _First, const void* const _Last, const uint8_t _Val) noexcept {
+    return _Counting::_Count_impl<_Counting::_Count_traits_1>(_First, _Last, _Val);
+}
+
+__declspec(noalias) size_t __stdcall __std_count_trivial_2(
+    const void* const _First, const void* const _Last, const uint16_t _Val) noexcept {
+    return _Counting::_Count_impl<_Counting::_Count_traits_2>(_First, _Last, _Val);
+}
+
+__declspec(noalias) size_t __stdcall __std_count_trivial_4(
+    const void* const _First, const void* const _Last, const uint32_t _Val) noexcept {
+    return _Counting::_Count_impl<_Counting::_Count_traits_4>(_First, _Last, _Val);
+}
+
+__declspec(noalias) size_t __stdcall __std_count_trivial_8(
+    const void* const _First, const void* const _Last, const uint64_t _Val) noexcept {
+    return _Counting::_Count_impl<_Counting::_Count_traits_8>(_First, _Last, _Val);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Find_meow_of {
+        // 'find_meow_of' is a quadratic complexity algorithm.
+        // Quadratic vectorization:
+        //  - SSE4.2 for 8-bit and 16-bit elements: _mm_cmpestri
+        //  - AVX2 for 32-bit and 64-bit elements: shuffle elements so that each is tried in each position,
+        //    find the min/max match position
+        //
+        // But for a needle with elements in a small range, a bitmap can be used, making the algorithm linear.
+        // We consider that only for 'basic_string'/'basic_string_view', not for 'std::find_first_of'.
+        // We consider bitmaps for elements in the range [0, 255].
+        //
+        // We have two different bitmap algorithms: AVX2 and scalar.
+        // The decision is based on needle and haystack lengths, see _Pick_strategy.
+
+        enum class _Predicate { _Any_of, _None_of };
+
+        namespace _Bitmap_details {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            __forceinline uint8x16_t _Bitmap_step(const uint8x16_t _Data, const uint8x16x2_t _Bitmap) noexcept {
+                const uint8x16_t _Idx = vshrq_n_u8(_Data, 3);
+                const uint8x16_t _Bit = vandq_u8(_Data, vdupq_n_u8(7));
+
+                const uint8x16_t _Byte = vqtbl2q_u8(_Bitmap, _Idx);
+                const int8x16_t _Shift = vnegq_s8(vreinterpretq_s8_u8(_Bit));
+                const uint8x16_t _Test = vshlq_u8(_Byte, _Shift);
+                return vtstq_u8(_Test, vdupq_n_u8(1));
+            }
+
+            uint8x16_t _Pack_u16(const uint16x8_t _Val0, const uint16x8_t _Val1) noexcept {
+                return vuzp1q_u8(vreinterpretq_u8_u16(_Val0), vreinterpretq_u8_u16(_Val1));
+            }
+
+            uint8x16_t _Pack_u32(const uint32x4_t _Val0, const uint32x4_t _Val1, const uint32x4_t _Val2,
+                const uint32x4_t _Val3) noexcept {
+                const auto _Val01 = vuzp1q_u16(vreinterpretq_u16_u32(_Val0), vreinterpretq_u16_u32(_Val1));
+                const auto _Val23 = vuzp1q_u16(vreinterpretq_u16_u32(_Val2), vreinterpretq_u16_u32(_Val3));
+                return _Pack_u16(_Val01, _Val23);
+            }
+
+            template <class _Ty>
+            __forceinline uint8x16_t _Do_bitmap(const _Ty* const _Src, const uint8x16x2_t _Bitmap) noexcept {
+                if constexpr (sizeof(_Ty) == 1) {
+                    const uint8x16_t _Data = vld1q_u8(_Src);
+                    return _Bitmap_step(_Data, _Bitmap);
+                } else if constexpr (sizeof(_Ty) == 2) {
+                    const auto _Data0 = vld1q_u16(_Src + 0);
+                    const auto _Data1 = vld1q_u16(_Src + 8);
+                    const auto _Data  = _Pack_u16(_Data0, _Data1);
+
+                    const auto _Limit     = vdupq_n_u16(0xFF);
+                    const auto _Overflow  = _Pack_u16(vcleq_u16(_Data0, _Limit), vcleq_u16(_Data1, _Limit));
+                    const auto _Mask_part = _Bitmap_step(_Data, _Bitmap);
+                    return vandq_u8(_Mask_part, _Overflow);
+                } else if constexpr (sizeof(_Ty) == 4) {
+                    const auto _Data0 = vld1q_u32(_Src + 0);
+                    const auto _Data1 = vld1q_u32(_Src + 4);
+                    const auto _Data2 = vld1q_u32(_Src + 8);
+                    const auto _Data3 = vld1q_u32(_Src + 12);
+                    const auto _Data  = _Pack_u32(_Data0, _Data1, _Data2, _Data3);
+
+                    const auto _Limit     = vdupq_n_u32(0xFF);
+                    const auto _Overflow0 = vcleq_u32(_Data0, _Limit);
+                    const auto _Overflow1 = vcleq_u32(_Data1, _Limit);
+                    const auto _Overflow2 = vcleq_u32(_Data2, _Limit);
+                    const auto _Overflow3 = vcleq_u32(_Data3, _Limit);
+                    const auto _Overflow  = _Pack_u32(_Overflow0, _Overflow1, _Overflow2, _Overflow3);
+
+                    const auto _Mask_part = _Bitmap_step(_Data, _Bitmap);
+                    return vandq_u8(_Mask_part, _Overflow);
+                } else {
+                    static_assert(false, "Unexpected size");
+                }
+            }
+
+            template <class _Ty>
+            __forceinline bool _Make_bitmap_small(
+                const void* const _Needle, const size_t _Needle_length, uint8x16x2_t& _Bitmap) noexcept {
+                auto _Needle_ptr = static_cast<const _Ty*>(_Needle);
+                const auto _Stop = _Needle_ptr + _Needle_length;
+
+                uint64_t _Bitmap0 = 0;
+                uint64_t _Bitmap1 = 0;
+                uint64_t _Bitmap2 = 0;
+                uint64_t _Bitmap3 = 0;
+
+                constexpr uint64_t _One = 1;
+
+                for (; _Needle_ptr != _Stop; ++_Needle_ptr) {
+                    const unsigned int _Val = static_cast<unsigned int>(*_Needle_ptr);
+
+                    if constexpr (sizeof(_Ty) > 1) {
+                        if (_Val >= 256) {
+                            return false;
+                        }
+                    }
+
+                    const uint64_t _One_low  = _rotl64(_One, _Val);
+                    const uint64_t _Bitmap01 = (_Val & 0x80) == 0 ? _One_low : 0;
+                    const uint64_t _Bitmap23 = (_Val & 0x80) != 0 ? _One_low : 0;
+                    _Bitmap0 |= (_Val & 0x40) == 0 ? _Bitmap01 : 0;
+                    _Bitmap1 |= (_Val & 0x40) != 0 ? _Bitmap01 : 0;
+                    _Bitmap2 |= (_Val & 0x40) == 0 ? _Bitmap23 : 0;
+                    _Bitmap3 |= (_Val & 0x40) != 0 ? _Bitmap23 : 0;
+                }
+
+                _Bitmap.val[0] = vreinterpretq_u8_u64(vsetq_lane_u64(_Bitmap1, vdupq_n_u64(_Bitmap0), 1));
+                _Bitmap.val[1] = vreinterpretq_u8_u64(vsetq_lane_u64(_Bitmap3, vdupq_n_u64(_Bitmap2), 1));
+
+                return true;
+            }
+
+            __forceinline uint64x1_t _Movemask_128_x4(const uint8x16_t _In0, const uint8x16_t _In1,
+                const uint8x16_t _In2, const uint8x16_t _In3, const uint8x16_t _Mask) noexcept {
+                uint8x16_t _And0 = vandq_u8(_In0, _Mask);
+                uint8x16_t _And1 = vandq_u8(_In1, _Mask);
+                uint8x16_t _And2 = vandq_u8(_In2, _Mask);
+                uint8x16_t _And3 = vandq_u8(_In3, _Mask);
+
+                uint8x16_t _Sum0 = vpaddq_u8(_And0, _And1);
+                uint8x16_t _Sum1 = vpaddq_u8(_And2, _And3);
+                _Sum0            = vpaddq_u8(_Sum0, _Sum1);
+                _Sum0            = vpaddq_u8(_Sum0, _Sum0);
+
+                return vget_low_u64(vreinterpretq_u64_u8(_Sum0));
+            }
+
+            template <class _Ty>
+            __forceinline bool _Make_bitmap_large_neon(
+                const void* const _Needle, const size_t _Needle_length, uint8x16x2_t& _Bitmap) noexcept {
+                // TRANSITION, DevCom-11055227
+                constexpr uint8_t _Mask_arr[16] = {
+                    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
+                const auto _Mask = vld1q_u8(_Mask_arr);
+
+                auto _Needle_ptr       = static_cast<const _Ty*>(_Needle);
+                const _Ty* const _Stop = _Needle_ptr + _Needle_length;
+
+                alignas(16) uint8_t _Table[256] = {};
+                for (; _Needle_ptr != _Stop; ++_Needle_ptr) {
+                    if constexpr (sizeof(_Ty) > 1) {
+                        if (*_Needle_ptr >= 256) {
+                            return false;
+                        }
+                    }
+
+                    _Table[*_Needle_ptr] = 0xFF;
+                }
+
+                for (size_t _Ix = 0; _Ix < 2; ++_Ix) {
+                    const auto _In0 = vld1q_u8(_Table + _Ix * 128 + 0 * 16);
+                    const auto _In1 = vld1q_u8(_Table + _Ix * 128 + 1 * 16);
+                    const auto _In2 = vld1q_u8(_Table + _Ix * 128 + 2 * 16);
+                    const auto _In3 = vld1q_u8(_Table + _Ix * 128 + 3 * 16);
+
+                    const auto _Bm0 = _Movemask_128_x4(_In0, _In1, _In2, _In3, _Mask);
+
+                    const auto _In4 = vld1q_u8(_Table + _Ix * 128 + 4 * 16);
+                    const auto _In5 = vld1q_u8(_Table + _Ix * 128 + 5 * 16);
+                    const auto _In6 = vld1q_u8(_Table + _Ix * 128 + 6 * 16);
+                    const auto _In7 = vld1q_u8(_Table + _Ix * 128 + 7 * 16);
+
+                    const auto _Bm1 = _Movemask_128_x4(_In4, _In5, _In6, _In7, _Mask);
+
+                    _Bitmap.val[_Ix] = vreinterpretq_u8_u64(vcombine_u64(_Bm0, _Bm1));
+                }
+
+                return true;
+            }
+
+            template <class _Ty>
+            __forceinline bool _Make_bitmap(
+                const void* const _Needle, const size_t _Needle_length, uint8x16x2_t& _Bitmap) noexcept {
+                if (_Needle_length <= 20) {
+                    return _Make_bitmap_small<_Ty>(_Needle, _Needle_length, _Bitmap);
+                } else {
+                    return _Make_bitmap_large_neon<_Ty>(_Needle, _Needle_length, _Bitmap);
+                }
+            }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+
+            // AVX2 bitmap: __m256i value with each bit corresponding to a needle element. Set bits mean "present".
+            //
+            // The bitmap algorithm implemented in _Bitmap_step:
+            //  - Process by 8 elements, populate them as in 32-bit values vector,
+            //    regardless of the original element size
+            //  - Split the low 5 bits and high 3 bits of these elements
+            //  - Use the high 3 bits with _mm256_permutevar8x32_epi32 to find 32-bit bitmap portion for each element
+            //  - Use the low 5 bits to shift the bitmap portion, so that the bitmap bit corresponding to them is on
+            //    highest position. Negate these low 5 bits before that, as we're populating the highest position
+            //  - The resulting mask can later be converted via _mm256_movemask_ps to one byte bitmap
+            __m256i _Bitmap_step(const __m256i _Bitmap, const __m256i _Data) noexcept {
+                const __m256i _Data_high    = _mm256_srli_epi32(_Data, 5);
+                const __m256i _Bitmap_parts = _mm256_permutevar8x32_epi32(_Bitmap, _Data_high);
+                const __m256i _Data_low_inv = _mm256_andnot_si256(_Data, _mm256_set1_epi32(0x1F));
+                const __m256i _Mask         = _mm256_sllv_epi32(_Bitmap_parts, _Data_low_inv);
+                return _Mask;
+            }
+
+            template <class _Ty>
+            __m256i _Load_avx_256_8(const _Ty* const _Src) noexcept {
+                if constexpr (sizeof(_Ty) == 1) {
+                    return _mm256_cvtepu8_epi32(_mm_loadu_si64(_Src));
+                } else if constexpr (sizeof(_Ty) == 2) {
+                    return _mm256_cvtepu16_epi32(_mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src)));
+                } else if constexpr (sizeof(_Ty) == 4) {
+                    return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+                } else if constexpr (sizeof(_Ty) == 8) {
+                    const __m256i _Low  = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+                    const __m256i _High = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src) + 1);
+                    const __m256i _Pack = _mm256_packs_epi32(_Low, _High);
+                    return _mm256_permute4x64_epi64(_Pack, _MM_SHUFFLE(3, 1, 2, 0));
+                } else {
+                    static_assert(false, "Unexpected size");
+                }
+            }
+
+            template <class _Ty>
+            __m256i _Load_avx_256_8_last(const _Ty* const _Src, const size_t _Count) noexcept {
+                if constexpr (sizeof(_Ty) == 1) {
+                    uint8_t _Buf[8];
+                    memcpy(_Buf, _Src, _Count);
+                    return _mm256_cvtepu8_epi32(_mm_loadu_si64(_Buf));
+                } else if constexpr (sizeof(_Ty) == 2) {
+                    uint8_t _Buf[16];
+                    memcpy(_Buf, _Src, _Count * 2);
+                    return _mm256_cvtepu16_epi32(_mm_loadu_si128(reinterpret_cast<const __m128i*>(_Buf)));
+                } else if constexpr (sizeof(_Ty) == 4) {
+                    return _mm256_maskload_epi32(reinterpret_cast<const int*>(_Src), _Avx2_tail_mask_32(_Count * 4));
+                } else if constexpr (sizeof(_Ty) == 8) {
+                    const __m256i _Mask_low  = _Avx2_tail_mask_32((_Count > 4 ? 4 : _Count) * 8);
+                    const __m256i _Low       = _mm256_maskload_epi32(reinterpret_cast<const int*>(_Src) + 0, _Mask_low);
+                    const __m256i _Mask_high = _Avx2_tail_mask_32((_Count > 4 ? _Count - 4 : 0) * 8);
+                    const __m256i _High = _mm256_maskload_epi32(reinterpret_cast<const int*>(_Src) + 8, _Mask_high);
+                    const __m256i _Pack = _mm256_packs_epi32(_Low, _High);
+                    return _mm256_permute4x64_epi64(_Pack, _MM_SHUFFLE(3, 1, 2, 0));
+                } else {
+                    static_assert(false, "Unexpected size");
+                }
+            }
+
+            template <class _Ty>
+            __m256i _Mask_out_overflow(const __m256i _Mask, const __m256i _Data) noexcept {
+                if constexpr (sizeof(_Ty) == 1) {
+                    return _Mask;
+                } else {
+                    const __m256i _Data_high =
+                        _mm256_and_si256(_Data, _mm256_set1_epi32(static_cast<int>(0xFFFF'FF00)));
+                    const __m256i _Fit_mask = _mm256_cmpeq_epi32(_Data_high, _mm256_setzero_si256());
+                    return _mm256_and_si256(_Mask, _Fit_mask);
+                }
+            }
+
+            template <class _Ty>
+            __forceinline __m256i _Make_bitmap_small(const _Ty* _Needle_ptr, const size_t _Needle_length) noexcept {
+                __m256i _Bitmap = _mm256_setzero_si256();
+
+                const _Ty* const _Stop = _Needle_ptr + _Needle_length;
+
+                const __m256i _High_bits_pattern =
+                    _mm256_set_epi32(7 << 5, 6 << 5, 5 << 5, 4 << 5, 3 << 5, 2 << 5, 1 << 5, 0 << 5);
+                const __m256i _Ones = _mm256_set1_epi32(1);
+
+                for (; _Needle_ptr != _Stop; ++_Needle_ptr) {
+                    const _Ty _Val = *_Needle_ptr;
+                    // Broadcast character value to eight 32-bit vector elements
+                    const __m128i _Count_low = _mm_cvtsi32_si128(static_cast<uint32_t>(_Val));
+                    const __m256i _Count_all = _mm256_broadcastd_epi32(_Count_low);
+                    // XOR with high bit patterns to make the right element below 32
+                    const __m256i _Count_one = _mm256_xor_si256(_High_bits_pattern, _Count_all);
+                    // The shift will produce zero for all ones, except the right one
+                    const __m256i _One_1 = _mm256_sllv_epi32(_Ones, _Count_one);
+                    _Bitmap              = _mm256_or_si256(_Bitmap, _One_1);
+                }
+
+                return _Bitmap;
+            }
+
+            template <class _Ty>
+            __forceinline __m256i _Make_bitmap_large(const _Ty* _Needle_ptr, const size_t _Needle_length) noexcept {
+                alignas(32) uint8_t _Table[256] = {};
+
+                const _Ty* const _Stop = _Needle_ptr + _Needle_length;
+
+                for (; _Needle_ptr != _Stop; ++_Needle_ptr) {
+                    _Table[*_Needle_ptr] = 0xFF;
+                }
+
+                const auto _Table_as_avx = reinterpret_cast<const __m256i*>(_Table);
+
+                return _mm256_setr_epi32( //
+                    _mm256_movemask_epi8(_mm256_load_si256(_Table_as_avx + 0)),
+                    _mm256_movemask_epi8(_mm256_load_si256(_Table_as_avx + 1)),
+                    _mm256_movemask_epi8(_mm256_load_si256(_Table_as_avx + 2)),
+                    _mm256_movemask_epi8(_mm256_load_si256(_Table_as_avx + 3)),
+                    _mm256_movemask_epi8(_mm256_load_si256(_Table_as_avx + 4)),
+                    _mm256_movemask_epi8(_mm256_load_si256(_Table_as_avx + 5)),
+                    _mm256_movemask_epi8(_mm256_load_si256(_Table_as_avx + 6)),
+                    _mm256_movemask_epi8(_mm256_load_si256(_Table_as_avx + 7)));
+            }
+
+            template <class _Ty>
+            __forceinline __m256i _Make_bitmap(const _Ty* const _Needle_ptr, const size_t _Needle_length) noexcept {
+                if (_Needle_length <= 20) {
+                    return _Make_bitmap_small(_Needle_ptr, _Needle_length);
+                } else {
+                    return _Make_bitmap_large(_Needle_ptr, _Needle_length);
+                }
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        } // namespace _Bitmap_details
+
+        namespace _Bitmap_impl {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            template <class _Ty>
+            bool _Use_bitmap_scalar(const size_t _Count1, const size_t _Count2) noexcept {
+                // Neon shuffle implementation is scalar for haystack < 16B.
+                if (_Count1 * sizeof(_Ty) < 16) {
+                    return true;
+                }
+
+                if constexpr (sizeof(_Ty) == 1) {
+                    return _Count2 >= 16;
+                } else if constexpr (sizeof(_Ty) == 2) {
+                    if (_Count2 < 8) {
+                        return false;
+                    } else if (_Count2 < 16) {
+                        return _Count1 >= 64;
+                    } else {
+                        return true;
+                    }
+                } else if constexpr (sizeof(_Ty) == 4) {
+                    if (_Count2 < 4) {
+                        return false;
+                    } else if (_Count2 < 8) {
+                        return _Count1 >= 24;
+                    } else {
+                        return true;
+                    }
+                } else {
+                    return _Count2 >= 2;
+                }
+            }
+
+            template <class _Ty>
+            bool _Use_bitmap_neon(const size_t _Count1, const size_t _Count2) noexcept {
+                if constexpr (sizeof(_Ty) == 1) {
+                    if (_Count1 < 32) {
+                        return false;
+                    } else if (_Count1 < 64) {
+                        return _Count2 >= 24;
+                    } else if (_Count1 < 128) {
+                        return _Count2 >= 8;
+                    } else {
+                        return _Count2 >= 4;
+                    }
+                } else if constexpr (sizeof(_Ty) == 2) {
+                    if (_Count1 < 32) {
+                        return false;
+                    } else if (_Count1 < 96) {
+                        return _Count2 >= 8;
+                    } else {
+                        return _Count2 >= 4;
+                    }
+                } else if constexpr (sizeof(_Ty) == 4) {
+                    if (_Count1 < 32) {
+                        return false;
+                    } else if (_Count1 < 64) {
+                        return _Count2 >= 64;
+                    } else if (_Count1 < 96) {
+                        return _Count2 >= 8;
+                    } else {
+                        return _Count2 >= 4;
+                    }
+                } else {
+                    return false;
+                }
+            }
+
+            template <class _Ty, _Predicate _Pred>
+            size_t _Impl_first_neon(
+                const void* const _Haystack, const size_t _Haystack_length, const uint8x16x2_t _Bitmap) noexcept {
+                const auto _Hay_ptr = static_cast<const _Ty*>(_Haystack);
+
+                size_t _Ix            = 0;
+                const size_t _Vec_end = _Haystack_length & ~size_t{15};
+                for (; _Ix != _Vec_end; _Ix += 16) {
+                    const auto _Eq = _Bitmap_details::_Do_bitmap(_Hay_ptr + _Ix, _Bitmap);
+
+                    auto _Mask = _Finding::_Find_traits_1::_Mask_q(_Eq);
+                    if constexpr (_Pred == _Predicate::_None_of) {
+                        _Mask ^= 0xFFFF'FFFF'FFFF'FFFF;
+                    }
+
+                    if (_Mask != 0) {
+                        return _Ix + _Finding::_Get_first_h_pos_q(_Mask);
+                    }
+                }
+
+                if (_Ix != _Haystack_length) {
+                    alignas(16) uint8_t _Bitmap_scalar_tail[32];
+                    vst1q_u8(_Bitmap_scalar_tail, _Bitmap.val[0]);
+                    vst1q_u8(_Bitmap_scalar_tail + 16, _Bitmap.val[1]);
+
+                    do {
+                        const _Ty _Val = _Hay_ptr[_Ix];
+
+                        if constexpr (sizeof(_Val) > 1) {
+                            if (_Val >= 256) {
+                                if constexpr (_Pred == _Predicate::_Any_of) {
+                                    continue;
+                                } else {
+                                    return _Ix;
+                                }
+                            }
+                        }
+
+                        const auto _Val_u8 = static_cast<uint8_t>(_Val);
+                        const uint8_t _Hi  = static_cast<uint8_t>(_Val_u8 >> 3);
+                        const uint8_t _Lo  = static_cast<uint8_t>(_Val_u8 & 0x7);
+                        const bool _Hit    = ((_Bitmap_scalar_tail[_Hi] >> _Lo) & 0x1) != 0;
+
+                        if constexpr (_Pred == _Predicate::_Any_of) {
+                            if (_Hit) {
+                                return _Ix;
+                            }
+                        } else {
+                            if (!_Hit) {
+                                return _Ix;
+                            }
+                        }
+
+                        ++_Ix;
+                    } while (_Ix != _Haystack_length);
+                }
+
+                return static_cast<size_t>(-1);
+            }
+
+            template <class _Ty, _Predicate _Pred>
+            size_t _Impl_last_neon(
+                const void* const _Haystack, const size_t _Haystack_length, const uint8x16x2_t _Bitmap) noexcept {
+                const auto _Hay_ptr = static_cast<const _Ty*>(_Haystack);
+
+                size_t _Ix = _Haystack_length;
+                while (_Ix >= 16) {
+                    _Ix -= 16;
+                    const auto _Eq = _Bitmap_details::_Do_bitmap(_Hay_ptr + _Ix, _Bitmap);
+
+                    auto _Mask = _Finding::_Find_traits_1::_Mask_q(_Eq);
+                    if constexpr (_Pred == _Predicate::_None_of) {
+                        _Mask ^= 0xFFFF'FFFF'FFFF'FFFF;
+                    }
+
+                    if (_Mask != 0) {
+                        return _Ix + _Finding::_Get_last_h_pos_q(_Mask);
+                    }
+                }
+
+                if (_Ix != 0) {
+                    alignas(16) uint8_t _Bitmap_scalar_tail[32];
+                    vst1q_u8(_Bitmap_scalar_tail, _Bitmap.val[0]);
+                    vst1q_u8(_Bitmap_scalar_tail + 16, _Bitmap.val[1]);
+
+                    do {
+                        --_Ix;
+                        const _Ty _Val = _Hay_ptr[_Ix];
+
+                        if constexpr (sizeof(_Val) > 1) {
+                            if (_Val >= 256) {
+                                if constexpr (_Pred == _Predicate::_Any_of) {
+                                    continue;
+                                } else {
+                                    return _Ix;
+                                }
+                            }
+                        }
+
+                        const auto _Val_u8 = static_cast<uint8_t>(_Val);
+                        const uint8_t _Hi  = static_cast<uint8_t>(_Val_u8 >> 3);
+                        const uint8_t _Lo  = static_cast<uint8_t>(_Val_u8 & 0x7);
+                        const bool _Hit    = ((_Bitmap_scalar_tail[_Hi] >> _Lo) & 0x1) != 0;
+
+                        if constexpr (_Pred == _Predicate::_Any_of) {
+                            if (_Hit) {
+                                return _Ix;
+                            }
+                        } else {
+                            if (!_Hit) {
+                                return _Ix;
+                            }
+                        }
+                    } while (_Ix != 0);
+                }
+
+                return static_cast<size_t>(-1);
+            }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            template <class _Ty>
+            bool _Use_bitmap_avx(const size_t _Count1, const size_t _Count2) noexcept {
+                if constexpr (sizeof(_Ty) == 1) {
+                    if (_Count2 <= 16) {
+                        return _Count1 > 1000;
+                    } else if (_Count2 <= 48) {
+                        return _Count1 > 80;
+                    } else if (_Count2 <= 240) {
+                        return _Count1 > 40;
+                    } else if (_Count2 <= 1000) {
+                        return _Count1 > 32;
+                    } else {
+                        return _Count1 > 16;
+                    }
+                } else if constexpr (sizeof(_Ty) == 2) {
+                    if (_Count2 <= 8) {
+                        return _Count1 > 128;
+                    } else if (_Count2 <= 48) {
+                        return _Count1 > 32;
+                    } else if (_Count2 <= 72) {
+                        return _Count1 > 24;
+                    } else if (_Count2 <= 144) {
+                        return _Count1 > 16;
+                    } else {
+                        return _Count1 > 8;
+                    }
+                } else if constexpr (sizeof(_Ty) == 4) {
+                    if (_Count2 <= 8) {
+                        return _Count1 > 64;
+                    } else if (_Count2 <= 24) {
+                        return _Count1 > 40;
+                    } else if (_Count2 <= 44) {
+                        return _Count1 > 24;
+                    } else if (_Count2 <= 112) {
+                        return _Count1 > 16;
+                    } else {
+                        return _Count1 > 8;
+                    }
+                } else if constexpr (sizeof(_Ty) == 8) {
+                    if (_Count2 <= 8) {
+                        return _Count1 > 40;
+                    } else if (_Count2 <= 12) {
+                        return _Count1 > 20;
+                    } else if (_Count2 <= 48) {
+                        return _Count1 > 16;
+                    } else if (_Count2 <= 64) {
+                        return _Count1 > 12;
+                    } else if (_Count2 <= 192) {
+                        return _Count1 > 8;
+                    } else {
+                        return _Count1 > 4;
+                    }
+                } else {
+                    static_assert(false, "unexpected size");
+                }
+            }
+
+            template <class _Ty>
+            bool _Use_bitmap_scalar(const size_t _Count1, const size_t _Count2) noexcept {
+                if constexpr (sizeof(_Ty) == 1) {
+                    if (_Count2 <= 32) {
+                        return false;
+                    } else if (_Count2 <= 48) {
+                        return _Count1 > 416;
+                    } else if (_Count2 <= 64) {
+                        return _Count1 > 224;
+                    } else if (_Count2 <= 80) {
+                        return _Count1 > 128;
+                    } else if (_Count2 <= 540) {
+                        return _Count1 > 48;
+                    } else {
+                        return _Count1 > 32;
+                    }
+                } else if constexpr (sizeof(_Ty) == 2) {
+                    if (_Count2 <= 8) {
+                        return false;
+                    } else if (_Count2 <= 80) {
+                        return _Count1 > 16;
+                    } else {
+                        return _Count1 > 8;
+                    }
+                } else if constexpr (sizeof(_Ty) == 4) {
+                    if (_Count2 <= 32) {
+                        return false;
+                    } else if (_Count2 <= 112) {
+                        return _Count1 > 16;
+                    } else {
+                        return _Count1 > 8;
+                    }
+                } else if constexpr (sizeof(_Ty) == 8) {
+                    if (_Count2 <= 16) {
+                        return false;
+                    } else if (_Count2 <= 32) {
+                        return _Count1 > 16;
+                    } else if (_Count2 <= 112) {
+                        return _Count1 > 8;
+                    } else {
+                        return _Count1 > 4;
+                    }
+                } else {
+                    static_assert(false, "unexpected size");
+                }
+            }
+
+            // The bitmap takes time to setup (especially AVX2), but it's linear and fast (especially AVX2, again), so:
+            //  - with a small amount of total iterations, the vectorized quadratic algorithm wins over bitmaps
+            //  - with a small haystack, among bitmaps the scalar bitmap is preferred, even if AVX2 is available
+
+            enum class _Strategy { _No_bitmap, _Scalar_bitmap, _Vector_bitmap };
+
+            template <class _Ty>
+            _Strategy _Pick_strategy(const size_t _Count1, const size_t _Count2, const bool _Use_avx2_) noexcept {
+                if (_Use_avx2_ && _Count1 > 48) {
+                    return _Use_bitmap_avx<_Ty>(_Count1, _Count2) ? _Strategy::_Vector_bitmap : _Strategy::_No_bitmap;
+                } else {
+                    return _Use_bitmap_scalar<_Ty>(_Count1, _Count2) ? _Strategy::_Scalar_bitmap
+                                                                     : _Strategy::_No_bitmap;
+                }
+            }
+
+            template <class _Ty>
+            bool _Can_fit_256_bits_sse(const _Ty* _Needle_ptr, const size_t _Needle_length) noexcept {
+                if constexpr (sizeof(_Ty) == 1) {
+                    return true;
+                } else {
+                    __m128i _Mask = _mm_undefined_si128();
+                    if constexpr (sizeof(_Ty) == 2) {
+                        _Mask = _mm_set1_epi16(static_cast<short>(0xFF00));
+                    } else if constexpr (sizeof(_Ty) == 4) {
+                        _Mask = _mm_set1_epi32(static_cast<int>(0xFFFF'FF00));
+                    } else if constexpr (sizeof(_Ty) == 8) {
+                        _Mask = _mm_set1_epi64x(static_cast<long long>(0xFFFF'FFFF'FFFF'FF00));
+                    } else {
+                        static_assert(false, "Unexpected size");
+                    }
+
+                    const size_t _Byte_size = _Needle_length * sizeof(_Ty);
+
+                    constexpr size_t _Vec_size = sizeof(_Mask);
+                    constexpr size_t _Vec_mask = _Vec_size - 1;
+                    static_assert((_Vec_size & _Vec_mask) == 0);
+
+                    const void* _Stop = _Needle_ptr;
+                    _Advance_bytes(_Stop, _Byte_size & ~_Vec_mask);
+                    for (; _Needle_ptr != _Stop; _Needle_ptr += _Vec_size / sizeof(_Ty)) {
+                        const __m128i _Data = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Needle_ptr));
+                        if (!_mm_testz_si128(_Mask, _Data)) {
+                            return false;
+                        }
+                    }
+
+                    _Advance_bytes(_Stop, _Byte_size & _Vec_mask);
+                    for (; _Needle_ptr != _Stop; ++_Needle_ptr) {
+                        if ((*_Needle_ptr & ~_Ty{0xFF}) != 0) {
+                            return false;
+                        }
+                    }
+
+                    return true;
+                }
+            }
+
+            template <class _Ty, _Predicate _Pred>
+            size_t _Impl_first_avx(const void* const _Haystack, const size_t _Haystack_length,
+                const void* const _Needle, const size_t _Needle_length) noexcept {
+                _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
+
+                const auto _Haystack_ptr = static_cast<const _Ty*>(_Haystack);
+                const auto _Needle_ptr   = static_cast<const _Ty*>(_Needle);
+
+                const __m256i _Bitmap = _Bitmap_details::_Make_bitmap(_Needle_ptr, _Needle_length);
+
+                const size_t _Haystack_length_vec = _Haystack_length & ~size_t{7};
+                for (size_t _Ix = 0; _Ix != _Haystack_length_vec; _Ix += 8) {
+                    const __m256i _Data      = _Bitmap_details::_Load_avx_256_8(_Haystack_ptr + _Ix);
+                    const __m256i _Mask_part = _Bitmap_details::_Bitmap_step(_Bitmap, _Data);
+                    const __m256i _Mask_full = _Bitmap_details::_Mask_out_overflow<_Ty>(_Mask_part, _Data);
+                    unsigned int _Bingo      = _mm256_movemask_ps(_mm256_castsi256_ps(_Mask_full));
+
+                    if constexpr (_Pred == _Predicate::_None_of) {
+                        _Bingo ^= 0xFF;
+                    }
+
+                    if (_Bingo != 0) {
+                        return _Ix + _tzcnt_u32(_Bingo);
+                    }
+                }
+
+                const size_t _Haystack_length_tail = _Haystack_length & 7;
+                if (_Haystack_length_tail != 0) {
+                    const unsigned int _Tail_bingo_mask = (1 << _Haystack_length_tail) - 1;
+                    const auto _Last_ptr                = _Haystack_ptr + _Haystack_length_vec;
+                    const __m256i _Data      = _Bitmap_details::_Load_avx_256_8_last(_Last_ptr, _Haystack_length_tail);
+                    const __m256i _Mask_part = _Bitmap_details::_Bitmap_step(_Bitmap, _Data);
+                    const __m256i _Mask_full = _Bitmap_details::_Mask_out_overflow<_Ty>(_Mask_part, _Data);
+                    unsigned int _Bingo      = _mm256_movemask_ps(_mm256_castsi256_ps(_Mask_full)) & _Tail_bingo_mask;
+
+                    if constexpr (_Pred == _Predicate::_None_of) {
+                        _Bingo ^= _Tail_bingo_mask;
+                    }
+
+                    if (_Bingo != 0) {
+                        return _Haystack_length_vec + _tzcnt_u32(_Bingo);
+                    }
+                }
+
+                return static_cast<size_t>(-1);
+            }
+
+            template <class _Ty, _Predicate _Pred>
+            size_t _Impl_last_avx(const void* const _Haystack, size_t _Haystack_length, const void* const _Needle,
+                const size_t _Needle_length) noexcept {
+                _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
+
+                const auto _Haystack_ptr = static_cast<const _Ty*>(_Haystack);
+                const auto _Needle_ptr   = static_cast<const _Ty*>(_Needle);
+
+                const __m256i _Bitmap = _Bitmap_details::_Make_bitmap(_Needle_ptr, _Needle_length);
+
+                while (_Haystack_length >= 8) {
+                    _Haystack_length -= 8;
+                    const __m256i _Data      = _Bitmap_details::_Load_avx_256_8(_Haystack_ptr + _Haystack_length);
+                    const __m256i _Mask_part = _Bitmap_details::_Bitmap_step(_Bitmap, _Data);
+                    const __m256i _Mask_full = _Bitmap_details::_Mask_out_overflow<_Ty>(_Mask_part, _Data);
+                    unsigned int _Bingo      = _mm256_movemask_ps(_mm256_castsi256_ps(_Mask_full));
+
+                    if constexpr (_Pred == _Predicate::_None_of) {
+                        _Bingo ^= 0xFF;
+                    }
+
+                    if (_Bingo != 0) {
+                        return _Haystack_length + 31 - _lzcnt_u32(_Bingo);
+                    }
+                }
+
+                const size_t _Haystack_length_tail = _Haystack_length & 7;
+                if (_Haystack_length_tail != 0) {
+                    const unsigned int _Tail_bingo_mask = (1 << _Haystack_length_tail) - 1;
+                    const __m256i _Data = _Bitmap_details::_Load_avx_256_8_last(_Haystack_ptr, _Haystack_length_tail);
+                    const __m256i _Mask_part = _Bitmap_details::_Bitmap_step(_Bitmap, _Data);
+                    const __m256i _Mask_full = _Bitmap_details::_Mask_out_overflow<_Ty>(_Mask_part, _Data);
+                    unsigned int _Bingo      = _mm256_movemask_ps(_mm256_castsi256_ps(_Mask_full)) & _Tail_bingo_mask;
+
+                    if constexpr (_Pred == _Predicate::_None_of) {
+                        _Bingo ^= _Tail_bingo_mask;
+                    }
+
+                    if (_Bingo != 0) {
+                        return 31 - _lzcnt_u32(_Bingo);
+                    }
+                }
+
+                return static_cast<size_t>(-1);
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+            // Scalar bitmap: bools, not really compressed to bits, for faster building and faster access.
+            // For sizes above integers but fitting within cache, this approach wins.
+            using _Scalar_table_t = bool[256];
+
+            template <class _Ty>
+            [[nodiscard]] bool _Build_scalar_table(
+                const void* const _Needle, const size_t _Needle_length, _Scalar_table_t& _Table) noexcept {
+                auto _Ptr       = static_cast<const _Ty*>(_Needle);
+                const auto _End = _Ptr + _Needle_length;
+
+                for (; _Ptr != _End; ++_Ptr) {
+                    const _Ty _Val = *_Ptr;
+
+                    if constexpr (sizeof(_Val) > 1) {
+                        if (_Val >= 256) {
+                            return false;
+                        }
+                    }
+
+                    _Table[_Val] = true;
+                }
+
+                return true;
+            }
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+            template <class _Ty>
+            void _Build_scalar_table_no_check(
+                const void* const _Needle, const size_t _Needle_length, _Scalar_table_t& _Table) noexcept {
+                auto _Ptr       = static_cast<const _Ty*>(_Needle);
+                const auto _End = _Ptr + _Needle_length;
+
+                for (; _Ptr != _End; ++_Ptr) {
+                    _Table[*_Ptr] = true;
+                }
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+            template <class _Ty, _Predicate _Pred>
+            size_t _Impl_first_scalar(
+                const void* const _Haystack, const size_t _Haystack_length, const _Scalar_table_t& _Table) noexcept {
+                const auto _Haystack_ptr = static_cast<const _Ty*>(_Haystack);
+
+                for (size_t _Ix = 0; _Ix != _Haystack_length; ++_Ix) {
+                    const _Ty _Val = _Haystack_ptr[_Ix];
+
+                    if constexpr (sizeof(_Val) > 1) {
+                        if (_Val >= 256) {
+                            if constexpr (_Pred == _Predicate::_Any_of) {
+                                continue;
+                            } else {
+                                return _Ix;
+                            }
+                        }
+                    }
+
+                    if constexpr (_Pred == _Predicate::_Any_of) {
+                        if (_Table[_Val]) {
+                            return _Ix;
+                        }
+                    } else {
+                        if (!_Table[_Val]) {
+                            return _Ix;
+                        }
+                    }
+                }
+
+                return static_cast<size_t>(-1);
+            }
+
+            template <class _Ty, _Predicate _Pred>
+            size_t _Impl_last_scalar(
+                const void* const _Haystack, size_t _Haystack_length, const _Scalar_table_t& _Table) noexcept {
+                const auto _Haystack_ptr = static_cast<const _Ty*>(_Haystack);
+
+                while (_Haystack_length != 0) {
+                    --_Haystack_length;
+
+                    const _Ty _Val = _Haystack_ptr[_Haystack_length];
+
+                    if constexpr (sizeof(_Val) > 1) {
+                        if (_Val >= 256) {
+                            if constexpr (_Pred == _Predicate::_Any_of) {
+                                continue;
+                            } else {
+                                return _Haystack_length;
+                            }
+                        }
+                    }
+
+                    if constexpr (_Pred == _Predicate::_Any_of) {
+                        if (_Table[_Val]) {
+                            return _Haystack_length;
+                        }
+                    } else {
+                        if (!_Table[_Val]) {
+                            return _Haystack_length;
+                        }
+                    }
+                }
+
+                return static_cast<size_t>(-1);
+            }
+        } // namespace _Bitmap_impl
+
+        namespace _First_of {
+            template <class _Ty, _Predicate _Pred>
+            const void* _Fallback(const void* _First1, const void* const _Last1, const void* const _First2,
+                const void* const _Last2) noexcept {
+                auto _Ptr_haystack           = static_cast<const _Ty*>(_First1);
+                const auto _Ptr_haystack_end = static_cast<const _Ty*>(_Last1);
+                const auto _Ptr_needle       = static_cast<const _Ty*>(_First2);
+                const auto _Ptr_needle_end   = static_cast<const _Ty*>(_Last2);
+
+                for (; _Ptr_haystack != _Ptr_haystack_end; ++_Ptr_haystack) {
+                    if constexpr (_Pred == _Predicate::_Any_of) {
+                        for (auto _Ptr = _Ptr_needle; _Ptr != _Ptr_needle_end; ++_Ptr) {
+                            if (*_Ptr_haystack == *_Ptr) {
+                                return _Ptr_haystack;
+                            }
+                        }
+                    } else {
+                        bool _Match = false;
+                        for (auto _Ptr = _Ptr_needle; _Ptr != _Ptr_needle_end; ++_Ptr) {
+                            if (*_Ptr_haystack == *_Ptr) {
+                                _Match = true;
+                                break;
+                            }
+                        }
+
+                        if (!_Match) {
+                            return _Ptr_haystack;
+                        }
+                    }
+                }
+
+                return _Ptr_haystack;
+            }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            template <class _Ty>
+            struct _Find_first_of_traits;
+
+            template <>
+            struct _Find_first_of_traits<uint8_t> : _Finding::_Find_traits_1 {
+                using _Vec_t = uint8x16_t;
+
+                static _Vec_t _Or(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                    return vorrq_u8(_Lhs, _Rhs);
+                }
+
+                static _Vec_t _And(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                    return vandq_u8(_Lhs, _Rhs);
+                }
+
+                template <size_t _Nx>
+                static _Vec_t _Ext(const _Vec_t _Val) noexcept {
+                    return vextq_u8(_Val, _Val, _Nx);
+                }
+            };
+
+            template <>
+            struct _Find_first_of_traits<uint16_t> : _Finding::_Find_traits_2 {
+                using _Vec_t = uint16x8_t;
+
+                static _Vec_t _Or(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                    return vorrq_u16(_Lhs, _Rhs);
+                }
+
+                static _Vec_t _And(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                    return vandq_u16(_Lhs, _Rhs);
+                }
+
+                template <size_t _Nx>
+                static _Vec_t _Ext(const _Vec_t _Val) noexcept {
+                    return vextq_u16(_Val, _Val, _Nx);
+                }
+            };
+
+            template <>
+            struct _Find_first_of_traits<uint32_t> : _Finding::_Find_traits_4 {
+                using _Vec_t = uint32x4_t;
+
+                static _Vec_t _Or(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                    return vorrq_u32(_Lhs, _Rhs);
+                }
+
+                static _Vec_t _And(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                    return vandq_u32(_Lhs, _Rhs);
+                }
+
+                template <size_t _Nx>
+                static _Vec_t _Ext(const _Vec_t _Val) noexcept {
+                    return vextq_u32(_Val, _Val, _Nx);
+                }
+            };
+
+            template <>
+            struct _Find_first_of_traits<uint64_t> : _Finding::_Find_traits_8 {
+                using _Vec_t = uint64x2_t;
+
+                static _Vec_t _Or(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                    return vorrq_u64(_Lhs, _Rhs);
+                }
+
+                static _Vec_t _And(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                    return vandq_u64(_Lhs, _Rhs);
+                }
+
+                template <size_t _Nx>
+                static _Vec_t _Ext(const _Vec_t _Val) noexcept {
+                    return vextq_u64(_Val, _Val, _Nx);
+                }
+            };
+
+            template <class _Ty>
+            using _Find_first_of_vec_t = _Find_first_of_traits<_Ty>::_Vec_t;
+
+            template <class _Traits, size_t _Needle_length_el_magnitude, class _Ty>
+            _Find_first_of_vec_t<_Ty> _Shuffle_step(
+                const _Find_first_of_vec_t<_Ty> _Data1, const _Find_first_of_vec_t<_Ty> _Data2s0) noexcept {
+                _Find_first_of_vec_t<_Ty> _Eq{};
+                if constexpr (_Needle_length_el_magnitude >= 1) {
+                    _Eq = _Traits::_Cmp_neon_q(_Data1, _Data2s0);
+                    if constexpr (_Needle_length_el_magnitude >= 2) {
+                        const auto _Data2s1 = _Traits::template _Ext<1>(_Data2s0);
+                        _Eq                 = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s1));
+                        if constexpr (sizeof(_Ty) != 8 && _Needle_length_el_magnitude >= 4) {
+                            const auto _Data2s2 = _Traits::template _Ext<2>(_Data2s0);
+                            _Eq                 = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s2));
+                            const auto _Data2s3 = _Traits::template _Ext<3>(_Data2s0);
+                            _Eq                 = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s3));
+                            if constexpr (_Needle_length_el_magnitude >= 8) {
+                                const auto _Data2s4 = _Traits::template _Ext<4>(_Data2s0);
+                                _Eq                 = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s4));
+                                const auto _Data2s5 = _Traits::template _Ext<5>(_Data2s0);
+                                _Eq                 = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s5));
+                                const auto _Data2s6 = _Traits::template _Ext<6>(_Data2s0);
+                                _Eq                 = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s6));
+                                const auto _Data2s7 = _Traits::template _Ext<7>(_Data2s0);
+                                _Eq                 = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s7));
+                                if constexpr (_Needle_length_el_magnitude >= 16) {
+                                    const auto _Data2s8  = _Traits::template _Ext<8>(_Data2s0);
+                                    _Eq                  = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s8));
+                                    const auto _Data2s9  = _Traits::template _Ext<9>(_Data2s0);
+                                    _Eq                  = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s9));
+                                    const auto _Data2s10 = _Traits::template _Ext<10>(_Data2s0);
+                                    _Eq                  = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s10));
+                                    const auto _Data2s11 = _Traits::template _Ext<11>(_Data2s0);
+                                    _Eq                  = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s11));
+                                    const auto _Data2s12 = _Traits::template _Ext<12>(_Data2s0);
+                                    _Eq                  = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s12));
+                                    const auto _Data2s13 = _Traits::template _Ext<13>(_Data2s0);
+                                    _Eq                  = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s13));
+                                    const auto _Data2s14 = _Traits::template _Ext<14>(_Data2s0);
+                                    _Eq                  = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s14));
+                                    const auto _Data2s15 = _Traits::template _Ext<15>(_Data2s0);
+                                    _Eq                  = _Traits::_Or(_Eq, _Traits::_Cmp_neon_q(_Data1, _Data2s15));
+                                }
+                            }
+                        }
+                    }
+                }
+                return _Eq;
+            }
+
+            template <class _Ty, _Predicate _Pred, size_t _Unrolled_tail_elems>
+            const void* _Shuffle_impl(const void* _First1, const void* const _Last1, const void* const _First2,
+                const void* const _Last2) noexcept {
+                using _Traits = _Find_first_of_traits<_Ty>;
+
+                constexpr size_t _Length_el = 16 / sizeof(_Ty);
+
+                const void* _Stop1            = _First1;
+                const size_t _Haystack_length = _Byte_length(_First1, _Last1);
+                const size_t _Vec_bytes       = _Haystack_length & ~size_t{0xF};
+                _Advance_bytes(_Stop1, _Vec_bytes);
+
+                if (_First1 != _Stop1) {
+                    const size_t _Needle_length = _Byte_length(_First2, _Last2);
+                    const void* _Stop2          = _First2;
+                    _Advance_bytes(_Stop2, _Needle_length & ~size_t{0xF});
+
+                    // Set _Lanes to 1 when we have 0 tail elements,
+                    // to stop the compiler from complaining about an empty array.
+                    constexpr size_t _Lanes = _Unrolled_tail_elems == 0 ? 1 : _Unrolled_tail_elems;
+                    _Find_first_of_vec_t<_Ty> _Needle_tail[_Lanes];
+
+                    if constexpr (_Unrolled_tail_elems > 0) {
+                        for (size_t _Lane = 0; _Lane < _Unrolled_tail_elems; ++_Lane) {
+                            _Needle_tail[_Lane] = _Traits::_Set_neon_q(*(static_cast<const _Ty*>(_Stop2) + _Lane));
+                        }
+                    }
+
+                    do {
+                        const auto _Data1 = _Traits::_Load_q(_First1);
+
+                        auto _Eq = _Traits::_Set_neon_q(0);
+
+                        const void* _Ptr2 = _First2;
+                        for (; _Ptr2 != _Stop2; _Advance_bytes(_Ptr2, 16)) {
+                            const auto _Data2s0 = _Traits::_Load_q(_Ptr2);
+                            _Eq = _Traits::_Or(_Eq, _Shuffle_step<_Traits, _Length_el, _Ty>(_Data1, _Data2s0));
+                        }
+
+                        if constexpr (_Unrolled_tail_elems > 0) {
+                            // Unrolled tail.
+                            for (size_t _Lane = 0; _Lane < _Unrolled_tail_elems; ++_Lane) {
+                                const auto _Cmp = _Traits::_Cmp_neon_q(_Data1, _Needle_tail[_Lane]);
+                                _Eq             = _Traits::_Or(_Eq, _Cmp);
+                            }
+                        }
+
+                        // We unroll by a maximum of 4 (for 2-byte and 1-byte element types), so we need a non-unrolled
+                        // tail loop.
+                        if constexpr (_Unrolled_tail_elems == 4) {
+                            _Advance_bytes(_Ptr2, sizeof(_Ty) * _Unrolled_tail_elems);
+
+                            for (; _Ptr2 != _Last2; _Advance_bytes(_Ptr2, sizeof(_Ty))) {
+                                const auto _Needle = _Traits::_Set_neon_q(*(static_cast<const _Ty*>(_Ptr2)));
+                                const auto _Cmp    = _Traits::_Cmp_neon_q(_Data1, _Needle);
+                                _Eq                = _Traits::_Or(_Eq, _Cmp);
+                            }
+                        }
+
+                        uint64_t _Match = _Traits::_Mask_q(_Eq);
+                        if constexpr (_Pred == _Predicate::_None_of) {
+                            _Match ^= 0xFFFF'FFFF'FFFF'FFFF;
+                        }
+
+                        if (_Match != 0) {
+                            const unsigned long _Offset = _Finding::_Get_first_h_pos_q(_Match);
+                            _Advance_bytes(_First1, _Offset);
+                            return _First1;
+                        }
+
+                        _Advance_bytes(_First1, 16);
+                    } while (_First1 != _Stop1);
+                }
+
+                return _Fallback<_Ty, _Pred>(_First1, _Last1, _First2, _Last2);
+            }
+
+            const void* _Fallback_find_not_2(const void* const _First1, const void* const _Last1,
+                const void* const _First2, const void* const _Last2) noexcept {
+                auto _Ptr_haystack           = static_cast<const uint16_t*>(_First1);
+                const auto _Ptr_haystack_end = static_cast<const uint16_t*>(_Last1);
+
+                for (; _Ptr_haystack != _Ptr_haystack_end; ++_Ptr_haystack) {
+                    if (_Finding::_Find_impl<_Finding::_Find_traits_2, _Finding::_Predicate::_Equal>(
+                            _First2, _Last2, *_Ptr_haystack)
+                        == _Last2) {
+                        return _Ptr_haystack;
+                    }
+                }
+
+                return _Ptr_haystack;
+            }
+
+            template <class _Ty, _Predicate _Pred>
+            const void* __stdcall _Shuffle_impl_dispatch(const void* const _First1, const void* const _Last1,
+                const void* const _First2, const void* const _Last2) noexcept {
+
+                const size_t _Needle_length       = _Byte_length(_First2, _Last2);
+                const size_t _Needle_tail_length  = _Needle_length & 0xF;
+                const size_t _Last_tail_length_el = _Needle_tail_length / sizeof(_Ty);
+
+                if (_Last_tail_length_el == 0) {
+                    return _Shuffle_impl<_Ty, _Pred, 0>(_First1, _Last1, _First2, _Last2);
+                } else if (_Last_tail_length_el == 1) {
+                    return _Shuffle_impl<_Ty, _Pred, 1>(_First1, _Last1, _First2, _Last2);
+                } else if (_Last_tail_length_el == 2) {
+                    if constexpr (sizeof(_Ty) <= 4) {
+                        return _Shuffle_impl<_Ty, _Pred, 2>(_First1, _Last1, _First2, _Last2);
+                    }
+                } else if (_Last_tail_length_el == 3) {
+                    if constexpr (sizeof(_Ty) <= 4) {
+                        return _Shuffle_impl<_Ty, _Pred, 3>(_First1, _Last1, _First2, _Last2);
+                    }
+                } else if (_Last_tail_length_el >= 4) {
+                    if constexpr (sizeof(_Ty) <= 2) {
+                        return _Shuffle_impl<_Ty, _Pred, 4>(_First1, _Last1, _First2, _Last2);
+                    }
+                }
+
+                _STL_UNREACHABLE;
+            }
+
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            template <class _Ty, _Predicate _Pred>
+            const void* _Impl_pcmpestri(const void* _First1, const size_t _Haystack_length, const void* const _First2,
+                const size_t _Needle_length) noexcept {
+                constexpr int _Op_base =
+                    (_Pred == _Predicate::_Any_of ? _SIDD_POSITIVE_POLARITY : _SIDD_MASKED_NEGATIVE_POLARITY)
+                    | (sizeof(_Ty) == 1 ? _SIDD_UBYTE_OPS : _SIDD_UWORD_OPS) | _SIDD_CMP_EQUAL_ANY;
+                constexpr int _Op           = _Op_base | _SIDD_LEAST_SIGNIFICANT;
+                constexpr int _Part_size_el = sizeof(_Ty) == 1 ? 16 : 8;
+
+                const void* _Stop_at = _First1;
+                _Advance_bytes(_Stop_at, _Haystack_length & ~size_t{0xF});
+
+                if (_Needle_length <= 16) {
+                    // Special handling of small needle
+                    // The generic branch could also be modified to handle it, but with slightly worse performance
+
+                    const int _Needle_length_el = static_cast<int>(_Needle_length / sizeof(_Ty));
+
+                    alignas(16) uint8_t _Tmp2[16];
+                    memcpy(_Tmp2, _First2, _Needle_length);
+                    const __m128i _Data2 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+
+                    while (_First1 != _Stop_at) {
+                        const __m128i _Data1 = _mm_loadu_si128(static_cast<const __m128i*>(_First1));
+                        if (_mm_cmpestrc(_Data2, _Needle_length_el, _Data1, _Part_size_el, _Op)) {
+                            const int _Pos = _mm_cmpestri(_Data2, _Needle_length_el, _Data1, _Part_size_el, _Op);
+                            _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+                            return _First1;
+                        }
+
+                        _Advance_bytes(_First1, 16);
+                    }
+
+                    if (const size_t _Last_part_size = _Haystack_length & 0xF; _Last_part_size != 0) {
+                        const int _Last_part_size_el = static_cast<int>(_Last_part_size / sizeof(_Ty));
+
+                        alignas(16) uint8_t _Tmp1[16];
+                        memcpy(_Tmp1, _First1, _Last_part_size);
+                        const __m128i _Data1 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+
+                        if (_mm_cmpestrc(_Data2, _Needle_length_el, _Data1, _Last_part_size_el, _Op)) {
+                            const int _Pos = _mm_cmpestri(_Data2, _Needle_length_el, _Data1, _Last_part_size_el, _Op);
+                            _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+                            return _First1;
+                        }
+
+                        _Advance_bytes(_First1, _Last_part_size);
+                    }
+
+                    return _First1;
+                } else {
+                    const void* _Last_needle = _First2;
+                    _Advance_bytes(_Last_needle, _Needle_length & ~size_t{0xF});
+
+                    const int _Last_needle_length = static_cast<int>(_Needle_length & 0xF);
+
+                    alignas(16) uint8_t _Tmp2[16];
+                    memcpy(_Tmp2, _Last_needle, _Last_needle_length);
+                    const __m128i _Last_needle_val   = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+                    const int _Last_needle_length_el = _Last_needle_length / sizeof(_Ty);
+
+                    constexpr int _Not_found      = 16; // arbitrary value greater than any found value
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+                    const auto _Test_whole_needle = [=](const __m128i _Data1, const int _Size1,
+                                                        const int _Found_pos_init) noexcept {
+                        if constexpr (_Pred == _Predicate::_Any_of) {
+                            int _Found_pos = _Found_pos_init;
+
+                            const auto _Step = [&_Found_pos](const __m128i _Data2, const int _Size2,
+                                                   const __m128i _Data1, const int _Size1) noexcept {
+                                if (_mm_cmpestrc(_Data2, _Size2, _Data1, _Size1, _Op)) {
+                                    const int _Pos = _mm_cmpestri(_Data2, _Size2, _Data1, _Size1, _Op);
+                                    if (_Pos < _Found_pos) {
+                                        _Found_pos = _Pos;
+                                    }
+                                }
+                            };
+
+                            const void* _Cur_needle = _First2;
+                            do {
+                                const __m128i _Data2 = _mm_loadu_si128(static_cast<const __m128i*>(_Cur_needle));
+                                _Step(_Data2, _Part_size_el, _Data1, _Size1);
+                                _Advance_bytes(_Cur_needle, 16);
+                            } while (_Cur_needle != _Last_needle);
+
+                            if (_Last_needle_length_el != 0) {
+                                _Step(_Last_needle_val, _Last_needle_length_el, _Data1, _Size1);
+                            }
+
+                            return _Found_pos;
+                        } else {
+                            constexpr int _Op_mask = _Op_base | _SIDD_BIT_MASK;
+
+                            const void* _Cur_needle = _First2;
+
+                            const __m128i _Data2_first = _mm_loadu_si128(static_cast<const __m128i*>(_Cur_needle));
+
+                            __m128i _Found = _mm_cmpestrm(_Data2_first, _Part_size_el, _Data1, _Size1, _Op_mask);
+                            _Advance_bytes(_Cur_needle, 16);
+
+                            while (_Cur_needle != _Last_needle) {
+                                const __m128i _Data2 = _mm_loadu_si128(static_cast<const __m128i*>(_Cur_needle));
+                                const __m128i _Found_part =
+                                    _mm_cmpestrm(_Data2, _Part_size_el, _Data1, _Size1, _Op_mask);
+                                _Found = _mm_and_si128(_Found, _Found_part);
+                                _Advance_bytes(_Cur_needle, 16);
+                            }
+
+                            if (_Last_needle_length_el != 0) {
+                                const __m128i _Found_part =
+                                    _mm_cmpestrm(_Last_needle_val, _Last_needle_length_el, _Data1, _Size1, _Op_mask);
+                                _Found = _mm_and_si128(_Found, _Found_part);
+                            }
+
+                            const unsigned int _Bingo = _mm_cvtsi128_si32(_Found);
+                            int _Found_pos            = _Found_pos_init;
+
+                            if (_Bingo != 0) {
+                                unsigned long _Tmp;
+                                // CodeQL [SM02313] _Tmp is always initialized: we just tested `if (_Bingo != 0)`.
+                                _BitScanForward(&_Tmp, _Bingo);
+                                if (_Found_pos > static_cast<int>(_Tmp)) {
+                                    _Found_pos = static_cast<int>(_Tmp);
+                                }
+                            }
+
+                            return _Found_pos;
+                        }
+                    };
+#pragma warning(pop)
+
+                    while (_First1 != _Stop_at) {
+                        const int _Found_pos = _Test_whole_needle(
+                            _mm_loadu_si128(static_cast<const __m128i*>(_First1)), _Part_size_el, _Not_found);
+
+                        if (_Found_pos != _Not_found) {
+                            _Advance_bytes(_First1, _Found_pos * sizeof(_Ty));
+                            return _First1;
+                        }
+
+                        _Advance_bytes(_First1, 16);
+                    }
+
+                    if (const size_t _Last_part_size = _Haystack_length & 0xF; _Last_part_size != 0) {
+                        const int _Last_part_size_el = static_cast<int>(_Last_part_size / sizeof(_Ty));
+
+                        alignas(16) uint8_t _Tmp1[16];
+                        memcpy(_Tmp1, _First1, _Last_part_size);
+                        const __m128i _Data1 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+
+                        const int _Found_pos = _Test_whole_needle(_Data1, _Last_part_size_el, _Last_part_size_el);
+
+                        _Advance_bytes(_First1, _Found_pos * sizeof(_Ty));
+                    }
+
+                    return _First1;
+                }
+            }
+
+            template <class _Ty>
+            struct _Find_first_of_traits;
+
+            template <>
+            struct _Find_first_of_traits<uint32_t> {
+                static __m256i _Cmp_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                    return _mm256_cmpeq_epi32(_Lhs, _Rhs);
+                }
+
+                template <size_t _Amount>
+                static __m256i _Spread_avx(__m256i _Val, const size_t _Needle_length_el) noexcept {
+                    if constexpr (_Amount == 0) {
+                        return _mm256_undefined_si256();
+                    } else if constexpr (_Amount == 1) {
+                        return _mm256_broadcastd_epi32(_mm256_castsi256_si128(_Val));
+                    } else if constexpr (_Amount == 2) {
+                        return _mm256_broadcastq_epi64(_mm256_castsi256_si128(_Val));
+                    } else if constexpr (_Amount == 4) {
+                        if (_Needle_length_el < 4) {
+                            _Val = _mm256_shuffle_epi32(_Val, _MM_SHUFFLE(0, 2, 1, 0));
+                        }
+
+                        return _mm256_permute4x64_epi64(_Val, _MM_SHUFFLE(1, 0, 1, 0));
+                    } else if constexpr (_Amount == 8) {
+                        if (_Needle_length_el < 8) {
+                            const __m256i _Mask = _Avx2_tail_mask_32(_Needle_length_el * 4);
+                            // zero unused elements in sequential permutation mask, so will be filled by 1st
+                            const __m256i _Perm = _mm256_and_si256(_mm256_set_epi32(7, 6, 5, 4, 3, 2, 1, 0), _Mask);
+                            _Val                = _mm256_permutevar8x32_epi32(_Val, _Perm);
+                        }
+
+                        return _Val;
+                    } else {
+                        static_assert(false, "Unexpected amount");
+                    }
+                }
+
+                template <size_t _Amount>
+                static __m256i _Shuffle_avx(const __m256i _Val) noexcept {
+                    if constexpr (_Amount == 1) {
+                        return _mm256_shuffle_epi32(_Val, _MM_SHUFFLE(2, 3, 0, 1));
+                    } else if constexpr (_Amount == 2) {
+                        return _mm256_shuffle_epi32(_Val, _MM_SHUFFLE(1, 0, 3, 2));
+                    } else if constexpr (_Amount == 4) {
+                        return _mm256_permute4x64_epi64(_Val, _MM_SHUFFLE(1, 0, 3, 2));
+                    } else {
+                        static_assert(false, "Unexpected amount");
+                    }
+                }
+            };
+
+            template <>
+            struct _Find_first_of_traits<uint64_t> {
+                static __m256i _Cmp_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                    return _mm256_cmpeq_epi64(_Lhs, _Rhs);
+                }
+
+                template <size_t _Amount>
+                static __m256i _Spread_avx(const __m256i _Val, const size_t _Needle_length_el) noexcept {
+                    if constexpr (_Amount == 0) {
+                        return _mm256_undefined_si256();
+                    } else if constexpr (_Amount == 1) {
+                        return _mm256_broadcastq_epi64(_mm256_castsi256_si128(_Val));
+                    } else if constexpr (_Amount == 2) {
+                        return _mm256_permute4x64_epi64(_Val, _MM_SHUFFLE(1, 0, 1, 0));
+                    } else if constexpr (_Amount == 4) {
+                        if (_Needle_length_el < 4) {
+                            return _mm256_permute4x64_epi64(_Val, _MM_SHUFFLE(0, 2, 1, 0));
+                        }
+
+                        return _Val;
+                    } else {
+                        static_assert(false, "Unexpected amount");
+                    }
+                }
+
+                template <size_t _Amount>
+                static __m256i _Shuffle_avx(const __m256i _Val) noexcept {
+                    if constexpr (_Amount == 1) {
+                        return _mm256_shuffle_epi32(_Val, _MM_SHUFFLE(1, 0, 3, 2));
+                    } else if constexpr (_Amount == 2) {
+                        return _mm256_permute4x64_epi64(_Val, _MM_SHUFFLE(1, 0, 3, 2));
+                    } else {
+                        static_assert(false, "Unexpected amount");
+                    }
+                }
+            };
+
+            template <class _Traits, size_t _Needle_length_el_magnitude>
+            __m256i _Shuffle_step(const __m256i _Data1, const __m256i _Data2s0) noexcept {
+                __m256i _Eq = _mm256_setzero_si256();
+                if constexpr (_Needle_length_el_magnitude >= 1) {
+                    _Eq = _Traits::_Cmp_avx(_Data1, _Data2s0);
+                    if constexpr (_Needle_length_el_magnitude >= 2) {
+                        const __m256i _Data2s1 = _Traits::template _Shuffle_avx<1>(_Data2s0);
+                        _Eq                    = _mm256_or_si256(_Eq, _Traits::_Cmp_avx(_Data1, _Data2s1));
+                        if constexpr (_Needle_length_el_magnitude >= 4) {
+                            const __m256i _Data2s2 = _Traits::template _Shuffle_avx<2>(_Data2s0);
+                            _Eq                    = _mm256_or_si256(_Eq, _Traits::_Cmp_avx(_Data1, _Data2s2));
+                            const __m256i _Data2s3 = _Traits::template _Shuffle_avx<1>(_Data2s2);
+                            _Eq                    = _mm256_or_si256(_Eq, _Traits::_Cmp_avx(_Data1, _Data2s3));
+                            if constexpr (_Needle_length_el_magnitude >= 8) {
+                                const __m256i _Data2s4 = _Traits::template _Shuffle_avx<4>(_Data2s0);
+                                _Eq                    = _mm256_or_si256(_Eq, _Traits::_Cmp_avx(_Data1, _Data2s4));
+                                const __m256i _Data2s5 = _Traits::template _Shuffle_avx<1>(_Data2s4);
+                                _Eq                    = _mm256_or_si256(_Eq, _Traits::_Cmp_avx(_Data1, _Data2s5));
+                                const __m256i _Data2s6 = _Traits::template _Shuffle_avx<2>(_Data2s4);
+                                _Eq                    = _mm256_or_si256(_Eq, _Traits::_Cmp_avx(_Data1, _Data2s6));
+                                const __m256i _Data2s7 = _Traits::template _Shuffle_avx<1>(_Data2s6);
+                                _Eq                    = _mm256_or_si256(_Eq, _Traits::_Cmp_avx(_Data1, _Data2s7));
+                            }
+                        }
+                    }
+                }
+                return _Eq;
+            }
+
+            template <class _Ty, bool _Large, size_t _Last2_length_el_magnitude>
+            const void* _Shuffle_impl(const void* _First1, const size_t _Haystack_length, const void* const _First2,
+                const void* const _Stop2, const size_t _Last2_length_el) noexcept {
+                using _Traits               = _Find_first_of_traits<_Ty>;
+                constexpr size_t _Length_el = 32 / sizeof(_Ty);
+
+                const __m256i _Last2val = _mm256_maskload_epi32(
+                    reinterpret_cast<const int*>(_Stop2), _Avx2_tail_mask_32(_Last2_length_el * sizeof(_Ty)));
+                const __m256i _Last2s0 =
+                    _Traits::template _Spread_avx<_Last2_length_el_magnitude>(_Last2val, _Last2_length_el);
+
+                const void* _Stop1 = _First1;
+                _Advance_bytes(_Stop1, _Haystack_length & ~size_t{0x1F});
+
+                for (; _First1 != _Stop1; _Advance_bytes(_First1, 32)) {
+                    const __m256i _Data1 = _mm256_loadu_si256(static_cast<const __m256i*>(_First1));
+                    __m256i _Eq          = _Shuffle_step<_Traits, _Last2_length_el_magnitude>(_Data1, _Last2s0);
+
+                    if constexpr (_Large) {
+                        for (const void* _Ptr2 = _First2; _Ptr2 != _Stop2; _Advance_bytes(_Ptr2, 32)) {
+                            const __m256i _Data2s0 = _mm256_loadu_si256(static_cast<const __m256i*>(_Ptr2));
+                            _Eq = _mm256_or_si256(_Eq, _Shuffle_step<_Traits, _Length_el>(_Data1, _Data2s0));
+                        }
+                    }
+
+                    if (const uint32_t _Bingo = _mm256_movemask_epi8(_Eq); _Bingo != 0) {
+                        const unsigned long _Offset = _tzcnt_u32(_Bingo);
+                        _Advance_bytes(_First1, _Offset);
+                        return _First1;
+                    }
+                }
+
+                if (const size_t _Haystack_tail_length = _Haystack_length & 0x1C; _Haystack_tail_length != 0) {
+                    const __m256i _Tail_mask = _Avx2_tail_mask_32(_Haystack_tail_length);
+                    const __m256i _Data1     = _mm256_maskload_epi32(static_cast<const int*>(_First1), _Tail_mask);
+                    __m256i _Eq              = _Shuffle_step<_Traits, _Last2_length_el_magnitude>(_Data1, _Last2s0);
+
+                    if constexpr (_Large) {
+                        for (const void* _Ptr2 = _First2; _Ptr2 != _Stop2; _Advance_bytes(_Ptr2, 32)) {
+                            const __m256i _Data2s0 = _mm256_loadu_si256(static_cast<const __m256i*>(_Ptr2));
+                            _Eq = _mm256_or_si256(_Eq, _Shuffle_step<_Traits, _Length_el>(_Data1, _Data2s0));
+                        }
+                    }
+
+                    if (const uint32_t _Bingo = _mm256_movemask_epi8(_mm256_and_si256(_Eq, _Tail_mask)); _Bingo != 0) {
+                        const unsigned long _Offset = _tzcnt_u32(_Bingo);
+                        _Advance_bytes(_First1, _Offset);
+                        return _First1;
+                    }
+
+                    _Advance_bytes(_First1, _Haystack_tail_length);
+                }
+
+                return _First1;
+            }
+
+            template <class _Ty, bool _Large>
+            const void* _Shuffle_impl_dispatch_magnitude(const void* const _First1, const size_t _Haystack_length,
+                const void* const _First2, const void* const _Stop2, const size_t _Last2_length_el) noexcept {
+                if (_Last2_length_el == 0) {
+                    return _Shuffle_impl<_Ty, _Large, 0>(_First1, _Haystack_length, _First2, _Stop2, _Last2_length_el);
+                } else if (_Last2_length_el == 1) {
+                    return _Shuffle_impl<_Ty, _Large, 1>(_First1, _Haystack_length, _First2, _Stop2, _Last2_length_el);
+                } else if (_Last2_length_el == 2) {
+                    return _Shuffle_impl<_Ty, _Large, 2>(_First1, _Haystack_length, _First2, _Stop2, _Last2_length_el);
+                } else if (_Last2_length_el <= 4) {
+                    return _Shuffle_impl<_Ty, _Large, 4>(_First1, _Haystack_length, _First2, _Stop2, _Last2_length_el);
+                } else if (_Last2_length_el <= 8) {
+                    if constexpr (sizeof(_Ty) == 4) {
+                        return _Shuffle_impl<_Ty, _Large, 8>(
+                            _First1, _Haystack_length, _First2, _Stop2, _Last2_length_el);
+                    }
+                }
+
+                _STL_UNREACHABLE;
+            }
+
+            template <class _Ty>
+            const void* _Impl_4_8(const void* const _First1, const size_t _Haystack_length, const void* const _First2,
+                const size_t _Needle_length) noexcept {
+                _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
+
+                const size_t _Last_needle_length    = _Needle_length & 0x1F;
+                const size_t _Last_needle_length_el = _Last_needle_length / sizeof(_Ty);
+
+                if (const size_t _Needle_length_large = _Needle_length & ~size_t{0x1F}; _Needle_length_large != 0) {
+                    const void* _Stop2 = _First2;
+                    _Advance_bytes(_Stop2, _Needle_length_large);
+                    return _Shuffle_impl_dispatch_magnitude<_Ty, true>(
+                        _First1, _Haystack_length, _First2, _Stop2, _Last_needle_length_el);
+                } else {
+                    return _Shuffle_impl_dispatch_magnitude<_Ty, false>(
+                        _First1, _Haystack_length, _First2, _First2, _Last_needle_length_el);
+                }
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+            template <class _Ty>
+            const void* __stdcall _Dispatch_ptr(const void* const _First1, const void* const _Last1,
+                const void* const _First2, const void* const _Last2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+                return _Shuffle_impl_dispatch<_Ty, _Predicate::_Any_of>(_First1, _Last1, _First2, _Last2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+                if constexpr (sizeof(_Ty) <= 2) {
+                    if (_Use_sse42()) {
+                        return _Impl_pcmpestri<_Ty, _Predicate::_Any_of>(
+                            _First1, _Byte_length(_First1, _Last1), _First2, _Byte_length(_First2, _Last2));
+                    }
+                } else {
+                    if (_Use_avx2()) {
+                        return _Impl_4_8<_Ty>(
+                            _First1, _Byte_length(_First1, _Last1), _First2, _Byte_length(_First2, _Last2));
+                    }
+                }
+
+                return _Fallback<_Ty, _Predicate::_Any_of>(_First1, _Last1, _First2, _Last2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+            }
+
+            template <class _Ty>
+            size_t _Pos_from_ptr(
+                const void* const _Result, const void* const _First1, const void* const _Last1) noexcept {
+                if (_Result != _Last1) {
+                    return _Byte_length(_First1, _Result) / sizeof(_Ty);
+                } else {
+                    return static_cast<size_t>(-1);
+                }
+            }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            template <class _Ty, _Predicate _Pred>
+            size_t _Dispatch_pos_neon(const void* const _First1, const size_t _Count1, const void* const _First2,
+                const size_t _Count2) noexcept {
+                using namespace _Bitmap_impl;
+
+                if (_Use_bitmap_neon<_Ty>(_Count1, _Count2)) {
+                    if constexpr (sizeof(_Ty) < 8) {
+                        uint8x16x2_t _Bitmap;
+                        if (_Bitmap_details::_Make_bitmap<_Ty>(_First2, _Count2, _Bitmap)) {
+                            return _Impl_first_neon<_Ty, _Pred>(_First1, _Count1, _Bitmap);
+                        }
+                    }
+                } else if (_Use_bitmap_scalar<_Ty>(_Count1, _Count2)) {
+                    _Scalar_table_t _Table = {};
+                    if (_Build_scalar_table<_Ty>(_First2, _Count2, _Table)) {
+                        return _Impl_first_scalar<_Ty, _Pred>(_First1, _Count1, _Table);
+                    }
+                }
+
+                const void* const _Last1 = static_cast<const _Ty*>(_First1) + _Count1;
+                const void* const _Last2 = static_cast<const _Ty*>(_First2) + _Count2;
+
+                // For _None_of, it can be faster to Find Haystack elements in Needle for longer Needles or
+                // non-vectorized Haystack lengths.
+                if constexpr (_Pred == _Predicate::_None_of && sizeof(_Ty) >= 2) {
+                    static_assert(sizeof(_Ty) == 2);
+
+                    // Heuristic of Haystack smaller than Neon width, or Needle at least twice the Neon width.
+                    if (_Count1 * sizeof(_Ty) < 16 || _Count2 * sizeof(_Ty) >= 32) {
+                        return _Pos_from_ptr<_Ty>(
+                            _Fallback_find_not_2(_First1, _Last1, _First2, _Last2), _First1, _Last1);
+                    }
+                }
+
+                return _Pos_from_ptr<_Ty>(
+                    _Shuffle_impl_dispatch<_Ty, _Pred>(_First1, _Last1, _First2, _Last2), _First1, _Last1);
+            }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            template <class _Ty, _Predicate _Pred>
+            size_t _Dispatch_pos_sse_1_2(const void* const _First1, const size_t _Count1, const void* const _First2,
+                const size_t _Count2) noexcept {
+                using namespace _Bitmap_impl;
+
+                const _Strategy _Strat = _Pick_strategy<_Ty>(_Count1, _Count2, _Use_avx2());
+
+                if (_Strat == _Strategy::_Vector_bitmap) {
+                    if (_Can_fit_256_bits_sse(static_cast<const _Ty*>(_First2), _Count2)) {
+                        return _Impl_first_avx<_Ty, _Pred>(_First1, _Count1, _First2, _Count2);
+                    }
+                } else if (_Strat == _Strategy::_Scalar_bitmap) {
+                    if (_Can_fit_256_bits_sse(static_cast<const _Ty*>(_First2), _Count2)) {
+                        alignas(32) _Scalar_table_t _Table = {};
+                        _Build_scalar_table_no_check<_Ty>(_First2, _Count2, _Table);
+                        return _Impl_first_scalar<_Ty, _Pred>(_First1, _Count1, _Table);
+                    }
+                }
+
+                const void* const _Last1   = static_cast<const _Ty*>(_First1) + _Count1;
+                const size_t _Size_bytes_1 = _Count1 * sizeof(_Ty);
+                const size_t _Size_bytes_2 = _Count2 * sizeof(_Ty);
+
+                return _Pos_from_ptr<_Ty>(
+                    _Impl_pcmpestri<_Ty, _Pred>(_First1, _Size_bytes_1, _First2, _Size_bytes_2), _First1, _Last1);
+            }
+
+            template <class _Ty>
+            size_t _Dispatch_pos_avx_4_8(const void* const _First1, const size_t _Count1, const void* const _First2,
+                const size_t _Count2) noexcept {
+                using namespace _Bitmap_impl;
+
+                const auto _Strat = _Pick_strategy<_Ty>(_Count1, _Count2, true);
+
+                if (_Strat == _Strategy::_Vector_bitmap) {
+                    if (_Can_fit_256_bits_sse(static_cast<const _Ty*>(_First2), _Count2)) {
+                        return _Impl_first_avx<_Ty, _Predicate::_Any_of>(_First1, _Count1, _First2, _Count2);
+                    }
+                } else if (_Strat == _Strategy::_Scalar_bitmap) {
+                    if (_Can_fit_256_bits_sse(static_cast<const _Ty*>(_First2), _Count2)) {
+                        alignas(32) _Scalar_table_t _Table = {};
+                        _Build_scalar_table_no_check<_Ty>(_First2, _Count2, _Table);
+                        return _Impl_first_scalar<_Ty, _Predicate::_Any_of>(_First1, _Count1, _Table);
+                    }
+                }
+
+                const void* const _Last1   = static_cast<const _Ty*>(_First1) + _Count1;
+                const size_t _Size_bytes_1 = _Count1 * sizeof(_Ty);
+                const size_t _Size_bytes_2 = _Count2 * sizeof(_Ty);
+
+                return _Pos_from_ptr<_Ty>(
+                    _Impl_4_8<_Ty>(_First1, _Size_bytes_1, _First2, _Size_bytes_2), _First1, _Last1);
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+            template <class _Ty, _Predicate _Pred>
+            size_t _Dispatch_pos_fallback(const void* const _First1, const size_t _Count1, const void* const _First2,
+                const size_t _Count2) noexcept {
+                using namespace _Bitmap_impl;
+
+                _Scalar_table_t _Table = {};
+                if (_Build_scalar_table<_Ty>(_First2, _Count2, _Table)) {
+                    return _Impl_first_scalar<_Ty, _Pred>(_First1, _Count1, _Table);
+                }
+
+                const void* const _Last1 = static_cast<const _Ty*>(_First1) + _Count1;
+                const void* const _Last2 = static_cast<const _Ty*>(_First2) + _Count2;
+
+                return _Pos_from_ptr<_Ty>(_Fallback<_Ty, _Pred>(_First1, _Last1, _First2, _Last2), _First1, _Last1);
+            }
+
+            template <class _Ty, _Predicate _Pred>
+            size_t __stdcall _Dispatch_pos(const void* const _First1, const size_t _Count1, const void* const _First2,
+                const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+                return _Dispatch_pos_neon<_Ty, _Pred>(_First1, _Count1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+                if constexpr (sizeof(_Ty) <= 2) {
+                    if (_Use_sse42()) {
+                        return _Dispatch_pos_sse_1_2<_Ty, _Pred>(_First1, _Count1, _First2, _Count2);
+                    }
+                } else {
+                    if (_Use_avx2()) {
+                        static_assert(_Pred == _Predicate::_Any_of);
+
+                        return _Dispatch_pos_avx_4_8<_Ty>(_First1, _Count1, _First2, _Count2);
+                    }
+                }
+                return _Dispatch_pos_fallback<_Ty, _Pred>(_First1, _Count1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+            }
+        } // namespace _First_of
+
+        namespace _Last_of {
+            template <class _Ty, _Predicate _Pred>
+            size_t __stdcall _Fallback(const void* const _Haystack, const size_t _Haystack_length,
+                const void* const _Needle, const size_t _Needle_length) noexcept {
+
+                const auto _Ptr_haystack = static_cast<const _Ty*>(_Haystack);
+                size_t _Pos              = _Haystack_length;
+                const auto _Needle_end   = static_cast<const _Ty*>(_Needle) + _Needle_length;
+
+                while (_Pos != 0) {
+                    --_Pos;
+
+                    if constexpr (_Pred == _Predicate::_Any_of) {
+                        for (auto _Ptr = static_cast<const _Ty*>(_Needle); _Ptr != _Needle_end; ++_Ptr) {
+                            if (_Ptr_haystack[_Pos] == *_Ptr) {
+                                return _Pos;
+                            }
+                        }
+                    } else {
+                        bool _Match = false;
+                        for (auto _Ptr = static_cast<const _Ty*>(_Needle); _Ptr != _Needle_end; ++_Ptr) {
+                            if (_Ptr_haystack[_Pos] == *_Ptr) {
+                                _Match = true;
+                                break;
+                            }
+                        }
+
+                        if (!_Match) {
+                            return _Pos;
+                        }
+                    }
+                }
+
+                return static_cast<size_t>(-1);
+            }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            template <class _Ty, _Predicate _Pred, size_t _Unrolled_tail_elems>
+            size_t _Shuffle_impl(const void* const _First1, const size_t _Count1, const void* const _First2,
+                const size_t _Count2) noexcept {
+                using _Traits                   = _First_of::_Find_first_of_traits<_Ty>;
+                constexpr size_t _Vec_size_elem = 16 / sizeof(_Ty);
+
+                const void* const _Last1 = static_cast<const _Ty*>(_First1) + _Count1;
+                const void* const _Last2 = static_cast<const _Ty*>(_First2) + _Count2;
+
+                const size_t _Haystack_length = _Byte_length(_First1, _Last1);
+                const size_t _Vec_bytes       = _Haystack_length & ~size_t{0xF};
+                const void* _Stop1            = _Last1;
+                _Rewind_bytes(_Stop1, _Vec_bytes);
+
+                const void* _Cur1 = _Last1;
+                if (_Cur1 != _Stop1) {
+                    const size_t _Needle_length = _Byte_length(_First2, _Last2);
+                    const void* _Stop2          = _First2;
+                    _Advance_bytes(_Stop2, _Needle_length & ~size_t{0xF});
+
+                    // Set _Lanes to 1 when we have 0 tail elements,
+                    // to stop the compiler from complaining about an empty array.
+                    constexpr size_t _Lanes = _Unrolled_tail_elems == 0 ? 1 : _Unrolled_tail_elems;
+                    _First_of::_Find_first_of_vec_t<_Ty> _Needle_tail[_Lanes];
+
+                    if constexpr (_Unrolled_tail_elems > 0) {
+                        for (size_t _Lane = 0; _Lane < _Unrolled_tail_elems; ++_Lane) {
+                            _Needle_tail[_Lane] = _Traits::_Set_neon_q(*(static_cast<const _Ty*>(_Stop2) + _Lane));
+                        }
+                    }
+
+                    do {
+                        _Rewind_bytes(_Cur1, 16);
+                        const auto _Data1 = _Traits::_Load_q(_Cur1);
+
+                        auto _Eq = _Traits::_Set_neon_q(0);
+
+                        const void* _Ptr2 = _First2;
+                        for (; _Ptr2 != _Stop2; _Advance_bytes(_Ptr2, 16)) {
+                            const auto _Data2s0 = _Traits::_Load_q(_Ptr2);
+                            _Eq                 = _Traits::_Or(
+                                _Eq, _First_of::_Shuffle_step<_Traits, _Vec_size_elem, _Ty>(_Data1, _Data2s0));
+                        }
+
+                        if constexpr (_Unrolled_tail_elems > 0) {
+                            // Unrolled tail.
+                            for (size_t _Lane = 0; _Lane < _Unrolled_tail_elems; ++_Lane) {
+                                const auto _Cmp = _Traits::_Cmp_neon_q(_Data1, _Needle_tail[_Lane]);
+                                _Eq             = _Traits::_Or(_Eq, _Cmp);
+                            }
+                        }
+
+                        // We unroll by a maximum of 4 (for 2-byte and 1-byte element types), so we need a non-unrolled
+                        // tail loop.
+                        if constexpr (_Unrolled_tail_elems == 4) {
+                            _Advance_bytes(_Ptr2, sizeof(_Ty) * _Unrolled_tail_elems);
+
+                            for (; _Ptr2 != _Last2; _Advance_bytes(_Ptr2, sizeof(_Ty))) {
+                                const auto _Needle = _Traits::_Set_neon_q(*(static_cast<const _Ty*>(_Ptr2)));
+                                const auto _Cmp    = _Traits::_Cmp_neon_q(_Data1, _Needle);
+                                _Eq                = _Traits::_Or(_Eq, _Cmp);
+                            }
+                        }
+
+                        uint64_t _Match = _Traits::_Mask_q(_Eq);
+                        if constexpr (_Pred == _Predicate::_None_of) {
+                            _Match ^= 0xFFFF'FFFF'FFFF'FFFF;
+                        }
+
+                        if (_Match != 0) {
+                            const auto _Pos = _Finding::_Get_last_h_pos_q(_Match);
+                            _Advance_bytes(_Cur1, _Pos - (sizeof(_Ty) - 1));
+                            return _Byte_length(_First1, _Cur1) / sizeof(_Ty);
+                        }
+                    } while (_Cur1 != _Stop1);
+                }
+
+                const auto _Rem1 = _Byte_length(_First1, _Cur1) / sizeof(_Ty);
+
+                return _Fallback<_Ty, _Pred>(_First1, _Rem1, _First2, _Count2);
+            }
+
+            template <class _Ty, _Predicate _Pred>
+            size_t __stdcall _Shuffle_impl_dispatch(const void* const _First1, const size_t _Count1,
+                const void* const _First2, const size_t _Count2) noexcept {
+
+                constexpr size_t _Vec_size_elems  = 16 / sizeof(_Ty);
+                const size_t _Last_tail_length_el = _Count2 & (_Vec_size_elems - 1);
+
+                if (_Last_tail_length_el == 0) {
+                    return _Shuffle_impl<_Ty, _Pred, 0>(_First1, _Count1, _First2, _Count2);
+                } else if (_Last_tail_length_el == 1) {
+                    return _Shuffle_impl<_Ty, _Pred, 1>(_First1, _Count1, _First2, _Count2);
+                } else if (_Last_tail_length_el == 2) {
+                    if constexpr (sizeof(_Ty) <= 4) {
+                        return _Shuffle_impl<_Ty, _Pred, 2>(_First1, _Count1, _First2, _Count2);
+                    }
+                } else if (_Last_tail_length_el == 3) {
+                    if constexpr (sizeof(_Ty) <= 4) {
+                        return _Shuffle_impl<_Ty, _Pred, 3>(_First1, _Count1, _First2, _Count2);
+                    }
+                } else if (_Last_tail_length_el >= 4) {
+                    if constexpr (sizeof(_Ty) <= 2) {
+                        return _Shuffle_impl<_Ty, _Pred, 4>(_First1, _Count1, _First2, _Count2);
+                    }
+                }
+
+                _STL_UNREACHABLE;
+            }
+
+            size_t _Fallback_find_not_2(const void* const _First1, const size_t _Count1, const void* const _First2,
+                const size_t _Count2) noexcept {
+                const auto _Haystack_start = static_cast<const uint16_t*>(_First1);
+                const auto _Last2          = static_cast<const uint16_t*>(_First2) + _Count2;
+
+                for (auto _Ptr = _Haystack_start + _Count1 - 1;; --_Ptr) {
+                    if (_Finding::_Find_impl<_Finding::_Find_traits_2, _Finding::_Predicate::_Equal>(
+                            _First2, _Last2, *_Ptr)
+                        == _Last2) {
+                        return static_cast<size_t>(_Ptr - _Haystack_start);
+                    }
+
+                    if (_Ptr == _Haystack_start) {
+                        return static_cast<size_t>(-1);
+                    }
+                }
+            }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            template <class _Ty, _Predicate _Pred>
+            size_t _Impl(const void* const _Haystack, const size_t _Haystack_length, const void* const _Needle,
+                const size_t _Needle_length) noexcept {
+                const size_t _Haystack_length_bytes = _Haystack_length * sizeof(_Ty);
+
+                constexpr int _Op_base =
+                    (_Pred == _Predicate::_Any_of ? _SIDD_POSITIVE_POLARITY : _SIDD_MASKED_NEGATIVE_POLARITY)
+                    | (sizeof(_Ty) == 1 ? _SIDD_UBYTE_OPS : _SIDD_UWORD_OPS) | _SIDD_CMP_EQUAL_ANY;
+                constexpr int _Op           = _Op_base | _SIDD_MOST_SIGNIFICANT;
+                constexpr int _Part_size_el = sizeof(_Ty) == 1 ? 16 : 8;
+
+                const size_t _Last_part_size = _Haystack_length_bytes & 0xF;
+
+                const void* _Stop_at = _Haystack;
+                _Advance_bytes(_Stop_at, _Last_part_size);
+
+                const void* _Cur = _Haystack;
+                _Advance_bytes(_Cur, _Haystack_length_bytes);
+
+                const size_t _Needle_length_bytes = _Needle_length * sizeof(_Ty);
+
+                if (_Needle_length_bytes <= 16) {
+                    // Special handling of small needle
+                    // The generic branch could also be modified to handle it, but with slightly worse performance
+                    const int _Needle_length_el = static_cast<int>(_Needle_length);
+
+                    alignas(16) uint8_t _Tmp2[16];
+                    memcpy(_Tmp2, _Needle, _Needle_length_bytes);
+                    const __m128i _Data2 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+
+                    while (_Cur != _Stop_at) {
+                        _Rewind_bytes(_Cur, 16);
+                        const __m128i _Data1 = _mm_loadu_si128(static_cast<const __m128i*>(_Cur));
+                        if (_mm_cmpestrc(_Data2, _Needle_length_el, _Data1, _Part_size_el, _Op)) {
+                            const int _Pos = _mm_cmpestri(_Data2, _Needle_length_el, _Data1, _Part_size_el, _Op);
+                            return _Byte_length(_Haystack, _Cur) / sizeof(_Ty) + _Pos;
+                        }
+                    }
+
+                    if (_Last_part_size != 0) {
+                        const int _Last_part_size_el = static_cast<int>(_Last_part_size / sizeof(_Ty));
+                        __m128i _Data1;
+
+                        if (_Haystack_length_bytes >= 16) {
+                            _Data1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Haystack));
+                        } else {
+                            alignas(16) uint8_t _Tmp1[16];
+                            memcpy(_Tmp1, _Haystack, _Haystack_length_bytes);
+                            _Data1 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+                        }
+
+                        if (_mm_cmpestrc(_Data2, _Needle_length_el, _Data1, _Last_part_size_el, _Op)) {
+                            return _mm_cmpestri(_Data2, _Needle_length_el, _Data1, _Last_part_size_el, _Op);
+                        }
+                    }
+
+                    return static_cast<size_t>(-1);
+                } else {
+                    const void* _Last_needle = _Needle;
+                    _Advance_bytes(_Last_needle, _Needle_length_bytes & ~size_t{0xF});
+
+                    const int _Last_needle_length = static_cast<int>(_Needle_length_bytes & 0xF);
+
+                    alignas(16) uint8_t _Tmp2[16];
+                    memcpy(_Tmp2, _Last_needle, _Last_needle_length);
+                    const __m128i _Last_needle_val   = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+                    const int _Last_needle_length_el = _Last_needle_length / sizeof(_Ty);
+
+                    // equal to npos when treated as size_t; also less than any found value
+                    constexpr int _Not_found      = -1;
+
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+                    const auto _Test_whole_needle = [=](const __m128i _Data1, const int _Size1) noexcept {
+                        if constexpr (_Pred == _Predicate::_Any_of) {
+                            int _Found_pos = _Not_found;
+
+                            const auto _Step = [&_Found_pos](const __m128i _Data2, const int _Size2,
+                                                   const __m128i _Data1, const int _Size1) noexcept {
+                                if (_mm_cmpestrc(_Data2, _Size2, _Data1, _Size1, _Op)) {
+                                    const int _Pos = _mm_cmpestri(_Data2, _Size2, _Data1, _Size1, _Op);
+                                    if (_Pos > _Found_pos) {
+                                        _Found_pos = _Pos;
+                                    }
+                                }
+                            };
+
+                            const void* _Cur_needle = _Needle;
+                            do {
+                                const __m128i _Data2 = _mm_loadu_si128(static_cast<const __m128i*>(_Cur_needle));
+                                _Step(_Data2, _Part_size_el, _Data1, _Size1);
+                                _Advance_bytes(_Cur_needle, 16);
+                            } while (_Cur_needle != _Last_needle);
+
+                            if (_Last_needle_length_el != 0) {
+                                _Step(_Last_needle_val, _Last_needle_length_el, _Data1, _Size1);
+                            }
+
+                            return _Found_pos;
+                        } else {
+                            constexpr int _Op_mask = _Op_base | _SIDD_BIT_MASK;
+
+                            const void* _Cur_needle = _Needle;
+
+                            const __m128i _Data2_first = _mm_loadu_si128(static_cast<const __m128i*>(_Cur_needle));
+
+                            __m128i _Found = _mm_cmpestrm(_Data2_first, _Part_size_el, _Data1, _Size1, _Op_mask);
+
+                            while (_Cur_needle != _Last_needle) {
+                                const __m128i _Data2 = _mm_loadu_si128(static_cast<const __m128i*>(_Cur_needle));
+                                const __m128i _Found_part =
+                                    _mm_cmpestrm(_Data2, _Part_size_el, _Data1, _Size1, _Op_mask);
+                                _Found = _mm_and_si128(_Found, _Found_part);
+                                _Advance_bytes(_Cur_needle, 16);
+                            }
+
+                            if (_Last_needle_length_el != 0) {
+                                const __m128i _Found_part =
+                                    _mm_cmpestrm(_Last_needle_val, _Last_needle_length_el, _Data1, _Size1, _Op_mask);
+                                _Found = _mm_and_si128(_Found, _Found_part);
+                                _Advance_bytes(_Cur_needle, 16);
+                            }
+
+                            const unsigned int _Bingo = _mm_cvtsi128_si32(_Found);
+                            int _Found_pos            = _Not_found;
+
+                            if (_Bingo != 0) {
+                                unsigned long _Tmp;
+                                // CodeQL [SM02313] _Tmp is always initialized: we just tested `if (_Bingo != 0)`.
+                                _BitScanReverse(&_Tmp, _Bingo);
+                                _Found_pos = static_cast<int>(_Tmp);
+                            }
+
+                            return _Found_pos;
+                        }
+                    };
+#pragma warning(pop)
+
+                    while (_Cur != _Stop_at) {
+                        _Rewind_bytes(_Cur, 16);
+                        const int _Found_pos =
+                            _Test_whole_needle(_mm_loadu_si128(static_cast<const __m128i*>(_Cur)), _Part_size_el);
+
+                        if (_Found_pos != _Not_found) {
+                            return _Byte_length(_Haystack, _Cur) / sizeof(_Ty) + _Found_pos;
+                        }
+                    }
+
+                    if (_Last_part_size != 0) {
+                        const int _Last_part_size_el = static_cast<int>(_Last_part_size / sizeof(_Ty));
+                        __m128i _Data1;
+
+                        if (_Haystack_length_bytes >= 16) {
+                            _Data1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Haystack));
+                        } else {
+                            alignas(16) uint8_t _Tmp1[16];
+                            memcpy(_Tmp1, _Haystack, _Haystack_length_bytes);
+                            _Data1 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+                        }
+
+                        return _Test_whole_needle(_Data1, _Last_part_size_el);
+                    }
+
+                    return static_cast<size_t>(_Not_found);
+                }
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+            template <class _Ty, _Predicate _Pred>
+            size_t __stdcall _Dispatch_pos(const void* const _First1, const size_t _Count1, const void* const _First2,
+                const size_t _Count2) noexcept {
+                using namespace _Bitmap_impl;
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+                if (_Use_bitmap_neon<_Ty>(_Count1, _Count2)) {
+                    if constexpr (sizeof(_Ty) < 8) {
+                        uint8x16x2_t _Bitmap;
+                        if (_Bitmap_details::_Make_bitmap<_Ty>(_First2, _Count2, _Bitmap)) {
+                            return _Impl_last_neon<_Ty, _Pred>(_First1, _Count1, _Bitmap);
+                        }
+                    }
+                } else if (_Use_bitmap_scalar<_Ty>(_Count1, _Count2)) {
+                    alignas(32) _Scalar_table_t _Table = {};
+                    if (_Build_scalar_table<_Ty>(_First2, _Count2, _Table)) {
+                        return _Impl_last_scalar<_Ty, _Pred>(_First1, _Count1, _Table);
+                    }
+                }
+
+                // For _None_of, it can be faster to Find Haystack elements in Needle for longer Needles or
+                // non-vectorized Haystack lengths.
+                if constexpr (_Pred == _Predicate::_None_of && sizeof(_Ty) >= 2) {
+                    static_assert(sizeof(_Ty) == 2);
+
+                    // Heuristic of Haystack smaller than Neon width, or Needle at least twice the Neon width.
+                    if (_Count1 * sizeof(_Ty) < 16 || _Count2 * sizeof(_Ty) >= 32) {
+                        return _Fallback_find_not_2(_First1, _Count1, _First2, _Count2);
+                    }
+                }
+
+                return _Shuffle_impl_dispatch<_Ty, _Pred>(_First1, _Count1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+                if (_Use_sse42()) {
+                    const auto _Strat = _Pick_strategy<_Ty>(_Count1, _Count2, _Use_avx2());
+
+                    if (_Strat == _Strategy::_Vector_bitmap) {
+                        if (_Can_fit_256_bits_sse(static_cast<const _Ty*>(_First2), _Count2)) {
+                            return _Impl_last_avx<_Ty, _Pred>(_First1, _Count1, _First2, _Count2);
+                        }
+                    } else if (_Strat == _Strategy::_Scalar_bitmap) {
+                        if (_Can_fit_256_bits_sse(static_cast<const _Ty*>(_First2), _Count2)) {
+                            alignas(32) _Scalar_table_t _Table = {};
+                            _Build_scalar_table_no_check<_Ty>(_First2, _Count2, _Table);
+                            return _Impl_last_scalar<_Ty, _Pred>(_First1, _Count1, _Table);
+                        }
+                    }
+
+                    return _Impl<_Ty, _Pred>(_First1, _Count1, _First2, _Count2);
+                } else {
+                    alignas(32) _Scalar_table_t _Table = {};
+                    if (_Build_scalar_table<_Ty>(_First2, _Count2, _Table)) {
+                        return _Impl_last_scalar<_Ty, _Pred>(_First1, _Count1, _Table);
+                    }
+
+                    return _Fallback<_Ty, _Pred>(_First1, _Count1, _First2, _Count2);
+                }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+            }
+        } // namespace _Last_of
+    } // namespace _Find_meow_of
+} // unnamed namespace
+
+extern "C" {
+
+const void* __stdcall __std_find_first_of_trivial_1(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_ptr<uint8_t>(_First1, _Last1, _First2, _Last2);
+}
+
+const void* __stdcall __std_find_first_of_trivial_2(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_ptr<uint16_t>(_First1, _Last1, _First2, _Last2);
+}
+
+const void* __stdcall __std_find_first_of_trivial_4(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_ptr<uint32_t>(_First1, _Last1, _First2, _Last2);
+}
+
+const void* __stdcall __std_find_first_of_trivial_8(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_ptr<uint64_t>(_First1, _Last1, _First2, _Last2);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_1(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_pos<uint8_t, _Find_meow_of::_Predicate::_Any_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_2(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_pos<uint16_t, _Find_meow_of::_Predicate::_Any_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_4(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_pos<uint32_t, _Find_meow_of::_Predicate::_Any_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_first_of_trivial_pos_8(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_pos<uint64_t, _Find_meow_of::_Predicate::_Any_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_last_of_trivial_pos_1(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_Last_of::_Dispatch_pos<uint8_t, _Find_meow_of::_Predicate::_Any_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_last_of_trivial_pos_2(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_Last_of::_Dispatch_pos<uint16_t, _Find_meow_of::_Predicate::_Any_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_first_not_of_trivial_pos_1(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_pos<uint8_t, _Find_meow_of::_Predicate::_None_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_first_not_of_trivial_pos_2(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_First_of::_Dispatch_pos<uint16_t, _Find_meow_of::_Predicate::_None_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_last_not_of_trivial_pos_1(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_Last_of::_Dispatch_pos<uint8_t, _Find_meow_of::_Predicate::_None_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+__declspec(noalias) size_t __stdcall __std_find_last_not_of_trivial_pos_2(const void* const _Haystack,
+    const size_t _Haystack_length, const void* const _Needle, const size_t _Needle_length) noexcept {
+    return _Find_meow_of::_Last_of::_Dispatch_pos<uint16_t, _Find_meow_of::_Predicate::_None_of>(
+        _Haystack, _Haystack_length, _Needle, _Needle_length);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Find_seq {
+        // The caveat in the 'search' and 'find_end' optimization is that this pattern would be inefficient:
+        //   for (auto i = hay_begin; i != hay_end; ++i) {
+        //      if (memcmp(i, needle, size) == 0) { return i; }
+        //   }
+        // because the mismatch usually happens early, so memcmp would typically be slower than a simple loop.
+        //
+        // The solution is:
+        //  - in outer loop, do the 'find'-like thing, but preserve the setup (i.e. vector with first needle element)
+        //  - in inner loop, try to compare with readily available needle in a register,
+        //    or at least with the needle start, if the needle is long, to fail early mismatches early.
+        // Or use SSE4.2 _mm_cmpestri, which can be good too, especially for 8-bit forward search.
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Find_seq_traits_neon {
+            static constexpr size_t _Vec_size = 16;
+            using _Guard                      = char;
+
+            static uint64_t _Tail_bitmask(const size_t _Tail_bytes) noexcept {
+                // _Tail_bytes in [0,16].
+                if (_Tail_bytes == 16) {
+                    return ~0ull;
+                }
+                return (uint64_t{1} << (4 * _Tail_bytes)) - 1;
+            }
+
+            static uint64_t _Bsf(const uint64_t _Mask) noexcept {
+                return _Finding::_Get_first_h_pos_q(_Mask);
+            }
+
+            static uint64_t _Bsr(const uint64_t _Mask) noexcept {
+                return _Finding::_Get_last_h_pos_q(_Mask);
+            }
+
+            static uint64_t _Bingo_next(const uint64_t _Bingo, const uint64_t _Pos) noexcept {
+                return _Bingo ^ (uint64_t{0xF} << (_Pos << 2));
+            }
+
+            static __forceinline bool _Memcmp_inline_eq(
+                const void* const _First, const void* const _Second, const size_t _Count) noexcept {
+                const auto _First_b  = static_cast<const uint8_t*>(_First);
+                const auto _Second_b = static_cast<const uint8_t*>(_Second);
+
+                size_t _Ix = 0;
+
+                if (_Count >= 16) {
+                    const size_t _Vec_end = _Count & ~size_t{0x1F};
+
+                    for (; _Ix < _Vec_end; _Ix += 32) {
+                        const auto _Cmp1    = veorq_u8(vld1q_u8(_First_b + _Ix), vld1q_u8(_Second_b + _Ix));
+                        const auto _Cmp2    = veorq_u8(vld1q_u8(_First_b + _Ix + 16), vld1q_u8(_Second_b + _Ix + 16));
+                        const auto _Combine = vpmaxq_u8(_Cmp1, _Cmp2);
+                        const uint64_t _Any = vgetq_lane_u64(vreinterpretq_u64_u8(vpmaxq_u8(_Combine, _Combine)), 0);
+                        if (_Any != 0) {
+                            return false;
+                        }
+                    }
+
+                    if ((_Count & size_t{0x10}) != 0) { // use original _Count; we've read only 32-byte chunks
+                        const auto _Cmp     = veorq_u8(vld1q_u8(_First_b + _Ix), vld1q_u8(_Second_b + _Ix));
+                        const uint64_t _Any = vgetq_lane_u64(vreinterpretq_u64_u8(vpmaxq_u8(_Cmp, _Cmp)), 0);
+                        if (_Any != 0) {
+                            return false;
+                        }
+
+                        _Ix += 16;
+                    }
+                }
+
+                if (_Ix < _Count) {
+                    // Overlapped Neon path avoids need for scalar tail.
+                    const ptrdiff_t _Ix_tail = static_cast<ptrdiff_t>(_Count) - 16;
+                    const auto _Cmp          = veorq_u8(vld1q_u8(_First_b + _Ix_tail), vld1q_u8(_Second_b + _Ix_tail));
+                    const uint64_t _Any      = vgetq_lane_u64(vreinterpretq_u64_u8(vpmaxq_u8(_Cmp, _Cmp)), 0);
+                    if (_Any != 0) {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+        };
+
+        struct _Find_seq_traits_neon_1 : _Find_seq_traits_neon {
+            using _Vec_t = uint8x16_t;
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_u8(static_cast<const uint8_t*>(_Src));
+            }
+
+            static _Vec_t _Load_tail(const void* const _Src, const size_t _Size_bytes, _Vec_t = {}) noexcept {
+                unsigned char _Tmp[16];
+                memcpy(_Tmp, _Src, _Size_bytes);
+                return _Load(_Tmp);
+            }
+
+            static _Vec_t _Broadcast(const _Vec_t _Data) noexcept {
+                return vdupq_n_u8(vgetq_lane_u8(_Data, 0));
+            }
+
+            static uint64_t _Cmp(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                return _Finding::_Find_traits_1::_Mask_q(vceqq_u8(_Lhs, _Rhs));
+            }
+
+            static _Vec_t _Xor(const _Vec_t _Val1, const _Vec_t _Val2) noexcept {
+                return veorq_u8(_Val1, _Val2);
+            }
+
+            static bool _TestZ(const _Vec_t _Val) noexcept {
+                const auto _Msk = vgetq_lane_u64(vreinterpretq_u64_u8(vpmaxq_u8(_Val, _Val)), 0);
+                return _Msk == 0;
+            }
+
+            static bool _TestZ(const _Vec_t _Val, const _Vec_t _Mask) noexcept {
+                return _TestZ(vandq_u8(_Val, _Mask));
+            }
+
+            static uint8x16_t _Mask(const size_t _Count_in_bytes) noexcept {
+                // _Count_in_bytes must be within [0,16].
+                static constexpr uint32_t _Tail_masks[8] = {~0u, ~0u, ~0u, ~0u, 0, 0, 0, 0};
+                const auto _Base                         = reinterpret_cast<const uint8_t*>(_Tail_masks);
+                return vld1q_u8(_Base + (16 - _Count_in_bytes));
+            }
+        };
+
+        struct _Find_seq_traits_neon_2 : _Find_seq_traits_neon {
+            using _Vec_t = uint16x8_t;
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_u16(static_cast<const uint16_t*>(_Src));
+            }
+
+            static _Vec_t _Load_tail(const void* const _Src, const size_t _Size_bytes, _Vec_t = {}) noexcept {
+                unsigned char _Tmp[16];
+                memcpy(_Tmp, _Src, _Size_bytes);
+                return _Load(_Tmp);
+            }
+
+            static _Vec_t _Broadcast(const _Vec_t _Data) noexcept {
+                return vdupq_n_u16(vgetq_lane_u16(_Data, 0));
+            }
+
+            static uint64_t _Cmp(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                return _Finding::_Find_traits_2::_Mask_q(vceqq_u16(_Lhs, _Rhs)) & 0x0F0F0F0F0F0F0F0F;
+            }
+
+            static _Vec_t _Xor(const _Vec_t _Val1, const _Vec_t _Val2) noexcept {
+                return veorq_u16(_Val1, _Val2);
+            }
+
+            static bool _TestZ(const _Vec_t _Val) noexcept {
+                return _Find_seq_traits_neon_1::_TestZ(vreinterpretq_u8_u16(_Val));
+            }
+
+            static bool _TestZ(const _Vec_t _Val, const _Vec_t _Mask) noexcept {
+                return _TestZ(vandq_u16(_Val, _Mask));
+            }
+
+            static _Vec_t _Mask(const size_t _Count_in_bytes) noexcept {
+                return vreinterpretq_u16_u8(_Find_seq_traits_neon_1::_Mask(_Count_in_bytes));
+            }
+        };
+
+        struct _Find_seq_traits_neon_4 : _Find_seq_traits_neon {
+            using _Vec_t = uint32x4_t;
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_u32(static_cast<const uint32_t*>(_Src));
+            }
+
+            static _Vec_t _Load_tail(const void* const _Src, const size_t _Size_bytes, _Vec_t = {}) noexcept {
+                unsigned char _Tmp[16];
+                memcpy(_Tmp, _Src, _Size_bytes);
+                return _Load(_Tmp);
+            }
+
+            static _Vec_t _Broadcast(const _Vec_t _Data) noexcept {
+                return vdupq_n_u32(vgetq_lane_u32(_Data, 0));
+            }
+
+            static uint64_t _Cmp(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                return _Finding::_Find_traits_4::_Mask_q(vceqq_u32(_Lhs, _Rhs)) & 0x000F000F000F000F;
+            }
+
+            static _Vec_t _Xor(const _Vec_t _Val1, const _Vec_t _Val2) noexcept {
+                return veorq_u32(_Val1, _Val2);
+            }
+
+            static bool _TestZ(const _Vec_t _Val) noexcept {
+                return _Find_seq_traits_neon_1::_TestZ(vreinterpretq_u8_u32(_Val));
+            }
+
+            static bool _TestZ(const _Vec_t _Val, const _Vec_t _Mask) noexcept {
+                return _TestZ(vandq_u32(_Val, _Mask));
+            }
+
+            static _Vec_t _Mask(const size_t _Count_in_bytes) noexcept {
+                return vreinterpretq_u32_u8(_Find_seq_traits_neon_1::_Mask(_Count_in_bytes));
+            }
+        };
+
+        struct _Find_seq_traits_neon_8 : _Find_seq_traits_neon {
+            using _Vec_t = uint64x2_t;
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return vld1q_u64(static_cast<const uint64_t*>(_Src));
+            }
+
+            static _Vec_t _Load_tail(const void* const _Src, const size_t _Size_bytes, _Vec_t = {}) noexcept {
+                unsigned char _Tmp[16];
+                memcpy(_Tmp, _Src, _Size_bytes);
+                return _Load(_Tmp);
+            }
+
+            static _Vec_t _Broadcast(const _Vec_t _Data) noexcept {
+                return vdupq_n_u64(vgetq_lane_u64(_Data, 0));
+            }
+
+            static uint64_t _Cmp(const _Vec_t _Lhs, const _Vec_t _Rhs) noexcept {
+                return _Finding::_Find_traits_8::_Mask_q(vceqq_u64(_Lhs, _Rhs)) & 0x0000000F0000000F;
+            }
+
+            static _Vec_t _Xor(const _Vec_t _Val1, const _Vec_t _Val2) noexcept {
+                return veorq_u64(_Val1, _Val2);
+            }
+
+            static bool _TestZ(const _Vec_t _Val) noexcept {
+                return _Find_seq_traits_neon_1::_TestZ(vreinterpretq_u8_u64(_Val));
+            }
+
+            static bool _TestZ(const _Vec_t _Val, const _Vec_t _Mask) noexcept {
+                return _TestZ(vandq_u64(_Val, _Mask));
+            }
+
+            static _Vec_t _Mask(const size_t _Count_in_bytes) noexcept {
+                return vreinterpretq_u64_u8(_Find_seq_traits_neon_1::_Mask(_Count_in_bytes));
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Find_seq_traits_avx {
+            using _Guard = _Zeroupper_on_exit;
+
+            static constexpr size_t _Vec_size = 32;
+
+            static unsigned long _Bingo_next(const unsigned long _Bingo, const unsigned int _Pos) noexcept {
+                return _Bingo ^ (1 << _Pos);
+            }
+
+            static __m256i _Mask(const size_t _Count_in_bytes) noexcept {
+                return _Avx2_tail_mask_32(_Count_in_bytes);
+            }
+
+            static unsigned int _Tail_bitmask(const size_t _Tail_bytes) noexcept {
+                return (1 << _Tail_bytes) - 1;
+            }
+
+            static __m256i _Load(const void* const _Src) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+            }
+
+            static __m256i _Xor(const __m256i _Val1, const __m256i _Val2) noexcept {
+                return _mm256_xor_si256(_Val1, _Val2);
+            }
+
+            static bool _TestZ(const __m256i _Val) noexcept {
+                return _mm256_testz_si256(_Val, _Val);
+            }
+
+            static bool _TestZ(const __m256i _Val1, const __m256i _Val2) noexcept {
+                return _mm256_testz_si256(_Val1, _Val2);
+            }
+
+            static unsigned int _Bsf(const unsigned long _Mask) noexcept {
+                return _tzcnt_u32(_Mask);
+            }
+
+            static unsigned int _Bsr(const unsigned long _Mask) noexcept {
+                return 31 - _lzcnt_u32(_Mask);
+            }
+
+            static __forceinline bool _Memcmp_inline_eq(
+                const void* const _First, const void* const _Second, const size_t _Count) noexcept {
+                return memcmp(_First, _Second, _Count) == 0;
+            }
+        };
+
+        struct _Find_seq_traits_avx_1_2 : _Find_seq_traits_avx {
+            static __m256i _Load_tail(
+                const void* const _Src, const size_t _Size_bytes, __m256i = _mm256_undefined_si256()) noexcept {
+                unsigned char _Tmp[32];
+                memcpy(_Tmp, _Src, _Size_bytes);
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Tmp));
+            }
+        };
+
+        struct _Find_seq_traits_avx_4_8 : _Find_seq_traits_avx {
+            static __m256i _Load_tail(const void* const _Src, size_t, const __m256i _Mask) noexcept {
+                return _mm256_maskload_epi32(reinterpret_cast<const int*>(_Src), _Mask);
+            }
+
+            static __m256i _Load_tail(const void* const _Src, const size_t _Size_bytes) noexcept {
+                const __m256i _Mask = _Avx2_tail_mask_32(_Size_bytes);
+                return _mm256_maskload_epi32(reinterpret_cast<const int*>(_Src), _Mask);
+            }
+        };
+
+        struct _Find_seq_traits_avx_1 : _Find_seq_traits_avx_1_2 {
+            static __m256i _Broadcast(const __m256i _Data) noexcept {
+                return _mm256_broadcastb_epi8(_mm256_castsi256_si128(_Data));
+            }
+
+            static unsigned long _Cmp(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_movemask_epi8(_mm256_cmpeq_epi8(_Lhs, _Rhs));
+            }
+        };
+
+        struct _Find_seq_traits_avx_2 : _Find_seq_traits_avx_1_2 {
+            static __m256i _Broadcast(const __m256i _Data) noexcept {
+                return _mm256_broadcastw_epi16(_mm256_castsi256_si128(_Data));
+            }
+
+            static unsigned long _Cmp(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_movemask_epi8(_mm256_cmpeq_epi16(_Lhs, _Rhs)) & 0x55555555;
+            }
+        };
+
+        struct _Find_seq_traits_avx_4 : _Find_seq_traits_avx_4_8 {
+            static __m256i _Broadcast(const __m256i _Data) noexcept {
+                return _mm256_broadcastd_epi32(_mm256_castsi256_si128(_Data));
+            }
+
+            static unsigned long _Cmp(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_movemask_epi8(_mm256_cmpeq_epi32(_Lhs, _Rhs)) & 0x11111111;
+            }
+        };
+
+        struct _Find_seq_traits_avx_8 : _Find_seq_traits_avx_4_8 {
+            static __m256i _Broadcast(const __m256i _Data) noexcept {
+                return _mm256_broadcastq_epi64(_mm256_castsi256_si128(_Data));
+            }
+
+            static unsigned long _Cmp(const __m256i _Lhs, const __m256i _Rhs) noexcept {
+                return _mm256_movemask_epi8(_mm256_cmpeq_epi64(_Lhs, _Rhs)) & 0x01010101;
+            }
+        };
+
+        struct _Find_seq_traits_sse_4_8 {
+            using _Guard = char;
+
+            static constexpr size_t _Vec_size = 16;
+
+            static unsigned long _Bingo_next(const unsigned long _Bingo, const unsigned int _Pos) noexcept {
+                return _Bingo ^ (1 << _Pos);
+            }
+
+            static __m128i _Mask(const size_t _Count_in_bytes) noexcept {
+                // _Count_in_bytes must be within [0, 16].
+                static constexpr unsigned int _Tail_masks[8] = {~0u, ~0u, ~0u, ~0u, 0, 0, 0, 0};
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(
+                    reinterpret_cast<const unsigned char*>(_Tail_masks) + (16 - _Count_in_bytes)));
+            }
+
+            static unsigned int _Tail_bitmask(const size_t _Tail_bytes) noexcept {
+                return (1 << _Tail_bytes) - 1;
+            }
+
+            static __m128i _Load(const void* const _Src) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
+            }
+
+            static __m128i _Xor(const __m128i _Val1, const __m128i _Val2) noexcept {
+                return _mm_xor_si128(_Val1, _Val2);
+            }
+
+            static bool _TestZ(const __m128i _Val) noexcept {
+                return _mm_testz_si128(_Val, _Val);
+            }
+
+            static bool _TestZ(const __m128i _Val1, const __m128i _Val2) noexcept {
+                return _mm_testz_si128(_Val1, _Val2);
+            }
+
+            static __m128i _Load_tail(
+                const void* const _Src, const size_t _Size_bytes, __m128i = _mm_undefined_si128()) noexcept {
+                unsigned char _Tmp[16];
+                memcpy(_Tmp, _Src, _Size_bytes);
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Tmp));
+            }
+
+            static unsigned int _Bsf(const unsigned long _Mask) noexcept {
+                unsigned long _Index;
+                // CodeQL [SM02313] _Index is always initialized: we checked _Mask != 0 on every call site
+                _BitScanForward(&_Index, _Mask);
+                return _Index;
+            }
+
+            static unsigned int _Bsr(const unsigned long _Mask) noexcept {
+                unsigned long _Index;
+                // CodeQL [SM02313] _Index is always initialized: we checked _Mask != 0 on every call site
+                _BitScanReverse(&_Index, _Mask);
+                return _Index;
+            }
+
+            static __forceinline bool _Memcmp_inline_eq(
+                const void* const _First, const void* const _Second, const size_t _Count) noexcept {
+                return memcmp(_First, _Second, _Count) == 0;
+            }
+        };
+
+        struct _Find_seq_traits_sse_4 : _Find_seq_traits_sse_4_8 {
+            static __m128i _Broadcast(const __m128i _Data) noexcept {
+                return _mm_shuffle_epi32(_Data, _MM_SHUFFLE(0, 0, 0, 0));
+            }
+
+            static unsigned long _Cmp(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_movemask_epi8(_mm_cmpeq_epi32(_Lhs, _Rhs)) & 0x1111;
+            }
+        };
+
+        struct _Find_seq_traits_sse_8 : _Find_seq_traits_sse_4_8 {
+            static __m128i _Broadcast(const __m128i _Data) noexcept {
+                return _mm_shuffle_epi32(_Data, _MM_SHUFFLE(1, 0, 1, 0));
+            }
+
+            static unsigned long _Cmp(const __m128i _Lhs, const __m128i _Rhs) noexcept {
+                return _mm_movemask_epi8(_mm_cmpeq_epi64(_Lhs, _Rhs)) & 0x0101;
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        template <class _Ty>
+        const void* _Search_scalar_tail(const void* const _First1, const void* const _Last1, const size_t _Size_bytes_1,
+            const void* const _First2, const size_t _Count2, const size_t _Size_bytes_2) noexcept {
+            const size_t _Max_pos = _Size_bytes_1 - _Size_bytes_2 + sizeof(_Ty);
+
+            auto _Ptr1         = static_cast<const _Ty*>(_First1);
+            const auto _Ptr2   = static_cast<const _Ty*>(_First2);
+            const void* _Stop1 = _Ptr1;
+            _Advance_bytes(_Stop1, _Max_pos);
+
+            for (; _Ptr1 != _Stop1; ++_Ptr1) {
+                if (*_Ptr1 != *_Ptr2) {
+                    continue;
+                }
+
+                bool _Equal = true;
+
+                for (size_t _Idx = 1; _Idx != _Count2; ++_Idx) {
+                    if (_Ptr1[_Idx] != _Ptr2[_Idx]) {
+                        _Equal = false;
+                        break;
+                    }
+                }
+
+                if (_Equal) {
+                    return _Ptr1;
+                }
+            }
+
+            return _Last1;
+        }
+
+        template <class _Ty>
+        const void* _Find_end_scalar_tail(const void* const _First1, const void* const _Last1,
+            const void* const _First2, const size_t _Count2) noexcept {
+            auto _Ptr1       = static_cast<const _Ty*>(_Last1) - _Count2;
+            const auto _Ptr2 = static_cast<const _Ty*>(_First2);
+
+            for (;;) {
+                if (*_Ptr1 == *_Ptr2) {
+                    bool _Equal = true;
+
+                    for (size_t _Idx = 1; _Idx != _Count2; ++_Idx) {
+                        if (_Ptr1[_Idx] != _Ptr2[_Idx]) {
+                            _Equal = false;
+                            break;
+                        }
+                    }
+
+                    if (_Equal) {
+                        return _Ptr1;
+                    }
+                }
+
+                if (_Ptr1 == _First1) {
+                    return _Last1;
+                }
+
+                --_Ptr1;
+            }
+        }
+
+        template <class _Traits, class _Ty>
+        const void* _Search_cmpeq(const void* _First1, const void* const _Last1, const void* const _First2,
+            const size_t _Size_bytes_2) noexcept {
+            [[maybe_unused]] typename _Traits::_Guard _Guard; // TRANSITION, DevCom-10331414
+            const size_t _Size_bytes_1 = _Byte_length(_First1, _Last1);
+            constexpr size_t _Vec_size = _Traits::_Vec_size;
+            constexpr size_t _Vec_mask = _Vec_size - 1;
+
+            if (_Size_bytes_2 <= _Vec_size) {
+                const auto _Mask2  = _Traits::_Mask(_Size_bytes_2);
+                const auto _Data2  = _Traits::_Load_tail(_First2, _Size_bytes_2, _Mask2);
+                const auto _Start2 = _Traits::_Broadcast(_Data2);
+
+                const void* _Stop1 = _First1;
+                _Advance_bytes(_Stop1, _Size_bytes_1 & ~_Vec_mask);
+                do {
+                    const auto _Data1 = _Traits::_Load(_First1);
+                    auto _Bingo       = _Traits::_Cmp(_Data1, _Start2);
+
+                    while (_Bingo != 0) {
+                        const auto _Pos = _Traits::_Bsf(_Bingo);
+
+                        const void* _Match = _First1;
+                        _Advance_bytes(_Match, _Pos);
+
+                        decltype(_Traits::_Load(_Match)) _Cmp;
+                        if (const size_t _Left_match = _Byte_length(_Match, _Last1); _Left_match >= _Vec_size) {
+                            const auto _Match_val = _Traits::_Load(_Match);
+                            _Cmp                  = _Traits::_Xor(_Data2, _Match_val);
+                        } else if (_Left_match >= _Size_bytes_2) {
+                            const auto _Match_val = _Traits::_Load_tail(_Match, _Left_match);
+                            _Cmp                  = _Traits::_Xor(_Data2, _Match_val);
+                        } else {
+                            break;
+                        }
+
+                        if (_Traits::_TestZ(_Cmp, _Mask2)) {
+                            return _Match;
+                        }
+
+                        _Bingo = _Traits::_Bingo_next(_Bingo, _Pos);
+                    }
+
+                    _Advance_bytes(_First1, _Vec_size);
+                } while (_First1 != _Stop1);
+
+                if (const size_t _Left1 = _Byte_length(_First1, _Last1); _Left1 >= _Size_bytes_2) {
+                    const auto _Data1 = _Traits::_Load_tail(_First1, _Left1);
+                    auto _Bingo       = _Traits::_Cmp(_Data1, _Start2);
+
+                    while (_Bingo != 0) {
+                        const auto _Pos = _Traits::_Bsf(_Bingo);
+
+                        if (_Pos > _Left1 - _Size_bytes_2) {
+                            break;
+                        }
+
+                        const void* _Match = _First1;
+                        _Advance_bytes(_Match, _Pos);
+
+                        const size_t _Left_match = _Byte_length(_Match, _Last1);
+                        const auto _Match_val    = _Traits::_Load_tail(_Match, _Left_match);
+                        const auto _Cmp          = _Traits::_Xor(_Data2, _Match_val);
+
+                        if (_Traits::_TestZ(_Cmp, _Mask2)) {
+                            return _Match;
+                        }
+
+                        _Bingo = _Traits::_Bingo_next(_Bingo, _Pos);
+                    }
+                }
+
+                return _Last1;
+            } else { // _Size_bytes_2 is greater than _Vec_size bytes
+                const auto _Data2  = _Traits::_Load(_First2);
+                const auto _Start2 = _Traits::_Broadcast(_Data2);
+
+                const size_t _Max_pos = _Size_bytes_1 - _Size_bytes_2;
+
+                const void* _Stop1 = _First1;
+                _Advance_bytes(_Stop1, _Max_pos);
+
+                const void* _Tail2 = _First2;
+                _Advance_bytes(_Tail2, _Vec_size);
+
+                do {
+                    const auto _Data1 = _Traits::_Load(_First1);
+                    auto _Bingo       = _Traits::_Cmp(_Data1, _Start2);
+
+                    while (_Bingo != 0) {
+                        const auto _Pos = _Traits::_Bsf(_Bingo);
+
+                        const void* _Match = _First1;
+                        _Advance_bytes(_Match, _Pos);
+
+                        if (_Match > _Stop1) {
+                            break; // Oops, doesn't fit
+                        }
+
+                        const auto _Match_val = _Traits::_Load(_Match);
+                        const auto _Cmp       = _Traits::_Xor(_Data2, _Match_val);
+
+                        if (_Traits::_TestZ(_Cmp)) {
+                            const void* _Tail1 = _Match;
+                            _Advance_bytes(_Tail1, _Vec_size);
+
+                            if (_Traits::_Memcmp_inline_eq(_Tail1, _Tail2, _Size_bytes_2 - _Vec_size)) {
+                                return _Match;
+                            }
+                        }
+
+                        _Bingo = _Traits::_Bingo_next(_Bingo, _Pos);
+                    }
+
+                    _Advance_bytes(_First1, _Vec_size);
+                } while (_First1 <= _Stop1);
+
+                return _Last1;
+            }
+        }
+
+        template <class _Traits, class _Ty>
+        const void* _Find_end_cmpeq(const void* const _First1, const void* const _Last1, const void* const _First2,
+            const size_t _Size_bytes_2) noexcept {
+            [[maybe_unused]] typename _Traits::_Guard _Guard; // TRANSITION, DevCom-10331414
+            const size_t _Size_bytes_1 = _Byte_length(_First1, _Last1);
+            constexpr size_t _Vec_size = _Traits::_Vec_size;
+            constexpr size_t _Vec_mask = _Vec_size - 1;
+
+            if (_Size_bytes_2 <= _Vec_size) {
+                const auto _Needle_fit_mask = _Traits::_Tail_bitmask(_Traits::_Vec_size - _Size_bytes_2 + sizeof(_Ty));
+
+                const void* _Stop1 = _First1;
+                _Advance_bytes(_Stop1, _Size_bytes_1 & _Vec_mask);
+
+                const auto _Mask2  = _Traits::_Mask(_Size_bytes_2);
+                const auto _Data2  = _Traits::_Load_tail(_First2, _Size_bytes_2, _Mask2);
+                const auto _Start2 = _Traits::_Broadcast(_Data2);
+
+                const void* _Mid1 = _Last1;
+                _Rewind_bytes(_Mid1, _Vec_size);
+
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+                const auto _Check_first = [=, &_Mid1](auto _Match) noexcept [[msvc::forceinline]] {
+                    while (_Match != 0) {
+                        const auto _Pos = _Traits::_Bsr(_Match);
+
+                        const void* _Tmp1 = _Mid1;
+                        _Advance_bytes(_Tmp1, _Pos);
+
+                        const auto _Match_data = _Traits::_Load_tail(_Tmp1, _Byte_length(_Tmp1, _Last1));
+                        const auto _Cmp_result = _Traits::_Xor(_Data2, _Match_data);
+
+                        if (_Traits::_TestZ(_Cmp_result, _Mask2)) {
+                            _Mid1 = _Tmp1;
+                            return true;
+                        }
+
+                        _Match = _Traits::_Bingo_next(_Match, _Pos);
+                    }
+
+                    return false;
+                };
+
+                const auto _Check = [=, &_Mid1](auto _Match) noexcept [[msvc::forceinline]] {
+                    while (_Match != 0) {
+                        const auto _Pos = _Traits::_Bsr(_Match);
+
+                        const void* _Tmp1 = _Mid1;
+                        _Advance_bytes(_Tmp1, _Pos);
+
+                        const auto _Match_data = _Traits::_Load(_Tmp1);
+                        const auto _Cmp_result = _Traits::_Xor(_Data2, _Match_data);
+
+                        if (_Traits::_TestZ(_Cmp_result, _Mask2)) {
+                            _Mid1 = _Tmp1;
+                            return true;
+                        }
+
+                        _Match = _Traits::_Bingo_next(_Match, _Pos);
+                    }
+
+                    return false;
+                };
+#pragma warning(pop)
+
+                // The very last part, for any match needle should fit, otherwise false match
+                const auto _Data1_last     = _Traits::_Load(_Mid1);
+                const auto _Match_last_val = _Traits::_Cmp(_Data1_last, _Start2);
+                if (_Check_first(_Match_last_val & _Needle_fit_mask)) {
+                    return _Mid1;
+                }
+
+                // The middle part, fit and unfit needle
+                while (_Mid1 != _Stop1) {
+                    _Rewind_bytes(_Mid1, _Vec_size);
+                    const auto _Data1     = _Traits::_Load(_Mid1);
+                    const auto _Match_val = _Traits::_Cmp(_Data1, _Start2);
+                    if (_Check(_Match_val)) {
+                        return _Mid1;
+                    }
+                }
+
+                // The first part, fit and unfit needle, mask out already processed positions
+                if (const size_t _Tail_bytes_1 = _Size_bytes_1 & _Vec_mask; _Tail_bytes_1 != 0) {
+                    _Mid1                 = _First1;
+                    const auto _Data1     = _Traits::_Load(_Mid1);
+                    const auto _Match_val = _Traits::_Cmp(_Data1, _Start2);
+                    if (_Match_val != 0 && _Check(_Match_val & _Traits::_Tail_bitmask(_Tail_bytes_1))) {
+                        return _Mid1;
+                    }
+                }
+
+                return _Last1;
+            } else { // _Size_bytes_2 is greater than _Vec_size bytes
+                const auto _Data2  = _Traits::_Load(_First2);
+                const auto _Start2 = _Traits::_Broadcast(_Data2);
+
+                const void* _Tail2 = _First2;
+                _Advance_bytes(_Tail2, _Vec_size);
+
+                const void* _Mid1 = _Last1;
+                _Rewind_bytes(_Mid1, _Size_bytes_2);
+
+                const size_t _Size_diff_bytes = _Size_bytes_1 - _Size_bytes_2;
+                const void* _Stop1            = _First1;
+                _Advance_bytes(_Stop1, _Size_diff_bytes & _Vec_mask);
+
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+                const auto _Check = [=, &_Mid1](auto _Match) noexcept [[msvc::forceinline]] {
+                    while (_Match != 0) {
+                        const auto _Pos = _Traits::_Bsr(_Match);
+
+                        const void* _Tmp1 = _Mid1;
+                        _Advance_bytes(_Tmp1, _Pos);
+
+                        const auto _Match_data = _Traits::_Load(_Tmp1);
+                        const auto _Cmp_result = _Traits::_Xor(_Data2, _Match_data);
+
+                        if (_Traits::_TestZ(_Cmp_result)) {
+                            const void* _Tail1 = _Tmp1;
+                            _Advance_bytes(_Tail1, _Vec_size);
+
+                            if (_Traits::_Memcmp_inline_eq(_Tail1, _Tail2, _Size_bytes_2 - _Vec_size)) {
+                                _Mid1 = _Tmp1;
+                                return true;
+                            }
+                        }
+
+                        _Match = _Traits::_Bingo_next(_Match, _Pos);
+                    }
+
+                    return false;
+                };
+#pragma warning(pop)
+                // The very last part, just compare, as true match must start with first symbol
+                const auto _Data1_last = _Traits::_Load(_Mid1);
+                const auto _Match_last = _Traits::_Xor(_Data2, _Data1_last);
+
+                if (_Traits::_TestZ(_Match_last)) {
+                    // Matched _Vec_size bytes, check the rest
+                    const void* _Tail1 = _Mid1;
+                    _Advance_bytes(_Tail1, _Vec_size);
+
+                    if (_Traits::_Memcmp_inline_eq(_Tail1, _Tail2, _Size_bytes_2 - _Vec_size)) {
+                        return _Mid1;
+                    }
+                }
+
+                // The main part, match all characters
+                while (_Mid1 != _Stop1) {
+                    _Rewind_bytes(_Mid1, _Vec_size);
+
+                    const auto _Data1     = _Traits::_Load(_Mid1);
+                    const auto _Match_val = _Traits::_Cmp(_Data1, _Start2);
+                    if (_Check(_Match_val)) {
+                        return _Mid1;
+                    }
+                }
+
+                // The first part, mask out already processed positions
+                if (const size_t _Tail_bytes_1 = _Size_diff_bytes & _Vec_mask; _Tail_bytes_1 != 0) {
+                    _Mid1                 = _First1;
+                    const auto _Data1     = _Traits::_Load(_Mid1);
+                    const auto _Match_val = _Traits::_Cmp(_Data1, _Start2);
+                    if (_Match_val != 0 && _Check(_Match_val & _Traits::_Tail_bitmask(_Tail_bytes_1))) {
+                        return _Mid1;
+                    }
+                }
+
+                return _Last1;
+            }
+        }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        template <class _FindTraits, class _Traits, class _Ty>
+        const void* __stdcall _Search_impl(const void* const _First1, const void* const _Last1,
+            const void* const _First2, const size_t _Count2) noexcept {
+            if (_Count2 == 0) {
+                return _First1;
+            }
+
+            if (_Count2 == 1) {
+                return _Finding::_Find_impl<_FindTraits, _Finding::_Predicate::_Equal>(
+                    _First1, _Last1, *static_cast<const _Ty*>(_First2));
+            }
+
+            const size_t _Size_bytes_1 = _Byte_length(_First1, _Last1);
+            const size_t _Size_bytes_2 = _Count2 * sizeof(_Ty);
+
+            if (_Size_bytes_1 < _Size_bytes_2) {
+                return _Last1;
+            }
+
+            if (_Size_bytes_1 >= 16) {
+                return _Search_cmpeq<_Traits, _Ty>(_First1, _Last1, _First2, _Size_bytes_2);
+            }
+
+            return _Search_scalar_tail<_Ty>(_First1, _Last1, _Size_bytes_1, _First2, _Count2, _Size_bytes_2);
+        }
+
+        template <class _FindTraits, class _Traits, class _Ty>
+        const void* __stdcall _Find_end_impl(const void* const _First1, const void* const _Last1,
+            const void* const _First2, const size_t _Count2) noexcept {
+            if (_Count2 == 0) {
+                return _Last1;
+            }
+
+            if (_Count2 == 1) {
+                return _Finding::_Find_last_impl<_FindTraits, _Finding::_Predicate::_Equal>(
+                    _First1, _Last1, *static_cast<const _Ty*>(_First2));
+            }
+
+            const size_t _Size_bytes_1 = _Byte_length(_First1, _Last1);
+            const size_t _Size_bytes_2 = _Count2 * sizeof(_Ty);
+
+            if (_Size_bytes_1 < _Size_bytes_2) {
+                return _Last1;
+            }
+
+            if (_Size_bytes_1 >= 16) {
+                return _Find_end_cmpeq<_Traits, _Ty>(_First1, _Last1, _First2, _Size_bytes_2);
+            }
+
+            return _Find_end_scalar_tail<_Ty>(_First1, _Last1, _First2, _Count2);
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        template <class _FindTraits, class _Traits_avx, class _Traits_sse, class _Ty>
+        const void* __stdcall _Search_impl(
+            const void* _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+            if (_Count2 == 0) {
+                return _First1;
+            }
+
+            if (_Count2 == 1) {
+                return _Finding::_Find_impl<_FindTraits, _Finding::_Predicate::_Equal>(
+                    _First1, _Last1, *static_cast<const _Ty*>(_First2));
+            }
+
+            const size_t _Size_bytes_1 = _Byte_length(_First1, _Last1);
+            const size_t _Size_bytes_2 = _Count2 * sizeof(_Ty);
+
+            if (_Size_bytes_1 < _Size_bytes_2) {
+                return _Last1;
+            }
+
+            // The AVX2 path for 8-bit elements is not necessarily more efficient than the SSE4.2 cmpestri path
+            if constexpr (sizeof(_Ty) != 1) {
+                if (_Use_avx2() && _Size_bytes_1 >= 32) {
+                    return _Search_cmpeq<_Traits_avx, _Ty>(_First1, _Last1, _First2, _Size_bytes_2);
+                }
+            }
+
+            if (_Use_sse42() && _Size_bytes_1 >= 16) {
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return _Search_cmpeq<_Traits_sse, _Ty>(_First1, _Last1, _First2, _Size_bytes_2);
+                } else {
+                    constexpr int _Op =
+                        (sizeof(_Ty) == 1 ? _SIDD_UBYTE_OPS : _SIDD_UWORD_OPS) | _SIDD_CMP_EQUAL_ORDERED;
+                    constexpr int _Part_size_el = sizeof(_Ty) == 1 ? 16 : 8;
+
+                    if (_Size_bytes_2 <= 16) {
+                        const int _Size_el_2 = static_cast<int>(_Size_bytes_2 / sizeof(_Ty));
+
+                        const int _Max_full_match_pos = _Part_size_el - _Size_el_2;
+
+                        alignas(16) uint8_t _Tmp2[16];
+                        memcpy(_Tmp2, _First2, _Size_bytes_2);
+                        const __m128i _Data2 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+
+                        const void* _Stop1 = _First1;
+                        _Advance_bytes(_Stop1, _Size_bytes_1 - 16);
+
+                        do {
+                            const __m128i _Data1 = _mm_loadu_si128(static_cast<const __m128i*>(_First1));
+
+                            if (!_mm_cmpestrc(_Data2, _Size_el_2, _Data1, _Part_size_el, _Op)) {
+                                _Advance_bytes(_First1, 16); // No matches, next.
+                            } else {
+                                const int _Pos = _mm_cmpestri(_Data2, _Size_el_2, _Data1, _Part_size_el, _Op);
+                                _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+                                if (_Pos <= _Max_full_match_pos) {
+                                    // Full match. Return this match.
+                                    return _First1;
+                                }
+                                // Partial match. Search again from the match start. Will return it if it is full.
+                            }
+                        } while (_First1 <= _Stop1);
+
+                        const size_t _Size_bytes_1_tail = _Byte_length(_First1, _Last1);
+                        if (_Size_bytes_1_tail != 0) {
+                            const int _Size_el_1_tail = static_cast<int>(_Size_bytes_1_tail / sizeof(_Ty));
+
+                            alignas(16) uint8_t _Tmp1[16];
+                            memcpy(_Tmp1, _First1, _Size_bytes_1_tail);
+                            const __m128i _Data1 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+
+                            if (_mm_cmpestrc(_Data2, _Size_el_2, _Data1, _Size_el_1_tail, _Op)) {
+                                const int _Pos = _mm_cmpestri(_Data2, _Size_el_2, _Data1, _Size_el_1_tail, _Op);
+                                _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+                                // Full match because size is less than 16. Return this match.
+                                return _First1;
+                            }
+                        }
+
+                        return _Last1;
+                    } else { // _Size_bytes_2 is greater than 16 bytes
+                        const __m128i _Data2  = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_First2));
+                        const size_t _Max_pos = _Size_bytes_1 - _Size_bytes_2;
+
+                        const void* _Stop1 = _First1;
+                        _Advance_bytes(_Stop1, _Max_pos);
+
+                        const void* _Tail2 = _First2;
+                        _Advance_bytes(_Tail2, 16);
+
+                        do {
+                            const __m128i _Data1 = _mm_loadu_si128(static_cast<const __m128i*>(_First1));
+                            if (!_mm_cmpestrc(_Data2, _Part_size_el, _Data1, _Part_size_el, _Op)) {
+                                _Advance_bytes(_First1, 16); // No matches, next.
+                            } else {
+                                const int _Pos = _mm_cmpestri(_Data2, _Part_size_el, _Data1, _Part_size_el, _Op);
+
+                                bool _Match_1st_16 = true;
+
+                                if (_Pos != 0) {
+                                    _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+
+                                    if (_First1 > _Stop1) {
+                                        break; // Oops, doesn't fit
+                                    }
+
+                                    // Match not from the first byte, check 16 symbols
+                                    const __m128i _Match1 = _mm_loadu_si128(static_cast<const __m128i*>(_First1));
+                                    const __m128i _Cmp    = _mm_xor_si128(_Data2, _Match1);
+                                    if (!_mm_testz_si128(_Cmp, _Cmp)) {
+                                        _Match_1st_16 = false;
+                                    }
+                                }
+
+                                if (_Match_1st_16) {
+                                    const void* _Tail1 = _First1;
+                                    _Advance_bytes(_Tail1, 16);
+
+                                    if (memcmp(_Tail1, _Tail2, _Size_bytes_2 - 16) == 0) {
+                                        return _First1;
+                                    }
+                                }
+
+                                // Start from the next element
+                                _Advance_bytes(_First1, sizeof(_Ty));
+                            }
+                        } while (_First1 <= _Stop1);
+
+                        return _Last1;
+                    }
+                }
+            }
+
+            return _Search_scalar_tail<_Ty>(_First1, _Last1, _Size_bytes_1, _First2, _Count2, _Size_bytes_2);
+        }
+
+        template <class _FindTraits, class _Traits_avx, class _Traits_sse, class _Ty>
+        const void* __stdcall _Find_end_impl(const void* const _First1, const void* const _Last1,
+            const void* const _First2, const size_t _Count2) noexcept {
+            if (_Count2 == 0) {
+                return _Last1;
+            }
+
+            if (_Count2 == 1) {
+                return _Finding::_Find_last_impl<_FindTraits, _Finding::_Predicate::_Equal>(
+                    _First1, _Last1, *static_cast<const _Ty*>(_First2));
+            }
+
+            const size_t _Size_bytes_1 = _Byte_length(_First1, _Last1);
+            const size_t _Size_bytes_2 = _Count2 * sizeof(_Ty);
+
+            if (_Size_bytes_1 < _Size_bytes_2) {
+                return _Last1;
+            }
+
+            if (_Use_avx2() && _Size_bytes_1 >= 32) {
+                return _Find_end_cmpeq<_Traits_avx, _Ty>(_First1, _Last1, _First2, _Size_bytes_2);
+            }
+
+            if (_Use_sse42() && _Size_bytes_1 >= 16) {
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return _Find_end_cmpeq<_Traits_sse, _Ty>(_First1, _Last1, _First2, _Size_bytes_2);
+                } else {
+                    constexpr int _Op =
+                        (sizeof(_Ty) == 1 ? _SIDD_UBYTE_OPS : _SIDD_UWORD_OPS) | _SIDD_CMP_EQUAL_ORDERED;
+                    constexpr int _Part_size_el = sizeof(_Ty) == 1 ? 16 : 8;
+
+                    static constexpr int8_t _Low_part_mask[] = {//
+                        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
+                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+                    if (_Size_bytes_2 <= 16) {
+                        const int _Size_el_2                  = static_cast<int>(_Count2);
+                        constexpr unsigned int _Whole_mask    = (1 << _Part_size_el) - 1;
+                        const unsigned int _Needle_fit_mask   = (1 << (_Part_size_el - _Size_el_2 + 1)) - 1;
+                        const unsigned int _Needle_unfit_mask = _Whole_mask ^ _Needle_fit_mask;
+
+                        const void* _Stop1 = _First1;
+                        _Advance_bytes(_Stop1, _Size_bytes_1 & 0xF);
+
+                        alignas(16) uint8_t _Tmp2[16];
+                        memcpy(_Tmp2, _First2, _Size_bytes_2);
+                        const __m128i _Data2 = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+
+                        const void* _Mid1 = _Last1;
+                        _Rewind_bytes(_Mid1, 16);
+
+                        const auto _Check_fit = [&_Mid1, _Needle_fit_mask](const unsigned int _Match) noexcept {
+                            const unsigned int _Fit_match = _Match & _Needle_fit_mask;
+                            if (_Fit_match != 0) {
+                                unsigned long _Match_last_pos;
+
+                                // CodeQL [SM02313] Result is always initialized: we just tested that _Fit_match != 0.
+                                _BitScanReverse(&_Match_last_pos, _Fit_match);
+
+                                _Advance_bytes(_Mid1, _Match_last_pos * sizeof(_Ty));
+                                return true;
+                            }
+
+                            return false;
+                        };
+
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+                        const auto _Check_unfit = [=, &_Mid1](const unsigned int _Match) noexcept {
+                            unsigned long _Unfit_match = _Match & _Needle_unfit_mask;
+                            while (_Unfit_match != 0) {
+                                const void* _Tmp1 = _Mid1;
+                                unsigned long _Match_last_pos;
+
+                                // CodeQL [SM02313] Result is always initialized: we just tested that _Unfit_match != 0.
+                                _BitScanReverse(&_Match_last_pos, _Unfit_match);
+
+                                _Advance_bytes(_Tmp1, _Match_last_pos * sizeof(_Ty));
+
+                                const __m128i _Match_data = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+                                const __m128i _Cmp_result = _mm_xor_si128(_Data2, _Match_data);
+                                const __m128i _Data_mask  = _mm_loadu_si128(
+                                    reinterpret_cast<const __m128i*>(_Low_part_mask + 16 - _Size_bytes_2));
+
+                                if (_mm_testz_si128(_Cmp_result, _Data_mask)) {
+                                    _Mid1 = _Tmp1;
+                                    return true;
+                                }
+
+                                _Unfit_match ^= 1 << _Match_last_pos;
+                            }
+
+                            return false;
+                        };
+#pragma warning(pop)
+
+                        // TRANSITION, DevCom-10689455, the code below could test with _mm_cmpestrc,
+                        // if it has been fused with _mm_cmpestrm.
+
+                        // The very last part, for any match needle should fit, otherwise false match
+                        const __m128i _Data1_last = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Mid1));
+                        const auto _Match_last    = _mm_cmpestrm(_Data2, _Size_el_2, _Data1_last, _Part_size_el, _Op);
+                        const unsigned int _Match_last_val = _mm_cvtsi128_si32(_Match_last);
+                        if (_Check_fit(_Match_last_val)) {
+                            return _Mid1;
+                        }
+
+                        // The middle part, fit and unfit needle
+                        while (_Mid1 != _Stop1) {
+                            _Rewind_bytes(_Mid1, 16);
+                            const __m128i _Data1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Mid1));
+                            const auto _Match    = _mm_cmpestrm(_Data2, _Size_el_2, _Data1, _Part_size_el, _Op);
+                            const unsigned int _Match_val = _mm_cvtsi128_si32(_Match);
+                            if (_Match_val != 0 && (_Check_unfit(_Match_val) || _Check_fit(_Match_val))) {
+                                return _Mid1;
+                            }
+                        }
+
+                        // The first part, fit and unfit needle, mask out already processed positions
+                        if (const size_t _Tail_bytes_1 = _Size_bytes_1 & 0xF; _Tail_bytes_1 != 0) {
+                            _Mid1                   = _First1;
+                            const __m128i _Data1    = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Mid1));
+                            const auto _Match       = _mm_cmpestrm(_Data2, _Size_el_2, _Data1, _Part_size_el, _Op);
+                            const size_t _Tail_el_1 = _Tail_bytes_1 / sizeof(_Ty);
+                            const unsigned int _Match_val = _mm_cvtsi128_si32(_Match) & ((1 << _Tail_el_1) - 1);
+                            if (_Match_val != 0 && (_Check_unfit(_Match_val) || _Check_fit(_Match_val))) {
+                                return _Mid1;
+                            }
+                        }
+
+                        return _Last1;
+                    } else { // _Size_bytes_2 is greater than 16 bytes
+                        const __m128i _Data2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_First2));
+
+                        const void* _Tail2 = _First2;
+                        _Advance_bytes(_Tail2, 16);
+
+                        const void* _Mid1 = _Last1;
+                        _Rewind_bytes(_Mid1, _Size_bytes_2);
+
+                        const size_t _Size_diff_bytes = _Size_bytes_1 - _Size_bytes_2;
+                        const void* _Stop1            = _First1;
+                        _Advance_bytes(_Stop1, _Size_diff_bytes & 0xF);
+
+#pragma warning(push)
+#pragma warning(disable : 4324) // structure was padded due to alignment specifier
+                        const auto _Check = [=, &_Mid1](unsigned long _Match) noexcept {
+                            while (_Match != 0) {
+                                const void* _Tmp1 = _Mid1;
+                                unsigned long _Match_last_pos;
+
+                                // CodeQL [SM02313] Result is always initialized: we just tested that _Match != 0.
+                                _BitScanReverse(&_Match_last_pos, _Match);
+
+                                bool _Match_1st_16 = true;
+
+                                if (_Match_last_pos != 0) {
+                                    _Advance_bytes(_Tmp1, _Match_last_pos * sizeof(_Ty));
+
+                                    const __m128i _Match_data =
+                                        _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+                                    const __m128i _Cmp_result = _mm_xor_si128(_Data2, _Match_data);
+
+                                    if (!_mm_testz_si128(_Cmp_result, _Cmp_result)) {
+                                        _Match_1st_16 = false;
+                                    }
+                                }
+
+                                if (_Match_1st_16) {
+                                    const void* _Tail1 = _Tmp1;
+                                    _Advance_bytes(_Tail1, 16);
+
+                                    if (memcmp(_Tail1, _Tail2, _Size_bytes_2 - 16) == 0) {
+                                        _Mid1 = _Tmp1;
+                                        return true;
+                                    }
+                                }
+
+                                _Match ^= 1 << _Match_last_pos;
+                            }
+
+                            return false;
+                        };
+#pragma warning(pop)
+                        // The very last part, just compare, as true match must start with first symbol
+                        const __m128i _Data1_last = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Mid1));
+                        const __m128i _Match_last = _mm_xor_si128(_Data2, _Data1_last);
+                        if (_mm_testz_si128(_Match_last, _Match_last)) {
+                            // Matched 16 bytes, check the rest
+                            const void* _Tail1 = _Mid1;
+                            _Advance_bytes(_Tail1, 16);
+
+                            if (memcmp(_Tail1, _Tail2, _Size_bytes_2 - 16) == 0) {
+                                return _Mid1;
+                            }
+                        }
+
+                        // TRANSITION, DevCom-10689455, the code below could test with _mm_cmpestrc,
+                        // if it has been fused with _mm_cmpestrm.
+
+                        // The main part, match all characters
+                        while (_Mid1 != _Stop1) {
+                            _Rewind_bytes(_Mid1, 16);
+
+                            const __m128i _Data1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Mid1));
+                            const auto _Match    = _mm_cmpestrm(_Data2, _Part_size_el, _Data1, _Part_size_el, _Op);
+                            const unsigned int _Match_val = _mm_cvtsi128_si32(_Match);
+                            if (_Match_val != 0 && _Check(_Match_val)) {
+                                return _Mid1;
+                            }
+                        }
+
+                        // The first part, mask out already processed positions
+                        if (const size_t _Tail_bytes_1 = _Size_diff_bytes & 0xF; _Tail_bytes_1 != 0) {
+                            _Mid1                   = _First1;
+                            const __m128i _Data1    = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Mid1));
+                            const auto _Match       = _mm_cmpestrm(_Data2, _Part_size_el, _Data1, _Part_size_el, _Op);
+                            const size_t _Tail_el_1 = _Tail_bytes_1 / sizeof(_Ty);
+                            const unsigned int _Match_val = _mm_cvtsi128_si32(_Match) & ((1 << _Tail_el_1) - 1);
+                            if (_Match_val != 0 && _Check(_Match_val)) {
+                                return _Mid1;
+                            }
+                        }
+
+                        return _Last1;
+                    }
+                }
+            }
+
+            return _Find_end_scalar_tail<_Ty>(_First1, _Last1, _First2, _Count2);
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+    } // namespace _Find_seq
+} // unnamed namespace
+
+extern "C" {
+
+const void* __stdcall __std_search_1(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Find_seq::_Search_impl<_Finding::_Find_traits_1, _Find_seq::_Find_seq_traits_neon_1, uint8_t>(
+        _First1, _Last1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Find_seq::_Search_impl<_Finding::_Find_traits_1, void, void, uint8_t>(_First1, _Last1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+const void* __stdcall __std_search_2(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Find_seq::_Search_impl<_Finding::_Find_traits_2, _Find_seq::_Find_seq_traits_neon_2, uint16_t>(
+        _First1, _Last1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Find_seq::_Search_impl<_Finding::_Find_traits_2, _Find_seq::_Find_seq_traits_avx_2, void, uint16_t>(
+        _First1, _Last1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+const void* __stdcall __std_search_4(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Find_seq::_Search_impl<_Finding::_Find_traits_4, _Find_seq::_Find_seq_traits_neon_4, uint32_t>(
+        _First1, _Last1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Find_seq::_Search_impl<_Finding::_Find_traits_4, _Find_seq::_Find_seq_traits_avx_4,
+        _Find_seq::_Find_seq_traits_sse_4, uint32_t>(_First1, _Last1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+const void* __stdcall __std_search_8(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Find_seq::_Search_impl<_Finding::_Find_traits_8, _Find_seq::_Find_seq_traits_neon_8, uint64_t>(
+        _First1, _Last1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Find_seq::_Search_impl<_Finding::_Find_traits_8, _Find_seq::_Find_seq_traits_avx_8,
+        _Find_seq::_Find_seq_traits_sse_8, uint64_t>(_First1, _Last1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+
+const void* __stdcall __std_find_end_1(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Find_seq::_Find_end_impl<_Finding::_Find_traits_1, _Find_seq::_Find_seq_traits_neon_1, uint8_t>(
+        _First1, _Last1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Find_seq::_Find_end_impl<_Finding::_Find_traits_1, _Find_seq::_Find_seq_traits_avx_1, void, uint8_t>(
+        _First1, _Last1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+const void* __stdcall __std_find_end_2(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Find_seq::_Find_end_impl<_Finding::_Find_traits_2, _Find_seq::_Find_seq_traits_neon_2, uint16_t>(
+        _First1, _Last1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Find_seq::_Find_end_impl<_Finding::_Find_traits_2, _Find_seq::_Find_seq_traits_avx_2, void, uint16_t>(
+        _First1, _Last1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+const void* __stdcall __std_find_end_4(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Find_seq::_Find_end_impl<_Finding::_Find_traits_4, _Find_seq::_Find_seq_traits_neon_4, uint32_t>(
+        _First1, _Last1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Find_seq::_Find_end_impl<_Finding::_Find_traits_4, _Find_seq::_Find_seq_traits_avx_4,
+        _Find_seq::_Find_seq_traits_sse_4, uint32_t>(_First1, _Last1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+const void* __stdcall __std_find_end_8(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const size_t _Count2) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Find_seq::_Find_end_impl<_Finding::_Find_traits_8, _Find_seq::_Find_seq_traits_neon_8, uint64_t>(
+        _First1, _Last1, _First2, _Count2);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Find_seq::_Find_end_impl<_Finding::_Find_traits_8, _Find_seq::_Find_seq_traits_avx_8,
+        _Find_seq::_Find_seq_traits_sse_8, uint64_t>(_First1, _Last1, _First2, _Count2);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Mismatching {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        template <class _Ty>
+        __declspec(noalias) size_t __stdcall _Mismatch_impl(
+            const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+            size_t _Result            = 0;
+            const auto _First1_ch     = static_cast<const uint8_t*>(_First1);
+            const auto _First2_ch     = static_cast<const uint8_t*>(_First2);
+            const size_t _Count_bytes = _Count * sizeof(_Ty);
+
+            const size_t _Count_bytes_32 = _Count_bytes & ~size_t{0x1F};
+            for (; _Result != _Count_bytes_32; _Result += 0x20) {
+                const auto _Elem1_lo = _Finding::_Find_traits_1::_Load_q(_First1_ch + _Result);
+                const auto _Elem2_lo = _Finding::_Find_traits_1::_Load_q(_First2_ch + _Result);
+                const auto _Elem1_hi = _Finding::_Find_traits_1::_Load_q(_First1_ch + _Result + 0x10);
+                const auto _Elem2_hi = _Finding::_Find_traits_1::_Load_q(_First2_ch + _Result + 0x10);
+
+                const auto _Cmp_lo = _Finding::_Find_traits_1::_Cmp_neon_q(_Elem1_lo, _Elem2_lo);
+                const auto _Cmp_hi = _Finding::_Find_traits_1::_Cmp_neon_q(_Elem1_hi, _Elem2_hi);
+
+                const auto _Any_mismatch = _Finding::_Find_traits_1::_Match_mask_ne(_Cmp_lo, _Cmp_hi);
+                if (_Any_mismatch != 0) {
+                    auto _Mask_lo = ~_Finding::_Find_traits_1::_Mask_q(_Cmp_lo);
+                    if (_Mask_lo != 0) {
+                        const auto _Offset = _Finding::_Get_first_h_pos_q(_Mask_lo);
+                        return (_Result + _Offset) / sizeof(_Ty);
+                    }
+
+                    auto _Mask_hi      = ~_Finding::_Find_traits_1::_Mask_q(_Cmp_hi);
+                    const auto _Offset = _Finding::_Get_first_h_pos_q(_Mask_hi) + 0x10;
+                    return (_Result + _Offset) / sizeof(_Ty);
+                }
+            }
+
+            if ((_Count_bytes & size_t{0x10}) != 0) { // use original _Count_bytes; we've read only 32-byte chunks
+                const auto _Elem1 = _Finding::_Find_traits_1::_Load_q(_First1_ch + _Result);
+                const auto _Elem2 = _Finding::_Find_traits_1::_Load_q(_First2_ch + _Result);
+                const auto _Cmp   = _Finding::_Find_traits_1::_Cmp_neon_q(_Elem1, _Elem2);
+
+                const auto _Mask = ~_Finding::_Find_traits_1::_Mask_q(_Cmp);
+                if (_Mask != 0) {
+                    const auto _Offset = _Finding::_Get_first_h_pos_q(_Mask);
+                    return (_Result + _Offset) / sizeof(_Ty);
+                }
+
+                _Result += 0x10;
+            }
+
+            if constexpr (sizeof(_Ty) < 8) {
+                // use original _Count_bytes; we've read only 16/32-byte chunks
+                if ((_Count_bytes & size_t{0x08}) != 0) {
+                    const auto _Elem1 = _Finding::_Find_traits_1::_Load(_First1_ch + _Result);
+                    const auto _Elem2 = _Finding::_Find_traits_1::_Load(_First2_ch + _Result);
+                    const auto _Cmp   = _Finding::_Find_traits_1::_Cmp_neon(_Elem1, _Elem2);
+
+                    const auto _Mask = ~_Finding::_Find_traits_1::_Mask(_Cmp);
+                    if (_Mask != 0) {
+                        const auto _Offset = _Finding::_Get_first_h_pos_d(_Mask);
+                        return (_Result + _Offset) / sizeof(_Ty);
+                    }
+
+                    _Result += 0x08;
+                }
+            }
+
+            _Result /= sizeof(_Ty);
+
+            const auto _First1_el = static_cast<const _Ty*>(_First1);
+            const auto _First2_el = static_cast<const _Ty*>(_First2);
+
+            for (; _Result != _Count; ++_Result) {
+                if (_First1_el[_Result] != _First2_el[_Result]) {
+                    break;
+                }
+            }
+
+            return _Result;
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        template <class _Ty>
+        __declspec(noalias) size_t __stdcall _Mismatch_impl(
+            const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+            size_t _Result = 0;
+
+            const auto _First1_ch = static_cast<const char*>(_First1);
+            const auto _First2_ch = static_cast<const char*>(_First2);
+
+            if (_Use_avx2()) {
+                _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
+
+                const size_t _Count_bytes          = _Count * sizeof(_Ty);
+                const size_t _Count_bytes_avx_full = _Count_bytes & ~size_t{0x1F};
+
+                for (; _Result != _Count_bytes_avx_full; _Result += 0x20) {
+                    const __m256i _Elem1 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First1_ch + _Result));
+                    const __m256i _Elem2 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First2_ch + _Result));
+                    const __m256i _Cmp   = _mm256_cmpeq_epi8(_Elem1, _Elem2);
+                    const auto _Bingo    = ~static_cast<unsigned int>(_mm256_movemask_epi8(_Cmp));
+                    if (_Bingo != 0) {
+                        return (_Result + _tzcnt_u32(_Bingo)) / sizeof(_Ty);
+                    }
+                }
+
+                const size_t _Count_tail = _Count_bytes & size_t{0x1C};
+
+                if (_Count_tail != 0) {
+                    const __m256i _Tail_mask = _Avx2_tail_mask_32(_Count_tail);
+                    const __m256i _Elem1 =
+                        _mm256_maskload_epi32(reinterpret_cast<const int*>(_First1_ch + _Result), _Tail_mask);
+                    const __m256i _Elem2 =
+                        _mm256_maskload_epi32(reinterpret_cast<const int*>(_First2_ch + _Result), _Tail_mask);
+
+                    const __m256i _Cmp = _mm256_cmpeq_epi8(_Elem1, _Elem2);
+                    const auto _Bingo  = ~static_cast<unsigned int>(_mm256_movemask_epi8(_Cmp));
+                    if (_Bingo != 0) {
+                        return (_Result + _tzcnt_u32(_Bingo)) / sizeof(_Ty);
+                    }
+
+                    _Result += _Count_tail;
+                }
+
+                _Result /= sizeof(_Ty);
+
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return _Result;
+                }
+            } else if (_Use_sse42()) {
+                const size_t _Count_bytes_sse = (_Count * sizeof(_Ty)) & ~size_t{0xF};
+
+                for (; _Result != _Count_bytes_sse; _Result += 0x10) {
+                    const __m128i _Elem1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_First1_ch + _Result));
+                    const __m128i _Elem2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_First2_ch + _Result));
+                    const __m128i _Cmp   = _mm_cmpeq_epi8(_Elem1, _Elem2);
+                    const auto _Bingo    = static_cast<unsigned int>(_mm_movemask_epi8(_Cmp)) ^ 0xFFFF;
+                    if (_Bingo != 0) {
+                        unsigned long _Offset;
+                        // CodeQL [SM02313] _Offset is always initialized: we just tested `if (_Bingo != 0)`.
+                        _BitScanForward(&_Offset, _Bingo);
+                        return (_Result + _Offset) / sizeof(_Ty);
+                    }
+                }
+
+                _Result /= sizeof(_Ty);
+            }
+
+            const auto _First1_el = static_cast<const _Ty*>(_First1);
+            const auto _First2_el = static_cast<const _Ty*>(_First2);
+
+            for (; _Result != _Count; ++_Result) {
+                if (_First1_el[_Result] != _First2_el[_Result]) {
+                    break;
+                }
+            }
+
+            return _Result;
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+    } // namespace _Mismatching
+} // unnamed namespace
+
+extern "C" {
+
+__declspec(noalias) size_t __stdcall __std_mismatch_1(
+    const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    return _Mismatching::_Mismatch_impl<uint8_t>(_First1, _First2, _Count);
+}
+
+__declspec(noalias) size_t __stdcall __std_mismatch_2(
+    const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    return _Mismatching::_Mismatch_impl<uint16_t>(_First1, _First2, _Count);
+}
+
+__declspec(noalias) size_t __stdcall __std_mismatch_4(
+    const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    return _Mismatching::_Mismatch_impl<uint32_t>(_First1, _First2, _Count);
+}
+
+__declspec(noalias) size_t __stdcall __std_mismatch_8(
+    const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    return _Mismatching::_Mismatch_impl<uint64_t>(_First1, _First2, _Count);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Replacing {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        template <class _Traits, class _Ty>
+        __declspec(noalias) void __stdcall _Replace_copy_impl(
+            const void* _First, const void* const _Last, void* _Dest, const _Ty _Old_val, const _Ty _New_val) noexcept {
+            const size_t _Size_bytes = _Byte_length(_First, _Last);
+
+            if (const size_t _Size = _Size_bytes & ~size_t{0x1F}; _Size != 0) {
+                const auto _Comparand   = _Traits::_Set_neon_q(_Old_val);
+                const auto _Replacement = _Traits::_Set_neon_q(_New_val);
+                const void* _Stop_at    = _First;
+                _Advance_bytes(_Stop_at, _Size);
+
+                do {
+                    const auto _Data_lo = _Traits::_Load_q(static_cast<const uint8_t*>(_First) + 0);
+                    const auto _Data_hi = _Traits::_Load_q(static_cast<const uint8_t*>(_First) + 16);
+
+                    const auto _Mask_lo = _Traits::_Cmp_neon_q(_Data_lo, _Comparand);
+                    const auto _Mask_hi = _Traits::_Cmp_neon_q(_Data_hi, _Comparand);
+
+                    const auto _Val_lo = _Traits::_Blend_q(_Data_lo, _Replacement, _Mask_lo);
+                    const auto _Val_hi = _Traits::_Blend_q(_Data_hi, _Replacement, _Mask_hi);
+
+                    _Traits::_Store_q(static_cast<uint8_t*>(_Dest) + 0, _Val_lo);
+                    _Traits::_Store_q(static_cast<uint8_t*>(_Dest) + 16, _Val_hi);
+
+                    _Advance_bytes(_First, 32);
+                    _Advance_bytes(_Dest, 32);
+                } while (_First != _Stop_at);
+            }
+
+            if ((_Size_bytes & size_t{0x10}) != 0) { // use original _Size_bytes; we've read only 32-byte chunks
+                const auto _Comparand   = _Traits::_Set_neon_q(_Old_val);
+                const auto _Replacement = _Traits::_Set_neon_q(_New_val);
+
+                const auto _Data = _Traits::_Load_q(_First);
+                const auto _Mask = _Traits::_Cmp_neon_q(_Data, _Comparand);
+                const auto _Val  = _Traits::_Blend_q(_Data, _Replacement, _Mask);
+
+                _Traits::_Store_q(_Dest, _Val);
+
+                _Advance_bytes(_First, 16);
+                _Advance_bytes(_Dest, 16);
+            }
+
+            if constexpr (sizeof(_Ty) < 8) {
+                if ((_Size_bytes & size_t{0x08}) != 0) { // use original _Size_bytes; we've read only 16/32-byte chunks
+                    const auto _Comparand   = _Traits::_Set_neon(_Old_val);
+                    const auto _Replacement = _Traits::_Set_neon(_New_val);
+
+                    const auto _Data = _Traits::_Load(_First);
+                    const auto _Mask = _Traits::_Cmp_neon(_Data, _Comparand);
+                    const auto _Val  = _Traits::_Blend(_Data, _Replacement, _Mask);
+
+                    _Traits::_Store(_Dest, _Val);
+
+                    _Advance_bytes(_First, 8);
+                    _Advance_bytes(_Dest, 8);
+                }
+            }
+
+            auto _Ptr_dest = static_cast<_Ty*>(_Dest);
+// Avoid auto-vectorization of the scalar tail, as this is not beneficial for performance.
+#pragma loop(no_vector)
+            for (auto _Ptr_src = static_cast<const _Ty*>(_First); _Ptr_src != _Last; ++_Ptr_src) {
+                const _Ty _Val = *_Ptr_src;
+                *_Ptr_dest     = _Val == _Old_val ? _New_val : _Val;
+                ++_Ptr_dest;
+            }
+        }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        template <class _Traits, class _Ty>
+        __declspec(noalias) void __stdcall _Replace_copy_impl(
+            const void* _First, const void* const _Last, void* _Dest, const _Ty _Old_val, const _Ty _New_val) noexcept {
+            const size_t _Size_bytes = _Byte_length(_First, _Last);
+
+            if (const size_t _Avx_size = _Size_bytes & ~size_t{0x1F}; _Avx_size != 0 && _Use_avx2()) {
+                const __m256i _Comparand   = _Traits::_Set_avx(_Old_val);
+                const __m256i _Replacement = _Traits::_Set_avx(_New_val);
+                const void* _Stop_at       = _First;
+                _Advance_bytes(_Stop_at, _Avx_size);
+
+                do {
+                    const __m256i _Data = _mm256_loadu_si256(static_cast<const __m256i*>(_First));
+                    const __m256i _Mask = _Traits::_Cmp_avx(_Data, _Comparand);
+                    const __m256i _Val  = _mm256_blendv_epi8(_Data, _Replacement, _Mask);
+
+                    _mm256_storeu_si256(static_cast<__m256i*>(_Dest), _Val);
+
+                    _Advance_bytes(_First, 32);
+                    _Advance_bytes(_Dest, 32);
+                } while (_First != _Stop_at);
+
+                if (const size_t _Avx_tail_size = _Size_bytes & 0x1C; _Avx_tail_size != 0) {
+                    const __m256i _Tail_mask = _Avx2_tail_mask_32(_Avx_tail_size);
+                    const __m256i _Data      = _mm256_maskload_epi32(static_cast<const int*>(_First), _Tail_mask);
+                    const __m256i _Mask      = _Traits::_Cmp_avx(_Data, _Comparand);
+                    const __m256i _Val       = _mm256_blendv_epi8(_Data, _Replacement, _Mask);
+
+                    _mm256_maskstore_epi32(static_cast<int*>(_Dest), _Tail_mask, _Val);
+
+                    _Advance_bytes(_First, _Avx_tail_size);
+                    _Advance_bytes(_Dest, _Avx_tail_size);
+                }
+
+                _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+
+                if constexpr (sizeof(_Ty) >= 4) {
+                    return;
+                }
+            } else if (const size_t _Sse_size = _Size_bytes & ~size_t{0xF}; _Sse_size != 0 && _Use_sse42()) {
+                const __m128i _Comparand   = _Traits::_Set_sse(_Old_val);
+                const __m128i _Replacement = _Traits::_Set_sse(_New_val);
+                const void* _Stop_at       = _First;
+                _Advance_bytes(_Stop_at, _Sse_size);
+
+                do {
+                    const __m128i _Data = _mm_loadu_si128(static_cast<const __m128i*>(_First));
+                    const __m128i _Mask = _Traits::_Cmp_sse(_Data, _Comparand);
+                    const __m128i _Val  = _mm_blendv_epi8(_Data, _Replacement, _Mask);
+
+                    _mm_storeu_si128(static_cast<__m128i*>(_Dest), _Val);
+
+                    _Advance_bytes(_First, 16);
+                    _Advance_bytes(_Dest, 16);
+                } while (_First != _Stop_at);
+            }
+            auto _Ptr_dest = static_cast<_Ty*>(_Dest);
+            for (auto _Ptr_src = static_cast<const _Ty*>(_First); _Ptr_src != _Last; ++_Ptr_src) {
+                const _Ty _Val = *_Ptr_src;
+                *_Ptr_dest     = _Val == _Old_val ? _New_val : _Val;
+                ++_Ptr_dest;
+            }
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+    } // namespace _Replacing
+} // unnamed namespace
+
+extern "C" {
+
+#ifndef _M_ARM64
+__declspec(noalias) void __stdcall __std_replace_4(
+    void* _First, void* const _Last, const uint32_t _Old_val, const uint32_t _New_val) noexcept {
+#ifndef _M_ARM64EC
+    if (_Use_avx2()) {
+        const __m256i _Comparand   = _mm256_broadcastd_epi32(_mm_cvtsi32_si128(_Old_val));
+        const __m256i _Replacement = _mm256_broadcastd_epi32(_mm_cvtsi32_si128(_New_val));
+        const size_t _Full_length  = _Byte_length(_First, _Last);
+
+        void* _Stop_at = _First;
+        _Advance_bytes(_Stop_at, _Full_length & ~size_t{0x1F});
+
+        while (_First != _Stop_at) {
+            const __m256i _Data = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First));
+            const __m256i _Mask = _mm256_cmpeq_epi32(_Comparand, _Data);
+            _mm256_maskstore_epi32(reinterpret_cast<int*>(_First), _Mask, _Replacement);
+
+            _Advance_bytes(_First, 32);
+        }
+
+        if (const size_t _Tail_length = _Full_length & 0x1C; _Tail_length != 0) {
+            const __m256i _Tail_mask = _Avx2_tail_mask_32(_Tail_length);
+            const __m256i _Data      = _mm256_maskload_epi32(reinterpret_cast<const int*>(_First), _Tail_mask);
+            const __m256i _Mask      = _mm256_and_si256(_mm256_cmpeq_epi32(_Comparand, _Data), _Tail_mask);
+            _mm256_maskstore_epi32(reinterpret_cast<int*>(_First), _Mask, _Replacement);
+        }
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else
+#endif // ^^^ !defined(_M_ARM64EC) ^^^
+    {
+        for (auto _Cur = reinterpret_cast<uint32_t*>(_First); _Cur != _Last; ++_Cur) {
+            if (*_Cur == _Old_val) {
+                *_Cur = _New_val;
+            }
+        }
+    }
+}
+
+__declspec(noalias) void __stdcall __std_replace_8(
+    void* _First, void* const _Last, const uint64_t _Old_val, const uint64_t _New_val) noexcept {
+#ifndef _M_ARM64EC
+    if (_Use_avx2()) {
+#ifdef _WIN64
+        const __m256i _Comparand   = _mm256_broadcastq_epi64(_mm_cvtsi64_si128(_Old_val));
+        const __m256i _Replacement = _mm256_broadcastq_epi64(_mm_cvtsi64_si128(_New_val));
+#else // ^^^ 64-bit / 32-bit, workaround, _mm_cvtsi64_si128 does not compile vvv
+        const __m256i _Comparand   = _mm256_set1_epi64x(_Old_val);
+        const __m256i _Replacement = _mm256_set1_epi64x(_New_val);
+#endif // ^^^ 32-bit ^^^
+        const size_t _Full_length = _Byte_length(_First, _Last);
+
+        void* _Stop_at = _First;
+        _Advance_bytes(_Stop_at, _Full_length & ~size_t{0x1F});
+
+        while (_First != _Stop_at) {
+            const __m256i _Data = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First));
+            const __m256i _Mask = _mm256_cmpeq_epi64(_Comparand, _Data);
+            _mm256_maskstore_epi64(reinterpret_cast<long long*>(_First), _Mask, _Replacement);
+
+            _Advance_bytes(_First, 32);
+        }
+
+        if (const size_t _Tail_length = _Full_length & 0x18; _Tail_length != 0) {
+            const __m256i _Tail_mask = _Avx2_tail_mask_32(_Tail_length);
+            const __m256i _Data      = _mm256_maskload_epi64(reinterpret_cast<const long long*>(_First), _Tail_mask);
+            const __m256i _Mask      = _mm256_and_si256(_mm256_cmpeq_epi64(_Comparand, _Data), _Tail_mask);
+            _mm256_maskstore_epi64(reinterpret_cast<long long*>(_First), _Mask, _Replacement);
+        }
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else
+#endif // ^^^ !defined(_M_ARM64EC) ^^^
+    {
+        for (auto _Cur = reinterpret_cast<uint64_t*>(_First); _Cur != _Last; ++_Cur) {
+            if (*_Cur == _Old_val) {
+                *_Cur = _New_val;
+            }
+        }
+    }
+}
+#endif // ^^^ !defined(_M_ARM64) ^^^
+
+__declspec(noalias) void __stdcall __std_replace_copy_1(const void* const _First, const void* const _Last,
+    void* const _Dest, const uint8_t _Old_val, const uint8_t _New_val) noexcept {
+    _Replacing::_Replace_copy_impl<_Finding::_Find_traits_1>(_First, _Last, _Dest, _Old_val, _New_val);
+}
+
+__declspec(noalias) void __stdcall __std_replace_copy_2(const void* const _First, const void* const _Last,
+    void* const _Dest, const uint16_t _Old_val, const uint16_t _New_val) noexcept {
+    _Replacing::_Replace_copy_impl<_Finding::_Find_traits_2>(_First, _Last, _Dest, _Old_val, _New_val);
+}
+
+__declspec(noalias) void __stdcall __std_replace_copy_4(const void* const _First, const void* const _Last,
+    void* const _Dest, const uint32_t _Old_val, const uint32_t _New_val) noexcept {
+    _Replacing::_Replace_copy_impl<_Finding::_Find_traits_4>(_First, _Last, _Dest, _Old_val, _New_val);
+}
+
+__declspec(noalias) void __stdcall __std_replace_copy_8(const void* const _First, const void* const _Last,
+    void* const _Dest, const uint64_t _Old_val, const uint64_t _New_val) noexcept {
+    _Replacing::_Replace_copy_impl<_Finding::_Find_traits_8>(_First, _Last, _Dest, _Old_val, _New_val);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Removing {
+        // 'remove' and 'unique': form bit mask based on matches, then do _mm_shuffle_epi8/_mm256_permutevar8x32_epi32
+        // to the destination with removed matches; the shuffle pattern is taken from a lookup table using the bit mask.
+        // After writing to dest, shift the dest pointer by the mismatch count.
+        // There will be redundant elements written, and they will be subsequently overwritten by overlapped writes.
+        //
+        // 'unique': the bit mask is formed by comparing against shifted self. 'adjacent_find' must precede this
+        // to avoid a load overlapping a just stored vector (store buffer stall).
+        //
+        // Non '_copy' flavors: store directly, the data past the returned iterator must be ignored anyway.
+        // '_copy' flavors: can't write more than expected, use intermediate buffer and then copy to dest.
+
+        template <class _Ty>
+        void* _Remove_fallback(
+            const void* const _First, const void* const _Last, void* const _Out, const _Ty _Val) noexcept {
+            const _Ty* _Src = reinterpret_cast<const _Ty*>(_First);
+            _Ty* _Dest      = reinterpret_cast<_Ty*>(_Out);
+
+            while (_Src != _Last) {
+                if (*_Src != _Val) {
+                    *_Dest = *_Src;
+                    ++_Dest;
+                }
+
+                ++_Src;
+            }
+
+            return _Dest;
+        }
+
+        template <class _Ty>
+        void* _Unique_fallback(const void* const _First, const void* const _Last, void* const _Dest) noexcept {
+            _Ty* _Out       = reinterpret_cast<_Ty*>(_Dest);
+            const _Ty* _Src = reinterpret_cast<const _Ty*>(_First);
+
+            while (_Src != _Last) {
+                if (*_Src != *_Out) {
+                    ++_Out;
+                    *_Out = *_Src;
+                }
+
+                ++_Src;
+            }
+
+            ++_Out;
+            return _Out;
+        }
+
+        template <size_t _Size_v, size_t _Size_h>
+        struct _Tables {
+            uint8_t _Shuf[_Size_v][_Size_h];
+            uint8_t _Size[_Size_v];
+        };
+
+        template <size_t _Size_v, size_t _Size_h>
+        constexpr auto _Make_tables(const uint32_t _Mul, const uint32_t _Ew) {
+            _Tables<_Size_v, _Size_h> _Result;
+
+            for (uint32_t _Vx = 0; _Vx != _Size_v; ++_Vx) {
+                uint32_t _Nx = 0;
+
+                // Make shuffle mask for pshufb / vpermd corresponding to _Vx bit value.
+                // Every bit set corresponds to an element skipped.
+                for (uint32_t _Hx = 0; _Hx != _Size_h / _Ew; ++_Hx) {
+                    if ((_Vx & (1 << _Hx)) == 0) {
+                        // Inner loop needed for cases where the shuffle mask operates on element parts rather than
+                        // whole elements; for whole elements there would be one iteration.
+                        for (uint32_t _Ex = 0; _Ex != _Ew; ++_Ex) {
+                            _Result._Shuf[_Vx][_Nx * _Ew + _Ex] = static_cast<uint8_t>(_Hx * _Ew + _Ex);
+                        }
+                        ++_Nx;
+                    }
+                }
+
+                // Size of elements that are not removed in bytes.
+                _Result._Size[_Vx] = static_cast<uint8_t>(_Nx * _Mul);
+
+                // Fill the remaining with arbitrary elements.
+                // It is not possible to leave them untouched while keeping this optimization efficient.
+                // This should not be a problem though, as they should be either overwritten by the next step,
+                // or left in the removed range.
+                for (; _Nx != _Size_h / _Ew; ++_Nx) {
+                    // Inner loop needed for cases where the shuffle mask operates on element parts rather than whole
+                    // elements; for whole elements there would be one iteration.
+                    for (uint32_t _Ex = 0; _Ex != _Ew; ++_Ex) {
+                        _Result._Shuf[_Vx][_Nx * _Ew + _Ex] = static_cast<uint8_t>(_Nx * _Ew + _Ex);
+                    }
+                }
+            }
+
+            return _Result;
+        }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        constexpr auto _Tables_1_neon = _Make_tables<256, 8>(1, 1);
+        constexpr auto _Tables_2_neon = _Make_tables<256, 16>(2, 2);
+        constexpr auto _Tables_4_neon = _Make_tables<16, 16>(4, 4);
+
+        struct _Neon_1 {
+            static constexpr size_t _Elem_size = 1;
+            static constexpr size_t _Step      = 8;
+            using _Vec_t                       = uint8x8_t;
+
+            static _Vec_t _Set(const uint8_t _Val) noexcept {
+                return vdup_n_u8(_Val);
+            }
+
+            static _Vec_t _Load(const void* const _Ptr) noexcept {
+                return vld1_u8(static_cast<const uint8_t*>(_Ptr));
+            }
+
+            static uint32_t _Mask(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                const auto _Cmp = vceq_u8(_First, _Second);
+                uint64_t _Val   = vget_lane_u64(vreinterpret_u64_u8(_Cmp), 0);
+                _Val &= 0x8080808080808080ull;
+                _Val *= 0x02040810204081ull;
+                return static_cast<uint32_t>(_Val >> 56);
+            }
+
+            static void* _Store_masked(void* _Out, const _Vec_t _Src, const uint32_t _Bingo) noexcept {
+                const auto _Shuf = vld1_u8(_Tables_1_neon._Shuf[_Bingo]);
+                const auto _Dest = vtbl1_u8(_Src, _Shuf);
+                vst1_u8(static_cast<uint8_t*>(_Out), _Dest);
+                _Advance_bytes(_Out, _Tables_1_neon._Size[_Bingo]);
+                return _Out;
+            }
+        };
+
+        struct _Neon_2 {
+            static constexpr size_t _Elem_size = 2;
+            static constexpr size_t _Step      = 16;
+            using _Vec_t                       = uint16x8_t;
+
+            static _Vec_t _Set(const uint16_t _Val) noexcept {
+                return vdupq_n_u16(_Val);
+            }
+
+            static _Vec_t _Load(const void* const _Ptr) noexcept {
+                return vld1q_u16(static_cast<const uint16_t*>(_Ptr));
+            }
+
+            static uint32_t _Mask(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                // TRANSITION, DevCom-11055227
+                constexpr uint16_t _Weights_arr[8] = {1, 2, 4, 8, 16, 32, 64, 128};
+                const auto _Weights                = vld1q_u16(_Weights_arr);
+
+                const auto _Cmp  = vceqq_u16(_First, _Second);
+                const auto _Bits = vandq_u16(_Cmp, _Weights);
+                return vaddvq_u16(_Bits);
+            }
+
+            static void* _Store_masked(void* _Out, const _Vec_t _Src, const uint32_t _Bingo) noexcept {
+                const auto _Shuf = vld1q_u8(_Tables_2_neon._Shuf[_Bingo]);
+                const auto _Dest = vreinterpretq_u16_u8(vqtbl1q_u8(vreinterpretq_u8_u16(_Src), _Shuf));
+                vst1q_u16(static_cast<uint16_t*>(_Out), _Dest);
+                _Advance_bytes(_Out, _Tables_2_neon._Size[_Bingo]);
+                return _Out;
+            }
+        };
+
+        struct _Neon_4 {
+            static constexpr size_t _Elem_size = 4;
+            static constexpr size_t _Step      = 16;
+            using _Vec_t                       = uint32x4_t;
+
+            static _Vec_t _Set(const uint32_t _Val) noexcept {
+                return vdupq_n_u32(_Val);
+            }
+
+            static _Vec_t _Load(const void* const _Ptr) noexcept {
+                return vld1q_u32(static_cast<const uint32_t*>(_Ptr));
+            }
+
+            static uint32_t _Mask(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                // TRANSITION, DevCom-11055227
+                constexpr uint32_t _Weights_arr[4] = {1, 2, 4, 8};
+                const auto _Weights                = vld1q_u32(_Weights_arr);
+
+                const auto _Cmp  = vceqq_u32(_First, _Second);
+                const auto _Bits = vandq_u32(_Cmp, _Weights);
+                return vaddvq_u32(_Bits);
+            }
+
+            static void* _Store_masked(void* _Out, const _Vec_t _Src, const uint32_t _Bingo) noexcept {
+                const auto _Shuf = vld1q_u8(_Tables_4_neon._Shuf[_Bingo]);
+                const auto _Dest = vreinterpretq_u32_u8(vqtbl1q_u8(vreinterpretq_u8_u32(_Src), _Shuf));
+                vst1q_u32(static_cast<uint32_t*>(_Out), _Dest);
+                _Advance_bytes(_Out, _Tables_4_neon._Size[_Bingo]);
+                return _Out;
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        constexpr auto _Tables_1_sse = _Make_tables<256, 8>(1, 1);
+        constexpr auto _Tables_2_sse = _Make_tables<256, 16>(2, 2);
+        constexpr auto _Tables_4_sse = _Make_tables<16, 16>(4, 4);
+        constexpr auto _Tables_4_avx = _Make_tables<256, 8>(4, 1);
+        constexpr auto _Tables_8_sse = _Make_tables<4, 16>(8, 8);
+        constexpr auto _Tables_8_avx = _Make_tables<16, 8>(8, 2);
+
+        struct _Sse_1 {
+            static constexpr size_t _Elem_size = 1;
+            static constexpr size_t _Step      = 8;
+
+            static __m128i _Set(const uint8_t _Val) noexcept {
+                return _mm_shuffle_epi8(_mm_cvtsi32_si128(_Val), _mm_setzero_si128());
+            }
+
+            static __m128i _Load(const void* const _Ptr) noexcept {
+                return _mm_loadu_si64(_Ptr);
+            }
+
+            static uint32_t _Mask(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_movemask_epi8(_mm_cmpeq_epi8(_First, _Second)) & 0xFF;
+            }
+
+            static void* _Store_masked(void* _Out, const __m128i _Src, const uint32_t _Bingo) noexcept {
+                const __m128i _Shuf = _mm_loadu_si64(_Tables_1_sse._Shuf[_Bingo]);
+                const __m128i _Dest = _mm_shuffle_epi8(_Src, _Shuf);
+                _mm_storeu_si64(_Out, _Dest);
+                _Advance_bytes(_Out, _Tables_1_sse._Size[_Bingo]);
+                return _Out;
+            }
+        };
+
+        struct _Sse_2 {
+            static constexpr size_t _Elem_size = 2;
+            static constexpr size_t _Step      = 16;
+
+            static __m128i _Set(const uint16_t _Val) noexcept {
+                return _mm_set1_epi16(_Val);
+            }
+
+            static __m128i _Load(const void* const _Ptr) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Ptr));
+            }
+
+            static uint32_t _Mask(const __m128i _First, const __m128i _Second) noexcept {
+                const __m128i _Mask = _mm_cmpeq_epi16(_First, _Second);
+                return _mm_movemask_epi8(_mm_packs_epi16(_Mask, _mm_setzero_si128()));
+            }
+
+            static void* _Store_masked(void* _Out, const __m128i _Src, const uint32_t _Bingo) noexcept {
+                const __m128i _Shuf = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Tables_2_sse._Shuf[_Bingo]));
+                const __m128i _Dest = _mm_shuffle_epi8(_Src, _Shuf);
+                _mm_storeu_si128(reinterpret_cast<__m128i*>(_Out), _Dest);
+                _Advance_bytes(_Out, _Tables_2_sse._Size[_Bingo]);
+                return _Out;
+            }
+        };
+
+        struct _Avx_4 {
+            static constexpr size_t _Elem_size = 4;
+            static constexpr size_t _Step      = 32;
+
+            static __m256i _Set(const uint32_t _Val) noexcept {
+                return _mm256_set1_epi32(_Val);
+            }
+
+            static __m256i _Load(const void* const _Ptr) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Ptr));
+            }
+
+            static uint32_t _Mask(const __m256i _First, const __m256i _Second) noexcept {
+                const __m256i _Mask = _mm256_cmpeq_epi32(_First, _Second);
+                return _mm256_movemask_ps(_mm256_castsi256_ps(_Mask));
+            }
+
+            static void* _Store_masked(void* _Out, const __m256i _Src, const uint32_t _Bingo) noexcept {
+                const __m256i _Shuf = _mm256_cvtepu8_epi32(_mm_loadu_si64(_Tables_4_avx._Shuf[_Bingo]));
+                const __m256i _Dest = _mm256_permutevar8x32_epi32(_Src, _Shuf);
+                _mm256_storeu_si256(reinterpret_cast<__m256i*>(_Out), _Dest);
+                _Advance_bytes(_Out, _Tables_4_avx._Size[_Bingo]);
+                return _Out;
+            }
+        };
+
+        struct _Sse_4 {
+            static constexpr size_t _Elem_size = 4;
+            static constexpr size_t _Step      = 16;
+
+            static __m128i _Set(const uint32_t _Val) noexcept {
+                return _mm_set1_epi32(_Val);
+            }
+
+            static __m128i _Load(const void* const _Ptr) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Ptr));
+            }
+
+            static uint32_t _Mask(const __m128i _First, const __m128i _Second) noexcept {
+                const __m128i _Mask = _mm_cmpeq_epi32(_First, _Second);
+                return _mm_movemask_ps(_mm_castsi128_ps(_Mask));
+            }
+
+            static void* _Store_masked(void* _Out, const __m128i _Src, const uint32_t _Bingo) noexcept {
+                const __m128i _Shuf = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Tables_4_sse._Shuf[_Bingo]));
+                const __m128i _Dest = _mm_shuffle_epi8(_Src, _Shuf);
+                _mm_storeu_si128(reinterpret_cast<__m128i*>(_Out), _Dest);
+                _Advance_bytes(_Out, _Tables_4_sse._Size[_Bingo]);
+                return _Out;
+            }
+        };
+
+        struct _Avx_8 {
+            static constexpr size_t _Elem_size = 8;
+            static constexpr size_t _Step      = 32;
+
+            static __m256i _Set(const uint64_t _Val) noexcept {
+                return _mm256_set1_epi64x(_Val);
+            }
+
+            static __m256i _Load(const void* const _Ptr) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Ptr));
+            }
+
+            static uint32_t _Mask(const __m256i _First, const __m256i _Second) noexcept {
+                const __m256i _Mask = _mm256_cmpeq_epi64(_First, _Second);
+                return _mm256_movemask_pd(_mm256_castsi256_pd(_Mask));
+            }
+
+            static void* _Store_masked(void* _Out, const __m256i _Src, const uint32_t _Bingo) noexcept {
+                const __m256i _Shuf = _mm256_cvtepu8_epi32(_mm_loadu_si64(_Tables_8_avx._Shuf[_Bingo]));
+                const __m256i _Dest = _mm256_permutevar8x32_epi32(_Src, _Shuf);
+                _mm256_storeu_si256(reinterpret_cast<__m256i*>(_Out), _Dest);
+                _Advance_bytes(_Out, _Tables_8_avx._Size[_Bingo]);
+                return _Out;
+            }
+        };
+
+        struct _Sse_8 {
+            static constexpr size_t _Elem_size = 8;
+            static constexpr size_t _Step      = 16;
+
+            static __m128i _Set(const uint64_t _Val) noexcept {
+                return _mm_set1_epi64x(_Val);
+            }
+
+            static __m128i _Load(const void* const _Ptr) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Ptr));
+            }
+
+            static uint32_t _Mask(const __m128i _First, const __m128i _Second) noexcept {
+                const __m128i _Mask = _mm_cmpeq_epi64(_First, _Second);
+                return _mm_movemask_pd(_mm_castsi128_pd(_Mask));
+            }
+
+            static void* _Store_masked(void* _Out, const __m128i _Src, const uint32_t _Bingo) noexcept {
+                const __m128i _Shuf = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Tables_8_sse._Shuf[_Bingo]));
+                const __m128i _Dest = _mm_shuffle_epi8(_Src, _Shuf);
+                _mm_storeu_si128(reinterpret_cast<__m128i*>(_Out), _Dest);
+                _Advance_bytes(_Out, _Tables_8_sse._Size[_Bingo]);
+                return _Out;
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        constexpr size_t _Copy_buffer_size = 512;
+
+        template <class _Traits, class _Ty>
+        void* _Remove_impl(void* _First, void* const _Stop, const _Ty _Val) noexcept {
+            void* _Out        = _First;
+            const auto _Match = _Traits::_Set(_Val);
+
+            do {
+                const auto _Src       = _Traits::_Load(_First);
+                const uint32_t _Bingo = _Traits::_Mask(_Src, _Match);
+                _Out                  = _Traits::_Store_masked(_Out, _Src, _Bingo);
+                _Advance_bytes(_First, _Traits::_Step);
+            } while (_First != _Stop);
+
+            return _Out;
+        }
+
+        template <class _Traits, class _Ty>
+        void* _Remove_copy_impl(const void* _First, const void* const _Stop, void* _Out, const _Ty _Val) noexcept {
+            unsigned char _Buffer[_Copy_buffer_size];
+            void* _Buffer_out        = _Buffer;
+            void* const _Buffer_stop = _Buffer + _Copy_buffer_size - _Traits::_Step;
+
+            const auto _Match = _Traits::_Set(_Val);
+
+            do {
+                const auto _Src       = _Traits::_Load(_First);
+                const uint32_t _Bingo = _Traits::_Mask(_Src, _Match);
+                _Buffer_out           = _Traits::_Store_masked(_Buffer_out, _Src, _Bingo);
+                _Advance_bytes(_First, _Traits::_Step);
+
+                if (_Buffer_out >= _Buffer_stop) {
+                    const size_t _Fill = _Byte_length(_Buffer, _Buffer_out);
+                    memcpy(_Out, _Buffer, _Fill);
+                    _Advance_bytes(_Out, _Fill);
+                    _Buffer_out = _Buffer;
+                }
+            } while (_First != _Stop);
+
+            const size_t _Fill = _Byte_length(_Buffer, _Buffer_out);
+            memcpy(_Out, _Buffer, _Fill);
+            _Advance_bytes(_Out, _Fill);
+            return _Out;
+        }
+
+        template <class _Traits>
+        void* _Unique_impl(void* _First, void* const _Stop) noexcept {
+            void* _Out = _First;
+
+            do {
+                const auto _Src = _Traits::_Load(_First);
+                void* _First_d  = _First;
+                _Rewind_bytes(_First_d, _Traits::_Elem_size);
+                const auto _Match     = _Traits::_Load(_First_d);
+                const uint32_t _Bingo = _Traits::_Mask(_Src, _Match);
+                _Out                  = _Traits::_Store_masked(_Out, _Src, _Bingo);
+                _Advance_bytes(_First, _Traits::_Step);
+            } while (_First != _Stop);
+
+            _Rewind_bytes(_Out, _Traits::_Elem_size);
+            return _Out;
+        }
+
+        template <class _Traits>
+        void* _Unique_copy_impl(const void* _First, const void* const _Stop, void* _Out) noexcept {
+            unsigned char _Buffer[_Copy_buffer_size];
+            void* _Buffer_out        = _Buffer;
+            void* const _Buffer_stop = _Buffer + _Copy_buffer_size - _Traits::_Step;
+
+            do {
+                const auto _Src      = _Traits::_Load(_First);
+                const void* _First_d = _First;
+                _Rewind_bytes(_First_d, _Traits::_Elem_size);
+                const auto _Match     = _Traits::_Load(_First_d);
+                const uint32_t _Bingo = _Traits::_Mask(_Src, _Match);
+                _Buffer_out           = _Traits::_Store_masked(_Buffer_out, _Src, _Bingo);
+                _Advance_bytes(_First, _Traits::_Step);
+
+                if (_Buffer_out >= _Buffer_stop) {
+                    const size_t _Fill = _Byte_length(_Buffer, _Buffer_out);
+                    memcpy(static_cast<unsigned char*>(_Out) + _Traits::_Elem_size, _Buffer, _Fill);
+                    _Advance_bytes(_Out, _Fill);
+                    _Buffer_out = _Buffer;
+                }
+            } while (_First != _Stop);
+
+            const size_t _Fill = _Byte_length(_Buffer, _Buffer_out);
+            memcpy(static_cast<unsigned char*>(_Out) + _Traits::_Elem_size, _Buffer, _Fill);
+            _Advance_bytes(_Out, _Fill);
+            return _Out;
+        }
+    } // namespace _Removing
+} // unnamed namespace
+
+extern "C" {
+
+void* __stdcall __std_remove_1(void* _First, void* const _Last, const uint8_t _Val) noexcept {
+    void* _Out = _First;
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 8) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{7});
+        _Out   = _Removing::_Remove_impl<_Removing::_Neon_1>(_First, _Stop, _Val);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_sse42() && _Size_bytes >= 8) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{7});
+        _Out   = _Removing::_Remove_impl<_Removing::_Sse_1>(_First, _Stop, _Val);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Remove_fallback(_First, _Last, _Out, _Val);
+}
+
+void* __stdcall __std_remove_2(void* _First, void* const _Last, const uint16_t _Val) noexcept {
+    void* _Out = _First;
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_impl<_Removing::_Neon_2>(_First, _Stop, _Val);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_sse42() && _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_impl<_Removing::_Sse_2>(_First, _Stop, _Val);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Remove_fallback(_First, _Last, _Out, _Val);
+}
+
+void* __stdcall __std_remove_4(void* _First, void* const _Last, const uint32_t _Val) noexcept {
+    void* _Out = _First;
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_impl<_Removing::_Neon_4>(_First, _Stop, _Val);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_avx2() && _Size_bytes >= 32) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0x1F});
+        _Out   = _Removing::_Remove_impl<_Removing::_Avx_4>(_First, _Stop, _Val);
+        _First = _Stop;
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else if (_Use_sse42() && _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_impl<_Removing::_Sse_4>(_First, _Stop, _Val);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Remove_fallback(_First, _Last, _Out, _Val);
+}
+
+void* __stdcall __std_remove_8(void* _First, void* const _Last, const uint64_t _Val) noexcept {
+    void* _Out = _First;
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_avx2() && _Size_bytes >= 32) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0x1F});
+        _Out   = _Removing::_Remove_impl<_Removing::_Avx_8>(_First, _Stop, _Val);
+        _First = _Stop;
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else if (_Use_sse42() && _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_impl<_Removing::_Sse_8>(_First, _Stop, _Val);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Remove_fallback(_First, _Last, _Out, _Val);
+}
+
+void* __stdcall __std_remove_copy_1(
+    const void* _First, const void* const _Last, void* _Out, const uint8_t _Val) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 8) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{7});
+        _Out   = _Removing::_Remove_copy_impl<_Removing::_Neon_1>(_First, _Stop, _Out, _Val);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_sse42() && _Size_bytes >= 8) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{7});
+        _Out   = _Removing::_Remove_copy_impl<_Removing::_Sse_1>(_First, _Stop, _Out, _Val);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Remove_fallback(_First, _Last, _Out, _Val);
+}
+
+void* __stdcall __std_remove_copy_2(
+    const void* _First, const void* const _Last, void* _Out, const uint16_t _Val) noexcept {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_copy_impl<_Removing::_Neon_2>(_First, _Stop, _Out, _Val);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_sse42() && _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_copy_impl<_Removing::_Sse_2>(_First, _Stop, _Out, _Val);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Remove_fallback(_First, _Last, _Out, _Val);
+}
+
+void* __stdcall __std_remove_copy_4(
+    const void* _First, const void* const _Last, void* _Out, const uint32_t _Val) noexcept {
+// We choose not to vectorize remove_copy for 32-bit elements on ARM64/ARM64EC
+// as this does not improve performance over the scalar code.
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_avx2() && _Size_bytes >= 32) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0x1F});
+        _Out   = _Removing::_Remove_copy_impl<_Removing::_Avx_4>(_First, _Stop, _Out, _Val);
+        _First = _Stop;
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else if (_Use_sse42() && _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_copy_impl<_Removing::_Sse_4>(_First, _Stop, _Out, _Val);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Remove_fallback(_First, _Last, _Out, _Val);
+}
+
+void* __stdcall __std_remove_copy_8(
+    const void* _First, const void* const _Last, void* _Out, const uint64_t _Val) noexcept {
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_avx2() && _Size_bytes >= 32) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0x1F});
+        _Out   = _Removing::_Remove_copy_impl<_Removing::_Avx_8>(_First, _Stop, _Out, _Val);
+        _First = _Stop;
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else if (_Use_sse42() && _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Out   = _Removing::_Remove_copy_impl<_Removing::_Sse_8>(_First, _Stop, _Out, _Val);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Remove_fallback(_First, _Last, _Out, _Val);
+}
+
+void* __stdcall __std_unique_1(void* _First, void* const _Last) noexcept {
+    _First = const_cast<void*>(__std_adjacent_find_1(_First, _Last));
+
+    if (_First == _Last) {
+        return _First;
+    }
+
+    void* _Dest = _First;
+    _Advance_bytes(_First, 1);
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 8) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{7});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Neon_1>(_First, _Stop);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_sse42() && _Size_bytes >= 8) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{7});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Sse_1>(_First, _Stop);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Unique_fallback<uint8_t>(_First, _Last, _Dest);
+}
+
+void* __stdcall __std_unique_2(void* _First, void* const _Last) noexcept {
+    _First = const_cast<void*>(__std_adjacent_find_2(_First, _Last));
+
+    if (_First == _Last) {
+        return _First;
+    }
+
+    void* _Dest = _First;
+    _Advance_bytes(_First, 2);
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Neon_2>(_First, _Stop);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_sse42() && _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Sse_2>(_First, _Stop);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Unique_fallback<uint16_t>(_First, _Last, _Dest);
+}
+
+void* __stdcall __std_unique_4(void* _First, void* const _Last) noexcept {
+    _First = const_cast<void*>(__std_adjacent_find_4(_First, _Last));
+
+    if (_First == _Last) {
+        return _First;
+    }
+
+    void* _Dest = _First;
+    _Advance_bytes(_First, 4);
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Neon_4>(_First, _Stop);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_avx2() && _Size_bytes >= 32) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0x1F});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Avx_4>(_First, _Stop);
+        _First = _Stop;
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else if (_Use_sse42() && _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Sse_4>(_First, _Stop);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Unique_fallback<uint32_t>(_First, _Last, _Dest);
+}
+
+void* __stdcall __std_unique_8(void* _First, void* const _Last) noexcept {
+    _First = const_cast<void*>(__std_adjacent_find_8(_First, _Last));
+
+    if (_First == _Last) {
+        return _First;
+    }
+
+    void* _Dest = _First;
+    _Advance_bytes(_First, 8);
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_avx2() && _Size_bytes >= 32) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0x1F});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Avx_8>(_First, _Stop);
+        _First = _Stop;
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else if (_Use_sse42() && _Size_bytes >= 16) {
+        void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_impl<_Removing::_Sse_8>(_First, _Stop);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Unique_fallback<uint64_t>(_First, _Last, _Dest);
+}
+
+void* __stdcall __std_unique_copy_1(const void* _First, const void* const _Last, void* _Dest) noexcept {
+    if (_First == _Last) {
+        return _Dest;
+    }
+
+    memcpy(_Dest, _First, 1);
+    _Advance_bytes(_First, 1);
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 8) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{7});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Neon_1>(_First, _Stop, _Dest);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_sse42() && _Size_bytes >= 8) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{7});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Sse_1>(_First, _Stop, _Dest);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Unique_fallback<uint8_t>(_First, _Last, _Dest);
+}
+
+void* __stdcall __std_unique_copy_2(const void* _First, const void* const _Last, void* _Dest) noexcept {
+    if (_First == _Last) {
+        return _Dest;
+    }
+
+    memcpy(_Dest, _First, 2);
+    _Advance_bytes(_First, 2);
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Neon_2>(_First, _Stop, _Dest);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_sse42() && _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Sse_2>(_First, _Stop, _Dest);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Unique_fallback<uint16_t>(_First, _Last, _Dest);
+}
+
+void* __stdcall __std_unique_copy_4(const void* _First, const void* const _Last, void* _Dest) noexcept {
+    if (_First == _Last) {
+        return _Dest;
+    }
+
+    memcpy(_Dest, _First, 4);
+    _Advance_bytes(_First, 4);
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Neon_4>(_First, _Stop, _Dest);
+        _First = _Stop;
+    }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_avx2() && _Size_bytes >= 32) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0x1F});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Avx_4>(_First, _Stop, _Dest);
+        _First = _Stop;
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else if (_Use_sse42() && _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Sse_4>(_First, _Stop, _Dest);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Unique_fallback<uint32_t>(_First, _Last, _Dest);
+}
+
+void* __stdcall __std_unique_copy_8(const void* _First, const void* const _Last, void* _Dest) noexcept {
+    if (_First == _Last) {
+        return _Dest;
+    }
+
+    memcpy(_Dest, _First, 8);
+    _Advance_bytes(_First, 8);
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+    if (const size_t _Size_bytes = _Byte_length(_First, _Last); _Use_avx2() && _Size_bytes >= 32) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0x1F});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Avx_8>(_First, _Stop, _Dest);
+        _First = _Stop;
+
+        _mm256_zeroupper(); // TRANSITION, DevCom-10331414
+    } else if (_Use_sse42() && _Size_bytes >= 16) {
+        const void* _Stop = _First;
+        _Advance_bytes(_Stop, _Size_bytes & ~size_t{0xF});
+        _Dest  = _Removing::_Unique_copy_impl<_Removing::_Sse_8>(_First, _Stop, _Dest);
+        _First = _Stop;
+    }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+    return _Removing::_Unique_fallback<uint64_t>(_First, _Last, _Dest);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Sorted_ranges {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_neon {
+            using _Guard                                = char;
+            static constexpr size_t _Vec_size           = 16;
+            static constexpr size_t _Tail_mask          = 0;
+            static constexpr bool _Has_unsigned_cmp     = true;
+            static constexpr uint64_t _Highest_one_mask = 1ull << 63;
+            static constexpr uint64_t _All_ones_mask    = static_cast<uint64_t>(-1);
+
+            static uint64_t _Bsf(const uint64_t _Mask) noexcept {
+                return _CountTrailingZeros64(_Mask) >> 2;
+            }
+        };
+
+        struct _Traits_1_neon : _Traits_neon {
+            using _Vec_t = int8x16_t;
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return _Sorting::_Traits_1_neon::_Load(_Src);
+            }
+
+            static uint64_t _Mask(const _Vec_t _Val) noexcept {
+                return _Finding::_Find_traits_1::_Mask_q(vreinterpretq_u8_s8(_Val));
+            }
+
+            static _Vec_t _Broadcast(const uint8_t _Data) noexcept {
+                return vreinterpretq_s8_u8(_Finding::_Find_traits_1::_Set_neon_q(_Data));
+            }
+
+            static _Vec_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Sorting::_Traits_1_neon::_Cmp_gt(_First, _Second);
+            }
+
+            static _Vec_t _Cmp_gt_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Sorting::_Traits_1_neon::_Cmp_gt_u(_First, _Second);
+            }
+        };
+
+        struct _Traits_2_neon : _Traits_neon {
+            using _Vec_t = int16x8_t;
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return _Sorting::_Traits_2_neon::_Load(_Src);
+            }
+
+            static uint64_t _Mask(const _Vec_t _Val) noexcept {
+                return _Finding::_Find_traits_2::_Mask_q(vreinterpretq_u16_s16(_Val));
+            }
+
+            static _Vec_t _Broadcast(const uint16_t _Data) noexcept {
+                return vreinterpretq_s16_u16(_Finding::_Find_traits_2::_Set_neon_q(_Data));
+            }
+
+            static _Vec_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Sorting::_Traits_2_neon::_Cmp_gt(_First, _Second);
+            }
+
+            static _Vec_t _Cmp_gt_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Sorting::_Traits_2_neon::_Cmp_gt_u(_First, _Second);
+            }
+        };
+
+        struct _Traits_4_neon : _Traits_neon {
+            using _Vec_t = int32x4_t;
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return _Sorting::_Traits_4_neon::_Load(_Src);
+            }
+
+            static uint64_t _Mask(const _Vec_t _Val) noexcept {
+                return _Finding::_Find_traits_4::_Mask_q(vreinterpretq_u32_s32(_Val));
+            }
+
+            static _Vec_t _Broadcast(const uint32_t _Data) noexcept {
+                return vreinterpretq_s32_u32(_Finding::_Find_traits_4::_Set_neon_q(_Data));
+            }
+
+            static _Vec_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Sorting::_Traits_4_neon::_Cmp_gt(_First, _Second);
+            }
+
+            static _Vec_t _Cmp_gt_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Sorting::_Traits_4_neon::_Cmp_gt_u(_First, _Second);
+            }
+        };
+
+        struct _Traits_8_neon : _Traits_neon {
+            using _Vec_t = int64x2_t;
+
+            static _Vec_t _Load(const void* const _Src) noexcept {
+                return _Sorting::_Traits_8_neon::_Load(_Src);
+            }
+
+            static uint64_t _Mask(const _Vec_t _Val) noexcept {
+                return _Finding::_Find_traits_8::_Mask_q(vreinterpretq_u64_s64(_Val));
+            }
+
+            static _Vec_t _Broadcast(const uint64_t _Data) noexcept {
+                return vreinterpretq_s64_u64(_Finding::_Find_traits_8::_Set_neon_q(_Data));
+            }
+
+            static _Vec_t _Cmp_gt(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Sorting::_Traits_8_neon::_Cmp_gt(_First, _Second);
+            }
+
+            static _Vec_t _Cmp_gt_u(const _Vec_t _First, const _Vec_t _Second) noexcept {
+                return _Sorting::_Traits_8_neon::_Cmp_gt_u(_First, _Second);
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_avx {
+            using _Guard                                = _Zeroupper_on_exit;
+            static constexpr size_t _Vec_size           = 32;
+            static constexpr size_t _Tail_mask          = 0x1C;
+            static constexpr bool _Has_unsigned_cmp     = false;
+            static constexpr uint32_t _Highest_one_mask = 1u << (_Vec_size - 1);
+            static constexpr uint32_t _All_ones_mask    = uint32_t{(uint64_t{1} << _Vec_size) - 1};
+
+            static __m256i _Load(const void* const _Src) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+            }
+
+            static __m256i _Load_mask(const void* const _Src, const __m256i _Mask) noexcept {
+                return _mm256_maskload_epi32(reinterpret_cast<const int*>(_Src), _Mask);
+            }
+
+            static unsigned long _Mask(const __m256i _Val) noexcept {
+                return _mm256_movemask_epi8(_Val);
+            }
+
+            static uint32_t _Bsf(const uint32_t _Val) noexcept {
+                return _tzcnt_u32(_Val);
+            }
+        };
+
+        struct _Traits_1_avx : _Traits_avx {
+            static __m256i _Broadcast(const uint8_t _Data) noexcept {
+                return _mm256_broadcastb_epi8(_mm_cvtsi32_si128(static_cast<uint32_t>(_Data)));
+            }
+
+            static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpgt_epi8(_First, _Second);
+            }
+
+            static __m256i _Sign_correction(const __m256i _Data) noexcept {
+                return _mm256_sub_epi8(_Data, _mm256_set1_epi8(static_cast<char>(0x80)));
+            }
+        };
+
+        struct _Traits_2_avx : _Traits_avx {
+            static __m256i _Broadcast(const uint16_t _Data) noexcept {
+                return _mm256_broadcastw_epi16(_mm_cvtsi32_si128(static_cast<uint32_t>(_Data)));
+            }
+
+            static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpgt_epi16(_First, _Second);
+            }
+
+            static __m256i _Sign_correction(const __m256i _Data) noexcept {
+                return _mm256_sub_epi16(_Data, _mm256_set1_epi16(static_cast<short>(0x8000)));
+            }
+        };
+
+        struct _Traits_4_avx : _Traits_avx {
+            static __m256i _Broadcast(const uint32_t _Data) noexcept {
+                return _mm256_broadcastd_epi32(_mm_cvtsi32_si128(_Data));
+            }
+
+            static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpgt_epi32(_First, _Second);
+            }
+
+            static __m256i _Sign_correction(const __m256i _Data) noexcept {
+                return _mm256_sub_epi32(_Data, _mm256_set1_epi32(static_cast<long>(0x8000'0000)));
+            }
+        };
+
+        struct _Traits_8_avx : _Traits_avx {
+            static __m256i _Broadcast(const uint64_t _Data) noexcept {
+#ifdef _WIN64
+                return _mm256_broadcastq_epi64(_mm_cvtsi64_si128(_Data));
+#else // ^^^ 64-bit / 32-bit, workaround, _mm_cvtsi64_si128 does not compile vvv
+                return _mm256_set1_epi64x(_Data);
+#endif // ^^^ 32-bit ^^^
+            }
+
+            static __m256i _Cmp_gt(const __m256i _First, const __m256i _Second) noexcept {
+                return _mm256_cmpgt_epi64(_First, _Second);
+            }
+
+            static __m256i _Sign_correction(const __m256i _Data) noexcept {
+                return _mm256_sub_epi64(_Data, _mm256_set1_epi64x(static_cast<long long>(0x8000'0000'0000'0000)));
+            }
+        };
+
+        struct _Traits_sse {
+            using _Guard                                = char;
+            static constexpr size_t _Vec_size           = 16;
+            static constexpr size_t _Tail_mask          = 0;
+            static constexpr bool _Has_unsigned_cmp     = false;
+            static constexpr uint32_t _Highest_one_mask = 1u << (_Vec_size - 1);
+            static constexpr uint32_t _All_ones_mask    = uint32_t{(uint64_t{1} << _Vec_size) - 1};
+
+            static __m128i _Load(const void* const _Src) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
+            }
+
+            static unsigned long _Mask(const __m128i _Val) noexcept {
+                return _mm_movemask_epi8(_Val);
+            }
+
+            static uint32_t _Bsf(const uint32_t _Val) noexcept {
+                unsigned long _Index;
+                // CodeQL [SM02313] _Index is always initialized: _Val != 0; see explanation at call sites.
+                _BitScanForward(&_Index, _Val);
+                return _Index;
+            }
+        };
+
+        struct _Traits_1_sse : _Traits_sse {
+            static __m128i _Broadcast(const uint8_t _Data) noexcept {
+                return _mm_shuffle_epi8(_mm_cvtsi32_si128(static_cast<uint32_t>(_Data)), _mm_setzero_si128());
+            }
+
+            static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpgt_epi8(_First, _Second);
+            }
+
+            static __m128i _Sign_correction(const __m128i _Data) noexcept {
+                return _mm_sub_epi8(_Data, _mm_set1_epi8(static_cast<char>(0x80)));
+            }
+        };
+
+        struct _Traits_2_sse : _Traits_sse {
+            static __m128i _Broadcast(const uint16_t _Data) noexcept {
+                return _mm_shuffle_epi8(_mm_cvtsi32_si128(static_cast<uint32_t>(_Data)), _mm_set1_epi16(0x0100));
+            }
+
+            static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpgt_epi16(_First, _Second);
+            }
+
+            static __m128i _Sign_correction(const __m128i _Data) noexcept {
+                return _mm_sub_epi16(_Data, _mm_set1_epi16(static_cast<short>(0x8000)));
+            }
+        };
+
+        struct _Traits_4_sse : _Traits_sse {
+            static __m128i _Broadcast(const uint32_t _Data) noexcept {
+                return _mm_shuffle_epi32(_mm_cvtsi32_si128(_Data), _MM_SHUFFLE(0, 0, 0, 0));
+            }
+
+            static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpgt_epi32(_First, _Second);
+            }
+
+            static __m128i _Sign_correction(const __m128i _Data) noexcept {
+                return _mm_sub_epi32(_Data, _mm_set1_epi32(static_cast<long>(0x8000'0000)));
+            }
+        };
+
+        struct _Traits_8_sse : _Traits_sse {
+            static __m128i _Broadcast(const uint64_t _Data) noexcept {
+#ifdef _WIN64
+                return _mm_shuffle_epi32(_mm_cvtsi64_si128(_Data), _MM_SHUFFLE(1, 0, 1, 0));
+#else // ^^^ 64-bit / 32-bit, workaround, _mm_cvtsi64_si128 does not compile vvv
+                return _mm_set1_epi64x(_Data);
+#endif // ^^^ 32-bit ^^^
+            }
+
+            static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
+                return _mm_cmpgt_epi64(_First, _Second);
+            }
+
+            static __m128i _Sign_correction(const __m128i _Data) noexcept {
+                return _mm_sub_epi64(_Data, _mm_set1_epi64x(static_cast<long long>(0x8000'0000'0000'0000)));
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        template <class _Traits, class _Ty>
+        bool _Includes_impl(
+            const void* _First1, const void* const _Last1, const void* _First2, const void* const _Last2) noexcept {
+            if constexpr (!std::is_void_v<_Traits>) {
+                // Only skipping some parts of haystack that are less than current needle element is vectorized.
+                // Otherwise this is scalar algorithm.
+
+                constexpr bool _Is_signed = std::is_signed_v<_Ty>;
+                [[maybe_unused]] typename _Traits::_Guard _Guard; // TRANSITION, DevCom-10331414
+
+                const size_t _Size_bytes_1 = _Byte_length(_First1, _Last1);
+                const void* _Stop1         = _First1;
+                _Advance_bytes(_Stop1, _Size_bytes_1 & ~(_Traits::_Vec_size - 1));
+
+                _Ty _Val2    = *reinterpret_cast<const _Ty*>(_First2);
+                auto _Start2 = _Traits::_Broadcast(_Val2);
+                if constexpr (!_Is_signed && !_Traits::_Has_unsigned_cmp) {
+                    _Start2 = _Traits::_Sign_correction(_Start2);
+                }
+
+                do {
+                    auto _Data1 = _Traits::_Load(_First1);
+                    if constexpr (!_Is_signed && !_Traits::_Has_unsigned_cmp) {
+                        _Data1 = _Traits::_Sign_correction(_Data1);
+                    }
+
+                    const void* _Next1 = _First1;
+                    _Advance_bytes(_Next1, _Traits::_Vec_size);
+
+                    const auto _Cmp_gt_wrap = [](const auto _First, const auto _Second) noexcept {
+                        if constexpr (_Is_signed || !_Traits::_Has_unsigned_cmp) {
+                            return _Traits::_Cmp_gt(_First, _Second);
+                        } else {
+                            return _Traits::_Cmp_gt_u(_First, _Second);
+                        }
+                    };
+
+                    const auto _Greater_start_2 = _Traits::_Mask(_Cmp_gt_wrap(_Start2, _Data1));
+                    // Testing _Highest_one_mask can be a bit more efficient than comparing against
+                    // _All_ones_mask (will test sign, and can share comparison with != 0 below).
+                    if ((_Greater_start_2 & _Traits::_Highest_one_mask) != 0) {
+                        // Needle first element is greater than each element of haystack vector.
+                        // Proceed to the next one, without updating the needle comparand.
+                        _First1 = _Next1;
+                    } else {
+                        if (_Greater_start_2 != 0) {
+                            // Needle first element is greater than some first elements of haystack part.
+                            // Advance past these elements.
+                            // The input is nonzero because we handled that case with _Highest_one_mask branch above.
+                            const auto _Skip = _Traits::_Bsf(_Greater_start_2 ^ _Traits::_All_ones_mask);
+                            _Advance_bytes(_First1, _Skip);
+                        }
+
+                        // The rest is scalar loop that completes the remaining vector-sized haystack part.
+                        // Except that it updates current needle value to compare against.
+                        do {
+                            const _Ty _Val1 = *static_cast<const _Ty*>(_First1);
+
+                            if (_Val2 < _Val1) {
+                                return false;
+                            }
+
+                            if (_Val2 == _Val1) {
+                                _Advance_bytes(_First2, sizeof(_Ty));
+                                if (_First2 == _Last2) {
+                                    return true;
+                                }
+
+                                _Val2 = *reinterpret_cast<const _Ty*>(_First2);
+                            }
+
+                            _Advance_bytes(_First1, sizeof(_Ty));
+                        } while (_First1 != _Next1);
+
+                        _Start2 = _Traits::_Broadcast(_Val2);
+                        if constexpr (!_Is_signed && !_Traits::_Has_unsigned_cmp) {
+                            _Start2 = _Traits::_Sign_correction(_Start2);
+                        }
+                    }
+                } while (_First1 != _Stop1);
+
+                if constexpr (_Traits::_Tail_mask != 0) {
+                    const size_t _Tail_bytes_size_1 = _Size_bytes_1 & _Traits::_Tail_mask;
+                    if (_Tail_bytes_size_1 != 0) {
+                        // Just try to advance past less one more time.
+                        // Don't need to repeat the scalar part here - falling to scalar loop anyway.
+                        const auto _Tail_mask = _Avx2_tail_mask_32(_Tail_bytes_size_1);
+                        auto _Data1           = _Traits::_Load_mask(_First1, _Tail_mask);
+                        if constexpr (!_Is_signed) {
+                            _Data1 = _Traits::_Sign_correction(_Data1);
+                        }
+
+                        const auto _Cmp                 = _Traits::_Cmp_gt(_Start2, _Data1);
+                        const uint32_t _Greater_start_2 = _Traits::_Mask(_mm256_and_si256(_Cmp, _Tail_mask));
+                        if (_Greater_start_2 != 0) {
+                            // Needle first element is greater than some first elements of haystack part.
+                            // Advance past these elements.
+                            // The input is nonzero because tail mask will have zeros for remaining elements.
+                            const uint32_t _Skip = _Traits::_Bsf(_Greater_start_2 ^ _Traits::_All_ones_mask);
+                            _Advance_bytes(_First1, _Skip);
+                        }
+                    }
+                }
+
+                if (_First1 == _Last1) {
+                    return false;
+                }
+            }
+
+            auto _Ptr1 = static_cast<const _Ty*>(_First1);
+            auto _Ptr2 = static_cast<const _Ty*>(_First2);
+
+            for (;;) {
+                if (*_Ptr1 < *_Ptr2) {
+                    ++_Ptr1;
+                    if (_Ptr1 == _Last1) {
+                        return false;
+                    }
+                } else if (*_Ptr2 < *_Ptr1) {
+                    return false;
+                } else {
+                    ++_Ptr1;
+                    ++_Ptr2;
+                    if (_Ptr2 == _Last2) {
+                        return true;
+                    } else if (_Ptr1 == _Last1) {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        struct _Traits_1 {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_1_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_1_sse;
+            using _Avx = _Traits_1_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        struct _Traits_2 {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_2_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_2_sse;
+            using _Avx = _Traits_2_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        struct _Traits_4 {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_4_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_4_sse;
+            using _Avx = _Traits_4_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        struct _Traits_8 {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            using _Neon = _Traits_8_neon;
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            using _Sse = _Traits_8_sse;
+            using _Avx = _Traits_8_avx;
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+        };
+
+        template <class _Traits, class _Ty>
+        bool __stdcall _Includes_disp(const void* const _First1, const void* const _Last1, const void* const _First2,
+            const void* const _Last2) noexcept {
+            const size_t _Size_bytes_1 = _Byte_length(_First1, _Last1);
+            const size_t _Size_bytes_2 = _Byte_length(_First2, _Last2);
+            if (_Size_bytes_2 == 0) {
+                return true;
+            } else if (_Size_bytes_1 < _Size_bytes_2) {
+                return false;
+            }
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+            if (_Size_bytes_1 >= 16) {
+                return _Includes_impl<typename _Traits::_Neon, _Ty>(_First1, _Last1, _First2, _Last2);
+            }
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+            if (_Size_bytes_1 >= 32 && _Use_avx2()) {
+                return _Includes_impl<typename _Traits::_Avx, _Ty>(_First1, _Last1, _First2, _Last2);
+            }
+
+            if (_Size_bytes_1 >= 16 && _Use_sse42()) {
+                return _Includes_impl<typename _Traits::_Sse, _Ty>(_First1, _Last1, _First2, _Last2);
+            }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+            return _Includes_impl<void, _Ty>(_First1, _Last1, _First2, _Last2);
+        }
+    } // namespace _Sorted_ranges
+} // unnamed namespace
+
+extern "C" {
+
+__declspec(noalias) bool __stdcall __std_includes_less_1i(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Sorted_ranges::_Includes_disp<_Sorted_ranges::_Traits_1, int8_t>(_First1, _Last1, _First2, _Last2);
+}
+
+__declspec(noalias) bool __stdcall __std_includes_less_1u(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Sorted_ranges::_Includes_disp<_Sorted_ranges::_Traits_1, uint8_t>(_First1, _Last1, _First2, _Last2);
+}
+
+__declspec(noalias) bool __stdcall __std_includes_less_2i(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Sorted_ranges::_Includes_disp<_Sorted_ranges::_Traits_2, int16_t>(_First1, _Last1, _First2, _Last2);
+}
+
+__declspec(noalias) bool __stdcall __std_includes_less_2u(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Sorted_ranges::_Includes_disp<_Sorted_ranges::_Traits_2, uint16_t>(_First1, _Last1, _First2, _Last2);
+}
+
+__declspec(noalias) bool __stdcall __std_includes_less_4i(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Sorted_ranges::_Includes_disp<_Sorted_ranges::_Traits_4, int32_t>(_First1, _Last1, _First2, _Last2);
+}
+
+__declspec(noalias) bool __stdcall __std_includes_less_4u(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Sorted_ranges::_Includes_disp<_Sorted_ranges::_Traits_4, uint32_t>(_First1, _Last1, _First2, _Last2);
+}
+
+__declspec(noalias) bool __stdcall __std_includes_less_8i(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Sorted_ranges::_Includes_disp<_Sorted_ranges::_Traits_8, int64_t>(_First1, _Last1, _First2, _Last2);
+}
+
+__declspec(noalias) bool __stdcall __std_includes_less_8u(
+    const void* const _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+    return _Sorted_ranges::_Includes_disp<_Sorted_ranges::_Traits_8, uint64_t>(_First1, _Last1, _First2, _Last2);
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Bitset_to_string {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_1_neon {
+            using _Value_type = uint16_t;
+            using _Vec_t      = uint8x16_t;
+            static void _Exit_vectorized() noexcept {}
+
+            static void _Out(void* const _Dest, const _Vec_t _Elems) noexcept {
+                vst1q_u8(static_cast<uint8_t*>(_Dest), _Elems);
+            }
+
+            static _Vec_t _Set(const uint8_t _Val) noexcept {
+                return vdupq_n_u8(_Val);
+            }
+
+            static _Vec_t _Load_constant() noexcept {
+                // We do not omit static here, despite DevCom-11055227, because codegen is worse - see DevCom-11056805.
+                static constexpr uint32_t _Idx_arr[4] = {0x01010101, 0x01010101, 0x00000000, 0x00000000};
+                const auto _Idx                       = vld1q_u8(reinterpret_cast<const uint8_t*>(_Idx_arr));
+                return _Idx;
+            }
+
+            static _Vec_t __forceinline _Step(
+                const uint16_t _Val, const _Vec_t _Px0, const _Vec_t _Px1, const _Vec_t _Idx) noexcept {
+                const auto _Vx0 = vdupq_n_u16(_Val);
+                const auto _Vx1 = vqtbl1q_u8(vreinterpretq_u8_u16(_Vx0), _Idx);
+                const auto _Msk = vandq_u8(_Vx1, vreinterpretq_u8_u64(vdupq_n_u64(0x0102040810204080)));
+                const auto _Ex0 = vceqq_u8(_Msk, vdupq_n_u8(0));
+                const auto _Ex1 = vbslq_u8(_Ex0, _Px0, _Px1);
+                return _Ex1;
+            }
+        };
+
+        struct _Traits_2_neon {
+            using _Value_type = uint8_t;
+            using _Vec_t      = uint16x8_t;
+            static void _Exit_vectorized() noexcept {}
+
+            static void _Out(void* const _Dest, const _Vec_t _Elems) noexcept {
+                vst1q_u16(static_cast<uint16_t*>(_Dest), _Elems);
+            }
+
+            static _Vec_t _Set(const uint16_t _Val) noexcept {
+                return vdupq_n_u16(_Val);
+            }
+
+            static _Vec_t _Load_constant() noexcept {
+                // We do not omit static here, despite DevCom-11055227, because codegen is worse - see DevCom-11056805.
+                static constexpr uint64_t _Wx_arr[2] = {0x0010002000400080, 0x0001000200040008};
+                const auto _Wx                       = vld1q_u64(_Wx_arr);
+                return vreinterpretq_u16_u64(_Wx);
+            }
+
+            static _Vec_t __forceinline _Step(
+                const uint8_t _Val, const _Vec_t _Px0, const _Vec_t _Px1, const _Vec_t _Wx) noexcept {
+                const auto _Vx0 = vdupq_n_u16(static_cast<uint16_t>(_Val));
+                const auto _Msk = vandq_u16(_Vx0, _Wx);
+                const auto _Ex0 = vceqq_u16(_Msk, vdupq_n_u16(0));
+                const auto _Ex1 = vbslq_u16(_Ex0, _Px0, _Px1);
+                return _Ex1;
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_avx {
+            static void _Out(void* const _Dest, const __m256i _Elems) noexcept {
+                _mm256_storeu_si256(static_cast<__m256i*>(_Dest), _Elems);
+            }
+
+            static void _Exit_vectorized() noexcept {
+                _mm256_zeroupper();
+            }
+
+            static int _Load_constant() noexcept {
+                return 0;
+            }
+        };
+
+        struct _Traits_sse {
+            static void _Out(void* const _Dest, const __m128i _Elems) noexcept {
+                _mm_storeu_si128(static_cast<__m128i*>(_Dest), _Elems);
+            }
+
+            static void _Exit_vectorized() noexcept {}
+
+            static int _Load_constant() noexcept {
+                return 0;
+            }
+        };
+
+        struct _Traits_1_avx : _Traits_avx {
+            using _Value_type = uint32_t;
+
+            static __m256i _Set(const char _Val) noexcept {
+                return _mm256_broadcastb_epi8(_mm_cvtsi32_si128(_Val));
+            }
+
+            static __m256i __forceinline _Step(
+                const uint32_t _Val, const __m256i _Px0, const __m256i _Px1, int) noexcept {
+                const __m128i _Vx0 = _mm_cvtsi32_si128(_Val);
+                const __m128i _Vx1 =
+                    _mm_shuffle_epi8(_Vx0, _mm_set_epi32(0x00000000, 0x01010101, 0x02020202, 0x03030303));
+                const __m256i _Vx2 = _mm256_castsi128_si256(_Vx1);
+                const __m256i _Vx3 = _mm256_permutevar8x32_epi32(_Vx2, _mm256_set_epi32(3, 3, 2, 2, 1, 1, 0, 0));
+                const __m256i _Msk = _mm256_and_si256(_Vx3, _mm256_set1_epi64x(0x0102040810204080));
+                const __m256i _Ex0 = _mm256_cmpeq_epi8(_Msk, _mm256_setzero_si256());
+                const __m256i _Ex1 = _mm256_blendv_epi8(_Px1, _Px0, _Ex0);
+                return _Ex1;
+            }
+        };
+
+        struct _Traits_1_sse : _Traits_sse {
+            using _Value_type = uint16_t;
+
+            static __m128i _Set(const char _Val) noexcept {
+                return _mm_shuffle_epi8(_mm_cvtsi32_si128(_Val), _mm_setzero_si128());
+            }
+
+            static __m128i __forceinline _Step(
+                const uint16_t _Val, const __m128i _Px0, const __m128i _Px1, int) noexcept {
+                const __m128i _Vx0 = _mm_cvtsi32_si128(_Val);
+                const __m128i _Vx1 =
+                    _mm_shuffle_epi8(_Vx0, _mm_set_epi32(0x00000000, 0x00000000, 0x01010101, 0x01010101));
+                const __m128i _Msk = _mm_and_si128(_Vx1, _mm_set1_epi64x(0x0102040810204080));
+                const __m128i _Ex0 = _mm_cmpeq_epi8(_Msk, _mm_setzero_si128());
+                const __m128i _Ex1 = _mm_blendv_epi8(_Px1, _Px0, _Ex0);
+                return _Ex1;
+            }
+        };
+
+        struct _Traits_2_avx : _Traits_avx {
+            using _Value_type = uint16_t;
+
+            static __m256i _Set(const wchar_t _Val) noexcept {
+                return _mm256_broadcastw_epi16(_mm_cvtsi32_si128(_Val));
+            }
+
+            static __m256i __forceinline _Step(
+                const uint16_t _Val, const __m256i _Px0, const __m256i _Px1, int) noexcept {
+                const __m128i _Vx0 = _mm_cvtsi32_si128(_Val);
+                const __m128i _Vx1 =
+                    _mm_shuffle_epi8(_Vx0, _mm_set_epi32(0x00000000, 0x00000000, 0x01010101, 0x01010101));
+                const __m256i _Vx2 = _mm256_castsi128_si256(_Vx1);
+                const __m256i _Vx3 = _mm256_permute4x64_epi64(_Vx2, _MM_SHUFFLE(1, 1, 0, 0));
+                const __m256i _Msk = _mm256_and_si256(_Vx3,
+                    _mm256_set_epi64x(0x0001000200040008, 0x0010002000400080, 0x0001000200040008, 0x0010002000400080));
+                const __m256i _Ex0 = _mm256_cmpeq_epi16(_Msk, _mm256_setzero_si256());
+                const __m256i _Ex1 = _mm256_blendv_epi8(_Px1, _Px0, _Ex0);
+                return _Ex1;
+            }
+        };
+
+        struct _Traits_2_sse : _Traits_sse {
+            using _Value_type = uint8_t;
+
+            static __m128i _Set(const wchar_t _Val) noexcept {
+                return _mm_set1_epi16(_Val);
+            }
+
+            static __m128i __forceinline _Step(
+                const uint8_t _Val, const __m128i _Px0, const __m128i _Px1, int) noexcept {
+                const __m128i _Vx  = _mm_set1_epi16(_Val);
+                const __m128i _Msk = _mm_and_si128(_Vx, _mm_set_epi64x(0x0001000200040008, 0x0010002000400080));
+                const __m128i _Ex0 = _mm_cmpeq_epi16(_Msk, _mm_setzero_si128());
+                const __m128i _Ex1 = _mm_blendv_epi8(_Px1, _Px0, _Ex0);
+                return _Ex1;
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        template <class _Traits, class _Elem>
+        void __stdcall _Impl(
+            _Elem* const _Dest, const void* _Src, size_t _Size_bits, const _Elem _Elem0, const _Elem _Elem1) noexcept {
+            constexpr size_t _Step_size_bits = sizeof(typename _Traits::_Value_type) * 8;
+
+            const auto _Px0 = _Traits::_Set(_Elem0);
+            const auto _Px1 = _Traits::_Set(_Elem1);
+
+            // TRANSITION: DevCom-11056873
+            const auto _Constant = _Traits::_Load_constant();
+
+            if (_Size_bits >= _Step_size_bits) {
+                _Elem* _Pos = _Dest + _Size_bits;
+                _Size_bits &= _Step_size_bits - 1;
+                _Elem* const _Stop_at = _Dest + _Size_bits;
+                do {
+                    typename _Traits::_Value_type _Val;
+                    memcpy(&_Val, _Src, sizeof(_Val));
+                    const auto _Elems = _Traits::_Step(_Val, _Px0, _Px1, _Constant);
+                    _Pos -= _Step_size_bits;
+                    _Traits::_Out(_Pos, _Elems);
+                    _Advance_bytes(_Src, sizeof(_Val));
+                } while (_Pos != _Stop_at);
+            }
+
+            if (_Size_bits > 0) {
+                typename _Traits::_Value_type _Val;
+                memcpy(&_Val, _Src, sizeof(_Val));
+                const auto _Elems = _Traits::_Step(_Val, _Px0, _Px1, _Constant);
+                _Elem _Tmp[_Step_size_bits];
+                _Traits::_Out(_Tmp, _Elems);
+                const _Elem* const _Tmpd = _Tmp + (_Step_size_bits - _Size_bits);
+                memcpy(_Dest, _Tmpd, _Size_bits * sizeof(_Elem));
+            }
+
+            _Traits::_Exit_vectorized(); // TRANSITION, DevCom-10331414
+        }
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+        template <class _Avx_traits, class _Sse_traits, class _Elem>
+        void __stdcall _Dispatch(_Elem* const _Dest, const void* const _Src, const size_t _Size_bits,
+            const _Elem _Elem0, const _Elem _Elem1) noexcept {
+            if (_Use_avx2() && _Size_bits >= 256) {
+                _Impl<_Avx_traits>(_Dest, _Src, _Size_bits, _Elem0, _Elem1);
+            } else if (_Use_sse42()) {
+                _Impl<_Sse_traits>(_Dest, _Src, _Size_bits, _Elem0, _Elem1);
+            } else {
+                const auto _Arr = reinterpret_cast<const uint8_t*>(_Src);
+                for (size_t _Ix = 0; _Ix < _Size_bits; ++_Ix) {
+                    _Dest[_Size_bits - 1 - _Ix] = ((_Arr[_Ix >> 3] >> (_Ix & 7)) & 1) != 0 ? _Elem1 : _Elem0;
+                }
+            }
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+    } // namespace _Bitset_to_string
+} // unnamed namespace
+
+extern "C" {
+
+__declspec(noalias) void __stdcall __std_bitset_to_string_1(
+    char* const _Dest, const void* const _Src, const size_t _Size_bits, const char _Elem0, const char _Elem1) noexcept {
+    using namespace _Bitset_to_string;
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    _Impl<_Traits_1_neon>(_Dest, _Src, _Size_bits, _Elem0, _Elem1);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    _Dispatch<_Traits_1_avx, _Traits_1_sse>(_Dest, _Src, _Size_bits, _Elem0, _Elem1);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+__declspec(noalias) void __stdcall __std_bitset_to_string_2(wchar_t* const _Dest, const void* const _Src,
+    const size_t _Size_bits, const wchar_t _Elem0, const wchar_t _Elem1) noexcept {
+    using namespace _Bitset_to_string;
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    _Impl<_Traits_2_neon>(_Dest, _Src, _Size_bits, _Elem0, _Elem1);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    _Dispatch<_Traits_2_avx, _Traits_2_sse>(_Dest, _Src, _Size_bits, _Elem0, _Elem1);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+} // extern "C"
+
+namespace {
+    namespace _Bitset_from_string {
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+        struct _Traits_1_neon {
+            using _Guard = char;
+            using _Vec   = uint8x16_t;
+
+            static _Vec _Load(const void* const _Src) noexcept {
+                return vld1q_u8(static_cast<const uint8_t*>(_Src));
+            }
+
+            static void _Store(void* const _Dest, const _Vec _Val) noexcept {
+                return vst1q_u8(static_cast<uint8_t*>(_Dest), _Val);
+            }
+
+            static _Vec _Set(const uint8_t _Val) noexcept {
+                return vdupq_n_u8(_Val);
+            }
+
+            static _Vec _Cmp(const _Vec _Val1, const _Vec _Val2) noexcept {
+                return vceqq_u8(_Val1, _Val2);
+            }
+
+            static bool _Check(const _Vec _Val, const _Vec _Ex1, const _Vec _Dx0) noexcept {
+                const auto _Ex0  = _Cmp(_Val, _Dx0);
+                const auto _Ex01 = vorrq_u8(_Ex0, _Ex1);
+                const auto _Msk  = vgetq_lane_u64(vreinterpretq_u64_u8(vpminq_u8(_Ex01, _Ex01)), 0);
+                return _Msk == 0xFFFF'FFFF'FFFF'FFFF;
+            }
+
+            static uint64_t _Movemask(const _Vec _Val) noexcept {
+                uint64_t _Val0 = vgetq_lane_u64(vreinterpretq_u64_u8(_Val), 0);
+                uint64_t _Val1 = vgetq_lane_u64(vreinterpretq_u64_u8(_Val), 1);
+
+                _Val0 &= 0x8080808080808080ull;
+                _Val1 &= 0x8080808080808080ull;
+                _Val0 *= 0x02040810204081ull;
+                _Val1 *= 0x02040810204081ull;
+
+                return (_Val0 >> 56) | ((_Val1 >> 56) << 8);
+            }
+
+            static uint16_t _To_bits(const _Vec _Ex1) noexcept {
+                // We do not omit static here, despite DevCom-11055227, because codegen is worse - see DevCom-11056805.
+                static constexpr uint8_t _Idx_arr[16] = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+                const auto _Idx                       = vld1q_u8(_Idx_arr);
+
+                const auto _Ex2 = vqtbl1q_u8(_Ex1, _Idx);
+                return static_cast<uint16_t>(_Movemask(_Ex2));
+            }
+        };
+
+        struct _Traits_2_neon {
+            using _Guard = char;
+            using _Vec   = uint16x8_t;
+
+            static _Vec _Load(const void* const _Src) noexcept {
+                return vld1q_u16(static_cast<const uint16_t*>(_Src));
+            }
+
+            static void _Store(void* const _Dest, const _Vec _Val) noexcept {
+                return vst1q_u16(static_cast<uint16_t*>(_Dest), _Val);
+            }
+
+            static _Vec _Set(const uint16_t _Val) noexcept {
+                return vdupq_n_u16(_Val);
+            }
+
+            static _Vec _Cmp(const _Vec _Val1, const _Vec _Val2) noexcept {
+                return vceqq_u16(_Val1, _Val2);
+            }
+
+            static bool _Check(const _Vec _Val, const _Vec _Ex1, const _Vec _Dx0) noexcept {
+                const auto _Ex0  = _Cmp(_Val, _Dx0);
+                const auto _Ex01 = vorrq_u16(_Ex0, _Ex1);
+                const auto _Msk  = vgetq_lane_u64(vreinterpretq_u64_u16(vpminq_u16(_Ex01, _Ex01)), 0);
+                return _Msk == 0xFFFF'FFFF'FFFF'FFFF;
+            }
+
+            static uint64_t _Movemask(const _Traits_1_neon::_Vec _Val) noexcept {
+                uint64_t _Val0 = vgetq_lane_u64(vreinterpretq_u64_u8(_Val), 0);
+                _Val0 &= 0x8080808080808080ull;
+                _Val0 *= 0x02040810204081ull;
+                return _Val0 >> 56;
+            }
+
+            static uint8_t _To_bits(const _Vec _Ex1) noexcept {
+                // We do not omit static here, despite DevCom-11055227, because codegen is worse - see DevCom-11056805.
+                static constexpr uint8_t _Idx_arr[16] = {
+                    14, 12, 10, 8, 6, 4, 2, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+                const auto _Idx = vld1q_u8(_Idx_arr);
+
+                const auto _Ex2 = vqtbl1q_u8(vreinterpretq_u8_u16(_Ex1), _Idx);
+                return static_cast<uint8_t>(_Movemask(_Ex2));
+            }
+        };
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+        struct _Traits_avx {
+            using _Guard = _Zeroupper_on_exit;
+            using _Vec   = __m256i;
+
+            static __m256i _Load(const void* _Src) noexcept {
+                return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Src));
+            }
+
+            static void _Store(void* _Dest, const __m256i _Val) noexcept {
+                _mm256_storeu_si256(reinterpret_cast<__m256i*>(_Dest), _Val);
+            }
+
+            static bool _Check(const __m256i _Val, const __m256i _Ex1, const __m256i _Dx0) noexcept {
+                return _mm256_testc_si256(_Ex1, _mm256_xor_si256(_Val, _Dx0));
+            }
+        };
+
+        struct _Traits_sse {
+            using _Guard = char;
+            using _Vec   = __m128i;
+
+            static __m128i _Load(const void* _Src) noexcept {
+                return _mm_loadu_si128(reinterpret_cast<const __m128i*>(_Src));
+            }
+
+            static void _Store(void* _Dest, const __m128i _Val) noexcept {
+                _mm_storeu_si128(reinterpret_cast<__m128i*>(_Dest), _Val);
+            }
+
+            static bool _Check(const __m128i _Val, const __m128i _Ex1, const __m128i _Dx0) noexcept {
+                return _mm_testc_si128(_Ex1, _mm_xor_si128(_Val, _Dx0));
+            }
+        };
+
+        struct _Traits_1_avx : _Traits_avx {
+            static __m256i _Set(const char _Val) noexcept {
+                return _mm256_set1_epi8(_Val);
+            }
+
+            static uint32_t _To_bits(const __m256i _Ex1) noexcept {
+                const __m256i _Shuf = _mm256_set_epi8( //
+                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, //
+                    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+
+                const __m256i _Ex2 = _mm256_shuffle_epi8(_Ex1, _Shuf);
+                return _rotl(static_cast<uint32_t>(_mm256_movemask_epi8(_Ex2)), 16);
+            }
+
+            static __m256i _Cmp(const __m256i _Val, const __m256i _Dx1) noexcept {
+                return _mm256_cmpeq_epi8(_Val, _Dx1);
+            }
+        };
+
+        struct _Traits_1_sse : _Traits_sse {
+            static __m128i _Set(const char _Val) noexcept {
+                return _mm_shuffle_epi8(_mm_cvtsi32_si128(_Val), _mm_setzero_si128());
+            }
+
+            static uint16_t _To_bits(const __m128i _Ex1) noexcept {
+                const __m128i _Shuf = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+                const __m128i _Ex2  = _mm_shuffle_epi8(_Ex1, _Shuf);
+                return static_cast<uint16_t>(_mm_movemask_epi8(_Ex2));
+            }
+
+            static __m128i _Cmp(const __m128i _Val, const __m128i _Dx1) noexcept {
+                return _mm_cmpeq_epi8(_Val, _Dx1);
+            }
+        };
+
+        struct _Traits_2_avx : _Traits_avx {
+            static __m256i _Set(const wchar_t _Val) noexcept {
+                return _mm256_set1_epi16(_Val);
+            }
+
+            static uint16_t _To_bits(const __m256i _Ex1) noexcept {
+                const __m256i _Shuf = _mm256_set_epi8( //
+                    +0, +2, +4, +6, +8, 10, 12, 14, -1, -1, -1, -1, -1, -1, -1, -1, //
+                    -1, -1, -1, -1, -1, -1, -1, -1, +0, +2, +4, +6, +8, 10, 12, 14);
+
+                const __m256i _Ex2 = _mm256_shuffle_epi8(_Ex1, _Shuf);
+                return static_cast<uint16_t>(_rotl(static_cast<uint32_t>(_mm256_movemask_epi8(_Ex2)), 8));
+            }
+
+            static __m256i _Cmp(const __m256i _Val, const __m256i _Dx1) noexcept {
+                return _mm256_cmpeq_epi16(_Val, _Dx1);
+            }
+        };
+
+        struct _Traits_2_sse : _Traits_sse {
+            static __m128i _Set(const wchar_t _Val) noexcept {
+                return _mm_set1_epi16(_Val);
+            }
+
+            static uint8_t _To_bits(const __m128i _Ex1) noexcept {
+                const __m128i _Shuf = _mm_set_epi8(-1, -1, -1, -1, -1, -1, -1, -1, 0, 2, 4, 6, 8, 10, 12, 14);
+                const __m128i _Ex2  = _mm_shuffle_epi8(_Ex1, _Shuf);
+                return static_cast<uint8_t>(_mm_movemask_epi8(_Ex2));
+            }
+
+            static __m128i _Cmp(const __m128i _Val, const __m128i _Dx1) noexcept {
+                return _mm_cmpeq_epi16(_Val, _Dx1);
+            }
+        };
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+
+        template <class _Traits, class _Elem, class _OutFn>
+        bool _Loop(const _Elem* const _Src, const _Elem* _Src_end, const typename _Traits::_Vec _Dx0,
+            const typename _Traits::_Vec _Dx1, _OutFn _Out) noexcept {
+            for (;;) {
+                typename _Traits::_Vec _Val;
+                constexpr size_t _Per_vec = sizeof(_Val) / sizeof(_Elem);
+
+                if (const size_t _Left = _Src_end - _Src; _Left >= _Per_vec) {
+                    _Src_end -= _Per_vec;
+                    _Val = _Traits::_Load(_Src_end);
+                } else if (_Left == 0) {
+                    return true;
+                } else {
+                    _Src_end = _Src;
+                    _Elem _Tmp[_Per_vec];
+                    _Traits::_Store(_Tmp, _Dx0);
+                    _Elem* const _Tmpd = _Tmp + (_Per_vec - _Left);
+                    memcpy(_Tmpd, _Src_end, _Left * sizeof(_Elem));
+                    _Val = _Traits::_Load(_Tmp);
+                }
+
+                const auto _Ex1 = _Traits::_Cmp(_Val, _Dx1);
+
+                if (!_Traits::_Check(_Val, _Ex1, _Dx0)) {
+                    return false;
+                }
+
+                _Out(_Ex1);
+            }
+        }
+
+        template <class _Traits, class _Elem>
+        bool _Impl(void* _Dest, const _Elem* const _Src, const size_t _Size_bytes, const size_t _Size_bits,
+            const size_t _Size_chars, const _Elem _Elem0, const _Elem _Elem1) noexcept {
+            [[maybe_unused]] typename _Traits::_Guard _Guard; // TRANSITION, DevCom-10331414
+            const auto _Dx0 = _Traits::_Set(_Elem0);
+            const auto _Dx1 = _Traits::_Set(_Elem1);
+
+            void* _Dest_end = _Dest;
+            _Advance_bytes(_Dest_end, _Size_bytes);
+
+            auto _Out = [&_Dest](const _Traits::_Vec _Ex1) {
+                const auto _Val = _Traits::_To_bits(_Ex1);
+                memcpy(_Dest, &_Val, sizeof(_Val));
+                _Advance_bytes(_Dest, sizeof(_Val));
+            };
+
+            const size_t _Size_convert = (_Size_chars <= _Size_bits) ? _Size_chars : _Size_bits;
+
+            // Convert characters to bits
+            if (!_Loop<_Traits>(_Src, _Src + _Size_convert, _Dx0, _Dx1, _Out)) {
+                return false;
+            }
+
+            // Verify remaining characters, if any
+            if (_Size_convert != _Size_chars
+                && !_Loop<_Traits>(_Src + _Size_convert, _Src + _Size_chars, _Dx0, _Dx1, [](_Traits::_Vec) {})) {
+                return false;
+            }
+
+            // Trim tail (may be padding tail, or too short string, or both)
+            if (_Dest != _Dest_end) {
+                memset(_Dest, 0, _Byte_length(_Dest, _Dest_end));
+            }
+
+            return true;
+        }
+
+        template <class _Elem>
+        bool _Fallback(void* const _Dest, const _Elem* const _Src, const size_t _Size_bytes, const size_t _Size_bits,
+            const size_t _Size_chars, const _Elem _Elem0, const _Elem _Elem1) noexcept {
+            const auto _Dest_bytes = static_cast<uint8_t*>(_Dest);
+            size_t _Size_convert   = _Size_chars;
+
+            if (_Size_chars > _Size_bits) {
+                _Size_convert = _Size_bits;
+
+                for (size_t _Ix = _Size_bits; _Ix < _Size_chars; ++_Ix) {
+                    if (const _Elem _Cur = _Src[_Ix]; _Cur != _Elem0 && _Cur != _Elem1) {
+                        return false;
+                    }
+                }
+            }
+
+            memset(_Dest, 0, _Size_bytes);
+
+            for (size_t _Ix = 0; _Ix != _Size_convert; ++_Ix) {
+                const _Elem _Cur = _Src[_Size_convert - _Ix - 1];
+
+                if (_Cur != _Elem0 && _Cur != _Elem1) {
+                    return false;
+                }
+
+                _Dest_bytes[_Ix >> 3] |= static_cast<uint8_t>(_Cur == _Elem1) << (_Ix & 0x7);
+            }
+
+            return true;
+        }
+
+#if !defined(_M_ARM64) && !defined(_M_ARM64EC)
+        template <class _Avx, class _Sse, class _Elem>
+        bool _Dispatch(void* _Dest, const _Elem* _Src, size_t _Size_bytes, size_t _Size_bits, size_t _Size_chars,
+            _Elem _Elem0, _Elem _Elem1) noexcept {
+            if (_Use_avx2() && _Size_bits >= 256) {
+                return _Impl<_Avx>(_Dest, _Src, _Size_bytes, _Size_bits, _Size_chars, _Elem0, _Elem1);
+            } else if (_Use_sse42()) {
+                return _Impl<_Sse>(_Dest, _Src, _Size_bytes, _Size_bits, _Size_chars, _Elem0, _Elem1);
+            } else {
+                return _Fallback(_Dest, _Src, _Size_bytes, _Size_bits, _Size_chars, _Elem0, _Elem1);
+            }
+        }
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+    } // namespace _Bitset_from_string
+} // unnamed namespace
+
+extern "C" {
+
+__declspec(noalias) bool __stdcall __std_bitset_from_string_1(void* const _Dest, const char* const _Src,
+    const size_t _Size_bytes, const size_t _Size_bits, const size_t _Size_chars, const char _Elem0,
+    const char _Elem1) noexcept {
+    using namespace _Bitset_from_string;
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Impl<_Traits_1_neon>(_Dest, _Src, _Size_bytes, _Size_bits, _Size_chars, _Elem0, _Elem1);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Dispatch<_Traits_1_avx, _Traits_1_sse>(_Dest, _Src, _Size_bytes, _Size_bits, _Size_chars, _Elem0, _Elem1);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+__declspec(noalias) bool __stdcall __std_bitset_from_string_2(void* const _Dest, const wchar_t* const _Src,
+    const size_t _Size_bytes, const size_t _Size_bits, const size_t _Size_chars, const wchar_t _Elem0,
+    const wchar_t _Elem1) noexcept {
+    using namespace _Bitset_from_string;
+
+#if defined(_M_ARM64) || defined(_M_ARM64EC)
+    return _Impl<_Traits_2_neon>(_Dest, _Src, _Size_bytes, _Size_bits, _Size_chars, _Elem0, _Elem1);
+#else // ^^^ defined(_M_ARM64) || defined(_M_ARM64EC) / !defined(_M_ARM64) && !defined(_M_ARM64EC) vvv
+    return _Dispatch<_Traits_2_avx, _Traits_2_sse>(_Dest, _Src, _Size_bytes, _Size_bits, _Size_chars, _Elem0, _Elem1);
+#endif // ^^^ !defined(_M_ARM64) && !defined(_M_ARM64EC) ^^^
+}
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/wcerr.cpp b/msvc-stl/stl/src/wcerr.cpp
new file mode 100644
index 0000000..41537b6
--- /dev/null
+++ b/msvc-stl/stl/src/wcerr.cpp
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard wide error stream
+
+#include <fstream>
+#include <iostream>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL static wfilebuf wferr(stderr);
+#if defined(_M_CEE_PURE)
+__PURE_APPDOMAIN_GLOBAL extern wostream wcerr(&wferr);
+#else
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream wcerr(&wferr);
+#endif
+
+struct _Init_wcerr { // ensures that wcerr is initialized
+    __CLR_OR_THIS_CALL _Init_wcerr() { // initialize wcerr
+        _Ptr_wcerr = &wcerr;
+        wcerr.tie(_Ptr_wcout);
+        wcerr.setf(ios_base::unitbuf);
+    }
+};
+__PURE_APPDOMAIN_GLOBAL static _Init_wcerr init_wcerr;
+
+_STD_END
diff --git a/msvc-stl/stl/src/wcin.cpp b/msvc-stl/stl/src/wcin.cpp
new file mode 100644
index 0000000..bc50087
--- /dev/null
+++ b/msvc-stl/stl/src/wcin.cpp
@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard wide input stream
+
+#include <fstream>
+#include <iostream>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL static wfilebuf wfin(stdin);
+#if defined(_M_CEE_PURE)
+__PURE_APPDOMAIN_GLOBAL extern wistream wcin(&wfin);
+#else
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wistream wcin(&wfin);
+#endif
+
+struct _Init_wcin { // ensures that wcin is initialized
+    __CLR_OR_THIS_CALL _Init_wcin() { // initialize wcin
+        _Ptr_wcin = &wcin;
+        wcin.tie(_Ptr_wcout);
+    }
+};
+__PURE_APPDOMAIN_GLOBAL static _Init_wcin init_wcin;
+
+_STD_END
diff --git a/msvc-stl/stl/src/wclog.cpp b/msvc-stl/stl/src/wclog.cpp
new file mode 100644
index 0000000..3ac05b1
--- /dev/null
+++ b/msvc-stl/stl/src/wclog.cpp
@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard wide log stream
+
+#include <fstream>
+#include <iostream>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL static wfilebuf wflog(stderr);
+#if defined(_M_CEE_PURE)
+__PURE_APPDOMAIN_GLOBAL extern wostream wclog(&wflog);
+#else
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream wclog(&wflog);
+#endif
+
+struct _Init_wclog { // ensures that wclog is initialized
+    __CLR_OR_THIS_CALL _Init_wclog() { // initialize wclog
+        _Ptr_wclog = &wclog;
+    }
+};
+__PURE_APPDOMAIN_GLOBAL static _Init_wclog init_wclog;
+
+_STD_END
diff --git a/msvc-stl/stl/src/wcout.cpp b/msvc-stl/stl/src/wcout.cpp
new file mode 100644
index 0000000..c969398
--- /dev/null
+++ b/msvc-stl/stl/src/wcout.cpp
@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// initialize standard wide output stream
+
+#include <fstream>
+#include <iostream>
+
+#include "init_locks.hpp"
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+static std::_Init_locks initlocks;
+
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL static wfilebuf wfout(stdout);
+#if defined(_M_CEE_PURE)
+__PURE_APPDOMAIN_GLOBAL extern wostream wcout(&wfout);
+#else
+__PURE_APPDOMAIN_GLOBAL extern _CRTDATA2_IMPORT wostream wcout(&wfout);
+#endif
+
+struct _Init_wcout { // ensures that wcout is initialized
+    __CLR_OR_THIS_CALL _Init_wcout() { // initialize wcout
+        _Ptr_wcout = &wcout;
+        if (_Ptr_wcin != nullptr) {
+            _Ptr_wcin->tie(_Ptr_wcout);
+        }
+
+        if (_Ptr_wcerr != nullptr) {
+            _Ptr_wcerr->tie(_Ptr_wcout);
+        }
+    }
+};
+__PURE_APPDOMAIN_GLOBAL static _Init_wcout init_wcout;
+
+_STD_END
diff --git a/msvc-stl/stl/src/winapinls.cpp b/msvc-stl/stl/src/winapinls.cpp
new file mode 100644
index 0000000..9d8227c
--- /dev/null
+++ b/msvc-stl/stl/src/winapinls.cpp
@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Previously, x64/x86 Desktop builds had to support targeting old versions of Windows, so we dllexported functions to
+// dynamically load new Windows APIs. Now, we directly call those Windows APIs, and the dllexported functions have
+// become simple wrappers, but they still need to be preserved for binary compatibility. The ARM64, App, and OneCore
+// builds never supported targeting old versions of Windows, so they never provided these dllexported functions.
+#if !(defined(_M_ARM64) || defined(_CRT_APP) || defined(_ONECORE))
+
+#include <yvals.h>
+
+#include <Windows.h>
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 int __cdecl __crtCompareStringEx(_In_opt_ LPCWSTR lpLocaleName, _In_ DWORD dwCmpFlags,
+    _In_NLS_string_(cchCount1) LPCWSTR lpString1, _In_ int cchCount1, _In_NLS_string_(cchCount2) LPCWSTR lpString2,
+    _In_ int cchCount2) noexcept {
+    return CompareStringEx(lpLocaleName, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2, nullptr, nullptr, 0);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 int __cdecl __crtLCMapStringEx(_In_opt_ LPCWSTR lpLocaleName, _In_ DWORD dwMapFlags,
+    _In_reads_(cchSrc) LPCWSTR lpSrcStr, _In_ int cchSrc, _Out_writes_opt_(cchDest) LPWSTR lpDestStr,
+    _In_ int cchDest) noexcept {
+    return LCMapStringEx(lpLocaleName, dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest, nullptr, nullptr, 0);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 int __cdecl __crtGetLocaleInfoEx(_In_opt_ LPCWSTR const lpLocaleName, _In_ LCTYPE const LCType,
+    _Out_writes_opt_(cchData) LPWSTR const lpLCData, _In_ int const cchData) noexcept {
+    return GetLocaleInfoEx(lpLocaleName, LCType, lpLCData, cchData);
+}
+
+#endif // ^^^ !(defined(_M_ARM64) || defined(_CRT_APP) || defined(_ONECORE)) ^^^
diff --git a/msvc-stl/stl/src/winapisupp.cpp b/msvc-stl/stl/src/winapisupp.cpp
new file mode 100644
index 0000000..33c0f88
--- /dev/null
+++ b/msvc-stl/stl/src/winapisupp.cpp
@@ -0,0 +1,178 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <yvals.h>
+
+#include <cstdlib>
+#include <internal_shared.h>
+
+#include <Windows.h>
+
+namespace {
+
+// Use this macro for defining the following function pointers
+#define DEFINEFUNCTIONPOINTER(fn_name) decltype(&fn_name) __KERNEL32Function_##fn_name = nullptr
+
+    DEFINEFUNCTIONPOINTER(GetTempPath2W);
+
+// Use this macro for caching a function pointer from a DLL
+#define STOREFUNCTIONPOINTER(instance, fn_name) \
+    __KERNEL32Function_##fn_name = reinterpret_cast<decltype(&fn_name)>(GetProcAddress(instance, #fn_name))
+
+// Use this macro for retrieving a cached function pointer from a DLL
+#define IFDYNAMICGETCACHEDFUNCTION(fn_name) if (const auto pf##fn_name = __KERNEL32Function_##fn_name)
+
+} // unnamed namespace
+
+#if !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 BOOL __cdecl __crtIsPackagedApp() noexcept {
+    return FALSE;
+}
+
+#endif // !defined(_CRT_WINDOWS) && !defined(UNDOCKED_WINDOWS_UCRT)
+
+// Previously, x64/x86 Desktop builds had to support targeting old versions of Windows, so we dllexported functions to
+// dynamically load new Windows APIs. Now, we directly call those Windows APIs, and the dllexported functions have
+// become simple wrappers, but they still need to be preserved for binary compatibility. The ARM64, App, and OneCore
+// builds never supported targeting old versions of Windows, so they never provided these dllexported functions.
+#if !(defined(_M_ARM64) || defined(_CRT_APP) || defined(_ONECORE))
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 ULONGLONG __cdecl __crtGetTickCount64() noexcept {
+    return GetTickCount64();
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 BOOL __cdecl __crtInitializeCriticalSectionEx(
+    _Out_ LPCRITICAL_SECTION const lpCriticalSection, _In_ DWORD const dwSpinCount, _In_ DWORD const Flags) noexcept {
+    return InitializeCriticalSectionEx(lpCriticalSection, dwSpinCount, Flags);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 BOOL __cdecl __crtInitOnceExecuteOnce(_Inout_ PINIT_ONCE const InitOnce,
+    _In_ PINIT_ONCE_FN const InitFn, _Inout_opt_ PVOID const Parameter, LPVOID* const Context) noexcept {
+    return InitOnceExecuteOnce(InitOnce, InitFn, Parameter, Context);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 HANDLE __cdecl __crtCreateEventExW(_In_opt_ LPSECURITY_ATTRIBUTES const lpEventAttributes,
+    _In_opt_ LPCWSTR const lpName, _In_ DWORD const dwFlags, _In_ DWORD const dwDesiredAccess) noexcept {
+    return CreateEventExW(lpEventAttributes, lpName, dwFlags, dwDesiredAccess);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 HANDLE __cdecl __crtCreateSemaphoreExW(_In_opt_ LPSECURITY_ATTRIBUTES const lpSemaphoreAttributes,
+    _In_ LONG const lInitialCount, _In_ LONG const lMaximumCount, _In_opt_ LPCWSTR const lpName,
+    _Reserved_ DWORD const dwFlags, _In_ DWORD const dwDesiredAccess) noexcept {
+    return CreateSemaphoreExW(lpSemaphoreAttributes, lInitialCount, lMaximumCount, lpName, dwFlags, dwDesiredAccess);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 PTP_TIMER __cdecl __crtCreateThreadpoolTimer(_In_ PTP_TIMER_CALLBACK const pfnti,
+    _Inout_opt_ PVOID const pv, _In_opt_ PTP_CALLBACK_ENVIRON const pcbe) noexcept {
+    return CreateThreadpoolTimer(pfnti, pv, pcbe);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 VOID __cdecl __crtSetThreadpoolTimer(_Inout_ PTP_TIMER const pti,
+    _In_opt_ PFILETIME const pftDueTime, _In_ DWORD const msPeriod, _In_ DWORD const msWindowLength) noexcept {
+    SetThreadpoolTimer(pti, pftDueTime, msPeriod, msWindowLength);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 VOID __cdecl __crtWaitForThreadpoolTimerCallbacks(
+    _Inout_ PTP_TIMER const pti, _In_ BOOL const fCancelPendingCallbacks) noexcept {
+    WaitForThreadpoolTimerCallbacks(pti, fCancelPendingCallbacks);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 VOID __cdecl __crtCloseThreadpoolTimer(_Inout_ PTP_TIMER const pti) noexcept {
+    CloseThreadpoolTimer(pti);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 PTP_WAIT __cdecl __crtCreateThreadpoolWait(
+    _In_ PTP_WAIT_CALLBACK const pfnwa, _Inout_opt_ PVOID const pv, _In_opt_ PTP_CALLBACK_ENVIRON const pcbe) noexcept {
+    return CreateThreadpoolWait(pfnwa, pv, pcbe);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 VOID __cdecl __crtSetThreadpoolWait(
+    _Inout_ PTP_WAIT const pwa, _In_opt_ HANDLE const h, _In_opt_ PFILETIME const pftTimeout) noexcept {
+    SetThreadpoolWait(pwa, h, pftTimeout);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 VOID __cdecl __crtCloseThreadpoolWait(_Inout_ PTP_WAIT const pwa) noexcept {
+    CloseThreadpoolWait(pwa);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 VOID __cdecl __crtFlushProcessWriteBuffers() noexcept {
+    FlushProcessWriteBuffers();
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 VOID __cdecl __crtFreeLibraryWhenCallbackReturns(
+    _Inout_ PTP_CALLBACK_INSTANCE const pci, _In_ HMODULE const mod) noexcept {
+    FreeLibraryWhenCallbackReturns(pci, mod);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 DWORD __cdecl __crtGetCurrentProcessorNumber() noexcept {
+    return GetCurrentProcessorNumber();
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 BOOLEAN __cdecl __crtCreateSymbolicLinkW(
+    _In_ LPCWSTR const lpSymlinkFileName, _In_ LPCWSTR const lpTargetFileName, _In_ DWORD const dwFlags) noexcept {
+    return CreateSymbolicLinkW(lpSymlinkFileName, lpTargetFileName, dwFlags);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 _Success_(return) BOOL __cdecl __crtGetFileInformationByHandleEx(_In_ HANDLE const hFile,
+    _In_ FILE_INFO_BY_HANDLE_CLASS const FileInformationClass,
+    _Out_writes_bytes_(dwBufferSize) LPVOID const lpFileInformation, _In_ DWORD const dwBufferSize) noexcept {
+    return GetFileInformationByHandleEx(hFile, FileInformationClass, lpFileInformation, dwBufferSize);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 BOOL __cdecl __crtSetFileInformationByHandle(_In_ HANDLE const hFile,
+    _In_ FILE_INFO_BY_HANDLE_CLASS const FileInformationClass,
+    _In_reads_bytes_(dwBufferSize) LPVOID const lpFileInformation, _In_ DWORD const dwBufferSize) noexcept {
+    return SetFileInformationByHandle(hFile, FileInformationClass, lpFileInformation, dwBufferSize);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+extern "C" _CRTIMP2 void __cdecl __crtGetSystemTimePreciseAsFileTime(_Out_ LPFILETIME lpSystemTimeAsFileTime) noexcept {
+    GetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime);
+}
+
+#endif // ^^^ !(defined(_M_ARM64) || defined(_CRT_APP) || defined(_ONECORE)) ^^^
+
+extern "C" _Success_(return > 0 && return < BufferLength) DWORD __stdcall __crtGetTempPath2W(
+    _In_ DWORD BufferLength, _Out_writes_to_opt_(BufferLength, return +1) LPWSTR Buffer) noexcept {
+    // use GetTempPath2W if it is available (only on Windows 11+)...
+    IFDYNAMICGETCACHEDFUNCTION(GetTempPath2W) {
+        return pfGetTempPath2W(BufferLength, Buffer);
+    }
+
+    // ...otherwise use GetTempPathW.
+    return GetTempPathW(BufferLength, Buffer);
+}
+
+// Helper to load all necessary Win32 API function pointers
+static int __cdecl initialize_pointers() noexcept {
+    HINSTANCE hKernel32 = GetModuleHandleW(L"kernel32.dll");
+    _Analysis_assume_(hKernel32);
+
+    // Note that GetTempPath2W is defined as of Windows 10 Build 20348 (a server release) or Windows 11,
+    // but there is no "_WIN32_WINNT_WIN11" constant, so we will always dynamically load it
+    STOREFUNCTIONPOINTER(hKernel32, GetTempPath2W);
+
+    return 0;
+}
+
+_CRTALLOC(".CRT$XIC") static _PIFV pinit = initialize_pointers;
diff --git a/msvc-stl/stl/src/wiostrea.cpp b/msvc-stl/stl/src/wiostrea.cpp
new file mode 100644
index 0000000..5755fe1
--- /dev/null
+++ b/msvc-stl/stl/src/wiostrea.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// _Winit members
+
+#include <iostream>
+_STD_BEGIN
+
+__PURE_APPDOMAIN_GLOBAL int _Winit::_Init_cnt = -1;
+
+_CRTIMP2_PURE __thiscall _Winit::_Winit() { // initialize standard wide streams first time
+    if (0 <= _Init_cnt) {
+        ++_Init_cnt;
+    } else {
+        _Init_cnt = 1;
+    }
+}
+
+_CRTIMP2_PURE __thiscall _Winit::~_Winit() noexcept { // flush standard wide streams last time
+    if (--_Init_cnt == 0) { // flush standard wide streams
+        if (_Ptr_wcout != nullptr) {
+            _Ptr_wcout->flush();
+        }
+
+        if (_Ptr_wcerr != nullptr) {
+            _Ptr_wcerr->flush();
+        }
+
+        if (_Ptr_wclog != nullptr) {
+            _Ptr_wclog->flush();
+        }
+    }
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/wlocale.cpp b/msvc-stl/stl/src/wlocale.cpp
new file mode 100644
index 0000000..8c33f32
--- /dev/null
+++ b/msvc-stl/stl/src/wlocale.cpp
@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// class locale wide member functions
+
+#include <istream>
+#include <locale>
+_STD_BEGIN
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+
+// facets associated with C categories
+#define ADDFAC(Facet, cat, ptrimp, ptrloc)                                                                  \
+    if ((_CATMASK(Facet::_Getcat()) & cat) == 0) {                                                          \
+        ;                                                                                                   \
+    } else if (ptrloc == nullptr) {                                                                         \
+        ptrimp->_Addfac(new Facet(lobj), Facet::id._Get_index());                                           \
+    } else {                                                                                                \
+        ptrimp->_Addfac(                                                                                    \
+            const_cast<locale::facet*>(static_cast<const locale::facet*>(&_STD use_facet<Facet>(*ptrloc))), \
+            Facet::id._Get_index());                                                                        \
+    }
+
+// moved from locale to ease subsetting
+using _Tw1  = ctype<wchar_t>;
+using _Tw2  = num_get<wchar_t>;
+using _Tw3  = num_put<wchar_t>;
+using _Tw4  = numpunct<wchar_t>;
+using _Tw5  = collate<wchar_t>;
+using _Tw6  = messages<wchar_t>;
+using _Tw7  = money_get<wchar_t>;
+using _Tw8  = money_put<wchar_t>;
+using _Tw9  = moneypunct<wchar_t, false>;
+using _Tw10 = moneypunct<wchar_t, true>;
+using _Tw11 = time_get<wchar_t>;
+using _Tw12 = time_put<wchar_t>;
+using _Tw13 = codecvt<wchar_t, char, _Mbstatet>;
+__PURE_APPDOMAIN_GLOBAL locale::id time_put<wchar_t>::id{};
+
+void __CLRCALL_OR_CDECL locale::_Locimp::_Makewloc(const _Locinfo& lobj, locale::category cat, _Locimp* ptrimp,
+    const locale* ptrloc) { // setup wide part of a new locale
+    ADDFAC(_Tw1, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw2, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw3, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw4, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw5, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw6, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw7, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw8, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw9, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw10, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw11, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw12, cat, ptrimp, ptrloc);
+    ADDFAC(_Tw13, cat, ptrimp, ptrloc);
+}
+
+// moved from locale to ease subsetting
+using _Tu1  = ctype<unsigned short>;
+using _Tu2  = num_get<unsigned short>;
+using _Tu3  = num_put<unsigned short>;
+using _Tu4  = numpunct<unsigned short>;
+using _Tu5  = collate<unsigned short>;
+using _Tu6  = messages<unsigned short>;
+using _Tu7  = money_get<unsigned short>;
+using _Tu8  = money_put<unsigned short>;
+using _Tu9  = moneypunct<unsigned short, false>;
+using _Tu10 = moneypunct<unsigned short, true>;
+using _Tu11 = time_get<unsigned short>;
+using _Tu12 = time_put<unsigned short>;
+using _Tu13 = codecvt<unsigned short, char, _Mbstatet>;
+
+void __CLRCALL_OR_CDECL locale::_Locimp::_Makeushloc(const _Locinfo& lobj, locale::category cat, _Locimp* ptrimp,
+    const locale* ptrloc) { // setup wide part of a new locale
+    ADDFAC(_Tu1, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu2, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu3, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu4, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu5, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu6, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu7, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu8, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu9, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu10, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu11, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu12, cat, ptrimp, ptrloc);
+    ADDFAC(_Tu13, cat, ptrimp, ptrloc);
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/xalloc.cpp b/msvc-stl/stl/src/xalloc.cpp
new file mode 100644
index 0000000..619e2a0
--- /dev/null
+++ b/msvc-stl/stl/src/xalloc.cpp
@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// TRANSITION, ABI: The functions in this file are preserved for binary compatibility
+
+#include <yvals.h>
+
+#include <Windows.h>
+
+namespace stdext {
+    namespace threads {
+
+        _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtx_new(void*& _Ptr) {
+            _Ptr = new CRITICAL_SECTION;
+            InitializeCriticalSectionEx(static_cast<CRITICAL_SECTION*>(_Ptr), 4000, 0);
+        }
+
+        _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtx_delete(void* _Ptr) {
+            DeleteCriticalSection(static_cast<CRITICAL_SECTION*>(_Ptr));
+            delete static_cast<CRITICAL_SECTION*>(_Ptr);
+        }
+
+        _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtx_lock(void* _Ptr) {
+            EnterCriticalSection(static_cast<CRITICAL_SECTION*>(_Ptr));
+        }
+
+        _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtx_unlock(void* _Ptr) {
+            LeaveCriticalSection(static_cast<CRITICAL_SECTION*>(_Ptr));
+        }
+
+    } // namespace threads
+} // namespace stdext
diff --git a/msvc-stl/stl/src/xcharconv_ryu_tables.cpp b/msvc-stl/stl/src/xcharconv_ryu_tables.cpp
new file mode 100644
index 0000000..a9a7d6f
--- /dev/null
+++ b/msvc-stl/stl/src/xcharconv_ryu_tables.cpp
@@ -0,0 +1,4728 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception AND BSL-1.0
+
+
+// Copyright 2018 Ulf Adams
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// 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.
+
+
+#include <cstdint>
+
+namespace std {
+
+    // clang-format off: avoid diverging from external code
+
+// vvvvvvvvvv DERIVED FROM d2s_full_table.h vvvvvvvvvv
+
+// These tables are generated by PrintDoubleLookupTable.
+extern const uint64_t __DOUBLE_POW5_INV_SPLIT[292][2] = {
+  {                    1u, 288230376151711744u }, {  3689348814741910324u, 230584300921369395u },
+  {  2951479051793528259u, 184467440737095516u }, { 17118578500402463900u, 147573952589676412u },
+  { 12632330341676300947u, 236118324143482260u }, { 10105864273341040758u, 188894659314785808u },
+  { 15463389048156653253u, 151115727451828646u }, { 17362724847566824558u, 241785163922925834u },
+  { 17579528692795369969u, 193428131138340667u }, {  6684925324752475329u, 154742504910672534u },
+  { 18074578149087781173u, 247588007857076054u }, { 18149011334012135262u, 198070406285660843u },
+  {  3451162622983977240u, 158456325028528675u }, {  5521860196774363583u, 253530120045645880u },
+  {  4417488157419490867u, 202824096036516704u }, {  7223339340677503017u, 162259276829213363u },
+  {  7867994130342094503u, 259614842926741381u }, {  2605046489531765280u, 207691874341393105u },
+  {  2084037191625412224u, 166153499473114484u }, { 10713157136084480204u, 265845599156983174u },
+  { 12259874523609494487u, 212676479325586539u }, { 13497248433629505913u, 170141183460469231u },
+  { 14216899864323388813u, 272225893536750770u }, { 11373519891458711051u, 217780714829400616u },
+  {  5409467098425058518u, 174224571863520493u }, {  4965798542738183305u, 278759314981632789u },
+  {  7661987648932456967u, 223007451985306231u }, {  2440241304404055250u, 178405961588244985u },
+  {  3904386087046488400u, 285449538541191976u }, { 17880904128604832013u, 228359630832953580u },
+  { 14304723302883865611u, 182687704666362864u }, { 15133127457049002812u, 146150163733090291u },
+  { 16834306301794583852u, 233840261972944466u }, {  9778096226693756759u, 187072209578355573u },
+  { 15201174610838826053u, 149657767662684458u }, {  2185786488890659746u, 239452428260295134u },
+  {  5437978005854438120u, 191561942608236107u }, { 15418428848909281466u, 153249554086588885u },
+  {  6222742084545298729u, 245199286538542217u }, { 16046240111861969953u, 196159429230833773u },
+  {  1768945645263844993u, 156927543384667019u }, { 10209010661905972635u, 251084069415467230u },
+  {  8167208529524778108u, 200867255532373784u }, { 10223115638361732810u, 160693804425899027u },
+  {  1599589762411131202u, 257110087081438444u }, {  4969020624670815285u, 205688069665150755u },
+  {  3975216499736652228u, 164550455732120604u }, { 13739044029062464211u, 263280729171392966u },
+  {  7301886408508061046u, 210624583337114373u }, { 13220206756290269483u, 168499666669691498u },
+  { 17462981995322520850u, 269599466671506397u }, {  6591687966774196033u, 215679573337205118u },
+  { 12652048002903177473u, 172543658669764094u }, {  9175230360419352987u, 276069853871622551u },
+  {  3650835473593572067u, 220855883097298041u }, { 17678063637842498946u, 176684706477838432u },
+  { 13527506561580357021u, 282695530364541492u }, {  3443307619780464970u, 226156424291633194u },
+  {  6443994910566282300u, 180925139433306555u }, {  5155195928453025840u, 144740111546645244u },
+  { 15627011115008661990u, 231584178474632390u }, { 12501608892006929592u, 185267342779705912u },
+  {  2622589484121723027u, 148213874223764730u }, {  4196143174594756843u, 237142198758023568u },
+  { 10735612169159626121u, 189713759006418854u }, { 12277838550069611220u, 151771007205135083u },
+  { 15955192865369467629u, 242833611528216133u }, {  1696107848069843133u, 194266889222572907u },
+  { 12424932722681605476u, 155413511378058325u }, {  1433148282581017146u, 248661618204893321u },
+  { 15903913885032455010u, 198929294563914656u }, {  9033782293284053685u, 159143435651131725u },
+  { 14454051669254485895u, 254629497041810760u }, { 11563241335403588716u, 203703597633448608u },
+  { 16629290697806691620u, 162962878106758886u }, {   781423413297334329u, 260740604970814219u },
+  {  4314487545379777786u, 208592483976651375u }, {  3451590036303822229u, 166873987181321100u },
+  {  5522544058086115566u, 266998379490113760u }, {  4418035246468892453u, 213598703592091008u },
+  { 10913125826658934609u, 170878962873672806u }, { 10082303693170474728u, 273406340597876490u },
+  {  8065842954536379782u, 218725072478301192u }, { 17520720807854834795u, 174980057982640953u },
+  {  5897060404116273733u, 279968092772225526u }, {  1028299508551108663u, 223974474217780421u },
+  { 15580034865808528224u, 179179579374224336u }, { 17549358155809824511u, 286687326998758938u },
+  {  2971440080422128639u, 229349861599007151u }, { 17134547323305344204u, 183479889279205720u },
+  { 13707637858644275364u, 146783911423364576u }, { 14553522944347019935u, 234854258277383322u },
+  {  4264120725993795302u, 187883406621906658u }, { 10789994210278856888u, 150306725297525326u },
+  {  9885293106962350374u, 240490760476040522u }, {   529536856086059653u, 192392608380832418u },
+  {  7802327114352668369u, 153914086704665934u }, {  1415676938738538420u, 246262538727465495u },
+  {  1132541550990830736u, 197010030981972396u }, { 15663428499760305882u, 157608024785577916u },
+  { 17682787970132668764u, 252172839656924666u }, { 10456881561364224688u, 201738271725539733u },
+  { 15744202878575200397u, 161390617380431786u }, { 17812026976236499989u, 258224987808690858u },
+  {  3181575136763469022u, 206579990246952687u }, { 13613306553636506187u, 165263992197562149u },
+  { 10713244041592678929u, 264422387516099439u }, { 12259944048016053467u, 211537910012879551u },
+  {  6118606423670932450u, 169230328010303641u }, {  2411072648389671274u, 270768524816485826u },
+  { 16686253377679378312u, 216614819853188660u }, { 13349002702143502650u, 173291855882550928u },
+  { 17669055508687693916u, 277266969412081485u }, { 14135244406950155133u, 221813575529665188u },
+  {   240149081334393137u, 177450860423732151u }, { 11452284974360759988u, 283921376677971441u },
+  {  5472479164746697667u, 227137101342377153u }, { 11756680961281178780u, 181709681073901722u },
+  {  2026647139541122378u, 145367744859121378u }, { 18000030682233437097u, 232588391774594204u },
+  { 18089373360528660001u, 186070713419675363u }, {  3403452244197197031u, 148856570735740291u },
+  { 16513570034941246220u, 238170513177184465u }, { 13210856027952996976u, 190536410541747572u },
+  {  3189987192878576934u, 152429128433398058u }, {  1414630693863812771u, 243886605493436893u },
+  {  8510402184574870864u, 195109284394749514u }, { 10497670562401807014u, 156087427515799611u },
+  {  9417575270359070576u, 249739884025279378u }, { 14912757845771077107u, 199791907220223502u },
+  {  4551508647133041040u, 159833525776178802u }, { 10971762650154775986u, 255733641241886083u },
+  { 16156107749607641435u, 204586912993508866u }, {  9235537384944202825u, 163669530394807093u },
+  { 11087511001168814197u, 261871248631691349u }, { 12559357615676961681u, 209496998905353079u },
+  { 13736834907283479668u, 167597599124282463u }, { 18289587036911657145u, 268156158598851941u },
+  { 10942320814787415393u, 214524926879081553u }, { 16132554281313752961u, 171619941503265242u },
+  { 11054691591134363444u, 274591906405224388u }, { 16222450902391311402u, 219673525124179510u },
+  { 12977960721913049122u, 175738820099343608u }, { 17075388340318968271u, 281182112158949773u },
+  {  2592264228029443648u, 224945689727159819u }, {  5763160197165465241u, 179956551781727855u },
+  {  9221056315464744386u, 287930482850764568u }, { 14755542681855616155u, 230344386280611654u },
+  { 15493782960226403247u, 184275509024489323u }, {  1326979923955391628u, 147420407219591459u },
+  {  9501865507812447252u, 235872651551346334u }, { 11290841220991868125u, 188698121241077067u },
+  {  1653975347309673853u, 150958496992861654u }, { 10025058185179298811u, 241533595188578646u },
+  {  4330697733401528726u, 193226876150862917u }, { 14532604630946953951u, 154581500920690333u },
+  {  1116074521063664381u, 247330401473104534u }, {  4582208431592841828u, 197864321178483627u },
+  { 14733813189500004432u, 158291456942786901u }, { 16195403473716186445u, 253266331108459042u },
+  {  5577625149489128510u, 202613064886767234u }, {  8151448934333213131u, 162090451909413787u },
+  { 16731667109675051333u, 259344723055062059u }, { 17074682502481951390u, 207475778444049647u },
+  {  6281048372501740465u, 165980622755239718u }, {  6360328581260874421u, 265568996408383549u },
+  {  8777611679750609860u, 212455197126706839u }, { 10711438158542398211u, 169964157701365471u },
+  {  9759603424184016492u, 271942652322184754u }, { 11497031554089123517u, 217554121857747803u },
+  { 16576322872755119460u, 174043297486198242u }, { 11764721337440549842u, 278469275977917188u },
+  { 16790474699436260520u, 222775420782333750u }, { 13432379759549008416u, 178220336625867000u },
+  {  3045063541568861850u, 285152538601387201u }, { 17193446092222730773u, 228122030881109760u },
+  { 13754756873778184618u, 182497624704887808u }, { 18382503128506368341u, 145998099763910246u },
+  {  3586563302416817083u, 233596959622256395u }, {  2869250641933453667u, 186877567697805116u },
+  { 17052795772514404226u, 149502054158244092u }, { 12527077977055405469u, 239203286653190548u },
+  { 17400360011128145022u, 191362629322552438u }, {  2852241564676785048u, 153090103458041951u },
+  { 15631632947708587046u, 244944165532867121u }, {  8815957543424959314u, 195955332426293697u },
+  { 18120812478965698421u, 156764265941034957u }, { 14235904707377476180u, 250822825505655932u },
+  {  4010026136418160298u, 200658260404524746u }, { 17965416168102169531u, 160526608323619796u },
+  {  2919224165770098987u, 256842573317791675u }, {  2335379332616079190u, 205474058654233340u },
+  {  1868303466092863352u, 164379246923386672u }, {  6678634360490491686u, 263006795077418675u },
+  {  5342907488392393349u, 210405436061934940u }, {  4274325990713914679u, 168324348849547952u },
+  { 10528270399884173809u, 269318958159276723u }, { 15801313949391159694u, 215455166527421378u },
+  {  1573004715287196786u, 172364133221937103u }, { 17274202803427156150u, 275782613155099364u },
+  { 17508711057483635243u, 220626090524079491u }, { 10317620031244997871u, 176500872419263593u },
+  { 12818843235250086271u, 282401395870821749u }, { 13944423402941979340u, 225921116696657399u },
+  { 14844887537095493795u, 180736893357325919u }, { 15565258844418305359u, 144589514685860735u },
+  {  6457670077359736959u, 231343223497377177u }, { 16234182506113520537u, 185074578797901741u },
+  {  9297997190148906106u, 148059663038321393u }, { 11187446689496339446u, 236895460861314229u },
+  { 12639306166338981880u, 189516368689051383u }, { 17490142562555006151u, 151613094951241106u },
+  {  2158786396894637579u, 242580951921985771u }, { 16484424376483351356u, 194064761537588616u },
+  {  9498190686444770762u, 155251809230070893u }, { 11507756283569722895u, 248402894768113429u },
+  { 12895553841597688639u, 198722315814490743u }, { 17695140702761971558u, 158977852651592594u },
+  { 17244178680193423523u, 254364564242548151u }, { 10105994129412828495u, 203491651394038521u },
+  {  4395446488788352473u, 162793321115230817u }, { 10722063196803274280u, 260469313784369307u },
+  {  1198952927958798777u, 208375451027495446u }, { 15716557601334680315u, 166700360821996356u },
+  { 17767794532651667857u, 266720577315194170u }, { 14214235626121334286u, 213376461852155336u },
+  {  7682039686155157106u, 170701169481724269u }, {  1223217053622520399u, 273121871170758831u },
+  { 15735968901865657612u, 218497496936607064u }, { 16278123936234436413u, 174797997549285651u },
+  {   219556594781725998u, 279676796078857043u }, {  7554342905309201445u, 223741436863085634u },
+  {  9732823138989271479u, 178993149490468507u }, {   815121763415193074u, 286389039184749612u },
+  { 11720143854957885429u, 229111231347799689u }, { 13065463898708218666u, 183288985078239751u },
+  {  6763022304224664610u, 146631188062591801u }, {  3442138057275642729u, 234609900900146882u },
+  { 13821756890046245153u, 187687920720117505u }, { 11057405512036996122u, 150150336576094004u },
+  {  6623802375033462826u, 240240538521750407u }, { 16367088344252501231u, 192192430817400325u },
+  { 13093670675402000985u, 153753944653920260u }, {  2503129006933649959u, 246006311446272417u },
+  { 13070549649772650937u, 196805049157017933u }, { 17835137349301941396u, 157444039325614346u },
+  {  2710778055689733971u, 251910462920982955u }, {  2168622444551787177u, 201528370336786364u },
+  {  5424246770383340065u, 161222696269429091u }, {  1300097203129523457u, 257956314031086546u },
+  { 15797473021471260058u, 206365051224869236u }, {  8948629602435097724u, 165092040979895389u },
+  {  3249760919670425388u, 264147265567832623u }, {  9978506365220160957u, 211317812454266098u },
+  { 15361502721659949412u, 169054249963412878u }, {  2442311466204457120u, 270486799941460606u },
+  { 16711244431931206989u, 216389439953168484u }, { 17058344360286875914u, 173111551962534787u },
+  { 12535955717491360170u, 276978483140055660u }, { 10028764573993088136u, 221582786512044528u },
+  { 15401709288678291155u, 177266229209635622u }, {  9885339602917624555u, 283625966735416996u },
+  {  4218922867592189321u, 226900773388333597u }, { 14443184738299482427u, 181520618710666877u },
+  {  4175850161155765295u, 145216494968533502u }, { 10370709072591134795u, 232346391949653603u },
+  { 15675264887556728482u, 185877113559722882u }, {  5161514280561562140u, 148701690847778306u },
+  {   879725219414678777u, 237922705356445290u }, {   703780175531743021u, 190338164285156232u },
+  { 11631070584651125387u, 152270531428124985u }, {   162968861732249003u, 243632850284999977u },
+  { 11198421533611530172u, 194906280227999981u }, {  5269388412147313814u, 155925024182399985u },
+  {  8431021459435702103u, 249480038691839976u }, {  3055468352806651359u, 199584030953471981u },
+  { 17201769941212962380u, 159667224762777584u }, { 16454785461715008838u, 255467559620444135u },
+  { 13163828369372007071u, 204374047696355308u }, { 17909760324981426303u, 163499238157084246u },
+  {  2830174816776909822u, 261598781051334795u }, {  2264139853421527858u, 209279024841067836u },
+  { 16568707141704863579u, 167423219872854268u }, {  4373838538276319787u, 267877151796566830u },
+  {  3499070830621055830u, 214301721437253464u }, {  6488605479238754987u, 171441377149802771u },
+  {  3003071137298187333u, 274306203439684434u }, {  6091805724580460189u, 219444962751747547u },
+  { 15941491023890099121u, 175555970201398037u }, { 10748990379256517301u, 280889552322236860u },
+  {  8599192303405213841u, 224711641857789488u }, { 14258051472207991719u, 179769313486231590u }
+};
+
+extern const uint64_t __DOUBLE_POW5_SPLIT[326][2] = {
+  {                    0u,  72057594037927936u }, {                    0u,  90071992547409920u },
+  {                    0u, 112589990684262400u }, {                    0u, 140737488355328000u },
+  {                    0u,  87960930222080000u }, {                    0u, 109951162777600000u },
+  {                    0u, 137438953472000000u }, {                    0u,  85899345920000000u },
+  {                    0u, 107374182400000000u }, {                    0u, 134217728000000000u },
+  {                    0u,  83886080000000000u }, {                    0u, 104857600000000000u },
+  {                    0u, 131072000000000000u }, {                    0u,  81920000000000000u },
+  {                    0u, 102400000000000000u }, {                    0u, 128000000000000000u },
+  {                    0u,  80000000000000000u }, {                    0u, 100000000000000000u },
+  {                    0u, 125000000000000000u }, {                    0u,  78125000000000000u },
+  {                    0u,  97656250000000000u }, {                    0u, 122070312500000000u },
+  {                    0u,  76293945312500000u }, {                    0u,  95367431640625000u },
+  {                    0u, 119209289550781250u }, {  4611686018427387904u,  74505805969238281u },
+  { 10376293541461622784u,  93132257461547851u }, {  8358680908399640576u, 116415321826934814u },
+  {   612489549322387456u,  72759576141834259u }, { 14600669991935148032u,  90949470177292823u },
+  { 13639151471491547136u, 113686837721616029u }, {  3213881284082270208u, 142108547152020037u },
+  {  4314518811765112832u,  88817841970012523u }, {   781462496279003136u, 111022302462515654u },
+  { 10200200157203529728u, 138777878078144567u }, { 13292654125893287936u,  86736173798840354u },
+  {  7392445620511834112u, 108420217248550443u }, {  4628871007212404736u, 135525271560688054u },
+  { 16728102434789916672u,  84703294725430033u }, {  7075069988205232128u, 105879118406787542u },
+  { 18067209522111315968u, 132348898008484427u }, {  8986162942105878528u,  82718061255302767u },
+  {  6621017659204960256u, 103397576569128459u }, {  3664586055578812416u, 129246970711410574u },
+  { 16125424340018921472u,  80779356694631608u }, {  1710036351314100224u, 100974195868289511u },
+  { 15972603494424788992u, 126217744835361888u }, {  9982877184015493120u,  78886090522101180u },
+  { 12478596480019366400u,  98607613152626475u }, { 10986559581596820096u, 123259516440783094u },
+  {  2254913720070624656u,  77037197775489434u }, { 12042014186943056628u,  96296497219361792u },
+  { 15052517733678820785u, 120370621524202240u }, {  9407823583549262990u,  75231638452626400u },
+  { 11759779479436578738u,  94039548065783000u }, { 14699724349295723422u, 117549435082228750u },
+  {  4575641699882439235u,  73468396926392969u }, { 10331238143280436948u,  91835496157991211u },
+  {  8302361660673158281u, 114794370197489014u }, {  1154580038986672043u, 143492962746861268u },
+  {  9944984561221445835u,  89683101716788292u }, { 12431230701526807293u, 112103877145985365u },
+  {  1703980321626345405u, 140129846432481707u }, { 17205888765512323542u,  87581154020301066u },
+  { 12283988920035628619u, 109476442525376333u }, {  1519928094762372062u, 136845553156720417u },
+  { 12479170105294952299u,  85528470722950260u }, { 15598962631618690374u, 106910588403687825u },
+  {  5663645234241199255u, 133638235504609782u }, { 17374836326682913246u,  83523897190381113u },
+  {  7883487353071477846u, 104404871487976392u }, {  9854359191339347308u, 130506089359970490u },
+  { 10770660513014479971u,  81566305849981556u }, { 13463325641268099964u, 101957882312476945u },
+  {  2994098996302961243u, 127447352890596182u }, { 15706369927971514489u,  79654595556622613u },
+  {  5797904354682229399u,  99568244445778267u }, {  2635694424925398845u, 124460305557222834u },
+  {  6258995034005762182u,  77787690973264271u }, {  3212057774079814824u,  97234613716580339u },
+  { 17850130272881932242u, 121543267145725423u }, { 18073860448192289507u,  75964541966078389u },
+  {  8757267504958198172u,  94955677457597987u }, {  6334898362770359811u, 118694596821997484u },
+  { 13182683513586250689u,  74184123013748427u }, { 11866668373555425458u,  92730153767185534u },
+  {  5609963430089506015u, 115912692208981918u }, { 17341285199088104971u,  72445432630613698u },
+  { 12453234462005355406u,  90556790788267123u }, { 10954857059079306353u, 113195988485333904u },
+  { 13693571323849132942u, 141494985606667380u }, { 17781854114260483896u,  88434366004167112u },
+  {  3780573569116053255u, 110542957505208891u }, {   114030942967678664u, 138178696881511114u },
+  {  4682955357782187069u,  86361685550944446u }, { 15077066234082509644u, 107952106938680557u },
+  {  5011274737320973344u, 134940133673350697u }, { 14661261756894078100u,  84337583545844185u },
+  {  4491519140835433913u, 105421979432305232u }, {  5614398926044292391u, 131777474290381540u },
+  { 12732371365632458552u,  82360921431488462u }, {  6692092170185797382u, 102951151789360578u },
+  { 17588487249587022536u, 128688939736700722u }, { 15604490549419276989u,  80430587335437951u },
+  { 14893927168346708332u, 100538234169297439u }, { 14005722942005997511u, 125672792711621799u },
+  { 15671105866394830300u,  78545495444763624u }, {  1142138259283986260u,  98181869305954531u },
+  { 15262730879387146537u, 122727336632443163u }, {  7233363790403272633u,  76704585395276977u },
+  { 13653390756431478696u,  95880731744096221u }, {  3231680390257184658u, 119850914680120277u },
+  {  4325643253124434363u,  74906821675075173u }, { 10018740084832930858u,  93633527093843966u },
+  {  3300053069186387764u, 117041908867304958u }, { 15897591223523656064u,  73151193042065598u },
+  { 10648616992549794273u,  91438991302581998u }, {  4087399203832467033u, 114298739128227498u },
+  { 14332621041645359599u, 142873423910284372u }, { 18181260187883125557u,  89295889943927732u },
+  {  4279831161144355331u, 111619862429909666u }, { 14573160988285219972u, 139524828037387082u },
+  { 13719911636105650386u,  87203017523366926u }, {  7926517508277287175u, 109003771904208658u },
+  {   684774848491833161u, 136254714880260823u }, {  7345513307948477581u,  85159196800163014u },
+  { 18405263671790372785u, 106448996000203767u }, { 18394893571310578077u, 133061245000254709u },
+  { 13802651491282805250u,  83163278125159193u }, {  3418256308821342851u, 103954097656448992u },
+  {  4272820386026678563u, 129942622070561240u }, {  2670512741266674102u,  81214138794100775u },
+  { 17173198981865506339u, 101517673492625968u }, {  3019754653622331308u, 126897091865782461u },
+  {  4193189667727651020u,  79310682416114038u }, { 14464859121514339583u,  99138353020142547u },
+  { 13469387883465536574u, 123922941275178184u }, {  8418367427165960359u,  77451838296986365u },
+  { 15134645302384838353u,  96814797871232956u }, {   471562554271496325u, 121018497339041196u },
+  {  9518098633274461011u,  75636560836900747u }, {  7285937273165688360u,  94545701046125934u },
+  { 18330793628311886258u, 118182126307657417u }, {  4539216990053847055u,  73863828942285886u },
+  { 14897393274422084627u,  92329786177857357u }, {  4786683537745442072u, 115412232722321697u },
+  { 14520892257159371055u,  72132645451451060u }, { 18151115321449213818u,  90165806814313825u },
+  {  8853836096529353561u, 112707258517892282u }, {  1843923083806916143u, 140884073147365353u },
+  { 12681666973447792349u,  88052545717103345u }, {  2017025661527576725u, 110065682146379182u },
+  { 11744654113764246714u, 137582102682973977u }, {   422879793461572340u,  85988814176858736u },
+  {   528599741826965425u, 107486017721073420u }, {   660749677283706782u, 134357522151341775u },
+  {  7330497575943398595u,  83973451344588609u }, { 13774807988356636147u, 104966814180735761u },
+  {  3383451930163631472u, 131208517725919702u }, { 15949715511634433382u,  82005323578699813u },
+  {  6102086334260878016u, 102506654473374767u }, {  3015921899398709616u, 128133318091718459u },
+  { 18025852251620051174u,  80083323807324036u }, {  4085571240815512351u, 100104154759155046u },
+  { 14330336087874166247u, 125130193448943807u }, { 15873989082562435760u,  78206370905589879u },
+  { 15230800334775656796u,  97757963631987349u }, {  5203442363187407284u, 122197454539984187u },
+  {   946308467778435600u,  76373409087490117u }, {  5794571603150432404u,  95466761359362646u },
+  { 16466586540792816313u, 119333451699203307u }, {  7985773578781816244u,  74583407312002067u },
+  {  5370530955049882401u,  93229259140002584u }, {  6713163693812353001u, 116536573925003230u },
+  { 18030785363914884337u,  72835358703127018u }, { 13315109668038829614u,  91044198378908773u },
+  {  2808829029766373305u, 113805247973635967u }, { 17346094342490130344u, 142256559967044958u },
+  {  6229622945628943561u,  88910349979403099u }, {  3175342663608791547u, 111137937474253874u },
+  { 13192550366365765242u, 138922421842817342u }, {  3633657960551215372u,  86826513651760839u },
+  { 18377130505971182927u, 108533142064701048u }, {  4524669058754427043u, 135666427580876311u },
+  {  9745447189362598758u,  84791517238047694u }, {  2958436949848472639u, 105989396547559618u },
+  { 12921418224165366607u, 132486745684449522u }, { 12687572408530742033u,  82804216052780951u },
+  { 11247779492236039638u, 103505270065976189u }, {   224666310012885835u, 129381587582470237u },
+  {  2446259452971747599u,  80863492239043898u }, { 12281196353069460307u, 101079365298804872u },
+  { 15351495441336825384u, 126349206623506090u }, { 14206370669262903769u,  78968254139691306u },
+  {  8534591299723853903u,  98710317674614133u }, { 15279925143082205283u, 123387897093267666u },
+  { 14161639232853766206u,  77117435683292291u }, { 13090363022639819853u,  96396794604115364u },
+  { 16362953778299774816u, 120495993255144205u }, { 12532689120651053212u,  75309995784465128u },
+  { 15665861400813816515u,  94137494730581410u }, { 10358954714162494836u, 117671868413226763u },
+  {  4168503687137865320u,  73544917758266727u }, {   598943590494943747u,  91931147197833409u },
+  {  5360365506546067587u, 114913933997291761u }, { 11312142901609972388u, 143642417496614701u },
+  {  9375932322719926695u,  89776510935384188u }, { 11719915403399908368u, 112220638669230235u },
+  { 10038208235822497557u, 140275798336537794u }, { 10885566165816448877u,  87672373960336121u },
+  { 18218643725697949000u, 109590467450420151u }, { 18161618638695048346u, 136988084313025189u },
+  { 13656854658398099168u,  85617552695640743u }, { 12459382304570236056u, 107021940869550929u },
+  {  1739169825430631358u, 133777426086938662u }, { 14922039196176308311u,  83610891304336663u },
+  { 14040862976792997485u, 104513614130420829u }, {  3716020665709083144u, 130642017663026037u },
+  {  4628355925281870917u,  81651261039391273u }, { 10397130925029726550u, 102064076299239091u },
+  {  8384727637859770284u, 127580095374048864u }, {  5240454773662356427u,  79737559608780540u },
+  {  6550568467077945534u,  99671949510975675u }, {  3576524565420044014u, 124589936888719594u },
+  {  6847013871814915412u,  77868710555449746u }, { 17782139376623420074u,  97335888194312182u },
+  { 13004302183924499284u, 121669860242890228u }, { 17351060901807587860u,  76043662651806392u },
+  {  3242082053549933210u,  95054578314757991u }, { 17887660622219580224u, 118818222893447488u },
+  { 11179787888887237640u,  74261389308404680u }, { 13974734861109047050u,  92826736635505850u },
+  {  8245046539531533005u, 116033420794382313u }, { 16682369133275677888u,  72520887996488945u },
+  {  7017903361312433648u,  90651109995611182u }, { 17995751238495317868u, 113313887494513977u },
+  {  8659630992836983623u, 141642359368142472u }, {  5412269370523114764u,  88526474605089045u },
+  { 11377022731581281359u, 110658093256361306u }, {  4997906377621825891u, 138322616570451633u },
+  { 14652906532082110942u,  86451635356532270u }, {  9092761128247862869u, 108064544195665338u },
+  {  2142579373455052779u, 135080680244581673u }, { 12868327154477877747u,  84425425152863545u },
+  {  2250350887815183471u, 105531781441079432u }, {  2812938609768979339u, 131914726801349290u },
+  {  6369772649532999991u,  82446704250843306u }, { 17185587848771025797u, 103058380313554132u },
+  {  3035240737254230630u, 128822975391942666u }, {  6508711479211282048u,  80514359619964166u },
+  { 17359261385868878368u, 100642949524955207u }, { 17087390713908710056u, 125803686906194009u },
+  {  3762090168551861929u,  78627304316371256u }, {  4702612710689827411u,  98284130395464070u },
+  { 15101637925217060072u, 122855162994330087u }, { 16356052730901744401u,  76784476871456304u },
+  {  1998321839917628885u,  95980596089320381u }, {  7109588318324424010u, 119975745111650476u },
+  { 13666864735807540814u,  74984840694781547u }, { 12471894901332038114u,  93731050868476934u },
+  {  6366496589810271835u, 117163813585596168u }, {  3979060368631419896u,  73227383490997605u },
+  {  9585511479216662775u,  91534229363747006u }, {  2758517312166052660u, 114417786704683758u },
+  { 12671518677062341634u, 143022233380854697u }, {  1002170145522881665u,  89388895863034186u },
+  { 10476084718758377889u, 111736119828792732u }, { 13095105898447972362u, 139670149785990915u },
+  {  5878598177316288774u,  87293843616244322u }, { 16571619758500136775u, 109117304520305402u },
+  { 11491152661270395161u, 136396630650381753u }, {   264441385652915120u,  85247894156488596u },
+  {   330551732066143900u, 106559867695610745u }, {  5024875683510067779u, 133199834619513431u },
+  { 10058076329834874218u,  83249896637195894u }, {  3349223375438816964u, 104062370796494868u },
+  {  4186529219298521205u, 130077963495618585u }, { 14145795808130045513u,  81298727184761615u },
+  { 13070558741735168987u, 101623408980952019u }, { 11726512408741573330u, 127029261226190024u },
+  {  7329070255463483331u,  79393288266368765u }, { 13773023837756742068u,  99241610332960956u },
+  { 17216279797195927585u, 124052012916201195u }, {  8454331864033760789u,  77532508072625747u },
+  {  5956228811614813082u,  96915635090782184u }, {  7445286014518516353u, 121144543863477730u },
+  {  9264989777501460624u,  75715339914673581u }, { 16192923240304213684u,  94644174893341976u },
+  {  1794409976670715490u, 118305218616677471u }, {  8039035263060279037u,  73940761635423419u },
+  {  5437108060397960892u,  92425952044279274u }, { 16019757112352226923u, 115532440055349092u },
+  {   788976158365366019u,  72207775034593183u }, { 14821278253238871236u,  90259718793241478u },
+  {  9303225779693813237u, 112824648491551848u }, { 11629032224617266546u, 141030810614439810u },
+  { 11879831158813179495u,  88144256634024881u }, {  1014730893234310657u, 110180320792531102u },
+  { 10491785653397664129u, 137725400990663877u }, {  8863209042587234033u,  86078375619164923u },
+  {  6467325284806654637u, 107597969523956154u }, { 17307528642863094104u, 134497461904945192u },
+  { 10817205401789433815u,  84060913690590745u }, { 18133192770664180173u, 105076142113238431u },
+  { 18054804944902837312u, 131345177641548039u }, { 18201782118205355176u,  82090736025967524u },
+  {  4305483574047142354u, 102613420032459406u }, { 14605226504413703751u, 128266775040574257u },
+  {  2210737537617482988u,  80166734400358911u }, { 16598479977304017447u, 100208418000448638u },
+  { 11524727934775246001u, 125260522500560798u }, {  2591268940807140847u,  78287826562850499u },
+  { 17074144231291089770u,  97859783203563123u }, { 16730994270686474309u, 122324729004453904u },
+  { 10456871419179046443u,  76452955627783690u }, {  3847717237119032246u,  95566194534729613u },
+  {  9421332564826178211u, 119457743168412016u }, {  5888332853016361382u,  74661089480257510u },
+  { 16583788103125227536u,  93326361850321887u }, { 16118049110479146516u, 116657952312902359u },
+  { 16991309721690548428u,  72911220195563974u }, { 12015765115258409727u,  91139025244454968u },
+  { 15019706394073012159u, 113923781555568710u }, {  9551260955736489391u, 142404726944460888u },
+  {  5969538097335305869u,  89002954340288055u }, {  2850236603241744433u, 111253692925360069u }
+};
+
+// ^^^^^^^^^^ DERIVED FROM d2s_full_table.h ^^^^^^^^^^
+
+// vvvvvvvvvv DERIVED FROM d2fixed_full_table.h vvvvvvvvvv
+
+extern const uint64_t __POW10_SPLIT[1224][3] = {
+  {                    1u,    72057594037927936u,                    0u },
+  {   699646928636035157u,             72057594u,                    0u },
+  {                    1u,                    0u,                  256u },
+  { 11902091922964236229u,        4722366482869u,                    0u },
+  {  6760415703743915872u,                 4722u,                    0u },
+  {                    1u,                    0u,             16777216u },
+  { 13369850649504950658u,   309485009821345068u,                    0u },
+  { 15151142278969419334u,            309485009u,                    0u },
+  {                    1u,                    0u,          75511627776u },
+  {  4635408826454083567u,  9437866644873197963u,                 1099u },
+  { 12367138975830625353u,       20282409603651u,                    0u },
+  {  7555853734021184432u,                20282u,                    0u },
+  {                    1u,                    0u,         250037927936u },
+  {  5171444645924616995u,   699646928636035156u,             72057594u },
+  { 16672297533003297786u,  1329227995784915872u,                    0u },
+  { 14479142226848862515u,           1329227995u,                    0u },
+  {                    1u,                    0u,         181645213696u },
+  { 12214193123817091081u, 11902091922964236228u,         114366482869u },
+  { 16592893013671929435u,  6760415703743915871u,                 4722u },
+  {  4549827147718617003u,       87112285931760u,                    0u },
+  {  5274510003815168971u,                87112u,                    0u },
+  {                    1u,                    0u,          44724781056u },
+  {  9794971998307800535u, 13369850649504950657u,         209821345068u },
+  { 14720142899209240169u, 15151142278969419333u,            309485009u },
+  {  4300745446091561535u,  5708990770823839524u,                    0u },
+  { 15197156861335443364u,           5708990770u,                    0u },
+  {                    1u,                    0u,         139251286016u },
+  { 13484604155038683037u,  4635408826454083566u,          67670423947u },
+  {  8356963862052375699u, 12367138975830625352u,          58409603651u },
+  {  5850852848337610021u,  7555853734021184431u,                20282u },
+  {  2712780827214982050u,      374144419156711u,                    0u },
+  {  7732076577307618052u,               374144u,                    0u },
+  {                    1u,                    0u,          84280344576u },
+  { 17296309485351745867u,  5171444645924616994u,         160903807060u },
+  { 16598859101615853088u, 16672297533003297785u,         219784915872u },
+  {  7469952526870444257u, 14479142226848862514u,           1329227995u },
+  { 13531654022114669524u,  6073184580144670117u,                    1u },
+  { 15757609704383306943u,          24519928653u,                    0u },
+  {  9590990814237149590u,                   24u,                    0u },
+  {                    1u,                    0u,         196662132736u },
+  { 15408590707489433890u, 12214193123817091080u,          95899502532u },
+  { 18332056844289122710u, 16592893013671929434u,         240246646623u },
+  { 11114572877353986193u,  4549827147718617002u,          72285931760u },
+  {  1703393793997526525u,  5274510003815168970u,                87112u },
+  {  5082852056285196265u,     1606938044258990u,                    0u },
+  {   816434266573722365u,              1606938u,                    0u },
+  {                    1u,                    0u,         129530986496u },
+  {  5736523019264798742u,  9794971998307800534u,          69797980545u },
+  { 10129314776268243339u, 14720142899209240168u,          36233143877u },
+  { 16511595775483995364u,  4300745446091561534u,          50823839524u },
+  { 12367293405401453325u, 15197156861335443363u,           5708990770u },
+  { 16934621733248854291u, 13078571300009428617u,                    5u },
+  { 10278280417769171336u,         105312291668u,                    0u },
+  {  5760764486226151240u,                  105u,                    0u },
+  {                    1u,                    0u,         238731001856u },
+  {  4128368337188369761u, 13484604155038683036u,          72453031918u },
+  { 10240941003671005056u,  8356963862052375698u,         175317175368u },
+  { 17933378316822368251u,  5850852848337610020u,         231147060143u },
+  {  8346249813075698616u,  2712780827214982049u,         128419156711u },
+  { 15906203609160902695u,  7732076577307618051u,               374144u },
+  { 14525607416135386328u,     6901746346790563u,                    0u },
+  {  6397156777364256320u,              6901746u,                    0u },
+  {                    1u,                    0u,          34937634816u },
+  { 16798760952716600048u, 17296309485351745866u,         249899825954u },
+  {  2419982808370854967u, 16598859101615853087u,          50404946937u },
+  {  2922947087773078956u,  7469952526870444256u,         165733552434u },
+  { 15419220167069510190u, 13531654022114669523u,          77854221733u },
+  {  3452124642157173416u, 15757609704383306942u,          24519928653u },
+  {  5979700067267186899u,  9590990814237149589u,                   24u },
+  {  4913998146922579597u,         452312848583u,                    0u },
+  {  5771037749337678924u,                  452u,                    0u },
+  {                    1u,                    0u,           8835301376u },
+  {  3464734175350698519u, 15408590707489433889u,          90993782792u },
+  {  9334527711335850125u, 18332056844289122709u,         170602522202u },
+  {  7269882896518450106u, 11114572877353986192u,         202092341162u },
+  {  1372511258182263196u,  1703393793997526524u,         174275541962u },
+  {  7571228438575951046u,  5082852056285196264u,          26044258990u },
+  {  2992506536646070406u,   816434266573722364u,              1606938u },
+  {   524517896824344606u,    29642774844752946u,                    0u },
+  { 15582941400898702773u,             29642774u,                    0u },
+  {                    1u,                    0u,         214310977536u },
+  {  3846112492507251066u,  5736523019264798741u,         104549111254u },
+  { 16681117750123089487u, 10129314776268243338u,          62895095400u },
+  { 14986314536556547267u, 16511595775483995363u,         163670432318u },
+  {  2573712825027107389u, 12367293405401453324u,         137918027683u },
+  {  7504855874008324928u, 16934621733248854290u,          84557186697u },
+  {  9572138030626879787u, 10278280417769171335u,         105312291668u },
+  {  8520676959353394843u,  5760764486226151239u,                  105u },
+  { 13448984662897903496u,        1942668892225u,                    0u },
+  { 12338883700918130648u,                 1942u,                    0u },
+  {                    1u,                    0u,         156223799296u },
+  {  2517285787892561600u,  4128368337188369760u,         146555162524u },
+  {  4338831817635138103u, 10240941003671005055u,          36972170386u },
+  {  1561495325934523196u, 17933378316822368250u,         161452451108u },
+  { 12262635050079398786u,  8346249813075698615u,           3862277025u },
+  { 11144065765517284188u, 15906203609160902694u,         163787434755u },
+  {  1212260522471875711u, 14525607416135386327u,         242346790563u },
+  {  9695352922247418869u,  6397156777364256319u,              6901746u },
+  {  7227025834627242948u,   127314748520905380u,                    0u },
+  {  9609008238705447829u,            127314748u,                    0u },
+  {                    1u,                    0u,          74910662656u },
+  {  3609144142396852269u, 16798760952716600047u,          31131187530u },
+  { 11568848377382068865u,  2419982808370854966u,         224158453279u },
+  { 10068303578029323957u,  2922947087773078955u,         211835877600u },
+  { 11645070846862630231u, 15419220167069510189u,         190187140051u },
+  { 12449386705878485055u,  3452124642157173415u,         149324160190u },
+  { 15025619323517318418u,  5979700067267186898u,         199266388373u },
+  { 14996237555047131272u,  4913998146922579596u,         196312848583u },
+  { 10211005638256058413u,  5771037749337678923u,                  452u },
+  {  1014743503555840530u,        8343699359066u,                    0u },
+  { 12900897707145290678u,                 8343u,                    0u },
+  {                    1u,                    0u,          33187823616u },
+  {  4718003016239473662u,  3464734175350698518u,         149506025761u },
+  { 14865830648693666725u,  9334527711335850124u,         144394101141u },
+  { 14754517212823091778u,  7269882896518450105u,         252074403984u },
+  { 11113946551474911901u,  1372511258182263195u,         232410437116u },
+  {  1963520352638130630u,  7571228438575951045u,         252162224104u },
+  { 13342587341404964200u,  2992506536646070405u,          50028434172u },
+  {  6240392545013573291u,   524517896824344605u,          22844752946u },
+  { 14377490861349714758u, 15582941400898702772u,             29642774u },
+  {  1717863312631397839u,   546812681195752981u,                    0u },
+  {  3611005143890591770u,            546812681u,                    0u },
+  {                    1u,                    0u,          21208498176u },
+  { 13168252824351245504u,  3846112492507251065u,         138904285205u },
+  {   735883891883379688u, 16681117750123089486u,         227812409738u },
+  { 10609203866866106404u, 14986314536556547266u,          12139521251u },
+  { 12358191111890306470u,  2573712825027107388u,          18406839052u },
+  { 15229916368406413528u,  7504855874008324927u,         135518906642u },
+  {  7241424335568075942u,  9572138030626879786u,          71461906823u },
+  {  6049715868779871913u,  8520676959353394842u,          65729070919u },
+  {  2000548404719336762u, 13448984662897903495u,         150668892225u },
+  {  1410974761895205301u, 12338883700918130647u,                 1942u },
+  { 16000132467694084868u,       35835915874844u,                    0u },
+  { 16894908866816792556u,                35835u,                    0u },
+  {                    1u,                    0u,          96136462336u },
+  {   589096329272056762u,  2517285787892561599u,         127235208544u },
+  {  7097729792403256904u,  4338831817635138102u,         250084648831u },
+  {  8553736750439287020u,  1561495325934523195u,         183664758778u },
+  {  2114152625261065696u, 12262635050079398785u,          38604121015u },
+  {  9817523680007641224u, 11144065765517284187u,         215065716774u },
+  { 13047215537500048015u,  1212260522471875710u,          63525586135u },
+  { 16755544192002345880u,  9695352922247418868u,         164391777855u },
+  {  6930119832670648356u,  7227025834627242947u,          60520905380u },
+  { 14560698131901886167u,  9609008238705447828u,            127314748u },
+  { 16408020927503338035u,  2348542582773833227u,                    0u },
+  { 14274703510609809116u,           2348542582u,                    0u },
+  {                    1u,                    0u,         239195652096u },
+  { 16428432973129962470u,  3609144142396852268u,          54627148527u },
+  {  3721112279790863774u, 11568848377382068864u,         171545803830u },
+  { 18032764903259620753u, 10068303578029323956u,          45631280555u },
+  { 18058455550468776079u, 11645070846862630230u,         167674882605u },
+  { 15692090139033993190u, 12449386705878485054u,         210814540455u },
+  {   389416944300619393u, 15025619323517318417u,         140812947666u },
+  { 12009691357260487293u, 14996237555047131271u,          75553539724u },
+  { 13494259174449809900u, 10211005638256058412u,          90055009355u },
+  { 18288583400616279877u,  1014743503555840529u,         151699359066u },
+  {     7216107869057472u, 12900897707145290677u,                 8343u },
+  { 17237061291959073878u,      153914086704665u,                    0u },
+  {  1599418782488783273u,               153914u,                    0u },
+  {                    1u,                    0u,          22255763456u },
+  {  9565464987240335777u,  4718003016239473661u,         140805878294u },
+  {   857713933775880687u, 14865830648693666724u,         185799843980u },
+  {  4621617820081363356u, 14754517212823091777u,         155602488249u },
+  {  9630162611715632528u, 11113946551474911900u,         197106442651u },
+  {  9283986497984645815u,  1963520352638130629u,         133723303109u },
+  {  8981807745082630996u, 13342587341404964199u,          29338292357u },
+  { 18350140531565934622u,  6240392545013573290u,         180779405341u },
+  {  4411619033127524143u, 14377490861349714757u,          21093125556u },
+  {  1852297584111266889u,  1717863312631397838u,           9195752981u },
+  { 11746243463811666096u,  3611005143890591769u,            546812681u },
+  {  6335244004343789147u, 10086913586276986678u,                    0u },
+  {  5109502367228239844u,          10086913586u,                    0u },
+  {  1603272682579847821u,                   10u,                    0u },
+  {                    1u,                    0u,         121713852416u },
+  {  6609546910952910052u, 13168252824351245503u,          78039892345u },
+  {  3911171343112928288u,   735883891883379687u,         194575126094u },
+  {  5254510615100863555u, 10609203866866106403u,          60669938882u },
+  {  3881927570803887650u, 12358191111890306469u,          63825615420u },
+  {  6379348759607163190u, 15229916368406413527u,          42392558399u },
+  { 14595733737222406466u,  7241424335568075941u,         154327955754u },
+  { 14670223432002373542u,  6049715868779871912u,         135108449946u },
+  {  4045087795619708513u,  2000548404719336761u,         215076489095u },
+  { 12598467307137142718u,  1410974761895205300u,          28867368919u },
+  {   734704388050777108u, 16000132467694084867u,         251915874844u },
+  {  5682201693687285822u, 16894908866816792555u,                35835u },
+  { 11048712694145438788u,      661055968790248u,                    0u },
+  { 17871025777010319485u,               661055u,                    0u },
+  {                    1u,                    0u,         191031934976u },
+  { 15268761435931663695u,   589096329272056761u,          54384768703u },
+  {  5016238054648555438u,  7097729792403256903u,          59463698998u },
+  { 14236047313993899750u,  8553736750439287019u,         129114608443u },
+  {  6957759675154690848u,  2114152625261065695u,          91532209025u },
+  { 18439367135478514473u,  9817523680007641223u,         126707290971u },
+  {  8539004472540641041u, 13047215537500048014u,         244908319870u },
+  {  1908462039431738399u, 16755544192002345879u,         195375682548u },
+  {   714690453250792146u,  6930119832670648355u,         148789337027u },
+  { 13782189447673929633u, 14560698131901886166u,          11889480596u },
+  {  3584742913798803164u, 16408020927503338034u,         118773833227u },
+  {  4347581515245125291u, 14274703510609809115u,           2348542582u },
+  { 16836742268156371392u,  6429475823218628948u,                    2u },
+  { 11764082328865615308u,          43322963970u,                    0u },
+  {  5957633711383291746u,                   43u,                    0u },
+  {                    1u,                    0u,          44890587136u },
+  {  9917186842884466953u, 16428432973129962469u,         128201721900u },
+  {  4751011869809829335u,  3721112279790863773u,         180977558144u },
+  { 11068497969931435029u, 18032764903259620752u,          86978950836u },
+  { 17118056985122509954u, 18058455550468776078u,          62850669910u },
+  { 14607066080907684459u, 15692090139033993189u,          17021110334u },
+  { 11768892370493391107u,   389416944300619392u,         135651046673u },
+  {  4043396447647747170u, 12009691357260487292u,          44731525255u },
+  {  1670341095362518057u, 13494259174449809899u,          17991426092u },
+  {  3190817644167043165u, 18288583400616279876u,         181000391185u },
+  { 10425820027224322486u,     7216107869057471u,          25934422965u },
+  { 13139964660506311565u, 17237061291959073877u,          58086704665u },
+  {  2297772885416059937u,  1599418782488783272u,               153914u },
+  {  7677687919964523763u,     2839213766779714u,                    0u },
+  { 14144589152747892828u,              2839213u,                    0u },
+  {                    1u,                    0u,         253518544896u },
+  { 17069730341503660290u,  9565464987240335776u,         164046496765u },
+  { 18167423787163077107u,   857713933775880686u,          65250538404u },
+  {  3765746945827805904u,  4621617820081363355u,         156522052161u },
+  { 10241734342430761691u,  9630162611715632527u,         197503285916u },
+  { 13345717282537140784u,  9283986497984645814u,         103486904773u },
+  {  9313926784816939953u,  8981807745082630995u,         170994763111u },
+  {   550974205049535019u, 18350140531565934621u,          69239154346u },
+  {  4494692285504086222u,  4411619033127524142u,         206100413253u },
+  {  1134308559863725587u,  1852297584111266888u,          25636765134u },
+  { 17587558045116130233u, 11746243463811666095u,          54343434265u },
+  {  9817142032346161594u,  6335244004343789146u,          50276986678u },
+  {  6071944935834172568u,  5109502367228239843u,          10086913586u },
+  { 11564168293299416955u,  1603272682579847820u,                   10u },
+  { 12458266507226064437u,         186070713419u,                    0u },
+  {  1304432355328256915u,                  186u,                    0u },
+  {                    1u,                    0u,         191358304256u },
+  { 15946798815542087355u,  6609546910952910051u,         231212025023u },
+  { 12082566083831286138u,  3911171343112928287u,          35284847591u },
+  { 11449623684706196411u,  5254510615100863554u,         165210439715u },
+  { 17518743620362604446u,  3881927570803887649u,         215345825189u },
+  {  9451061563087633805u,  6379348759607163189u,         165791236311u },
+  { 13191114787623314926u, 14595733737222406465u,         168795274405u },
+  {  8367349876734474799u, 14670223432002373541u,          57219284648u },
+  {  6544253801674393507u,  4045087795619708512u,         180682964281u },
+  { 16113906253336597498u, 12598467307137142717u,           3039828404u },
+  { 10294087136797312392u,   734704388050777107u,         235308032771u },
+  {  9127173070014462803u,  5682201693687285821u,         232598951915u },
+  { 16266900839595484952u, 11048712694145438787u,          63968790248u },
+  {  3299745387370952632u, 17871025777010319484u,               661055u },
+  { 12061115182604399189u,    12194330274671844u,                    0u },
+  {  5066801222582989646u,             12194330u,                    0u },
+  {                    1u,                    0u,         185827721216u },
+  {  7568423425299591513u, 15268761435931663694u,          71271930809u },
+  { 16561505984665207377u,  5016238054648555437u,         235771737671u },
+  {  4329114621856906245u, 14236047313993899749u,         223377180907u },
+  {  1477500474861899139u,  6957759675154690847u,         135999600095u },
+  { 16891579639263969684u, 18439367135478514472u,         142462900359u },
+  {  4684451357140027420u,  8539004472540641040u,         151103457934u },
+  { 14727186580409080709u,  1908462039431738398u,          35038743447u },
+  { 15864176859687308834u,   714690453250792145u,         214747133987u },
+  {  1755486942842684438u, 13782189447673929632u,          50194329302u },
+  { 17417077516652710041u,  3584742913798803163u,         219235682866u },
+  {  4290982361913532783u,  4347581515245125290u,          84912721627u },
+  { 11826659981004351409u, 16836742268156371391u,           2637732180u },
+  {   932930645678090820u, 11764082328865615307u,          43322963970u },
+  { 12707792781328052617u,  5957633711383291745u,                   43u },
+  { 16491596426880311906u,         799167628880u,                    0u },
+  {  3092207065214166010u,                  799u,                    0u },
+  {                    1u,                    0u,         229537611776u },
+  {  8142946531605512550u,  9917186842884466952u,         157257552869u },
+  {  5328402096432654515u,  4751011869809829334u,         144600024477u },
+  {  1932004361303814512u, 11068497969931435028u,         142927971728u },
+  {  2511477647985517771u, 17118056985122509953u,         229791850638u },
+  { 17451375493324716694u, 14607066080907684458u,         128637992933u },
+  {  9489266854478998489u, 11768892370493391106u,         124219192960u },
+  {  8803053132063235169u,  4043396447647747169u,         235090549372u },
+  { 16198682197142616773u,  1670341095362518056u,          68172974571u },
+  { 13696242485403414202u,  3190817644167043164u,         191565184836u },
+  { 16409082426079859931u, 10425820027224322485u,          85712318911u },
+  { 11653410736879597610u, 13139964660506311564u,         168124562517u },
+  { 13589514120653213261u,  2297772885416059936u,          66416208296u },
+  {  8032934885905905774u,  7677687919964523762u,         173766779714u },
+  {  2753021350129449273u, 14144589152747892827u,              2839213u },
+  { 16974897459201404133u,    52374249726338269u,                    0u },
+  { 13398576176159101589u,             52374249u,                    0u },
+  {                    1u,                    0u,         160925351936u },
+  { 10284586955251725351u, 17069730341503660289u,         238984858016u },
+  {  5294476488634150891u, 18167423787163077106u,         155204141550u },
+  { 15833244538135063323u,  3765746945827805903u,         143555205531u },
+  { 10348512742273116664u, 10241734342430761690u,         182723472783u },
+  { 13658504610142595663u, 13345717282537140783u,          83504908982u },
+  { 11956362239240850266u,  9313926784816939952u,          29029868371u },
+  { 13415901703662731781u,   550974205049535018u,          46243657757u },
+  {  5161774027546852762u,  4494692285504086221u,          72061490990u },
+  { 15274384838790587711u,  1134308559863725586u,         175953423432u },
+  { 14233354597679374929u, 17587558045116130232u,          90532188335u },
+  {  4274656492162486921u,  9817142032346161593u,         227329160794u },
+  { 12040276505541795046u,  6071944935834172567u,         140626894819u },
+  { 13238307206256765457u, 11564168293299416954u,          75675363980u },
+  { 12850161204172713271u, 12458266507226064436u,         186070713419u },
+  { 17531777095001445154u,  1304432355328256914u,                  186u },
+  {  5623628114515245990u,        3432398830065u,                    0u },
+  {  7357116143579573377u,                 3432u,                    0u },
+  {                    1u,                    0u,         227864477696u },
+  {  3555734177475596582u, 15946798815542087354u,          31654997219u },
+  { 14001876724756424382u, 12082566083831286137u,          66620685343u },
+  { 18159905057231476140u, 11449623684706196410u,          33949692994u },
+  {  5585207679308509467u, 17518743620362604445u,          53512343073u },
+  { 13948697622866724672u,  9451061563087633804u,          65715091765u },
+  {  9807691927739036432u, 13191114787623314925u,         165453594945u },
+  { 15818010096140820918u,  8367349876734474798u,          96354764709u },
+  {  5629845624785010943u,  6544253801674393506u,         189873536608u },
+  {  9517635131137734707u, 16113906253336597497u,          19558043581u },
+  {   619338244618780585u, 10294087136797312391u,          61494785043u },
+  { 11632367007491958899u,  9127173070014462802u,          67881830461u },
+  { 12083314261009739916u, 16266900839595484951u,         124178879555u },
+  { 16880538609458881650u,  3299745387370952631u,         228653834364u },
+  { 17404223674486504228u, 12061115182604399188u,          26274671844u },
+  {  7089067015287185433u,  5066801222582989645u,             12194330u },
+  {  2592264228029443648u,   224945689727159819u,                    0u },
+  { 13413731084370224440u,            224945689u,                    0u },
+  {                    1u,                    0u,          78410285056u },
+  {  9323915941641553425u,  7568423425299591512u,         173897801038u },
+  { 12155831029092699564u, 16561505984665207376u,         229234681773u },
+  { 17397171276588232676u,  4329114621856906244u,          31080095461u },
+  { 11874560617553253769u,  1477500474861899138u,          40915694367u },
+  { 13444839516837727954u, 16891579639263969683u,          16253944616u },
+  { 16994416043584590671u,  4684451357140027419u,          30798362384u },
+  { 15879694502877015730u, 14727186580409080708u,         209859998750u },
+  {  4234647645735263359u, 15864176859687308833u,         160095165137u },
+  {  7978589901512919496u,  1755486942842684437u,         219944181664u },
+  {  6114237175390859894u, 17417077516652710040u,         170232614619u },
+  {  8658612872088282708u,  4290982361913532782u,         191641124522u },
+  { 10253813330683324853u, 11826659981004351408u,         203050574271u },
+  { 13289465061747830991u,   932930645678090819u,          97688890827u },
+  {  4123165538545565412u, 12707792781328052616u,          80894011233u },
+  {  7846417485927038481u, 16491596426880311905u,          31167628880u },
+  { 10562273346358018864u,  3092207065214166009u,                  799u },
+  {  2691512658346619120u,       14742040721959u,                    0u },
+  {   751187558544605998u,                14742u,                    0u },
+  {                    1u,                    0u,           8441430016u },
+  {  3757709791947931308u,  8142946531605512549u,         214288853256u },
+  {  3452755398462519465u,  5328402096432654514u,          20104734166u },
+  {  3105818720159874523u,  1932004361303814511u,         129136147476u },
+  { 16859138458894499364u,  2511477647985517770u,         106946040961u },
+  { 12271894740606233755u, 17451375493324716693u,           2514414186u },
+  {  5429638071845793701u,  9489266854478998488u,          97477214466u },
+  {   145278150038876889u,  8803053132063235168u,          40878132321u },
+  {  9050266019724932450u, 16198682197142616772u,          92742474792u },
+  { 11907016253451490866u, 13696242485403414201u,         181889538140u },
+  {  2472757296513770735u, 16409082426079859930u,         140631732661u },
+  { 10558733798178239360u, 11653410736879597609u,          32736689036u },
+  { 15917322570831255850u, 13589514120653213260u,         242435466272u },
+  { 12254334656791355238u,  8032934885905905773u,          91149241586u },
+  {  7869542424662730262u,  2753021350129449272u,         221920211035u },
+  {  1378558986933000253u, 16974897459201404132u,         233726338269u },
+  { 13521405041909411105u, 13398576176159101588u,             52374249u },
+  {  3206744593298092012u,   966134380754314586u,                    0u },
+  { 13914648122214918505u,            966134380u,                    0u },
+  {                    1u,                    0u,           1557528576u },
+  {  1235541077112082496u, 10284586955251725350u,         242287014145u },
+  { 12014985518315533846u,  5294476488634150890u,         207858321906u },
+  {  1561535086344155741u, 15833244538135063322u,         218560993999u },
+  { 12761747276316224577u, 10348512742273116663u,          47740429018u },
+  {  9745594781103966137u, 13658504610142595662u,         176648155695u },
+  { 17514238702394846785u, 11956362239240850265u,          42727277488u },
+  {  2428898913707151713u, 13415901703662731780u,         205279820330u },
+  {    71666709959904945u,  5161774027546852761u,          18828026061u },
+  {  4049380135452919193u, 15274384838790587710u,         184771591698u },
+  { 18422240861777453733u, 14233354597679374928u,         185231729592u },
+  {  2914504416394425696u,  4274656492162486920u,         151652704697u },
+  { 12721377795748989418u, 12040276505541795045u,         122717650071u },
+  {  2626074459217717422u, 13238307206256765456u,          52696608634u },
+  {  4261529925046307655u, 12850161204172713270u,         146950399540u },
+  { 11536038685430305586u, 17531777095001445153u,         241304857490u },
+  { 12555757789435162768u,  5623628114515245989u,         104398830065u },
+  { 11905178684546080059u,  7357116143579573376u,                 3432u },
+  { 14032797718924543051u,       63316582777114u,                    0u },
+  { 10750340288005853484u,                63316u,                    0u },
+  {                    1u,                    0u,         186192756736u },
+  {  9660290106216358253u,  3555734177475596581u,         121759043258u },
+  { 14820142034615351103u, 14001876724756424381u,         186984450425u },
+  { 12674041783707777619u, 18159905057231476139u,         157302774714u },
+  { 15386686816442679994u,  5585207679308509466u,         140756160413u },
+  {  5679510383719146248u, 13948697622866724671u,         237531676044u },
+  {  1391101719248678506u,  9807691927739036431u,          46857496045u },
+  {  3364596672173710517u, 15818010096140820917u,         162305194542u },
+  { 11276509210104319732u,  5629845624785010942u,         249515952034u },
+  {  5316312656902630164u,  9517635131137734706u,         135033574393u },
+  { 17470981304473644647u,   619338244618780584u,          82630591879u },
+  {  7373293636384920591u, 11632367007491958898u,          23655037778u },
+  {  7616810902585191937u, 12083314261009739915u,         183915095831u },
+  { 12740295655921903924u, 16880538609458881649u,          84943484855u },
+  { 18366635945916526940u, 17404223674486504227u,          77384299092u },
+  {  4472171448243407067u,  7089067015287185432u,          11140526925u },
+  {   229592460858185629u,  2592264228029443647u,          25727159819u },
+  { 12749672866417114996u, 13413731084370224439u,            224945689u },
+  {  9452256722867098693u,  4149515568880992958u,                    0u },
+  { 16251451636418604634u,           4149515568u,                    0u },
+  {                    1u,                    0u,          88505450496u },
+  {  4515791283442995454u,  9323915941641553424u,          80658968920u },
+  { 13306155670047701346u, 12155831029092699563u,           4943102544u },
+  {  4456930152933417601u, 17397171276588232675u,         130643721220u },
+  {  9089157128546489637u, 11874560617553253768u,         147728846210u },
+  { 12437332180345515840u, 13444839516837727953u,          27921269139u },
+  {  3433060408790452524u, 16994416043584590670u,         132860839963u },
+  {  8275594526021936172u, 15879694502877015729u,          33229560708u },
+  {  3846512444641107689u,  4234647645735263358u,          21432520225u },
+  {  6210962618469046250u,  7978589901512919495u,         152331453461u },
+  {  7272858906616296575u,  6114237175390859893u,         110469384344u },
+  {  3710743300451225347u,  8658612872088282707u,         176555860334u },
+  {  6424677242672030600u, 10253813330683324852u,          67720423344u },
+  { 11485842256170301862u, 13289465061747830990u,         136223517251u },
+  {  7355797963557024308u,  4123165538545565411u,          97425355144u },
+  {  6358188982569427273u,  7846417485927038480u,         249572581985u },
+  { 12475094728768767402u, 10562273346358018863u,          39145907193u },
+  { 17288154837907896183u,  2691512658346619119u,         150040721959u },
+  {  2983850577727105262u,   751187558544605997u,                14742u },
+  { 13918604635001185935u,      271942652322184u,                    0u },
+  { 12033220395769876327u,               271942u,                    0u },
+  {                    1u,                    0u,         101203705856u },
+  {  5782377197813462997u,  3757709791947931307u,         178187174245u },
+  { 17732139848231399226u,  3452755398462519464u,         111168366770u },
+  {  3628839527415562921u,  3105818720159874522u,         202913935727u },
+  {  3188692267613601004u, 16859138458894499363u,         149665260746u },
+  {  5168130193478377352u, 12271894740606233754u,         216294341269u },
+  { 12556227529405091290u,  5429638071845793700u,          96007875544u },
+  { 15087090312791441192u,   145278150038876888u,         196490615904u },
+  { 10281804758610642494u,  9050266019724932449u,         185645480644u },
+  { 14238177586158586580u, 11907016253451490865u,         218134048441u },
+  {  7107927498217678128u,  2472757296513770734u,          41572390106u },
+  {  3845814658485364450u, 10558733798178239359u,          76862879785u },
+  {   714293333681725946u, 15917322570831255849u,         109664308812u },
+  { 16766172658649116982u, 12254334656791355237u,          56426608749u },
+  {   812461421432632215u,  7869542424662730261u,         228074731832u },
+  { 15218024718633799196u,  1378558986933000252u,         148732996836u },
+  {  8110797782612805146u, 13521405041909411104u,          90173837972u },
+  { 15941193964933529227u,  3206744593298092011u,         108754314586u },
+  { 14144280602323277933u, 13914648122214918504u,            966134380u },
+  { 15072402647813125245u, 17822033662586700072u,                    0u },
+  { 10822706091283369889u,          17822033662u,                    0u },
+  { 15163844593710966731u,                   17u,                    0u },
+  {                    1u,                    0u,          38066978816u },
+  {  2408529687792073670u,  1235541077112082495u,         234651333670u },
+  {  3980682212356510808u, 12014985518315533845u,          26084650986u },
+  {  4202670442792148519u,  1561535086344155740u,         247691815706u },
+  {  9419583343154651922u, 12761747276316224576u,          78528309751u },
+  { 16359166491570434575u,  9745594781103966136u,          89949448782u },
+  { 12567727056384237385u, 17514238702394846784u,           4131670873u },
+  {  2068388267923286639u,  2428898913707151712u,         153003885060u },
+  {  5689135844565021196u,    71666709959904944u,          62219517337u },
+  {  3104061965171139313u,  4049380135452919192u,          80998671678u },
+  {  7955173880156328016u, 18422240861777453732u,         136157995600u },
+  {  1445179403240833754u,  2914504416394425695u,         229689627272u },
+  { 12538201164459126715u, 12721377795748989417u,          16142359781u },
+  {  7580606719088482667u,  2626074459217717421u,          54231018000u },
+  {  8168318283218819755u,  4261529925046307654u,          33625369910u },
+  {  5249615277755961676u, 11536038685430305585u,         165680648993u },
+  {  6312997372068219831u, 12555757789435162767u,         128645381029u },
+  {  9183815417025176703u, 11905178684546080058u,          26760719488u },
+  { 10683849953373876937u, 14032797718924543050u,          84582777114u },
+  { 17175012155615667568u, 10750340288005853483u,                63316u },
+  { 18003508288378896912u,     1167984798111281u,                    0u },
+  { 14722554560950996951u,              1167984u,                    0u },
+  {                    1u,                    0u,          37523685376u },
+  { 15059324482416394930u,  9660290106216358252u,         189803401509u },
+  {  4134778595813308312u, 14820142034615351102u,         171687061181u },
+  { 16321118342639660948u, 12674041783707777618u,          26834113963u },
+  {  1523550293123468805u, 15386686816442679993u,          63307886874u },
+  {  8016371634569878509u,  5679510383719146247u,          15075411775u },
+  {  9884220139611134110u,  1391101719248678505u,         181182395151u },
+  {  7218073002727840414u,  3364596672173710516u,         254611300789u },
+  { 16062235669481359233u, 11276509210104319731u,          50288197886u },
+  { 15558048660560338002u,  5316312656902630163u,         168947103794u },
+  {  8394398745765058609u, 17470981304473644646u,         114399707048u },
+  {  5693296366442904274u,  7373293636384920590u,         139412908146u },
+  { 11783494675061161358u,  7616810902585191936u,         113690652811u },
+  { 13377293110865447894u, 12740295655921903923u,          35995657329u },
+  { 12840734051093062130u, 18366635945916526939u,          24242436899u },
+  {  7009868331566697505u,  4472171448243407066u,          63012446232u },
+  {  5019690705031194477u,   229592460858185628u,          55691161151u },
+  {  8608277240439804984u, 12749672866417114995u,         190512407863u },
+  { 12172482590657749222u,  9452256722867098692u,          48880992958u },
+  { 16613484892678771990u, 16251451636418604633u,           4149515568u },
+  {  5721488662757049244u,  2758075434182769113u,                    4u },
+  {   386931106438877039u,          76545051729u,                    0u },
+  { 10054429752182825659u,                   76u,                    0u },
+  {                    1u,                    0u,          16244801536u },
+  {  8634592106137071313u,  4515791283442995453u,         171721328144u },
+  { 12626356501369830731u, 13306155670047701345u,         227241610667u },
+  {  4803333258178976933u,  4456930152933417600u,         136492724195u },
+  { 13613083223558209297u,  9089157128546489636u,         209674229128u },
+  { 16106967997237446989u, 12437332180345515839u,          78186106577u },
+  { 14832921244380020170u,  3433060408790452523u,         177448620878u },
+  { 13774024637717231397u,  8275594526021936171u,         126208519857u },
+  {  9673012968505228885u,  3846512444641107688u,         199336696958u },
+  {  5391832334264815667u,  6210962618469046249u,         117394262471u },
+  { 16514436292632703088u,  7272858906616296574u,          83201159797u },
+  { 12025036352783454153u,  3710743300451225346u,         180348282451u },
+  {  7059867105311401050u,  6424677242672030599u,         206622648756u },
+  { 12769210631552594670u, 11485842256170301861u,         227398758606u },
+  {  8328873878884556145u,  7355797963557024307u,          16344678115u },
+  {  1016565892414238685u,  6358188982569427272u,          47676276240u },
+  {  9662978461927250281u, 12475094728768767401u,         239937192751u },
+  { 13729967277551868112u, 17288154837907896182u,          45161754863u },
+  {  6371593776693359475u,  2983850577727105261u,         136754529069u },
+  { 17617208110845643245u, 13918604635001185934u,          70652322184u },
+  { 14960960225633086797u, 12033220395769876326u,               271942u },
+  { 12090634301321662558u,     5016456510113118u,                    0u },
+  {  9409926148478635503u,              5016456u,                    0u },
+  {                    1u,                    0u,         171313463296u },
+  {  4307062684900157136u,  5782377197813462996u,         168961261227u },
+  { 15300759383869911853u, 17732139848231399225u,         218196719784u },
+  { 16007534237643445447u,  3628839527415562920u,          35172859354u },
+  {  7138502295759677634u,  3188692267613601003u,         154280164899u },
+  {  8218537071653683708u,  5168130193478377351u,         164680674458u },
+  {  2254219416760329296u, 12556227529405091289u,         216817872804u },
+  {  3057410459568460683u, 15087090312791441191u,          97557377752u },
+  {  8217810929938874370u, 10281804758610642493u,          49771853153u },
+  { 11741126472498340929u, 14238177586158586579u,         238385321521u },
+  {  1175325363726654805u,  7107927498217678127u,         127208482030u },
+  {  9428843070696730900u,  3845814658485364449u,          41038721919u },
+  { 12662500978715131896u,   714293333681725945u,         101908896041u },
+  {  6443045597035184564u, 16766172658649116981u,          21044043621u },
+  {  1921385512639171183u,   812461421432632214u,          60824970773u },
+  { 10469475094355551399u, 15218024718633799195u,          32439687228u },
+  { 14679174489076953574u,  8110797782612805145u,         235864173856u },
+  { 11853074234719825644u, 15941193964933529226u,         104766762987u },
+  {  8270896886596139124u, 14144280602323277932u,          40817076584u },
+  { 16532667046659118126u, 15072402647813125244u,         254586700072u },
+  {   148341279888833483u, 10822706091283369888u,          17822033662u },
+  { 10364629296397276041u, 15163844593710966730u,                   17u },
+  { 14265682585545771671u,         328758493846u,                    0u },
+  { 13991741872911347878u,                  328u,                    0u },
+  {                    1u,                    0u,          63130566656u },
+  { 14029045786848724433u,  2408529687792073669u,          21215793215u },
+  {  4005878521026842341u,  3980682212356510807u,          92227827221u },
+  {  3428326338640386488u,  4202670442792148518u,          64510636636u },
+  {  1010001558294829380u,  9419583343154651921u,         184886832192u },
+  {  2012063724327403418u, 16359166491570434574u,          64681297848u },
+  { 10997154538851372612u, 12567727056384237384u,          96112127552u },
+  {  1917749645489607898u,  2068388267923286638u,         176308408672u },
+  {  9763872523711218805u,  5689135844565021195u,         152168271536u },
+  { 15875699078454059311u,  3104061965171139312u,         164431250840u },
+  { 10966529452671276106u,  7955173880156328015u,          95078343332u },
+  { 18073244132105736913u,  1445179403240833753u,         233679697247u },
+  {  4435241176994913173u, 12538201164459126714u,         173410945513u },
+  {  5464400086219074323u,  7580606719088482666u,          70442805421u },
+  {  2445909179323258812u,  8168318283218819754u,          49284582214u },
+  {   873962058644121211u,  5249615277755961675u,         143342228273u },
+  { 16675872194112650857u,  6312997372068219830u,          58497855631u },
+  { 10680102689274800355u,  9183815417025176702u,          74579172666u },
+  {  2370498083108897524u, 10683849953373876936u,          43931059274u },
+  { 15354400521451334666u, 17175012155615667567u,          49975972139u },
+  {   259991949657381021u, 18003508288378896911u,         112798111281u },
+  { 10335286558772966917u, 14722554560950996950u,              1167984u },
+  { 16337526653906757263u,    21545516652742137u,                    0u },
+  { 12040967163702784894u,             21545516u,                    0u },
+  {                    1u,                    0u,         108816367616u },
+  {  3373309160242342187u, 15059324482416394929u,          62224146796u },
+  { 13639841054510584221u,  4134778595813308311u,          82884769598u },
+  { 15898855427739708031u, 16321118342639660947u,         185082591826u },
+  {  4544387940067005419u,  1523550293123468804u,           7434568377u },
+  {  5281598644835398575u,  8016371634569878508u,         105535824647u },
+  { 13675642405083408835u,  9884220139611134109u,         180391292521u },
+  {  3973392623768015721u,  7218073002727840413u,         243870735540u },
+  {  4491285101509114191u, 16062235669481359232u,          19843403507u },
+  { 15002304272810270500u, 15558048660560338001u,         102455061267u },
+  { 17325098540619893468u,  8394398745765058608u,          14308634214u },
+  {  1137212864974584822u,  5693296366442904273u,            638784526u },
+  {  2619406097224859078u, 11783494675061161357u,          51725184512u },
+  {  8281347529729293732u, 13377293110865447893u,          91696097587u },
+  { 11344719666795450104u, 12840734051093062129u,         218380005723u },
+  { 17283870506679425783u,  7009868331566697504u,         156272117978u },
+  { 11054210518010603775u,  5019690705031194476u,         115466655644u },
+  {  6399455551799092885u,  8608277240439804983u,          68659871603u },
+  { 12930529916573967170u, 12172482590657749221u,          89900618820u },
+  { 14550097052337552404u, 16613484892678771989u,         217310162521u },
+  { 12487632712206414748u,  5721488662757049243u,          81020975577u },
+  {  5791017277843595715u,   386931106438877038u,          76545051729u },
+  { 10227264183449036113u, 10054429752182825658u,                   76u },
+  {  2006055278511721441u,        1412006979354u,                    0u },
+  {   128746359043876333u,                 1412u,                    0u },
+  {                    1u,                    0u,         253468082176u },
+  {  7408146306870995754u,  8634592106137071312u,          97684476157u },
+  {  8299024588195267962u, 12626356501369830730u,         128260389217u },
+  {  1497052939192040881u,  4803333258178976932u,          36737966720u },
+  { 16771714264265803747u, 13613083223558209296u,          63873160484u },
+  {   142988846654429432u, 16106967997237446988u,          43804094271u },
+  { 11839838367716104145u, 14832921244380020169u,          43746691371u },
+  {  6019646776647679765u, 13774024637717231396u,         232524375083u },
+  {  4611972391702034948u,  9673012968505228884u,         233292291816u },
+  { 16447182322205429545u,  5391832334264815666u,         126895249385u },
+  {  2113477168726764245u, 16514436292632703087u,           2651878526u },
+  {  3536261187802311516u, 12025036352783454152u,         135382716162u },
+  { 18444381860986709854u,  7059867105311401049u,         165692220295u },
+  {  4734315730275909838u, 12769210631552594669u,          51451509157u },
+  {  9974936316849658174u,  8328873878884556144u,          72055108147u },
+  { 11864423681540657642u,  1016565892414238684u,         169523831112u },
+  {  8207245621417902667u,  9662978461927250280u,         118744303017u },
+  {  7992526918695295028u, 13729967277551868111u,         237345404790u },
+  {  8679354522130259987u,  6371593776693359474u,         142955030765u },
+  {  6065763799692166461u, 17617208110845643244u,         102811035278u },
+  { 18143341109049024976u, 14960960225633086796u,          94655434598u },
+  { 15242492331283350570u, 12090634301321662557u,         136510113118u },
+  {  9986352353182266963u,  9409926148478635502u,              5016456u },
+  { 17340463289911536077u,    92537289398950870u,                    0u },
+  {  7359344614214233035u,             92537289u,                    0u },
+  {                    1u,                    0u,         212233486336u },
+  {   419091135888749535u,  4307062684900157135u,          57829455828u },
+  {  1073142712661309790u, 15300759383869911852u,         168867770169u },
+  { 11076438902195672286u, 16007534237643445446u,         235386978984u },
+  {  1820390940081322073u,  7138502295759677633u,         135445527787u },
+  { 18417808973944523597u,  8218537071653683707u,         217122201479u },
+  { 10251294197731582957u,  2254219416760329295u,          39165742553u },
+  {  1502394029870156428u,  3057410459568460682u,          61445488423u },
+  {   321014853559106075u,  8217810929938874369u,         211636487741u },
+  {  2390953058510591778u, 11741126472498340928u,          47063714515u },
+  { 10685224265907994087u,  1175325363726654804u,         225511138607u },
+  {  5967405799190505023u,  9428843070696730899u,         249686435553u },
+  { 11210723659228214761u, 12662500978715131895u,          53349278201u },
+  { 12327123641078462773u,  6443045597035184563u,         150104158517u },
+  {  1709976940107894237u,  1921385512639171182u,          27567551382u },
+  { 16607686590938553511u, 10469475094355551398u,          25795759643u },
+  { 18332088094272679457u, 14679174489076953573u,         138642556441u },
+  {  2946170632136780882u, 11853074234719825643u,         108448366218u },
+  {  4824449494694383419u,  8270896886596139123u,         124896237676u },
+  { 17008332258693407134u, 16532667046659118125u,         160008041596u },
+  {  1773419466622750661u,   148341279888833482u,         202561867680u },
+  {  3892343466023784379u, 10364629296397276040u,         150773344202u },
+  { 12001571085575422796u, 14265682585545771670u,          72758493846u },
+  { 12933506765500977582u, 13991741872911347877u,                  328u },
+  { 11884830007749143734u,        6064523798049u,                    0u },
+  {  9662368568096205337u,                 6064u,                    0u },
+  {                    1u,                    0u,         197760516096u },
+  { 16801499925276664442u, 14029045786848724432u,          87217159109u },
+  { 10492407990787637084u,  4005878521026842340u,          38185849943u },
+  {  7673849751013230269u,  3428326338640386487u,          17054752294u },
+  {  6046724489853072367u,  1010001558294829379u,          14109074193u },
+  {  3723941391207507903u,  2012063724327403417u,          72596156942u },
+  { 16844122108860347659u, 10997154538851372611u,         110103961416u },
+  { 10622020182694668027u,  1917749645489607897u,          11529300590u },
+  {  8741198820686854862u,  9763872523711218804u,         240860623371u },
+  {  6855480461211306807u, 15875699078454059310u,          79594496752u },
+  { 10005708458011566304u, 10966529452671276105u,         217979752527u },
+  {  8932093106442919061u, 18073244132105736912u,         186240434905u },
+  {  9062763476260756743u,  4435241176994913172u,         106296225722u },
+  { 13664977682032775521u,  5464400086219074322u,         170132593002u },
+  {  1078499125430623453u,  2445909179323258811u,          75047377578u },
+  {  6554586738078431161u,   873962058644121210u,         182904000843u },
+  { 12177313698643242883u, 16675872194112650856u,         126578969526u },
+  { 16615072271904633953u, 10680102689274800354u,         200128504958u },
+  { 16375404983106569285u,  2370498083108897523u,         111832363720u },
+  { 13552251831473522729u, 15354400521451334665u,          15014094191u },
+  {  8330500218412111874u,   259991949657381020u,         214560277007u },
+  {  7044338079053294004u, 10335286558772966916u,         249885659094u },
+  {  2688849443046530184u, 16337526653906757262u,          44652742137u },
+  {   855940991879596845u, 12040967163702784893u,             21545516u },
+  {  7344363609485825662u,   397444631628981487u,                    0u },
+  { 11602660525134634992u,            397444631u,                    0u },
+  {                    1u,                    0u,         177182867456u },
+  { 16945343208344873835u,  3373309160242342186u,         151739417265u },
+  {  9617992661337889145u, 13639841054510584220u,         147861878679u },
+  { 18280344933262742088u, 15898855427739708030u,           4246351763u },
+  {  5179975582362777795u,  4544387940067005418u,         236286316036u },
+  {  1798918997870037130u,  5281598644835398574u,         157741358060u },
+  {  6327667344756325883u, 13675642405083408834u,         157215398045u },
+  { 18380327574124007701u,  3973392623768015720u,         128243473053u },
+  { 18015447557304295289u,  4491285101509114190u,          81813276544u },
+  { 10315590748073249878u, 15002304272810270499u,          48939195473u },
+  {  7697916092577993382u, 17325098540619893467u,         209061648432u },
+  {  3124132817942110723u,  1137212864974584821u,         141141998289u },
+  {  7448238998520507049u,  2619406097224859077u,         213448932749u },
+  { 13892823322374205297u,  8281347529729293731u,         241614998485u },
+  { 11042137840046332564u, 11344719666795450103u,          32936960497u },
+  { 10513966307445593804u, 17283870506679425782u,         108599249952u },
+  {  9388437460943526958u, 11054210518010603774u,          55346915180u },
+  { 10967228614677896228u,  6399455551799092884u,         229700965431u },
+  {  2310996671540235542u, 12930529916573967169u,          21788762341u },
+  {  4989110555003898587u, 14550097052337552403u,         155676955925u },
+  { 16271452421983657679u, 12487632712206414747u,         110313931675u },
+  {  9523160181437090473u,  5791017277843595714u,         186554421102u },
+  { 13137707423765072250u, 10227264183449036112u,          26108748474u },
+  { 16846859744221860705u,  2006055278511721440u,         132006979354u },
+  {  7767140033449795569u,   128746359043876332u,                 1412u },
+  { 17169456915721160017u,       26046931378436u,                    0u },
+  { 17180899661833327819u,                26046u,                    0u },
+  {                    1u,                    0u,         208401596416u },
+  { 17572520700934791416u,  7408146306870995753u,          74449891024u },
+  { 17968798858233825417u,  8299024588195267961u,         164081155402u },
+  { 15338423313945305609u,  1497052939192040880u,          16909196452u },
+  { 17895321323836726301u, 16771714264265803746u,          76007751440u },
+  {   814069333008965773u,   142988846654429431u,         201641838924u },
+  {  7200328959852723947u, 11839838367716104144u,          36326325705u },
+  {   759884557248133773u,  6019646776647679764u,          84250015524u },
+  { 13410165861863974851u,  4611972391702034947u,          50891603540u },
+  {  6278452420856351570u, 16447182322205429544u,         111114571826u },
+  {  9072115382556676442u,  2113477168726764244u,         200191701103u },
+  {  2755882551854926563u,  3536261187802311515u,          89999871944u },
+  {  8496072611504649269u, 18444381860986709853u,         237256647769u },
+  {  4122009033579215815u,  4734315730275909837u,         112540742381u },
+  { 10222217724450527221u,  9974936316849658173u,         220643171696u },
+  {  2064539481554006325u, 11864423681540657641u,         104444915676u },
+  {  7935605886598063693u,  8207245621417902666u,         207433275752u },
+  {  7805147585347548429u,  7992526918695295027u,         114470508751u },
+  {  5709020905457661273u,  8679354522130259986u,         236328825714u },
+  { 16257370307404906674u,  6065763799692166460u,          76983552492u },
+  { 14971258192939373646u, 18143341109049024975u,          93826297164u },
+  {  1133404845901376390u, 15242492331283350569u,         238541361245u },
+  {  9460827548162822047u,  9986352353182266962u,         214940028398u },
+  {  1273897659779791346u, 17340463289911536076u,         201398950870u },
+  {  7833262224435092783u,  7359344614214233034u,             92537289u },
+  {  3033420566713364587u,  1707011694817242694u,                    0u },
+  { 15075466825360349103u,           1707011694u,                    0u },
+  {                    1u,                    0u,         207022718976u },
+  {  2484134775182816690u,   419091135888749534u,          44058175183u },
+  { 18400539815335991277u,  1073142712661309789u,         198600454956u },
+  {   485494064952118286u, 11076438902195672285u,         193098683590u },
+  { 17577048805241314891u,  1820390940081322072u,         251998431425u },
+  {  2863946907557583807u, 18417808973944523596u,          79555723771u },
+  { 13045307417786230800u, 10251294197731582956u,         138081444943u },
+  { 12032088871615097766u,  1502394029870156427u,           1017402250u },
+  {  8848763446997690580u,   321014853559106074u,          64129613825u },
+  { 10031289150307672684u,  2390953058510591777u,          84579247168u },
+  { 11592215575498656563u, 10685224265907994086u,          19323493716u },
+  { 15894436747956898388u,  5967405799190505022u,         247607734547u },
+  {  2091546719588500923u, 11210723659228214760u,         179668254711u },
+  {  5863809244813756109u, 12327123641078462772u,         110092698035u },
+  { 11303008753675411245u,  1709976940107894236u,         166900304494u },
+  { 13238426537506910532u, 16607686590938553510u,         229993784486u },
+  { 17258458071023005565u, 18332088094272679456u,         235159712229u },
+  {  8385733444777075179u,  2946170632136780881u,         115261533931u },
+  {  9530757096163247300u,  4824449494694383418u,          45922023539u },
+  { 14423000845391072217u, 17008332258693407133u,         202096137261u },
+  { 10953140011159884311u,  1773419466622750660u,         136211004362u },
+  { 12228340237948264127u,  3892343466023784378u,         150650606472u },
+  { 11279134946966259189u, 12001571085575422795u,         165701126806u },
+  { 14640097792684582651u, 12933506765500977581u,          33644277925u },
+  {  6232313315128656728u, 11884830007749143733u,         176523798049u },
+  { 16136121832933322088u,  9662368568096205336u,                 6064u },
+  { 15074767079673358271u,      111870718431542u,                    0u },
+  { 13252722804829281908u,               111870u,                    0u },
+  {                    1u,                    0u,         208910811136u },
+  {  7740175894281560509u, 16801499925276664441u,         228568794576u },
+  { 15670495392425593226u, 10492407990787637083u,         183416000228u },
+  { 15152257626756992778u,  7673849751013230268u,          67327793591u },
+  {  4090073428152440422u,  6046724489853072366u,         153201875267u },
+  { 14450327772834205584u,  3723941391207507902u,          67913121689u },
+  {  4466091895542494216u, 16844122108860347658u,         217575820867u },
+  { 10454115378553795377u, 10622020182694668026u,         116473861337u },
+  {  2267817233475657788u,  8741198820686854861u,          46371636340u },
+  {  5500455702636497521u,  6855480461211306806u,          73542410542u },
+  { 15178768299492252549u, 10005708458011566303u,         208484209737u },
+  {  7062359872332045590u,  8932093106442919060u,         148491293392u },
+  { 12297347290027942576u,  9062763476260756742u,          18740779924u },
+  {  8030124596941085588u, 13664977682032775520u,         187058465554u },
+  {  6526656990996654843u,  1078499125430623452u,         122355324859u },
+  {  6254287345256979850u,  6554586738078431160u,         104660133498u },
+  {  6642007136244870032u, 12177313698643242882u,         226900704872u },
+  {  2027592955437164718u, 16615072271904633952u,         243887712482u },
+  {   942718349157325567u, 16375404983106569284u,           9734669043u },
+  { 14617066671884002278u, 13552251831473522728u,         156451597321u },
+  {  6831631114396133348u,  8330500218412111873u,           4381874332u },
+  { 14603040013386939258u,  7044338079053294003u,         142145762820u },
+  {  9906106765319401103u,  2688849443046530183u,         125046400654u },
+  {  1396179595609933063u,   855940991879596844u,         239398138749u },
+  { 11524884268464976417u,  7344363609485825661u,          23628981487u },
+  {   382929570730827274u, 11602660525134634991u,            397444631u },
+  {  6109721884461301381u,  7331559403129590068u,                    0u },
+  {  2390514825000339691u,           7331559403u,                    0u },
+  {  6116191454763441755u,                    7u,                    0u },
+  {                    1u,                    0u,          42918608896u },
+  { 11598868771099176310u, 16945343208344873834u,         156521392426u },
+  { 14449966445520085105u,  9617992661337889144u,         126990979484u },
+  { 11675595287405614726u, 18280344933262742087u,         234280807038u },
+  { 15860796398550489897u,  5179975582362777794u,         174097519594u },
+  { 16180408435245829662u,  1798918997870037129u,         194343023534u },
+  { 13756992797154950706u,  6327667344756325882u,         104996399554u },
+  {  8830551328786758466u, 18380327574124007700u,          78976619368u },
+  { 16699955256560951264u, 18015447557304295288u,          35559209294u },
+  { 10038983627153402074u, 10315590748073249877u,         219417304867u },
+  { 15085100736692127346u,  7697916092577993381u,         245169359579u },
+  { 10007783780289711125u,  3124132817942110722u,         197403769845u },
+  { 17596907048353602192u,  7448238998520507048u,         163753131461u },
+  { 13530650344896573509u, 13892823322374205296u,         247598595491u },
+  {  6337724853398437005u, 11042137840046332563u,         246569963255u },
+  { 12768885008904063297u, 10513966307445593803u,         254508948214u },
+  {  2759773619512884114u,  9388437460943526957u,         148594534654u },
+  {  8434364600126655292u, 10967228614677896227u,          65125279380u },
+  {  3843827521199949338u,  2310996671540235541u,          19270460225u },
+  {  4661660852957808994u,  4989110555003898586u,         155882077203u },
+  { 15298044134177324417u, 16271452421983657678u,         194516251547u },
+  {  7747773274913338217u,  9523160181437090472u,          80712196546u },
+  { 10348785912020632966u, 13137707423765072249u,         224913270096u },
+  {  4175372293197190170u, 16846859744221860704u,         236421057504u },
+  { 11326064156813083145u,  7767140033449795568u,           4930758124u },
+  {  8100407170505981763u, 17169456915721160016u,         190931378436u },
+  {  1706556116319916846u, 17180899661833327818u,                26046u },
+  { 15028897280749641942u,      480481077043500u,                    0u },
+  {  1421201742071739121u,               480481u,                    0u },
+  {                    1u,                    0u,          41952608256u },
+  {  8480737406125178272u, 17572520700934791415u,         121974090537u },
+  { 10947205650755620361u, 17968798858233825416u,         176831497593u },
+  {   868577942165647781u, 15338423313945305608u,         226970107312u },
+  { 16017710019091388479u, 17895321323836726300u,         247044130786u },
+  {  6610879150827623375u,   814069333008965772u,         208390330615u },
+  { 12110095866223762092u,  7200328959852723946u,          20041193424u },
+  {  7756802952949470775u,   759884557248133772u,           3726966548u },
+  {  2941800790804618759u, 13410165861863974850u,          40340355587u },
+  { 11703600274199927522u,  6278452420856351569u,         212491800360u },
+  {   806737539257940346u,  9072115382556676441u,          91149396692u },
+  { 14579028397110132023u,  2755882551854926562u,          93460573019u },
+  { 14247808875344366934u,  8496072611504649268u,         205223454557u },
+  {  9713379923695279513u,  4122009033579215814u,          61554147533u },
+  {  2246428675703313877u, 10222217724450527220u,         233111918909u },
+  {  3549783776592680620u,  2064539481554006324u,          74430190057u },
+  { 12645029747929213033u,  7935605886598063692u,          51423117898u },
+  { 16279009267476580506u,  7805147585347548428u,          18309486643u },
+  {   343358782242907186u,  5709020905457661272u,          60881313810u },
+  { 10077054739085890321u, 16257370307404906673u,         207811593532u },
+  { 10526715404712173586u, 14971258192939373645u,          41061441999u },
+  { 11438715865125144243u,  1133404845901376389u,          82512872489u },
+  {  5040916178827294801u,  9460827548162822046u,         204069058130u },
+  { 16643761637275849508u,  1273897659779791345u,         202424641996u },
+  {  4852542977279030386u,  7833262224435092782u,          70164442058u },
+  {  7883373066544387129u,  3033420566713364586u,         110817242694u },
+  { 16699064314768500978u, 15075466825360349102u,           1707011694u },
+  {  6805863634444817214u, 13042063791413317777u,                    1u },
+  {  2266540253968903500u,          31488807865u,                    0u },
+  {  9016913589137908810u,                   31u,                    0u },
+  {                    1u,                    0u,         222134665216u },
+  { 11654451024602552034u,  2484134775182816689u,          93997495262u },
+  {  5299013208454526793u, 18400539815335991276u,         221026318685u },
+  { 14918550373926182540u,   485494064952118285u,          88952853725u },
+  {  6225552657491071054u, 17577048805241314890u,          76155254872u },
+  { 10344713496596235785u,  2863946907557583806u,         236707187532u },
+  { 12972405634433280209u, 13045307417786230799u,         139652260844u },
+  { 12911885282402784945u, 12032088871615097765u,          26479692427u },
+  {  6934311832970995868u,  8848763446997690579u,          33543797274u },
+  {  9975729197003430461u, 10031289150307672683u,         230628415265u },
+  {  1982857556803548935u, 11592215575498656562u,          62861639142u },
+  {  2095735223386298223u, 15894436747956898387u,         232113382974u },
+  {  7110931538347639365u,  2091546719588500922u,          52317877736u },
+  { 15822183724630969535u,  5863809244813756108u,         220612737332u },
+  { 16931982690156327501u, 11303008753675411244u,         166717656540u },
+  {  6740069226761666110u, 13238426537506910531u,          32935582886u },
+  {  3138792961008474902u, 17258458071023005564u,          81454591520u },
+  { 12154594426971851390u,  8385733444777075178u,          58516663377u },
+  { 15780127219221910902u,  9530757096163247299u,         157781872442u },
+  { 16421541930960194381u, 14423000845391072216u,         196593770909u },
+  {  7485894627196740576u, 10953140011159884310u,         186662899652u },
+  {  8897269432694476707u, 12228340237948264126u,          75611443130u },
+  { 17189823634941678805u, 11279134946966259188u,         173793641291u },
+  {  9585582064286255216u, 14640097792684582650u,         181337854381u },
+  { 12835472279575022097u,  6232313315128656727u,          24874740917u },
+  {  6776016669542754608u, 16136121832933322087u,          54817204760u },
+  { 18340015775620871027u, 15074767079673358270u,         254718431542u },
+  {  5254188752292365830u, 13252722804829281907u,               111870u },
+  {  6798802596750151183u,     2063650512248692u,                    0u },
+  {  9449320530215272000u,              2063650u,                    0u },
+  {                    1u,                    0u,         121419595776u },
+  { 17110720482574968811u,  7740175894281560508u,          91849499257u },
+  { 16172441693558688213u, 15670495392425593225u,         188821405531u },
+  {  6234654946353717320u, 15152257626756992777u,         238221723324u },
+  { 11180283100679445438u,  4090073428152440421u,         190783353838u },
+  { 14852260031176961272u, 14450327772834205583u,          10242107326u },
+  {  4481533167346438750u,  4466091895542494215u,         250566718730u },
+  {  4269718344362365664u, 10454115378553795376u,         205122938618u },
+  { 11520029752381101466u,  2267817233475657787u,          54298180301u },
+  { 16778682550309368417u,  5500455702636497520u,         223822842678u },
+  {  9687587467301363608u, 15178768299492252548u,         148382851295u },
+  { 10093971076828497318u,  7062359872332045589u,           6666640532u },
+  {  1913763026490934696u, 12297347290027942575u,          96435313926u },
+  { 12701450127613557000u,  8030124596941085587u,         220353810784u },
+  {  8974572160711134644u,  6526656990996654842u,         184339045596u },
+  {  9890000077336694124u,  6254287345256979849u,         130360063928u },
+  {  4292326716201059148u,  6642007136244870031u,          96109916034u },
+  { 14644519175104337420u,  2027592955437164717u,          68051104864u },
+  {  5051178622270136798u,   942718349157325566u,          40792392772u },
+  {   675983118348065839u, 14617066671884002277u,           1370343464u },
+  {  4431647660065117244u,  6831631114396133347u,         179791632385u },
+  {  8316115180008411962u, 14603040013386939257u,         135537011123u },
+  {  9621158095544965602u,  9906106765319401102u,          44075687047u },
+  { 15283478958951102072u,  1396179595609933062u,         125624765228u },
+  { 13981553073094447813u, 11524884268464976416u,         239020758653u },
+  {  4558368743929911607u,   382929570730827273u,          52331208687u },
+  { 15217004469858477791u,  6109721884461301380u,         235129590068u },
+  { 11589190369996515737u,  2390514825000339690u,           7331559403u },
+  {  3670624237398152929u,  6116191454763441754u,                    7u },
+  { 13471713758418039777u,         135243399970u,                    0u },
+  {  4489936967610296411u,                  135u,                    0u },
+  {                    1u,                    0u,         106628775936u },
+  {  9052049303222747950u, 11598868771099176309u,         120783334250u },
+  {  1011330006193020538u, 14449966445520085104u,          71632935288u },
+  { 17412075644359478612u, 11675595287405614725u,         194859815495u },
+  {  6358678384745980468u, 15860796398550489896u,         137877141698u },
+  { 15262353928842850919u, 16180408435245829661u,         250745768073u },
+  { 11145257686438581736u, 13756992797154950705u,          20478705146u },
+  {  1600562031807691890u,  8830551328786758465u,         120905306388u },
+  {  6775147337046626724u, 16699955256560951263u,          85544214392u },
+  { 15772127322106297822u, 10038983627153402073u,         165817764949u },
+  {  4141472200527441474u, 15085100736692127345u,           2542523045u },
+  { 18246007807879281267u, 10007783780289711124u,         168953930242u },
+  {   960746958654787123u, 17596907048353602191u,         112733498024u },
+  { 11355981212264408477u, 13530650344896573508u,         147343568752u },
+  {  1573078209576251481u,  6337724853398437004u,         203692202643u },
+  {  6245294478780491367u, 12768885008904063296u,          45149607627u },
+  {  7523292955659721510u,  2759773619512884113u,          35457227821u },
+  { 14454736751015226505u,  8434364600126655291u,          21208374307u },
+  {  7219786377781411316u,  3843827521199949337u,         218252709141u },
+  { 10597123082209392431u,  4661660852957808993u,         206829308634u },
+  {  6922353544343010714u, 15298044134177324416u,         168420007630u },
+  { 14317523356293377430u,  7747773274913338216u,         121561008808u },
+  {  4057766168681892717u, 10348785912020632965u,          96226347385u },
+  { 15214083611901244045u,  4175372293197190169u,         240613987168u },
+  {  8390569016883950721u, 11326064156813083144u,          80439123952u },
+  { 10680472538208175055u,  8100407170505981762u,         202092512592u },
+  { 12173567833130544927u,  1706556116319916845u,          44814718154u },
+  {  1386341248286610026u, 15028897280749641941u,         225077043500u },
+  { 12487300952797237352u,  1421201742071739120u,               480481u },
+  {  2614759871804869720u,     8863311460481781u,                    0u },
+  {  8494389567327729477u,              8863311u,                    0u },
+  {                    1u,                    0u,         247459741696u },
+  {  6260469580539185878u,  8480737406125178271u,         136593449207u },
+  { 17818573101084525841u, 10947205650755620360u,           8047085704u },
+  {  2201029069927307150u,   868577942165647780u,          28868321800u },
+  { 10397997613804897039u, 16017710019091388478u,         140358376476u },
+  { 14269915965770103741u,  6610879150827623374u,         234656489612u },
+  { 16776139909196366727u, 12110095866223762091u,         140420497130u },
+  {  6246513436385199720u,  7756802952949470774u,         194159475340u },
+  {  2926026498821554288u,  2941800790804618758u,          81634453442u },
+  { 15725499391028340982u, 11703600274199927521u,          89043733329u },
+  {  8576577277771450827u,   806737539257940345u,         226790330713u },
+  { 15523351176022259335u, 14579028397110132022u,          52772375266u },
+  {  4775158829429176134u, 14247808875344366933u,         198526563380u },
+  { 10141817222123532462u,  9713379923695279512u,         244121779142u },
+  { 12847658900242624586u,  2246428675703313876u,          52192434164u },
+  { 13708197964460514655u,  3549783776592680619u,          76685488436u },
+  {  1951540006613246932u, 12645029747929213032u,          12882486860u },
+  {  9979297327280092199u, 16279009267476580505u,          88018613516u },
+  { 15381307706282553684u,   343358782242907185u,         177546278232u },
+  { 10037428657543061177u, 10077054739085890320u,          77570654385u },
+  {  2584877324547208668u, 10526715404712173585u,         133620094029u },
+  {  1126624732730703576u, 11438715865125144242u,         158273268613u },
+  {  1501064139624981020u,  5040916178827294800u,         241902260126u },
+  {  5219661484955306109u, 16643761637275849507u,          46263056881u },
+  {  5336997298570282212u,  4852542977279030385u,         106427358510u },
+  { 12191131175733833362u,  7883373066544387128u,         174905258090u },
+  {  3707068178994436536u, 16699064314768500977u,         145368946606u },
+  {  5045484691732942022u,  6805863634444817213u,         185122869393u },
+  { 14847900542908711232u,  2266540253968903499u,          31488807865u },
+  {  9097257915916965135u,  9016913589137908809u,                   31u },
+  {  2472027983230314217u,         580865979874u,                    0u },
+  { 15974509111133272205u,                  580u,                    0u },
+  {                    1u,                    0u,         177631789056u },
+  { 12099486841948187399u, 11654451024602552033u,         236287260081u },
+  {  5319910566029976328u,  5299013208454526792u,          13808736236u },
+  { 11549214421017285864u, 14918550373926182539u,          74337487885u },
+  {  1998791413186046700u,  6225552657491071053u,         190560788042u },
+  { 17075171930090011210u, 10344713496596235784u,          15703235518u },
+  { 15158296003813501474u, 12972405634433280208u,         165699954703u },
+  {  1360083178079384115u, 12911885282402784944u,         211375909797u },
+  {  6167980558592741158u,  6934311832970995867u,         107540785363u },
+  {  3630180428124865653u,  9975729197003430460u,          50107490923u },
+  {  2276550099763657677u,  1982857556803548934u,          83113610034u },
+  {   407006713016100655u,  2095735223386298222u,         186385484371u },
+  { 14242579061653496002u,  7110931538347639364u,         204857722298u },
+  { 17944493332678643704u, 15822183724630969534u,          44917884620u },
+  {   987185901870869452u, 16931982690156327500u,          67365379884u },
+  {  5578665155415167745u,  6740069226761666109u,         124170154307u },
+  {  4849210377429577536u,  3138792961008474901u,         234658901884u },
+  { 10811995403388891862u, 12154594426971851389u,         195855442410u },
+  {  7051931074990177294u, 15780127219221910901u,         216890213571u },
+  {  2030832259446664275u, 16421541930960194380u,          22405811160u },
+  {  6069512651054767896u,  7485894627196740575u,         190482321942u },
+  { 10608701253763958799u,  8897269432694476706u,         244931862206u },
+  { 15700053443426906717u, 17189823634941678804u,         250519635444u },
+  { 17759719234725541222u,  9585582064286255215u,          87695812346u },
+  { 15187321568916405210u, 12835472279575022096u,         103367328599u },
+  { 11040156458113129594u,  6776016669542754607u,         190994214247u },
+  {  2800727824598008497u, 18340015775620871026u,         115284830142u },
+  {  2997236166375604479u,  5254188752292365829u,         116368563827u },
+  {  6260091886451512841u,  6798802596750151182u,          34512248692u },
+  { 17573059315228347474u,  9449320530215271999u,              2063650u },
+  {  7519453664590169251u,    38067632857031246u,                    0u },
+  { 15809436065653866529u,             38067632u,                    0u },
+  {                    1u,                    0u,         188927574016u },
+  {   228921437623588922u, 17110720482574968810u,         137876709820u },
+  {  2195862230003073884u, 16172441693558688212u,           9337981321u },
+  {   960207412233973688u,  6234654946353717319u,         101606084361u },
+  {  2464387149230492479u, 11180283100679445437u,         143805142629u },
+  {  3631866936444955213u, 14852260031176961271u,           7242944399u },
+  {  1578304441149380227u,  4481533167346438749u,          48231461895u },
+  { 18190538519673445181u,  4269718344362365663u,          59624502064u },
+  {  1271000736479934749u, 11520029752381101465u,         112909574203u },
+  { 18292963032817745634u, 16778682550309368416u,         132525165168u },
+  { 17168014021925537455u,  9687587467301363607u,          21547195268u },
+  { 18046757712870378949u, 10093971076828497317u,         175103745301u },
+  { 14857998893911743220u,  1913763026490934695u,         147688546991u },
+  { 11933607369968684575u, 12701450127613556999u,         250486512531u },
+  {  3483798509902859162u,  8974572160711134643u,         137536137978u },
+  {  7378828438829845831u,  9890000077336694123u,         143232687497u },
+  { 15791137430347699565u,  4292326716201059147u,         173793880975u },
+  { 17044141236829932641u, 14644519175104337419u,         254273824941u },
+  {  9075651910862456484u,  5051178622270136797u,         229036645118u },
+  { 17811207355884564095u,   675983118348065838u,         227240240101u },
+  {  4438638126207305937u,  4431647660065117243u,         121450817507u },
+  { 12507972635512950185u,  8316115180008411961u,         142521564025u },
+  { 14658269128098109408u,  9621158095544965601u,           6828519054u },
+  {  3642436268910286111u, 15283478958951102071u,          32757941510u },
+  {  3783099432964819561u, 13981553073094447812u,           9247109664u },
+  {  9497579866027539638u,  4558368743929911606u,         132824915465u },
+  {  3395179445046271361u, 15217004469858477790u,         234628251268u },
+  {  5938502732309497276u, 11589190369996515736u,          90198984938u },
+  {  5793671185917606255u,  3670624237398152928u,          34730303066u },
+  {   889272970253526588u, 13471713758418039776u,         135243399970u },
+  {  8594177504370135501u,  4489936967610296410u,                  135u },
+  {  7374354721120724712u,        2494800386918u,                    0u },
+  { 14764532643665507567u,                 2494u,                    0u },
+  {                    1u,                    0u,         117490712576u },
+  {  5392404173658087695u,  9052049303222747949u,         112054824309u },
+  {  4976586473237854316u,  1011330006193020537u,         133943910512u },
+  {  6308932742419013569u, 17412075644359478611u,          40344704645u },
+  {  4831846642430703059u,  6358678384745980467u,          29827373864u },
+  { 18139507855949846901u, 15262353928842850918u,          49604185629u },
+  {  4865833876326628410u, 11145257686438581735u,          65086766641u },
+  { 14296661839130179261u,  1600562031807691889u,         223367281473u },
+  {  9254773150378118248u,  6775147337046626723u,         217855008735u },
+  { 12174712433727875143u, 15772127322106297821u,         113224509657u },
+  {   705653145340915199u,  4141472200527441473u,          20989118065u },
+  { 17763928858962481812u, 18246007807879281266u,         143052082196u },
+  {  3982836567612046296u,   960746958654787122u,          68615608975u },
+  { 12730849277561967739u, 11355981212264408476u,         140085276740u },
+  { 17314488764367235908u,  1573078209576251480u,          64338558092u },
+  { 15951418930590301119u,  6245294478780491366u,         145407838528u },
+  {  7193356087283467261u,  7523292955659721509u,          59783592849u },
+  { 17592945625696089446u, 14454736751015226504u,          25391385403u },
+  {  3554461664875361428u,  7219786377781411315u,          97574471193u },
+  {  2213779057785318208u, 10597123082209392430u,         128375261537u },
+  {  3880940796082421148u,  6922353544343010713u,         104776154496u },
+  {  4528237545358141043u, 14317523356293377429u,         133219971944u },
+  { 11681196539088147363u,  4057766168681892716u,          25824757125u },
+  {  9835005502912643017u, 15214083611901244044u,           8454853657u },
+  {  4964088126040986696u,  8390569016883950720u,          66578989576u },
+  {  3355564873147047622u, 10680472538208175054u,          45659930434u },
+  {  1853093467828272927u, 12173567833130544926u,         213075153709u },
+  { 14755341584803008677u,  1386341248286610025u,         240676937941u },
+  {  4701571132542556621u, 12487300952797237351u,         245141746416u },
+  {  6128849686644853851u,  2614759871804869719u,          79460481781u },
+  { 12026867901170202094u,  8494389567327729476u,              8863311u },
+  { 17909760324981426303u,   163499238157084246u,                    0u },
+  {  2897692901883393664u,            163499238u,                    0u },
+  {                    1u,                    0u,         159339380736u },
+  { 12323704802554838154u,  6260469580539185877u,           8965946783u },
+  {  7135886931147821732u, 17818573101084525840u,         164119318024u },
+  { 15341283120292884947u,  2201029069927307149u,          62563676580u },
+  {  3092789040392634166u, 10397997613804897038u,         206773573694u },
+  {  8811761390822097865u, 14269915965770103740u,         171909436366u },
+  { 16870860798610218169u, 16776139909196366726u,          54338624171u },
+  { 17452041453591904833u,  6246513436385199719u,           6158620214u },
+  { 10314783684009874908u,  2926026498821554287u,         225852481030u },
+  {  4932636630789274903u, 15725499391028340981u,         121464937185u },
+  { 18143884346082124480u,  8576577277771450826u,          54841522553u },
+  {  2823209155405527322u, 15523351176022259334u,          85258861878u },
+  { 16195396106620226251u,  4775158829429176133u,         152549789013u },
+  {  1150544491807648944u, 10141817222123532461u,         212696472984u },
+  {  7767455475523884824u, 12847658900242624585u,         171743122900u },
+  { 15204378045683991808u, 13708197964460514654u,         104105793195u },
+  { 17239732561718805622u,  1951540006613246931u,         153540978792u },
+  { 12886430624522800062u,  9979297327280092198u,          49833822361u },
+  { 18162250541178258136u, 15381307706282553683u,          16544130097u },
+  { 17028935366700158084u, 10037428657543061176u,          17140126480u },
+  { 16075467823964198637u,  2584877324547208667u,         178061074449u },
+  {  9803858825574498304u,  1126624732730703575u,          80081372850u },
+  { 17464070808143041817u,  1501064139624981019u,          35282958416u },
+  { 17682703471239266776u,  5219661484955306108u,         113289319203u },
+  { 18147688354161351336u,  5336997298570282211u,          56660882545u },
+  {  6663423873348080051u, 12191131175733833361u,         241200960568u },
+  {  9417270363716235133u,  3707068178994436535u,          61273516273u },
+  {  9295013721571344179u,  5045484691732942021u,          75804906301u },
+  {  6199479138350037783u, 14847900542908711231u,          73493163339u },
+  {   887603005365085688u,  9097257915916965134u,         226134008905u },
+  {   333989628642975696u,  2472027983230314216u,          68865979874u },
+  {  4620735991403939439u, 15974509111133272204u,                  580u },
+  { 12418523063962801201u,       10715086071862u,                    0u },
+  {  1587745622680169419u,                10715u,                    0u },
+  {                    1u,                    0u,         225655914496u },
+  { 10968905082284365638u, 12099486841948187398u,          72288392929u },
+  { 14076907092801977812u,  5319910566029976327u,         139626084168u },
+  {  3438322122816124202u, 11549214421017285863u,          77108354699u },
+  { 14645413324829073676u,  1998791413186046699u,           8925646925u },
+  { 12271281439492289999u, 17075171930090011209u,         208821732872u },
+  {  6233751789862708246u, 15158296003813501473u,         176073730256u },
+  {  1962644459455827991u,  1360083178079384114u,         155334366896u },
+  {  8726934184642952500u,  6167980558592741157u,          60196792475u },
+  {  4531087719737475147u,  3630180428124865652u,           6123412028u },
+  {   481513520412720775u,  2276550099763657676u,         110022063878u },
+  {   992149349835802669u,   407006713016100654u,          68772091758u },
+  { 11165474436676191361u, 14242579061653496001u,         190972772932u },
+  { 10240785855143707184u, 17944493332678643703u,          76053515454u },
+  { 10059329918238932466u,   987185901870869451u,          61302420044u },
+  { 14791716450947031886u,  5578665155415167744u,          21262876221u },
+  { 15378882314737417403u,  4849210377429577535u,         125586119445u },
+  { 14726970229242271128u, 10811995403388891861u,         117382285949u },
+  {  5090110549507128156u,  7051931074990177293u,          76110091637u },
+  { 17185220781106503841u,  2030832259446664274u,         223329028940u },
+  {  9858517691519529306u,  6069512651054767895u,         162575098847u },
+  {  5595905546638020703u, 10608701253763958798u,         212851101602u },
+  { 15555173226968030256u, 15700053443426906716u,         111962756308u },
+  { 10745236628845355771u, 17759719234725541221u,          16823306351u },
+  {  9973314042399760760u, 15187321568916405209u,          47598488080u },
+  {  4374506813558796576u, 11040156458113129593u,         114151827759u },
+  { 15960826480426749933u,  2800727824598008496u,           5162480498u },
+  {  9636454862798615738u,  2997236166375604478u,          14339360261u },
+  { 17973331528911319269u,  6260091886451512840u,          63952637454u },
+  {  7366495200039369602u, 17573059315228347473u,          78407630399u },
+  { 10505831326526933399u,  7519453664590169250u,         176857031246u },
+  {  2803218632575724145u, 15809436065653866528u,             38067632u },
+  {  8425731874431741636u,   702223880805592151u,                    0u },
+  { 14860552245711912111u,            702223880u,                    0u },
+  {                    1u,                    0u,         234012409856u },
+  {  6993664200669526994u,   228921437623588921u,         212119037930u },
+  {  4065363582031999356u,  2195862230003073883u,          71052052948u },
+  {  6899780515342669867u,   960207412233973687u,         189133594695u },
+  { 17713500890201844939u,  2464387149230492478u,         247196883901u },
+  {  6445781125105107086u,  3631866936444955212u,          93085560055u },
+  { 13563044070717478571u,  1578304441149380226u,         223986111069u },
+  { 13167612994149348885u, 18190538519673445180u,         153068901087u },
+  {  5505463469596727288u,  1271000736479934748u,          96991663513u },
+  { 12125446212518819372u, 18292963032817745633u,         151930679904u },
+  { 12537707724735421794u, 17168014021925537454u,         165978316695u },
+  { 15173675086703777069u, 18046757712870378948u,         167805453733u },
+  { 13535510174093048476u, 14857998893911743219u,           7646922151u },
+  { 10698912997087096629u, 11933607369968684574u,         179188857095u },
+  { 16952559548431933861u,  3483798509902859161u,         107400007091u },
+  { 13528255827744249993u,  7378828438829845830u,          75856039275u },
+  { 14122167436324771955u, 15791137430347699564u,          11923964747u },
+  { 13071007137740038297u, 17044141236829932640u,         221491992075u },
+  { 13011887609328904025u,  9075651910862456483u,          46965547485u },
+  {  3116434332871336590u, 17811207355884564094u,          59240619054u },
+  {  9050993820536772770u,  4438638126207305936u,          57678058555u },
+  { 11993719123438634238u, 12507972635512950184u,         225794626361u },
+  {  1414857165879849301u, 14658269128098109407u,         119197456865u },
+  { 13819438220812375094u,  3642436268910286110u,         196205082231u },
+  {  6073063033888264440u,  3783099432964819560u,          54514864836u },
+  {  6828883869150720294u,  9497579866027539637u,         222184053046u },
+  {  4548265621068768345u,  3395179445046271360u,         152321926878u },
+  { 10422524923581371874u,  5938502732309497275u,         224314075544u },
+  {  1858996082510682634u,  5793671185917606254u,         224048207584u },
+  {   890276727450878316u,   889272970253526587u,          90465891296u },
+  {  3886008133802710905u,  8594177504370135500u,         102399764570u },
+  {   612074409233016757u,  7374354721120724711u,         190800386918u },
+  {  3927020336901729264u, 14764532643665507566u,                 2494u },
+  {  5298603480094474942u,       46020944252475u,                    0u },
+  { 17418383752590430025u,                46020u,                    0u },
+  {                    1u,                    0u,          45292322816u },
+  {  8973799690601597929u,  5392404173658087694u,         121269781293u },
+  {  1343055462055792431u,  4976586473237854315u,          83342007929u },
+  { 17425118728683169659u,  6308932742419013568u,          51261934931u },
+  { 18389781726026675967u,  4831846642430703058u,         102983344691u },
+  {   272526939565961561u, 18139507855949846900u,         231263777382u },
+  { 11293026845930963228u,  4865833876326628409u,         113775023591u },
+  { 13997416438903902597u, 14296661839130179260u,         163501702257u },
+  {  6186605805999441184u,  9254773150378118247u,         221659992483u },
+  {  4401776373281836138u, 12174712433727875142u,          65038253533u },
+  { 16338917089754547008u,   705653145340915198u,         114962984513u },
+  { 13337700757935003056u, 17763928858962481811u,          50215910002u },
+  { 14612496890816348693u,  3982836567612046295u,         156690140722u },
+  {  3219935399907691719u, 12730849277561967738u,          88938620316u },
+  { 10887238730052330387u, 17314488764367235907u,         102864728152u },
+  {   360256418697768294u, 15951418930590301118u,          37389952614u },
+  {   321440824631118565u,  7193356087283467260u,         136953715493u },
+  { 10069228080701402580u, 17592945625696089445u,         243192687752u },
+  {  9428069607611622975u,  3554461664875361427u,          46120009203u },
+  { 14736799017468812344u,  2213779057785318207u,         153210386222u },
+  { 10875332567307979280u,  3880940796082421147u,         149245476249u },
+  {  4611492910339012807u,  4528237545358141042u,         108633238933u },
+  { 10743508637597314786u, 11681196539088147362u,         140533156716u },
+  {  9356196315668016028u,  9835005502912643016u,         128269103756u },
+  { 15755598617722189347u,  4964088126040986695u,         206181905536u },
+  {  1275276394173375542u,  3355564873147047621u,          30100456398u },
+  { 12644999363867216251u,  1853093467828272926u,         105799888670u },
+  {  4553830511509832021u, 14755341584803008676u,         103254872681u },
+  {  8869400642218174412u,  4701571132542556620u,          87332245607u },
+  { 16570849151159054040u,  6128849686644853850u,          68651977815u },
+  { 16127119334101797673u, 12026867901170202093u,          86970890052u },
+  {  9686867250420930550u, 17909760324981426302u,         230157084246u },
+  { 10678226869774428035u,  2897692901883393663u,            163499238u },
+  {  7767227962910162068u,  3016028602530220424u,                    0u },
+  {  9780840471948993674u,           3016028602u,                    0u },
+  {                    1u,                    0u,         213668069376u },
+  {  6288709332106746357u, 12323704802554838153u,          16386837205u },
+  {  9066785620141948673u,  7135886931147821731u,         141831652624u },
+  {  8442375916704414909u, 15341283120292884946u,          14167660429u },
+  { 11604629218100425803u,  3092789040392634165u,         188477686542u },
+  {  3877248044010875762u,  8811761390822097864u,         134914571196u },
+  { 16435137704395217283u, 16870860798610218168u,         103946077062u },
+  { 14994442577577813271u, 17452041453591904832u,         111559165543u },
+  {  4410105917142436089u, 10314783684009874907u,         245267398767u },
+  {  4632574728444936970u,  4932636630789274902u,         202983581941u },
+  {  9117147535650050359u, 18143884346082124479u,         134153046474u },
+  {   588939301256904809u,  2823209155405527321u,          69877954182u },
+  {   324393982565305683u, 16195396106620226250u,         173062371141u },
+  {  9380909186923521175u,  1150544491807648943u,          73421074605u },
+  {  4463385697777230217u,  7767455475523884823u,          94824230985u },
+  { 16378985502426333808u, 15204378045683991807u,         211934567774u },
+  { 18210894922387834354u, 17239732561718805621u,          38698574803u },
+  {  1555748035329493205u, 12886430624522800061u,          83984577574u },
+  {  4277055533891898507u, 18162250541178258135u,         184923140435u },
+  { 11574429772510874408u, 17028935366700158083u,         219871452856u },
+  { 17391099253493808815u, 16075467823964198636u,         215531468251u },
+  {  5791212393959129882u,  9803858825574498303u,          27946729175u },
+  { 11254268231455680880u, 17464070808143041816u,         124958581275u },
+  { 16355477587312235322u, 17682703471239266775u,         227983788156u },
+  {  2411485149249320633u, 18147688354161351335u,         145361224931u },
+  { 12763114642070638360u,  6663423873348080050u,         183510511249u },
+  {  1147543073987366419u,  9417270363716235132u,         197503883703u },
+  {  8410777835225272692u,  9295013721571344178u,          63336074437u },
+  {  8134725822306818018u,  6199479138350037782u,          14048117055u },
+  {  8899607004752328377u,   887603005365085687u,         232018105614u },
+  {   690976506652396830u,   333989628642975695u,         140250490600u },
+  { 12281570945595192074u,  4620735991403939438u,          54673209484u },
+  { 12592957291365552899u, 12418523063962801200u,         219086071862u },
+  { 13595807339013970272u,  1587745622680169418u,                10715u },
+  {  9698096389749839992u,      197658450495420u,                    0u },
+  {  8310173728816391804u,               197658u,                    0u },
+};
+
+extern const uint64_t __POW10_SPLIT_2[3133][3] = {
+  {                    0u,                    0u,              3906250u },
+  {                    0u,                    0u,         202000000000u },
+  {                    0u, 11153727427136454656u,                   59u },
+  {                    0u,  7205759403792793600u,          59604644775u },
+  {                    0u,                    0u,         167390625000u },
+  {                    0u,                    0u,         232000000000u },
+  {                    0u,    16777216000000000u,                    0u },
+  {                    0u, 12945425605062557696u,               909494u },
+  {                    0u,  4388757836872548352u,         182701772928u },
+  {                    0u,  1152921504606846976u,         128237915039u },
+  {                    0u,                    0u,         159062500000u },
+  {                    0u,                    0u,         160000000000u },
+  {                    0u,         256000000000u,                    0u },
+  {                    0u, 16192327041775828992u,                   13u },
+  {                    0u, 15024075324038053888u,          13877787807u },
+  {                    0u,  5449091666327633920u,         159814456755u },
+  {                    0u,  2494994193563254784u,         179295395851u },
+  {                    0u,  4611686018427387904u,          11135253906u },
+  {                    0u,                    0u,         146250000000u },
+  {                    0u,                    0u,         128000000000u },
+  {                    0u,              3906250u,                    0u },
+  {                    0u,     3906250000000000u,                    0u },
+  {                    0u,  4368439412768899072u,               211758u },
+  {                    0u,  1563676642168012800u,          46236813575u },
+  {                    0u, 11532349341402398720u,           7084767080u },
+  {                    0u,  9048364970084925440u,         104625169910u },
+  {                    0u, 16609275425742389248u,         246490512847u },
+  {                    0u,                    0u,         207900390625u },
+  {                    0u,                    0u,         225000000000u },
+  { 11153727427136454656u,                   59u,                    0u },
+  {  7205759403792793600u,          59604644775u,                    0u },
+  {                    0u,  4264412554261970152u,                    3u },
+  {                    0u, 14485570586272534528u,           3231174267u },
+  {                    0u, 17827675094632103936u,         123785264354u },
+  {                    0u,  7347197909193981952u,         226966440203u },
+  {                    0u, 13677404030777688064u,          11398292396u },
+  {                    0u,  3810326759732150272u,         172741453558u },
+  {                    0u,  9943947977234055168u,         246206558227u },
+  {                    0u,                    0u,          19539062500u },
+  {                    0u,                    0u,         228000000000u },
+  { 12945425605062557696u,               909494u,                    0u },
+  {  4388757836872548352u,      909494701772928u,                    0u },
+  {  1152921504606846976u, 14878706826214591391u,                49303u },
+  {                    0u,  4387341015746028192u,         151806576313u },
+  {                    0u,   651726680428265472u,         185237838233u },
+  {                    0u,  2570638187944738816u,         153035330174u },
+  {                    0u,  7419175577111756800u,         126139354575u },
+  {                    0u, 17299322326264840192u,         207402194313u },
+  {                    0u,  7990511638862102528u,         137937798142u },
+  {                    0u, 16717361816799281152u,         254433166503u },
+  {                    0u,                    0u,         167906250000u },
+  {                    0u,                    0u,          16000000000u },
+  { 16192327041775828992u,                   13u,                    0u },
+  { 15024075324038053888u,          13877787807u,                    0u },
+  {  5449091666327633920u, 13877787807814456755u,                    0u },
+  {  2494994193563254784u,  9707857417284919307u,            752316384u },
+  {  4611686018427387904u,  1844515466944871826u,         224526264005u },
+  {                    0u, 15167599819856275072u,         197099991383u },
+  {                    0u, 14830185305589481472u,          87822237233u },
+  {                    0u,  6163721531743535104u,          49803945956u },
+  {                    0u, 14122847407012052992u,         228334136013u },
+  {                    0u,   335491783960035328u,         205765601092u },
+  {                    0u,   941252322120433664u,          68018187046u },
+  {                    0u, 11529215046068469760u,          38051025390u },
+  {                    0u,                    0u,         238625000000u },
+  {                    0u,                    0u,          64000000000u },
+  {  4368439412768899072u,               211758u,                    0u },
+  {  1563676642168012800u,      211758236813575u,                    0u },
+  { 11532349341402398720u,  8061591463141767016u,                11479u },
+  {  9048364970084925440u, 16628725344207857142u,         215437019748u },
+  { 16609275425742389248u,  3555541870038531535u,         100901445007u },
+  {                    0u, 18316647450161853665u,         143192746310u },
+  {                    0u, 16709574568378075648u,          70992947447u },
+  {                    0u,  7696022835795591168u,         247905827852u },
+  {                    0u, 16664449640376041472u,          12417202233u },
+  {                    0u,  3109186955116544000u,          57903381625u },
+  {                    0u, 10515518101817131008u,         121168549362u },
+  {                    0u,  9961962375743537152u,         242570047378u },
+  {                    0u,  9223372036854775808u,         146540039062u },
+  {                    0u,                    0u,         150500000000u },
+  { 14485570586272534528u,           3231174267u,                    0u },
+  { 17827675094632103936u,  3231174267785264354u,                    0u },
+  {  7347197909193981952u,   748977172262750475u,            175162308u },
+  { 13677404030777688064u, 15965033457315095468u,         196040602133u },
+  {  3810326759732150272u, 16809402149066729206u,          21865466197u },
+  {  9943947977234055168u,  7563769067065700371u,          85911239516u },
+  {                    0u, 13550322810840051428u,          92410032742u },
+  {                    0u,  8663209637545764864u,         102734564471u },
+  {                    0u,  8969247575312957440u,         119469633535u },
+  {                    0u,  6193172891660451840u,         255486223885u },
+  {                    0u,  3427954273864908800u,          13335732575u },
+  {                    0u, 10058367555266936832u,          95185829773u },
+  {                    0u, 13907115649320091648u,         141545265197u },
+  {                    0u,                    0u,          45753906250u },
+  {                    0u,                    0u,          74000000000u },
+  { 14878706826214591391u,                49303u,                    0u },
+  {  4387341015746028192u,       49303806576313u,                    0u },
+  {   651726680428265472u, 14106411361315920281u,                 2672u },
+  {  2570638187944738816u,  3609034283485221502u,         112764710092u },
+  {  7419175577111756800u,  9896072247338192335u,         204195646140u },
+  { 17299322326264840192u,  8889095178479228297u,         188536467151u },
+  {  7990511638862102528u,  3631796911038383102u,         207481878815u },
+  { 16717361816799281152u,   898318840772166823u,          31196880105u },
+  {                    0u, 17293677953982795024u,         233048697961u },
+  {                    0u,  7353628266884669440u,         105937492160u },
+  {                    0u,  2404693032470315008u,         192398640987u },
+  {                    0u,  9191155893041889280u,          91130358670u },
+  {                    0u,  6353946855033798656u,         142498253559u },
+  {                    0u,  3767824038248841216u,         247344448149u },
+  {                    0u,  7205759403792793600u,         149204254150u },
+  {                    0u,                    0u,         198390625000u },
+  {                    0u,                    0u,         232000000000u },
+  {  9707857417284919307u,            752316384u,                    0u },
+  {  1844515466944871826u,   752316384526264005u,                    0u },
+  { 15167599819856275072u, 17063068157692817751u,             40783152u },
+  { 14830185305589481472u,  5385330256507239985u,          48924990778u },
+  {  6163721531743535104u,  3373050282752075748u,          58291939338u },
+  { 14122847407012052992u,  4116064001262906061u,          10182853422u },
+  {   335491783960035328u, 11306582046748043076u,          46223132276u },
+  {   941252322120433664u, 17035410946089626406u,         116612931040u },
+  { 11529215046068469760u, 15618595715183448558u,         224923491477u },
+  {                    0u,  5141740092277295680u,         149846685770u },
+  {                    0u, 16973644291514990592u,          74278734288u },
+  {                    0u, 14625255268443750400u,         208920143100u },
+  {                    0u, 14021170507320131584u,         252792836676u },
+  {                    0u,  4451355232865091584u,          68760089176u },
+  {                    0u, 12891553933348044800u,          88241308450u },
+  {                    0u,  1152921504606846976u,          34698852539u },
+  {                    0u,                    0u,         187062500000u },
+  {                    0u,                    0u,         160000000000u },
+  {  8061591463141767016u,                11479u,                    0u },
+  { 16628725344207857142u,       11479437019748u,                    0u },
+  {  3555541870038531535u,  5562205901560339855u,                  622u },
+  { 18316647450161853665u,  2106077949367544134u,         110301527786u },
+  { 16709574568378075648u,  7496855998374373623u,         234114170714u },
+  {  7696022835795591168u,   229183437194837004u,          90406405378u },
+  { 16664449640376041472u,   465169186276472889u,           2012424059u },
+  {  3109186955116544000u,  2152980561625316473u,         123025216872u },
+  { 10515518101817131008u,  2059790725449340402u,         104116713310u },
+  {  9961962375743537152u, 17891190926410198930u,          94111661478u },
+  {  9223372036854775808u,  9930696175609809814u,         166969883403u },
+  {                    0u,  7276914261609005312u,          11538344118u },
+  {                    0u, 10539762974036983808u,         182394482312u },
+  {                    0u, 12851089458992250880u,         136571361695u },
+  {                    0u,  9449311677678878720u,         159696658955u },
+  {                    0u,  8699564697382289408u,          11512248212u },
+  {                    0u,  4224376450473525248u,         148471604347u },
+  {                    0u,  4611686018427387904u,         123229003906u },
+  {                    0u,                    0u,         130250000000u },
+  {                    0u,                    0u,         128000000000u },
+  {   748977172262750475u,            175162308u,                    0u },
+  { 15965033457315095468u,   175162308040602133u,                    0u },
+  { 16809402149066729206u, 13756840147955779925u,              9495567u },
+  {  7563769067065700371u, 13788447602092505948u,          15745759798u },
+  { 13550322810840051428u,  4972540435632173670u,          54747473242u },
+  {  8663209637545764864u,  2844874687533091959u,          90269561957u },
+  {  8969247575312957440u, 15377573779532804095u,         101154220965u },
+  {  6193172891660451840u, 17824715805091194381u,         165833619944u },
+  {  3427954273864908800u, 18277569135638159711u,         232966279779u },
+  { 10058367555266936832u,  4254645803379752845u,          99990829008u },
+  { 13907115649320091648u,  2933643244178200621u,         208230644811u },
+  {                    0u, 17188148801879487562u,          75159033118u },
+  {                    0u, 11069762501163246592u,          30931771413u },
+  {                    0u, 11676570643941818368u,          21600093027u },
+  {                    0u, 17840016768744030208u,          99632988162u },
+  {                    0u, 16463817321652158464u,           2967109246u },
+  {                    0u,  6954191143357644800u,         126892505325u },
+  {                    0u,  5080060379673919488u,         237376987457u },
+  {                    0u,                    0u,          65275390625u },
+  {                    0u,                    0u,         161000000000u },
+  { 14106411361315920281u,                 2672u,                    0u },
+  {  3609034283485221502u,        2672764710092u,                    0u },
+  {  9896072247338192335u, 16433563478020213436u,                  144u },
+  {  8889095178479228297u,  4194750497955655375u,         144890865261u },
+  {  3631796911038383102u,  2691539602252904735u,         109227397880u },
+  {   898318840772166823u,  3775467271962795241u,         248145908654u },
+  { 17293677953982795024u, 16980212613224918121u,         174204668490u },
+  {  7353628266884669440u,  4172857038337333440u,          74920499170u },
+  {  2404693032470315008u,  5936867627376461659u,         226226211033u },
+  {  9191155893041889280u, 17856837443266866062u,         217321838238u },
+  {  6353946855033798656u,  8956297047799810807u,         158968021097u },
+  {  3767824038248841216u, 15356974049716912789u,         105485521835u },
+  {  7205759403792793600u,  6923608913322982854u,         171832503231u },
+  {                    0u,  4855902993563955944u,         191375329591u },
+  {                    0u, 13835893222288330752u,          55263239028u },
+  {                    0u,  9114973913760137216u,         116750045274u },
+  {                    0u, 17937099003422310400u,          90494123725u },
+  {                    0u,  7007960010734960640u,         205972372085u },
+  {                    0u,  7683422439270776832u,         117379902273u },
+  {                    0u,   720575940379279360u,          65416519165u },
+  {                    0u,                    0u,         253039062500u },
+  {                    0u,                    0u,         228000000000u },
+  { 17063068157692817751u,             40783152u,                    0u },
+  {  5385330256507239985u,    40783152924990778u,                    0u },
+  {  3373050282752075748u,  2768933352715741194u,              2210859u },
+  {  4116064001262906061u, 15201941611824153390u,          43150104177u },
+  { 11306582046748043076u,  1418128541727000180u,         113824098906u },
+  { 17035410946089626406u,  5353350204565757408u,          90076876902u },
+  { 15618595715183448558u,  1721001680354286741u,         102290205696u },
+  {  5141740092277295680u,   637631411660453962u,             93295688u },
+  { 16973644291514990592u,  1630012588870568400u,          72034566068u },
+  { 14625255268443750400u,  9253063571656828156u,         180088363159u },
+  { 14021170507320131584u,  6029146854993203780u,         151501609581u },
+  {  4451355232865091584u, 16987401965352759896u,         109326840705u },
+  { 12891553933348044800u, 14499131620542087970u,         129920888905u },
+  {  1152921504606846976u,  1978417255298660539u,          73785999500u },
+  {                    0u,  5790079354402454176u,         140107250214u },
+  {                    0u, 13748918935842078720u,          38313880830u },
+  {                    0u, 18047438014740692992u,         254745330388u },
+  {                    0u,  3116889656839372800u,         212978353575u },
+  {                    0u, 15995952446606147584u,         167168966926u },
+  {                    0u, 12530140063251562496u,          14867142319u },
+  {                    0u, 16717361816799281152u,         175679260253u },
+  {                    0u,                    0u,          93906250000u },
+  {                    0u,                    0u,          16000000000u },
+  {  5562205901560339855u,                  622u,                    0u },
+  {  2106077949367544134u,         622301527786u,                    0u },
+  {  7496855998374373623u, 13558973353698967386u,                   33u },
+  {   229183437194837004u,  6228991722850501890u,          33735033418u },
+  {   465169186276472889u, 16886831391703377787u,          74337674317u },
+  {  2152980561625316473u,  1181713637872883048u,          77915436964u },
+  {  2059790725449340402u, 12393932434925221726u,         164064060824u },
+  { 17891190926410198930u, 10684799845419711910u,         152671876423u },
+  {  9930696175609809814u,  4590318792215640843u,          71579224160u },
+  {  7276914261609005312u,  6383712187366189238u,          96248841680u },
+  { 10539762974036983808u,  1904270214927675016u,         208346061731u },
+  { 12851089458992250880u,  3711506775113308575u,         163103230695u },
+  {  9449311677678878720u,  8091219444738793995u,         231201201185u },
+  {  8699564697382289408u,    39436684991068052u,          33438625885u },
+  {  4224376450473525248u, 18025182908196512891u,          93002137866u },
+  {  4611686018427387904u,  7853924592034603138u,          10977147123u },
+  {                    0u,  4815749283615688320u,         243425762105u },
+  {                    0u, 14242399906544287744u,          57261062291u },
+  {                    0u,    76242322576113664u,         147772082046u },
+  {                    0u, 10858088421377703936u,         126004133104u },
+  {                    0u, 14293835879041466368u,         240588618152u },
+  {                    0u, 12182236992037191680u,         168774870395u },
+  {                    0u, 11529215046068469760u,         123660400390u },
+  {                    0u,                    0u,           6625000000u },
+  {                    0u,                    0u,          64000000000u },
+  { 13756840147955779925u,              9495567u,                    0u },
+  { 13788447602092505948u,     9495567745759798u,                    0u },
+  {  4972540435632173670u, 14000097438505379162u,               514755u },
+  {  2844874687533091959u, 16451062686452429925u,         195758946802u },
+  { 15377573779532804095u,  4009347599785716645u,         242891813895u },
+  { 17824715805091194381u, 16544162347546196456u,           7217347168u },
+  { 18277569135638159711u, 17674258299745817187u,          96896860837u },
+  {  4254645803379752845u,  5215238411201214416u,         165958123462u },
+  {  2933643244178200621u, 14253990228345322571u,         198282718640u },
+  { 17188148801879487562u, 11214836553940194590u,         176772710358u },
+  { 11069762501163246592u, 14620711348380590101u,         214607957507u },
+  { 11676570643941818368u,  6638710787931587427u,           3792590350u },
+  { 17840016768744030208u, 17320000343692853250u,          14359885232u },
+  { 16463817321652158464u,    75147386268843646u,         176938919100u },
+  {  6954191143357644800u, 17938801582125480173u,         188004073747u },
+  {  5080060379673919488u,  6573358613626446145u,          19972464382u },
+  {                    0u,  8688505427903736481u,         254356342484u },
+  {                    0u,   539870168696556032u,         212471004823u },
+  {                    0u,  9002861336394465280u,         151029266420u },
+  {                    0u, 17989846818158018560u,         244488046090u },
+  {                    0u,  2700938287723315200u,          10975231550u },
+  {                    0u, 17800090499088908288u,          62146418157u },
+  {                    0u,  8809040871136690176u,         237964944839u },
+  {                    0u,  9223372036854775808u,         199477539062u },
+  {                    0u,                    0u,         246500000000u },
+  { 16433563478020213436u,                  144u,                    0u },
+  {  4194750497955655375u,         144890865261u,                    0u },
+  {  2691539602252904735u, 15763656745260536568u,                    7u },
+  {  3775467271962795241u,  8787336846248645550u,           7854549544u },
+  { 16980212613224918121u, 17584084447880694346u,          40476362484u },
+  {  4172857038337333440u, 18041672551129683938u,         244953235127u },
+  {  5936867627376461659u, 14025886302294509785u,         183978041028u },
+  { 17856837443266866062u, 18430498103283160734u,         196760344819u },
+  {  8956297047799810807u,  3292348826238025833u,         243999119304u },
+  { 15356974049716912789u,  9211721212658275243u,         200178478587u },
+  {  6923608913322982854u, 10233245872666307519u,         251499368407u },
+  {  4855902993563955944u,  6200995035623311671u,         215554745370u },
+  { 13835893222288330752u,  8480542380570450804u,          26336156614u },
+  {  9114973913760137216u, 11870363864499900506u,         198459731123u },
+  { 17937099003422310400u,  9301051379839581901u,         179643493714u },
+  {  7007960010734960640u, 11456694803569638005u,          82504211005u },
+  {  7683422439270776832u, 14327208890643983169u,          61621068669u },
+  {   720575940379279360u,  4510081789599866365u,         125776679550u },
+  {                    0u, 13255356976020303332u,         126244492023u },
+  {                    0u,  9658806854127314944u,         247718574341u },
+  {                    0u, 13708435528809971712u,           5523604968u },
+  {                    0u,  1580190652103131136u,         232743135779u },
+  {                    0u, 16557336970347413504u,          35085662306u },
+  {                    0u, 12751520132434493440u,          98897575035u },
+  {                    0u,  9295429630892703744u,         123691261291u },
+  {                    0u,                    0u,         107503906250u },
+  {                    0u,                    0u,         202000000000u },
+  {  2768933352715741194u,              2210859u,                    0u },
+  { 15201941611824153390u,     2210859150104177u,                    0u },
+  {  1418128541727000180u, 16872870088062921306u,               119850u },
+  {  5353350204565757408u,  5112979788807802982u,          42914680120u },
+  {  1721001680354286741u, 13742728082020150272u,          56277175189u },
+  {   637631411660453962u,  2217110934613627976u,         149744994782u },
+  {  1630012588870568400u, 11021433940188610484u,         222120189824u },
+  {  9253063571656828156u,  1713669895470733463u,         128597473131u },
+  {  6029146854993203780u,  3313382510572018285u,         107092898231u },
+  { 16987401965352759896u, 14976595232784069505u,         183179618825u },
+  { 14499131620542087970u,  7213172372862496841u,           9811882854u },
+  {  1978417255298660539u, 15836474542502248588u,         102391026857u },
+  {  5790079354402454176u,  3221099285878340134u,         169858497005u },
+  { 13748918935842078720u,  3265814602578095358u,         237174616142u },
+  { 18047438014740692992u,  6502528252282225364u,          78177040164u },
+  {  3116889656839372800u, 16392476834556790183u,          36352502762u },
+  { 15995952446606147584u, 15167629413417091342u,         234888637949u },
+  { 12530140063251562496u,  1366763272626280111u,         253822238838u },
+  { 16717361816799281152u,  8720523635169216093u,         118074092385u },
+  {                    0u,  9649171375767398672u,          97472740533u },
+  {                    0u,  7647980704001073152u,         181523082628u },
+  {                    0u, 13286434495608651776u,         132414597864u },
+  {                    0u,  4358271637167013888u,         232720259057u },
+  {                    0u, 15954987941890097152u,         241236262378u },
+  {                    0u,  7911135695429697536u,         234864921629u },
+  {                    0u,  7205759403792793600u,          29428863525u },
+  {                    0u,                    0u,          37390625000u },
+  {                    0u,                    0u,         232000000000u },
+  { 13558973353698967386u,                   33u,                    0u },
+  {  6228991722850501890u,          33735033418u,                    0u },
+  { 16886831391703377787u, 15288289344628122701u,                    1u },
+  {  1181713637872883048u,   952589339068938148u,           1828779826u },
+  { 12393932434925221726u, 10058155040190817688u,          50051639971u },
+  { 10684799845419711910u,  5322725640026584391u,         163545253677u },
+  {  4590318792215640843u,  2269982385930389600u,          45288545535u },
+  {  6383712187366189238u, 13216683679976310224u,         255123055991u },
+  {  1904270214927675016u, 17417440642083494819u,         119716477857u },
+  {  3711506775113308575u,  3029180749090900711u,         161944201349u },
+  {  8091219444738793995u,  8315443826261908513u,         133164212217u },
+  {    39436684991068052u,  1488962797247197277u,         249450781113u },
+  { 18025182908196512891u, 18009099634999034122u,         185080716834u },
+  {  7853924592034603138u,  8092455412807497971u,          34976275247u },
+  {  4815749283615688320u, 17808458047236758329u,          47438692886u },
+  { 14242399906544287744u,  3164591817527425171u,          22965398445u },
+  {    76242322576113664u,  3314036340472350590u,         173171552866u },
+  { 10858088421377703936u,    33234902404332784u,          98179654270u },
+  { 14293835879041466368u, 12349284717857274280u,         126001801667u },
+  { 12182236992037191680u, 18209607903013119355u,         195669456065u },
+  { 11529215046068469760u,  7891549145984268038u,         193987144822u },
+  {                    0u,  7703609897518594624u,         118427801736u },
+  {                    0u,  6336912652634587136u,         136417613529u },
+  {                    0u,  4461621834659397632u,         217343524723u },
+  {                    0u,  5484660635557953536u,         115241865004u },
+  {                    0u, 15142619273265938432u,          44297324048u },
+  {                    0u, 12170977992968765440u,          16820883035u },
+  {                    0u,  1152921504606846976u,          91659790039u },
+  {                    0u,                    0u,         215062500000u },
+  {                    0u,                    0u,         160000000000u },
+  { 14000097438505379162u,               514755u,                    0u },
+  { 16451062686452429925u,      514755758946802u,                    0u },
+  {  4009347599785716645u, 17812314011563521031u,                27904u },
+  { 16544162347546196456u,  7684138864490314336u,            965607477u },
+  { 17674258299745817187u,  9740522787420029605u,          53416558002u },
+  {  5215238411201214416u,  6701109407732989894u,         178528034798u },
+  { 14253990228345322571u, 16534886227502443952u,         238363267868u },
+  { 11214836553940194590u,  8908667306968317910u,          28896357978u },
+  { 14620711348380590101u,  7531472173477105155u,          90482939822u },
+  {  6638710787931587427u, 11527371604834801166u,         174408281924u },
+  { 17320000343692853250u, 15688593496691078576u,          68624900066u },
+  {    75147386268843646u, 11394944804253312188u,         226850480357u },
+  { 17938801582125480173u, 11182279880854372627u,         229617721195u },
+  {  6573358613626446145u,   150579373068361470u,         107606192607u },
+  {  8688505427903736481u,  3147220002440857300u,         223008162924u },
+  {   539870168696556032u,  3630514817795505815u,         108170611138u },
+  {  9002861336394465280u, 11708796588334233588u,         194196810602u },
+  { 17989846818158018560u, 16844495466426369546u,         106634735134u },
+  {  2700938287723315200u, 17636655472325475902u,          30913141928u },
+  { 17800090499088908288u, 17038926655686645229u,         168956085008u },
+  {  8809040871136690176u, 15602838456783529415u,          16923682064u },
+  {  9223372036854775808u, 10869815869248876790u,          16845831567u },
+  {                    0u, 18407124180939800832u,         143589253898u },
+  {                    0u,  5705018517251293184u,          10997852201u },
+  {                    0u,  9660452258743058432u,          41309269673u },
+  {                    0u,  5646292272224927744u,         169523694166u },
+  {                    0u,  7410409304047484928u,          86306086117u },
+  {                    0u,  5953758707383795712u,         229401719093u },
+  {                    0u,  4611686018427387904u,          53322753906u },
+  {                    0u,                    0u,         114250000000u },
+  {                    0u,                    0u,         128000000000u },
+  { 15763656745260536568u,                    7u,                    0u },
+  {  8787336846248645550u,           7854549544u,                    0u },
+  { 17584084447880694346u,  7854549544476362484u,                    0u },
+  { 18041672551129683938u,    15035424419724983u,            425795984u },
+  { 14025886302294509785u, 18280822466032836292u,         144000815071u },
+  { 18430498103283160734u, 11524250747302615283u,         223991005371u },
+  {  3292348826238025833u, 15212285943691810760u,         187624730884u },
+  {  9211721212658275243u,  7951804027551297019u,           4824659673u },
+  { 10233245872666307519u,  1706416229965221847u,         217431068160u },
+  {  6200995035623311671u,  3406023111930700826u,             92505009u },
+  {  8480542380570450804u, 16132696204133391302u,         177184640882u },
+  { 11870363864499900506u, 11593846688794356915u,         114874555213u },
+  {  9301051379839581901u,  6875759884161133906u,          77628503688u },
+  { 11456694803569638005u,  3593593325323835965u,         136372735690u },
+  { 14327208890643983169u,  9542049733257388925u,         202194809084u },
+  {  4510081789599866365u,  9926551925937787518u,         252517275552u },
+  { 13255356976020303332u,  3128491553219547895u,         160538119458u },
+  {  9658806854127314944u, 17158408656931354885u,          34169595866u },
+  { 13708435528809971712u,  2065169543154992616u,         218930159197u },
+  {  1580190652103131136u,  4832622393556232739u,          93111953065u },
+  { 16557336970347413504u, 16505930714733656162u,         169261976984u },
+  { 12751520132434493440u, 18270988073492888699u,         152894788296u },
+  {  9295429630892703744u,  2525111411519708523u,         200990472248u },
+  {                    0u, 16728989342518570442u,          56136886563u },
+  {                    0u,  7974052022039438336u,          35906880329u },
+  {                    0u,  5356554962386550784u,          73432274226u },
+  {                    0u,  6693869495028547584u,          50290379426u },
+  {                    0u,  8157517147199766528u,         162362875392u },
+  {                    0u, 12065776720423157760u,            442219890u },
+  {                    0u, 11997589407315001344u,         114654087066u },
+  {                    0u,                    0u,         154650390625u },
+  {                    0u,                    0u,          97000000000u },
+  { 16872870088062921306u,               119850u,                    0u },
+  {  5112979788807802982u,      119850914680120u,                    0u },
+  { 13742728082020150272u,  2418433229320326037u,                 6497u },
+  {  2217110934613627976u,  1143911773589293534u,          97131103528u },
+  { 11021433940188610484u,  9276183703610924928u,          40062011581u },
+  {  1713669895470733463u,  3532180128827684715u,         189502862926u },
+  {  3313382510572018285u,  8563997501322031543u,          78191479868u },
+  { 14976595232784069505u, 14843890409658460681u,          60464255234u },
+  {  7213172372862496841u,  9489417861634552678u,           2804688911u },
+  { 15836474542502248588u,  1113198223322322089u,          15514422373u },
+  {  3221099285878340134u, 11190777557146597869u,         101060346596u },
+  {  3265814602578095358u, 17764553645932638286u,         228606653266u },
+  {  6502528252282225364u, 14900777150991234852u,          82963018382u },
+  { 16392476834556790183u, 17364899863357893610u,         142807772747u },
+  { 15167629413417091342u, 15537570181590167037u,          75941353107u },
+  {  1366763272626280111u,  5558052627121307766u,         147842293367u },
+  {  8720523635169216093u, 12095241565795232609u,         119301302636u },
+  {  9649171375767398672u,  2187936505958366389u,         108655684359u },
+  {  7647980704001073152u, 12009203621325860228u,           7118608275u },
+  { 13286434495608651776u, 14814842834750302952u,         147651020232u },
+  {  4358271637167013888u,  5965296499605198833u,         200803114239u },
+  { 15954987941890097152u,  4051026394962148842u,         255323379371u },
+  {  7911135695429697536u, 16799526299141688349u,         171219606580u },
+  {  7205759403792793600u,  9460214166646215205u,          52910704145u },
+  {                    0u, 10750736995029068008u,          17512839237u },
+  {                    0u,  5377963045376430080u,          69582798620u },
+  {                    0u, 15996910350253424640u,          28291539960u },
+  {                    0u, 13651157529655246848u,         248867194247u },
+  {                    0u,  9771305410219737088u,         135740030732u },
+  {                    0u, 12709439623416250368u,          12529703527u },
+  {                    0u,  9943947977234055168u,         103688980102u },
+  {                    0u,                    0u,         134539062500u },
+  {                    0u,                    0u,         228000000000u },
+  {   952589339068938148u,           1828779826u,                    0u },
+  { 10058155040190817688u,  1828779826051639971u,                    0u },
+  {  5322725640026584391u,   371564423966525229u,             99138353u },
+  {  2269982385930389600u, 14464859121514339583u,          49020142547u },
+  { 13216683679976310224u,  3913119023023056247u,         211784141584u },
+  { 17417440642083494819u,  5493396321716566945u,          16212130607u },
+  {  3029180749090900711u,  5837454566818211973u,          47297797611u },
+  {  8315443826261908513u,  2886670683193253881u,         235316449046u },
+  {  1488962797247197277u,  5504823105587173817u,          22156486731u },
+  { 18009099634999034122u,  9431834277334851106u,          75298417058u },
+  {  8092455412807497971u, 12921661346456247087u,         162511300760u },
+  { 17808458047236758329u,  3643076516404724246u,         152700484665u },
+  {  3164591817527425171u, 12559396953196866477u,          57197491573u },
+  {  3314036340472350590u,  1626880974916825698u,         117680846273u },
+  {    33234902404332784u,  6806994170946429566u,         193088193394u },
+  { 12349284717857274280u,  7596631230206896579u,         114369007893u },
+  { 18209607903013119355u,  3100480253729502401u,          21411814204u },
+  {  7891549145984268038u,  6310570748781063286u,          60168077371u },
+  {  7703609897518594624u, 14251867077375744136u,          59342096725u },
+  {  6336912652634587136u,  6701165793751570137u,          85772595262u },
+  {  4461621834659397632u, 10856833140463959923u,          62363270925u },
+  {  5484660635557953536u, 15867563727561248556u,          13588550103u },
+  { 15142619273265938432u,  5048961008671491600u,         215860182353u },
+  { 12170977992968765440u, 13278183119599849051u,          81273704724u },
+  {  1152921504606846976u,  4547591784941053655u,          20719811749u },
+  {                    0u, 11815437715887182496u,         165246525444u },
+  {                    0u,   398495392178782208u,           4640516162u },
+  {                    0u,  9154841240825495552u,          66021602478u },
+  {                    0u,  1902683298245640192u,         174496284938u },
+  {                    0u,  5081900962138816512u,          10103144668u },
+  {                    0u,  3234710432358858752u,         220275490403u },
+  {                    0u, 16717361816799281152u,          99175354003u },
+  {                    0u,                    0u,         147906250000u },
+  {                    0u,                    0u,          16000000000u },
+  { 17812314011563521031u,                27904u,                    0u },
+  {  7684138864490314336u,       27904965607477u,                    0u },
+  {  9740522787420029605u, 13488568028574514610u,                 1512u },
+  {  6701109407732989894u,   275784718433886190u,         232731216738u },
+  { 16534886227502443952u, 10020568880357102364u,          98014950319u },
+  {  8908667306968317910u,  8876397213146246746u,         175543216127u },
+  {  7531472173477105155u,  2155905919114811310u,         255481190457u },
+  { 11527371604834801166u,  1087100407155601220u,          57116871894u },
+  { 15688593496691078576u,  2903498381705011170u,         214058931831u },
+  { 11394944804253312188u, 12223476257006657765u,         119157398962u },
+  { 11182279880854372627u, 12148657163736735595u,         178662635975u },
+  {   150579373068361470u,  8951241323311673823u,         199658580024u },
+  {  3147220002440857300u,  8463862715901576300u,          56485247764u },
+  {  3630514817795505815u,  3873401978748963266u,          20458826917u },
+  { 11708796588334233588u,   248364795947002730u,         165209977542u },
+  { 16844495466426369546u, 10454378025404001822u,         198013463882u },
+  { 17636655472325475902u,  6574176865628265640u,          74566732968u },
+  { 17038926655686645229u,    16703315293848336u,         168356386842u },
+  { 15602838456783529415u,  9896033222450013456u,          26000905488u },
+  { 10869815869248876790u, 17311376269334085007u,          16536465035u },
+  { 18407124180939800832u, 18378511316495639306u,         139938451587u },
+  {  5705018517251293184u, 15120796393727584297u,         131996301094u },
+  {  9660452258743058432u, 18253447805740347049u,          38819700014u },
+  {  5646292272224927744u,  5842497225601731158u,          46989521388u },
+  {  7410409304047484928u,  4369968404176723173u,         236316722409u },
+  {  5953758707383795712u, 16142207253674488117u,         233236896461u },
+  {  4611686018427387904u, 12124259227391928178u,         205875070808u },
+  {                    0u, 13019483264566077056u,          88657257409u },
+  {                    0u,    74901376448135168u,         193705787602u },
+  {                    0u, 13897060093813325824u,         210004060411u },
+  {                    0u,  4495486210810052608u,         251753361137u },
+  {                    0u, 14885496280087265280u,         241243700795u },
+  {                    0u,  4976477588244398080u,          59806944370u },
+  {                    0u, 11529215046068469760u,         114269775390u },
+  {                    0u,                    0u,          30625000000u },
+  {                    0u,                    0u,          64000000000u },
+  {    15035424419724983u,            425795984u,                    0u },
+  { 18280822466032836292u,   425795984000815071u,                    0u },
+  { 11524250747302615283u, 10043594327130472635u,             23082446u },
+  { 15212285943691810760u,  8336034337032909060u,         206544464339u },
+  {  7951804027551297019u, 16717215784895280857u,         211451897326u },
+  {  1706416229965221847u, 10968831263951212032u,         238906242083u },
+  {  3406023111930700826u,  5536629379734406065u,          35594621534u },
+  { 16132696204133391302u,  1618806894932332402u,          94300141280u },
+  { 11593846688794356915u, 11363331325254998861u,         224087755697u },
+  {  6875759884161133906u,  8775167772751754888u,         177616007425u },
+  {  3593593325323835965u,  2898202945316114122u,           1475702798u },
+  {  9542049733257388925u,  8868842714495185148u,          14157111896u },
+  {  9926551925937787518u, 17052094667531999136u,          88480780926u },
+  {  3128491553219547895u,  3658615537031138594u,         126924395904u },
+  { 17158408656931354885u, 12486952437987190746u,         128198333945u },
+  {  2065169543154992616u,   912079238520577629u,         249676919048u },
+  {  4832622393556232739u, 10960072898031888041u,           8049443914u },
+  { 16505930714733656162u,  6129550094334741912u,          74594146742u },
+  { 18270988073492888699u,  7965724516573729480u,         182332283576u },
+  {  2525111411519708523u,  5801761178810791992u,         184431822791u },
+  { 16728989342518570442u, 13197466483098446115u,         199314514103u },
+  {  7974052022039438336u, 11326268638393107273u,         183715436091u },
+  {  5356554962386550784u,  3597339351794947378u,          59613998253u },
+  {  6693869495028547584u,   353880726151383714u,         173195012157u },
+  {  8157517147199766528u, 11154818162602073600u,          61019183912u },
+  { 12065776720423157760u,  5141043976157511026u,          40604703904u },
+  { 11997589407315001344u,  7188225141808859034u,         160278696552u },
+  {                    0u, 13894168943295705185u,         104389674465u },
+  {                    0u, 12176538069834828288u,         225753204407u },
+  {                    0u,  7994239409235165184u,         183660091451u },
+  {                    0u, 13707777025480065024u,          59433368586u },
+  {                    0u, 10120227247676719104u,          10743100081u },
+  {                    0u,  7358494763030413312u,         177548618618u },
+  {                    0u,  7656119366529843200u,         122398904800u },
+  {                    0u,  9223372036854775808u,         224415039062u },
+  {                    0u,                    0u,          86500000000u },
+  {  2418433229320326037u,                 6497u,                    0u },
+  {  1143911773589293534u,        6497131103528u,                    0u },
+  {  9276183703610924928u,  3877189582299842749u,                  352u },
+  {  3532180128827684715u,  7625565791857948238u,          96210182868u },
+  {  8563997501322031543u, 16568435163612007484u,         212413382749u },
+  { 14843890409658460681u, 17592071940521808130u,          93898176669u },
+  {  9489417861634552678u, 15158637878035490831u,         157953668130u },
+  {  1113198223322322089u, 17789243229146401893u,          34821751405u },
+  { 11190777557146597869u, 14677686051252896484u,         109964356807u },
+  { 17764553645932638286u,  3531237481269211986u,         199795678955u },
+  { 14900777150991234852u,  8074435404989280910u,         235191428767u },
+  { 17364899863357893610u,  7086549341467684427u,         159437716020u },
+  { 15537570181590167037u, 10556134770918626963u,          52384162609u },
+  {  5558052627121307766u, 10772666134712966775u,          49572249212u },
+  { 12095241565795232609u,  6195173298198112620u,         124583987401u },
+  {  2187936505958366389u,  8144773843324250887u,         201335841017u },
+  { 12009203621325860228u, 14144284817150924691u,         249441529074u },
+  { 14814842834750302952u,  6464447844648863176u,         242766763216u },
+  {  5965296499605198833u, 15760468443293179135u,         208350438419u },
+  {  4051026394962148842u,  5172191224908322475u,          19854376706u },
+  { 16799526299141688349u,  2357554307308969012u,           2280385048u },
+  {  9460214166646215205u,  1602046917604361745u,          24127803275u },
+  { 10750736995029068008u,  7830970218109515845u,         139086847137u },
+  {  5377963045376430080u,  2899479134887821084u,         161424517746u },
+  { 15996910350253424640u, 15792042302392017912u,         114157181078u },
+  { 13651157529655246848u, 11286099112296056199u,         150856088328u },
+  {  9771305410219737088u, 15161477829153947404u,           8611820658u },
+  { 12709439623416250368u,   423831848142641767u,         114821905360u },
+  {  9943947977234055168u,  9707413321046312582u,         208022975970u },
+  {                    0u, 10969483299803835620u,         226526239930u },
+  {                    0u,  4326479556120930304u,         186594656881u },
+  {                    0u, 12876227232041795584u,         113234538926u },
+  {                    0u, 16967986827791171584u,         174698021676u },
+  {                    0u,  1288146316538413056u,          44919836409u },
+  {                    0u, 13715290452691779584u,         249069830551u },
+  {                    0u,  4683743612465315840u,         151743507385u },
+  {                    0u,                    0u,         185253906250u },
+  {                    0u,                    0u,          74000000000u },
+  {   371564423966525229u,             99138353u,                    0u },
+  { 14464859121514339583u,    99138353020142547u,                    0u },
+  {  3913119023023056247u, 16344805304534272784u,              5374300u },
+  {  5493396321716566945u,    26429987091348271u,          92886053671u },
+  {  5837454566818211973u,  8691371289609838059u,          39001432772u },
+  {  2886670683193253881u, 12980168378493046550u,         196471160181u },
+  {  5504823105587173817u, 14010125458129496139u,         117703656337u },
+  {  9431834277334851106u, 17061829677031795106u,         145759490422u },
+  { 12921661346456247087u,  2227928323072698520u,         118924923640u },
+  {  3643076516404724246u,  7394752319272287289u,         248120776236u },
+  { 12559396953196866477u,  8805771303577744757u,          44400870326u },
+  {  1626880974916825698u, 16371027194302248385u,         182477361818u },
+  {  6806994170946429566u,  9114324123731231602u,         154887475162u },
+  {  7596631230206896579u, 14468189808746991893u,         218494088500u },
+  {  3100480253729502401u,  2376054557800684348u,          52784322141u },
+  {  6310570748781063286u, 12462238943546048571u,          93128806175u },
+  { 14251867077375744136u, 15334855370842605909u,          31675579326u },
+  {  6701165793751570137u,  7211347914013798462u,         190831304175u },
+  { 10856833140463959923u, 13763642332572548877u,         239390927953u },
+  { 15867563727561248556u, 16868268377740071383u,          81746128545u },
+  {  5048961008671491600u,  1120013377627684177u,         161914430661u },
+  { 13278183119599849051u, 15898107650717274388u,         197060716046u },
+  {  4547591784941053655u, 12281923376333274277u,          14861838142u },
+  { 11815437715887182496u,  6383530489286615044u,          62665804400u },
+  {   398495392178782208u,  4253822060257126466u,         112346051881u },
+  {  9154841240825495552u, 17614372438391501998u,          41230600155u },
+  {  1902683298245640192u,  4309951310554333450u,         219954877043u },
+  {  5081900962138816512u, 13106185988973773020u,         115233642928u },
+  {  3234710432358858752u,  2070134359761960547u,         176710487766u },
+  { 16717361816799281152u,  9399359914137865875u,         214112222208u },
+  {                    0u, 17415053284723541264u,            509540321u },
+  {                    0u,  4840502610448261120u,         225944071930u },
+  {                    0u,  5690599259712258048u,         250262404172u },
+  {                    0u,   114769594245185536u,          76308488004u },
+  {                    0u,  3150620882578178048u,          68006221672u },
+  {                    0u,  5136918324969472000u,         104170795500u },
+  {                    0u,  7205759403792793600u,         236278472900u },
+  {                    0u,                    0u,         196390625000u },
+  {                    0u,                    0u,         232000000000u },
+  { 13488568028574514610u,                 1512u,                    0u },
+  {   275784718433886190u,        1512731216738u,                    0u },
+  { 10020568880357102364u,    98202693831717807u,                   82u },
+  {  8876397213146246746u, 12909287260170414079u,          82005323578u },
+  {  2155905919114811310u, 11728631949380786233u,          58699813864u },
+  {  1087100407155601220u, 18263701925522197718u,         232635810411u },
+  {  2903498381705011170u,  4868886449713321591u,         107990077265u },
+  { 12223476257006657765u,  5870139507184082354u,          81263942863u },
+  { 12148657163736735595u,  5978562500822661575u,         207318220900u },
+  {  8951241323311673823u, 10821136839630268472u,         100324098522u },
+  {  8463862715901576300u,  9490907630136752916u,         218586615003u },
+  {  3873401978748963266u, 10564005678001613989u,         219514503133u },
+  {   248364795947002730u,  5754050547468481222u,         221572675895u },
+  { 10454378025404001822u,  3833909949855542602u,          55311927705u },
+  {  6574176865628265640u, 15446538552665967784u,         153207836674u },
+  {    16703315293848336u, 14924837848804399130u,           2837358532u },
+  {  9896033222450013456u, 18140170340418344208u,         196809077080u },
+  { 17311376269334085007u, 11380424819825208971u,          88983380604u },
+  { 18378511316495639306u, 12416915664152252547u,         124616934065u },
+  { 15120796393727584297u, 17195282241626289958u,         177673122346u },
+  { 18253447805740347049u,  2649541045825281326u,          42932158118u },
+  {  5842497225601731158u, 16577429864268509676u,         166143631907u },
+  {  4369968404176723173u, 12051257060168107241u,          35898664273u },
+  { 16142207253674488117u,  5363884561143470797u,          81653299954u },
+  { 12124259227391928178u, 13054029903083620184u,         242290776764u },
+  { 13019483264566077056u,   566314952158634945u,         188707660379u },
+  {    74901376448135168u,  1329472079642345682u,          91030699995u },
+  { 13897060093813325824u, 15686237486658857211u,         219072070825u },
+  {  4495486210810052608u,  1069073549290598129u,         169850352638u },
+  { 14885496280087265280u,  4323599065125928507u,         254057954593u },
+  {  4976477588244398080u, 17861823329752681586u,          33234382774u },
+  { 11529215046068469760u, 17220149985412802078u,         182968291382u },
+  {                    0u,  4344934572159429184u,          54933506201u },
+  {                    0u,  2252927464837120000u,         153235539375u },
+  {                    0u, 10910018171964489728u,         175122131442u },
+  {                    0u,  3597328585515335680u,         242591433270u },
+  {                    0u,  6972808074239148032u,          54195011573u },
+  {                    0u,  2227030015734710272u,         245377996683u },
+  {                    0u,  1152921504606846976u,         139120727539u },
+  {                    0u,                    0u,         243062500000u },
+  {                    0u,                    0u,         160000000000u },
+  { 10043594327130472635u,             23082446u,                    0u },
+  {  8336034337032909060u,    23082446544464339u,                    0u },
+  { 16717215784895280857u, 17238287503805244910u,              1251301u },
+  { 10968831263951212032u,  1434575446038410275u,         229934489438u },
+  {  5536629379734406065u, 14009569747841241694u,          94077768490u },
+  {  1618806894932332402u, 14938795732275951328u,          42759460297u },
+  { 11363331325254998861u,  6687653542888983473u,         201809833739u },
+  {  8775167772751754888u,    28238723295162625u,          11362538425u },
+  {  2898202945316114122u,  4745270274832691214u,         185001530824u },
+  {  8868842714495185148u,   926478968112308824u,         200257241617u },
+  { 17052094667531999136u,  9213681606604198526u,          17050224525u },
+  {  3658615537031138594u, 13346223820579313024u,         141499474680u },
+  { 12486952437987190746u,   691642518601291257u,         248723500243u },
+  {   912079238520577629u,  1153720150033789192u,         211037494016u },
+  { 10960072898031888041u, 12089015034721780810u,             62543294u },
+  {  6129550094334741912u,  3555868702841788854u,         190655346818u },
+  {  7965724516573729480u, 11708406782758214328u,         130192764028u },
+  {  5801761178810791992u,  9417497762905343943u,         124634714003u },
+  { 13197466483098446115u, 12838336066957615287u,         147510523576u },
+  { 11326268638393107273u, 13737708142128207419u,         184695967592u },
+  {  3597339351794947378u, 11683434809834695853u,         104744722650u },
+  {   353880726151383714u,  2689114340106315837u,         218633360270u },
+  { 11154818162602073600u,  8859225263374261032u,         142145777180u },
+  {  5141043976157511026u, 15761671984578600096u,          28480259563u },
+  {  7188225141808859034u,  7087267079878005352u,         235854441950u },
+  { 13894168943295705185u,  4601291730423121377u,         222384201518u },
+  { 12176538069834828288u,  9559411037059581623u,          46249436524u },
+  {  7994239409235165184u, 12969820289641388091u,         108518216710u },
+  { 13707777025480065024u, 13628239920285957130u,           6703095366u },
+  { 10120227247676719104u,  8049893933765800625u,          70738788366u },
+  {  7358494763030413312u, 10391755948840250234u,          14436385624u },
+  {  7656119366529843200u, 14454650777462444512u,          88563338218u },
+  {  9223372036854775808u, 14244638523341127254u,         234783588188u },
+  {                    0u, 12246016810439753984u,          92772203401u },
+  {                    0u,  9382741764551081984u,         137663857901u },
+  {                    0u,  4608696190291148800u,         237508639450u },
+  {                    0u,  1696483666416369664u,         218249837921u },
+  {                    0u, 15416683541605384192u,          97091966563u },
+  {                    0u,  7683140964294066176u,          99835740089u },
+  {                    0u,  4611686018427387904u,         185416503906u },
+  {                    0u,                    0u,          98250000000u },
+  {                    0u,                    0u,         128000000000u },
+  {  3877189582299842749u,                  352u,                    0u },
+  {  7625565791857948238u,         352210182868u,                    0u },
+  { 16568435163612007484u,  1722045467931902045u,                   19u },
+  { 17592071940521808130u, 16095324008152856733u,          19093352271u },
+  { 15158637878035490831u, 15216188060094280738u,          79872529262u },
+  { 17789243229146401893u, 10793385929903030893u,         110824871207u },
+  { 14677686051252896484u, 12613277226875940039u,          39585110623u },
+  {  3531237481269211986u, 10644539625155600107u,          95683767128u },
+  {  8074435404989280910u,  6181262895644173983u,          88577041649u },
+  {  7086549341467684427u,   148914399627082292u,         241335086933u },
+  { 10556134770918626963u, 14379289774887985969u,          85008072665u },
+  { 10772666134712966775u, 11743339675582627452u,         217779502860u },
+  {  6195173298198112620u,  7841621929809463497u,          12636607719u },
+  {  8144773843324250887u, 11168944680251236601u,         231425095176u },
+  { 14144284817150924691u,  6178560202529287410u,           8605469704u },
+  {  6464447844648863176u, 13295243308201596112u,           8334940419u },
+  { 15760468443293179135u, 17040673746172470291u,           3720736583u },
+  {  5172191224908322475u, 14957442487039409922u,          71923776774u },
+  {  2357554307308969012u, 17778155426506992152u,           6810844581u },
+  {  1602046917604361745u, 14945404984219733899u,         165963755736u },
+  {  7830970218109515845u, 11590754866058681505u,         216810192027u },
+  {  2899479134887821084u,  6020790784469412466u,         155628336080u },
+  { 15792042302392017912u,  7934351824569522326u,         208326387722u },
+  { 11286099112296056199u,  5038361112172116744u,          10430122074u },
+  { 15161477829153947404u,  3305187319649924210u,          90273130103u },
+  {   423831848142641767u, 11470175511099161552u,         119179174563u },
+  {  9707413321046312582u,  7308362160352048610u,         163621799460u },
+  { 10969483299803835620u, 10666410671225576634u,          36396187106u },
+  {  4326479556120930304u,  2181639019945820785u,         226578227281u },
+  { 12876227232041795584u,  4615749499734847918u,          81118266888u },
+  { 16967986827791171584u, 14076159200958497580u,           8250220281u },
+  {  1288146316538413056u,  5470405257862074105u,         249763070119u },
+  { 13715290452691779584u,  4565741478181339543u,         167296551263u },
+  {  4683743612465315840u,  8901832997861862329u,          95247509341u },
+  {                    0u, 14190141170191714122u,          93482569333u },
+  {                    0u,  4240772322245764096u,         117769249094u },
+  {                    0u,  4422842195340951552u,          70229892728u },
+  {                    0u, 15448426386733137920u,         120239762755u },
+  {                    0u,  9203504548935630848u,          67837460872u },
+  {                    0u,  5936377627571912704u,         136498922981u },
+  {                    0u,   468374361246531584u,         229321811676u },
+  {                    0u,                    0u,         220025390625u },
+  {                    0u,                    0u,          33000000000u },
+  { 16344805304534272784u,              5374300u,                    0u },
+  {    26429987091348271u,     5374300886053671u,                    0u },
+  {  8691371289609838059u,  8020875056524075716u,               291341u },
+  { 12980168378493046550u,  1400288714762747253u,          13434812508u },
+  { 14010125458129496139u,  6136037711314764689u,          92075909803u },
+  { 17061829677031795106u, 15735488086392394102u,         171332635270u },
+  {  2227928323072698520u,  7735094782793634552u,         134853022518u },
+  {  7394752319272287289u,  7273689191766726188u,          54419320328u },
+  {  8805771303577744757u,  3410634565056431030u,           8394307481u },
+  { 16371027194302248385u,  4600927904885215898u,         153184890870u },
+  {  9114324123731231602u,  9154871331680374746u,         246249416801u },
+  { 14468189808746991893u,  6117978272461042996u,          97496286569u },
+  {  2376054557800684348u, 13116904339287496285u,         105331656266u },
+  { 12462238943546048571u,   867037205615660831u,          74711068809u },
+  { 15334855370842605909u,  1802487145191504830u,         137047002181u },
+  {  7211347914013798462u, 17242009718457409007u,          69097713023u },
+  { 13763642332572548877u, 13620802355488468049u,         127934691219u },
+  { 16868268377740071383u,  4442227880594435745u,         147738385175u },
+  {  1120013377627684177u, 17354849212854314181u,          23240813655u },
+  { 15898107650717274388u, 18202319179831567886u,          87940808260u },
+  { 12281923376333274277u, 17568634016348874558u,          68986749699u },
+  {  6383530489286615044u,  7496925598312450672u,           3952397558u },
+  {  4253822060257126466u,   601870379496813865u,         246406409151u },
+  { 17614372438391501998u, 11995106565680728027u,         191032627458u },
+  {  4309951310554333450u, 16331071694764184179u,           2650256029u },
+  { 13106185988973773020u,  9665962217000524208u,         157885309170u },
+  {  2070134359761960547u, 13682661374415474390u,         242523992861u },
+  {  9399359914137865875u,  6940361789924260864u,          29741738559u },
+  { 17415053284723541264u,  9658039831644010465u,          63376237766u },
+  {  4840502610448261120u,  6843715893910236922u,         198523563388u },
+  {  5690599259712258048u,    47089792870595660u,         124370998582u },
+  {   114769594245185536u, 14510386192097156932u,          54002552742u },
+  {  3150620882578178048u, 12059931208360040296u,         166786609611u },
+  {  5136918324969472000u, 14877013468459184620u,         203653770180u },
+  {  7205759403792793600u,  2397668560671695044u,         196806484516u },
+  {                    0u,  2195572305559232232u,          36129977873u },
+  {                    0u,  3261686279425953792u,          17119022213u },
+  {                    0u,  9333850662059900928u,         133176816367u },
+  {                    0u,  5036522340217782272u,         239505989058u },
+  {                    0u,  2800120215143186432u,         194273030423u },
+  {                    0u,   441634238459019264u,          23151794821u },
+  {                    0u,   720575940379279360u,         133023941040u },
+  {                    0u,                    0u,         176039062500u },
+  {                    0u,                    0u,         228000000000u },
+  {    98202693831717807u,                   82u,                    0u },
+  { 12909287260170414079u,          82005323578u,                    0u },
+  { 11728631949380786233u,  8218347283861607400u,                    4u },
+  { 18263701925522197718u, 17896200385973633643u,           4445517498u },
+  {  4868886449713321591u, 16333242102094352209u,         186970154966u },
+  {  5870139507184082354u,  9981905728606788815u,         214885426828u },
+  {  5978562500822661575u, 15219470018924839012u,         140541120193u },
+  { 10821136839630268472u, 17152070168529617370u,         193825049122u },
+  {  9490907630136752916u, 17841343440958328027u,          34929815586u },
+  { 10564005678001613989u, 17291078023923990493u,          34967181165u },
+  {  5754050547468481222u, 16744804581790759223u,         109937351217u },
+  {  3833909949855542602u,  5001622214111594905u,          49907737675u },
+  { 15446538552665967784u,  9676746897435398146u,          75271138483u },
+  { 14924837848804399130u,  8109025833995118532u,         179524577500u },
+  { 18140170340418344208u,  5495826424046694744u,         220439591171u },
+  { 11380424819825208971u,  7890288164365705852u,           3297929347u },
+  { 12416915664152252547u,  8616438349039895217u,         131427733378u },
+  { 17195282241626289958u, 15787154801788760618u,         130467098058u },
+  {  2649541045825281326u, 12418659311480782502u,         202855823376u },
+  { 16577429864268509676u,  4486988874116669987u,          16673216870u },
+  { 12051257060168107241u,  4828971301551875409u,         102243240154u },
+  {  5363884561143470797u, 14769106422014442226u,         218261779058u },
+  { 13054029903083620184u,  7763933466423188156u,         114800634863u },
+  {   566314952158634945u, 10449097116253839963u,         239420883676u },
+  {  1329472079642345682u, 12870692502472900571u,         220566446689u },
+  { 15686237486658857211u, 11597479481311003817u,          97697721638u },
+  {  1069073549290598129u,  8294994869530047486u,          38628700622u },
+  {  4323599065125928507u, 16879315829924478241u,         206449672572u },
+  { 17861823329752681586u, 11873324837601439670u,         124915029544u },
+  { 17220149985412802078u,  3277599055636107318u,          40643654229u },
+  {  4344934572159429184u, 15363467897354242201u,          85177679000u },
+  {  2252927464837120000u, 10351182204479784367u,         152832855263u },
+  { 10910018171964489728u, 12811517584931924466u,         223561138711u },
+  {  3597328585515335680u, 16988930699558748726u,          23694513759u },
+  {  6972808074239148032u, 11683499918824718325u,          95920971778u },
+  {  2227030015734710272u, 13119300691281647499u,           2633363799u },
+  {  1152921504606846976u, 10125549106595354099u,          87711198715u },
+  {                    0u, 17505352699870800544u,         251548907116u },
+  {                    0u,  6756039242241163264u,         108948967071u },
+  {                    0u,  3537338758766526464u,         159366245621u },
+  {                    0u,  6522626374119718912u,         245191759518u },
+  {                    0u,  4733294203482669056u,         158353592284u },
+  {                    0u, 16997710893603094528u,         220256592392u },
+  {                    0u, 16717361816799281152u,           8921447753u },
+  {                    0u,                    0u,          73906250000u },
+  {                    0u,                    0u,          16000000000u },
+  { 17238287503805244910u,              1251301u,                    0u },
+  {  1434575446038410275u,     1251301934489438u,                    0u },
+  { 14009569747841241694u,  3943737498063000362u,                67833u },
+  { 14938795732275951328u,  2870731037991212489u,         249213790438u },
+  {  6687653542888983473u,  7389433400402095883u,         230155622641u },
+  {    28238723295162625u,  5675049236146197433u,         241400581987u },
+  {  4745270274832691214u,  9953779846262904264u,          99307645035u },
+  {   926478968112308824u, 12691978937179636241u,         107539595486u },
+  {  9213681606604198526u, 15523327331528198029u,         222688033556u },
+  { 13346223820579313024u, 15722603279568118520u,          20841521260u },
+  {   691642518601291257u, 11838632364171816147u,         108852324031u },
+  {  1153720150033789192u,  7832751832367143680u,         191641773546u },
+  { 12089015034721780810u, 12167724027162940862u,         234424614327u },
+  {  3555868702841788854u,  4108211144748152962u,         183659613641u },
+  { 11708406782758214328u,  7530983398136343676u,         201222706572u },
+  {  9417497762905343943u,  1117587133956542355u,         140408255428u },
+  { 12838336066957615287u, 17134748625149490872u,         196060584519u },
+  { 13737708142128207419u,  4039918359454207848u,          71928876584u },
+  { 11683434809834695853u,  1830218764589441242u,          40219004413u },
+  {  2689114340106315837u,   637895981480825742u,         253099216358u },
+  {  8859225263374261032u,  8246879226348334620u,         230034580410u },
+  { 15761671984578600096u, 12389239568142583275u,         186447064218u },
+  {  7087267079878005352u, 14041257178803154398u,         154671622022u },
+  {  4601291730423121377u, 16312515716494630702u,         134761178076u },
+  {  9559411037059581623u, 17088522799596987756u,         220884303248u },
+  { 12969820289641388091u,  3588932524637852678u,         144926370677u },
+  { 13628239920285957130u,   107218049069817414u,         117194556422u },
+  {  8049893933765800625u,  1596707240462008334u,           6005812302u },
+  { 10391755948840250234u, 17461913142391587672u,          78086557672u },
+  { 14454650777462444512u,  4366474266651610090u,         232946612208u },
+  { 14244638523341127254u,  5539304013194805084u,         240236707044u },
+  { 12246016810439753984u,  4762470619211987849u,         228300286272u },
+  {  9382741764551081984u, 10835638458986644717u,          64258174049u },
+  {  4608696190291148800u, 16141642290510052058u,          97587401137u },
+  {  1696483666416369664u, 17390568670756355425u,         177875040181u },
+  { 15416683541605384192u, 12536768491333867107u,         181942744616u },
+  {  7683140964294066176u, 13145148522871947193u,          40679619581u },
+  {  4611686018427387904u,  5665349945233068642u,         253712599929u },
+  {                    0u, 17074607537751066240u,         121307119235u },
+  {                    0u,  6241525660962062336u,         131925616329u },
+  {                    0u,  1142860629783085056u,         201338353784u },
+  {                    0u, 16287527416870469632u,         120061954598u },
+  {                    0u,  9028002014738513920u,          38882948630u },
+  {                    0u, 16217462258161156096u,          22489408969u },
+  {                    0u, 11529215046068469760u,         201879150390u },
+  {                    0u,                    0u,          54625000000u },
+  {                    0u,                    0u,          64000000000u },
+  {  1722045467931902045u,                   19u,                    0u },
+  { 16095324008152856733u,          19093352271u,                    0u },
+  { 15216188060094280738u,   646608198162977646u,                    1u },
+  { 10793385929903030893u, 12170458846894708007u,           1035052700u },
+  { 12613277226875940039u,  1797330480103086687u,         156659761896u },
+  { 10644539625155600107u, 10332188564497263448u,         232097433480u },
+  {  6181262895644173983u,  7524259485079594225u,         136560109064u },
+  {   148914399627082292u,    62681109059153749u,           8407890924u },
+  { 14379289774887985969u, 13480636451804037081u,         236003397949u },
+  { 11743339675582627452u,  6948168233012789004u,          61730786766u },
+  {  7841621929809463497u, 12015502974041806055u,         206376660954u },
+  { 11168944680251236601u,  7343801660689004040u,         218651361721u },
+  {  6178560202529287410u, 13670580858640731144u,         185398108285u },
+  { 13295243308201596112u,  5605073897566574851u,         125741083673u },
+  { 17040673746172470291u, 15387788940505247559u,          25303851664u },
+  { 14957442487039409922u, 17565181499678113030u,         144834173709u },
+  { 17778155426506992152u,  1893743623847493029u,          13952210397u },
+  { 14945404984219733899u, 10243498996716269784u,         221102660047u },
+  { 11590754866058681505u,  5619675836950314139u,         207555301193u },
+  {  6020790784469412466u, 10224869737511515088u,          73304643237u },
+  {  7934351824569522326u,  2574495974386198538u,         165554291299u },
+  {  5038361112172116744u,  7825756347302873178u,          99139563706u },
+  {  3305187319649924210u, 12071550103794656887u,         186424235101u },
+  { 11470175511099161552u,  7195875213867606691u,          93654400042u },
+  {  7308362160352048610u, 18271364438406891044u,          42390089176u },
+  { 10666410671225576634u, 16966521933952564706u,         216990492650u },
+  {  2181639019945820785u,   289920862029570129u,         234919756997u },
+  {  4615749499734847918u,  7804199568098625032u,         197015716641u },
+  { 14076159200958497580u,  5758118571242446585u,          33423066506u },
+  {  5470405257862074105u,  4030788293606375591u,         138312148233u },
+  {  4565741478181339543u,  4387716460037196127u,           9218509471u },
+  {  8901832997861862329u, 16807506478881285981u,         159237858585u },
+  { 14190141170191714122u, 17033060604413529717u,          25911136751u },
+  {  4240772322245764096u, 10498418508292170054u,         239923364065u },
+  {  4422842195340951552u, 13237752038744465016u,         225569120407u },
+  { 15448426386733137920u, 17737618428304633155u,         151717619975u },
+  {  9203504548935630848u, 13546183833248825736u,           7961558221u },
+  {  5936377627571912704u,   826778452978976229u,         205734340097u },
+  {   468374361246531584u, 13728076626990147292u,           1044819749u },
+  {                    0u,  2794860281883592225u,          37744200525u },
+  {                    0u,  8680705720425908736u,          77151509679u },
+  {                    0u,   731520517439488000u,         175470582000u },
+  {                    0u, 13120812320768917504u,         240039655806u },
+  {                    0u,  2722954908557901824u,         126711280661u },
+  {                    0u,  6860847004205973504u,          21147611681u },
+  {                    0u,  6503197861922996224u,          33371927261u },
+  {                    0u,  9223372036854775808u,         221352539062u },
+  {                    0u,                    0u,         182500000000u },
+  {  8020875056524075716u,               291341u,                    0u },
+  {  1400288714762747253u,      291341434812508u,                    0u },
+  {  6136037711314764689u, 12005656413127238315u,                15793u },
+  { 15735488086392394102u,  4821130826186787462u,         177650827938u },
+  {  7735094782793634552u, 14377899467066168118u,         162261354025u },
+  {  7273689191766726188u, 16575613239625444872u,          41779427491u },
+  {  3410634565056431030u,  4317827099179284377u,         163898565794u },
+  {  4600927904885215898u,  1242354770412171254u,         162234069876u },
+  {  9154871331680374746u,   994838588328896609u,         116067348187u },
+  {  6117978272461042996u, 17283309862013060457u,         219053930307u },
+  { 13116904339287496285u,   124242522249856586u,          67936930105u },
+  {   867037205615660831u, 11564608014666985609u,          57006735200u },
+  {  1802487145191504830u, 12401028575581654085u,          96626918656u },
+  { 17242009718457409007u,  2490725392961465727u,            672261106u },
+  { 13620802355488468049u,  1949482237120640915u,         242135022494u },
+  {  4442227880594435745u, 15410502396166200087u,         158105681643u },
+  { 17354849212854314181u, 15694919529799920727u,         235835405008u },
+  { 18202319179831567886u, 10324869370171768388u,         208850823292u },
+  { 17568634016348874558u,  1631866459122189059u,         124559712290u },
+  {  7496925598312450672u,   172020494461226230u,          34088463658u },
+  {   601870379496813865u, 12734610307908856767u,          42009325249u },
+  { 11995106565680728027u,  1467513250829340930u,         193690344608u },
+  { 16331071694764184179u, 13558759428494307997u,         160079554052u },
+  {  9665962217000524208u,  7915355143999496434u,           4735021821u },
+  { 13682661374415474390u,  2876370200608797469u,         253429092262u },
+  {  6940361789924260864u,   343685370404989503u,         166155928341u },
+  {  9658039831644010465u,  4837266557407634630u,          21018631221u },
+  {  6843715893910236922u,  9622591415747161468u,          53262228745u },
+  {    47089792870595660u, 16503783814424220982u,           9521641725u },
+  { 14510386192097156932u,  5377083431343591334u,         253894671913u },
+  { 12059931208360040296u, 16508482371299291595u,          41291492276u },
+  { 14877013468459184620u, 10515883558812249028u,         180894926622u },
+  {  2397668560671695044u,    63492062913405476u,          30570067190u },
+  {  2195572305559232232u, 11571919759617799697u,         246003441911u },
+  {  3261686279425953792u,  2956602334970088581u,         247627315027u },
+  {  9333850662059900928u, 13604736747717849839u,          83160277733u },
+  {  5036522340217782272u, 16573540719338151362u,         229737514256u },
+  {  2800120215143186432u, 12620703004601168151u,          16898453442u },
+  {   441634238459019264u, 14649407809089591941u,         194684169680u },
+  {   720575940379279360u, 11290375247898624432u,         208794145988u },
+  {                    0u, 11020319450292874212u,         196612052468u },
+  {                    0u,  8754634933362354176u,         244597412714u },
+  {                    0u, 12976319450332528640u,         106474589710u },
+  {                    0u, 17447331119627239424u,          14703447686u },
+  {                    0u,  3665184902673858560u,         134945821715u },
+  {                    0u, 12949678516038795264u,          19198690071u },
+  {                    0u,    72057594037927936u,          23702003479u },
+  {                    0u,                    0u,          23003906250u },
+  {                    0u,                    0u,         202000000000u },
+  {  8218347283861607400u,                    4u,                    0u },
+  { 17896200385973633643u,           4445517498u,                    0u },
+  { 16333242102094352209u,  4445517498970154966u,                    0u },
+  {  9981905728606788815u,  9413159735776077452u,            240991986u },
+  { 15219470018924839012u, 14279163482889998017u,         242510288411u },
+  { 17152070168529617370u,  8693044629541194274u,          27774075003u },
+  { 17841343440958328027u, 11863110253260222498u,         123471250893u },
+  { 17291078023923990493u,  8319293368489531245u,         205643100495u },
+  { 16744804581790759223u,  3376307525676489265u,          79450989797u },
+  {  5001622214111594905u, 13205662254759912523u,         229183029997u },
+  {  9676746897435398146u,  5276250334231686323u,         237715880385u },
+  {  8109025833995118532u, 13790198520922745052u,         193286026103u },
+  {  5495826424046694744u, 14195535250150996227u,         119747568159u },
+  {  7890288164365705852u, 16425228796427004035u,          31769541507u },
+  {  8616438349039895217u,  4295900841296269186u,         131890413437u },
+  { 15787154801788760618u,  4533952595483946442u,         125232881251u },
+  { 12418659311480782502u, 12885038019373447184u,          99245786062u },
+  {  4486988874116669987u, 12140736240487831910u,         206698499310u },
+  {  4828971301551875409u,  6927124077155322074u,         238658150630u },
+  { 14769106422014442226u, 12477788342407819890u,         230375520148u },
+  {  7763933466423188156u,  7980854329409711087u,         148676422261u },
+  { 10449097116253839963u,  2062671021810827996u,         117432642980u },
+  { 12870692502472900571u,  2739521363598172769u,         164111817620u },
+  { 11597479481311003817u, 12897585686593465638u,         148148509750u },
+  {  8294994869530047486u,  1127632646629044686u,          54699179521u },
+  { 16879315829924478241u,  4833775019274666364u,           1061129088u },
+  { 11873324837601439670u, 15867662672939849256u,         128262039468u },
+  {  3277599055636107318u,  2092350330982953557u,         172860187717u },
+  { 15363467897354242201u, 13330062299842493592u,          69113426538u },
+  { 10351182204479784367u,  4479193352178519263u,         106722624125u },
+  { 12811517584931924466u,  3149393938889064983u,         125242817558u },
+  { 16988930699558748726u,  9736379904070620767u,          22170728987u },
+  { 11683499918824718325u,  3816238703055069186u,          27527810212u },
+  { 13119300691281647499u, 11598915938798661975u,         164206878714u },
+  { 10125549106595354099u, 17821633264606555643u,         250628778492u },
+  { 17505352699870800544u,  2514623558764574316u,         252966112675u },
+  {  6756039242241163264u,  4976730480406253215u,         163136318016u },
+  {  3537338758766526464u, 17276563697191611637u,          64269789099u },
+  {  6522626374119718912u, 12524734095940998814u,         171936564394u },
+  {  4733294203482669056u, 15331551308930355164u,         170678967195u },
+  { 16997710893603094528u, 15417115581125943816u,         155831125061u },
+  { 16717361816799281152u,  6010750237807115593u,          69835763510u },
+  {                    0u,  5624630987553628432u,          54325843423u },
+  {                    0u, 14881848243837640704u,         223304911856u },
+  {                    0u, 15281613886881529856u,         240806746609u },
+  {                    0u, 14057902358273196032u,         241828417948u },
+  {                    0u, 16075318494433902592u,         156762080413u },
+  {                    0u, 13891916000577716224u,         157871444761u },
+  {                    0u,  7205759403792793600u,          25753082275u },
+  {                    0u,                    0u,         163390625000u },
+  {                    0u,                    0u,         232000000000u },
+  {  3943737498063000362u,                67833u,                    0u },
+  {  2870731037991212489u,       67833213790438u,                    0u },
+  {  7389433400402095883u,  4535831408134330609u,                 3677u },
+  {  5675049236146197433u,  6204770794376564579u,          93245887913u },
+  {  9953779846262904264u, 13869812122751887467u,         169336361298u },
+  { 12691978937179636241u, 14253229412394467550u,          82751884021u },
+  { 15523327331528198029u, 12776557610216045332u,         245772669114u },
+  { 15722603279568118520u, 16493640728678654060u,         186692618575u },
+  { 11838632364171816147u,  9434398296825833151u,          79894122055u },
+  {  7832751832367143680u,  8773374058285327850u,          71511439756u },
+  { 12167724027162940862u, 12932015276748029367u,         140475605560u },
+  {  4108211144748152962u, 16293958583527755209u,          56701045952u },
+  {  7530983398136343676u, 13511893936143127948u,         192883297264u },
+  {  1117587133956542355u, 18409936402005226436u,         240732481237u },
+  { 17134748625149490872u,  2189663026458466887u,         213998004652u },
+  {  4039918359454207848u,  9497725274248154664u,         172118701870u },
+  {  1830218764589441242u, 14766925481127792125u,          46514872718u },
+  {   637895981480825742u,  6982373971809635814u,         142800516634u },
+  {  8246879226348334620u,  8616702383006884794u,          26378515251u },
+  { 12389239568142583275u,  3059473300040871066u,          51467112372u },
+  { 14041257178803154398u, 17123843157031495558u,         180165854379u },
+  { 16312515716494630702u, 11210627174210626524u,         171928285397u },
+  { 17088522799596987756u, 15868067138625928592u,         213607729316u },
+  {  3588932524637852678u,  4467869511636937589u,         164860209643u },
+  {   107218049069817414u, 10052108125844341766u,         235242203691u },
+  {  1596707240462008334u,  7470588003218451534u,          43544925873u },
+  { 17461913142391587672u,  2613527085490786280u,         177404981387u },
+  {  4366474266651610090u,  3632919450036549616u,         139141679587u },
+  {  5539304013194805084u,   179367907231218916u,         227196940958u },
+  {  4762470619211987849u, 13553068184555874624u,         158009723553u },
+  { 10835638458986644717u,  8798774862365584481u,         161734713298u },
+  { 16141642290510052058u,   910911255817064881u,         210476982541u },
+  { 17390568670756355425u,  2304331144765093813u,          13049380598u },
+  { 12536768491333867107u, 12248937023083640360u,         246124918041u },
+  { 13145148522871947193u, 10206039550662130685u,          25664016206u },
+  {  5665349945233068642u, 12267881323837852537u,          78553270512u },
+  { 17074607537751066240u,  2858642007937891971u,         240665043179u },
+  {  6241525660962062336u, 14171330289750320841u,         235154967293u },
+  {  1142860629783085056u,  6601103619749017720u,         253768229354u },
+  { 16287527416870469632u,  4919573414486739494u,         234357846544u },
+  {  9028002014738513920u,  3401998285294974486u,          16266690609u },
+  { 16217462258161156096u, 10799436256515532233u,          49184422696u },
+  { 11529215046068469760u, 10083786644665753398u,          40585438612u },
+  {                    0u,  6481194517685688896u,         148546643169u },
+  {                    0u, 15104161756860547072u,         225351346258u },
+  {                    0u,  9556039274244079616u,          82818798249u },
+  {                    0u,  1376343134954323968u,         169518033927u },
+  {                    0u, 15682488278596976640u,           7074611710u },
+  {                    0u,  1506454075355430912u,         254850149393u },
+  {                    0u,  1152921504606846976u,          17081665039u },
+  {                    0u,                    0u,          15062500000u },
+  {                    0u,                    0u,         160000000000u },
+  { 12170458846894708007u,           1035052700u,                    0u },
+  {  1797330480103086687u,  1035052700659761896u,                    0u },
+  { 10332188564497263448u,  6172559441576707976u,             56110319u },
+  {  7524259485079594225u, 15083329738554729992u,         239334615117u },
+  {    62681109059153749u, 10013126833549229036u,          77817668943u },
+  { 13480636451804037081u,  5817156823499936061u,          79542812693u },
+  {  6948168233012789004u,  5282692560913632718u,          21315348703u },
+  { 12015502974041806055u, 10252307034225766362u,         223286375337u },
+  {  7343801660689004040u, 17981881283247669689u,         169555778677u },
+  { 13670580858640731144u, 11689290159733383293u,         117974799737u },
+  {  5605073897566574851u,  5530668968487988249u,         121633677689u },
+  { 15387788940505247559u, 10083765740821947024u,         121299818165u },
+  { 17565181499678113030u,  2798423656816843533u,         181546642036u },
+  {  1893743623847493029u,  7614494481582904797u,         116151702850u },
+  { 10243498996716269784u, 17811318500083423695u,          66412782572u },
+  {  5619675836950314139u, 11641467412200329033u,         236965553510u },
+  { 10224869737511515088u, 17733593025296340645u,         102631085212u },
+  {  2574495974386198538u,  3689424000190644835u,         156961340004u },
+  {  7825756347302873178u, 14966634145516728506u,         100200004075u },
+  { 12071550103794656887u, 14171681941562070109u,         235811342862u },
+  {  7195875213867606691u,  8130575762882608170u,          14768248417u },
+  { 18271364438406891044u,  5234550794400656856u,          97440759395u },
+  { 16966521933952564706u,  3020576149360486378u,          99283765567u },
+  {   289920862029570129u,  3038675756589057221u,          63163745761u },
+  {  7804199568098625032u, 15470260187120878369u,         225164726942u },
+  {  5758118571242446585u,  3497929414841828746u,         158838644485u },
+  {  4030788293606375591u,  9935840636861015305u,           5189623133u },
+  {  4387716460037196127u,  3647355485153741471u,          93538623000u },
+  { 16807506478881285981u,   766100215038272793u,          24197723537u },
+  { 17033060604413529717u, 16128087474216800751u,         145041530375u },
+  { 10498418508292170054u, 16216631732633731297u,           7874305373u },
+  { 13237752038744465016u, 13760220872779997335u,          93879105367u },
+  { 17737618428304633155u,  3826276262374222087u,          87745943068u },
+  { 13546183833248825736u, 14938032745839181005u,          28207422851u },
+  {   826778452978976229u, 14479259995009508865u,         131809792377u },
+  { 13728076626990147292u,  2372033248156102437u,         121784922257u },
+  {  2794860281883592225u,   792005346826701645u,         145128588180u },
+  {  8680705720425908736u, 16278924527931792559u,         148042934695u },
+  {   731520517439488000u, 17442516423538940144u,         167882482266u },
+  { 13120812320768917504u,    13844184233048446u,          90945560710u },
+  {  2722954908557901824u, 13486193870480782357u,         134000750494u },
+  {  6860847004205973504u, 11931315179184648737u,         158731088034u },
+  {  6503197861922996224u, 16492562205587485405u,         162646797891u },
+  {  9223372036854775808u, 12128987217680380854u,          67894063588u },
+  {                    0u, 10568123814189138176u,         228657513714u },
+  {                    0u, 17007583519117541376u,         242572899139u },
+  {                    0u,   143791533903052800u,          67921982950u },
+  {                    0u, 12398714235792654336u,         230007794954u },
+  {                    0u,  9659957317919047680u,          10672135645u },
+  {                    0u,  9412523221204336640u,         221523667335u },
+  {                    0u,  4611686018427387904u,         135510253906u },
+  {                    0u,                    0u,          82250000000u },
+  {                    0u,                    0u,         128000000000u },
+  { 12005656413127238315u,                15793u,                    0u },
+  {  4821130826186787462u,       15793650827938u,                    0u },
+  { 14377899467066168118u,  3237900842885170729u,                  856u },
+  { 16575613239625444872u,  7515893506498066595u,          88175526956u },
+  {  4317827099179284377u,  7300206309181072546u,          44407437403u },
+  {  1242354770412171254u,     5999737279837044u,          91395744977u },
+  {   994838588328896609u,  7556839307242450651u,         209000325246u },
+  { 17283309862013060457u, 12946035041643640643u,         126409657079u },
+  {   124242522249856586u, 15885877642352740665u,         247701805965u },
+  { 11564608014666985609u, 10770818348246089568u,         141861175152u },
+  { 12401028575581654085u, 11635415503599551744u,         112583887232u },
+  {  2490725392961465727u,  6248053924100826098u,         128630757138u },
+  {  1949482237120640915u, 16894170802729859998u,          18338707681u },
+  { 15410502396166200087u,  6143589029651889899u,         225915834834u },
+  { 15694919529799920727u, 11812087701837886160u,         210333044628u },
+  { 10324869370171768388u,  7306705080150829180u,         148640334557u },
+  {  1631866459122189059u,  1485332570280714274u,         221396097276u },
+  {   172020494461226230u, 18042602303295630634u,         252080520039u },
+  { 12734610307908856767u, 13397029889257074369u,         103978091430u },
+  {  1467513250829340930u,  9948104869613411488u,         166726254445u },
+  { 13558759428494307997u, 10836066241170646532u,         109539287845u },
+  {  7915355143999496434u, 18330574781234459389u,          37587424327u },
+  {  2876370200608797469u,   666297360208433062u,          71993702450u },
+  {   343685370404989503u,  5035352224889324309u,          50036120052u },
+  {  4837266557407634630u,  1341745796439923765u,         244272966991u },
+  {  9622591415747161468u,  6846932182653803785u,          79072736185u },
+  { 16503783814424220982u,  6727685027257825533u,         185371172937u },
+  {  5377083431343591334u,  2168538874806877737u,          73364708536u },
+  { 16508482371299291595u, 17694936100676971444u,         184117556727u },
+  { 10515883558812249028u,  2163944241059563294u,         247959244408u },
+  {    63492062913405476u,  6727780864524301558u,         120117307652u },
+  { 11571919759617799697u,  8599551977795002615u,           4364713731u },
+  {  2956602334970088581u, 15428264807806859091u,           3466182646u },
+  { 13604736747717849839u,  2126771385339683557u,         246836367911u },
+  { 16573540719338151362u, 15094316562082972944u,          39115292507u },
+  { 12620703004601168151u,  8111300598225956802u,          91818264540u },
+  { 14649407809089591941u,  9481215200564260304u,         220439714486u },
+  { 11290375247898624432u, 16836674128623424708u,         182513977705u },
+  { 11020319450292874212u,  7087243115299722740u,         105912717933u },
+  {  8754634933362354176u,  2343560867338408810u,         109384200219u },
+  { 12976319450332528640u,  3431385749090422286u,          27127044689u },
+  { 17447331119627239424u,  3504545517469224582u,          81186015794u },
+  {  3665184902673858560u,  3333759805712094227u,          50189981793u },
+  { 12949678516038795264u,  3595183476205994775u,          97180723481u },
+  {    72057594037927936u, 14191566632569921303u,          25194895286u },
+  {                    0u, 12917427671358095562u,         182769326368u },
+  {                    0u,  3883793922738316288u,          32700255157u },
+  {                    0u,  7857281689266421760u,         181210540890u },
+  {                    0u, 15987081651486195712u,          90425944093u },
+  {                    0u, 16827562156399525888u,          29866661432u },
+  {                    0u,  7012737938513461248u,          56912223972u },
+  {                    0u,  7385903388887613440u,         228380161285u },
+  {                    0u,                    0u,           5400390625u },
+  {                    0u,                    0u,         225000000000u },
+  {  9413159735776077452u,            240991986u,                    0u },
+  { 14279163482889998017u,   240991986510288411u,                    0u },
+  {  8693044629541194274u, 14135788013842776187u,             13064201u },
+  { 11863110253260222498u, 13284322918167594445u,           9766302603u },
+  {  8319293368489531245u,  7264587765474046287u,         139720144588u },
+  {  3376307525676489265u, 16176482219778368741u,         204393814091u },
+  { 13205662254759912523u,  5401983818872095469u,          75876928858u },
+  {  5276250334231686323u, 11208857446851049921u,          90292842129u },
+  { 13790198520922745052u, 13794690008281035639u,         145607633379u },
+  { 14195535250150996227u, 14519782740993303071u,         227747811643u },
+  { 16425228796427004035u, 10885858587044789123u,          59787118999u },
+  {  4295900841296269186u,  8710500938899914621u,         151590123576u },
+  {  4533952595483946442u,  1284182587483102819u,          56472197202u },
+  { 12885038019373447184u, 10346074482131502030u,          82069615677u },
+  { 12140736240487831910u,  9429804686255246574u,          61560861821u },
+  {  6927124077155322074u,  6412022633845121254u,         125511190736u },
+  { 12477788342407819890u,  8892351297529018260u,         208347596443u },
+  {  7980854329409711087u, 14098160105983060597u,         155482055329u },
+  {  2062671021810827996u, 13793833029739474340u,         161764262790u },
+  {  2739521363598172769u, 16367653765996977044u,         134747765186u },
+  { 12897585686593465638u, 10684788343333772342u,         194887292288u },
+  {  1127632646629044686u, 13272681218705145345u,         128579223536u },
+  {  4833775019274666364u, 11093568615497829248u,         240719513490u },
+  { 15867662672939849256u, 12488220765137758124u,         146601383559u },
+  {  2092350330982953557u,  3727114642519696453u,         135676987804u },
+  { 13330062299842493592u, 11549865375695057514u,         156202047289u },
+  {  4479193352178519263u, 11292809154908783229u,          57626119456u },
+  {  3149393938889064983u, 17723904861837310998u,          32612184410u },
+  {  9736379904070620767u, 14877674388187150875u,          90960814807u },
+  {  3816238703055069186u, 12178961950105734308u,         215806520344u },
+  { 11598915938798661975u,  4540604068069253114u,          24660222850u },
+  { 17821633264606555643u, 13832478722153359868u,         130246146639u },
+  {  2514623558764574316u,  1308046668730371491u,          79749860174u },
+  {  4976730480406253215u, 18400531023544756800u,          78070909351u },
+  { 17276563697191611637u,  9789823458621466539u,         167997494785u },
+  { 12524734095940998814u,  1924870562610267306u,           1530707393u },
+  { 15331551308930355164u,  5290016144582400923u,         193104347442u },
+  { 15417115581125943816u, 15162883663174059077u,          50286772349u },
+  {  6010750237807115593u,  8078086116520046390u,         125821981570u },
+  {  5624630987553628432u, 15731407332173190623u,         130437913925u },
+  { 14881848243837640704u,  5346389182763011056u,          69852801300u },
+  { 15281613886881529856u,  6368422217216252401u,          20289828338u },
+  { 14057902358273196032u,  2961453088119116188u,         242345232860u },
+  { 16075318494433902592u, 10932141691610170525u,         220160540693u },
+  { 13891916000577716224u, 11034016191361782553u,          21592632588u },
+  {  7205759403792793600u,  5455325785621453219u,          12598155216u },
+  {                    0u,  7735615202566149352u,         208295733803u },
+  {                    0u,  7502396497775759360u,          43419348540u },
+  {                    0u,  1601286435751591936u,          60406705729u },
+  {                    0u, 11449383158571597824u,          65086805911u },
+  {                    0u, 13043944595690356736u,         151620672304u },
+  {                    0u,  7773494431818186752u,          48707113653u },
+  {                    0u,  9943947977234055168u,         181421401977u },
+  {                    0u,                    0u,         121539062500u },
+  {                    0u,                    0u,         228000000000u },
+  {  4535831408134330609u,                 3677u,                    0u },
+  {  6204770794376564579u,        3677245887913u,                    0u },
+  { 13869812122751887467u,  6343817245135589714u,                  199u },
+  { 14253229412394467550u, 17549323075660516085u,         199343899021u },
+  { 12776557610216045332u,  3948641822109421754u,         141951350710u },
+  { 16493640728678654060u,  1750739713693534543u,         182214056302u },
+  {  9434398296825833151u,   962163898128633415u,         110094907790u },
+  {  8773374058285327850u,  7967320249386531212u,         142052159009u },
+  { 12932015276748029367u,  3018466665533383224u,          33431909296u },
+  { 16293958583527755209u, 15076865731854945472u,         176163631405u },
+  { 13511893936143127948u,   691187172844604400u,          45817318529u },
+  { 18409936402005226436u, 13274492813370992341u,         129037469331u },
+  {  2189663026458466887u,  6364168818499152300u,         147719611697u },
+  {  9497725274248154664u, 17599380787401914158u,          49345002282u },
+  { 14766925481127792125u,  3782323149461692814u,          42954064344u },
+  {  6982373971809635814u, 14470163442442237466u,         216205040148u },
+  {  8616702383006884794u,   476109872130437939u,          20784429132u },
+  {  3059473300040871066u, 16330548844673355700u,          76025809967u },
+  { 17123843157031495558u, 14089158961463739563u,          47885280826u },
+  { 11210627174210626524u, 13385510793074798805u,          58763774837u },
+  { 15868067138625928592u,  1549401308746959012u,         117725629994u },
+  {  4467869511636937589u,  4607384943843027435u,          42083993213u },
+  { 10052108125844341766u,  5157353797716093483u,         125249766838u },
+  {  7470588003218451534u, 10846828782671550129u,         182279580709u },
+  {  2613527085490786280u,  9915857350819131531u,          37588007766u },
+  {  3632919450036549616u,  1673544973504317923u,          86537539704u },
+  {   179367907231218916u, 14780986291622785694u,         120090723054u },
+  { 13553068184555874624u,  8168111319515466401u,         238801278872u },
+  {  8798774862365584481u, 16345760387859734482u,         152442794201u },
+  {   910911255817064881u,  3177475373321281805u,         217886105446u },
+  {  2304331144765093813u,  2558676822419554038u,         102172251285u },
+  { 12248937023083640360u,  8813474062662382873u,         149138706148u },
+  { 10206039550662130685u,  5426294560236228430u,         228477779386u },
+  { 12267881323837852537u,  9919177474128333040u,         186294160017u },
+  {  2858642007937891971u,  6197383943089627371u,         145537719688u },
+  { 14171330289750320841u, 13673239314867423997u,         136335960856u },
+  {  6601103619749017720u,  9309584098968723946u,          24741227788u },
+  {  4919573414486739494u,  4647101757759615504u,          12504673565u },
+  {  3401998285294974486u,  1405809295505096753u,          29251919891u },
+  { 10799436256515532233u, 11332704079573859112u,          19076209074u },
+  { 10083786644665753398u,  2960072434514044308u,         178614347119u },
+  {  6481194517685688896u,  3887266602785432801u,         111160465848u },
+  { 15104161756860547072u, 14545546084687849554u,         184210729144u },
+  {  9556039274244079616u,  4617763804182385321u,         184788515633u },
+  {  1376343134954323968u,  7857823815580249095u,          49250329477u },
+  { 15682488278596976640u, 10939326736548364798u,         133425973482u },
+  {  1506454075355430912u, 12262012446566951953u,         234593022090u },
+  {  1152921504606846976u, 12555024338687723023u,         138664725026u },
+  {                    0u,  3332969632922829472u,          34680609233u },
+  {                    0u, 15535060143360327680u,         209180680645u },
+  {                    0u, 15794322927987458048u,         197842157297u },
+  {                    0u, 10571474314433921024u,         241856211961u },
+  {                    0u, 16679514427547975680u,         249573080770u },
+  {                    0u, 16925653299565166592u,         194904198288u },
+  {                    0u, 16717361816799281152u,         144917541503u },
+  {                    0u,                    0u,         127906250000u },
+  {                    0u,                    0u,          16000000000u },
+  {  6172559441576707976u,             56110319u,                    0u },
+  { 15083329738554729992u,    56110319334615117u,                    0u },
+  { 10013126833549229036u,  9335385384027907407u,              3041746u },
+  {  5817156823499936061u, 13237828406194798613u,         210506072255u },
+  {  5282692560913632718u, 15667486867836528863u,         191717624115u },
+  { 10252307034225766362u, 17982325043592934313u,          51849336164u },
+  { 17981881283247669689u, 17159117626917379189u,         100974823793u },
+  { 11689290159733383293u,  8336208968408929657u,         113930197630u },
+  {  5530668968487988249u, 12767090573379150201u,         126451906793u },
+  { 10083765740821947024u, 14736070002412246709u,         233692105366u },
+  {  2798423656816843533u,  9697296975344560756u,         150798843955u },
+  {  7614494481582904797u,  7291706381199103298u,          51525691522u },
+  { 17811318500083423695u, 18098546597780825068u,         130395284194u },
+  { 11641467412200329033u,   132913902678533478u,         226981124177u },
+  { 17733593025296340645u,  1879347741692007580u,          81007205277u },
+  {  3689424000190644835u,  4056624629214083684u,         157101879645u },
+  { 14966634145516728506u, 14713227692042795499u,          93219910061u },
+  { 14171681941562070109u,  7366415124022528526u,         173797605671u },
+  {  8130575762882608170u,   825770353378039393u,          39399334164u },
+  {  5234550794400656856u, 10244023944395357795u,          20044765100u },
+  {  3020576149360486378u, 14302658294713551167u,         172555329650u },
+  {  3038675756589057221u, 14246653166206862817u,         114775348659u },
+  { 15470260187120878369u, 12404486258134291102u,         179772312615u },
+  {  3497929414841828746u,  8887442218637942533u,          39672448547u },
+  {  9935840636861015305u,  1186724038081863005u,          35481789208u },
+  {  3647355485153741471u,   211331772484951576u,          24064332439u },
+  {   766100215038272793u,  6311919513247413649u,         151011456318u },
+  { 16128087474216800751u,  8131780018703965703u,          62342169842u },
+  { 16216631732633731297u,  2262544347226725725u,         242440824678u },
+  { 13760220872779997335u, 15318188749880522583u,         102122652774u },
+  {  3826276262374222087u,  1073117094162650652u,         102830400676u },
+  { 14938032745839181005u,  4447950380665871747u,         164058173794u },
+  { 14479259995009508865u,  5373227185066463609u,          98241123873u },
+  {  2372033248156102437u,  6739731406934274193u,          33291283229u },
+  {   792005346826701645u, 12328812617001239444u,          29365361571u },
+  { 16278924527931792559u,  3246111484407310759u,         163668346271u },
+  { 17442516423538940144u,  3250825415176839770u,         159175972056u },
+  {    13844184233048446u, 16146270540000862342u,         216176227598u },
+  { 13486193870480782357u, 15686773375425916830u,          14875291079u },
+  { 11931315179184648737u, 11920791905793880226u,         199850381688u },
+  { 16492562205587485405u,  1853290561644080707u,         120646227424u },
+  { 12128987217680380854u, 12157689141506159076u,         224100467082u },
+  { 10568123814189138176u, 18100318838862562546u,         138659069648u },
+  { 17007583519117541376u,  7171257882533475139u,         208981220250u },
+  {   143791533903052800u, 14477550873015039462u,         154388754668u },
+  { 12398714235792654336u,  8109481182495403274u,         236784829605u },
+  {  9659957317919047680u, 14565395719337663965u,         165439615855u },
+  {  9412523221204336640u,  1860318978161305991u,         111789591684u },
+  {  4611686018427387904u, 16268646275151585618u,         132100848093u },
+  {                    0u, 13759019338835519104u,         221881925081u },
+  {                    0u, 17003783176010661888u,         217745877932u },
+  {                    0u, 18357489540307877888u,         172921776932u },
+  {                    0u,   905481790074912768u,          36995161502u },
+  {                    0u,  3638882110636294144u,         158049086266u },
+  {                    0u,  9011702854368362496u,          58197264194u },
+  {                    0u, 11529215046068469760u,          66488525390u },
+  {                    0u,                    0u,          78625000000u },
+  {                    0u,                    0u,          64000000000u },
+  {  3237900842885170729u,                  856u,                    0u },
+  {  7515893506498066595u,         856175526956u,                    0u },
+  {  7300206309181072546u,  7625299565768063067u,                   46u },
+  {     5999737279837044u, 13889021769065194705u,          46413368317u },
+  {  7556839307242450651u, 14498170692313014398u,         253752925378u },
+  { 12946035041643640643u,  1541631360972245751u,         194785947408u },
+  { 15885877642352740665u,  9903958882920799117u,          16083572003u },
+  { 10770818348246089568u, 15744148547788062576u,          35536894686u },
+  { 11635415503599551744u, 17936061801321712000u,         222853492002u },
+  {  6248053924100826098u,  9986394078324430610u,          34972315858u },
+  { 16894170802729859998u, 13849561248103430369u,         210541363507u },
+  {  6143589029651889899u, 12142378807953854930u,          51750786219u },
+  { 11812087701837886160u,  2513847703931031444u,         171658239674u },
+  {  7306705080150829180u,  1752183758129038045u,         186136275957u },
+  {  1485332570280714274u, 15824833342220556540u,         245094986071u },
+  { 18042602303295630634u,  8168747198299470695u,          87857865934u },
+  { 13397029889257074369u, 17414799840149357478u,         206442828672u },
+  {  9948104869613411488u,    83147520704167789u,         128944058191u },
+  { 10836066241170646532u,  2383542703041471269u,          79004507436u },
+  { 18330574781234459389u, 15540952725549257799u,          44129212108u },
+  {   666297360208433062u,  6949835416232048690u,         204842476735u },
+  {  5035352224889324309u, 15398868937585367540u,         191376751332u },
+  {  1341745796439923765u, 14710915985268256079u,         228834774357u },
+  {  6846932182653803785u,  9665704836873335737u,          85797480353u },
+  {  6727685027257825533u,  2528789298740305993u,         161523978909u },
+  {  2168538874806877737u, 10562914675687726264u,         157137085942u },
+  { 17694936100676971444u, 17671658300096837111u,         246572616751u },
+  {  2163944241059563294u,   356471401631698552u,          47957982516u },
+  {  6727780864524301558u,  7450677157218003204u,          52019324353u },
+  {  8599551977795002615u,   317174560787152643u,         193403902018u },
+  { 15428264807806859091u,  7251937674440720374u,          66017194067u },
+  {  2126771385339683557u,  1252631516699038247u,          83393128329u },
+  { 15094316562082972944u, 10818009768860843867u,         137067905290u },
+  {  8111300598225956802u, 12330114194950162396u,          10586445484u },
+  {  9481215200564260304u, 15826681638261168822u,         172668416829u },
+  { 16836674128623424708u, 14240150078499211625u,          61857966130u },
+  {  7087243115299722740u, 10725372116242125421u,          50771960082u },
+  {  2343560867338408810u,  8434925524647833627u,          18581423587u },
+  {  3431385749090422286u, 17133902668520348241u,         227457258228u },
+  {  3504545517469224582u, 15093996047981365810u,         244928830724u },
+  {  3333759805712094227u,  6187974166976813153u,           4818247165u },
+  {  3595183476205994775u, 13946144707720259865u,         253335450751u },
+  { 14191566632569921303u,  9138079832881862582u,         127756022019u },
+  { 12917427671358095562u,  6600697628576225568u,           3495376300u },
+  {  3883793922738316288u,  8137099536646556597u,         172357824535u },
+  {  7857281689266421760u, 14169855543453903706u,          23441113049u },
+  { 15987081651486195712u,  3706403268650100765u,         217768149408u },
+  { 16827562156399525888u, 14736932266877982264u,         160200924523u },
+  {  7012737938513461248u, 18004795125138956004u,         107798890698u },
+  {  7385903388887613440u,  9068489270661002501u,         202976041899u },
+  {                    0u,  7758835715193269217u,         171491603788u },
+  {                    0u, 16943947811135261184u,          76420607326u },
+  {                    0u,  6745843108403216384u,          94918533251u },
+  {                    0u, 12338229654069444608u,         131365692887u },
+  {                    0u, 14358176069683511296u,         215668856769u },
+  {                    0u,  7083775185760813056u,         193778358284u },
+  {                    0u,  5350276357316149248u,          12384012222u },
+  {                    0u,  9223372036854775808u,         190290039062u },
+  {                    0u,                    0u,          22500000000u },
+  { 14135788013842776187u,             13064201u,                    0u },
+  { 13284322918167594445u,    13064201766302603u,                    0u },
+  {  7264587765474046287u, 14699116688460625612u,               708211u },
+  { 16176482219778368741u,  6684126021499623499u,         115796840712u },
+  {  5401983818872095469u, 12614606079692508506u,           8362347197u },
+  { 11208857446851049921u, 15358270276683001489u,         189683839165u },
+  { 13794690008281035639u, 18077126190953408995u,         189832573499u },
+  { 14519782740993303071u,  7864121581925945659u,          59979962974u },
+  { 10885858587044789123u,  3518026639210514839u,          94426314885u },
+  {  8710500938899914621u,  4698310163811252280u,         133190712606u },
+  {  1284182587483102819u,  6101155398200416338u,          30254695904u },
+  { 10346074482131502030u, 16049178580360033341u,         224330744296u },
+  {  9429804686255246574u,  3167464649127375997u,         232870027714u },
+  {  6412022633845121254u, 12778923935480989904u,         194171708602u },
+  {  8892351297529018260u, 11875553912612980379u,         186692746854u },
+  { 14098160105983060597u, 10628760849351697057u,         102643775067u },
+  { 13793833029739474340u,  3408944711673234310u,          91576186280u },
+  { 16367653765996977044u,  2102091496050506178u,         168184799263u },
+  { 10684788343333772342u,  6254611118630245760u,          31113954608u },
+  { 13272681218705145345u,  2647941151989776368u,          48339063148u },
+  { 11093568615497829248u,  8855437735410157458u,         108143545177u },
+  { 12488220765137758124u, 10184270603132180103u,          89480054241u },
+  {  3727114642519696453u, 12079083162535627164u,         225552090415u },
+  { 11549865375695057514u,  5952952868716156729u,          47654808410u },
+  { 11292809154908783229u, 11958907037815852320u,          90322710221u },
+  { 17723904861837310998u, 10101562137321697626u,         205648293649u },
+  { 14877674388187150875u, 13633527411279258327u,          17547606780u },
+  { 12178961950105734308u, 16555627393501768728u,         252739075001u },
+  {  4540604068069253114u,  6359650463500280706u,         185897482359u },
+  { 13832478722153359868u,  8093923611102181967u,         119344757342u },
+  {  1308046668730371491u,  2848827352928635726u,          94438772478u },
+  { 18400531023544756800u,  4686723431961561511u,         254154435240u },
+  {  9789823458621466539u,  6245554925867652609u,         168254067786u },
+  {  1924870562610267306u, 17527406820792516033u,          74338572210u },
+  {  5290016144582400923u, 12119966834653692210u,         178950162627u },
+  { 15162883663174059077u, 11606502845877928061u,         195657024718u },
+  {  8078086116520046390u,   424311496652297090u,         206629189780u },
+  { 15731407332173190623u,  5977664048034127173u,         148023001972u },
+  {  5346389182763011056u,  6702712461535947028u,         116324049817u },
+  {  6368422217216252401u, 11384349854055020018u,         153363354770u },
+  {  2961453088119116188u,  3782955013294836188u,         146617146842u },
+  { 10932141691610170525u,  3531805968821207061u,         218205074402u },
+  { 11034016191361782553u,  3867566898657193228u,         226191459585u },
+  {  5455325785621453219u, 12688734637425072080u,           1209661221u },
+  {  7735615202566149352u, 18435982764454619691u,          37687857682u },
+  {  7502396497775759360u,  4728836163964677692u,          18999416628u },
+  {  1601286435751591936u,  2120012917348838977u,          52256350722u },
+  { 11449383158571597824u,  9856965465824679831u,           2114926130u },
+  { 13043944595690356736u, 11217197671061248816u,          50534347168u },
+  {  7773494431818186752u,  3840562972677739189u,         160608085504u },
+  {  9943947977234055168u, 17104366978925258617u,            208197335u },
+  {                    0u, 16177877219841993444u,         215927229591u },
+  {                    0u,  7338522384267208704u,         151877004481u },
+  {                    0u, 10935240458612244480u,         193397822095u },
+  {                    0u,  1732868046462124032u,         143592800573u },
+  {                    0u,   557965042578882560u,          61093938965u },
+  {                    0u, 10454684322475540480u,          21030247345u },
+  {                    0u, 13907115649320091648u,         177566749572u },
+  {                    0u,                    0u,         132753906250u },
+  {                    0u,                    0u,          74000000000u },
+  {  6343817245135589714u,                  199u,                    0u },
+  { 17549323075660516085u,         199343899021u,                    0u },
+  {  3948641822109421754u, 14876458284855834550u,                   10u },
+  {  1750739713693534543u, 10450704926982265198u,          10806454419u },
+  {   962163898128633415u,  5385653213018257806u,         147566533849u },
+  {  7967320249386531212u, 12735569669880147489u,         217291956845u },
+  {  3018466665533383224u,  3619762560577729456u,         109690396615u },
+  { 15076865731854945472u, 11123448126624084269u,         199196227721u },
+  {   691187172844604400u,  4072715118852885633u,         137603003331u },
+  { 13274492813370992341u, 18239087231420827283u,         195220782328u },
+  {  6364168818499152300u,   423431461216085297u,         248988742900u },
+  { 17599380787401914158u,  9360976716520160042u,         244022954265u },
+  {  3782323149461692814u, 11655927117263208920u,          25507459564u },
+  { 14470163442442237466u,  2646622721938364948u,         236631869075u },
+  {   476109872130437939u,  4496462484548171852u,         147143473705u },
+  { 16330548844673355700u, 13140258519803350063u,          41243753719u },
+  { 14089158961463739563u, 13089764333320627770u,         247712334841u },
+  { 13385510793074798805u,  6926286827289840501u,         249709597546u },
+  {  1549401308746959012u,  4985580225290866218u,         106375474761u },
+  {  4607384943843027435u, 10478790837359789693u,          73270268845u },
+  {  5157353797716093483u, 10041191967455692214u,         173568056389u },
+  { 10846828782671550129u,  5035461258013813797u,          69544334107u },
+  {  9915857350819131531u, 14208759661559249750u,          27272972901u },
+  {  1673544973504317923u, 12347272163241758840u,         101770258404u },
+  { 14780986291622785694u,  3372534174410277614u,         228669346965u },
+  {  8168111319515466401u, 17226704187274712984u,         149182825443u },
+  { 16345760387859734482u,  4250480179449852121u,         227933861505u },
+  {  3177475373321281805u,  4303723537755414374u,         129230418992u },
+  {  2558676822419554038u,  8680503847344854165u,          48233305320u },
+  {  8813474062662382873u,  8817608623911079652u,         232470571056u },
+  {  5426294560236228430u,  5692030448698539450u,          48478003521u },
+  {  9919177474128333040u, 16908836314686769809u,          65308565588u },
+  {  6197383943089627371u,  6073762347067727240u,          84916629853u },
+  { 13673239314867423997u, 10931066692585106200u,          93329259316u },
+  {  9309584098968723946u, 14466591364061539596u,          52592574312u },
+  {  4647101757759615504u,  4958077340960173341u,         104784235489u },
+  {  1405809295505096753u,  4076890037156765715u,         225268777911u },
+  { 11332704079573859112u, 14083973146609179058u,         183221008651u },
+  {  2960072434514044308u,  2565183738039805295u,          11763493714u },
+  {  3887266602785432801u,  1482420938751351224u,          82139058889u },
+  { 14545546084687849554u,  2151089495335413944u,         201080362200u },
+  {  4617763804182385321u,  3738604531753220913u,         216116610795u },
+  {  7857823815580249095u, 14195686514836005765u,         235202670157u },
+  { 10939326736548364798u, 17808833916231796970u,          77769549707u },
+  { 12262012446566951953u,  1302384553035657354u,         139965418821u },
+  { 12555024338687723023u,  1672033517974833698u,          69070602408u },
+  {  3332969632922829472u, 11673925532927662545u,         168090641118u },
+  { 15535060143360327680u,  3905334232240480709u,         222632844771u },
+  { 15794322927987458048u, 17411087320267472625u,         227211708592u },
+  { 10571474314433921024u, 16573305231063706617u,         176943856934u },
+  { 16679514427547975680u, 15481103236037148354u,          38898440676u },
+  { 16925653299565166592u,   907440704754420880u,         228839232288u },
+  { 16717361816799281152u,  3224970785139077759u,          32049192459u },
+  {                    0u, 10560826509734608144u,          11174826016u },
+  {                    0u,  4700940027512659968u,          32572503552u },
+  {                    0u,  9733694683502084096u,            254838469u },
+  {                    0u,  1995535635724632064u,         197527664646u },
+  {                    0u, 10629833226245373952u,           6108178203u },
+  {                    0u, 15729384648544878592u,          27576244413u },
+  {                    0u,  7205759403792793600u,         189852691650u },
+  {                    0u,                    0u,         194390625000u },
+  {                    0u,                    0u,         232000000000u },
+  {  9335385384027907407u,              3041746u,                    0u },
+  { 13237828406194798613u,     3041746506072255u,                    0u },
+  { 15667486867836528863u,  7535526066623007027u,               164893u },
+  { 17982325043592934313u, 11302146918409311588u,          29408501686u },
+  { 17159117626917379189u,  2480833299122194801u,         182612690612u },
+  {  8336208968408929657u, 11513226205589330558u,         180134486242u },
+  { 12767090573379150201u,  4073957068281936105u,         226624133243u },
+  { 14736070002412246709u,  3729887061093812886u,         123220849655u },
+  {  9697296975344560756u, 13616911779739451443u,         247202197582u },
+  {  7291706381199103298u, 13039053282195777666u,          78738174266u },
+  { 18098546597780825068u, 14490756113210417890u,          58706848494u },
+  {   132913902678533478u, 17432486112977557585u,         238785545462u },
+  {  1879347741692007580u, 14308820825344039837u,         246945016965u },
+  {  4056624629214083684u,  4190949538817536349u,         133775682731u },
+  { 14713227692042795499u, 13616552502810964397u,         171227191829u },
+  {  7366415124022528526u,  4898145803694965031u,          21738154790u },
+  {   825770353378039393u,  1399036321001644308u,          38265529016u },
+  { 10244023944395357795u, 17170331128243738540u,         184075841910u },
+  { 14302658294713551167u, 10641321388205367410u,         118930805515u },
+  { 14246653166206862817u,  6648873641312572851u,          11576867188u },
+  { 12404486258134291102u,  5988456964560374823u,         116360436162u },
+  {  8887442218637942533u,  9972593758348346915u,         194324634902u },
+  {  1186724038081863005u, 16709668921872818968u,          22540615390u },
+  {   211331772484951576u,  6094829131503407767u,         222905832967u },
+  {  6311919513247413649u,  4892016478899926334u,           7330401349u },
+  {  8131780018703965703u, 13150857244079031538u,          69265196744u },
+  {  2262544347226725725u, 12983943395318785894u,         200712909399u },
+  { 15318188749880522583u, 15341644584614757478u,          87703860981u },
+  {  1073117094162650652u,  7507635124856644772u,         245831672219u },
+  {  4447950380665871747u, 11619655367084544354u,         155406989715u },
+  {  5373227185066463609u, 11553116952478783009u,         147629902779u },
+  {  6739731406934274193u, 17392150014233193245u,         187626295724u },
+  { 12328812617001239444u,  8877887560294980515u,         172942830341u },
+  {  3246111484407310759u, 18404180619915609503u,           5481271248u },
+  {  3250825415176839770u, 10079413095288181976u,         208997692630u },
+  { 16146270540000862342u, 14102802966539105550u,         214546406078u },
+  { 15686773375425916830u, 13333966026135891399u,         190764514480u },
+  { 11920791905793880226u, 12344968670173516152u,         176722835746u },
+  {  1853290561644080707u, 10577007819804726752u,          34669222092u },
+  { 12157689141506159076u, 15337041354031088010u,         204573380742u },
+  { 18100318838862562546u, 14333607285614673616u,         134831422677u },
+  {  7171257882533475139u, 17171597563219696538u,         213777026407u },
+  { 14477550873015039462u,  2849642930482147564u,         103930874169u },
+  {  8109481182495403274u, 14791248423979435173u,          57154479452u },
+  { 14565395719337663965u, 13882371364576310127u,          92801835183u },
+  {  1860318978161305991u, 11735995808941329540u,         175752564859u },
+  { 16268646275151585618u, 11376996674339273181u,         123636209607u },
+  { 13759019338835519104u,  9849638057168043481u,         199616748225u },
+  { 17003783176010661888u, 18241520229279361964u,         193533949948u },
+  { 18357489540307877888u,  1865852368526961444u,         252988874793u },
+  {   905481790074912768u, 10601487369276448158u,          41101148059u },
+  {  3638882110636294144u, 15999931310312762170u,         155574707781u },
+  {  9011702854368362496u,  5773775867713013570u,          69867358014u },
+  { 11529215046068469760u, 17726239863982547534u,          62312997016u },
+  {                    0u,  9711316695888316992u,         152960941388u },
+  {                    0u, 17872002620723724288u,          76526451532u },
+  {                    0u,  7429694208660733952u,          76968843203u },
+  {                    0u,  1782821038871019520u,         195402764530u },
+  {                    0u,  3225250234313474048u,         242096646922u },
+  {                    0u, 10009250171830927360u,          10174841165u },
+  {                    0u,  1152921504606846976u,          77542602539u },
+  {                    0u,                    0u,          43062500000u },
+  {                    0u,                    0u,         160000000000u },
+  {  7625299565768063067u,                   46u,                    0u },
+  { 13889021769065194705u,          46413368317u,                    0u },
+  { 14498170692313014398u,  9519880170333822146u,                    2u },
+  {  1541631360972245751u,  2285186318012886800u,           2516073738u },
+  {  9903958882920799117u,  9706420951402272035u,          10123880198u },
+  { 15744148547788062576u,  2369632031840402142u,           6526186134u },
+  { 17936061801321712000u, 15599123897979399458u,         150128458009u },
+  {  9986394078324430610u, 17579576584023912658u,          25845630200u },
+  { 13849561248103430369u,  3480927339588501811u,         248952990756u },
+  { 12142378807953854930u,  3547346616671294635u,          36188701449u },
+  {  2513847703931031444u,  7705317123868384954u,           9192302045u },
+  {  1752183758129038045u,  4969425237478353909u,         221417706078u },
+  { 15824833342220556540u, 17043246700132217175u,          94269393081u },
+  {  8168747198299470695u, 17053788362783499470u,         185923916254u },
+  { 17414799840149357478u, 11102988228454224768u,         222924487719u },
+  {    83147520704167789u, 16944305387801685839u,          39601894197u },
+  {  2383542703041471269u, 11725142977459199276u,          53918552635u },
+  { 15540952725549257799u,  8175984171998533324u,          59635621274u },
+  {  6949835416232048690u,  1372352885142856895u,         154443220990u },
+  { 15398868937585367540u, 17975093466502888164u,         254074395398u },
+  { 14710915985268256079u,  6467823391459085653u,           6974431769u },
+  {  9665704836873335737u, 11319386883146885025u,          25350621408u },
+  {  2528789298740305993u,  9141999262922068637u,         224613625192u },
+  { 10562914675687726264u,  1587330393383478774u,         104495588773u },
+  { 17671658300096837111u,   884187548095712303u,         165086049353u },
+  {   356471401631698552u,   488841225726377268u,          73047931903u },
+  {  7450677157218003204u, 17462624199405856193u,         255026500135u },
+  {   317174560787152643u, 13183677579115583554u,          39946650754u },
+  {  7251937674440720374u, 11645015818917277779u,         130714688593u },
+  {  1252631516699038247u,  8760523002035971977u,          81631277572u },
+  { 10818009768860843867u, 10068817678491468042u,           4474908903u },
+  { 12330114194950162396u,  1273658177787418284u,         231545831700u },
+  { 15826681638261168822u,  3100019384328057661u,          20069045148u },
+  { 14240150078499211625u, 10363063568089458738u,         156168052387u },
+  { 10725372116242125421u, 13030756371481403666u,         163561782801u },
+  {  8434925524647833627u,  6538878900684195299u,          17706398718u },
+  { 17133902668520348241u,  8984884716779098868u,         254354473335u },
+  { 15093996047981365810u,  8728727397070363908u,         119487071576u },
+  {  6187974166976813153u,  6398650562917867005u,          88473185260u },
+  { 13946144707720259865u,  1190873176164938879u,         236346871542u },
+  {  9138079832881862582u,  4383628525805121795u,         246064557364u },
+  {  6600697628576225568u, 10189374699734119852u,          52237636978u },
+  {  8137099536646556597u,  5276291920541626391u,         114552367109u },
+  { 14169855543453903706u,  2692252373800386521u,           5286028358u },
+  {  3706403268650100765u, 11578684995169173920u,          70145947293u },
+  { 14736932266877982264u,  5799408022254132587u,         157627681771u },
+  { 18004795125138956004u, 15548569837712345290u,         235314386538u },
+  {  9068489270661002501u, 15763030464322902955u,         106842889659u },
+  {  7758835715193269217u, 13257749746581255500u,         187854515593u },
+  { 16943947811135261184u, 16152470009188707678u,         137718704053u },
+  {  6745843108403216384u, 13806790848493904003u,         181875627153u },
+  { 12338229654069444608u, 11981226523265951191u,         145748467631u },
+  { 14358176069683511296u,  5133628726077003713u,         175649503591u },
+  {  7083775185760813056u, 16183955741910833164u,         103278294570u },
+  {  5350276357316149248u, 13640425554331371454u,          42877333998u },
+  {  9223372036854775808u, 18108120906868035862u,         238739448950u },
+  {                    0u,  6324011669895037184u,         118981643201u },
+  {                    0u, 10444437689515769856u,         193342825359u },
+  {                    0u, 12324712543665782784u,         143566194101u },
+  {                    0u, 13928941951563857920u,         181668124005u },
+  {                    0u,  3975288688270639104u,         101755089456u },
+  {                    0u, 11141905478114607104u,          48215500831u },
+  {                    0u,  4611686018427387904u,          31604003906u },
+  {                    0u,                    0u,          66250000000u },
+  {                    0u,                    0u,         128000000000u },
+  { 14699116688460625612u,               708211u,                    0u },
+  {  6684126021499623499u,      708211796840712u,                    0u },
+  { 12614606079692508506u,  4398362855256705725u,                38392u },
+  { 15358270276683001489u,  2812083125569302717u,         248238435728u },
+  { 18077126190953408995u, 12868509142973100603u,         144152443331u },
+  {  7864121581925945659u,  8726243776748165726u,         195697603278u },
+  {  3518026639210514839u,   358304413426858117u,         206473050623u },
+  {  4698310163811252280u,  3180720351566429470u,         255019423721u },
+  {  6101155398200416338u, 14053818240400098784u,         233172427195u },
+  { 16049178580360033341u,  7340140541492429288u,         187761859013u },
+  {  3167464649127375997u,  1323571167904965058u,         197397909816u },
+  { 12778923935480989904u, 14463851737583396026u,          56071750936u },
+  { 11875553912612980379u, 15122784818916048486u,          24784086973u },
+  { 10628760849351697057u, 13557974621377508955u,         189819807807u },
+  {  3408944711673234310u, 17525172074563876264u,          63734979276u },
+  {  2102091496050506178u, 15148880683074215967u,         204950041481u },
+  {  6254611118630245760u,  6744828147558597936u,         137821222467u },
+  {  2647941151989776368u,  9799290779647971692u,          67365637866u },
+  {  8855437735410157458u, 11170890203898678105u,         234531220617u },
+  { 10184270603132180103u,  7068779781287527905u,         137605575171u },
+  { 12079083162535627164u, 14474741922505540911u,           3383199319u },
+  {  5952952868716156729u, 17107062680405191514u,          87784677331u },
+  { 11958907037815852320u,  2712598571300237005u,         211927375726u },
+  { 10101562137321697626u,  3767556054903418641u,         110147050263u },
+  { 13633527411279258327u, 18158239681706277628u,          23204239622u },
+  { 16555627393501768728u, 10531652712128330681u,           6984360145u },
+  {  6359650463500280706u,  9548395326934120567u,         209570922037u },
+  {  8093923611102181967u, 15875647850297719390u,          53517619547u },
+  {  2848827352928635726u,  8215825295203192574u,          91860620594u },
+  {  4686723431961561511u, 12747310908260543144u,          50445380781u },
+  {  6245554925867652609u,    77706528053613642u,         173691033109u },
+  { 17527406820792516033u,  6024737704056756146u,          21004212479u },
+  { 12119966834653692210u,  6819452388570089667u,         255326601685u },
+  { 11606502845877928061u, 13695926775373186254u,         213369683254u },
+  {   424311496652297090u,  3746531715392682132u,          54742457678u },
+  {  5977664048034127173u,  4717376233154528116u,          78203099891u },
+  {  6702712461535947028u,   385190957950313369u,         243255729478u },
+  { 11384349854055020018u, 12388374310648616082u,          70020881243u },
+  {  3782955013294836188u,  1078067332084407770u,          91671575117u },
+  {  3531805968821207061u,  3257295319358714850u,          77058442147u },
+  {  3867566898657193228u,  1545453099660723457u,         163176578333u },
+  { 12688734637425072080u,  7495477664653506341u,          29083779180u },
+  { 18435982764454619691u,  7225503732673614354u,         108406330658u },
+  {  4728836163964677692u,  3935478326103643956u,          34391695342u },
+  {  2120012917348838977u, 10082240682742686210u,         238213342707u },
+  {  9856965465824679831u, 10838712705567897138u,         243546559362u },
+  { 11217197671061248816u,  2142546572501643680u,         130587567793u },
+  {  3840562972677739189u,  7893042119150331392u,         177116147682u },
+  { 17104366978925258617u, 12084811642251302615u,         226427882670u },
+  { 16177877219841993444u, 15317234482572954775u,         174655118951u },
+  {  7338522384267208704u,  2283226355108359361u,         103830348945u },
+  { 10935240458612244480u, 13359725152575722127u,         145123773948u },
+  {  1732868046462124032u, 13126551011491594557u,         252724232151u },
+  {   557965042578882560u,  3598021288691861269u,         215711591756u },
+  { 10454684322475540480u, 16462621795896662961u,          76195049124u },
+  { 13907115649320091648u, 14682112756964627332u,         164892440515u },
+  {                    0u,  7174112100896070218u,         195795918927u },
+  {                    0u,  5023109019590616064u,          79388909396u },
+  {                    0u, 10765223023086141440u,          84272303285u },
+  {                    0u,  8228137177297453056u,         181583583909u },
+  {                    0u,  2891199497780592640u,         165446048210u },
+  {                    0u, 15294857653247803392u,         210156732238u },
+  {                    0u, 14303432416528695296u,          78829135894u },
+  {                    0u,                    0u,          22775390625u },
+  {                    0u,                    0u,         161000000000u },
+  { 14876458284855834550u,                   10u,                    0u },
+  { 10450704926982265198u,          10806454419u,                    0u },
+  {  5385653213018257806u, 10806454419566533849u,                    0u },
+  { 12735569669880147489u, 17118225092618494573u,            585819067u },
+  {  3619762560577729456u, 13385738875341807559u,         187927980841u },
+  { 11123448126624084269u,  8272682717439277193u,          41725642358u },
+  {  4072715118852885633u, 13402436483369350083u,         118448463028u },
+  { 18239087231420827283u, 10946328903241612536u,         180726547537u },
+  {   423431461216085297u, 16265808923426731252u,          81593401678u },
+  {  9360976716520160042u, 11080374459871185177u,          78881771268u },
+  { 11655927117263208920u,  1240761893433831916u,           4600668303u },
+  {  2646622721938364948u,   367264070493390483u,         143067261837u },
+  {  4496462484548171852u,  2863675693461092905u,         141019909425u },
+  { 13140258519803350063u,  7511929581752138999u,          49155240170u },
+  { 13089764333320627770u, 11154557789993845753u,         234407222518u },
+  {  6926286827289840501u,  8325416539745948522u,         246604689789u },
+  {  4985580225290866218u, 17745129874679852617u,         125451321734u },
+  { 10478790837359789693u,  1074820986392253357u,         134961965418u },
+  { 10041191967455692214u,  7820952682162838597u,         106058266162u },
+  {  5035461258013813797u,  8215518006273528603u,          50423974694u },
+  { 14208759661559249750u,  9680426791089900133u,          38445364123u },
+  { 12347272163241758840u, 16128495723604797412u,         155524776987u },
+  {  3372534174410277614u,  2264789053583348885u,          27874327505u },
+  { 17226704187274712984u, 11175458488686298083u,         209122774460u },
+  {  4250480179449852121u, 11026777810412287617u,         188605822818u },
+  {  4303723537755414374u, 16199890034895598640u,          98597762822u },
+  {  8680503847344854165u,  9094320719494763752u,           6878197798u },
+  {  8817608623911079652u,  1250835564687222832u,          38493004114u },
+  {  5692030448698539450u, 15362466642459337025u,          82067807931u },
+  { 16908836314686769809u,  7831109835595423828u,         187832800985u },
+  {  6073762347067727240u, 15426237284335022429u,         217424525314u },
+  { 10931066692585106200u, 15636308361455434548u,           2836257998u },
+  { 14466591364061539596u, 13967173875944980328u,         206847645974u },
+  {  4958077340960173341u, 18245979923595824097u,          22757162012u },
+  {  4076890037156765715u, 11335054479675278263u,          28989116553u },
+  { 14083973146609179058u, 11165339882630461707u,         137614474534u },
+  {  2565183738039805295u, 15944437408299395922u,          38605274287u },
+  {  1482420938751351224u, 15806416348777321161u,         175864349683u },
+  {  2151089495335413944u,  4201030477408556248u,         243856867547u },
+  {  3738604531753220913u,  9485474942554588907u,         219227738318u },
+  { 14195686514836005765u, 18238757647663230541u,         206514208626u },
+  { 17808833916231796970u,  4642199687824746379u,         114988725033u },
+  {  1302384553035657354u,  6134575894869364037u,          41251654149u },
+  {  1672033517974833698u, 11524208547121316008u,           5332556025u },
+  { 11673925532927662545u,  2734683241527878366u,         249624728597u },
+  {  3905334232240480709u, 10629223456178675171u,          21148247475u },
+  { 17411087320267472625u,  2788042336985254064u,         179576211358u },
+  { 16573305231063706617u, 17285498758066142502u,         158151140077u },
+  { 15481103236037148354u,  5525538192421886436u,         237937048765u },
+  {   907440704754420880u, 11414325503043801888u,         189299540025u },
+  {  3224970785139077759u,  7246608114685173259u,          57618771825u },
+  { 10560826509734608144u,  1007884269852184608u,         113392839413u },
+  {  4700940027512659968u, 13823717876510029312u,         245054637515u },
+  {  9733694683502084096u, 12487410768239429317u,         203749385247u },
+  {  1995535635724632064u,  3361062421598631942u,          31676943894u },
+  { 10629833226245373952u, 17853337379088328475u,          22182203558u },
+  { 15729384648544878592u, 11551561037491869885u,         166967831358u },
+  {  7205759403792793600u, 11480877996635204802u,          62626211378u },
+  {                    0u,  5527488381934471912u,          50622379643u },
+  {                    0u, 11143438404407726080u,         123299645745u },
+  {                    0u,  6472279730688098304u,          49604087006u },
+  {                    0u,  4561816853579563008u,         222350862987u },
+  {                    0u,  2888714464062865408u,         139247296587u },
+  {                    0u, 16258276129784201216u,          75156597524u },
+  {                    0u,   720575940379279360u,          20881362915u },
+  {                    0u,                    0u,         227039062500u },
+  {                    0u,                    0u,         228000000000u },
+  {  7535526066623007027u,               164893u,                    0u },
+  { 11302146918409311588u,      164893408501686u,                    0u },
+  {  2480833299122194801u, 16409970870640346804u,                 8938u },
+  { 11513226205589330558u,  7721907286269370594u,         234889586303u },
+  {  4073957068281936105u, 14300743897882155131u,         127418605432u },
+  {  3729887061093812886u,  2068482633821123575u,         120775244880u },
+  { 13616911779739451443u,  4922882895416406094u,          80112132668u },
+  { 13039053282195777666u,  9317632875623428410u,          60266870016u },
+  { 14490756113210417890u,  5693844901999766254u,            505109890u },
+  { 17432486112977557585u, 11569484900262102262u,         130308663950u },
+  { 14308820825344039837u,  3138170119352085637u,         142627183033u },
+  {  4190949538817536349u,   950584692575235243u,         185170120543u },
+  { 13616552502810964397u,  8136430299747162645u,          95051531299u },
+  {  4898145803694965031u,  6698711700804594470u,          35441076770u },
+  {  1399036321001644308u, 17401191571004302008u,          34363137888u },
+  { 17170331128243738540u,  4721732028538188150u,          96943320485u },
+  { 10641321388205367410u,  2984214103553086219u,         165255965606u },
+  {  6648873641312572851u, 13128675202005662068u,         166161774570u },
+  {  5988456964560374823u, 14638512997670672834u,         234711706908u },
+  {  9972593758348346915u, 12942085665769692438u,          28793555379u },
+  { 16709668921872818968u, 14131134357119205086u,         179701591869u },
+  {  6094829131503407767u,  8921946894736102919u,          61766050328u },
+  {  4892016478899926334u,  5601522560505809989u,          24483659710u },
+  { 13150857244079031538u,  8602606493507716808u,         190303659146u },
+  { 12983943395318785894u,  8576789731078566487u,         138466348232u },
+  { 15341644584614757478u, 17881118138842658549u,         200464948702u },
+  {  7507635124856644772u, 11624372674432704923u,         222969337356u },
+  { 11619655367084544354u,  6826284072848095635u,          12630158505u },
+  { 11553116952478783009u,  1646466632033733563u,         169370053601u },
+  { 17392150014233193245u, 17871081657060299180u,         225089255134u },
+  {  8877887560294980515u, 15910893124677544709u,         222968793277u },
+  { 18404180619915609503u, 11031217459450580944u,         189862531244u },
+  { 10079413095288181976u, 13554987390037243094u,         172598003496u },
+  { 14102802966539105550u, 15026714590903687870u,          40734817338u },
+  { 13333966026135891399u,  4406379654994689200u,          58814599830u },
+  { 12344968670173516152u, 13596329092861950242u,         150238870319u },
+  { 10577007819804726752u,   284812388227373260u,          47737058477u },
+  { 15337041354031088010u,  9285079159392309382u,         173015439710u },
+  { 14333607285614673616u, 15046108141952711893u,          94503345149u },
+  { 17171597563219696538u, 13795366909944958311u,         253815651156u },
+  {  2849642930482147564u, 12909920641180059961u,          84747848338u },
+  { 14791248423979435173u,  5333762939889788252u,         146699848200u },
+  { 13882371364576310127u,  6411331390005944495u,           8289143868u },
+  { 11735995808941329540u,  1447104583224217723u,          60347558971u },
+  { 11376996674339273181u, 11940049226167932871u,          59078447696u },
+  {  9849638057168043481u,  9772290783590472385u,          80647271365u },
+  { 18241520229279361964u, 16351989577831528444u,         197529756944u },
+  {  1865852368526961444u,  4376738725895725097u,          16886443131u },
+  { 10601487369276448158u, 13851276297739812763u,         123237263481u },
+  { 15999931310312762170u, 12641996203470333509u,         121750879192u },
+  {  5773775867713013570u,  7707081716407945022u,         216685323987u },
+  { 17726239863982547534u,   417638323657040024u,         211417801737u },
+  {  9711316695888316992u, 16438047707692449100u,           9022640218u },
+  { 17872002620723724288u, 14850108107043306316u,          90891108351u },
+  {  7429694208660733952u, 10423290807904720835u,         255805025973u },
+  {  1782821038871019520u, 16951162310302339314u,         181565047726u },
+  {  3225250234313474048u,  2752437506572397322u,         174918924350u },
+  { 10009250171830927360u,  3925815842962784589u,          62149209936u },
+  {  1152921504606846976u,  5274166674003605291u,          80212818903u },
+  {                    0u,  5538963350863452832u,         215285913148u },
+  {                    0u, 16900671634439028736u,          60300267804u },
+  {                    0u,  2326997710751662080u,          28916187245u },
+  {                    0u, 12327726161625874432u,         109126146798u },
+  {                    0u,  5756455743825903616u,         238668287374u },
+  {                    0u,  3018537650245074944u,         142312058091u },
+  {                    0u, 16717361816799281152u,         235163635253u },
+  {                    0u,                    0u,          53906250000u },
+  {                    0u,                    0u,          16000000000u },
+  {  2285186318012886800u,           2516073738u,                    0u },
+  {  9706420951402272035u,  2516073738123880198u,                    0u },
+  {  2369632031840402142u, 11997425759292732054u,            136396630u },
+  { 15599123897979399458u, 11491152661270395161u,          86650381753u },
+  { 17579576584023912658u, 18181063258234881272u,         185622936633u },
+  {  3480927339588501811u,  2466921813123869732u,          57985597414u },
+  {  3547346616671294635u,  8430880678232179465u,         230133732099u },
+  {  7705317123868384954u,  6738034873677997533u,           3457038957u },
+  {  4969425237478353909u,  7678250951042929246u,         109365269602u },
+  { 17043246700132217175u,  1853560606315563193u,          98416238818u },
+  { 17053788362783499470u, 14942676593409905118u,         226100481721u },
+  { 11102988228454224768u,  4909892170837638183u,         185810044121u },
+  { 16944305387801685839u, 16871149368312132405u,         217266165787u },
+  { 11725142977459199276u, 16096130589333770811u,          27914586839u },
+  {  8175984171998533324u, 12512479187631824282u,         215872572987u },
+  {  1372352885142856895u, 16980304980540557310u,          59678302855u },
+  { 17975093466502888164u,  8640919162749295366u,         135920504177u },
+  {  6467823391459085653u,  7862382415464063513u,         113468425166u },
+  { 11319386883146885025u, 14534157903009925344u,         206426220604u },
+  {  9141999262922068637u, 12627464554215107944u,          60787898278u },
+  {  1587330393383478774u,  2456849734836299173u,         166684536225u },
+  {   884187548095712303u, 18428252197697827913u,         161133186090u },
+  {   488841225726377268u,  7244734215936736255u,          42998997553u },
+  { 17462624199405856193u, 14756175050504770087u,          49392737828u },
+  { 13183677579115583554u,  6764116534566945922u,          36799933852u },
+  { 11645015818917277779u,  1588822142405565521u,         156366683492u },
+  {  8760523002035971977u, 17053265624843842052u,         100086130220u },
+  { 10068817678491468042u, 16996891591759999207u,          44924459381u },
+  {  1273658177787418284u,  8565556232370585876u,         117921403339u },
+  {  3100019384328057661u, 14464960359145886620u,         203464339733u },
+  { 10363063568089458738u,  5813189542048784035u,          21784147072u },
+  { 13030756371481403666u,  9739241026882027025u,         128315133636u },
+  {  6538878900684195299u, 18175068535675302910u,         196527965313u },
+  {  8984884716779098868u, 10562697212061761911u,         129985272439u },
+  {  8728727397070363908u,  4264834835660801368u,         119572604963u },
+  {  6398650562917867005u, 13019066443690126316u,          35231197159u },
+  {  1190873176164938879u,  1828040177823321846u,         231705765006u },
+  {  4383628525805121795u, 11240369830376975668u,         142099098256u },
+  { 10189374699734119852u,  8886938465302549874u,         144609341669u },
+  {  5276291920541626391u,  9985240313589688325u,         229481761899u },
+  {  2692252373800386521u,   722909126956573766u,         107541300962u },
+  { 11578684995169173920u,  5493363474638452381u,         226039188982u },
+  {  5799408022254132587u, 12410535279213120491u,         246297795830u },
+  { 15548569837712345290u, 10543108918366869098u,         246672776465u },
+  { 15763030464322902955u, 12953909016524823995u,          17571543079u },
+  { 13257749746581255500u, 16505942145872588169u,          39702232814u },
+  { 16152470009188707678u, 12428594380392015797u,         238894788916u },
+  { 13806790848493904003u,  7528259605829768337u,          52673755451u },
+  { 11981226523265951191u, 18147447600042811311u,          59408107770u },
+  {  5133628726077003713u, 12021069431116183911u,         250983775105u },
+  { 16183955741910833164u, 11819985069665662506u,         129651663479u },
+  { 13640425554331371454u, 10401877114068152814u,         119640762674u },
+  { 18108120906868035862u,  4611631138117837942u,          50563886888u },
+  {  6324011669895037184u, 17200813398607252417u,          40249997024u },
+  { 10444437689515769856u, 14100466137553658767u,         224932457962u },
+  { 12324712543665782784u, 17887776768825509301u,         234764387800u },
+  { 13928941951563857920u, 12632656857970087269u,         216969698321u },
+  {  3975288688270639104u,  8923681664054686256u,          17684817700u },
+  { 11141905478114607104u,  6213926103737837599u,          36483753752u },
+  {  4611686018427387904u,  1233118281776157762u,          24336857609u },
+  {                    0u,    30716279628678784u,           9066847476u },
+  {                    0u, 15775734650898546688u,         244001665132u },
+  {                    0u,   976806005729918976u,         108855204289u },
+  {                    0u, 12460098853279891456u,         193052952759u },
+  {                    0u,  5635665595421687808u,         183675463312u },
+  {                    0u,  1805943450575568896u,         144305510044u },
+  {                    0u, 11529215046068469760u,         156097900390u },
+  {                    0u,                    0u,         102625000000u },
+  {                    0u,                    0u,          64000000000u },
+  {  4398362855256705725u,                38392u,                    0u },
+  {  2812083125569302717u,       38392238435728u,                    0u },
+  { 12868509142973100603u,  4564018338575530435u,                 2081u },
+  {  8726243776748165726u, 16553437246451512014u,          33247415929u },
+  {   358304413426858117u,  4339777136957372927u,         121897363631u },
+  {  3180720351566429470u, 18439463366554654697u,         175235259789u },
+  { 14053818240400098784u,  1370067356680643003u,         141999605312u },
+  {  7340140541492429288u,  4210124040914115013u,          64074271500u },
+  {  1323571167904965058u, 10692225626142609720u,          12228231281u },
+  { 14463851737583396026u, 11592856673895384344u,         113579626712u },
+  { 15122784818916048486u, 10284479231227406269u,         216628450019u },
+  { 13557974621377508955u,  4961071383534266431u,         227557522736u },
+  { 17525172074563876264u, 10960611551445686988u,          48268940218u },
+  { 15148880683074215967u, 14616396723115619209u,         186594175942u },
+  {  6744828147558597936u,  1025604265437492803u,         198792356454u },
+  {  9799290779647971692u, 11711588454892179178u,         102055598118u },
+  { 11170890203898678105u,  5580373263251565705u,          38634886482u },
+  {  7068779781287527905u, 14109334653033148931u,          82302512640u },
+  { 14474741922505540911u,  2899414033769399895u,            764868564u },
+  { 17107062680405191514u, 13233457234892808147u,         212157177549u },
+  {  2712598571300237005u,  3287946691509034862u,         205717387154u },
+  {  3767556054903418641u,  5488480288717445911u,         146178239947u },
+  { 18158239681706277628u, 11687233053874362630u,         203297531112u },
+  { 10531652712128330681u,  6783772100089274577u,         232633566173u },
+  {  9548395326934120567u,  7898291058728402485u,         221367749022u },
+  { 15875647850297719390u,  4423684977486598491u,         158428167216u },
+  {  8215825295203192574u,  2750833684599526706u,          48239808443u },
+  { 12747310908260543144u, 15669689830489025709u,         187149122992u },
+  {    77706528053613642u, 15117307274214954517u,         176849455587u },
+  {  6024737704056756146u,  8148639818575698175u,         227819510869u },
+  {  6819452388570089667u, 13006484426078994901u,          85441738649u },
+  { 13695926775373186254u, 10287496057845513526u,         153705082933u },
+  {  3746531715392682132u, 14159876032966532430u,          53557686278u },
+  {  4717376233154528116u, 15742212196465548019u,           6767608417u },
+  {   385190957950313369u,  2892220461917134150u,          97853387033u },
+  { 12388374310648616082u,  7487151560715393883u,          25156787585u },
+  {  1078067332084407770u,  7245756744165177933u,         129405879299u },
+  {  3257295319358714850u,  3067122860671533987u,           3392793260u },
+  {  1545453099660723457u,  8135043905834122525u,         172166269063u },
+  {  7495477664653506341u, 14730019368921022572u,         135441001613u },
+  {  7225503732673614354u,   495969939682055458u,         141798515950u },
+  {  3935478326103643956u,  5617761407265775598u,         238026886584u },
+  { 10082240682742686210u,  2087044847072781811u,         184304539456u },
+  { 10838712705567897138u, 15929674232061203330u,          64113138927u },
+  {  2142546572501643680u,  8658086469608285873u,         239863549370u },
+  {  7893042119150331392u, 18369871790780313570u,         186469355807u },
+  { 12084811642251302615u,  3545648451947416750u,          31995832745u },
+  { 15317234482572954775u, 13347376792767929959u,         169192209987u },
+  {  2283226355108359361u, 14482164459838203025u,          67723562745u },
+  { 13359725152575722127u,  8899577765623565820u,         249785079708u },
+  { 13126551011491594557u,  7095320096604405719u,         156482447077u },
+  {  3598021288691861269u,  2968593824439315788u,         229384638073u },
+  { 16462621795896662961u, 12621408323612585636u,         121160927793u },
+  { 14682112756964627332u,  3954422936414648259u,          49684207916u },
+  {  7174112100896070218u, 17143730087577690191u,          44214369696u },
+  {  5023109019590616064u,  5033045529399041876u,         160929363470u },
+  { 10765223023086141440u, 15857648521994521781u,          14272841944u },
+  {  8228137177297453056u, 16655573486499109541u,         216859644848u },
+  {  2891199497780592640u, 16652154439190075858u,         176902900447u },
+  { 15294857653247803392u, 18016950600164130638u,         223902715100u },
+  { 14303432416528695296u,  2086292996072613910u,         220976700849u },
+  {                    0u, 17324462585194799521u,         177113098169u },
+  {                    0u, 11079151463184927232u,         185939160998u },
+  {                    0u,  5239846817488961536u,         166600602004u },
+  {                    0u,  2778806963520143360u,         148284052665u },
+  {                    0u,  6240890740138835968u,         185150639427u },
+  {                    0u, 17250651344549707776u,          67338319364u },
+  {                    0u,  4197354852709302272u,           4935159683u },
+  {                    0u,  9223372036854775808u,         131227539062u },
+  {                    0u,                    0u,         118500000000u },
+  { 17118225092618494573u,            585819067u,                    0u },
+  { 13385738875341807559u,   585819067927980841u,                    0u },
+  {  8272682717439277193u,  5654803392547571318u,             31757315u },
+  { 13402436483369350083u,  2931628102185393332u,           3306547506u },
+  { 10946328903241612536u, 15964697617980212305u,          50158923877u },
+  { 16265808923426731252u,   450380868305846606u,         101865447992u },
+  { 11080374459871185177u, 14631133530814566148u,          56024415195u },
+  {  1240761893433831916u,    31969822783742095u,         219793155338u },
+  {   367264070493390483u, 10437269029385743245u,          10001733087u },
+  {  2863675693461092905u, 15196146496377392433u,         223565805487u },
+  {  7511929581752138999u,  4409099735137480938u,         175823784752u },
+  { 11154557789993845753u, 10644987914903248118u,          48239017775u },
+  {  8325416539745948522u,  3154431617534062973u,          47577065951u },
+  { 17745129874679852617u, 11702056331247960454u,         223171002080u },
+  {  1074820986392253357u, 15575315065965259114u,         224634369744u },
+  {  7820952682162838597u, 10759747609480050226u,         208844339521u },
+  {  8215518006273528603u, 12538236653960743718u,          65583287086u },
+  {  9680426791089900133u, 17857942663978005403u,          46679699170u },
+  { 16128495723604797412u, 11443004154750813211u,         226968081011u },
+  {  2264789053583348885u,  4004313188770806737u,         115620326498u },
+  { 11175458488686298083u, 17134872954824183228u,          98217074252u },
+  { 11026777810412287617u,  2659553912986171234u,          76928883324u },
+  { 16199890034895598640u,  9501854300969137926u,         124144174706u },
+  {  9094320719494763752u, 14528169966301018150u,         114515096553u },
+  {  1250835564687222832u, 18172091996515901778u,         233787573671u },
+  { 15362466642459337025u,  1133541705604751035u,         167985111081u },
+  {  7831109835595423828u, 18280349987988641497u,          41061449418u },
+  { 15426237284335022429u,  9936015874712336386u,         202990979758u },
+  { 15636308361455434548u, 15876720399740689614u,         174538632499u },
+  { 13967173875944980328u,  8618117825152456982u,          51860678737u },
+  { 18245979923595824097u,  8085525680745921564u,          81467189103u },
+  { 11335054479675278263u,  8072355444669730953u,         111438317225u },
+  { 11165339882630461707u,  9395030504766848294u,         169437603265u },
+  { 15944437408299395922u,  3537903114058185903u,         193509305624u },
+  { 15806416348777321161u,  2126094743961928691u,          24191790112u },
+  {  4201030477408556248u,   289185362555601115u,          32115255827u },
+  {  9485474942554588907u, 16909937501450129614u,          19015676769u },
+  { 18238757647663230541u, 14449642060360499058u,          97916689548u },
+  {  4642199687824746379u, 12433818908498244393u,         140783316665u },
+  {  6134575894869364037u, 11884444034578008581u,         185674038673u },
+  { 11524208547121316008u,   988625838444140793u,         145644257002u },
+  {  2734683241527878366u,  1675370907158909973u,         234053593514u },
+  { 10629223456178675171u, 15920186275316934067u,         170090822038u },
+  {  2788042336985254064u,  5600921198503757726u,         150863035027u },
+  { 17285498758066142502u, 10457357161776341741u,         147303626546u },
+  {  5525538192421886436u, 12225356765775740093u,          50566894467u },
+  { 11414325503043801888u,  4486633318598164537u,         131662737918u },
+  {  7246608114685173259u, 10302486602879381361u,         254243220879u },
+  {  1007884269852184608u, 15536428611301239541u,         143558498917u },
+  { 13823717876510029312u, 12026126645955462603u,         101842231482u },
+  { 12487410768239429317u, 14877968141142123551u,         186651937631u },
+  {  3361062421598631942u,   734560801645383190u,          95806536269u },
+  { 17853337379088328475u, 15648943144911081638u,          77039820620u },
+  { 11551561037491869885u, 13664182862003235646u,          76848330907u },
+  { 11480877996635204802u,  3895127525902132786u,         155740736837u },
+  {  5527488381934471912u,  5249187334214137467u,          69211155286u },
+  { 11143438404407726080u, 10642260063359027505u,          86284559015u },
+  {  6472279730688098304u,   783598951897779422u,         167576918074u },
+  {  4561816853579563008u,  5538576558607624843u,          58042478984u },
+  {  2888714464062865408u, 15974581187564609611u,         136300246836u },
+  { 16258276129784201216u,  7474269406918257428u,          52865983781u },
+  {   720575940379279360u,  8045286838779138019u,          37405180956u },
+  {                    0u,  8184246376556341732u,          28436135873u },
+  {                    0u,  1493267152679331840u,         193443668885u },
+  {                    0u, 10179074811222818816u,         149080950174u },
+  {                    0u,  3892499202005008384u,         158551808751u },
+  {                    0u, 10341173215925108736u,         239211012804u },
+  {                    0u,  6230307872002015232u,         196560596123u },
+  {                    0u,  9295429630892703744u,         155337745666u },
+  {                    0u,                    0u,           2503906250u },
+  {                    0u,                    0u,         202000000000u },
+  { 16409970870640346804u,                 8938u,                    0u },
+  {  7721907286269370594u,        8938889586303u,                    0u },
+  { 14300743897882155131u, 10665454627995623288u,                  484u },
+  {  2068482633821123575u, 16803537892767562832u,         228578175453u },
+  {  4922882895416406094u,  8099123106849104444u,         221910921614u },
+  {  9317632875623428410u,  7077413686679401728u,         142439054343u },
+  {  5693844901999766254u, 13536636358372449666u,           7383667364u },
+  { 11569484900262102262u,  7280632235418610318u,         164733822527u },
+  {  3138170119352085637u,  6187823673116858809u,          63394683864u },
+  {   950584692575235243u,  8624343686231740255u,         216335442593u },
+  {  8136430299747162645u,   806211610822132771u,         161467526608u },
+  {  6698711700804594470u, 18388078233202190882u,         208043704818u },
+  { 17401191571004302008u,  7628864426595573600u,         242996819718u },
+  {  4721732028538188150u,  4530799784343874981u,           6413561569u },
+  {  2984214103553086219u,  8561580552078486438u,         225245615148u },
+  { 13128675202005662068u, 13349114951221999594u,          44464124211u },
+  { 14638512997670672834u, 10029144738508991772u,          51723656971u },
+  { 12942085665769692438u, 12601907197916268979u,          11543681025u },
+  { 14131134357119205086u,  1329580921391066941u,           1683150758u },
+  {  8921946894736102919u,  3198179786356761112u,         166072076726u },
+  {  5601522560505809989u, 11406753413634654142u,         182173373673u },
+  {  8602606493507716808u, 11131812960525182090u,         233618361341u },
+  {  8576789731078566487u, 14299636753645227208u,         253603456789u },
+  { 17881118138842658549u, 12964114684643663326u,          21775184861u },
+  { 11624372674432704923u,  5019257593846306316u,         221702786065u },
+  {  6826284072848095635u,  6929086798159998121u,          17272094499u },
+  {  1646466632033733563u, 18359765766933703649u,          35375626547u },
+  { 17871081657060299180u,  9993076234752063198u,          51995284896u },
+  { 15910893124677544709u,  3257189215046584509u,         160541725748u },
+  { 11031217459450580944u,  2905234736672690348u,          52176572581u },
+  { 13554987390037243094u, 12064985302079670056u,         165157493090u },
+  { 15026714590903687870u, 14315096064942799930u,          98654044163u },
+  {  4406379654994689200u, 11943971043551974038u,           3776022912u },
+  { 13596329092861950242u, 12472773152119929647u,         128647483967u },
+  {   284812388227373260u,  7791259796982183085u,          63676150387u },
+  {  9285079159392309382u, 16866829442051086686u,         115422365039u },
+  { 15046108141952711893u,  3702498393844653053u,         111914352656u },
+  { 13795366909944958311u,  2057239613841701716u,          16200712840u },
+  { 12909920641180059961u, 17201969976738286226u,         136111523182u },
+  {  5333762939889788252u, 18271566505443461640u,         110932520660u },
+  {  6411331390005944495u, 18368509115417119804u,         212990503604u },
+  {  1447104583224217723u,  7613923684154518587u,         180995758874u },
+  { 11940049226167932871u, 17984805084714865232u,          26412751629u },
+  {  9772290783590472385u,  4220802739051410373u,          13974958237u },
+  { 16351989577831528444u, 17812459042810815760u,         157228810174u },
+  {  4376738725895725097u, 10629526089664605307u,         190965615339u },
+  { 13851276297739812763u, 17437443267816548473u,         235576227763u },
+  { 12641996203470333509u, 12506371893701049304u,         179945285693u },
+  {  7707081716407945022u, 15737221540003030739u,          61677971778u },
+  {   417638323657040024u,  2358380859011605513u,          66853116489u },
+  { 16438047707692449100u, 10042972713837039706u,          73127848082u },
+  { 14850108107043306316u, 13424397272769642495u,         146544430641u },
+  { 10423290807904720835u,  6867102315755663029u,          49727738034u },
+  { 16951162310302339314u,  8690748404825506734u,         178372266362u },
+  {  2752437506572397322u,   956229930815387710u,         122471126415u },
+  {  3925815842962784589u,  7734449506297687888u,         143051837328u },
+  {  5274166674003605291u, 16332184961683848151u,         144419285347u },
+  {  5538963350863452832u, 15580777817612768828u,          99885369520u },
+  { 16900671634439028736u, 17404245271944696092u,         176844635657u },
+  {  2326997710751662080u, 13201420160494469229u,           9943486026u },
+  { 12327726161625874432u, 16511717657124068078u,          74715650420u },
+  {  5756455743825903616u, 14131292492116594062u,         116895102007u },
+  {  3018537650245074944u, 18429136031865875691u,          55766058900u },
+  { 16717361816799281152u,  2563978348305862197u,         148999045466u },
+  {                    0u, 14239974392147482896u,          90138993544u },
+  {                    0u, 11164201396098998272u,         136771950558u },
+  {                    0u,  7116971104932986880u,         222605212570u },
+  {                    0u, 12437629862867369984u,         154385811776u },
+  {                    0u, 16501893821638901760u,          64674245265u },
+  {                    0u, 10649324268870959104u,         145894569456u },
+  {                    0u,  7205759403792793600u,         240577301025u },
+  {                    0u,                    0u,          33390625000u },
+  {                    0u,                    0u,         232000000000u },
+  { 11997425759292732054u,            136396630u,                    0u },
+  { 11491152661270395161u,   136396630650381753u,                    0u },
+  { 18181063258234881272u,  3016823727048309817u,              7394076u },
+  {  2466921813123869732u, 17405973192644624358u,          28163542341u },
+  {  8430880678232179465u,  8937219978302591747u,          69943579697u },
+  {  6738034873677997533u, 15178463196824222317u,          49484487665u },
+  {  7678250951042929246u, 11979404627460330594u,         241822826138u },
+  {  1853560606315563193u,  2006448052689740002u,         154649404826u },
+  { 14942676593409905118u, 16330465320863239865u,         154108769766u },
+  {  4909892170837638183u, 17136208883957646553u,         230885276298u },
+  { 16871149368312132405u,   140455118208931867u,         138928955745u },
+  { 16096130589333770811u,  3964972929179372247u,          97007614087u },
+  { 12512479187631824282u,  3378050330022776379u,         135214941613u },
+  { 16980304980540557310u,  6065353437512901255u,         173183124475u },
+  {  8640919162749295366u, 12768753059854699889u,         251328803468u },
+  {  7862382415464063513u,  6848720690951013326u,         140692195490u },
+  { 14534157903009925344u, 10953228058585475132u,         162371269892u },
+  { 12627464554215107944u, 15539127852083296166u,           4593775682u },
+  {  2456849734836299173u, 14534853647735598497u,          66842377808u },
+  { 18428252197697827913u,  1506909603576368170u,          80787935995u },
+  {  7244734215936736255u,  5475702579938239025u,         251081689733u },
+  { 14756175050504770087u, 12039747373985783332u,         133296838431u },
+  {  6764116534566945922u, 17572399137760898460u,          31652676012u },
+  {  1588822142405565521u,   869552790852091236u,         172952601666u },
+  { 17053265624843842052u,  4549585778048181804u,          66047138551u },
+  { 16996891591759999207u,  4121918231767210357u,         247246633539u },
+  {  8565556232370585876u,  1558397953312543179u,          67223449635u },
+  { 14464960359145886620u,  6067524298738069781u,          35084480922u },
+  {  5813189542048784035u,  5811095224555517056u,         154328921151u },
+  {  9739241026882027025u,  6440894514158997188u,          63315020103u },
+  { 18175068535675302910u,  4612748874388784257u,          71349161591u },
+  { 10562697212061761911u,  9908101430749813367u,         119250057617u },
+  {  4264834835660801368u, 15150017990912190499u,         145537119254u },
+  { 13019066443690126316u, 17470426264690059239u,          22821284120u },
+  {  1828040177823321846u,  9615161096851907726u,          24947073705u },
+  { 11240369830376975668u,  9227932132124142224u,         169521238927u },
+  {  8886938465302549874u,  4794113194321211621u,         143500247203u },
+  {  9985240313589688325u,   391512698859146347u,         163259889397u },
+  {   722909126956573766u, 17209658878068655842u,         245021223945u },
+  {  5493363474638452381u,  3077364726606876150u,           9932937477u },
+  { 12410535279213120491u,  1952989567673965814u,           5166824276u },
+  { 10543108918366869098u, 11172860676923186449u,          84105871776u },
+  { 12953909016524823995u, 17338078544784947239u,         160605681990u },
+  { 16505942145872588169u,  4593380466519703278u,          70939899121u },
+  { 12428594380392015797u,   786884753602720052u,         241249007654u },
+  {  7528259605829768337u, 17848875822468020539u,          38042657107u },
+  { 18147447600042811311u,  2899664567187130618u,          83967589497u },
+  { 12021069431116183911u,  2973178834961857409u,         121157191131u },
+  { 11819985069665662506u, 11117453141176836727u,         219161176347u },
+  { 10401877114068152814u,  7535238370146462002u,          27602678342u },
+  {  4611631138117837942u, 10246175467290865448u,          70408486090u },
+  { 17200813398607252417u,  1203128834127050464u,         202555446285u },
+  { 14100466137553658767u, 14518048959078919658u,          13065221744u },
+  { 17887776768825509301u,  1553474987376920024u,         112787025011u },
+  { 12632656857970087269u, 14956572380830948369u,         115084214047u },
+  {  8923681664054686256u,  7594162606042048292u,          31810797413u },
+  {  6213926103737837599u, 14461296147288811288u,         101411680379u },
+  {  1233118281776157762u, 18305427728131488265u,         123783948434u },
+  {    30716279628678784u, 10253208939347909876u,         146992339225u },
+  { 15775734650898546688u,  6446028915490812012u,          25555827570u },
+  {   976806005729918976u, 12986063676957432257u,         114349439927u },
+  { 12460098853279891456u,  9769714697972762807u,         183703975922u },
+  {  5635665595421687808u,    97429465146664592u,         242529617295u },
+  {  1805943450575568896u, 16395571728207795868u,         143005281661u },
+  { 11529215046068469760u,  6331668478323650406u,         125888805724u },
+  {                    0u, 18129911846294207040u,          92343240435u },
+  {                    0u,  9890094564876124160u,         243982824490u },
+  {                    0u, 12290856656987750400u,          42536143100u },
+  {                    0u,  8498454992640802816u,         252666288674u },
+  {                    0u,  5341660584200896512u,          34460702168u },
+  {                    0u,  9288674231451648000u,         216289572000u },
+  {                    0u,  1152921504606846976u,         160503540039u },
+  {                    0u,                    0u,          71062500000u },
+  {                    0u,                    0u,         160000000000u },
+  {  4564018338575530435u,                 2081u,                    0u },
+  { 16553437246451512014u,        2081247415929u,                    0u },
+  {  4339777136957372927u, 15212079674427582639u,                  112u },
+  { 18439463366554654697u, 10179808126814248333u,         112824648491u },
+  {  1370067356680643003u,  6066766544199222848u,          43551848504u },
+  {  4210124040914115013u,  6625308131806923532u,          56328880073u },
+  { 10692225626142609720u,  9122786786400665713u,         201359158673u },
+  { 11592856673895384344u, 11932880778639151320u,         145494547262u },
+  { 10284479231227406269u,  3884040911779255011u,          62646882763u },
+  {  4961071383534266431u, 13441817515637357872u,         203210554279u },
+  { 10960611551445686988u, 11628577856022352826u,         167728682387u },
+  { 14616396723115619209u, 13296656925520243654u,         147630386468u },
+  {  1025604265437492803u,  5020720704545399398u,          36720813216u },
+  { 11711588454892179178u, 14121973606499014694u,         160272173814u },
+  {  5580373263251565705u,  3642481034345420114u,         246765553723u },
+  { 14109334653033148931u,  9845536238569696768u,          59197459292u },
+  {  2899414033769399895u, 17655403572195686356u,          92533727588u },
+  { 13233457234892808147u,  8377495365136654029u,         100957101345u },
+  {  3287946691509034862u, 13713682649609025426u,          33454144933u },
+  {  5488480288717445911u,  1367709905452854731u,         165743420226u },
+  { 11687233053874362630u,  9981467701727208680u,          66074143702u },
+  {  6783772100089274577u,  6277920117543306205u,         214541096448u },
+  {  7898291058728402485u,  9344111460418701726u,            340326731u },
+  {  4423684977486598491u,  4918507011364617264u,          75506545297u },
+  {  2750833684599526706u,  6554777203830755259u,         145266632799u },
+  { 15669689830489025709u,  4198262173120265648u,          95355335184u },
+  { 15117307274214954517u,  8080325935698446819u,          16227588248u },
+  {  8148639818575698175u, 12797633874200091733u,         152438035346u },
+  { 13006484426078994901u,  8376502502208665497u,         146693761122u },
+  { 10287496057845513526u,  9891973386793349173u,          98454091110u },
+  { 14159876032966532430u, 14877430279003795462u,         102536244951u },
+  { 15742212196465548019u,  8759933935842067041u,         215806507111u },
+  {  2892220461917134150u,  3753418510388703513u,         103474876970u },
+  {  7487151560715393883u,  2961383332545305985u,          42203473225u },
+  {  7245756744165177933u,  2497674184068629507u,          73160536912u },
+  {  3067122860671533987u, 15244544070742305452u,          80135399188u },
+  {  8135043905834122525u,    45953573565810823u,          20826408390u },
+  { 14730019368921022572u,  3960077421351906445u,         198002491148u },
+  {   495969939682055458u,  3173330011013883118u,          12214676227u },
+  {  5617761407265775598u, 11026266219545759160u,           3172026564u },
+  {  2087044847072781811u,  8886757764964685632u,         196597735089u },
+  { 15929674232061203330u, 13952322129918090479u,         177481752103u },
+  {  8658086469608285873u,  4127250666614902202u,          39756356898u },
+  { 18369871790780313570u, 17649958504065306911u,          34223738706u },
+  {  3545648451947416750u, 13269305359002216873u,          82956806167u },
+  { 13347376792767929959u, 16236593433831947843u,          23719330484u },
+  { 14482164459838203025u, 13580930396682424057u,         180880187493u },
+  {  8899577765623565820u,   421976357197961116u,         101736223712u },
+  {  7095320096604405719u,  2962130818798626533u,         224022875384u },
+  {  2968593824439315788u,  8234383947306356345u,         248160577433u },
+  { 12621408323612585636u,  4380469931801381425u,         153446386848u },
+  {  3954422936414648259u, 15279887469027055916u,         160237465750u },
+  { 17143730087577690191u,  8534542821713755552u,         150828324359u },
+  {  5033045529399041876u,  7814613482565088782u,           7462658493u },
+  { 15857648521994521781u, 13771954404705323224u,         189423631045u },
+  { 16655573486499109541u,  4568173274762548144u,         197746579144u },
+  { 16652154439190075858u,  8105292616250821343u,         200247641169u },
+  { 18016950600164130638u,  2923678426777275612u,          81439388793u },
+  {  2086292996072613910u,  1808633176918384049u,         121158492925u },
+  { 17324462585194799521u, 18118642609460438969u,         253098046200u },
+  { 11079151463184927232u, 18138164175864360870u,         248982213583u },
+  {  5239846817488961536u,  4031433690465792404u,         207983271850u },
+  {  2778806963520143360u,  5012226396942308537u,         170218544458u },
+  {  6240890740138835968u,  7889712298793536835u,          74271713337u },
+  { 17250651344549707776u, 13500762396543628804u,          57427702160u },
+  {  4197354852709302272u,   501020624068841347u,         144731877796u },
+  {  9223372036854775808u,  8370653768288261750u,         164027160382u },
+  {                    0u,   647579990023635200u,          62453774050u },
+  {                    0u, 11106569307181154304u,         226035105381u },
+  {                    0u, 10797461613892861952u,         101602088328u },
+  {                    0u, 17627230675448889344u,         136585331566u },
+  {                    0u, 12197735707942322176u,         110955574089u },
+  {                    0u, 12871287735024877568u,          73661240577u },
+  {                    0u,  4611686018427387904u,           1697753906u },
+  {                    0u,                    0u,          50250000000u },
+  {                    0u,                    0u,         128000000000u },
+  {  5654803392547571318u,             31757315u,                    0u },
+  {  2931628102185393332u,    31757315306547506u,                    0u },
+  { 15964697617980212305u,  9451803574512021605u,              1721567u },
+  {   450380868305846606u,  8662766454758138424u,         223512383298u },
+  { 14631133530814566148u,  9207992007314947035u,          66469609510u },
+  {    31969822783742095u, 17118602861291201802u,          38499166246u },
+  { 10437269029385743245u, 11186560605745599967u,          38928001320u },
+  { 15196146496377392433u, 10505549821532796847u,          40606424665u },
+  {  4409099735137480938u, 18133667530488679216u,          89569506996u },
+  { 10644987914903248118u, 10778135771244330799u,         180983028086u },
+  {  3154431617534062973u, 17087985777033767391u,         118584283910u },
+  { 11702056331247960454u,  2639185991757283040u,           6926341565u },
+  { 15575315065965259114u,  5401720287293896400u,         189143070559u },
+  { 10759747609480050226u,  9816495392633895233u,          95292827843u },
+  { 12538236653960743718u, 10042051500090034990u,         195532153281u },
+  { 17857942663978005403u, 11629689537856384738u,         193544380702u },
+  { 11443004154750813211u,  2099086731766010483u,          30630446733u },
+  {  4004313188770806737u, 13665537898516458594u,         141113791719u },
+  { 17134872954824183228u, 16375672064669490764u,         231740810293u },
+  {  2659553912986171234u,  7770550512184564348u,          53887726961u },
+  {  9501854300969137926u,  6197048880720627314u,         113421242387u },
+  { 14528169966301018150u, 17963594118523106281u,          19335942692u },
+  { 18172091996515901778u,  8255454642407818663u,          36973808388u },
+  {  1133541705604751035u, 16744201957549498409u,           4447529092u },
+  { 18280349987988641497u, 17442505417202859722u,         132907705006u },
+  {  9936015874712336386u,  6383975767786687150u,         174945560113u },
+  { 15876720399740689614u, 15245442964998335795u,          49346076019u },
+  {  8618117825152456982u,  2910016124519524433u,         115826457119u },
+  {  8085525680745921564u,  3847913871169988463u,          31157752290u },
+  {  8072355444669730953u, 17210451512590059177u,         226208595828u },
+  {  9395030504766848294u, 17899408909991454145u,         116932980445u },
+  {  3537903114058185903u,  5920601932753251608u,         221970328901u },
+  {  2126094743961928691u, 16521781895108979744u,          69320956473u },
+  {   289185362555601115u,  3697493405554698771u,          57895647591u },
+  { 16909937501450129614u,  2816108280295732065u,         103200441519u },
+  { 14449642060360499058u, 14251078772056398988u,         175152661535u },
+  { 12433818908498244393u,  4543066550096031417u,          31772552528u },
+  { 11884444034578008581u,  3099369389734296977u,          80246280131u },
+  {   988625838444140793u,  5243484113636490986u,         195168017151u },
+  {  1675370907158909973u,  6823370511605197226u,         255284249843u },
+  { 15920186275316934067u, 11396290277624641942u,         243369895656u },
+  {  5600921198503757726u, 15934361408437566099u,         232617794133u },
+  { 10457357161776341741u, 14939272230935131954u,          85863803462u },
+  { 12225356765775740093u,  7500666177940329347u,          70809859570u },
+  {  4486633318598164537u,  4806714453065462270u,         242406611928u },
+  { 10302486602879381361u, 11557851247268441487u,         216260572512u },
+  { 15536428611301239541u, 10655523157206817381u,          96626552371u },
+  { 12026126645955462603u, 14769600176490881210u,          51577637067u },
+  { 14877968141142123551u, 16688495540925795167u,         203800661629u },
+  {   734560801645383190u,   909793965395524173u,         125904685156u },
+  { 15648943144911081638u, 12724590949761703756u,         100049320029u },
+  { 13664182862003235646u, 10810739657314826395u,          93689801457u },
+  {  3895127525902132786u,  2431218615388671301u,         241586051371u },
+  {  5249187334214137467u,  4235001167959059286u,          43131796625u },
+  { 10642260063359027505u,  6253317787396334247u,         145229579873u },
+  {   783598951897779422u,  9534525563070371898u,          97338993036u },
+  {  5538576558607624843u,  8392783992374030728u,         140516867666u },
+  { 15974581187564609611u, 16356257019231647540u,          82454973731u },
+  {  7474269406918257428u, 12896334001521091877u,          35886674469u },
+  {  8045286838779138019u,  1427636373320877084u,          37699111667u },
+  {  8184246376556341732u, 16116755731295043521u,         243077392322u },
+  {  1493267152679331840u, 15945633911163986837u,         194873691078u },
+  { 10179074811222818816u,  7510154241072743838u,         198864414546u },
+  {  3892499202005008384u,  3571560509790395119u,          82407126277u },
+  { 10341173215925108736u,  3576991649007035076u,           5193614683u },
+  {  6230307872002015232u, 15509961892750732443u,          91193909105u },
+  {  9295429630892703744u, 17789791359353349378u,         113840796718u },
+  {                    0u, 18331227331079738314u,          46964386521u },
+  {                    0u, 15386712883100476416u,         217993737824u },
+  {                    0u, 14082462055028752384u,          96834115376u },
+  {                    0u, 12919043128765186048u,          48763411797u },
+  {                    0u,  6125373368465096704u,          85700342731u },
+  {                    0u, 12335992698065387520u,         203332057155u },
+  {                    0u,  2774217370460225536u,          67668735504u },
+  {                    0u,                    0u,          16150390625u },
+  {                    0u,                    0u,          97000000000u },
+  { 10665454627995623288u,                  484u,                    0u },
+  { 16803537892767562832u,         484578175453u,                    0u },
+  {  8099123106849104444u,  4962829537462579598u,                   26u },
+  {  7077413686679401728u,  5711259460785241095u,          26269035528u },
+  { 13536636358372449666u, 13845894607204897444u,           8309607995u },
+  {  7280632235418610318u, 12116633056637003327u,          59750587450u },
+  {  6187823673116858809u,  2965791047992089560u,          58656843994u },
+  {  8624343686231740255u, 16021997451315962529u,         218160775854u },
+  {   806211610822132771u,  3942052271663803856u,         174868554222u },
+  { 18388078233202190882u, 15669876414782439922u,         238213699081u },
+  {  7628864426595573600u, 10594415915406145286u,           9849465702u },
+  {  4530799784343874981u, 10789820553031921377u,         102574324437u },
+  {  8561580552078486438u,  3989990218583987244u,         213584917344u },
+  { 13349114951221999594u,  2937341169808224563u,          96216297803u },
+  { 10029144738508991772u, 16267436558584536843u,          75159233583u },
+  { 12601907197916268979u, 16221580362814625793u,          47881859502u },
+  {  1329580921391066941u,  9695437602320209830u,         174879373633u },
+  {  3198179786356761112u, 10729753156793715126u,          65525590725u },
+  { 11406753413634654142u,  2609241432056861929u,         197581661084u },
+  { 11131812960525182090u,  8462663743997037565u,         156141447261u },
+  { 14299636753645227208u, 14993422143908194069u,          93458761920u },
+  { 12964114684643663326u,  1307443894537745373u,         192812795043u },
+  {  5019257593846306316u, 10017257439419829265u,         163070876675u },
+  {  6929086798159998121u, 16754772009970777891u,           3543036613u },
+  { 18359765766933703649u, 11722573031602862387u,         197908278010u },
+  {  9993076234752063198u,  7363764277467092384u,         250635481957u },
+  {  3257189215046584509u,  6733958494847390772u,         101399190461u },
+  {  2905234736672690348u,  8799796600227451045u,         189365048621u },
+  { 12064985302079670056u, 10512023194742249826u,          45477037929u },
+  { 14315096064942799930u,  4572542132337197059u,         105569857919u },
+  { 11943971043551974038u, 12600500455757416832u,         127247878005u },
+  { 12472773152119929647u,  7873789864743195199u,         117683074498u },
+  {  7791259796982183085u, 15724851676325671539u,         194426839003u },
+  { 16866829442051086686u,  8748017220462413167u,         219852445917u },
+  {  3702498393844653053u, 14172589522760466448u,         221474230963u },
+  {  2057239613841701716u,  9520545591489413768u,         179768297617u },
+  { 17201969976738286226u, 12488551088392570222u,         145516109810u },
+  { 18271566505443461640u,  1135798823651241684u,         242677005711u },
+  { 18368509115417119804u, 11168725610120161972u,         143061571777u },
+  {  7613923684154518587u,  9580104948718508826u,         193605457828u },
+  { 17984805084714865232u, 16638722716909738765u,         164519338529u },
+  {  4220802739051410373u, 15732724012348272797u,          33901986965u },
+  { 17812459042810815760u, 12269722190021214142u,         149852872677u },
+  { 10629526089664605307u, 13110655916311972587u,         229665142972u },
+  { 17437443267816548473u,  6618112997062866867u,         188710730081u },
+  { 12506371893701049304u,  8457936459015989309u,          97358768624u },
+  { 15737221540003030739u,  3329167139937134914u,         240458505654u },
+  {  2358380859011605513u,  5245511557216705097u,         182180474512u },
+  { 10042972713837039706u,  5655931353280440466u,         144284359751u },
+  { 13424397272769642495u,   604622132328697393u,          71306608653u },
+  {  6867102315755663029u,  8673282619234652338u,          13032776631u },
+  {  8690748404825506734u, 16929477433058445690u,         183470179592u },
+  {   956229930815387710u, 11036952409253549455u,           8917748810u },
+  {  7734449506297687888u, 18199392190170386320u,          74598314388u },
+  { 16332184961683848151u,  9683116091880335715u,         148986591027u },
+  { 15580777817612768828u,  2993913337608915120u,          51524922775u },
+  { 17404245271944696092u,  4490779842162392585u,         151162300367u },
+  { 13201420160494469229u,   946849923353644618u,         207243445663u },
+  { 16511717657124068078u,  3613491058474899828u,         159051328837u },
+  { 14131292492116594062u, 14624054199004410935u,          69195887742u },
+  { 18429136031865875691u, 12088470271991908244u,         126792771566u },
+  {  2563978348305862197u, 10071980927725011290u,         238655317286u },
+  { 14239974392147482896u,  2833441711428854664u,          38546003180u },
+  { 11164201396098998272u, 17655572411864340446u,         236153601182u },
+  {  7116971104932986880u,  4997642792058747802u,         158957110498u },
+  { 12437629862867369984u, 11489200787635734848u,         226270922758u },
+  { 16501893821638901760u, 12983586226429536913u,           6622830822u },
+  { 10649324268870959104u, 12311150768725063152u,         230703841619u },
+  {  7205759403792793600u,  8530052476845967905u,          83667388820u },
+  {                    0u,  6282736361499820264u,         148462415071u },
+  {                    0u, 11337164765929082880u,         223340587820u },
+  {                    0u,  8343856200414134272u,          44614588933u },
+  {                    0u, 17889330377156198400u,           5452321350u },
+  {                    0u, 17730714064155312128u,          70969782542u },
+  {                    0u,  7449235258647511040u,          14961183935u },
+  {                    0u,  9943947977234055168u,         191403823852u },
+  {                    0u,                    0u,         236539062500u },
+  {                    0u,                    0u,         228000000000u },
+  {  3016823727048309817u,              7394076u,                    0u },
+  { 17405973192644624358u,     7394076163542341u,                    0u },
+  {  8937219978302591747u, 12396245121240683569u,               400833u },
+  { 15178463196824222317u, 10248996648596888561u,         193672001794u },
+  { 11979404627460330594u, 11257495103713935002u,           2555599221u },
+  {  2006448052689740002u,  7555396579247433114u,         117610270032u },
+  { 16330465320863239865u,  4805022328730367462u,          80409578869u },
+  { 17136208883957646553u,  7056637817080232586u,         117260480782u },
+  {   140455118208931867u, 10811411483818434913u,          14382541102u },
+  {  3964972929179372247u, 16962406704495245447u,          46586087790u },
+  {  3378050330022776379u, 18074517319117194669u,         110919533909u },
+  {  6065353437512901255u,  3702019776117654523u,          85979821547u },
+  { 12768753059854699889u,  3551977551381082764u,         235200686894u },
+  {  6848720690951013326u, 16442608985936005282u,          46192553088u },
+  { 10953228058585475132u,  3580046275479139588u,         128891355619u },
+  { 15539127852083296166u,  8737412692712715330u,         227194074697u },
+  { 14534853647735598497u,  3082033243045084752u,          73473656091u },
+  {  1506909603576368170u, 16401023756841128699u,          27167077356u },
+  {  5475702579938239025u,  7520296082779572869u,         236889101279u },
+  { 12039747373985783332u,  9854104766152464159u,         223407676067u },
+  { 17572399137760898460u, 14169188802648310188u,         163534192089u },
+  {   869552790852091236u,  2018609909210367042u,         217768113264u },
+  {  4549585778048181804u,  8270271948267674359u,         112109429062u },
+  {  4121918231767210357u, 12320338602894572099u,          70448332340u },
+  {  1558397953312543179u, 17538536685990080547u,          52667886893u },
+  {  6067524298738069781u, 15833914616956760474u,          45950765978u },
+  {  5811095224555517056u,  6137696141415969855u,         154858358231u },
+  {  6440894514158997188u,  9757490468419438919u,         215332725174u },
+  {  4612748874388784257u,  3566639201356598903u,         182528954618u },
+  {  9908101430749813367u,  9760900035773954449u,         250193347898u },
+  { 15150017990912190499u,  3873778773990716438u,          58529139451u },
+  { 17470426264690059239u,  2295668377270167832u,         251209997968u },
+  {  9615161096851907726u,  1791721710912807593u,         144124448432u },
+  {  9227932132124142224u, 10571009006922683279u,         176097129428u },
+  {  4794113194321211621u,  9840791932778184867u,         212573055546u },
+  {   391512698859146347u, 11525464956561274613u,          58533470399u },
+  { 17209658878068655842u,  4435781488897895433u,         191624796707u },
+  {  3077364726606876150u,  6395563367070996741u,          35240464196u },
+  {  1952989567673965814u, 15538690795135662932u,          68346704184u },
+  { 11172860676923186449u, 16294558813563371936u,          56842354115u },
+  { 17338078544784947239u,  4942096228426070342u,         195883329803u },
+  {  4593380466519703278u,  6910116424372647153u,          11267911573u },
+  {   786884753602720052u, 17923400669760829478u,         149374598161u },
+  { 17848875822468020539u,  4134686917293039955u,          17971629497u },
+  {  2899664567187130618u, 16857102463116098681u,         185224141826u },
+  {  2973178834961857409u, 11364321508775167451u,           2913825355u },
+  { 11117453141176836727u,  7966947780972783899u,          75616061103u },
+  {  7535238370146462002u, 11261055695926686278u,         175431889104u },
+  { 10246175467290865448u,  9227040437353594058u,         208610463052u },
+  {  1203128834127050464u,  7185344074282882061u,          76500198864u },
+  { 14518048959078919658u, 14197856148610578032u,         208389518282u },
+  {  1553474987376920024u,   885688687260429427u,         202769667324u },
+  { 14956572380830948369u, 17407816160380305183u,         252048013279u },
+  {  7594162606042048292u, 17812728703806357349u,         223943679604u },
+  { 14461296147288811288u, 17120198191964319867u,         116965629957u },
+  { 18305427728131488265u, 12091952048375408786u,           5928087803u },
+  { 10253208939347909876u,   405056939269888281u,         251655506034u },
+  {  6446028915490812012u, 12485440679452408690u,         114021958180u },
+  { 12986063676957432257u,  8394369900823444407u,          36676837095u },
+  {  9769714697972762807u,  2877421667354294258u,         231455059704u },
+  {    97429465146664592u,  2676980714750756239u,         248155985341u },
+  { 16395571728207795868u,  6119309228579057021u,         189145119415u },
+  {  6331668478323650406u, 18203256146533333852u,         183331728417u },
+  { 18129911846294207040u,   351919978865493747u,          33986800493u },
+  {  9890094564876124160u,  5190010931882390570u,         109019077620u },
+  { 12290856656987750400u,  6982466386088036604u,         244281351056u },
+  {  8498454992640802816u,  4707293888784996898u,         144378520261u },
+  {  5341660584200896512u,   690306801165964760u,         197255182913u },
+  {  9288674231451648000u, 12456770961278956704u,          65037421606u },
+  {  1152921504606846976u, 16946092489294063943u,          38675282906u },
+  {                    0u, 11098404173866185376u,         218918649514u },
+  {                    0u, 15152070965853306880u,         170601645695u },
+  {                    0u, 17370091362040414208u,         127821395412u },
+  {                    0u, 10141938552171134976u,         212941634539u },
+  {                    0u, 10586988556645826560u,         235549795590u },
+  {                    0u, 12169852093061922816u,           6573921799u },
+  {                    0u, 16717361816799281152u,           7659729003u },
+  {                    0u,                    0u,         107906250000u },
+  {                    0u,                    0u,          16000000000u },
+  { 15212079674427582639u,                  112u,                    0u },
+  { 10179808126814248333u,         112824648491u,                    0u },
+  {  6066766544199222848u,  2144184049294538808u,                    6u },
+  {  6625308131806923532u,  4108002197393276873u,           6116236450u },
+  {  9122786786400665713u,  6446230217393892753u,         162222695245u },
+  { 11932880778639151320u,  5571068025259989822u,          77349450840u },
+  {  3884040911779255011u, 14804812668872528331u,          88302008202u },
+  { 13441817515637357872u, 17369928488562523047u,         138802570502u },
+  { 11628577856022352826u,  2967474173531035027u,           6941625710u },
+  { 13296656925520243654u,  5291425437992807716u,         110160867097u },
+  {  5020720704545399398u, 14219547193739388064u,          25286848747u },
+  { 14121973606499014694u, 17720313647158217462u,         235770843197u },
+  {  3642481034345420114u, 12334850628290578491u,          61960620127u },
+  {  9845536238569696768u,  7818499847417334620u,          95668673592u },
+  { 17655403572195686356u,   136007040922198372u,          56423841726u },
+  {  8377495365136654029u,  8523477092112604449u,         190007372956u },
+  { 13713682649609025426u,   367934822655966629u,         156462058619u },
+  {  1367709905452854731u, 12964987687054730050u,         123019945786u },
+  {  9981467701727208680u, 15267036012420885462u,          58702833390u },
+  {  6277920117543306205u, 11142900264750765568u,         238827627680u },
+  {  9344111460418701726u, 13680181547777718603u,         160604057833u },
+  {  4918507011364617264u, 13001922925761426065u,         233741604127u },
+  {  6554777203830755259u,  2397730045956515935u,          31704835654u },
+  {  4198262173120265648u,  4482395522588406288u,          70129981206u },
+  {  8080325935698446819u,  3255525722490493080u,          22242991148u },
+  { 12797633874200091733u,   836222287193822098u,          44176482403u },
+  {  8376502502208665497u,   420898743993182306u,          99045331701u },
+  {  9891973386793349173u, 11652649973356574054u,         245022816966u },
+  { 14877430279003795462u, 15058402726661910231u,         198631691420u },
+  {  8759933935842067041u,  9600134495208339559u,         156816317647u },
+  {  3753418510388703513u, 14626343323989004842u,         207520424333u },
+  {  2961383332545305985u,  6813981265331086665u,         141792895660u },
+  {  2497674184068629507u, 10281745288790487888u,         172369386664u },
+  { 15244544070742305452u, 17569829347075761940u,         168557374528u },
+  {    45953573565810823u,  7654580675237889478u,          64952462357u },
+  {  3960077421351906445u, 16194838649686212364u,          21414955649u },
+  {  3173330011013883118u,  6495102772252453635u,         129877923962u },
+  { 11026266219545759160u, 14935159852819761348u,         122352100226u },
+  {  8886757764964685632u, 17381879863441579697u,         130809636637u },
+  { 13952322129918090479u,  9062335510435372583u,          29942273595u },
+  {  4127250666614902202u,  7569219009130126626u,          59491270192u },
+  { 17649958504065306911u, 12652124168176193362u,          48410328184u },
+  { 13269305359002216873u,  8940200224697247767u,         120685873025u },
+  { 16236593433831947843u,  5600570701927432884u,         129484649225u },
+  { 13580930396682424057u,  2018432801986093157u,           9303607546u },
+  {   421976357197961116u,  8235849749361824736u,         250109419461u },
+  {  2962130818798626533u,  9705097287982370040u,         197446466309u },
+  {  8234383947306356345u,  3517483139049842585u,           5526114378u },
+  {  4380469931801381425u,   958281614186777760u,          74190683143u },
+  { 15279887469027055916u,  7336473432636108950u,           7051948550u },
+  {  8534542821713755552u, 12955383920176764423u,           6397711021u },
+  {  7814613482565088782u, 10735469126281273789u,         173702312769u },
+  { 13771954404705323224u,  8637888232514730693u,          65581970947u },
+  {  4568173274762548144u,  6806336737533581000u,           3468260859u },
+  {  8105292616250821343u, 16142569672872330321u,         251368972253u },
+  {  2923678426777275612u,  8141285259947963513u,         221875090455u },
+  {  1808633176918384049u,  5220241098754220797u,          23441339958u },
+  { 18118642609460438969u,   154438799943119608u,          54282989837u },
+  { 18138164175864360870u,  2226876628677628879u,          13008372144u },
+  {  4031433690465792404u, 17219557081221357482u,         176120719223u },
+  {  5012226396942308537u, 15401507148161015114u,         119933474059u },
+  {  7889712298793536835u,  8842629766613985337u,          11834917375u },
+  { 13500762396543628804u,  3180100571546071440u,         255479359920u },
+  {   501020624068841347u,  7740848704392475044u,         176172393597u },
+  {  8370653768288261750u,  2014314126623495998u,         125419632249u },
+  {   647579990023635200u, 11209566016506885858u,         121109196187u },
+  { 11106569307181154304u,  7117166613733441125u,         155607671791u },
+  { 10797461613892861952u,  4197646860931880328u,         239385822375u },
+  { 17627230675448889344u,  5487263271238026094u,         167227554892u },
+  { 12197735707942322176u, 18148076225293562697u,          76297465137u },
+  { 12871287735024877568u,  9127276943027950849u,          49983809183u },
+  {  4611686018427387904u,  9691696125379324722u,         159494790674u },
+  {                    0u, 13102362262487705216u,          18525387899u },
+  {                    0u,  8929385439893192704u,         123710280481u },
+  {                    0u, 11891353410743566336u,          33484062954u },
+  {                    0u,  1587423090877399040u,         234644631560u },
+  {                    0u,  3489137423026225152u,           8086054378u },
+  {                    0u, 13046928120492326912u,         234189146518u },
+  {                    0u, 11529215046068469760u,         150707275390u },
+  {                    0u,                    0u,         126625000000u },
+  {                    0u,                    0u,          64000000000u },
+  {  9451803574512021605u,              1721567u,                    0u },
+  {  8662766454758138424u,     1721567512383298u,                    0u },
+  {  9207992007314947035u,  6674960280855494694u,                93326u },
+  { 17118602861291201802u, 16378845781483497510u,         142361850321u },
+  { 11186560605745599967u, 17606907750956804392u,         209887899008u },
+  { 10505549821532796847u, 13225609159240506969u,         128954472381u },
+  { 18133667530488679216u,  2668084873338435252u,         189716961709u },
+  { 10778135771244330799u, 14802814305275861366u,         173144637170u },
+  { 17087985777033767391u,  8005510553372365574u,         242802462171u },
+  {  2639185991757283040u, 12748500143273514429u,         219433979596u },
+  {  5401720287293896400u, 10393733905569036127u,         204691097577u },
+  {  9816495392633895233u,   603389089974790339u,         233563445444u },
+  { 10042051500090034990u,  2033494532597735873u,         196032709788u },
+  { 11629689537856384738u,  9204796763694620958u,         156110235959u },
+  {  2099086731766010483u,  7826260310402107021u,          55498993032u },
+  { 13665537898516458594u, 10122690201685169383u,         136424262421u },
+  { 16375672064669490764u,  7438455564568110133u,          21548752135u },
+  {  7770550512184564348u,  2805412574380520817u,           7403239484u },
+  {  6197048880720627314u,  7250965427231182867u,          60152081720u },
+  { 17963594118523106281u,  8136242944826085924u,          56393075623u },
+  {  8255454642407818663u, 15357191647956011780u,         167441066613u },
+  { 16744201957549498409u,  7369614426695395460u,         117832515027u },
+  { 17442505417202859722u, 10886957545142526638u,         211399507598u },
+  {  6383975767786687150u,  2030047207417538097u,         142590183151u },
+  { 15245442964998335795u, 11557093828502314355u,         239110049079u },
+  {  2910016124519524433u, 15201062539664128543u,          55626511311u },
+  {  3847913871169988463u,  8846936323343880674u,         207824051251u },
+  { 17210451512590059177u,  1485291750116245364u,          51479593379u },
+  { 17899408909991454145u,  2076024439668322013u,         163080517827u },
+  {  5920601932753251608u,  7029497773682748741u,         195112541510u },
+  { 16521781895108979744u, 16333533921668749881u,          70381069837u },
+  {  3697493405554698771u,  2065057316131928423u,          13885442648u },
+  {  2816108280295732065u,  7800502648925570223u,          88111946981u },
+  { 14251078772056398988u, 17011619967093802015u,         229422866095u },
+  {  4543066550096031417u,  5368819344429198672u,         175922201766u },
+  {  3099369389734296977u, 15598879366754275267u,         166291044279u },
+  {  5243484113636490986u, 16393893486035835647u,         183845616944u },
+  {  6823370511605197226u, 12042046205096920307u,          48888714746u },
+  { 11396290277624641942u, 15437070428008474344u,         250652800632u },
+  { 15934361408437566099u, 13704569163204647509u,         120836845264u },
+  { 14939272230935131954u, 18192483750856993350u,         208742926182u },
+  {  7500666177940329347u,  5152535865317963250u,         102986216520u },
+  {  4806714453065462270u, 17512614083933854680u,          72279319528u },
+  { 11557851247268441487u, 14481918350603613536u,         232949360711u },
+  { 10655523157206817381u, 16124419709964004915u,          71785066366u },
+  { 14769600176490881210u, 18088011566435813579u,         126874106543u },
+  { 16688495540925795167u, 15008862380698848893u,         175980553071u },
+  {   909793965395524173u, 18160498644611827812u,         111813632059u },
+  { 12724590949761703756u,  3604680497457231965u,          59984482604u },
+  { 10810739657314826395u,  5957615565551495921u,          44195410121u },
+  {  2431218615388671301u, 17528455034961565995u,         201322962986u },
+  {  4235001167959059286u,  8503772325120113809u,          42950219451u },
+  {  6253317787396334247u,  8501492578048509537u,         187460990421u },
+  {  9534525563070371898u,  2296237701094386060u,         213460866836u },
+  {  8392783992374030728u,  3753593040591076946u,          20124479295u },
+  { 16356257019231647540u,  8518075399775653155u,          63203482686u },
+  { 12896334001521091877u, 12757855675959554597u,          62461765792u },
+  {  1427636373320877084u,   121631169379748595u,         160691604742u },
+  { 16116755731295043521u, 16679062494579173314u,           6006593638u },
+  { 15945633911163986837u, 10739912744743898054u,         102904173789u },
+  {  7510154241072743838u,  9367340677776287570u,         221582211836u },
+  {  3571560509790395119u, 12227321512794715397u,         252507804555u },
+  {  3576991649007035076u,  7241061891859170651u,         139662844427u },
+  { 15509961892750732443u, 13148571323079237489u,          11392538751u },
+  { 17789791359353349378u, 12509763434355012654u,         127712785479u },
+  { 18331227331079738314u, 11812768946960181977u,          71678155634u },
+  { 15386712883100476416u, 14170358803552564832u,         114640371487u },
+  { 14082462055028752384u, 18179989524780635952u,          31768176689u },
+  { 12919043128765186048u, 17091718978514754901u,          49985539206u },
+  {  6125373368465096704u,  7394768384359232459u,         134926543942u },
+  { 12335992698065387520u,  6778628272692852803u,          70400871197u },
+  {  2774217370460225536u, 18193335045875234320u,          29367470174u },
+  {                    0u,  1378519212560967521u,          94986262669u },
+  {                    0u,  4677732610631043584u,         141074729676u },
+  {                    0u, 17296098591070486528u,         204253580392u },
+  {                    0u,  7343735382392963072u,         104937623383u },
+  {                    0u, 14525996728454217728u,          87398104692u },
+  {                    0u,  9691359370008330240u,         116787455860u },
+  {                    0u,  3044433348102455296u,         116525369644u },
+  {                    0u,  9223372036854775808u,          44165039062u },
+  {                    0u,                    0u,         214500000000u },
+  {  4962829537462579598u,                   26u,                    0u },
+  {  5711259460785241095u,          26269035528u,                    0u },
+  { 13845894607204897444u,  7822291454600056379u,                    1u },
+  { 12116633056637003327u,  8201586317771250746u,           1424047269u },
+  {  2965791047992089560u,  3278889188817135834u,         165444608885u },
+  { 16021997451315962529u,  1710725240251040430u,         117177748939u },
+  {  3942052271663803856u,  1850175733663425006u,         203092738601u },
+  { 15669876414782439922u,  9147599666163914249u,          41100298227u },
+  { 10594415915406145286u, 10221885933644344166u,         243495892371u },
+  { 10789820553031921377u, 14901479793736678101u,         147554129546u },
+  {  3989990218583987244u,  5181831442059703136u,         138807810838u },
+  {  2937341169808224563u,  6396246577759793483u,          22280907645u },
+  { 16267436558584536843u, 14167229556464870447u,         125346741221u },
+  { 16221580362814625793u,  2969982933326311854u,         229768007053u },
+  {  9695437602320209830u,  7892677766222018881u,         141161003097u },
+  { 10729753156793715126u,   798698968922663621u,          89427862919u },
+  {  2609241432056861929u, 15926812109043458972u,         135043297557u },
+  {  8462663743997037565u,  8663842590352697437u,          21863394214u },
+  { 14993422143908194069u, 17093523026636671168u,         166469667847u },
+  {  1307443894537745373u,   839764004742743203u,           7926641740u },
+  { 10017257439419829265u, 16894643909298232323u,          76045523697u },
+  { 16754772009970777891u,  9066702926218949317u,         241915860481u },
+  { 11722573031602862387u,  9119392417260546810u,           1491506950u },
+  {  7363764277467092384u,  9723021096578315109u,           6494363253u },
+  {  6733958494847390772u, 14787464248751217597u,         117527086029u },
+  {  8799796600227451045u,  3733434565920249133u,         205801630043u },
+  { 10512023194742249826u,  6643788868836820841u,          91202389893u },
+  {  4572542132337197059u,  4729646697422664063u,         133360160516u },
+  { 12600500455757416832u,  4090144564201555829u,           4256394661u },
+  {  7873789864743195199u,  2109480737093400002u,         165221727181u },
+  { 15724851676325671539u, 16577155033369419739u,         205114355179u },
+  {  8748017220462413167u,   745377248603805917u,         235898649375u },
+  { 14172589522760466448u, 11305561465807999667u,          31040406981u },
+  {  9520545591489413768u,  2211245518782892177u,         197612875715u },
+  { 12488551088392570222u, 14170095199249735666u,         195119871859u },
+  {  1135798823651241684u, 17849973668116118927u,         115768162399u },
+  { 11168725610120161972u,  9020960204585720001u,          95967649011u },
+  {  9580104948718508826u, 10807134002871850916u,         243489027232u },
+  { 16638722716909738765u,  3925122626254791201u,         160585855908u },
+  { 15732724012348272797u, 17208463291312718997u,         164212781323u },
+  { 12269722190021214142u,  5145077219589447653u,          11932872664u },
+  { 13110655916311972587u, 17602397765035489468u,         216278915194u },
+  {  6618112997062866867u, 16422643262490753377u,         122954227894u },
+  {  8457936459015989309u,  2902509461400906224u,         182890273275u },
+  {  3329167139937134914u,  3422418805967265206u,         251157345353u },
+  {  5245511557216705097u,  4228874576277237392u,          73185529695u },
+  {  5655931353280440466u,  2553488530807495751u,          95229247750u },
+  {   604622132328697393u, 11546099176912486413u,           6138424890u },
+  {  8673282619234652338u, 10460791037534167991u,          58625915290u },
+  { 16929477433058445690u,  8127117908566000904u,         154567080618u },
+  { 11036952409253549455u, 11541304458088287306u,         170440571944u },
+  { 18199392190170386320u,  6249718665174839700u,          40625655368u },
+  {  9683116091880335715u, 13102508413386290995u,          72338797927u },
+  {  2993913337608915120u,  6274675218640661911u,         103710288404u },
+  {  4490779842162392585u,  3404497118599817167u,          20340150825u },
+  {   946849923353644618u, 11258566093988562335u,          41184558158u },
+  {  3613491058474899828u, 16762592482501635397u,          78610328090u },
+  { 14624054199004410935u,  5550125446725071998u,          26908701959u },
+  { 12088470271991908244u,  6370033225258510318u,           7300872903u },
+  { 10071980927725011290u,  1503521728674735398u,         199345320193u },
+  {  2833441711428854664u,  4250415082606384364u,           1081506076u },
+  { 17655572411864340446u,  6020091901030562974u,          28230415463u },
+  {  4997642792058747802u, 16288222967151527138u,         103326349835u },
+  { 11489200787635734848u,  6377016228656203782u,          11882986336u },
+  { 12983586226429536913u,  8378856515587563750u,          96345698742u },
+  { 12311150768725063152u, 15812881490200838483u,         182454218721u },
+  {  8530052476845967905u,  4548570371183413652u,         225857218023u },
+  {  6282736361499820264u, 16731431495283420383u,         231246578493u },
+  { 11337164765929082880u, 14737727629551135532u,          61907012718u },
+  {  8343856200414134272u, 12413722258104293893u,         110798933815u },
+  { 17889330377156198400u,   800899742400762438u,          55672949232u },
+  { 17730714064155312128u,   603197008376033550u,         240043416862u },
+  {  7449235258647511040u,  6380777281587743935u,          30032699375u },
+  {  9943947977234055168u, 10001440249018225388u,         239345902629u },
+  {                    0u,  5505914461980436708u,          37542179162u },
+  {                    0u,  1105464290051876864u,          90298476221u },
+  {                    0u,  4500443576769970176u,         189059927339u },
+  {                    0u,  2843045143185981440u,          43243969535u },
+  {                    0u,   660949699682893824u,         255154121786u },
+  {                    0u,   276549164618219520u,          58035830155u },
+  {                    0u,  4683743612465315840u,         139014991760u },
+  {                    0u,                    0u,         144253906250u },
+  {                    0u,                    0u,          74000000000u },
+  { 12396245121240683569u,               400833u,                    0u },
+  { 10248996648596888561u,      400833672001794u,                    0u },
+  { 11257495103713935002u,  4370024159708535157u,                21729u },
+  {  7555396579247433114u,  7166684413908503888u,         225236899484u },
+  {  4805022328730367462u, 10217286283215687029u,         156388506740u },
+  {  7056637817080232586u,  4767369911989629198u,         116553880199u },
+  { 10811411483818434913u, 14407999214182082862u,         135258439640u },
+  { 16962406704495245447u,  8472271297615317358u,         216781059202u },
+  { 18074517319117194669u,  6236024012584764757u,         130459282747u },
+  {  3702019776117654523u,  1951826556984620523u,          59338055539u },
+  {  3551977551381082764u, 12357130551551830830u,         115105808729u },
+  { 16442608985936005282u,  8927758011099278464u,          89669881389u },
+  {  3580046275479139588u, 10199854049407140323u,          45483974731u },
+  {  8737412692712715330u, 17895455027038549577u,          75552935195u },
+  {  3082033243045084752u, 16539200343720527131u,          27970114560u },
+  { 16401023756841128699u,  3536976106235802604u,            896591847u },
+  {  7520296082779572869u, 16980391644793590751u,         231191739858u },
+  {  9854104766152464159u, 10090294316609084067u,         210920508875u },
+  { 14169188802648310188u, 17603457857266236889u,         203546995950u },
+  {  2018609909210367042u, 11164962743035868272u,         238954285362u },
+  {  8270271948267674359u,  1585686890718568774u,          50605253843u },
+  { 12320338602894572099u, 10882524700472655412u,         211085960258u },
+  { 17538536685990080547u,  2194808754940947757u,          66589942846u },
+  { 15833914616956760474u,   274100791137209242u,          62118980821u },
+  {  6137696141415969855u, 12203404582981010903u,         213014859033u },
+  {  9757490468419438919u,   541940706340938166u,          25661547888u },
+  {  3566639201356598903u, 10305434016011833594u,         112029378664u },
+  {  9760900035773954449u,  7900783531944543546u,         104558658697u },
+  {  3873778773990716438u,  8920818625012419323u,         137428302333u },
+  {  2295668377270167832u, 12532363335400447632u,         253483598546u },
+  {  1791721710912807593u, 13483507182924762800u,         210679380777u },
+  { 10571009006922683279u,   415911049779278804u,          41730942389u },
+  {  9840791932778184867u,  3441628281170127418u,         181022546583u },
+  { 11525464956561274613u, 17830811568183566527u,         151186571042u },
+  {  4435781488897895433u, 17897295813176613411u,          34966610231u },
+  {  6395563367070996741u,  2086148701331574596u,          55970214350u },
+  { 15538690795135662932u, 13015567826878853432u,         206113090347u },
+  { 16294558813563371936u, 12944531121587846595u,          43705575345u },
+  {  4942096228426070342u,  3534180912913737995u,         177701724438u },
+  {  6910116424372647153u,  3447584022400118677u,          22191588331u },
+  { 17923400669760829478u,  6375676813770849297u,         235186893904u },
+  {  4134686917293039955u, 11580694081479200185u,          80345626132u },
+  { 16857102463116098681u,  1872134358882196482u,          20627790684u },
+  { 11364321508775167451u, 17602652840520938059u,          92101488606u },
+  {  7966947780972783899u, 10331040597716338351u,         222954241722u },
+  { 11261055695926686278u,    73785407041056976u,         186560046833u },
+  {  9227040437353594058u, 17166209109167902028u,         241003999914u },
+  {  7185344074282882061u,  8762475644006589904u,         170930582060u },
+  { 14197856148610578032u,  8839001228645872586u,          44475014756u },
+  {   885688687260429427u, 13558262784529110268u,         100479163216u },
+  { 17407816160380305183u,  5640853896420358111u,          80734994898u },
+  { 17812728703806357349u,  8459930353450835572u,         210305791302u },
+  { 17120198191964319867u,  7643830211500171269u,          70458613743u },
+  { 12091952048375408786u,  1308629115231236347u,         239414372866u },
+  {   405056939269888281u,  8957268500971669618u,           2070940926u },
+  { 12485440679452408690u,  7645679094277669412u,         254485574498u },
+  {  8394369900823444407u,  3821107497040617191u,          98414473094u },
+  {  2877421667354294258u,  8847137191985934072u,         134207142652u },
+  {  2676980714750756239u,  3531126524756088253u,         252479604268u },
+  {  6119309228579057021u,  8726915034124352183u,          44191422752u },
+  { 18203256146533333852u, 17611136727168068641u,          32473087011u },
+  {   351919978865493747u, 18017743272784259949u,          35954701634u },
+  {  5190010931882390570u, 18113575006829616116u,          66976743819u },
+  {  6982466386088036604u, 12805550441678740368u,         139981938868u },
+  {  4707293888784996898u,  8061966093393027781u,         180694190280u },
+  {   690306801165964760u, 11954593141554100801u,         200437040057u },
+  { 12456770961278956704u, 14068656112359197734u,         185648059792u },
+  { 16946092489294063943u,   895878255770467290u,         144762663376u },
+  { 11098404173866185376u, 10319906489512197802u,         208048565657u },
+  { 15152070965853306880u, 14551142616794302079u,         153559443251u },
+  { 17370091362040414208u, 15933181735739307476u,          51788819021u },
+  { 10141938552171134976u, 11524527334398983147u,          77863739512u },
+  { 10586988556645826560u, 11828012606225556742u,         120624745878u },
+  { 12169852093061922816u,  3556238869349799431u,         150641197848u },
+  { 16717361816799281152u,  7403090230513381483u,          24192784095u },
+  {                    0u, 10172292854665622800u,         223401322325u },
+  {                    0u, 11240746576366182400u,          85551441100u },
+  {                    0u, 17021927826892259328u,         204609362092u },
+  {                    0u,  9046328496309141504u,         172922760556u },
+  {                    0u,  8038996803112140800u,         108490402450u },
+  {                    0u, 17098478935265509376u,         146435794889u },
+  {                    0u,  7205759403792793600u,         201926910400u },
+  {                    0u,                    0u,         192390625000u },
+  {                    0u,                    0u,         232000000000u },
+  {  2144184049294538808u,                    6u,                    0u },
+  {  4108002197393276873u,           6116236450u,                    0u },
+  {  6446230217393892753u,  6116236450222695245u,                    0u },
+  {  5571068025259989822u,  6240972538554414168u,            331561842u },
+  { 14804812668872528331u,  4356262642990299018u,         114338323799u },
+  { 17369928488562523047u,  1335108558830511366u,          87236153471u },
+  {  2967474173531035027u, 18435704923261947246u,         127072376379u },
+  {  5291425437992807716u,  8395401931972636441u,          59999401566u },
+  { 14219547193739388064u, 12482665946362458347u,          94455115650u },
+  { 17720313647158217462u, 16101242875289374781u,         130676686676u },
+  { 12334850628290578491u,  4708983440241068127u,          84872850125u },
+  {  7818499847417334620u, 14856666972541426744u,         205255274503u },
+  {   136007040922198372u,  6938795288315789246u,           7805381530u },
+  {  8523477092112604449u,  5556307628265073820u,         154376152846u },
+  {   367934822655966629u,  1441404248927865979u,          14301208040u },
+  { 12964987687054730050u, 16710378912353838906u,         232078138680u },
+  { 15267036012420885462u, 18289940136919312110u,          56905871455u },
+  { 11142900264750765568u, 10217414145292657824u,          95991499641u },
+  { 13680181547777718603u, 12461165826430955753u,         121553887130u },
+  { 13001922925761426065u,   662762458988270879u,         154675521153u },
+  {  2397730045956515935u, 16488546856395302470u,         129035928424u },
+  {  4482395522588406288u,  2612816787977180950u,         104893845916u },
+  {  3255525722490493080u, 16446616379327454252u,         156141641081u },
+  {   836222287193822098u,  7842178508581740643u,         121891572860u },
+  {   420898743993182306u, 14779029861369369333u,         124425125348u },
+  { 11652649973356574054u,  2697664446153849542u,         228801172814u },
+  { 15058402726661910231u, 12135106444393649308u,          78146240682u },
+  {  9600134495208339559u,  9550285041205189839u,         170657845438u },
+  { 14626343323989004842u,  8790318168586740109u,         190517721989u },
+  {  6813981265331086665u, 14038474217155846828u,         133476524102u },
+  { 10281745288790487888u,  4263144264274812072u,          70761027212u },
+  { 17569829347075761940u, 11940456333341715520u,         140231105513u },
+  {  7654580675237889478u, 15751110736831573013u,         233647293434u },
+  { 16194838649686212364u, 18384528705472318081u,         250853869423u },
+  {  6495102772252453635u,  2393654818032310394u,         111996627298u },
+  { 14935159852819761348u, 12812209822018626434u,          98129760287u },
+  { 17381879863441579697u,  3110778569433458461u,          31694551286u },
+  {  9062335510435372583u,  2860264756226872891u,         246168635644u },
+  {  7569219009130126626u,  2384146980060315184u,         252155055263u },
+  { 12652124168176193362u, 14117430062880324728u,         159129244866u },
+  {  8940200224697247767u,  3769610173216737153u,         194765307417u },
+  {  5600570701927432884u, 17731974340232672009u,          25204350976u },
+  {  2018432801986093157u,  1971479303384713466u,            961252255u },
+  {  8235849749361824736u,  3449462959779012549u,         159106874107u },
+  {  9705097287982370040u, 13743454852043766533u,         251186995761u },
+  {  3517483139049842585u,  7417711187131879498u,          49745034180u },
+  {   958281614186777760u,  3650992383501007879u,         196402114929u },
+  {  7336473432636108950u, 12838770342493958662u,         113197920693u },
+  { 12955383920176764423u, 16025068246546338477u,         181695991134u },
+  { 10735469126281273789u,  6579965938260177729u,          94868720690u },
+  {  8637888232514730693u,  4742939430174291459u,          50356700668u },
+  {  6806336737533581000u, 13062256857527449083u,         252257115261u },
+  { 16142569672872330321u,  2301174570202439645u,         125708106363u },
+  {  8141285259947963513u,  7638687886069412887u,         123124746923u },
+  {  5220241098754220797u,   936322449610274358u,         171414094100u },
+  {   154438799943119608u, 12926010544311283981u,          20050758141u },
+  {  2226876628677628879u, 12647854908989899184u,         253700720435u },
+  { 17219557081221357482u,  8862093163358513015u,          51685641588u },
+  { 15401507148161015114u,   444784343917630731u,         116480415033u },
+  {  8842629766613985337u, 11033952249213387263u,          57024111807u },
+  {  3180100571546071440u, 18168634046363183536u,         191598151749u },
+  {  7740848704392475044u,  3837904761417065597u,          69984923625u },
+  {  2014314126623495998u,   111459007020906105u,         233208053234u },
+  { 11209566016506885858u, 16191761957496794523u,         242006042204u },
+  {  7117166613733441125u,  9856250800340378607u,          92877757174u },
+  {  4197646860931880328u,  9491800102275105959u,         246534308426u },
+  {  5487263271238026094u, 10777328578953608268u,          74514551514u },
+  { 18148076225293562697u, 17424440628313779505u,         218584240152u },
+  {  9127276943027950849u,  3285814872419755679u,          24944580819u },
+  {  9691696125379324722u,  2824823424107240978u,         211178124381u },
+  { 13102362262487705216u, 12271707680713669755u,          93153133984u },
+  {  8929385439893192704u,  6951481875178001185u,         160665250606u },
+  { 11891353410743566336u, 10202522487003824362u,          46376840587u },
+  {  1587423090877399040u,  4834668463880990728u,         139553079852u },
+  {  3489137423026225152u, 10871520987687904746u,          44262087902u },
+  { 13046928120492326912u, 12057698794225322390u,         222589346333u },
+  { 11529215046068469760u,  7263351819222681214u,          29653649161u },
+  {                    0u,  1778055686910650944u,           9393747091u },
+  {                    0u, 17108187120491986944u,         147096388591u },
+  {                    0u,  3067636961549221888u,         239927436682u },
+  {                    0u, 16702141595163557888u,         138166296932u },
+  {                    0u,  2432053749942845440u,         100905424910u },
+  {                    0u, 17791470327927144448u,          14131841897u },
+  {                    0u,  1152921504606846976u,         105964477539u },
+  {                    0u,                    0u,          99062500000u },
+  {                    0u,                    0u,         160000000000u },
+  {  6674960280855494694u,                93326u,                    0u },
+  { 16378845781483497510u,       93326361850321u,                    0u },
+  { 17606907750956804392u,  4283581425266273664u,                 5059u },
+  { 13225609159240506969u,  6725911039793895357u,         195232213414u },
+  {  2668084873338435252u,  1188689198788975021u,         166364612368u },
+  { 14802814305275861366u, 10825527435847761650u,          16064438970u },
+  {  8005510553372365574u,  3917696829526085083u,         186586853018u },
+  { 12748500143273514429u, 12646861173976387276u,         154212378770u },
+  { 10393733905569036127u, 18398576063183996905u,         146685587717u },
+  {   603389089974790339u, 16919251228485834948u,           5997388806u },
+  {  2033494532597735873u, 17296019588687185052u,           6917194446u },
+  {  9204796763694620958u, 12365301604512770359u,         206937619100u },
+  {  7826260310402107021u,  2814271599679204744u,         156670324343u },
+  { 10122690201685169383u,  2154994415780170517u,         119152561969u },
+  {  7438455564568110133u,  6717373824370072839u,          49116822481u },
+  {  2805412574380520817u, 12709155755801344060u,         209364149564u },
+  {  7250965427231182867u,   826847911966403896u,          60688964714u },
+  {  8136242944826085924u,  2277322703890025383u,         106044823515u },
+  { 15357191647956011780u,  2774508958389496437u,         219123453911u },
+  {  7369614426695395460u,   245697774950120915u,         215150406432u },
+  { 10886957545142526638u,  1268929063431863950u,          32013319303u },
+  {  2030047207417538097u,  6735665673159411439u,         135068788782u },
+  { 11557093828502314355u, 14734771742997073207u,          46365141167u },
+  { 15201062539664128543u, 13683287077957612495u,         175798773576u },
+  {  8846936323343880674u, 15370263741354826803u,          72741772478u },
+  {  1485291750116245364u,    48035913070297507u,         190833223667u },
+  {  2076024439668322013u,  1206547475966802115u,         243002604032u },
+  {  7029497773682748741u, 13512340386605768006u,             65407069u },
+  { 16333533921668749881u,  2325760467700278797u,          93732505440u },
+  {  2065057316131928423u, 10848110652847753816u,          96126079727u },
+  {  7800502648925570223u, 15846378960784301285u,         239588077256u },
+  { 17011619967093802015u, 14121839924449844911u,         200859033924u },
+  {  5368819344429198672u,  5147613424753296550u,          68765546476u },
+  { 15598879366754275267u, 16817040482828810167u,         236279052682u },
+  { 16393893486035835647u,  5773528746119363888u,         138911653591u },
+  { 12042046205096920307u,  8716201595536184826u,         215312983620u },
+  { 15437070428008474344u,  5259122109038474872u,          68472506235u },
+  { 13704569163204647509u, 14744540084230155984u,         123285097580u },
+  { 18192483750856993350u, 10719345477982635878u,         108799303119u },
+  {  5152535865317963250u, 13698037261310555208u,         207581096882u },
+  { 17512614083933854680u, 16141171632951976936u,         178742572087u },
+  { 14481918350603613536u, 10060790174955808839u,          55875014667u },
+  { 16124419709964004915u,  4250043307981877118u,          11545396528u },
+  { 18088011566435813579u,  7075646198054337199u,          48230395309u },
+  { 15008862380698848893u, 18141738384245531503u,         173383571548u },
+  { 18160498644611827812u,  8174370508376809531u,          92983465608u },
+  {  3604680497457231965u,  3581964982731575596u,         136443133513u },
+  {  5957615565551495921u, 14798509948722114761u,          73194178710u },
+  { 17528455034961565995u, 14713923334885122090u,         150802228831u },
+  {  8503772325120113809u,  5042978054260414139u,          95797643382u },
+  {  8501492578048509537u,  2052996319372883413u,         118273380388u },
+  {  2296237701094386060u,  8825683007899981588u,          36111293153u },
+  {  3753593040591076946u,  9992196755378745151u,         225478441234u },
+  {  8518075399775653155u,  9301073417573669950u,          18541678071u },
+  { 12757855675959554597u,  5331614769144850592u,         247504212200u },
+  {   121631169379748595u, 14354009428310052102u,         232289027415u },
+  { 16679062494579173314u,  5581221063029119078u,          87778132410u },
+  { 10739912744743898054u,  1529260335339476189u,         186302558600u },
+  {  9367340677776287570u, 16483061525949201148u,         136082901368u },
+  { 12227321512794715397u, 14431217812333089675u,         120893548555u },
+  {  7241061891859170651u,  3452349151135392267u,          11782317885u },
+  { 13148571323079237489u,  9075317899834447999u,          61187152222u },
+  { 12509763434355012654u,  2764331337978901575u,          94491973969u },
+  { 11812768946960181977u,  1942890683708857202u,          81149854702u },
+  { 14170358803552564832u,   165089169728028447u,         238105324315u },
+  { 18179989524780635952u, 15193620741871233073u,          27008949501u },
+  { 17091718978514754901u, 14995000835194145926u,         253823647830u },
+  {  7394768384359232459u,  1788823614552255558u,          86812880624u },
+  {  6778628272692852803u,  8384901184618498845u,         240096972322u },
+  { 18193335045875234320u,   405511217862281310u,          34454546404u },
+  {  1378519212560967521u,  3111530463755196557u,         228021982807u },
+  {  4677732610631043584u,  7893558450035460812u,          87168676404u },
+  { 17296098591070486528u,   156573858237402216u,          52427910661u },
+  {  7343735382392963072u, 15915324019419451223u,           5008487885u },
+  { 14525996728454217728u, 16293363012778802804u,         205862771443u },
+  {  9691359370008330240u, 14342105318291351412u,         243883264978u },
+  {  3044433348102455296u,  3788398842525387052u,         210777487087u },
+  {  9223372036854775808u, 14118764407048307670u,         239205369512u },
+  {                    0u,  2705021334614720768u,         168765379752u },
+  {                    0u,  7017988973805568000u,         168146639500u },
+  {                    0u, 10956732053634154496u,         140380445944u },
+  {                    0u, 14657517938546835456u,         248593965634u },
+  {                    0u, 11268868284797157376u,          66794585639u },
+  {                    0u, 14600669991935148032u,          39610886573u },
+  {                    0u,  4611686018427387904u,         173791503906u },
+  {                    0u,                    0u,          34250000000u },
+  {                    0u,                    0u,         128000000000u },
+  {  8201586317771250746u,           1424047269u,                    0u },
+  {  3278889188817135834u,  1424047269444608885u,                    0u },
+  {  1710725240251040430u,  3001188830946823627u,             77197757u },
+  {  1850175733663425006u,  9732296932705387049u,         189162694772u },
+  {  9147599666163914249u, 16337535782679529459u,         116527588873u },
+  { 10221885933644344166u,  7969742269895046547u,           9885659589u },
+  { 14901479793736678101u,  2923592083903829642u,         197432040594u },
+  {  5181831442059703136u,  8144196241160608534u,         146158488244u },
+  {  6396246577759793483u, 16431078457793424253u,         180441497762u },
+  { 14167229556464870447u,   202362949592775653u,         162890730548u },
+  {  2969982933326311854u,  8835125248522947981u,          52010970117u },
+  {  7892677766222018881u,  7959873808777345113u,           5478953099u },
+  {   798698968922663621u, 14929747122315126151u,         139431505623u },
+  { 15926812109043458972u,  4310328817360515349u,         215809343213u },
+  {  8663842590352697437u,  7294899422760201126u,         237233663393u },
+  { 17093523026636671168u,  2047461597291187207u,         161395457290u },
+  {   839764004742743203u, 10942374468813517900u,          10110993115u },
+  { 16894643909298232323u, 10364795403063433969u,         219593187308u },
+  {  9066702926218949317u, 12330859528790939137u,         236561876684u },
+  {  9119392417260546810u,  8973160144879916806u,         204668457234u },
+  {  9723021096578315109u,  2895354388547509877u,          18486435986u },
+  { 14787464248751217597u, 16766844772497556429u,         146156957475u },
+  {  3733434565920249133u,  7442407174620948827u,          35908932476u },
+  {  6643788868836820841u,  6683013428676659077u,         124403453701u },
+  {  4729646697422664063u, 16713703375071907588u,           5362286883u },
+  {  4090144564201555829u,  8791044883080637861u,          35906051675u },
+  {  2109480737093400002u,   602844107089214413u,          91476563498u },
+  { 16577155033369419739u,  9754832281172880875u,          42032680244u },
+  {   745377248603805917u, 10587846778003503903u,          52528810517u },
+  { 11305561465807999667u, 17206244172922947013u,          21573968323u },
+  {  2211245518782892177u, 11620628420699303875u,         195932752365u },
+  { 14170095199249735666u, 17864732368219338611u,         237629955528u },
+  { 17849973668116118927u,  4146383014621345887u,         200968449082u },
+  {  9020960204585720001u, 11445705075042688243u,          58224775873u },
+  { 10807134002871850916u,  7369147888966546592u,         193620472915u },
+  {  3925122626254791201u,  9762476865090597796u,          83399482307u },
+  { 17208463291312718997u,  5507001428194242827u,         195529224931u },
+  {  5145077219589447653u, 11371471148365328344u,         227298535145u },
+  { 17602397765035489468u,  3148788104946538618u,         233616448686u },
+  { 16422643262490753377u,  3762722308424507574u,         174170696145u },
+  {  2902509461400906224u,  1156171244825745915u,         209203977585u },
+  {  3422418805967265206u, 14208921674868257865u,         113062676168u },
+  {  4228874576277237392u,  7903080886897905503u,         200770267187u },
+  {  2553488530807495751u,  6367240794154270982u,          51428426873u },
+  { 11546099176912486413u,  1623672396662369850u,         121345168815u },
+  { 10460791037534167991u, 18323231215381674394u,         175088019456u },
+  {  8127117908566000904u,  9842279843006544554u,            993304354u },
+  { 11541304458088287306u,  7376839231308610600u,          34533551059u },
+  {  6249718665174839700u,   609751749293657672u,         211399899256u },
+  { 13102508413386290995u, 10386457966860989799u,         120033054708u },
+  {  6274675218640661911u, 11160336020836149780u,         244563051014u },
+  {  3404497118599817167u, 17947559933847409193u,           6605003027u },
+  { 11258566093988562335u, 10229787001712704590u,          19972939173u },
+  { 16762592482501635397u, 10441677090043619866u,         165554557864u },
+  {  5550125446725071998u,  4996681336392922375u,         168566044449u },
+  {  6370033225258510318u,   124497102381021895u,          33270870638u },
+  {  1503521728674735398u,  8180812057779384577u,         110006749001u },
+  {  4250415082606384364u,  5294232873532946716u,          73443482710u },
+  {  6020091901030562974u,  2885620189169448039u,          86287000939u },
+  { 16288222967151527138u, 16662526875008170507u,         107156429783u },
+  {  6377016228656203782u, 15663095032402672480u,         215903277391u },
+  {  8378856515587563750u,  1824281504410546614u,          79849098083u },
+  { 15812881490200838483u,  9506565509584809953u,          99098894498u },
+  {  4548570371183413652u, 16941136942345070055u,         162515351948u },
+  { 16731431495283420383u, 15924115693705937725u,         140918380873u },
+  { 14737727629551135532u,  9247807690406628462u,          73863248041u },
+  { 12413722258104293893u,  7993916633864834871u,         169501324659u },
+  {   800899742400762438u,  1018504409177639408u,         115433351089u },
+  {   603197008376033550u, 12097800686634130718u,         177055213234u },
+  {  6380777281587743935u,  6221488888422637551u,         178655823089u },
+  { 10001440249018225388u,  8229322865256080421u,         241337267588u },
+  {  5505914461980436708u,  7927745108183101786u,         132446112486u },
+  {  1105464290051876864u,  8488683721235326653u,         230429763923u },
+  {  4500443576769970176u, 11165516518170922283u,          83460172466u },
+  {  2843045143185981440u,  5463648141113596927u,         178605283863u },
+  {   660949699682893824u,  3958440403860778042u,          23296184959u },
+  {   276549164618219520u,  5091534813990256011u,         127214587484u },
+  {  4683743612465315840u,  6100166970623291280u,          92276012655u },
+  {                    0u,  1913011027739012426u,         111330690714u },
+  {                    0u, 11310957650604221440u,         154103704535u },
+  {                    0u, 16303817257009020928u,         215613168242u },
+  {                    0u,  9090406322154766336u,         114883831704u },
+  {                    0u,  3003279315069566976u,         152492791914u },
+  {                    0u, 16582887146675765248u,         106162808097u },
+  {                    0u,  9691746398101307392u,          33898960113u },
+  {                    0u,                    0u,         241525390625u },
+  {                    0u,                    0u,          33000000000u },
+};
+
+// ^^^^^^^^^^ DERIVED FROM d2fixed_full_table.h ^^^^^^^^^^
+
+    // clang-format on
+
+} // namespace std
diff --git a/msvc-stl/stl/src/xcharconv_tables_double.cpp b/msvc-stl/stl/src/xcharconv_tables_double.cpp
new file mode 100644
index 0000000..a9f348a
--- /dev/null
+++ b/msvc-stl/stl/src/xcharconv_tables_double.cpp
@@ -0,0 +1,114 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <xcharconv_tables.h>
+
+namespace std {
+
+    const uint64_t _General_precision_tables_2<double>::_Special_X_table[195] = {0x3F18E757928E0C9Du,
+        0x3F4F212D77318FC5u, 0x3F8374BC6A7EF9DBu, 0x3FB851EB851EB851u, 0x3FEE666666666666u, 0x4022FFFFFFFFFFFFu,
+        0x3F1A1554FBDAD751u, 0x3F504D551D68C692u, 0x3F8460AA64C2F837u, 0x3FB978D4FDF3B645u, 0x3FEFD70A3D70A3D7u,
+        0x4023E66666666666u, 0x4058DFFFFFFFFFFFu, 0x3F1A3387ECC8EB96u, 0x3F506034F3FD933Eu, 0x3F84784230FCF80Du,
+        0x3FB99652BD3C3611u, 0x3FEFFBE76C8B4395u, 0x4023FD70A3D70A3Du, 0x4058FCCCCCCCCCCCu, 0x408F3BFFFFFFFFFFu,
+        0x3F1A368D04E0BA6Au, 0x3F506218230C7482u, 0x3F847A9E2BCF91A3u, 0x3FB99945B6C3760Bu, 0x3FEFFF972474538Eu,
+        0x4023FFBE76C8B439u, 0x4058FFAE147AE147u, 0x408F3F9999999999u, 0x40C387BFFFFFFFFFu, 0x3F1A36DA54164F19u,
+        0x3F506248748DF16Fu, 0x3F847ADA91B16DCBu, 0x3FB99991361DC93Eu, 0x3FEFFFF583A53B8Eu, 0x4023FFF972474538u,
+        0x4058FFF7CED91687u, 0x408F3FF5C28F5C28u, 0x40C387F999999999u, 0x40F869F7FFFFFFFFu, 0x3F1A36E20F35445Du,
+        0x3F50624D49814ABAu, 0x3F847AE09BE19D69u, 0x3FB99998C2DA04C3u, 0x3FEFFFFEF39085F4u, 0x4023FFFF583A53B8u,
+        0x4058FFFF2E48E8A7u, 0x408F3FFEF9DB22D0u, 0x40C387FF5C28F5C2u, 0x40F869FF33333333u, 0x412E847EFFFFFFFFu,
+        0x3F1A36E2D51EC34Bu, 0x3F50624DC5333A0Eu, 0x3F847AE136800892u, 0x3FB9999984200AB7u, 0x3FEFFFFFE5280D65u,
+        0x4023FFFFEF39085Fu, 0x4058FFFFEB074A77u, 0x408F3FFFE5C91D14u, 0x40C387FFEF9DB22Du, 0x40F869FFEB851EB8u,
+        0x412E847FE6666666u, 0x416312CFEFFFFFFFu, 0x3F1A36E2E8E94FFCu, 0x3F50624DD191D1FDu, 0x3F847AE145F6467Du,
+        0x3FB999999773D81Cu, 0x3FEFFFFFFD50CE23u, 0x4023FFFFFE5280D6u, 0x4058FFFFFDE7210Bu, 0x408F3FFFFD60E94Eu,
+        0x40C387FFFE5C91D1u, 0x40F869FFFDF3B645u, 0x412E847FFD70A3D7u, 0x416312CFFE666666u, 0x4197D783FDFFFFFFu,
+        0x3F1A36E2EAE3F7A7u, 0x3F50624DD2CE7AC8u, 0x3F847AE14782197Bu, 0x3FB9999999629FD9u, 0x3FEFFFFFFFBB47D0u,
+        0x4023FFFFFFD50CE2u, 0x4058FFFFFFCA501Au, 0x408F3FFFFFBCE421u, 0x40C387FFFFD60E94u, 0x40F869FFFFCB923Au,
+        0x412E847FFFBE76C8u, 0x416312CFFFD70A3Du, 0x4197D783FFCCCCCCu, 0x41CDCD64FFBFFFFFu, 0x3F1A36E2EB16A205u,
+        0x3F50624DD2EE2543u, 0x3F847AE147A9AE94u, 0x3FB9999999941A39u, 0x3FEFFFFFFFF920C8u, 0x4023FFFFFFFBB47Du,
+        0x4058FFFFFFFAA19Cu, 0x408F3FFFFFF94A03u, 0x40C387FFFFFBCE42u, 0x40F869FFFFFAC1D2u, 0x412E847FFFF97247u,
+        0x416312CFFFFBE76Cu, 0x4197D783FFFAE147u, 0x41CDCD64FFF99999u, 0x4202A05F1FFBFFFFu, 0x3F1A36E2EB1BB30Fu,
+        0x3F50624DD2F14FE9u, 0x3F847AE147ADA3E3u, 0x3FB9999999990CDCu, 0x3FEFFFFFFFFF5014u, 0x4023FFFFFFFF920Cu,
+        0x4058FFFFFFFF768Fu, 0x408F3FFFFFFF5433u, 0x40C387FFFFFF94A0u, 0x40F869FFFFFF79C8u, 0x412E847FFFFF583Au,
+        0x416312CFFFFF9724u, 0x4197D783FFFF7CEDu, 0x41CDCD64FFFF5C28u, 0x4202A05F1FFF9999u, 0x42374876E7FF7FFFu,
+        0x3F1A36E2EB1C34C3u, 0x3F50624DD2F1A0FAu, 0x3F847AE147AE0938u, 0x3FB9999999998B86u, 0x3FEFFFFFFFFFEE68u,
+        0x4023FFFFFFFFF501u, 0x4058FFFFFFFFF241u, 0x408F3FFFFFFFEED1u, 0x40C387FFFFFFF543u, 0x40F869FFFFFFF294u,
+        0x412E847FFFFFEF39u, 0x416312CFFFFFF583u, 0x4197D783FFFFF2E4u, 0x41CDCD64FFFFEF9Du, 0x4202A05F1FFFF5C2u,
+        0x42374876E7FFF333u, 0x426D1A94A1FFEFFFu, 0x3F1A36E2EB1C41BBu, 0x3F50624DD2F1A915u, 0x3F847AE147AE135Au,
+        0x3FB9999999999831u, 0x3FEFFFFFFFFFFE3Du, 0x4023FFFFFFFFFEE6u, 0x4058FFFFFFFFFEA0u, 0x408F3FFFFFFFFE48u,
+        0x40C387FFFFFFFEEDu, 0x40F869FFFFFFFEA8u, 0x412E847FFFFFFE52u, 0x416312CFFFFFFEF3u, 0x4197D783FFFFFEB0u,
+        0x41CDCD64FFFFFE5Cu, 0x4202A05F1FFFFEF9u, 0x42374876E7FFFEB8u, 0x426D1A94A1FFFE66u, 0x42A2309CE53FFEFFu,
+        0x3F1A36E2EB1C4307u, 0x3F50624DD2F1A9E4u, 0x3F847AE147AE145Eu, 0x3FB9999999999975u, 0x3FEFFFFFFFFFFFD2u,
+        0x4023FFFFFFFFFFE3u, 0x4058FFFFFFFFFFDCu, 0x408F3FFFFFFFFFD4u, 0x40C387FFFFFFFFE4u, 0x40F869FFFFFFFFDDu,
+        0x412E847FFFFFFFD5u, 0x416312CFFFFFFFE5u, 0x4197D783FFFFFFDEu, 0x41CDCD64FFFFFFD6u, 0x4202A05F1FFFFFE5u,
+        0x42374876E7FFFFDFu, 0x426D1A94A1FFFFD7u, 0x42A2309CE53FFFE6u, 0x42D6BCC41E8FFFDFu, 0x3F1A36E2EB1C4328u,
+        0x3F50624DD2F1A9F9u, 0x3F847AE147AE1477u, 0x3FB9999999999995u, 0x3FEFFFFFFFFFFFFBu, 0x4023FFFFFFFFFFFDu,
+        0x4058FFFFFFFFFFFCu, 0x408F3FFFFFFFFFFBu, 0x40C387FFFFFFFFFDu, 0x40F869FFFFFFFFFCu, 0x412E847FFFFFFFFBu,
+        0x416312CFFFFFFFFDu, 0x4197D783FFFFFFFCu, 0x41CDCD64FFFFFFFBu, 0x4202A05F1FFFFFFDu, 0x42374876E7FFFFFCu,
+        0x426D1A94A1FFFFFBu, 0x42A2309CE53FFFFDu, 0x42D6BCC41E8FFFFCu, 0x430C6BF52633FFFBu};
+
+    const uint64_t _General_precision_tables_2<double>::_Ordinary_X_table[314] = {0x3F1A36E2EB1C432Cu,
+        0x3F50624DD2F1A9FBu, 0x3F847AE147AE147Au, 0x3FB9999999999999u, 0x3FEFFFFFFFFFFFFFu, 0x4023FFFFFFFFFFFFu,
+        0x4058FFFFFFFFFFFFu, 0x408F3FFFFFFFFFFFu, 0x40C387FFFFFFFFFFu, 0x40F869FFFFFFFFFFu, 0x412E847FFFFFFFFFu,
+        0x416312CFFFFFFFFFu, 0x4197D783FFFFFFFFu, 0x41CDCD64FFFFFFFFu, 0x4202A05F1FFFFFFFu, 0x42374876E7FFFFFFu,
+        0x426D1A94A1FFFFFFu, 0x42A2309CE53FFFFFu, 0x42D6BCC41E8FFFFFu, 0x430C6BF52633FFFFu, 0x4341C37937E07FFFu,
+        0x4376345785D89FFFu, 0x43ABC16D674EC7FFu, 0x43E158E460913CFFu, 0x4415AF1D78B58C3Fu, 0x444B1AE4D6E2EF4Fu,
+        0x4480F0CF064DD591u, 0x44B52D02C7E14AF6u, 0x44EA784379D99DB4u, 0x45208B2A2C280290u, 0x4554ADF4B7320334u,
+        0x4589D971E4FE8401u, 0x45C027E72F1F1281u, 0x45F431E0FAE6D721u, 0x46293E5939A08CE9u, 0x465F8DEF8808B024u,
+        0x4693B8B5B5056E16u, 0x46C8A6E32246C99Cu, 0x46FED09BEAD87C03u, 0x4733426172C74D82u, 0x476812F9CF7920E2u,
+        0x479E17B84357691Bu, 0x47D2CED32A16A1B1u, 0x48078287F49C4A1Du, 0x483D6329F1C35CA4u, 0x48725DFA371A19E6u,
+        0x48A6F578C4E0A060u, 0x48DCB2D6F618C878u, 0x4911EFC659CF7D4Bu, 0x49466BB7F0435C9Eu, 0x497C06A5EC5433C6u,
+        0x49B18427B3B4A05Bu, 0x49E5E531A0A1C872u, 0x4A1B5E7E08CA3A8Fu, 0x4A511B0EC57E6499u, 0x4A8561D276DDFDC0u,
+        0x4ABABA4714957D30u, 0x4AF0B46C6CDD6E3Eu, 0x4B24E1878814C9CDu, 0x4B5A19E96A19FC40u, 0x4B905031E2503DA8u,
+        0x4BC4643E5AE44D12u, 0x4BF97D4DF19D6057u, 0x4C2FDCA16E04B86Du, 0x4C63E9E4E4C2F344u, 0x4C98E45E1DF3B015u,
+        0x4CCF1D75A5709C1Au, 0x4D03726987666190u, 0x4D384F03E93FF9F4u, 0x4D6E62C4E38FF872u, 0x4DA2FDBB0E39FB47u,
+        0x4DD7BD29D1C87A19u, 0x4E0DAC74463A989Fu, 0x4E428BC8ABE49F63u, 0x4E772EBAD6DDC73Cu, 0x4EACFA698C95390Bu,
+        0x4EE21C81F7DD43A7u, 0x4F16A3A275D49491u, 0x4F4C4C8B1349B9B5u, 0x4F81AFD6EC0E1411u, 0x4FB61BCCA7119915u,
+        0x4FEBA2BFD0D5FF5Bu, 0x502145B7E285BF98u, 0x50559725DB272F7Fu, 0x508AFCEF51F0FB5Eu, 0x50C0DE1593369D1Bu,
+        0x50F5159AF8044462u, 0x512A5B01B605557Au, 0x516078E111C3556Cu, 0x5194971956342AC7u, 0x51C9BCDFABC13579u,
+        0x5200160BCB58C16Cu, 0x52341B8EBE2EF1C7u, 0x526922726DBAAE39u, 0x529F6B0F092959C7u, 0x52D3A2E965B9D81Cu,
+        0x53088BA3BF284E23u, 0x533EAE8CAEF261ACu, 0x53732D17ED577D0Bu, 0x53A7F85DE8AD5C4Eu, 0x53DDF67562D8B362u,
+        0x5412BA095DC7701Du, 0x5447688BB5394C25u, 0x547D42AEA2879F2Eu, 0x54B249AD2594C37Cu, 0x54E6DC186EF9F45Cu,
+        0x551C931E8AB87173u, 0x5551DBF316B346E7u, 0x558652EFDC6018A1u, 0x55BBE7ABD3781ECAu, 0x55F170CB642B133Eu,
+        0x5625CCFE3D35D80Eu, 0x565B403DCC834E11u, 0x569108269FD210CBu, 0x56C54A3047C694FDu, 0x56FA9CBC59B83A3Du,
+        0x5730A1F5B8132466u, 0x5764CA732617ED7Fu, 0x5799FD0FEF9DE8DFu, 0x57D03E29F5C2B18Bu, 0x58044DB473335DEEu,
+        0x583961219000356Au, 0x586FB969F40042C5u, 0x58A3D3E2388029BBu, 0x58D8C8DAC6A0342Au, 0x590EFB1178484134u,
+        0x59435CEAEB2D28C0u, 0x59783425A5F872F1u, 0x59AE412F0F768FADu, 0x59E2E8BD69AA19CCu, 0x5A17A2ECC414A03Fu,
+        0x5A4D8BA7F519C84Fu, 0x5A827748F9301D31u, 0x5AB7151B377C247Eu, 0x5AECDA62055B2D9Du, 0x5B22087D4358FC82u,
+        0x5B568A9C942F3BA3u, 0x5B8C2D43B93B0A8Bu, 0x5BC19C4A53C4E697u, 0x5BF6035CE8B6203Du, 0x5C2B843422E3A84Cu,
+        0x5C6132A095CE492Fu, 0x5C957F48BB41DB7Bu, 0x5CCADF1AEA12525Au, 0x5D00CB70D24B7378u, 0x5D34FE4D06DE5056u,
+        0x5D6A3DE04895E46Cu, 0x5DA066AC2D5DAEC3u, 0x5DD4805738B51A74u, 0x5E09A06D06E26112u, 0x5E400444244D7CABu,
+        0x5E7405552D60DBD6u, 0x5EA906AA78B912CBu, 0x5EDF485516E7577Eu, 0x5F138D352E5096AFu, 0x5F48708279E4BC5Au,
+        0x5F7E8CA3185DEB71u, 0x5FB317E5EF3AB327u, 0x5FE7DDDF6B095FF0u, 0x601DD55745CBB7ECu, 0x6052A5568B9F52F4u,
+        0x60874EAC2E8727B1u, 0x60BD22573A28F19Du, 0x60F2357684599702u, 0x6126C2D4256FFCC2u, 0x615C73892ECBFBF3u,
+        0x6191C835BD3F7D78u, 0x61C63A432C8F5CD6u, 0x61FBC8D3F7B3340Bu, 0x62315D847AD00087u, 0x6265B4E5998400A9u,
+        0x629B221EFFE500D3u, 0x62D0F5535FEF2084u, 0x630532A837EAE8A5u, 0x633A7F5245E5A2CEu, 0x63708F936BAF85C1u,
+        0x63A4B378469B6731u, 0x63D9E056584240FDu, 0x64102C35F729689Eu, 0x6444374374F3C2C6u, 0x647945145230B377u,
+        0x64AF965966BCE055u, 0x64E3BDF7E0360C35u, 0x6518AD75D8438F43u, 0x654ED8D34E547313u, 0x6583478410F4C7ECu,
+        0x65B819651531F9E7u, 0x65EE1FBE5A7E7861u, 0x6622D3D6F88F0B3Cu, 0x665788CCB6B2CE0Cu, 0x668D6AFFE45F818Fu,
+        0x66C262DFEEBBB0F9u, 0x66F6FB97EA6A9D37u, 0x672CBA7DE5054485u, 0x6761F48EAF234AD3u, 0x679671B25AEC1D88u,
+        0x67CC0E1EF1A724EAu, 0x680188D357087712u, 0x6835EB082CCA94D7u, 0x686B65CA37FD3A0Du, 0x68A11F9E62FE4448u,
+        0x68D56785FBBDD55Au, 0x690AC1677AAD4AB0u, 0x6940B8E0ACAC4EAEu, 0x6974E718D7D7625Au, 0x69AA20DF0DCD3AF0u,
+        0x69E0548B68A044D6u, 0x6A1469AE42C8560Cu, 0x6A498419D37A6B8Fu, 0x6A7FE52048590672u, 0x6AB3EF342D37A407u,
+        0x6AE8EB0138858D09u, 0x6B1F25C186A6F04Cu, 0x6B537798F428562Fu, 0x6B88557F31326BBBu, 0x6BBE6ADEFD7F06AAu,
+        0x6BF302CB5E6F642Au, 0x6C27C37E360B3D35u, 0x6C5DB45DC38E0C82u, 0x6C9290BA9A38C7D1u, 0x6CC734E940C6F9C5u,
+        0x6CFD022390F8B837u, 0x6D3221563A9B7322u, 0x6D66A9ABC9424FEBu, 0x6D9C5416BB92E3E6u, 0x6DD1B48E353BCE6Fu,
+        0x6E0621B1C28AC20Bu, 0x6E3BAA1E332D728Eu, 0x6E714A52DFFC6799u, 0x6EA59CE797FB817Fu, 0x6EDB04217DFA61DFu,
+        0x6F10E294EEBC7D2Bu, 0x6F451B3A2A6B9C76u, 0x6F7A6208B5068394u, 0x6FB07D457124123Cu, 0x6FE49C96CD6D16CBu,
+        0x7019C3BC80C85C7Eu, 0x70501A55D07D39CFu, 0x708420EB449C8842u, 0x70B9292615C3AA53u, 0x70EF736F9B3494E8u,
+        0x7123A825C100DD11u, 0x7158922F31411455u, 0x718EB6BAFD91596Bu, 0x71C33234DE7AD7E2u, 0x71F7FEC216198DDBu,
+        0x722DFE729B9FF152u, 0x7262BF07A143F6D3u, 0x72976EC98994F488u, 0x72CD4A7BEBFA31AAu, 0x73024E8D737C5F0Au,
+        0x7336E230D05B76CDu, 0x736C9ABD04725480u, 0x73A1E0B622C774D0u, 0x73D658E3AB795204u, 0x740BEF1C9657A685u,
+        0x74417571DDF6C813u, 0x7475D2CE55747A18u, 0x74AB4781EAD1989Eu, 0x74E10CB132C2FF63u, 0x75154FDD7F73BF3Bu,
+        0x754AA3D4DF50AF0Au, 0x7580A6650B926D66u, 0x75B4CFFE4E7708C0u, 0x75EA03FDE214CAF0u, 0x7620427EAD4CFED6u,
+        0x7654531E58A03E8Bu, 0x768967E5EEC84E2Eu, 0x76BFC1DF6A7A61BAu, 0x76F3D92BA28C7D14u, 0x7728CF768B2F9C59u,
+        0x775F03542DFB8370u, 0x779362149CBD3226u, 0x77C83A99C3EC7EAFu, 0x77FE494034E79E5Bu, 0x7832EDC82110C2F9u,
+        0x7867A93A2954F3B7u, 0x789D9388B3AA30A5u, 0x78D27C35704A5E67u, 0x79071B42CC5CF601u, 0x793CE2137F743381u,
+        0x79720D4C2FA8A030u, 0x79A6909F3B92C83Du, 0x79DC34C70A777A4Cu, 0x7A11A0FC668AAC6Fu, 0x7A46093B802D578Bu,
+        0x7A7B8B8A6038AD6Eu, 0x7AB137367C236C65u, 0x7AE585041B2C477Eu, 0x7B1AE64521F7595Eu, 0x7B50CFEB353A97DAu,
+        0x7B8503E602893DD1u, 0x7BBA44DF832B8D45u, 0x7BF06B0BB1FB384Bu, 0x7C2485CE9E7A065Eu, 0x7C59A742461887F6u,
+        0x7C9008896BCF54F9u, 0x7CC40AABC6C32A38u, 0x7CF90D56B873F4C6u, 0x7D2F50AC6690F1F8u, 0x7D63926BC01A973Bu,
+        0x7D987706B0213D09u, 0x7DCE94C85C298C4Cu, 0x7E031CFD3999F7AFu, 0x7E37E43C8800759Bu, 0x7E6DDD4BAA009302u,
+        0x7EA2AA4F4A405BE1u, 0x7ED754E31CD072D9u, 0x7F0D2A1BE4048F90u, 0x7F423A516E82D9BAu, 0x7F76C8E5CA239028u,
+        0x7FAC7B1F3CAC7433u, 0x7FE1CCF385EBC89Fu, 0x7FEFFFFFFFFFFFFFu};
+
+} // namespace std
diff --git a/msvc-stl/stl/src/xcharconv_tables_float.cpp b/msvc-stl/stl/src/xcharconv_tables_float.cpp
new file mode 100644
index 0000000..c68de40
--- /dev/null
+++ b/msvc-stl/stl/src/xcharconv_tables_float.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <xcharconv_tables.h>
+
+namespace std {
+
+    const uint32_t _General_precision_tables_2<float>::_Special_X_table[63] = {0x38C73ABCu, 0x3A79096Bu, 0x3C1BA5E3u,
+        0x3DC28F5Cu, 0x3F733333u, 0x4117FFFFu, 0x38D0AAA7u, 0x3A826AA8u, 0x3C230553u, 0x3DCBC6A7u, 0x3F7EB851u,
+        0x411F3333u, 0x42C6FFFFu, 0x38D19C3Fu, 0x3A8301A7u, 0x3C23C211u, 0x3DCCB295u, 0x3F7FDF3Bu, 0x411FEB85u,
+        0x42C7E666u, 0x4479DFFFu, 0x38D1B468u, 0x3A8310C1u, 0x3C23D4F1u, 0x3DCCCA2Du, 0x3F7FFCB9u, 0x411FFDF3u,
+        0x42C7FD70u, 0x4479FCCCu, 0x461C3DFFu, 0x38D1B6D2u, 0x3A831243u, 0x3C23D6D4u, 0x3DCCCC89u, 0x3F7FFFACu,
+        0x411FFFCBu, 0x42C7FFBEu, 0x4479FFAEu, 0x461C3FCCu, 0x47C34FBFu, 0x38D1B710u, 0x3A83126Au, 0x3C23D704u,
+        0x3DCCCCC6u, 0x3F7FFFF7u, 0x411FFFFAu, 0x42C7FFF9u, 0x4479FFF7u, 0x461C3FFAu, 0x47C34FF9u, 0x497423F7u,
+        0x38D1B716u, 0x3A83126Eu, 0x3C23D709u, 0x3DCCCCCCu, 0x3F7FFFFFu, 0x411FFFFFu, 0x42C7FFFFu, 0x4479FFFFu,
+        0x461C3FFFu, 0x47C34FFFu, 0x497423FFu, 0x4B18967Fu};
+
+    const uint32_t _General_precision_tables_2<float>::_Ordinary_X_table[44] = {0x38D1B717u, 0x3A83126Eu, 0x3C23D70Au,
+        0x3DCCCCCCu, 0x3F7FFFFFu, 0x411FFFFFu, 0x42C7FFFFu, 0x4479FFFFu, 0x461C3FFFu, 0x47C34FFFu, 0x497423FFu,
+        0x4B18967Fu, 0x4CBEBC1Fu, 0x4E6E6B27u, 0x501502F8u, 0x51BA43B7u, 0x5368D4A5u, 0x551184E7u, 0x56B5E620u,
+        0x58635FA9u, 0x5A0E1BC9u, 0x5BB1A2BCu, 0x5D5E0B6Bu, 0x5F0AC723u, 0x60AD78EBu, 0x6258D726u, 0x64078678u,
+        0x65A96816u, 0x6753C21Bu, 0x69045951u, 0x6AA56FA5u, 0x6C4ECB8Fu, 0x6E013F39u, 0x6FA18F07u, 0x7149F2C9u,
+        0x72FC6F7Cu, 0x749DC5ADu, 0x76453719u, 0x77F684DFu, 0x799A130Bu, 0x7B4097CEu, 0x7CF0BDC2u, 0x7E967699u,
+        0x7F7FFFFFu};
+
+} // namespace std
diff --git a/msvc-stl/stl/src/xcosh.cpp b/msvc-stl/stl/src/xcosh.cpp
new file mode 100644
index 0000000..2eb46bf
--- /dev/null
+++ b/msvc-stl/stl/src/xcosh.cpp
@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cerrno>
+#include <cmath>
+#include <ymath.h>
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Cosh(double x, double y) noexcept { // compute y * cosh(x), |y| <= 1
+    switch (_STD fpclassify(x)) { // test for special codes
+    case FP_NAN:
+    case FP_INFINITE:
+        return x;
+    case FP_ZERO:
+        return y;
+    default: // finite
+        if (y == 0.0) {
+            return y;
+        }
+
+        if (x < 0.0) {
+            x = -x;
+        }
+
+        constexpr double _Xbig = ((48 + _DOFF) + 2) * 0.347;
+        if (x < _Xbig) { // worth adding in exp(-x)
+            _Exp(&x, 1.0, -1);
+            return y * (x + 0.25 / x);
+        }
+        switch (_Exp(&x, y, -1)) {
+        case FP_ZERO: // report underflow
+        case FP_INFINITE: // report overflow
+            errno = ERANGE;
+            break;
+        }
+        return x;
+    }
+}
+
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _LCosh(long double x, long double y) noexcept {
+    return _Cosh(static_cast<double>(x), static_cast<double>(y));
+}
+
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _FCosh(float x, float y) noexcept { // compute y * cosh(x), |y| <= 1
+    switch (_STD fpclassify(x)) { // test for special codes
+    case FP_NAN:
+    case FP_INFINITE:
+        return x;
+    case FP_ZERO:
+        return y;
+    default: // finite
+        if (y == 0.0) {
+            return y;
+        }
+
+        if (x < 0.0) {
+            x = -x;
+        }
+
+        constexpr float _FXbig = ((16 + _FOFF) + 2) * 0.347f;
+        if (x < _FXbig) { // worth adding in exp(-x)
+            _FExp(&x, 1.0F, -1);
+            return y * (x + 0.25F / x);
+        }
+        switch (_FExp(&x, y, -1)) {
+        case FP_ZERO: // report underflow
+        case FP_INFINITE: // report overflow
+            errno = ERANGE;
+            break;
+        }
+        return x;
+    }
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xdateord.cpp b/msvc-stl/stl/src/xdateord.cpp
new file mode 100644
index 0000000..312d96d
--- /dev/null
+++ b/msvc-stl/stl/src/xdateord.cpp
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// look up date ordering
+
+#include <locale>
+
+#include <Windows.h>
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Getdateorder() noexcept { // return date order for current locale
+    const wchar_t* const locale_name = ___lc_locale_name_func()[LC_TIME];
+    if (locale_name == nullptr) { // Indicates "C" locale; GetLocaleInfoEx would see this as LOCALE_NAME_USER_DEFAULT
+        return std::time_base::mdy;
+    }
+
+    wchar_t buf[2] = {0};
+    GetLocaleInfoEx(locale_name, LOCALE_ILDATE, buf, static_cast<int>(std::size(buf)));
+
+    switch (buf[0]) {
+    case L'0':
+        return std::time_base::mdy;
+    case L'1':
+        return std::time_base::dmy;
+    case L'2':
+        return std::time_base::ymd;
+    default:
+        return std::time_base::no_order;
+    }
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xdtest.cpp b/msvc-stl/stl/src/xdtest.cpp
new file mode 100644
index 0000000..7f4c190
--- /dev/null
+++ b/msvc-stl/stl/src/xdtest.cpp
@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cmath>
+
+_EXTERN_C_UNLESS_PURE
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Dtest(double* px) noexcept {
+    return static_cast<short>(_STD fpclassify(*px));
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _LDtest(long double* px) noexcept {
+    return _Dtest(reinterpret_cast<double*>(px));
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _FDtest(float* px) noexcept {
+    return static_cast<short>(_STD fpclassify(*px));
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xexp.cpp b/msvc-stl/stl/src/xexp.cpp
new file mode 100644
index 0000000..6a4bca0
--- /dev/null
+++ b/msvc-stl/stl/src/xexp.cpp
@@ -0,0 +1,345 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cmath>
+#include <limits>
+
+namespace {
+    constexpr int _D0 = 3; // little-endian
+    constexpr int _D1 = 2;
+    constexpr int _D2 = 1;
+    constexpr int _D3 = 0;
+
+    union _Dval { // pun floating type as integer array
+        unsigned short _Sh[4];
+        double _Val;
+    };
+    static_assert(sizeof(_Dval::_Sh) == sizeof(_Dval::_Val), "_Dval members should be the same size");
+
+    short _Dnorm(_Dval* ps) noexcept { // normalize double fraction
+        short xchar         = 1;
+        unsigned short sign = static_cast<unsigned short>(ps->_Sh[_D0] & _DSIGN);
+
+        if ((ps->_Sh[_D0] &= _DFRAC) != 0 || ps->_Sh[_D1] || ps->_Sh[_D2] || ps->_Sh[_D3]) { // nonzero, scale
+            for (; ps->_Sh[_D0] == 0; xchar -= 16) { // shift left by 16
+                ps->_Sh[_D0] = ps->_Sh[_D1];
+                ps->_Sh[_D1] = ps->_Sh[_D2];
+                ps->_Sh[_D2] = ps->_Sh[_D3];
+                ps->_Sh[_D3] = 0;
+            }
+            for (; ps->_Sh[_D0] < 1 << _DOFF; --xchar) { // shift left by 1
+                ps->_Sh[_D0] = static_cast<unsigned short>(ps->_Sh[_D0] << 1 | ps->_Sh[_D1] >> 15);
+                ps->_Sh[_D1] = static_cast<unsigned short>(ps->_Sh[_D1] << 1 | ps->_Sh[_D2] >> 15);
+                ps->_Sh[_D2] = static_cast<unsigned short>(ps->_Sh[_D2] << 1 | ps->_Sh[_D3] >> 15);
+                ps->_Sh[_D3] <<= 1;
+            }
+            for (; 1 << (_DOFF + 1) <= ps->_Sh[_D0]; ++xchar) { // shift right by 1
+                ps->_Sh[_D3] = static_cast<unsigned short>(ps->_Sh[_D3] >> 1 | ps->_Sh[_D2] << 15);
+                ps->_Sh[_D2] = static_cast<unsigned short>(ps->_Sh[_D2] >> 1 | ps->_Sh[_D1] << 15);
+                ps->_Sh[_D1] = static_cast<unsigned short>(ps->_Sh[_D1] >> 1 | ps->_Sh[_D0] << 15);
+                ps->_Sh[_D0] >>= 1;
+            }
+            ps->_Sh[_D0] &= _DFRAC;
+        }
+        ps->_Sh[_D0] |= sign;
+        return xchar;
+    }
+
+    short _Dscale(double* px, long lexp) noexcept { // scale *px by 2^xexp with checking
+        const auto ps = reinterpret_cast<_Dval*>(px);
+        short xchar   = static_cast<short>((ps->_Sh[_D0] & _DMASK) >> _DOFF);
+
+        if (xchar == _DMAX) {
+            return (ps->_Sh[_D0] & _DFRAC) != 0 || ps->_Sh[_D1] != 0 || ps->_Sh[_D2] != 0 || ps->_Sh[_D3] != 0
+                     ? FP_NAN
+                     : FP_INFINITE;
+        } else if (xchar == 0 && 0 < (xchar = _Dnorm(ps))) {
+            return FP_ZERO;
+        }
+
+        if (0 < lexp && _DMAX - xchar <= lexp) { // overflow, return +/-INF
+            constexpr double inf = _STD numeric_limits<double>::infinity();
+
+            *px = ps->_Sh[_D0] & _DSIGN ? -inf : inf;
+            return FP_INFINITE;
+        } else if (-xchar < lexp) { // finite result, repack
+            ps->_Sh[_D0] = static_cast<unsigned short>(ps->_Sh[_D0] & ~_DMASK | (lexp + xchar) << _DOFF);
+            return FP_NORMAL;
+        } else { // denormalized, scale
+            unsigned short sign = static_cast<unsigned short>(ps->_Sh[_D0] & _DSIGN);
+
+            ps->_Sh[_D0] = static_cast<unsigned short>(1 << _DOFF | ps->_Sh[_D0] & _DFRAC);
+            lexp += xchar - 1;
+            if (lexp < -(48 + 1 + _DOFF) || 0 <= lexp) { // certain underflow, return +/-0
+                ps->_Sh[_D0] = sign;
+                ps->_Sh[_D1] = 0;
+                ps->_Sh[_D2] = 0;
+                ps->_Sh[_D3] = 0;
+                return FP_ZERO;
+            } else { // nonzero, align fraction
+                short xexp         = static_cast<short>(lexp);
+                unsigned short psx = 0;
+
+                for (; xexp <= -16; xexp += 16) { // scale by words
+                    psx          = ps->_Sh[_D3] | (psx != 0 ? 1 : 0);
+                    ps->_Sh[_D3] = ps->_Sh[_D2];
+                    ps->_Sh[_D2] = ps->_Sh[_D1];
+                    ps->_Sh[_D1] = ps->_Sh[_D0];
+                    ps->_Sh[_D0] = 0;
+                }
+                if (xexp != 0) { // scale by bits
+                    xexp         = -xexp;
+                    psx          = (ps->_Sh[_D3] << (16 - xexp)) | (psx != 0 ? 1 : 0);
+                    ps->_Sh[_D3] = static_cast<unsigned short>(ps->_Sh[_D3] >> xexp | ps->_Sh[_D2] << (16 - xexp));
+                    ps->_Sh[_D2] = static_cast<unsigned short>(ps->_Sh[_D2] >> xexp | ps->_Sh[_D1] << (16 - xexp));
+                    ps->_Sh[_D1] = static_cast<unsigned short>(ps->_Sh[_D1] >> xexp | ps->_Sh[_D0] << (16 - xexp));
+                    ps->_Sh[_D0] >>= xexp;
+                }
+
+                ps->_Sh[_D0] |= sign;
+                if ((0x8000 < psx || 0x8000 == psx && (ps->_Sh[_D3] & 0x0001) != 0) && (++ps->_Sh[_D3] & 0xffff) == 0
+                    && (++ps->_Sh[_D2] & 0xffff) == 0 && (++ps->_Sh[_D1] & 0xffff) == 0) {
+                    ++ps->_Sh[_D0]; // round up
+                } else if (ps->_Sh[_D0] == sign && ps->_Sh[_D1] == 0 && ps->_Sh[_D2] == 0 && ps->_Sh[_D3] == 0) {
+                    return FP_ZERO;
+                }
+
+                return FP_NORMAL;
+            }
+        }
+    }
+
+    constexpr int _F0 = 1; // little-endian
+    constexpr int _F1 = 0;
+
+    union _Fval { // pun floating type as integer array
+        unsigned short _Sh[2];
+        float _Val;
+    };
+    static_assert(sizeof(_Fval::_Sh) == sizeof(_Fval::_Val), "_Fval members should be the same size");
+
+    short _FDnorm(_Fval* ps) noexcept { // normalize float fraction
+        short xchar         = 1;
+        unsigned short sign = static_cast<unsigned short>(ps->_Sh[_F0] & _FSIGN);
+
+        if ((ps->_Sh[_F0] &= _FFRAC) != 0 || ps->_Sh[_F1]) { // nonzero, scale
+            if (ps->_Sh[_F0] == 0) {
+                ps->_Sh[_F0] = ps->_Sh[_F1];
+                ps->_Sh[_F1] = 0;
+                xchar -= 16;
+            }
+
+            for (; ps->_Sh[_F0] < 1 << _FOFF; --xchar) { // shift left by 1
+                ps->_Sh[_F0] = static_cast<unsigned short>(ps->_Sh[_F0] << 1 | ps->_Sh[_F1] >> 15);
+                ps->_Sh[_F1] <<= 1;
+            }
+            for (; 1 << (_FOFF + 1) <= ps->_Sh[_F0]; ++xchar) { // shift right by 1
+                ps->_Sh[_F1] = static_cast<unsigned short>(ps->_Sh[_F1] >> 1 | ps->_Sh[_F0] << 15);
+                ps->_Sh[_F0] >>= 1;
+            }
+            ps->_Sh[_F0] &= _FFRAC;
+        }
+        ps->_Sh[_F0] |= sign;
+        return xchar;
+    }
+
+    short _FDscale(float* px, long lexp) noexcept { // scale *px by 2^xexp with checking
+        const auto ps = reinterpret_cast<_Fval*>(px);
+        short xchar   = static_cast<short>((ps->_Sh[_F0] & _FMASK) >> _FOFF);
+
+        if (xchar == _FMAX) {
+            return (ps->_Sh[_F0] & _FFRAC) != 0 || ps->_Sh[_F1] != 0 ? FP_NAN : FP_INFINITE;
+        } else if (xchar == 0 && 0 < (xchar = _FDnorm(ps))) {
+            return FP_ZERO;
+        }
+
+        if (0 < lexp && _FMAX - xchar <= lexp) { // overflow, return +/-INF
+            constexpr float inf = _STD numeric_limits<float>::infinity();
+
+            *px = ps->_Sh[_F0] & _FSIGN ? -inf : inf;
+            return FP_INFINITE;
+        } else if (-xchar < lexp) { // finite result, repack
+            ps->_Sh[_F0] = static_cast<unsigned short>(ps->_Sh[_F0] & ~_FMASK | (lexp + xchar) << _FOFF);
+            return FP_NORMAL;
+        } else { // denormalized, scale
+            unsigned short sign = static_cast<unsigned short>(ps->_Sh[_F0] & _FSIGN);
+
+            ps->_Sh[_F0] = static_cast<unsigned short>(1 << _FOFF | ps->_Sh[_F0] & _FFRAC);
+            lexp += xchar - 1;
+            if (lexp < -(16 + 1 + _FOFF) || 0 <= lexp) { // underflow, return +/-0
+                ps->_Sh[_F0] = sign;
+                ps->_Sh[_F1] = 0;
+                return FP_ZERO;
+            } else { // nonzero, align fraction
+                short xexp         = static_cast<short>(lexp);
+                unsigned short psx = 0;
+
+                if (xexp <= -16) { // scale by words
+                    psx          = ps->_Sh[_F1];
+                    ps->_Sh[_F1] = ps->_Sh[_F0];
+                    ps->_Sh[_F0] = 0;
+                    xexp += 16;
+                }
+
+                if (xexp != 0) { // scale by bits
+                    xexp         = -xexp;
+                    psx          = (ps->_Sh[_F1] << (16 - xexp)) | (psx != 0 ? 1 : 0);
+                    ps->_Sh[_F1] = static_cast<unsigned short>(ps->_Sh[_F1] >> xexp | ps->_Sh[_F0] << (16 - xexp));
+                    ps->_Sh[_F0] >>= xexp;
+                }
+
+                ps->_Sh[_F0] |= sign;
+                if ((0x8000 < psx || 0x8000 == psx && (ps->_Sh[_F1] & 0x0001) != 0) && (++ps->_Sh[_F1] & 0xffff) == 0) {
+                    ++ps->_Sh[_F0]; // round up
+                } else if (ps->_Sh[_F0] == sign && ps->_Sh[_F1] == 0) {
+                    return FP_ZERO;
+                }
+
+                return FP_NORMAL;
+            }
+        }
+    }
+
+// raise IEEE 754 exceptions
+#ifndef _M_CEE_PURE
+#pragma float_control(except, on, push)
+#endif
+
+    template <class T>
+    [[nodiscard]] T _Xfe_overflow(const T sign) noexcept {
+        static_assert(_STD is_floating_point_v<T>, "Expected is_floating_point_v<T>.");
+        constexpr T huge = _STD numeric_limits<T>::max();
+        return _STD copysign(huge, sign) * huge;
+    }
+
+    template <class T>
+    [[nodiscard]] T _Xfe_underflow(const T sign) noexcept {
+        static_assert(_STD is_floating_point_v<T>, "Expected is_floating_point_v<T>.");
+        constexpr T tiny = _STD numeric_limits<T>::min();
+        return _STD copysign(tiny, sign) * tiny;
+    }
+
+#ifndef _M_CEE_PURE
+#pragma float_control(pop)
+#endif
+
+} // unnamed namespace
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Exp(double* px, double y, short eoff) noexcept {
+    // compute y * e^(*px), (*px) finite, |y| not huge
+
+    // coefficients
+    static constexpr double p[] = {1.0, 420.30235984910635, 15132.70094680474802};
+    static constexpr double q[] = {30.01511290683317, 3362.72154416553028, 30265.40189360949691};
+    constexpr double c1         = 22713.0 / 32768.0;
+    constexpr double c2         = 1.4286068203094172321214581765680755e-6;
+    constexpr double hugexp     = static_cast<int>(_DMAX * 900L / 1000);
+    constexpr double invln2     = 1.4426950408889634073599246810018921;
+
+    if (y == 0.0) { // zero
+        *px = y;
+        return FP_ZERO;
+    } else if (*px < -hugexp) { // certain underflow
+        *px = _Xfe_underflow(y);
+        return FP_ZERO;
+    } else if (hugexp < *px) { // certain overflow
+        *px = _Xfe_overflow(y);
+        return FP_INFINITE;
+    } else { // xexp won't overflow
+        double g   = *px * invln2;
+        short xexp = static_cast<short>(g + (g < 0.0 ? -0.5 : +0.5));
+
+        g = xexp;
+        g = (*px - g * c1) - g * c2;
+
+        constexpr double eps = 0x1p-54;
+        if (-eps < g && g < eps) {
+            *px = y;
+        } else { // g * g worth computing
+            const double z = g * g;
+            const double w = (q[0] * z + q[1]) * z + q[2];
+
+            g *= (z + p[1]) * z + p[2];
+            *px = (w + g) / (w - g) * 2.0 * y;
+            --xexp;
+        }
+
+        const short result_code = _Dscale(px, static_cast<long>(xexp) + eoff);
+
+        switch (result_code) {
+        case FP_ZERO:
+            *px = _Xfe_underflow(y);
+            break;
+        case FP_INFINITE:
+            *px = _Xfe_overflow(y);
+            break;
+        default:
+            break;
+        }
+
+        return result_code;
+    }
+}
+
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _LExp(long double* px, long double y, short eoff) noexcept {
+    return _Exp(reinterpret_cast<double*>(px), static_cast<double>(y), eoff);
+}
+
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _FExp(float* px, float y, short eoff) noexcept {
+    // compute y * e^(*px), (*px) finite, |y| not huge
+
+    static constexpr float p[] = {1.0F, 60.09114349F};
+    static constexpr float q[] = {12.01517514F, 120.18228722F};
+    constexpr float c1         = (22713.0F / 32768.0F);
+    constexpr float c2         = 1.4286068203094172321214581765680755e-6F;
+    constexpr float hugexp     = static_cast<int>(_FMAX * 900L / 1000);
+    constexpr float invln2     = 1.4426950408889634073599246810018921F;
+
+    if (y == 0.0F) { // zero
+        *px = y;
+        return FP_ZERO;
+    } else if (*px < -hugexp) { // certain underflow
+        *px = _Xfe_underflow(y);
+        return FP_ZERO;
+    } else if (hugexp < *px) { // certain overflow
+        *px = _Xfe_overflow(y);
+        return FP_INFINITE;
+    } else { // xexp won't overflow
+        float g    = *px * invln2;
+        short xexp = static_cast<short>(g + (g < 0.0F ? -0.5F : +0.5F));
+
+        g = xexp;
+        g = static_cast<float>((*px - g * c1) - g * c2);
+
+        constexpr float eps = 0x1p-25f;
+        if (-eps < g && g < eps) {
+            *px = y;
+        } else { // g * g worth computing
+            const float z = g * g;
+            const float w = q[0] * z + q[1];
+
+            g *= z + p[1];
+            *px = (w + g) / (w - g) * 2.0F * y;
+            --xexp;
+        }
+
+        const short result_code = _FDscale(px, static_cast<long>(xexp) + eoff);
+
+        switch (result_code) {
+        case FP_ZERO:
+            *px = _Xfe_underflow(y);
+            break;
+        case FP_INFINITE:
+            *px = _Xfe_overflow(y);
+            break;
+        default:
+            break;
+        }
+
+        return result_code;
+    }
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xgetwctype.cpp b/msvc-stl/stl/src/xgetwctype.cpp
new file mode 100644
index 0000000..66b3e9d
--- /dev/null
+++ b/msvc-stl/stl/src/xgetwctype.cpp
@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// _Getwctype -- return character classification flags for wide character
+
+#include <yvals.h>
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cwchar>
+
+#include <Windows.h>
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Getwctype(wchar_t _Ch, const _Ctypevec* _Ctype) noexcept {
+    // return character classification flags for _Ch
+    _CRT_UNUSED(_Ctype);
+    short _Mask;
+    return static_cast<short>(GetStringTypeW(CT_CTYPE1, &_Ch, 1, reinterpret_cast<LPWORD>(&_Mask)) == 0 ? 0 : _Mask);
+}
+
+_CRTIMP2_PURE const wchar_t* __CLRCALL_PURE_OR_CDECL _Getwctypes(
+    const wchar_t* _First, const wchar_t* _Last, short* _Dest, const _Ctypevec* _Ctype) noexcept {
+    // get mask sequence for elements in [_First, _Last)
+    _CRT_UNUSED(_Ctype);
+    GetStringTypeW(CT_CTYPE1, _First, static_cast<int>(_Last - _First), reinterpret_cast<LPWORD>(_Dest));
+    return _Last;
+}
+
+#ifdef MRTDLL
+_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Getwctype(unsigned short _Ch, const _Ctypevec* _Ctype) noexcept {
+    return _Getwctype(static_cast<wchar_t>(_Ch), _Ctype);
+}
+
+_CRTIMP2_PURE const unsigned short* __CLRCALL_PURE_OR_CDECL _Getwctypes(
+    const unsigned short* _First, const unsigned short* _Last, short* _Dest, const _Ctypevec* _Ctype) noexcept {
+    return reinterpret_cast<const unsigned short*>(
+        _Getwctypes(reinterpret_cast<const wchar_t*>(_First), reinterpret_cast<const wchar_t*>(_Last), _Dest, _Ctype));
+}
+#endif // ^^^ defined(MRTDLL) ^^^
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xlgamma.cpp b/msvc-stl/stl/src/xlgamma.cpp
new file mode 100644
index 0000000..4367cf6
--- /dev/null
+++ b/msvc-stl/stl/src/xlgamma.cpp
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cmath>
+
+_STD_BEGIN
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _XLgamma(float x) noexcept {
+    return _STD lgamma(x);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _XLgamma(double x) noexcept {
+    return _STD lgamma(x);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _XLgamma(long double x) noexcept {
+    return _STD lgamma(x);
+}
+_STD_END
diff --git a/msvc-stl/stl/src/xlocale.cpp b/msvc-stl/stl/src/xlocale.cpp
new file mode 100644
index 0000000..6ba71b0
--- /dev/null
+++ b/msvc-stl/stl/src/xlocale.cpp
@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// class locale exotic char member functions
+
+#include <istream>
+#include <locale>
+_STD_BEGIN
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+
+// facets associated with C categories
+#define ADDFAC(Facet, cat, ptrimp, ptrloc)                                                                  \
+    if ((_CATMASK(Facet::_Getcat()) & cat) == 0) {                                                          \
+        ;                                                                                                   \
+    } else if (ptrloc == nullptr) {                                                                         \
+        ptrimp->_Addfac(new Facet(lobj), Facet::id._Get_index());                                           \
+    } else {                                                                                                \
+        ptrimp->_Addfac(                                                                                    \
+            const_cast<locale::facet*>(static_cast<const locale::facet*>(&_STD use_facet<Facet>(*ptrloc))), \
+            Facet::id._Get_index());                                                                        \
+    }
+
+// moved from locale to ease subsetting
+using _Tx1 = collate<char>;
+using _Tx2 = messages<char>;
+using _Tx3 = money_get<char>;
+using _Tx4 = money_put<char>;
+using _Tx5 = moneypunct<char, false>;
+using _Tx6 = moneypunct<char, true>;
+using _Tx7 = time_get<char>;
+using _Tx8 = time_put<char>;
+
+void __CLRCALL_OR_CDECL locale::_Locimp::_Makexloc(const _Locinfo& lobj, locale::category cat, _Locimp* ptrimp,
+    const locale* ptrloc) { // setup exotic char part of a new locale
+    ADDFAC(_Tx1, cat, ptrimp, ptrloc);
+    ADDFAC(_Tx2, cat, ptrimp, ptrloc);
+    ADDFAC(_Tx3, cat, ptrimp, ptrloc);
+    ADDFAC(_Tx4, cat, ptrimp, ptrloc);
+    ADDFAC(_Tx5, cat, ptrimp, ptrloc);
+    ADDFAC(_Tx6, cat, ptrimp, ptrloc);
+    ADDFAC(_Tx7, cat, ptrimp, ptrloc);
+    ADDFAC(_Tx8, cat, ptrimp, ptrloc);
+}
+_STD_END
diff --git a/msvc-stl/stl/src/xlock.cpp b/msvc-stl/stl/src/xlock.cpp
new file mode 100644
index 0000000..1aea80d
--- /dev/null
+++ b/msvc-stl/stl/src/xlock.cpp
@@ -0,0 +1,124 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// global lock for locales, etc.
+
+#include <yvals.h>
+
+#include <clocale>
+#include <cstdlib>
+
+#include "init_locks.hpp"
+#include "xmtx.hpp"
+
+_STD_BEGIN
+
+constexpr int _Max_lock = 8; // must be power of two; TRANSITION, ABI: may be less now
+
+#pragma warning(disable : 4074)
+#pragma init_seg(compiler)
+
+static _Rmtx mtx[_Max_lock];
+static long init = -1;
+
+#if !defined(MRTDLL)
+
+__thiscall _Init_locks::_Init_locks() noexcept { // initialize locks
+    if (InterlockedIncrement(&init) == 0) {
+        for (auto& elem : mtx) {
+            _Mtxinit(&elem);
+        }
+    }
+}
+
+__thiscall _Init_locks::~_Init_locks() noexcept { // clean up locks
+    if (InterlockedDecrement(&init) < 0) {
+        for (auto& elem : mtx) {
+            _Mtxdst(&elem);
+        }
+    }
+}
+
+#endif // ^^^ !defined(MRTDLL) ^^^
+
+void __cdecl _Init_locks::_Init_locks_ctor(_Init_locks*) noexcept { // initialize locks
+    if (InterlockedIncrement(&init) == 0) {
+        for (auto& elem : mtx) {
+            _Mtxinit(&elem);
+        }
+    }
+}
+
+void __cdecl _Init_locks::_Init_locks_dtor(_Init_locks*) noexcept { // clean up locks
+    if (InterlockedDecrement(&init) < 0) {
+        for (auto& elem : mtx) {
+            _Mtxdst(&elem);
+        }
+    }
+}
+
+static _Init_locks initlocks;
+
+#if !defined(MRTDLL)
+
+__thiscall _Lockit::_Lockit() noexcept : _Locktype(0) { // lock default mutex
+    if (_Locktype == _LOCK_LOCALE) {
+        _lock_locales();
+    } else {
+        _Mtxlock(&mtx[0]);
+    }
+}
+
+__thiscall _Lockit::_Lockit(int kind) noexcept : _Locktype(kind) { // lock the mutex
+    if (_Locktype == _LOCK_LOCALE) {
+        _lock_locales();
+    } else if (_Locktype < _Max_lock) {
+        _Mtxlock(&mtx[_Locktype]);
+    }
+}
+
+__thiscall _Lockit::~_Lockit() noexcept { // unlock the mutex
+    if (_Locktype == _LOCK_LOCALE) {
+        _unlock_locales();
+    } else if (_Locktype < _Max_lock) {
+        _Mtxunlock(&mtx[_Locktype]);
+    }
+}
+
+#endif // ^^^ !defined(MRTDLL) ^^^
+
+void __cdecl _Lockit::_Lockit_ctor(_Lockit*) noexcept { // lock default mutex
+    _Mtxlock(&mtx[0]);
+}
+
+void __cdecl _Lockit::_Lockit_ctor(_Lockit* _This, int kind) noexcept { // lock the mutex
+    if (kind == _LOCK_LOCALE) {
+        _lock_locales();
+    } else {
+        _This->_Locktype = kind & (_Max_lock - 1);
+        _Mtxlock(&mtx[_This->_Locktype]);
+    }
+}
+
+void __cdecl _Lockit::_Lockit_dtor(_Lockit* _This) noexcept { // unlock the mutex
+    _Mtxunlock(&mtx[_This->_Locktype]);
+}
+
+_RELIABILITY_CONTRACT
+void __cdecl _Lockit::_Lockit_ctor(int kind) noexcept { // lock the mutex
+    if (kind == _LOCK_LOCALE) {
+        _lock_locales();
+    } else {
+        _Mtxlock(&mtx[kind & (_Max_lock - 1)]);
+    }
+}
+
+_RELIABILITY_CONTRACT
+void __cdecl _Lockit::_Lockit_dtor(int kind) noexcept { // unlock the mutex
+    if (kind == _LOCK_LOCALE) {
+        _unlock_locales();
+    } else {
+        _Mtxunlock(&mtx[kind & (_Max_lock - 1)]);
+    }
+}
+_STD_END
diff --git a/msvc-stl/stl/src/xmbtowc.cpp b/msvc-stl/stl/src/xmbtowc.cpp
new file mode 100644
index 0000000..236f9f6
--- /dev/null
+++ b/msvc-stl/stl/src/xmbtowc.cpp
@@ -0,0 +1,169 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Convert multibyte char to wide char.
+
+#include <yvals.h>
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cctype>
+#include <cerrno>
+#include <climits> // for INT_MAX
+#include <crtdbg.h>
+#include <internal_shared.h>
+
+_EXTERN_C_UNLESS_PURE
+
+static int _Utf8_trailing_byte_count(unsigned long* partialCh, unsigned char ch) noexcept {
+    if ((ch & 0x80u) == 0x00u) { // high bit unset, plain ASCII
+        return 0;
+    }
+
+    if ((ch & 0xE0u) == 0xC0u) { // first 3 bits are 110, 1 trailing byte
+        *partialCh = ch & 0x1Fu;
+        return 1;
+    }
+
+    if ((ch & 0xF0u) == 0xE0u) { // first 4 bits are 1110, 2 trailing bytes
+        *partialCh = ch & 0x0Fu;
+        return 2;
+    }
+
+    if ((ch & 0xF8u) == 0xF0u) { // first 5 bits are 11110, 3 trailing bytes
+        *partialCh = ch & 0x07u;
+        return 3;
+    }
+
+    return INT_MAX;
+}
+
+static int _Decode_utf8_trailing_byte(unsigned long* partialCh, unsigned char ch) noexcept {
+    if ((ch & 0xC0) == 0x80) {
+        *partialCh <<= 6;
+        *partialCh |= ch & 0x3Fu;
+        return 0;
+    }
+
+    return 1;
+}
+
+// int _Mbrtowc() - Convert multibyte char to wide character.
+//
+// Purpose:
+//     Convert a multi-byte character into the equivalent wide character,
+//     according to the specified LC_CTYPE category, or the current locale.
+//     [ANSI].
+//
+// Entry:
+//     wchar_t* pwc        = pointer to destination wide character
+//     const char* s       = pointer to multibyte character
+//     size_t n            = maximum length of multibyte character to consider
+//     mbstate_t* pst      = pointer to state
+//     const _Cvtvec* ploc = pointer to locale info
+//
+// Returns: 0 (if *s = null char)
+//          -1 (if the next n or fewer bytes not valid mbc)
+//          -2 (if partial conversion)
+//          number of bytes comprising converted mbc
+_MRTIMP2 _Success_(return >= 0) int __cdecl _Mbrtowc(
+    _When_(n != 0, _Out_) wchar_t* pwc, const char* s, size_t n, mbstate_t* pst, const _Cvtvec* ploc) noexcept {
+    (void) pst;
+    if (n == 0) { // indicate do not have state-dependent encodings, handle zero length string
+        return 0;
+    }
+
+    if (!*s) { // handle null terminator, TRANSITION, VSO-654347
+        *pwc = 0;
+        return 0;
+    }
+
+    // perform locale-dependent parse
+    unsigned char ch = static_cast<unsigned char>(*s);
+    if (ploc->_Isclocale) {
+        *pwc = ch;
+        return 1;
+    }
+
+    unsigned long wch;
+    int consumedCount;
+    int trailingUtf8Units;
+    switch (ploc->_Mbcurmax) {
+    default:
+        _ASSERTE(!"Bad number of encoding units for this code page");
+        _FALLTHROUGH;
+    case 1:
+        if (MultiByteToWideChar(ploc->_Page, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, s, 1, pwc, 1) == 0) {
+            errno = EILSEQ;
+            return -1;
+        }
+
+        return 1;
+
+    case 4: // UTF-8
+        _ASSERTE(ploc->_Page == CP_UTF8);
+        trailingUtf8Units = _Utf8_trailing_byte_count(&wch, ch);
+        if (trailingUtf8Units == 0) { // optimistic ASCII passthrough
+            *pwc = static_cast<wchar_t>(ch);
+            return 1;
+        }
+
+        if (trailingUtf8Units > 2) { // this would result in a UTF-16 surrogate pair, which we can't emit in our
+                                     // singular output wchar_t, so fail
+                                     // see N4950 [locale.codecvt.virtuals]/3
+            errno = EILSEQ;
+            return -1;
+        }
+
+        consumedCount = 1;
+        for (; trailingUtf8Units; ++consumedCount, --trailingUtf8Units) { // consume remaining trailing bytes
+            if (static_cast<size_t>(consumedCount) >= n) { // no byte to consume, return partial
+                return -2;
+            }
+
+            if (_Decode_utf8_trailing_byte(&wch, static_cast<unsigned char>(s[consumedCount]))) {
+                errno = EILSEQ;
+                return -1;
+            }
+        }
+
+        if ((consumedCount == 2 && wch < 0x80u) || (consumedCount == 3 && wch < 0x800u)) { // overlong forms
+            errno = EILSEQ;
+            return -1;
+        }
+
+        if (wch >= 0xD800u && wch <= 0xDFFFu) { // tried to decode unpaired surrogate
+            errno = EILSEQ;
+            return -1;
+        }
+
+        *pwc = static_cast<wchar_t>(wch);
+        return consumedCount;
+
+    case 2:
+        if (ploc->_Isleadbyte[ch >> 3] & (1u << (ch & 7u))) {
+            if (n == 1) { // partial multibyte character
+                return -2;
+            }
+
+            consumedCount = 2;
+        } else {
+            consumedCount = 1;
+        }
+
+        if (MultiByteToWideChar(ploc->_Page, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, s, consumedCount, pwc, 1) == 0) {
+            errno = EILSEQ;
+            return -1;
+        }
+
+        return consumedCount;
+    }
+}
+
+#ifdef MRTDLL
+_MRTIMP2 int __cdecl _Mbrtowc(
+    unsigned short* pwc, const char* s, size_t n, mbstate_t* pst, const _Cvtvec* ploc) noexcept {
+    return _Mbrtowc(reinterpret_cast<wchar_t*>(pwc), s, n, pst, ploc);
+}
+#endif // defined(MRTDLL)
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xmtx.cpp b/msvc-stl/stl/src/xmtx.cpp
new file mode 100644
index 0000000..b10bba2
--- /dev/null
+++ b/msvc-stl/stl/src/xmtx.cpp
@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// mutex support
+
+#include "xmtx.hpp"
+
+_EXTERN_C_UNLESS_PURE
+
+// Win32 critical sections are recursive
+
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtxinit(_Rmtx* _Mtx) noexcept { // initialize mutex
+    InitializeCriticalSectionEx(_Mtx, 4000, 0);
+}
+
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtxdst(_Rmtx* _Mtx) noexcept { // delete mutex
+    DeleteCriticalSection(_Mtx);
+}
+
+_RELIABILITY_CONTRACT
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtxlock(_Rmtx* _Mtx) noexcept { // lock mutex
+#ifdef _M_CEE
+    System::Threading::Thread::BeginThreadAffinity();
+#endif
+    EnterCriticalSection(_Mtx);
+}
+
+_RELIABILITY_CONTRACT
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtxunlock(_Rmtx* _Mtx) noexcept { // unlock mutex
+    LeaveCriticalSection(_Mtx);
+#ifdef _M_CEE
+    System::Threading::Thread::EndThreadAffinity();
+#endif
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xmtx.hpp b/msvc-stl/stl/src/xmtx.hpp
new file mode 100644
index 0000000..a9848b6
--- /dev/null
+++ b/msvc-stl/stl/src/xmtx.hpp
@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <yvals.h>
+
+#include <cstdlib>
+
+#include <Windows.h>
+
+#ifdef _M_CEE
+#if _PREPARE_CONSTRAINED_REGIONS
+#define _CRT_SUPPRESS_C4950
+#define _CRT_RESTORE_C4950
+#else // ^^^ _PREPARE_CONSTRAINED_REGIONS / !_PREPARE_CONSTRAINED_REGIONS vvv
+// Constrained regions are obsolete in .NET 6 and above.
+#define _CRT_SUPPRESS_C4950 __pragma(warning(push)) _pragma(warning(disable : 4950))
+#define _CRT_RESTORE_C4950  __pragma(warning(pop))
+#endif // ^^^ !_PREPARE_CONSTRAINED_REGIONS ^^^
+#define _RELIABILITY_CONTRACT                                                    \
+    _CRT_SUPPRESS_C4950                                                          \
+    [System::Runtime::ConstrainedExecution::ReliabilityContract(                 \
+        System::Runtime::ConstrainedExecution::Consistency::WillNotCorruptState, \
+        System::Runtime::ConstrainedExecution::Cer::Success)] /**/               \
+        _CRT_RESTORE_C4950
+#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
+#define _RELIABILITY_CONTRACT
+#endif // ^^^ !defined(_M_CEE) ^^^
+
+_EXTERN_C_UNLESS_PURE
+
+using _Rmtx = CRITICAL_SECTION;
+
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtxinit(_Rmtx*) noexcept;
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtxdst(_Rmtx*) noexcept;
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtxlock(_Rmtx*) noexcept;
+_MRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtxunlock(_Rmtx*) noexcept;
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xnotify.cpp b/msvc-stl/stl/src/xnotify.cpp
new file mode 100644
index 0000000..a49c889
--- /dev/null
+++ b/msvc-stl/stl/src/xnotify.cpp
@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstdlib>
+#include <mutex>
+#include <xthreads.h>
+
+#include <Windows.h>
+
+constexpr int _Nitems = 20;
+
+namespace {
+    struct _At_thread_exit_data { // data for condition-variable slot
+        _Thrd_t id;
+        _Mtx_t mtx;
+        _Cnd_t cnd;
+        int* res;
+    };
+
+    struct _At_thread_exit_block { // block of condition-variable slots
+        _At_thread_exit_data data[_Nitems];
+        int num_used;
+        _At_thread_exit_block* next;
+    };
+
+    _At_thread_exit_block _Thread_exit_data;
+
+    constinit std::mutex _Thread_exit_data_mutex;
+} // unnamed namespace
+
+extern "C" {
+
+_CRTIMP2_PURE void __cdecl _Cnd_register_at_thread_exit(_Cnd_t cnd, _Mtx_t mtx, int* p) noexcept {
+    // register condition variable and mutex for cleanup at thread exit
+
+    // find block with available space
+    _At_thread_exit_block* block = &_Thread_exit_data;
+
+    std::lock_guard _Lock{_Thread_exit_data_mutex};
+    while (block != nullptr) { // loop through list of blocks
+        if (block->num_used == _Nitems) { // block is full; move to next block and allocate
+            if (block->next == nullptr) {
+                block->next = static_cast<_At_thread_exit_block*>(calloc(1, sizeof(_At_thread_exit_block)));
+            }
+
+            block = block->next;
+        } else { // found block with available space
+            for (int i = 0; i < _Nitems; ++i) { // find empty slot
+                if (block->data[i].mtx == nullptr) { // store into empty slot
+                    block->data[i].id._Id = GetCurrentThreadId();
+                    block->data[i].mtx    = mtx;
+                    block->data[i].cnd    = cnd;
+                    block->data[i].res    = p;
+                    ++block->num_used;
+                    break;
+                }
+            }
+            block = nullptr;
+        }
+    }
+}
+
+_CRTIMP2_PURE void __cdecl _Cnd_unregister_at_thread_exit(_Mtx_t mtx) noexcept {
+    // unregister condition variable/mutex for cleanup at thread exit
+
+    // find condition variables waiting for this thread to exit
+    _At_thread_exit_block* block = &_Thread_exit_data;
+
+    std::lock_guard _Lock{_Thread_exit_data_mutex};
+    while (block != nullptr) { // loop through list of blocks
+        for (int i = 0; block->num_used != 0 && i < _Nitems; ++i) {
+            if (block->data[i].mtx == mtx) { // release slot
+                block->data[i].mtx = nullptr;
+                --block->num_used;
+            }
+        }
+
+        block = block->next;
+    }
+}
+
+_CRTIMP2_PURE void __cdecl _Cnd_do_broadcast_at_thread_exit() noexcept {
+    // notify condition variables waiting for this thread to exit
+
+    // find condition variables waiting for this thread to exit
+    _At_thread_exit_block* block       = &_Thread_exit_data;
+    const unsigned int currentThreadId = _Thrd_id();
+
+    std::lock_guard _Lock{_Thread_exit_data_mutex};
+    while (block != nullptr) { // loop through list of blocks
+        for (int i = 0; block->num_used != 0 && i < _Nitems; ++i) {
+            if (block->data[i].mtx != nullptr && block->data[i].id._Id == currentThreadId) { // notify and release slot
+                if (block->data[i].res) {
+                    *block->data[i].res = 1;
+                }
+                _Cnd_broadcast(block->data[i].cnd);
+                _Mtx_unlock(block->data[i].mtx);
+                block->data[i].mtx = nullptr;
+                --block->num_used;
+            }
+        }
+
+        block = block->next;
+    }
+}
+
+} // extern "C"
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/msvc-stl/stl/src/xonce.cpp b/msvc-stl/stl/src/xonce.cpp
new file mode 100644
index 0000000..486c602
--- /dev/null
+++ b/msvc-stl/stl/src/xonce.cpp
@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <mutex>
+
+#include <Windows.h>
+
+_STD_BEGIN
+// Returns BOOL, nonzero to indicate success, zero for failure
+using _Execute_once_fp_t = int(__stdcall*)(void*, void*, void**);
+
+// TRANSITION, ABI: _Execute_once() is preserved for binary compatibility
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Execute_once(
+    once_flag& _Flag, _Execute_once_fp_t _Callback, void* _Pv) noexcept { // wrap Win32 InitOnceExecuteOnce()
+    static_assert(sizeof(_Flag._Opaque) == sizeof(INIT_ONCE), "invalid size");
+
+    return InitOnceExecuteOnce(
+        reinterpret_cast<PINIT_ONCE>(&_Flag._Opaque), reinterpret_cast<PINIT_ONCE_FN>(_Callback), _Pv, nullptr);
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
+    _XGetLastError() { // throw system_error containing GetLastError()
+    error_code _Code(static_cast<int>(GetLastError()), _STD system_category());
+    _THROW(system_error(_Code));
+}
+_STD_END
diff --git a/msvc-stl/stl/src/xonce2.cpp b/msvc-stl/stl/src/xonce2.cpp
new file mode 100644
index 0000000..0e3968f
--- /dev/null
+++ b/msvc-stl/stl/src/xonce2.cpp
@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <yvals_core.h>
+
+#include <cstdlib>
+
+#include <Windows.h>
+
+// Provides forwarders for InitOnceBeginInitialize and InitOnceComplete for
+// environments that can't use /ALTERNATENAME.
+// They were originally specific to /clr but are now used in other scenarios.
+
+extern "C" {
+
+int __stdcall __std_init_once_begin_initialize_clr(
+    void** _LpInitOnce, unsigned long _DwFlags, int* _FPending, void** _LpContext) noexcept {
+    return InitOnceBeginInitialize(reinterpret_cast<LPINIT_ONCE>(_LpInitOnce), _DwFlags, _FPending, _LpContext);
+}
+
+int __stdcall __std_init_once_complete_clr(void** _LpInitOnce, unsigned long _DwFlags, void* _LpContext) noexcept {
+    return InitOnceComplete(reinterpret_cast<LPINIT_ONCE>(_LpInitOnce), _DwFlags, _LpContext);
+}
+
+[[noreturn]] void __stdcall __std_init_once_link_alternate_names_and_abort() noexcept {
+    _CSTD abort();
+}
+
+#if defined(_M_HYBRID)
+// <mutex> uses the forwarder fallbacks for ARM64EC and CHPE.
+// Note that ARM64EC nevertheless needs the ALTERNATENAMEs to support x64 object files.
+#elif defined(_M_IX86)
+#pragma comment(linker, "/ALTERNATENAME:__imp____std_init_once_begin_initialize@16=__imp__InitOnceBeginInitialize@16")
+#pragma comment(linker, "/ALTERNATENAME:__imp____std_init_once_complete@12=__imp__InitOnceComplete@12")
+#elif defined(_M_X64) || defined(_M_ARM64) // Note: includes _M_ARM64EC
+#pragma comment(linker, "/ALTERNATENAME:__imp___std_init_once_begin_initialize=__imp_InitOnceBeginInitialize")
+#pragma comment(linker, "/ALTERNATENAME:__imp___std_init_once_complete=__imp_InitOnceComplete")
+#else // ^^^ known architecture / unknown architecture vvv
+#error Unknown architecture
+#endif // ^^^ unknown architecture ^^^
+
+} // extern "C"
diff --git a/msvc-stl/stl/src/xrngabort.cpp b/msvc-stl/stl/src/xrngabort.cpp
new file mode 100644
index 0000000..43ef28b
--- /dev/null
+++ b/msvc-stl/stl/src/xrngabort.cpp
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// abort on precondition failure in random number generators
+
+#include <yvals.h>
+
+#include <cstdio>
+#include <cstdlib>
+
+_STD_BEGIN
+// TRANSITION, ABI: _Rng_abort() is preserved for binary compatibility
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Rng_abort(_In_z_ const char* _Msg) {
+    // abort on precondition failure
+    _CSTD fputs(_Msg, stderr);
+    _CSTD fputc('\n', stderr);
+    _CSTD abort();
+}
+_STD_END
diff --git a/msvc-stl/stl/src/xrngdev.cpp b/msvc-stl/stl/src/xrngdev.cpp
new file mode 100644
index 0000000..b538a7d
--- /dev/null
+++ b/msvc-stl/stl/src/xrngdev.cpp
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// implement random_device
+
+#include <cstdlib>
+#include <xutility>
+
+_STD_BEGIN
+_CRTIMP2_PURE unsigned int __CLRCALL_PURE_OR_CDECL _Random_device() { // return a random value
+    unsigned int ans;
+    if (_CSTD rand_s(&ans)) {
+        _Xout_of_range("invalid random_device value");
+    }
+
+    return ans;
+}
+
+_STD_END
diff --git a/msvc-stl/stl/src/xsinh.cpp b/msvc-stl/stl/src/xsinh.cpp
new file mode 100644
index 0000000..44914ad
--- /dev/null
+++ b/msvc-stl/stl/src/xsinh.cpp
@@ -0,0 +1,133 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cerrno>
+#include <cmath>
+#include <xutility>
+#include <ymath.h>
+
+namespace {
+    double _Poly(double x, const double* tab, int n) noexcept { // compute polynomial
+        double y;
+
+        for (y = *tab; 0 <= --n;) {
+            y = y * x + *++tab;
+        }
+
+        return y;
+    }
+} // unnamed namespace
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Sinh(double x, double y) noexcept {
+    // compute y * sinh(x), |y| <= 1
+
+    // coefficients
+    static constexpr double p[] = {0.0000000001632881, 0.0000000250483893, 0.0000027557344615, 0.0001984126975233,
+        0.0083333333334816, 0.1666666666666574, 1.0000000000000001};
+    constexpr size_t NP         = std::size(p) - 1;
+
+    short neg;
+
+    switch (_STD fpclassify(x)) { // test for special codes
+    case FP_NAN:
+        return x;
+    case FP_INFINITE:
+        return y != 0.0 ? x : _STD signbit(x) ? -y : y;
+    case FP_ZERO:
+        return x * y;
+    default: // finite
+        if (y == 0.0) {
+            return x < 0.0 ? -y : y;
+        }
+
+        if (x < 0.0) {
+            x   = -x;
+            neg = 1;
+        } else {
+            neg = 0;
+        }
+
+        constexpr double rteps = 0x1p-27;
+        constexpr double _Xbig = ((48 + _DOFF) + 2) * 0.347;
+        if (x < rteps) {
+            x *= y; // x tiny
+        } else if (x < 1.0) {
+            double w = x * x;
+
+            x += x * w * _Poly(w, p, NP - 1);
+            x *= y;
+        } else if (x < _Xbig) { // worth adding in exp(-x)
+            _Exp(&x, 1.0, -1);
+            x = y * (x - 0.25 / x);
+        } else {
+            switch (_Exp(&x, y, -1)) {
+            case FP_ZERO: // report underflow
+            case FP_INFINITE: // report overflow
+                errno = ERANGE;
+                break;
+            }
+        }
+
+        return neg ? -x : x;
+    }
+}
+
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _LSinh(long double x, long double y) noexcept {
+    return _Sinh(static_cast<double>(x), static_cast<double>(y));
+}
+
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _FSinh(float x, float y) noexcept {
+    // compute y * sinh(x), |y| <= 1
+
+    // coefficients
+    static constexpr float p[] = {0.00020400F, 0.00832983F, 0.16666737F, 0.99999998F};
+
+    short neg;
+
+    switch (_STD fpclassify(x)) { // test for special codes
+    case FP_NAN:
+        return x;
+    case FP_INFINITE:
+        return y != 0.0F ? x : _STD signbit(x) ? -y : y;
+    case FP_ZERO:
+        return x * y;
+    default: // finite
+        if (y == 0.0F) {
+            return x < 0.0F ? -y : y;
+        }
+
+        if (x < 0.0F) {
+            x   = -x;
+            neg = 1;
+        } else {
+            neg = 0;
+        }
+
+        constexpr float rteps  = 0x1p-12f;
+        constexpr float _FXbig = ((16 + _FOFF) + 2) * 0.347f;
+        if (x < rteps) {
+            x *= y; // x tiny
+        } else if (x < 1.0F) {
+            float w = x * x;
+
+            x += ((p[0] * w + p[1]) * w + p[2]) * w * x;
+            x *= y;
+        } else if (x < _FXbig) { // worth adding in exp(-x)
+            _FExp(&x, 1.0F, -1);
+            x = y * (x - 0.25F / x);
+        } else {
+            switch (_FExp(&x, y, -1)) {
+            case FP_ZERO: // report underflow
+            case FP_INFINITE: // report overflow
+                errno = ERANGE;
+                break;
+            }
+        }
+
+        return neg ? -x : x;
+    }
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xstod.cpp b/msvc-stl/stl/src/xstod.cpp
new file mode 100644
index 0000000..be42bee
--- /dev/null
+++ b/msvc-stl/stl/src/xstod.cpp
@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cmath>
+#include <cstdlib>
+
+_EXTERN_C_UNLESS_PURE
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Stodx(const char* _Str, char** _Endptr, long _Pten, int* _Perr) noexcept {
+    int& _Errno_ref = errno; // Nonzero cost, pay it once
+    const int _Orig = _Errno_ref;
+
+    _Errno_ref  = 0;
+    double _Val = _CSTD strtod(_Str, _Endptr);
+    *_Perr      = _Errno_ref;
+    _Errno_ref  = _Orig;
+
+    if (_Pten != 0) {
+        _Val *= _CSTD pow(10.0, static_cast<double>(_Pten));
+    }
+
+    return _Val;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Stod(const char* s, char** endptr, long pten) noexcept {
+    return _Stodx(s, endptr, pten, nullptr);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _Stoldx(const char* s, char** endptr, long pten, int* perr) noexcept {
+    return _Stodx(s, endptr, pten, perr);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _Stold(const char* s, char** endptr, long pten) noexcept {
+    return _Stodx(s, endptr, pten, nullptr);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xstof.cpp b/msvc-stl/stl/src/xstof.cpp
new file mode 100644
index 0000000..9d3e3d5
--- /dev/null
+++ b/msvc-stl/stl/src/xstof.cpp
@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cmath>
+#include <cstdlib>
+
+_EXTERN_C_UNLESS_PURE
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _Stofx(const char* _Str, char** _Endptr, long _Pten, int* _Perr) noexcept {
+    int& _Errno_ref = errno; // Nonzero cost, pay it once
+    const int _Orig = _Errno_ref;
+
+    _Errno_ref = 0;
+    float _Val = _CSTD strtof(_Str, _Endptr);
+    *_Perr     = _Errno_ref;
+    _Errno_ref = _Orig;
+
+    if (_Pten != 0) {
+        _Val *= _CSTD powf(10.0f, static_cast<float>(_Pten));
+    }
+
+    return _Val;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _Stof(const char* s, char** endptr, long pten) noexcept {
+    return _Stofx(s, endptr, pten, nullptr);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xstol.cpp b/msvc-stl/stl/src/xstol.cpp
new file mode 100644
index 0000000..6a4507d
--- /dev/null
+++ b/msvc-stl/stl/src/xstol.cpp
@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <yvals.h>
+
+#include <cctype>
+#include <cerrno>
+#include <climits>
+#include <cstdlib>
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Stoulx(const char*, char**, int, int*) noexcept;
+
+_CRTIMP2_PURE long __CLRCALL_PURE_OR_CDECL _Stolx(const char* s, char** endptr, int base, int* perr) noexcept {
+    // convert string to long, with checking
+    const char* sc;
+    char* se;
+    char sign;
+    unsigned long x;
+
+    if (endptr == nullptr) {
+        endptr = &se;
+    }
+
+    sc = s;
+    while (isspace(static_cast<unsigned char>(*sc))) {
+        ++sc;
+    }
+
+    sign = *sc == '-' || *sc == '+' ? *sc++ : '+';
+    x    = _Stoulx(sc, endptr, base, perr);
+    if (sc == *endptr) {
+        *endptr = const_cast<char*>(s);
+    }
+
+    if (s == *endptr && x != 0 || sign == '+' && LONG_MAX < x || sign == '-' && (1ul << 31) < x) { // overflow
+        errno = ERANGE;
+        if (perr != nullptr) {
+            *perr = 1;
+        }
+
+        return sign == '-' ? LONG_MIN : LONG_MAX;
+    }
+
+    return static_cast<long>(sign == '-' ? 0 - x : x);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xstoll.cpp b/msvc-stl/stl/src/xstoll.cpp
new file mode 100644
index 0000000..4eaed74
--- /dev/null
+++ b/msvc-stl/stl/src/xstoll.cpp
@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <yvals.h>
+
+#include <cctype>
+#include <cerrno>
+#include <climits>
+#include <cstdlib>
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE unsigned long long __CLRCALL_PURE_OR_CDECL _Stoullx(const char*, char**, int, int*) noexcept;
+
+_CRTIMP2_PURE long long __CLRCALL_PURE_OR_CDECL _Stollx(const char* s, char** endptr, int base, int* perr) noexcept {
+    // convert string to long long, with checking
+    const char* sc;
+    char* se;
+    char sign;
+    unsigned long long x;
+
+    if (endptr == nullptr) {
+        endptr = &se;
+    }
+
+    sc = s;
+    while (isspace(static_cast<unsigned char>(*sc))) {
+        ++sc;
+    }
+
+    sign = static_cast<char>(*sc == '-' || *sc == '+' ? *sc++ : '+');
+    x    = _Stoullx(sc, endptr, base, perr);
+    if (sc == *endptr) {
+        *endptr = const_cast<char*>(s);
+    }
+
+    if (s == *endptr && x != 0 || sign == '+' && LLONG_MAX < x || sign == '-' && (1ull << 63) < x) { // overflow
+        errno = ERANGE;
+        if (perr != nullptr) {
+            *perr = 1;
+        }
+
+        return sign == '-' ? LLONG_MIN : LLONG_MAX;
+    }
+
+    return static_cast<long long>(sign == '-' ? 0 - x : x);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE long long __CLRCALL_PURE_OR_CDECL _Stoll(const char* s, char** endptr, int base) noexcept {
+    // convert string, discard error code
+    return _Stollx(s, endptr, base, nullptr);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xstoul.cpp b/msvc-stl/stl/src/xstoul.cpp
new file mode 100644
index 0000000..8b20203
--- /dev/null
+++ b/msvc-stl/stl/src/xstoul.cpp
@@ -0,0 +1,114 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <yvals.h>
+
+#include <cctype>
+#include <cerrno>
+#include <climits>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Stoulx(
+    const char* s, char** endptr, int base, int* perr) noexcept {
+    // convert string to unsigned long, with checking
+
+    constexpr int _Base_max                    = 36; // largest valid base
+    static constexpr char digits[]             = "0123456789abcdefghijklmnopqrstuvwxyz"; // valid digits
+    static constexpr char ndigs[_Base_max + 1] = {0, 0, 33, 21, 17, 14, 13, 12, 11, 11, 10, 10, 9, 9, 9, 9, 9, 8, 8, 8,
+        8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7}; // 32-bits!
+
+    const char* sc;
+    const char* sd;
+    const char* s1;
+    const char* s2;
+    char dig = 0;
+    char sign;
+    ptrdiff_t n;
+    unsigned long x;
+    unsigned long y;
+
+    if (perr != nullptr) {
+        *perr = 0;
+    }
+
+    sc = s;
+    while (isspace(static_cast<unsigned char>(*sc))) {
+        ++sc;
+    }
+
+    sign = *sc == '-' || *sc == '+' ? *sc++ : '+';
+    if (base < 0 || base == 1 || _Base_max < base) { // silly base
+        if (endptr != nullptr) {
+            *endptr = const_cast<char*>(s);
+        }
+
+        return 0;
+    }
+
+    if (0 < base) { // strip 0x or 0X
+        if (base == 16 && *sc == '0' && (sc[1] == 'x' || sc[1] == 'X')) {
+            sc += 2;
+        }
+    } else if (*sc != '0') {
+        base = 10;
+    } else if (sc[1] == 'x' || sc[1] == 'X') {
+        base = 16;
+        sc += 2;
+    } else {
+        base = 8;
+    }
+
+    s1 = sc;
+    while (*sc == '0') { // skip leading zeros
+        ++sc;
+    }
+
+    x = 0;
+    for (s2 = sc, y = 0; (sd = static_cast<const char*>(memchr(&digits[0], tolower(*sc), base))) != nullptr;
+        ++sc) { // accumulate digits
+        y   = x;
+        dig = static_cast<char>(sd - digits); // for overflow checking
+        x   = x * base + dig;
+    }
+
+    if (s1 == sc) { // check string validity
+        if (endptr != nullptr) {
+            *endptr = const_cast<char*>(s);
+        }
+
+        return 0;
+    }
+
+    n = sc - s2 - ndigs[base];
+    if (n >= 0 && (0 < n || x < x - dig || (x - dig) / base != y)) { // overflow
+        errno = ERANGE;
+        if (perr != nullptr) {
+            *perr = 1;
+        }
+
+        x    = ULONG_MAX;
+        sign = '+'; // silence negation
+    }
+
+    if (sign == '-') { // get final value
+        x = 0 - x;
+    }
+
+    if (endptr != nullptr) {
+        *endptr = const_cast<char*>(sc);
+    }
+
+    return x;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Stoul(const char* s, char** endptr, int base) noexcept {
+    // convert string, discard error code
+    return _Stoulx(s, endptr, base, nullptr);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xstoull.cpp b/msvc-stl/stl/src/xstoull.cpp
new file mode 100644
index 0000000..e55d51d
--- /dev/null
+++ b/msvc-stl/stl/src/xstoull.cpp
@@ -0,0 +1,112 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <yvals.h>
+
+#include <cctype>
+#include <cerrno>
+#include <climits>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE unsigned long long __CLRCALL_PURE_OR_CDECL _Stoullx(
+    const char* s, char** endptr, int base, int* perr) noexcept {
+    // convert string to unsigned long long, with checking
+
+    constexpr int _Base_max                    = 36; // largest valid base
+    static constexpr char digits[]             = "0123456789abcdefghijklmnopqrstuvwxyz"; // valid digits
+    static constexpr char ndigs[_Base_max + 1] = {0, 0, 65, 41, 33, 28, 25, 23, 22, 21, 20, 19, 18, 18, 17, 17, 17, 16,
+        16, 16, 15, 15, 15, 15, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13}; // 64-bits!
+
+    const char* sc;
+    const char* sd;
+    const char* s1;
+    const char* s2;
+    char dig;
+    char sign;
+    ptrdiff_t n;
+    unsigned long long x;
+    unsigned long long y;
+
+    if (perr != nullptr) {
+        *perr = 0;
+    }
+
+    sc = s;
+    while (isspace(static_cast<unsigned char>(*sc))) {
+        ++sc;
+    }
+
+    sign = static_cast<char>(*sc == '-' || *sc == '+' ? *sc++ : '+');
+    if (base < 0 || base == 1 || _Base_max < base) { // silly base
+        if (endptr != nullptr) {
+            *endptr = const_cast<char*>(s);
+        }
+
+        return 0;
+    }
+
+    if (0 < base) { // strip 0x or 0X
+        if (base == 16 && *sc == '0' && (sc[1] == 'x' || sc[1] == 'X')) {
+            sc += 2;
+        }
+    } else if (*sc != '0') {
+        base = 10;
+    } else if (sc[1] == 'x' || sc[1] == 'X') {
+        base = 16;
+        sc += 2;
+    } else {
+        base = 8;
+    }
+
+    for (s1 = sc; *sc == '0'; ++sc) { // skip leading zeros
+    }
+
+    x = 0;
+    for (s2 = sc, y = 0, dig = 0; (sd = static_cast<const char*>(memchr(&digits[0], tolower(*sc), base))) != nullptr;
+        ++sc) { // accumulate digits
+        y   = x;
+        dig = static_cast<char>(sd - digits); // for overflow checking
+        x   = x * base + dig;
+    }
+
+    if (s1 == sc) { // check string validity
+        if (endptr != nullptr) {
+            *endptr = const_cast<char*>(s);
+        }
+
+        return 0;
+    }
+
+    n = sc - s2 - ndigs[base];
+    if (n >= 0 && (0 < n || x < x - dig || (x - dig) / base != y)) { // overflow
+        errno = ERANGE;
+        if (perr != nullptr) {
+            *perr = 1;
+        }
+
+        x    = ULLONG_MAX;
+        sign = '+';
+    }
+
+    if (sign == '-') { // get final value
+        x = 0 - x;
+    }
+
+    if (endptr != nullptr) {
+        *endptr = const_cast<char*>(sc);
+    }
+
+    return x;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE unsigned long long __CLRCALL_PURE_OR_CDECL _Stoull(const char* s, char** endptr, int base) noexcept {
+    // convert string, discard error code
+    return _Stoullx(s, endptr, base, nullptr);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xstrcoll.cpp b/msvc-stl/stl/src/xstrcoll.cpp
new file mode 100644
index 0000000..5d6e0ee
--- /dev/null
+++ b/msvc-stl/stl/src/xstrcoll.cpp
@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Compare two strings using the locale LC_COLLATE information.
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cerrno>
+#include <clocale>
+#include <crtdbg.h>
+#include <cstdlib>
+#include <cstring>
+#include <malloc.h>
+
+#include "awint.hpp"
+
+_EXTERN_C_UNLESS_PURE
+
+// int _Strcoll() - Collate locale strings
+//
+// Purpose:
+//     Compare two strings using the locale LC_COLLATE information.
+//     [ANSI].
+//
+//     In the C locale, strcoll() simply resolves to strcmp().
+//
+// Entry:
+//     const char* string1  = pointer to beginning of the first string
+//     const char* end1     = pointer past end of the first string
+//     const char* string2  = pointer to beginning of the second string
+//     const char* end2     = pointer past end of the second string
+//     const _Collvec* ploc = pointer to locale info
+//
+// Exit:
+//     Less than 0    = first string less than second string
+//     0              = strings are equal
+//     Greater than 0 = first string greater than second string
+//
+// Exceptions:
+//     _NLSCMPERROR = error
+//     errno = EINVAL
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Strcoll(
+    const char* string1, const char* end1, const char* string2, const char* end2, const _Collvec* ploc) noexcept {
+    int ret = 0;
+    UINT codepage;
+    int n1 = static_cast<int>(end1 - string1);
+    int n2 = static_cast<int>(end2 - string2);
+    const wchar_t* locale_name;
+
+    if (ploc == nullptr) {
+        locale_name = ___lc_locale_name_func()[LC_COLLATE];
+        codepage    = ___lc_collate_cp_func();
+    } else {
+        locale_name = ploc->_LocaleName;
+        codepage    = ploc->_Page;
+    }
+
+    if (locale_name == nullptr) {
+        int ans = memcmp(string1, string2, n1 < n2 ? n1 : n2);
+        ret     = (ans != 0 || n1 == n2 ? ans : n1 < n2 ? -1 : +1);
+    } else {
+        ret = __crtCompareStringA(locale_name, SORT_STRINGSORT, string1, n1, string2, n2, codepage);
+
+        if (ret == 0) {
+            errno = EINVAL;
+            ret   = _NLSCMPERROR;
+        } else {
+            ret -= 2;
+        }
+    }
+
+    return ret;
+}
+
+// _Collvec _Getcoll() - get collation info for current locale
+_CRTIMP2_PURE _Collvec __CLRCALL_PURE_OR_CDECL _Getcoll() noexcept {
+    _Collvec coll;
+
+    coll._Page       = ___lc_collate_cp_func();
+    coll._LocaleName = ___lc_locale_name_func()[LC_COLLATE];
+    if (coll._LocaleName) {
+        coll._LocaleName = _wcsdup_dbg(coll._LocaleName, _CRT_BLOCK, __FILE__, __LINE__);
+    }
+
+    return coll;
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xstrxfrm.cpp b/msvc-stl/stl/src/xstrxfrm.cpp
new file mode 100644
index 0000000..69209b5
--- /dev/null
+++ b/msvc-stl/stl/src/xstrxfrm.cpp
@@ -0,0 +1,96 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Transform a string using the locale information as set by LC_COLLATE.
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <clocale>
+#include <cstdlib>
+#include <cstring>
+#include <malloc.h>
+
+#include <Windows.h>
+
+#include "awint.hpp"
+
+_EXTERN_C_UNLESS_PURE
+
+// size_t _Strxfrm() - Transform a string using locale information
+//
+// Purpose:
+//     Transform the string pointed to by string2 and place the
+//     resulting string into the array pointed to by string1.
+//     No more than end1 - string1 characters are placed into the
+//     resulting string (including the null).
+//
+//     The transformation is such that if strcmp() is applied to
+//     the two transformed strings, the return value is equal to
+//     the result of strcoll() applied to the two original strings.
+//     Thus, the conversion must take the locale LC_COLLATE info
+//     into account.
+//     [ANSI]
+//
+//     The value of the following expression is the size of the array
+//     needed to hold the transformation of the source string:
+//
+//     1 + strxfrm(nullptr,string,0)
+//
+//     In the "C" locale, _Strxfrm() simply resolves to strncpy()/strlen().
+//
+// Entry:
+//     char* string1        = pointer to beginning of result string
+//     char* end1           = pointer past end of result string
+//     const char* string2  = pointer to beginning of source string
+//     const char* end2     = pointer past end of source string
+//     const _Collvec* ploc = pointer to locale info
+//
+// Exit:
+//     Length of the transformed string.
+//     If the value returned is too big, the contents of the
+//     string1 array are indeterminate.
+//
+// Exceptions:
+//     Non-standard: if OM/API error, return SIZE_MAX.
+_CRTIMP2_PURE size_t __CLRCALL_PURE_OR_CDECL _Strxfrm(
+    _Out_writes_(end1 - string1) _Post_readable_size_(return) char* string1, char* end1,
+    _In_reads_(end2 - string2) const char* string2, const char* end2, _In_opt_ const _Collvec* ploc) noexcept {
+    size_t n1     = end1 - string1;
+    size_t n2     = end2 - string2;
+    size_t retval = static_cast<size_t>(-1); // NON-ANSI: default if OM or API error
+    UINT codepage;
+    const wchar_t* locale_name;
+
+    if (ploc == nullptr) {
+        locale_name = ___lc_locale_name_func()[LC_COLLATE];
+        codepage    = ___lc_collate_cp_func();
+    } else {
+        locale_name = ploc->_LocaleName;
+        codepage    = ploc->_Page;
+    }
+
+    if (locale_name == nullptr && codepage == CP_ACP) {
+        if (n2 <= n1) {
+            memcpy(string1, string2, n2);
+        }
+        retval = n2;
+    } else {
+        // Inquire size of dst string in BYTES
+        const int dstlen =
+            __crtLCMapStringA(locale_name, LCMAP_SORTKEY, string2, static_cast<int>(n2), nullptr, 0, codepage, TRUE);
+
+        if (dstlen != 0) {
+            retval = dstlen;
+
+            // if not enough room, return amount needed
+            if (dstlen <= static_cast<int>(n1)) {
+                // Map src string to dst string
+                __crtLCMapStringA(locale_name, LCMAP_SORTKEY, string2, static_cast<int>(n2), string1,
+                    static_cast<int>(n1), codepage, TRUE);
+            }
+        }
+    }
+
+    return retval;
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xthrow.cpp b/msvc-stl/stl/src/xthrow.cpp
new file mode 100644
index 0000000..2ec0a3e
--- /dev/null
+++ b/msvc-stl/stl/src/xthrow.cpp
@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <functional>
+#include <new>
+#include <regex>
+#include <stdexcept>
+
+_STD_BEGIN
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc() {
+    _THROW(bad_alloc{});
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument(_In_z_ const char* const _Message) {
+    _THROW(invalid_argument(_Message));
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xlength_error(_In_z_ const char* const _Message) {
+    _THROW(length_error(_Message));
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range(_In_z_ const char* const _Message) {
+    _THROW(out_of_range(_Message));
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xoverflow_error(_In_z_ const char* const _Message) {
+    _THROW(overflow_error(_Message));
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xruntime_error(_In_z_ const char* const _Message) {
+    _THROW(runtime_error(_Message));
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_function_call() {
+    _THROW(bad_function_call{});
+}
+
+[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xregex_error(const regex_constants::error_type _Code) {
+    _THROW(regex_error(_Code));
+}
+_STD_END
diff --git a/msvc-stl/stl/src/xtime.cpp b/msvc-stl/stl/src/xtime.cpp
new file mode 100644
index 0000000..52ac582
--- /dev/null
+++ b/msvc-stl/stl/src/xtime.cpp
@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// _timespec64 functions for system time
+
+#include <atomic>
+#include <xtimec.h>
+
+#include <Windows.h>
+
+namespace {
+    constexpr long _Nsec_per_sec  = 1000000000L;
+    constexpr long _Nsec_per_msec = 1000000L;
+    constexpr int _Msec_per_sec   = 1000;
+
+    void _timespec64_normalize(_timespec64* xt) { // adjust so that 0 <= tv_nsec < 1 000 000 000
+        while (xt->tv_nsec < 0) { // normalize target time
+            xt->tv_sec -= 1;
+            xt->tv_nsec += _Nsec_per_sec;
+        }
+        while (_Nsec_per_sec <= xt->tv_nsec) { // normalize target time
+            xt->tv_sec += 1;
+            xt->tv_nsec -= _Nsec_per_sec;
+        }
+    }
+
+    // return _timespec64 object holding difference between xt and now, treating negative difference as 0
+    _timespec64 _timespec64_diff(const _timespec64* xt, const _timespec64* now) {
+        _timespec64 diff = *xt;
+        _timespec64_normalize(&diff);
+        if (diff.tv_nsec < now->tv_nsec) { // avoid underflow
+            diff.tv_sec -= now->tv_sec + 1;
+            diff.tv_nsec += _Nsec_per_sec - now->tv_nsec;
+        } else { // no underflow
+            diff.tv_sec -= now->tv_sec;
+            diff.tv_nsec -= now->tv_nsec;
+        }
+
+        if (diff.tv_sec < 0 || (diff.tv_sec == 0 && diff.tv_nsec <= 0)) { // time is zero
+            diff.tv_sec  = 0;
+            diff.tv_nsec = 0;
+        }
+        return diff;
+    }
+} // unnamed namespace
+
+extern "C" {
+
+_CRTIMP2_PURE long long __cdecl _Xtime_get_ticks() noexcept {
+    // get system time in 100-nanosecond intervals since the epoch
+    constexpr long long _Epoch = 0x19DB1DED53E8000LL;
+
+    FILETIME ft;
+    GetSystemTimePreciseAsFileTime(&ft);
+    return ((static_cast<long long>(ft.dwHighDateTime)) << 32) + static_cast<long long>(ft.dwLowDateTime) - _Epoch;
+}
+
+// Used by several src files, but not dllexported.
+void _Timespec64_get_sys(_timespec64* xt) noexcept { // get system time with nanosecond resolution
+    constexpr long _Nsec100_per_sec = _Nsec_per_sec / 100;
+
+    unsigned long long now = _Xtime_get_ticks();
+    xt->tv_sec             = static_cast<__time64_t>(now / _Nsec100_per_sec);
+    xt->tv_nsec            = static_cast<long>(now % _Nsec100_per_sec) * 100;
+}
+
+// convert time to milliseconds
+_CRTIMP2_PURE long __cdecl _Xtime_diff_to_millis2(const _timespec64* xt1, const _timespec64* xt2) noexcept {
+    _timespec64 diff = _timespec64_diff(xt1, xt2);
+    return static_cast<long>(diff.tv_sec * _Msec_per_sec + (diff.tv_nsec + _Nsec_per_msec - 1) / _Nsec_per_msec);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE long __cdecl _Xtime_diff_to_millis(const _timespec64* xt) noexcept { // convert time to milliseconds
+    _timespec64 now;
+    _Timespec64_get_sys(&now);
+    return _Xtime_diff_to_millis2(xt, &now);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE int __cdecl xtime_get(_timespec64* xt, int type) noexcept { // get current time
+    if (type != TIME_UTC || xt == nullptr) {
+        type = 0;
+    } else {
+        _Timespec64_get_sys(xt);
+    }
+
+    return type;
+}
+
+_CRTIMP2_PURE long long __cdecl _Query_perf_counter() noexcept { // get current value of performance counter
+    LARGE_INTEGER li;
+    QueryPerformanceCounter(&li); // always succeeds
+    return li.QuadPart;
+}
+
+_CRTIMP2_PURE long long __cdecl _Query_perf_frequency() noexcept { // get frequency of performance counter
+    static std::atomic<long long> freq_cached{0};
+    long long freq = freq_cached.load(std::memory_order_relaxed);
+    if (freq == 0) {
+        LARGE_INTEGER li;
+        QueryPerformanceFrequency(&li); // always succeeds
+        freq = li.QuadPart; // doesn't change after system boot
+        freq_cached.store(freq, std::memory_order_relaxed);
+    }
+    return freq;
+}
+
+} // extern "C"
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * (c) Copyright William E. Kempf 2001
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation. William E. Kempf makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ */
diff --git a/msvc-stl/stl/src/xtowlower.cpp b/msvc-stl/stl/src/xtowlower.cpp
new file mode 100644
index 0000000..3e6f8de
--- /dev/null
+++ b/msvc-stl/stl/src/xtowlower.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// _Towlower -- convert wchar_t to lower case
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cwchar>
+
+#include "awint.hpp"
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE wchar_t __CLRCALL_PURE_OR_CDECL _Towlower(wchar_t _Ch, const _Ctypevec* _Ctype) noexcept {
+    // convert element to lower case
+    wchar_t _Res = _Ch;
+    if (_Ch != WEOF) {
+        if (_Ctype->_LocaleName == nullptr && _Ch < 256) { // handle ASCII character in C locale
+            if (L'A' <= _Ch && _Ch <= L'Z') {
+                _Res = static_cast<wchar_t>(_Ch - L'A' + L'a');
+            }
+        } else if (__crtLCMapStringW(_Ctype->_LocaleName, LCMAP_LOWERCASE, &_Ch, 1, &_Res, 1) == 0) {
+            _Res = _Ch;
+        }
+    }
+
+    return _Res;
+}
+
+#ifdef MRTDLL
+_CRTIMP2_PURE unsigned short __CLRCALL_PURE_OR_CDECL _Towlower(unsigned short _Ch, const _Ctypevec* _Ctype) noexcept {
+    return _Towlower(static_cast<wchar_t>(_Ch), _Ctype);
+}
+#endif
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xtowupper.cpp b/msvc-stl/stl/src/xtowupper.cpp
new file mode 100644
index 0000000..382d8c1
--- /dev/null
+++ b/msvc-stl/stl/src/xtowupper.cpp
@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// _Towupper -- convert wchar_t to upper case
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cwchar>
+
+#include "awint.hpp"
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE wchar_t __CLRCALL_PURE_OR_CDECL _Towupper(wchar_t _Ch, const _Ctypevec* _Ctype) noexcept {
+    // convert element to upper case
+    wchar_t _Res = _Ch;
+    if (_Ch != WEOF) {
+        if (_Ctype->_LocaleName == nullptr && _Ch < 256) { // handle ASCII character in C locale
+            if (L'a' <= _Ch && _Ch <= L'z') {
+                _Res = static_cast<wchar_t>(_Ch - L'a' + L'A');
+            }
+        } else if (__crtLCMapStringW(_Ctype->_LocaleName, LCMAP_UPPERCASE, &_Ch, 1, &_Res, 1) == 0) {
+            _Res = _Ch;
+        }
+    }
+
+    return _Res;
+}
+
+#ifdef MRTDLL
+_CRTIMP2_PURE unsigned short __CLRCALL_PURE_OR_CDECL _Towupper(unsigned short _Ch, const _Ctypevec* _Ctype) noexcept {
+    return _Towupper(static_cast<wchar_t>(_Ch), _Ctype);
+}
+#endif
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xvalues.cpp b/msvc-stl/stl/src/xvalues.cpp
new file mode 100644
index 0000000..020c3c8
--- /dev/null
+++ b/msvc-stl/stl/src/xvalues.cpp
@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// values used by math functions -- IEEE 754 version
+
+#if defined(_M_CEE_PURE)
+#if defined(MRTDLL)
+#undef MRTDLL
+#endif
+#endif
+
+#include <yvals.h>
+
+_EXTERN_C_UNLESS_PURE
+
+// TRANSITION, ABI: preserved for binary compatibility
+union _Dconst { // pun float types as integer array
+    unsigned short _Word[8];
+    float _Float;
+    double _Double;
+    long double _Long_double;
+};
+extern _CRTIMP2_PURE _Dconst _Denorm  = {1, 0, 0, 0};
+extern _CRTIMP2_PURE _Dconst _LDenorm = {1, 0, 0, 0};
+extern _CRTIMP2_PURE _Dconst _Hugeval = {0, 0, 0, 0x7ff0};
+extern _CRTIMP2_PURE _Dconst _Inf     = {0, 0, 0, 0x7ff0};
+extern _CRTIMP2_PURE _Dconst _LInf    = {0, 0, 0, 0x7ff0};
+extern _CRTIMP2_PURE _Dconst _Nan     = {0, 0, 0, 0x7ff8};
+extern _CRTIMP2_PURE _Dconst _LNan    = {0, 0, 0, 0x7ff8};
+extern _CRTIMP2_PURE _Dconst _Snan    = {1, 0, 0, 0x7ff0};
+extern _CRTIMP2_PURE _Dconst _LSnan   = {1, 0, 0, 0x7ff0};
+extern _CRTIMP2_PURE _Dconst _FDenorm = {1, 0};
+extern _CRTIMP2_PURE _Dconst _FInf    = {0, 0x7f80};
+extern _CRTIMP2_PURE _Dconst _FNan    = {0, 0x7fc0};
+extern _CRTIMP2_PURE _Dconst _FSnan   = {1, 0x7f80};
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xwcscoll.cpp b/msvc-stl/stl/src/xwcscoll.cpp
new file mode 100644
index 0000000..9cfdc5d
--- /dev/null
+++ b/msvc-stl/stl/src/xwcscoll.cpp
@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Compare two wchar_t strings using the locale LC_COLLATE information.
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cerrno>
+#include <clocale>
+#include <cstdlib>
+#include <cwchar>
+
+#include "awint.hpp"
+
+_EXTERN_C_UNLESS_PURE
+
+// int _Wcscoll() - Collate wide-character locale strings
+//
+// Purpose:
+//     Compare two wchar_t strings using the locale LC_COLLATE information.
+//     In the C locale, wcscmp() is used to make the comparison.
+//
+// Entry:
+//     const wchar_t* string1  = pointer to beginning of the first string
+//     const wchar_t* end1     = pointer past end of the first string
+//     const wchar_t* string2  = pointer to beginning of the second string
+//     const wchar_t* end2     = pointer past end of the second string
+//     const _Collvec* ploc    = pointer to locale info
+//
+// Exit:
+//     -1 = first string less than second string
+//     0 = strings are equal
+//     1 = first string greater than second string
+//     This range of return values may differ from other *cmp / *coll functions.
+//
+// Exceptions:
+//     _NLSCMPERROR = error
+//     errno = EINVAL
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Wcscoll(const wchar_t* string1, const wchar_t* end1, const wchar_t* string2,
+    const wchar_t* end2, const _Collvec* ploc) noexcept {
+    int n1  = static_cast<int>(end1 - string1);
+    int n2  = static_cast<int>(end2 - string2);
+    int ret = 0;
+    const wchar_t* locale_name;
+
+    if (ploc == nullptr) {
+        locale_name = ___lc_locale_name_func()[LC_COLLATE];
+    } else {
+        locale_name = ploc->_LocaleName;
+    }
+
+    if (locale_name == nullptr) {
+        int ans = wmemcmp(string1, string2, n1 < n2 ? n1 : n2);
+        ret     = (ans != 0 || n1 == n2 ? ans : n1 < n2 ? -1 : +1);
+    } else {
+        ret = __crtCompareStringW(locale_name, SORT_STRINGSORT, string1, n1, string2, n2);
+
+        if (ret == 0) {
+            errno = EINVAL;
+            ret   = _NLSCMPERROR;
+        } else {
+            ret -= 2;
+        }
+    }
+
+    return ret;
+}
+
+#ifdef MRTDLL
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Wcscoll(const unsigned short* string1, const unsigned short* end1,
+    const unsigned short* string2, const unsigned short* end2, const _Collvec* ploc) noexcept {
+    return _Wcscoll(reinterpret_cast<const wchar_t*>(string1), reinterpret_cast<const wchar_t*>(end1),
+        reinterpret_cast<const wchar_t*>(string2), reinterpret_cast<const wchar_t*>(end2), ploc);
+}
+#endif // defined(MRTDLL)
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xwcsxfrm.cpp b/msvc-stl/stl/src/xwcsxfrm.cpp
new file mode 100644
index 0000000..4b2e9b5
--- /dev/null
+++ b/msvc-stl/stl/src/xwcsxfrm.cpp
@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Transform a wide-character string using the locale information as set by LC_COLLATE.
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <climits>
+#include <clocale>
+#include <cstdlib>
+#include <cstring>
+#include <internal_shared.h>
+
+#include "awint.hpp"
+
+_EXTERN_C_UNLESS_PURE
+
+// size_t _Wcsxfrm() - Transform a string using locale information
+//
+// Purpose:
+//     Transform the wide string pointed to by string2 and place the
+//     resulting wide string into the array pointed to by string1.
+//     No more than end1 - string1 wide characters are placed into the
+//     resulting string (including the null).
+//
+//     The transformation is such that if wcscmp() is applied to
+//     the two transformed strings, the return value is equal to
+//     the result of wcscoll() applied to the two original strings.
+//     Thus, the conversion must take the locale LC_COLLATE info
+//     into account.
+//
+//     In the C locale, wcsxfrm() simply resolves to wcsncpy()/wcslen().
+//
+// Entry:
+//     wchar_t* string1        = pointer to beginning of result string
+//     wchar_t* end1           = pointer past end of result string
+//     const wchar_t* string2  = pointer to beginning of source string
+//     const wchar_t* end2     = pointer past end of source string
+//     const _Collvec* ploc    = pointer to locale info
+//
+// Exit:
+//     Length of the transformed string.
+//     If the value returned is too big, the contents of the
+//     string1 array are indeterminate.
+//
+// Exceptions:
+//     Non-standard: if OM/API error, return SIZE_MAX.
+_CRTIMP2_PURE size_t __CLRCALL_PURE_OR_CDECL _Wcsxfrm(
+    _Out_writes_(end1 - string1) _Post_readable_size_(return) wchar_t* string1, wchar_t* end1,
+    _In_reads_(end2 - string2) const wchar_t* string2, const wchar_t* end2, _In_opt_ const _Collvec* ploc) noexcept {
+    size_t n1   = end1 - string1;
+    size_t n2   = end2 - string2;
+    size_t size = static_cast<size_t>(-1);
+    const wchar_t* locale_name;
+
+    if (ploc == nullptr) {
+        locale_name = ___lc_locale_name_func()[LC_COLLATE];
+    } else {
+        locale_name = ploc->_LocaleName;
+    }
+
+    if (locale_name == nullptr) {
+        if (n2 <= n1) {
+            memcpy(string1, string2, n2 * sizeof(wchar_t));
+        }
+        size = n2;
+    } else {
+        // When using LCMAP_SORTKEY, LCMapStringW handles BYTES not wide
+        // chars. We use a byte buffer to hold bytes and then convert the
+        // byte string to a wide char string and return this so it can be
+        // compared using wcscmp(). User's buffer is n1 wide chars, so
+        // use an internal buffer of n1 bytes.
+
+        auto bbuffer = _malloc_crt_t(unsigned char, n1);
+
+        if (bbuffer) {
+#pragma warning(push)
+#pragma warning(disable : 6386) // PREfast doesn't understand LCMAP_SORTKEY
+            size = __crtLCMapStringW(locale_name, LCMAP_SORTKEY, string2, static_cast<int>(n2),
+                reinterpret_cast<wchar_t*>(bbuffer.get()), static_cast<int>(n1));
+#pragma warning(pop)
+
+            if (size == 0) {
+                // buffer not big enough, get size required.
+                size = __crtLCMapStringW(locale_name, LCMAP_SORTKEY, string2, static_cast<int>(n2), nullptr, 0);
+
+                if (size == 0) {
+                    size = static_cast<size_t>(-1); // default error
+                }
+            } else {
+                // string successfully mapped, convert to wide char
+
+                for (size_t i = 0; i < size; ++i) {
+                    string1[i] = static_cast<wchar_t>(bbuffer.get()[i]);
+                }
+            }
+        }
+    }
+
+    return size;
+}
+
+#ifdef MRTDLL
+_CRTIMP2_PURE size_t __CLRCALL_PURE_OR_CDECL _Wcsxfrm(unsigned short* string1, unsigned short* end1,
+    const unsigned short* string2, const unsigned short* end2, const _Collvec* ploc) noexcept {
+    return _Wcsxfrm(reinterpret_cast<wchar_t*>(string1), reinterpret_cast<wchar_t*>(end1),
+        reinterpret_cast<const wchar_t*>(string2), reinterpret_cast<const wchar_t*>(end2), ploc);
+}
+#endif // defined(MRTDLL)
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xwctomb.cpp b/msvc-stl/stl/src/xwctomb.cpp
new file mode 100644
index 0000000..e1a87fb
--- /dev/null
+++ b/msvc-stl/stl/src/xwctomb.cpp
@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Convert wide character to multibyte character, with locale.
+
+#include <yvals.h>
+
+#include <__msvc_xlocinfo_types.hpp>
+#include <cerrno>
+#include <climits> // for MB_LEN_MAX
+#include <clocale>
+#include <cstdlib>
+#include <mbctype.h>
+
+#include <Windows.h>
+
+_EXTERN_C_UNLESS_PURE
+
+_CRTIMP2_PURE _Cvtvec __CLRCALL_PURE_OR_CDECL _Getcvt() noexcept { // get conversion info for current locale
+    _Cvtvec _Cvt = {0};
+
+    _Cvt._Page      = ___lc_codepage_func();
+    _Cvt._Mbcurmax  = ___mb_cur_max_func();
+    _Cvt._Isclocale = ___lc_locale_name_func()[LC_CTYPE] == nullptr;
+
+    if (!_Cvt._Isclocale) {
+        const unsigned short* const _Ctype_table = __pctype_func();
+        for (int _Idx = 0; _Idx < 256; ++_Idx) {
+            if (_Ctype_table[_Idx] & _LEADBYTE) {
+                _Cvt._Isleadbyte[_Idx >> 3] |= 1 << (_Idx & 7);
+            }
+        }
+    }
+
+    return _Cvt;
+}
+
+// int _Wcrtomb() - Convert wide character to multibyte character.
+//
+// Purpose:
+//     Convert a wide character into the equivalent multi-byte character,
+//     according to the specified LC_CTYPE category, or the current locale.
+//     [ANSI].
+//
+// Entry:
+//     char* s             = pointer to multibyte character
+//     wchar_t wchar       = source wide character
+//     mbstate_t* pst      = pointer to state (not used)
+//     const _Cvtvec* ploc = pointer to locale info
+//
+// Exit:
+// Returns:
+//     -1 (if error) or number of bytes comprising converted mbc
+//
+// Exceptions:
+//     None.
+
+_CRTIMP2_PURE _Success_(return != -1) int __CLRCALL_PURE_OR_CDECL
+    _Wcrtomb(_Out_ char* s, wchar_t wchar, mbstate_t* pst, const _Cvtvec* ploc) noexcept {
+    _CRT_UNUSED(pst);
+    if (ploc->_Isclocale) {
+        if (wchar > 255) { // validate high byte
+            errno = EILSEQ;
+            return -1;
+        }
+
+        *s = static_cast<char>(wchar);
+        return sizeof(char);
+    } else {
+        BOOL defused = 0;
+        _Cvtvec cvtvec;
+
+        if (ploc == nullptr) {
+            cvtvec = _Getcvt();
+            ploc   = &cvtvec;
+        }
+
+        const int size = WideCharToMultiByte(ploc->_Page, 0, &wchar, 1, s, ploc->_Mbcurmax, nullptr, &defused);
+        if (size == 0 || defused) {
+            errno = EILSEQ;
+            return -1;
+        }
+
+        return size;
+    }
+}
+
+#ifdef MRTDLL
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Wcrtomb(
+    char* s, unsigned short wchar, mbstate_t* pst, const _Cvtvec* ploc) noexcept {
+    return _Wcrtomb(s, static_cast<wchar_t>(wchar), pst, ploc);
+}
+#endif // defined(MRTDLL)
+
+// TRANSITION, ABI: __Wcrtomb_lk() is preserved for binary compatibility
+_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL __Wcrtomb_lk(
+    char* s, wchar_t wchar, mbstate_t* pst, const _Cvtvec* ploc) noexcept {
+    return _Wcrtomb(s, wchar, pst, ploc);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xwstod.cpp b/msvc-stl/stl/src/xwstod.cpp
new file mode 100644
index 0000000..4cd3ece
--- /dev/null
+++ b/msvc-stl/stl/src/xwstod.cpp
@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cmath>
+#include <cwchar>
+
+_EXTERN_C_UNLESS_PURE
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _WStodx(
+    const wchar_t* _Str, wchar_t** _Endptr, long _Pten, int* _Perr) noexcept {
+    int& _Errno_ref = errno; // Nonzero cost, pay it once
+    const int _Orig = _Errno_ref;
+
+    _Errno_ref  = 0;
+    double _Val = _CSTD wcstod(_Str, _Endptr);
+    *_Perr      = _Errno_ref;
+    _Errno_ref  = _Orig;
+
+    if (_Pten != 0) {
+        _Val *= _CSTD pow(10.0, static_cast<double>(_Pten));
+    }
+
+    return _Val;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _WStod(const wchar_t* s, wchar_t** endptr, long pten) noexcept {
+    return _WStodx(s, endptr, pten, nullptr);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _WStoldx(
+    const wchar_t* s, wchar_t** endptr, long pten, int* perr) noexcept {
+    return _WStodx(s, endptr, pten, perr);
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _WStold(const wchar_t* s, wchar_t** endptr, long pten) noexcept {
+    return _WStodx(s, endptr, pten, nullptr);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/msvc-stl/stl/src/xwstof.cpp b/msvc-stl/stl/src/xwstof.cpp
new file mode 100644
index 0000000..d212032
--- /dev/null
+++ b/msvc-stl/stl/src/xwstof.cpp
@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cmath>
+#include <cwchar>
+
+_EXTERN_C_UNLESS_PURE
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _WStofx(
+    const wchar_t* _Str, wchar_t** _Endptr, long _Pten, int* _Perr) noexcept {
+    int& _Errno_ref = errno; // Nonzero cost, pay it once
+    const int _Orig = _Errno_ref;
+
+    _Errno_ref = 0;
+    float _Val = _CSTD wcstof(_Str, _Endptr);
+    *_Perr     = _Errno_ref;
+    _Errno_ref = _Orig;
+
+    if (_Pten != 0) {
+        _Val *= _CSTD powf(10.0f, static_cast<float>(_Pten));
+    }
+
+    return _Val;
+}
+
+// TRANSITION, ABI: preserved for binary compatibility
+_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _WStof(const wchar_t* s, wchar_t** endptr, long pten) noexcept {
+    return _WStofx(s, endptr, pten, nullptr);
+}
+
+_END_EXTERN_C_UNLESS_PURE
diff --git a/solutions/cpp11/00-auto-and-decltype-0.cpp b/solutions/cpp11/00-auto-and-decltype-0.cpp
index 743141d..43ab73d 100644
--- a/solutions/cpp11/00-auto-and-decltype-0.cpp
+++ b/solutions/cpp11/00-auto-and-decltype-0.cpp
@@ -22,12 +22,13 @@ int main() {
     char c = 'c';
     auto c1 = c;          // c1: char
     decltype(c) c2 = c;   // c2: char
-    (void)c1; (void)c2;
 
     d2x_assert_eq(a, a1);
     d2x_assert_eq(a1, a2);
     d2x_assert_eq(b, b1);
     d2x_assert_eq(b1, b2);
+    d2x_assert_eq(c, c1);
+    d2x_assert_eq(c1, c2);
 
     return 0;
 }
diff --git a/solutions/cpp11/00-auto-and-decltype-5.cpp b/solutions/cpp11/00-auto-and-decltype-5.cpp
new file mode 100644
index 0000000..fe6a5ec
--- /dev/null
+++ b/solutions/cpp11/00-auto-and-decltype-5.cpp
@@ -0,0 +1,44 @@
+// d2mcpp: https://github.com/mcpp-community/d2mcpp
+// license: Apache-2.0
+// reference solution for: dslings/cpp11/00-auto-and-decltype-5.cpp
+//
+// 用途: 仅给 CI 与维护者参考使用，不是教程入口。
+// 教程练习入口: dslings/cpp11/00-auto-and-decltype-5.cpp
+//
+
+#include <d2x/cpp/common.hpp>
+
+#include <type_traits>
+
+
+// 5. const 与引用的剥离和保留
+
+int main() {
+    const int ci = 1;
+    int n = 2;
+    int& ri = n;
+
+    bool type_check = false;
+
+    // auto 剥离顶层 const: a 推导成 int
+    auto a = ci;
+    type_check = std::is_same<decltype(a), int>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // auto 剥离引用: b 推导成 int (b 是 n 的独立副本)
+    auto b = ri;
+    type_check = std::is_same<decltype(b), int>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // 用 const auto& 保留 const 引用 const int&
+    const auto& cr = ci;
+    type_check = std::is_same<decltype(cr), const int &>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    // 用 decltype 精确保留声明类型 const int
+    decltype(ci) d = ci;
+    type_check = std::is_same<decltype(d), const int>::value;
+    d2x_assert(type_check); type_check = false; // dont change this line
+
+    return 0;
+}
diff --git a/solutions/cpp11/xmake.lua b/solutions/cpp11/xmake.lua
index 5b934eb..6cfcfce 100644
--- a/solutions/cpp11/xmake.lua
+++ b/solutions/cpp11/xmake.lua
@@ -27,6 +27,9 @@ target("cpp11-00-auto-and-decltype-3-ref")
 target("cpp11-00-auto-and-decltype-4-ref")
     add_files("00-auto-and-decltype-4.cpp")
 
+target("cpp11-00-auto-and-decltype-5-ref")
+    add_files("00-auto-and-decltype-5.cpp")
+
 -- target: cpp11-01-default-and-delete
 
 target("cpp11-01-default-and-delete-0-ref")
diff --git a/xmake.lua b/xmake.lua
index d54015e..e37aca0 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -3,4 +3,4 @@ add_plugindirs("d2x/buildtools")
 add_includedirs(".")
 
 includes("dslings/xmake.lua")
-includes("solutions/xmake.lua")
\ No newline at end of file
+--includes("solutions/xmake.lua")
\ No newline at end of file