From 84bf514ceba6feca424d26153dd6f132b7c192f7 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 09:01:05 -0700
Subject: [PATCH 01/39] Cycle locations.

---
 azure-devops/create-1es-hosted-pool.ps1 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-devops/create-1es-hosted-pool.ps1 b/azure-devops/create-1es-hosted-pool.ps1
index 80cdd74911..d5b2519b37 100644
--- a/azure-devops/create-1es-hosted-pool.ps1
+++ b/azure-devops/create-1es-hosted-pool.ps1
@@ -48,7 +48,7 @@ if ($VMSku -ieq 'Fasv6') {
   $AvailableLocations = @('eastus2', 'northeurope') # Locations where CPP_STL_GitHub has quota for 1024 cores (32 VMs).
 }
 
-$AvailableLocationIdx = 5 # Increment for each new set of pools, to cycle through the available locations.
+$AvailableLocationIdx = 6 # Increment for each new set of pools, to cycle through the available locations.
 $Location = $AvailableLocations[$AvailableLocationIdx % $AvailableLocations.Length]
 
 if ($Arch -ieq 'x64') {

From 333249fc5e751f23cd023284559685fab8095021 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 09:13:01 -0700
Subject: [PATCH 02/39] CUDA 13.2 (now required).

---
 azure-devops/provision-image.ps1                   | 2 +-
 stl/inc/yvals_core.h                               | 4 ++--
 tests/std/tests/GH_000639_nvcc_include_all/env.lst | 3 +--
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/azure-devops/provision-image.ps1 b/azure-devops/provision-image.ps1
index 2429644b0f..03a664c612 100644
--- a/azure-devops/provision-image.ps1
+++ b/azure-devops/provision-image.ps1
@@ -74,7 +74,7 @@ $PythonArgs = @('/quiet', 'InstallAllUsers=1', 'PrependPath=1', 'CompileAll=1',
 
 # https://developer.nvidia.com/cuda-toolkit
 if ($Provisioning_x64) {
-  $CudaUrl = 'https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_551.61_windows.exe'
+  $CudaUrl = 'https://developer.download.nvidia.com/compute/cuda/13.2.0/local_installers/cuda_13.2.0_windows.exe'
 } else {
   $CudaUrl = 'CUDA is not installed for ARM64'
 }
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index a47ce4cca1..f5648c52f4 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -894,8 +894,8 @@
 
 #ifndef _ALLOW_COMPILER_AND_STL_VERSION_MISMATCH
 #if defined(__CUDACC__) && defined(__CUDACC_VER_MAJOR__)
-#if __CUDACC_VER_MAJOR__ < 12 || (__CUDACC_VER_MAJOR__ == 12 && __CUDACC_VER_MINOR__ < 4)
-_EMIT_STL_ERROR(STL1002, "Unexpected compiler version, expected CUDA 12.4 or newer.");
+#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
diff --git a/tests/std/tests/GH_000639_nvcc_include_all/env.lst b/tests/std/tests/GH_000639_nvcc_include_all/env.lst
index b58d105f34..d2f0a5adb9 100644
--- a/tests/std/tests/GH_000639_nvcc_include_all/env.lst
+++ b/tests/std/tests/GH_000639_nvcc_include_all/env.lst
@@ -1,8 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-# TRANSITION, CUDA 12.4 rejected MSVC Compiler 19.50 as unsupported, so we need --allow-unsupported-compiler
-PM_COMPILER="nvcc" PM_CL="--x cu -Xcompiler -Od,-EHsc,-nologo,-W4,-WX,-openmp --allow-unsupported-compiler"
+PM_COMPILER="nvcc" PM_CL="--x cu -Xcompiler -Od,-EHsc,-nologo,-W4,-WX,-openmp"
 RUNALL_CROSSLIST
 PM_CL="-Xcompiler -MT"
 PM_CL="--debug -Xcompiler -MTd"

From b76a37823e5ba2c5b0508476f7da564c2cd1c1a2 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 09:17:35 -0700
Subject: [PATCH 03/39] CMake 4.2.3 (now required).

---
 CMakeLists.txt                | 2 +-
 benchmarks/CMakeLists.txt     | 2 +-
 tools/CMakeLists.txt          | 2 +-
 tools/format/CMakeLists.txt   | 2 +-
 tools/validate/CMakeLists.txt | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4ae54d0071..b433aa72ec 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-cmake_minimum_required(VERSION 4.2.1)
+cmake_minimum_required(VERSION 4.2.3)
 
 set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 project(msvc_standard_libraries LANGUAGES CXX)
diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt
index ad9b1f0a43..0470518a0f 100644
--- a/benchmarks/CMakeLists.txt
+++ b/benchmarks/CMakeLists.txt
@@ -1,7 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-cmake_minimum_required(VERSION 4.2.1)
+cmake_minimum_required(VERSION 4.2.3)
 project(msvc_standard_libraries_benchmarks LANGUAGES CXX)
 
 if(DEFINED STL_BINARY_DIR)
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
index 5eb8ec12ae..46b85cf616 100644
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@@ -1,7 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-cmake_minimum_required(VERSION 4.2.1)
+cmake_minimum_required(VERSION 4.2.3)
 project(msvc_standard_libraries_tools LANGUAGES CXX)
 
 add_subdirectory(format)
diff --git a/tools/format/CMakeLists.txt b/tools/format/CMakeLists.txt
index be3bfa9ea8..8e2ed27a9b 100644
--- a/tools/format/CMakeLists.txt
+++ b/tools/format/CMakeLists.txt
@@ -1,7 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-cmake_minimum_required(VERSION 4.2.1)
+cmake_minimum_required(VERSION 4.2.3)
 project(msvc_standard_libraries_format NONE)
 
 find_program(CLANG_FORMAT
diff --git a/tools/validate/CMakeLists.txt b/tools/validate/CMakeLists.txt
index 12a182ce6b..7232bcdba3 100644
--- a/tools/validate/CMakeLists.txt
+++ b/tools/validate/CMakeLists.txt
@@ -1,7 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-cmake_minimum_required(VERSION 4.2.1)
+cmake_minimum_required(VERSION 4.2.3)
 project(msvc_standard_libraries_validate LANGUAGES CXX)
 
 add_executable(validate-binary validate.cpp)

From d5271b43ca55342a1dd486042e078727f8806d40 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 09:19:11 -0700
Subject: [PATCH 04/39] MSVC Compiler 19.51.36122 (now required).

Internal toolset is still 19.50.
---
 CMakeLists.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b433aa72ec..81684cf77e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,8 +6,8 @@ cmake_minimum_required(VERSION 4.2.3)
 set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 project(msvc_standard_libraries LANGUAGES CXX)
 
-if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.51.36014")
-    message(FATAL_ERROR "The STL must be built with MSVC Compiler 19.51.36014 or later.")
+if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.51.36122")
+    message(FATAL_ERROR "The STL must be built with MSVC Compiler 19.51.36122 or later.")
 endif()
 
 include(CheckCXXSourceCompiles)

From d4aff74c048c584bc6b4ee478981a0e39ef2be8d Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 10:19:58 -0700
Subject: [PATCH 05/39] New pools.

---
 azure-devops/config.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/azure-devops/config.yml b/azure-devops/config.yml
index 81067e751b..c3961a3ae1 100644
--- a/azure-devops/config.yml
+++ b/azure-devops/config.yml
@@ -5,13 +5,13 @@
 
 variables:
 - name: x64SlowPoolName
-  value: 'Stl-2026-02-20T0952-x64-Pool'
+  value: 'Stl-2026-03-11T0936-x64-Fasv6-Pool'
   readonly: true
 - name: x64FastPoolName
-  value: 'Stl-2026-02-24T1452-x64-Fasv7-Pool'
+  value: 'Stl-2026-03-11T0936-x64-Fasv7-Pool'
   readonly: true
 - name: arm64PoolName
-  value: 'Stl-2026-02-20T0952-arm64-Pool'
+  value: 'Stl-2026-03-11T0936-arm64-Dpsv6-Pool'
   readonly: true
 - name: poolDemands
   value: 'EnableSpotVM -equals false'

From 75452eebe2b5621866e6da74ef6bce4ff86e804c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 13 Mar 2026 09:31:03 -0700
Subject: [PATCH 06/39] cxx23-feature.md: Delete.

Users have occasionally misused this, it's outdated for C++26, and it isn't a huge time-saver anyways.
---
 .github/ISSUE_TEMPLATE/cxx23-feature.md | 26 -------------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 .github/ISSUE_TEMPLATE/cxx23-feature.md

diff --git a/.github/ISSUE_TEMPLATE/cxx23-feature.md b/.github/ISSUE_TEMPLATE/cxx23-feature.md
deleted file mode 100644
index 2d9002a313..0000000000
--- a/.github/ISSUE_TEMPLATE/cxx23-feature.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-name: cxx23 Feature
-about: For STL maintainers only
-title: PAPER_NUMBER PAPER_TITLE
-labels: cxx23
-assignees: ''
-
----
-
-**NOTE**
-This issue template is for STL maintainers only.
-Please use the Bug Report template instead.
-
-
-[PAPER_NUMBER](https://wg21.link/PAPER_NUMBER) PAPER_TITLE
-
-Note: If this link appears to be broken, don't worry! Papers are often
-revised during a WG21 meeting before the final vote. When that happens,
-there's a delay of a few weeks between the end of the meeting
-and the publication of the papers. When the papers are available,
-the https://wg21.link redirector will start working.
-
-Feature-test macro:
-```cpp
-#define MACRO_NAME MACRO_VALUE
-```

From 887dc53c9c2c8d26b4adb4b131ce5b3722ac1531 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 13 Mar 2026 09:37:35 -0700
Subject: [PATCH 07/39] README.md, CMakeLists.txt: Improve guidance for the
 Preview build tools.

If the compiler or WinSDK version checks fail, we should point to the README's centralized explanation of the VS Installer and `vcvarsall.bat` options.
---
 CMakeLists.txt |  4 ++--
 README.md      | 11 ++++++++---
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 81684cf77e..7c4b587a24 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,7 +7,7 @@ set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 project(msvc_standard_libraries LANGUAGES CXX)
 
 if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.51.36122")
-    message(FATAL_ERROR "The STL must be built with MSVC Compiler 19.51.36122 or later.")
+    message(FATAL_ERROR "The STL must be built with MSVC Compiler 19.51.36122 or later. Follow the README instructions.")
 endif()
 
 include(CheckCXXSourceCompiles)
@@ -18,7 +18,7 @@ int main() {}
 ]=] WINDOWS_SDK_VERSION_CHECK)
 
 if(NOT WINDOWS_SDK_VERSION_CHECK)
-    message(FATAL_ERROR "The STL must be built with the Windows 11 SDK (10.0.26100) or later. Make sure it's available by selecting it in the Individual Components tab of the VS Installer.")
+    message(FATAL_ERROR "The STL must be built with the Windows 11 SDK (10.0.26100) or later. Follow the README instructions.")
 endif()
 
 if(NOT DEFINED VCLIBS_TARGET_ARCHITECTURE)
diff --git a/README.md b/README.md
index 47fe7294cf..0d4c398649 100644
--- a/README.md
+++ b/README.md
@@ -142,7 +142,7 @@ Just try to follow these rules, so we can spend more time fixing bugs and implem
 # Visual Studio Installer Prerequisites
 
 * Install [VS 2026 Insiders][] and keep it up to date.
-  + **You must install Insiders for STL development.** *See Note 1 below.*
+  + **You must install the Insiders IDE and the Preview build tools for STL development.** *See Note 1 below.*
   + Select the "Desktop development with C++" workload.
   + Select the following components at a minimum:
     - "MSVC Build Tools for x64/x86 (Preview)"
@@ -155,8 +155,12 @@ Just try to follow these rules, so we can spend more time fixing bugs and implem
   + Select "Add python.exe to PATH" if you want to follow the instructions below that invoke `python`.
     Otherwise, you should be familiar with alternative methods.
 
-*Note 1:* The STL and the compiler ship together, and we frequently need the latest
-compiler fixes and features, so the last production release of the compiler is too old.
+*Note 1:* The STL and the compiler ship together, and we frequently need recently implemented
+compiler fixes and features, so the Latest build tools (i.e. latest production) are too old.
+Because the Insiders IDE supports having the Latest and Preview build tools installed simultaneously,
+you need to ensure that you're using the Preview build tools. If you build with the IDE, we've arranged for
+this to happen automatically. If you build with the Command Prompt, you need to pass `-vcvars_ver=preview`
+as explained below. For more info, read the [C++ Team Blog post][preview] that announced this release process.
 
 *Note 2:* The x64/x86 build tools are usually sufficient.
 You'll need the ARM64/ARM64EC build tools if you're working with architecture-sensitive code.
@@ -627,3 +631,4 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 [VS 2026 Insiders]: https://visualstudio.microsoft.com/insiders/
 [CXXFLAGS]: https://cmake.org/cmake/help/latest/envvar/CXXFLAGS.html
 [start-command]: https://learn.microsoft.com/windows-server/administration/windows-commands/start
+[preview]: https://devblogs.microsoft.com/cppblog/microsoft-c-msvc-build-tools-v14-51-preview-released-how-to-opt-in/

From 4878def21489f908ff7ccb394406f1fb8561c51a Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 13 Mar 2026 11:11:11 -0700
Subject: [PATCH 08/39] bug-report.md: Recommend the Latest or Preview version.

---
 .github/ISSUE_TEMPLATE/bug-report.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/ISSUE_TEMPLATE/bug-report.md b/.github/ISSUE_TEMPLATE/bug-report.md
index 97b57aaa2d..4f827180d9 100644
--- a/.github/ISSUE_TEMPLATE/bug-report.md
+++ b/.github/ISSUE_TEMPLATE/bug-report.md
@@ -13,6 +13,10 @@ read the guidelines for submitting STL bug reports in `README.md`. If you are
 having problems with any component that is not the STL, instructions to get
 to the right place are there.
 
+Even if your project is using an older version of the MSVC Build Tools, please
+check the Latest production release (or better yet, the Preview release) before
+reporting bugs. This will save time by avoiding reports of already-fixed bugs.
+
 # Command-line test case
 ```
 C:\Temp>type repro.cpp

From 347749519ddaba5cea66b728aafed05b040a8b02 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 13 Mar 2026 12:11:35 -0700
Subject: [PATCH 09/39] pull_request_template.md: Add AI guidance.

---
 .github/pull_request_template.md | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 411e82a94b..bead761b0f 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,5 +1,19 @@
-<!--
-Before submitting a pull request, please ensure that:
+<!-- Before submitting a pull request, please ensure that:
+
+* Any AI-generated code has been clearly disclosed in your PR description.
+  We strongly discourage AI-generated changes to product code because the STL
+  is a highly unusual codebase with complex correctness and performance
+  requirements imposed by the Standard, and highly unusual code patterns that
+  don't look like typical codebases. Our intensive code review process
+  (to avoid bugs) is intentionally a bottleneck, so we ask that you be
+  considerate of the time and effort that we'll need to spend, by starting
+  with changes that you fully understand. Test code has weaker requirements,
+  so AI-generated changes for tests can be acceptable if properly disclosed.
+
+* Your PR description explains your intent behind the changes.
+  We discourage AI-generated PR descriptions because we can read the changes,
+  and we have access to the same AI tools that you have, so we can get
+  an AI-generated summary if we want.
 
 * Identifiers in product code changes are properly `_Ugly` as per
   https://eel.is/c++draft/lex.name#3.1 or there are no product code changes.

From a04545014bbd8f860920ece8073cf3df677dae23 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 12 Mar 2026 05:08:03 -0700
Subject: [PATCH 10/39] Azure Pipelines: Consolidate Setup TMP Directory into
 Clean After Checkout.

Deleting and recreating tmpDir is essentially cleaning, so we don't need to adjust the displayName.

The checkout doesn't use tmpDir, so we can do this in any order.

This will avoid displaying an extremely boring step in Azure Pipelines.
---
 azure-devops/checkout-self.yml | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/azure-devops/checkout-self.yml b/azure-devops/checkout-self.yml
index 9939678389..d108e66452 100644
--- a/azure-devops/checkout-self.yml
+++ b/azure-devops/checkout-self.yml
@@ -2,17 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 steps:
-- task: PowerShell@2
-  displayName: 'Setup TMP Directory'
-  inputs:
-    pwsh: true
-    targetType: inline
-    script: |
-      $PSNativeCommandUseErrorActionPreference = $true
-      if (Test-Path -LiteralPath "$(tmpDir)") {
-          Remove-Item -LiteralPath "$(tmpDir)" -Recurse -Force
-      }
-      mkdir "$(tmpDir)" -Force | Out-Null
 - checkout: self
   clean: true
   submodules: false
@@ -27,3 +16,7 @@ steps:
     script: |
       $PSNativeCommandUseErrorActionPreference = $true
       git clean --quiet -x -d -f -f
+      if (Test-Path -LiteralPath "$(tmpDir)") {
+          Remove-Item -LiteralPath "$(tmpDir)" -Recurse -Force
+      }
+      mkdir "$(tmpDir)" -Force | Out-Null

From 988d050daebf76f9b85c64cba351e2244997d8a8 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 12:18:07 -0700
Subject: [PATCH 11/39] All: Avoid warnings about comparing unsigned integers
 with zero.

MSVC warning C4296: '<': expression is always false
CUDA warning 186-D: pointless comparison of unsigned integer with zero
---
 stl/inc/__msvc_iter_core.hpp |  3 +++
 stl/inc/format               | 22 +++++++++++++---------
 stl/inc/xstring              |  7 +++++--
 3 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/stl/inc/__msvc_iter_core.hpp b/stl/inc/__msvc_iter_core.hpp
index 812c00cfc2..c6ea7b6d29 100644
--- a/stl/inc/__msvc_iter_core.hpp
+++ b/stl/inc/__msvc_iter_core.hpp
@@ -506,6 +506,9 @@ struct iterator_traits<_Ty*> : _Iterator_traits_pointer_base<_Ty> {}; // get tra
 
 template <class _Ty>
 constexpr bool _Integer_like = _Is_nonbool_integral<_Ty>;
+
+template <class _Ty>
+constexpr bool _Signed_integer_like = _Integer_like<_Ty> && static_cast<_Ty>(-1) < static_cast<_Ty>(0);
 #endif // ^^^ !_HAS_CXX20 ^^^
 
 _INLINE_VAR constexpr auto _Meta_npos = ~size_t{0};
diff --git a/stl/inc/format b/stl/inc/format
index 077fa50eb2..f38376354f 100644
--- a/stl/inc/format
+++ b/stl/inc/format
@@ -2023,8 +2023,6 @@ template <class _CharT, class _OutputIt>
 _NODISCARD _OutputIt _Fmt_write(
     _OutputIt _Out, basic_string_view<_CharT> _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale);
 
-#pragma warning(push)
-#pragma warning(disable : 4296) // '<': expression is always false
 template <class _CharT, class _OutputIt, integral _Integral>
 _NODISCARD _OutputIt _Write_integral(
     _OutputIt _Out, const _Integral _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale) {
@@ -2072,13 +2070,16 @@ _NODISCARD _OutputIt _Write_integral(
     auto _Buffer_start = _Buffer;
     auto _Width        = static_cast<int>(_End - _Buffer_start);
 
-    if (_Value >= _Integral{0}) {
-        if (_Specs._Sgn != _Fmt_sign::_Minus) {
-            _Width += 1;
-        }
-    } else {
+    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') {
@@ -2102,7 +2103,11 @@ _NODISCARD _OutputIt _Write_integral(
 
     const bool _Write_leading_zeroes = _Specs._Leading_zero && _Specs._Alignment == _Fmt_align::_None;
     auto _Writer                     = [&, _End = _End](_OutputIt _Out) {
-        _Out = _Write_sign(_STD move(_Out), _Specs._Sgn, _Value < _Integral{0});
+        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'});
@@ -2122,7 +2127,6 @@ _NODISCARD _OutputIt _Write_integral(
 
     return _Write_aligned(_STD move(_Out), _Width, _Specs, _Fmt_align::_Right, _Writer);
 }
-#pragma warning(pop)
 
 template <class _CharT, class _OutputIt, integral _Integral>
     requires (!_CharT_or_bool<_Integral, _CharT>)
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 1617a4aa38..e81dea8b7b 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -2325,12 +2325,15 @@ public:
         auto _Arg_ptr           = _Mypair._Myval2._Myptr();
         auto _Arg_size          = _New_size;
         const auto _Result_size = _STD move(_Op)(_Arg_ptr, _Arg_size);
-        static_assert(_Integer_like<decltype(_Result_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
-        _STL_VERIFY(_Result_size >= 0, "the returned size can't be smaller than 0, N5014 [string.capacity]/9.2");
+        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

From 4ff6a07578f2520e319f810e4ae2e8e1aeed1d49 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 14:24:00 -0700
Subject: [PATCH 12/39] All: Remove workaround for CWG-1129, implemented aeons
 ago.

---
 .../Dev11_0535636_functional_overhaul/test.cpp  | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/tests/std/tests/Dev11_0535636_functional_overhaul/test.cpp b/tests/std/tests/Dev11_0535636_functional_overhaul/test.cpp
index 0f79623e2d..8daf59b489 100644
--- a/tests/std/tests/Dev11_0535636_functional_overhaul/test.cpp
+++ b/tests/std/tests/Dev11_0535636_functional_overhaul/test.cpp
@@ -702,12 +702,7 @@ constexpr int quadruple(int n) {
     return n * 4;
 }
 
-// separate constexpr and non-constexpr functions are TRANSITION, CWG-1129
-int square(int n) {
-    return n * n;
-}
-
-constexpr int square_constexpr(int n) {
+constexpr int square(int n) {
     return n * n;
 }
 
@@ -715,11 +710,7 @@ int square_noexcept(int n) noexcept {
     return n * n;
 }
 
-int cube(int n) {
-    return n * n * n;
-}
-
-constexpr int cube_constexpr(int n) {
+constexpr int cube(int n) {
     return n * n * n;
 }
 
@@ -1069,8 +1060,8 @@ constexpr bool test_invoke_constexpr() {
 #endif // _HAS_CXX20
     assert(invoke(&Thing::sum, p, 5) == 1025);
 
-    assert(invoke(square_constexpr, 6) == 36);
-    assert(invoke(&cube_constexpr, 7) == 343);
+    assert(invoke(square, 6) == 36);
+    assert(invoke(&cube, 7) == 343);
     return true;
 }
 

From f6674ea49866317027e1a92c635173195c3bdc7f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 13:03:26 -0700
Subject: [PATCH 13/39] CUDA: Perma-workaround for designated aggregate
 initialization.

This was introduced by GH 5662 on 2025-08-08.
Just initialize the return value with `{}` to avoid garbage.
Use the name `_Tm` (instead of the previous `_Time`) for consistency with other returns.

Avoids host compiler error C2760: syntax error: '}' was unexpected here; expected 'expression'
---
 stl/inc/chrono | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/stl/inc/chrono b/stl/inc/chrono
index b0a8bf31a2..40e42f9d1e 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -5120,17 +5120,16 @@ namespace chrono {
                 _Seconds = static_cast<int>(_Val.seconds().count());
             }
 
-            return {
-                .tm_sec  = _Seconds,
-                .tm_min  = _Minutes,
-                .tm_hour = _Hours,
-                .tm_mday = static_cast<int>(_Day),
-                .tm_mon  = static_cast<int>(_Month) - 1,
-                .tm_year = _Year - 1900,
-                .tm_wday = _Weekday,
-                .tm_yday = _Yearday,
-                .tm_isdst{},
-            };
+            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;
         }
     }
 

From b23071c28ce3a3cbd8c758c1953396a31beaf75e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 10:23:12 -0700
Subject: [PATCH 14/39] CUDA: Remove workaround for Down With Typename.

I'm adding test coverage for this.
---
 stl/inc/__msvc_iter_core.hpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/stl/inc/__msvc_iter_core.hpp b/stl/inc/__msvc_iter_core.hpp
index c6ea7b6d29..c567ee73be 100644
--- a/stl/inc/__msvc_iter_core.hpp
+++ b/stl/inc/__msvc_iter_core.hpp
@@ -289,11 +289,7 @@ struct _Iter_traits_category4<false> {
 
 template <class _It>
 concept _Cpp17_random_delta =
-#if defined(__CUDACC__) && !defined(__clang__) // TRANSITION, fixed in CUDA 12.5
-    totally_ordered<_It> && requires(_It __i, typename incrementable_traits<_It>::difference_type __n) {
-#else // ^^^ workaround / no workaround vvv
     totally_ordered<_It> && requires(_It __i, incrementable_traits<_It>::difference_type __n) {
-#endif // ^^^ no workaround ^^^
         { __i += __n } -> same_as<_It&>;
         { __i -= __n } -> same_as<_It&>;
         { __i + __n } -> same_as<_It>;

From 03f9320bbb5479907d5597f128c1ecbaaf23573a Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 10:29:24 -0700
Subject: [PATCH 15/39] CUDA: Remove workaround for CWG-2518
 static_assert(false).

No test coverage necessary; the whole issue was that static_assert(false) was previously an instant error.
---
 stl/inc/__msvc_formatter.hpp |  4 ++--
 stl/inc/functional           | 18 ++++++++----------
 stl/inc/numbers              |  4 ++--
 stl/inc/ranges               |  2 +-
 stl/inc/type_traits          |  9 +++------
 stl/inc/utility              |  2 +-
 stl/inc/xlocale              |  2 +-
 7 files changed, 18 insertions(+), 23 deletions(-)

diff --git a/stl/inc/__msvc_formatter.hpp b/stl/inc/__msvc_formatter.hpp
index 0f70edd359..e61fb08fb1 100644
--- a/stl/inc/__msvc_formatter.hpp
+++ b/stl/inc/__msvc_formatter.hpp
@@ -318,8 +318,8 @@ _EXPORT_STD enum class range_format { disabled, map, set, sequence, string, debu
 
 template <class _Ty>
 struct _Invalid_format_kind {
-    static_assert(_Always_false<_Ty>, "A program that instantiates the primary template of format_kind is ill-formed. "
-                                      "(N4981 [format.range.fmtkind]/1)");
+    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>
diff --git a/stl/inc/functional b/stl/inc/functional
index 416bb58990..00d75668ea 100644
--- a/stl/inc/functional
+++ b/stl/inc/functional
@@ -1191,7 +1191,7 @@ private:
 
 template <class _Tx>
 struct _Get_function_impl {
-    static_assert(_Always_false<_Tx>, "std::function only accepts function types as template arguments.");
+    static_assert(false, "std::function only accepts function types as template arguments.");
 };
 
 #define _GET_FUNCTION_IMPL(CALL_OPT, X1, X2, X3)                                                  \
@@ -1204,11 +1204,10 @@ _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(                                                                                            \
-            _Always_false<_Ret>, "std::function does not accept noexcept function types as template arguments."); \
+#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
@@ -1913,10 +1912,9 @@ public:
 
 template <class... _Signature>
 class _Function_call {
-    static_assert(_Always_false<integral_constant<size_t, sizeof...(_Signature)>>,
-        "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.");
+    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
diff --git a/stl/inc/numbers b/stl/inc/numbers
index d1410126ee..cfe61dcb27 100644
--- a/stl/inc/numbers
+++ b/stl/inc/numbers
@@ -23,8 +23,8 @@ _STD_BEGIN
 namespace numbers {
     template <class _Ty>
     struct _Invalid {
-        static_assert(_Always_false<_Ty>, "A program that instantiates a primary template of a mathematical constant "
-                                          "variable template is ill-formed. (N4950 [math.constants]/3)");
+        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:
diff --git a/stl/inc/ranges b/stl/inc/ranges
index 10666a0223..6b8fa9769b 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -102,7 +102,7 @@ namespace ranges {
 
     template <range _Rng, class _Derived>
     class _Cached_position : public view_interface<_Derived> {
-        static_assert(_Always_false<_Rng>, "A range must be at least forward for position caching to be worthwhile.");
+        static_assert(false, "A range must be at least forward for position caching to be worthwhile.");
     };
 
     template <forward_range _Rng, class _Derived>
diff --git a/stl/inc/type_traits b/stl/inc/type_traits
index 0a47f81077..4d2a90b0c0 100644
--- a/stl/inc/type_traits
+++ b/stl/inc/type_traits
@@ -29,9 +29,6 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef no_specializations
 
 _STD_BEGIN
-template <class>
-constexpr bool _Always_false = false; // TRANSITION, needed by CUDA 12.4 in classes; see CWG-2518, VSO-2016422 (EDG)
-
 template <bool _First_value, class _First, class... _Rest>
 struct _Conjunction { // handle false trait or last trait
     using type = _First;
@@ -1256,7 +1253,7 @@ struct _Aligned<_Len, _Align, double, false> {
     };
 #else // ^^^ defined(_ENABLE_EXTENDED_ALIGNED_STORAGE) / !defined(_ENABLE_EXTENDED_ALIGNED_STORAGE) vvv
 #ifndef _DISABLE_EXTENDED_ALIGNED_STORAGE
-    static_assert(_Always_false<_Aligned>,
+    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 "
@@ -1946,8 +1943,8 @@ using _Select_invoke_traits = conditional_t<sizeof...(_Args) == 0, _Invoke_trait
 #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(_Always_false<_Fty>, "result_of<CallableType> is invalid; use "
-                                       "result_of<CallableType(zero or more argument types)> instead.");
+    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)                                                                    \
diff --git a/stl/inc/utility b/stl/inc/utility
index 8445fe12d2..58097e561e 100644
--- a/stl/inc/utility
+++ b/stl/inc/utility
@@ -710,7 +710,7 @@ struct tuple_size<tuple<_Types...>> : integral_constant<size_t, sizeof...(_Types
 
 template <size_t _Index>
 struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, tuple<>> { // enforce bounds checking
-    static_assert(_Always_false<integral_constant<size_t, _Index>>, "tuple index out of bounds");
+    static_assert(false, "tuple index out of bounds");
 };
 
 template <class _This, class... _Rest>
diff --git a/stl/inc/xlocale b/stl/inc/xlocale
index f9f33468c6..3265b2e187 100644
--- a/stl/inc/xlocale
+++ b/stl/inc/xlocale
@@ -2420,7 +2420,7 @@ _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 || _Always_false<_Elem>, _FACET_SPECIALIZATION_MESSAGE);
+    static_assert(!_ENFORCE_FACET_SPECIALIZATIONS, _FACET_SPECIALIZATION_MESSAGE);
 
     using char_type = _Elem;
 

From 915c42070a1022664b90e0707f2ca22dd3e26b51 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 10:45:49 -0700
Subject: [PATCH 16/39] CUDA: Remove workaround for intrinsics.

I'm adding test coverage for this.
---
 stl/inc/__msvc_bit_utils.hpp | 6 +++---
 stl/inc/__msvc_int128.hpp    | 2 +-
 stl/inc/cmath                | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/stl/inc/__msvc_bit_utils.hpp b/stl/inc/__msvc_bit_utils.hpp
index 0231603c9b..7e65ab5e25 100644
--- a/stl/inc/__msvc_bit_utils.hpp
+++ b/stl/inc/__msvc_bit_utils.hpp
@@ -51,7 +51,7 @@ _NODISCARD constexpr int _Countl_zero_fallback(_Ty _Val) noexcept {
     return static_cast<int>(_Nx) - static_cast<int>(_Val);
 }
 
-#if !defined(_M_CEE_PURE) && !defined(__CUDACC__)
+#if !defined(_M_CEE_PURE)
 #define _HAS_COUNTL_ZERO_INTRINSICS 1
 #else // ^^^ intrinsics available / intrinsics unavailable vvv
 #define _HAS_COUNTL_ZERO_INTRINSICS 0
@@ -176,7 +176,7 @@ _NODISCARD constexpr int _Popcount_fallback(_Ty _Val) noexcept {
 }
 
 #if ((defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))) \
-    && !defined(_M_CEE_PURE) && !defined(__CUDACC__)
+    && !defined(_M_CEE_PURE)
 #define _HAS_TZCNT_BSF_INTRINSICS 1
 #else // ^^^ intrinsics available / intrinsics unavailable vvv
 #define _HAS_TZCNT_BSF_INTRINSICS 0
@@ -267,7 +267,7 @@ _NODISCARD int _Checked_x86_x64_countr_zero(const _Ty _Val) noexcept {
 
 #endif // _HAS_TZCNT_BSF_INTRINSICS
 
-#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM64)) && !defined(_M_CEE_PURE) && !defined(__CUDACC__)
+#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM64)) && !defined(_M_CEE_PURE)
 #define _HAS_POPCNT_INTRINSICS 1
 #if defined(__AVX__) || defined(_M_ARM64) || defined(_M_ARM64EC)
 #define _POPCNT_INTRINSICS_ALWAYS_AVAILABLE 1
diff --git a/stl/inc/__msvc_int128.hpp b/stl/inc/__msvc_int128.hpp
index 08b0267caf..2283d2f17a 100644
--- a/stl/inc/__msvc_int128.hpp
+++ b/stl/inc/__msvc_int128.hpp
@@ -36,7 +36,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-#if defined(_M_X64) && !defined(_M_ARM64EC) && !defined(_M_CEE_PURE) && !defined(__CUDACC__)
+#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
diff --git a/stl/inc/cmath b/stl/inc/cmath
index 6c45e1c61a..3b89d7865a 100644
--- a/stl/inc/cmath
+++ b/stl/inc/cmath
@@ -11,7 +11,7 @@
 #include <cstdlib>
 #include <xtr1common>
 
-#if !defined(__clang__) && !defined(__CUDACC__) && !defined(_M_CEE) // TRANSITION, VSO-1663104
+#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

From 17dc94cd476a0d97942b4c978cd06ff2cc4f9d79 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 10:46:44 -0700
Subject: [PATCH 17/39] CUDA: Remove workaround for nocheck type traits.

I'm adding test coverage for this.
---
 stl/inc/type_traits | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stl/inc/type_traits b/stl/inc/type_traits
index 4d2a90b0c0..bcf8de281c 100644
--- a/stl/inc/type_traits
+++ b/stl/inc/type_traits
@@ -864,7 +864,7 @@ struct _NO_SPECIALIZATIONS_OF_TYPE_TRAITS is_assignable : bool_constant<__is_ass
 _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) && !defined(__CUDACC__)
+#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
@@ -882,7 +882,7 @@ _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) && !defined(__CUDACC__)
+#if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED)
 template <class _Ty>
 struct _Is_copy_assignable_no_precondition_check
     : bool_constant<__is_assignable_no_precondition_check(
@@ -909,7 +909,7 @@ _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) && !defined(__CUDACC__)
+#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)> {};

From 11e4f20aa75c690b4ce9cd15966abde29ec620a3 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 10:39:24 -0700
Subject: [PATCH 18/39] CUDA: Remove workaround for static call operators.

I'm adding test coverage for this.
---
 stl/inc/yvals_core.h | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index f5648c52f4..7d3a71ee03 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -829,17 +829,28 @@
     _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")        \
     _Pragma("clang diagnostic ignored \"-Wuser-defined-literals\"")
 // clang-format on
-#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#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(__clang__) ^^^
+#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")
-#else // ^^^ defined(__clang__) / !defined(__clang__) vvv
+#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(__clang__) ^^^
+#endif // ^^^ !defined(__CUDACC__) ^^^
 #endif // !defined(_STL_RESTORE_CLANG_WARNINGS)
 
 // warning: use of NaN is undefined behavior due to the currently enabled
@@ -1929,7 +1940,7 @@ _EMIT_STL_ERROR(STL1013, "The STL doesn't support /RTCc because it rejects confo
 #define _STL_INTERNAL_STATIC_ASSERT(...)
 #endif // ^^^ !defined(_ENABLE_STL_INTERNAL_CHECK) ^^^
 
-#ifdef __CUDACC__ // TRANSITION, CUDA 12.4 doesn't have downlevel support for static call operators.
+#if 0
 #define _STATIC_CALL_OPERATOR
 #define _CONST_CALL_OPERATOR const
 #else // ^^^ workaround / no workaround vvv

From c8d758ddca898907aa62a20c2182a751fe396468 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 14:42:00 -0700
Subject: [PATCH 19/39] CUDA: Remove workaround for parenthesized aggregate
 initialization.

I'm adding test coverage for this.
---
 stl/inc/chrono | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/stl/inc/chrono b/stl/inc/chrono
index 40e42f9d1e..a52fb31245 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -2272,9 +2272,8 @@ namespace chrono {
             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());
-            // TRANSITION, NVCC (was DevCom-10732572), should call emplace_front with construction arguments
-            _Tzdb_list.emplace_front(tzdb{
-                _STD move(_Version), _STD move(_Zones), _STD move(_Links), _STD move(_Leap_sec), _All_ls_positive});
+            _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 {
@@ -2331,9 +2330,8 @@ namespace chrono {
                 }
 
                 auto _Version = _CHRONO _Tzdb_update_version(_Tzdb.version, _Leap_sec.size());
-                // TRANSITION, NVCC (was DevCom-10732572), should call emplace_front with construction arguments
-                _Tzdb_list.emplace_front(tzdb{
-                    _STD move(_Version), _STD move(_Zones), _STD move(_Links), _STD move(_Leap_sec), _All_ls_positive});
+                _Tzdb_list.emplace_front(
+                    _STD move(_Version), _STD move(_Zones), _STD move(_Links), _STD move(_Leap_sec), _All_ls_positive);
             }
             return _Tzdb_list.front();
         }

From f0a7793e908a1c84107c976e6d3b54fbf738374c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 05:41:36 -0700
Subject: [PATCH 20/39] MSVC: Remove workaround: VSO-1285783 was fixed by
 MSVC-PR-694629 on 2025-12-12.

Including the 4th and final workaround, which appears to have been fixed by later changes.
---
 .../tests/P1208R6_source_location/test.cpp    | 28 +++----------------
 1 file changed, 4 insertions(+), 24 deletions(-)

diff --git a/tests/std/tests/P1208R6_source_location/test.cpp b/tests/std/tests/P1208R6_source_location/test.cpp
index 128f4a1abe..8de83049a8 100644
--- a/tests/std/tests/P1208R6_source_location/test.cpp
+++ b/tests/std/tests/P1208R6_source_location/test.cpp
@@ -96,19 +96,9 @@ constexpr void sloc_constructor_test() {
     assert(x.loc.column() == 13);
 #endif // ^^^ !defined(__EDG__) ^^^
 #if _USE_DETAILED_FUNCTION_NAME_IN_SOURCE_LOCATION
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1285783 (fixed in MSVC Compiler 19.51)
-    if (!is_constant_evaluated())
-#endif // ^^^ workaround ^^^
-    {
-        assert(x.loc.function_name() == "void __cdecl sloc_constructor_test(void)"sv);
-    }
+    assert(x.loc.function_name() == "void __cdecl sloc_constructor_test(void)"sv);
 #else // ^^^ detailed / basic vvv
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1285783 (fixed in MSVC Compiler 19.51)
-    if (!is_constant_evaluated())
-#endif // ^^^ workaround ^^^
-    {
-        assert(x.loc.function_name() == "sloc_constructor_test"sv);
-    }
+    assert(x.loc.function_name() == "sloc_constructor_test"sv);
 #endif // ^^^ basic ^^^
     assert(string_view{x.loc.file_name()}.ends_with(test_cpp));
 }
@@ -142,19 +132,9 @@ constexpr void sub_member_test() {
     assert(s.x.loc.column() == 14);
 #endif // ^^^ !defined(__EDG__) ^^^
 #if _USE_DETAILED_FUNCTION_NAME_IN_SOURCE_LOCATION
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1285783 (fixed in MSVC Compiler 19.51)
-    if (!is_constant_evaluated())
-#endif // ^^^ workaround ^^^
-    {
-        assert(s.x.loc.function_name() == "void __cdecl sub_member_test(void)"sv);
-    }
+    assert(s.x.loc.function_name() == "void __cdecl sub_member_test(void)"sv);
 #else // ^^^ detailed / basic vvv
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-1285783
-    if (!is_constant_evaluated())
-#endif // ^^^ workaround ^^^
-    {
-        assert(s.x.loc.function_name() == "sub_member_test"sv);
-    }
+    assert(s.x.loc.function_name() == "sub_member_test"sv);
 #endif // ^^^ basic ^^^
     assert(string_view{s.x.loc.file_name()}.ends_with(test_cpp));
 

From d9847f419e473201797f2e39637d20973649507d Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 05:55:12 -0700
Subject: [PATCH 21/39] MSVC: Remove workaround: VSO-2714784 was fixed by
 MSVC-PR-707352 on 2026-02-10.

---
 tests/std/tests/P0429R9_flat_map/test.cpp |  8 +-------
 tests/std/tests/P1222R4_flat_set/test.cpp | 14 ++++----------
 2 files changed, 5 insertions(+), 17 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index b2e8adea29..f509d3fefc 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -18,7 +18,6 @@
 #include <utility>
 #include <vector>
 
-#include <is_permissive.hpp>
 #include <test_container_requirements.hpp>
 #include <test_death.hpp>
 using namespace std;
@@ -1347,12 +1346,7 @@ void test_insert_hint_is_respected() {
 
 template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_key_mapped_cont_combinations() {
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-2714784
-    if constexpr (!is_permissive)
-#endif // ^^^ workaround ^^^
-    {
-        test_construction<KeyCont, MappedCont>();
-    }
+    test_construction<KeyCont, MappedCont>();
     test_insert_hint_is_respected<KeyCont, MappedCont>();
     test_throwing_compare_swap_single<flat_map, KeyCont, MappedCont>();
     test_throwing_compare_swap_single<flat_multimap, KeyCont, MappedCont>();
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 5648dc4746..ac673797ca 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -18,7 +18,6 @@
 #include <utility>
 #include <vector>
 
-#include <is_permissive.hpp>
 #include <test_container_requirements.hpp>
 #include <test_death.hpp>
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
@@ -1352,15 +1351,10 @@ void test_non_strict_weak_order_compare() {
 void run_normal_tests() {
     mt19937_64 eng(42);
 
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-2714784
-    if constexpr (!is_permissive)
-#endif // ^^^ workaround ^^^
-    {
-        test_constructors<vector<int>>();
-        test_constructors<deque<int>>();
-        test_allocator_extended_constructors<iterator_pair_construction::allocator_first>();
-        test_allocator_extended_constructors<iterator_pair_construction::allocator_last>();
-    }
+    test_constructors<vector<int>>();
+    test_constructors<deque<int>>();
+    test_allocator_extended_constructors<iterator_pair_construction::allocator_first>();
+    test_allocator_extended_constructors<iterator_pair_construction::allocator_last>();
 
     test_iterators_and_capacity<flat_set<int>>();
     test_iterators_and_capacity<flat_multiset<int>>();

From 0d185fc93bd12113c5ee3cb6a5cbffc6413a0920 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 05:56:38 -0700
Subject: [PATCH 22/39] MSVC: Remove workaround: VSO-2714798 was fixed by
 MSVC-PR-708374 on 2026-02-17.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index f509d3fefc..ca4a2989ef 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -957,7 +957,6 @@ void test_insert() {
 }
 
 void test_insert_range() {
-#ifndef _PREFAST_ // TRANSITION, VSO-2714798
     {
         flat_map<int, char> fm{{1, 'p'}, {4, 'q'}, {9, 'r'}};
         using char_type_array = flat_map<int, char>::value_type[];
@@ -982,7 +981,6 @@ void test_insert_range() {
         assert(check_key_content(fmm, {1, 4, 4, 9, 9, 9, 16, 16, 25}));
         assert(check_value_content(fmm, {'p', 'q', 'z', 'r', 'y', 'a', 'x', 'b', 'c'}));
     }
-#endif // ^^^ no workaround ^^^
 }
 
 // GH-4344 <flat_map> Fix compile errors

From b2b2f53e88842fefb9077f886fdfb443f7e81838 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 05:50:56 -0700
Subject: [PATCH 23/39] MSVC: Remove workaround: DevCom-10798069 was fixed by
 MSVC-PR-704666 on 2026-02-02.

P1004R2_constexpr_vector still needs 2 workarounds, filed GH 6155 for followup.
---
 stl/inc/memory                                |  8 -----
 stl/inc/xutility                              | 27 ---------------
 .../test.cpp                                  | 33 +++++++++----------
 .../tests/P1004R2_constexpr_vector/test.cpp   | 22 ++++++-------
 4 files changed, 26 insertions(+), 64 deletions(-)

diff --git a/stl/inc/memory b/stl/inc/memory
index 26535cc7cf..f83002ddd5 100644
--- a/stl/inc/memory
+++ b/stl/inc/memory
@@ -548,14 +548,6 @@ namespace ranges {
 #if defined(__clang__) // TRANSITION, LLVM-117294
                 ::new (static_cast<void*>(_Location)) _Ty();
                 return __builtin_launder(_Location); // per old resolution of LWG-3436
-#elif defined(_MSC_VER) // TRANSITION, DevCom-10798069
-                if constexpr (is_trivially_destructible_v<_Ty>) {
-                    _MSVC_CONSTEXPR return ::new (_Secret_placement_new_tag{}, static_cast<void*>(_Location)) _Ty[1]();
-                } else {
-                    // For non-trivially-destructible types, the workaround doesn't work
-                    // because additional space is required to record the number of class objects to destroy.
-                    return ::new (static_cast<void*>(_Location)) _Ty[1]();
-                }
 #else // ^^^ workaround / no workaround vvv
                 _MSVC_CONSTEXPR return ::new (static_cast<void*>(_Location)) _Ty[1]();
 #endif // ^^^ no workaround ^^^
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 75fa266a03..46fba82342 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -248,25 +248,6 @@ __declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const
 
 } // extern "C"
 
-#if _HAS_CXX20 && !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-10798069
-_STD_BEGIN
-struct _Secret_placement_new_tag {
-    explicit _Secret_placement_new_tag() = default;
-};
-_STD_END
-
-template <_STD same_as<_STD _Secret_placement_new_tag> _Tag>
-_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size)
-    _Post_satisfies_(return == _Where) constexpr void* __CRTDECL operator new[](
-        size_t _Size, _Tag, _Writable_bytes_(_Size) void* _Where) noexcept {
-    (void) _Size;
-    return _Where;
-}
-
-template <_STD same_as<_STD _Secret_placement_new_tag> _Tag>
-constexpr void __CRTDECL operator delete[](void*, _Tag, void*) noexcept {}
-#endif // ^^^ workaround ^^^
-
 _STD_BEGIN
 
 template <class _Target, class _Source>
@@ -619,14 +600,6 @@ constexpr _Ty* construct_at(_Ty* const _Location, _Types&&... _Args)
 #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
-#elif defined(_MSC_VER) // TRANSITION, DevCom-10798069
-        if constexpr (is_trivially_destructible_v<_Ty>) {
-            _MSVC_CONSTEXPR return ::new (_Secret_placement_new_tag{}, static_cast<void*>(_Location)) _Ty[1]();
-        } else {
-            // For non-trivially-destructible types, the workaround doesn't work
-            // because additional space is required to record the number of class objects to destroy.
-            return ::new (static_cast<void*>(_Location)) _Ty[1]();
-        }
 #else // ^^^ workaround / no workaround vvv
         _MSVC_CONSTEXPR return ::new (static_cast<void*>(_Location)) _Ty[1]();
 #endif // ^^^ no workaround ^^^
diff --git a/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp b/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
index 5dfd33f6bd..319cf5b6de 100644
--- a/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
+++ b/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
@@ -663,28 +663,25 @@ constexpr bool test_construct_at_array() {
     test_ranges_construct_at_array<int, 1>();
     test_ranges_construct_at_array<int, 42>();
 
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-10798069
-    if (!is_constant_evaluated())
-#endif // ^^^ workaround ^^^
-    {
 #if !_HAS_CXX23
-        if (!is_constant_evaluated())
+    if (!is_constant_evaluated())
 #endif // !_HAS_CXX23
-        {
-            test_std_construct_at_array<unique_ptr<string>, 1>();
-            test_std_construct_at_array<unique_ptr<string>, 42>();
-            test_ranges_construct_at_array<unique_ptr<string>, 1>();
-            test_ranges_construct_at_array<unique_ptr<string>, 42>();
-        }
-        test_std_construct_at_array<string, 1>();
-        test_ranges_construct_at_array<string, 1>();
+    {
+        test_std_construct_at_array<unique_ptr<string>, 1>();
+        test_std_construct_at_array<unique_ptr<string>, 42>();
+        test_ranges_construct_at_array<unique_ptr<string>, 1>();
+        test_ranges_construct_at_array<unique_ptr<string>, 42>();
+    }
+
+    test_std_construct_at_array<string, 1>();
+    test_ranges_construct_at_array<string, 1>();
+
 #if defined(__EDG__) && _ITERATOR_DEBUG_LEVEL != 0 // TRANSITION, DevCom-11012299
-        if (!is_constant_evaluated())
+    if (!is_constant_evaluated())
 #endif // ^^^ workaround ^^^
-        {
-            test_std_construct_at_array<string, 42>();
-            test_ranges_construct_at_array<string, 42>();
-        }
+    {
+        test_std_construct_at_array<string, 42>();
+        test_ranges_construct_at_array<string, 42>();
     }
 
     return true;
diff --git a/tests/std/tests/P1004R2_constexpr_vector/test.cpp b/tests/std/tests/P1004R2_constexpr_vector/test.cpp
index c5e46cdcb2..b2702dbf37 100644
--- a/tests/std/tests/P1004R2_constexpr_vector/test.cpp
+++ b/tests/std/tests/P1004R2_constexpr_vector/test.cpp
@@ -674,21 +674,21 @@ constexpr bool test_vector_of_array() {
     test_vector_of_array_impl<int, 1>();
     test_vector_of_array_impl<int, 42>();
 
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-10798069
-    if (!is_constant_evaluated())
-#endif // ^^^ workaround ^^^
-    {
 #if !_HAS_CXX23
-        if (!is_constant_evaluated())
+    if (!is_constant_evaluated())
 #endif // !_HAS_CXX23
-        {
-            test_vector_of_array_impl<unique_ptr<vector<char>>, 1>();
-            test_vector_of_array_impl<unique_ptr<vector<char>>, 42>();
-        }
-        test_vector_of_array_impl<vector<long>, 1>();
-        test_vector_of_array_impl<vector<long>, 42>();
+    {
+        test_vector_of_array_impl<unique_ptr<vector<char>>, 1>();
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, GH-6155 (not yet reported to MSVC)
+        test_vector_of_array_impl<unique_ptr<vector<char>>, 42>();
+#endif // ^^^ no workaround ^^^
     }
 
+    test_vector_of_array_impl<vector<long>, 1>();
+#if defined(__clang__) || defined(__EDG__) // TRANSITION, GH-6155 (not yet reported to MSVC)
+    test_vector_of_array_impl<vector<long>, 42>();
+#endif // ^^^ no workaround ^^^
+
     return true;
 }
 #pragma warning(pop)

From 7f13edbe2470206ddce12c9a8b5c8b8d62f5b5ba Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 12:27:13 -0700
Subject: [PATCH 24/39] MSVC: Remove workaround: DevCom-10416247 was fixed
 before 2024-10-15.

---
 tests/std/tests/GH_000940_missing_valarray_copy/test.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/std/tests/GH_000940_missing_valarray_copy/test.cpp b/tests/std/tests/GH_000940_missing_valarray_copy/test.cpp
index d8d6189b82..ba947407d7 100644
--- a/tests/std/tests/GH_000940_missing_valarray_copy/test.cpp
+++ b/tests/std/tests/GH_000940_missing_valarray_copy/test.cpp
@@ -113,9 +113,7 @@ int main() {
     test_strengthened_exception_specification<std::size_t>();
     test_strengthened_exception_specification<double>();
 
-#if defined(__clang__) || defined(__EDG__) // TRANSITION, DevCom-10416247
     STATIC_ASSERT(std::is_nothrow_default_constructible_v<std::gslice>); // strengthened
-#endif // ^^^ no workaround ^^^
     std::gslice gs{};
     STATIC_ASSERT(noexcept(gs.start())); // strengthened
 }

From 2b5b0f52ac4f208ccc611f600d01ce67bfb481e7 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 14:27:38 -0700
Subject: [PATCH 25/39] MSVC: Remove workaround: VSO-570323 was a `/Za` bug,
 which we no longer test or care about.

---
 stl/inc/filesystem | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/stl/inc/filesystem b/stl/inc/filesystem
index 7d838ea2d1..02735cf96c 100644
--- a/stl/inc/filesystem
+++ b/stl/inc/filesystem
@@ -1323,15 +1323,13 @@ namespace filesystem {
         _NODISCARD inline iterator end() const noexcept; // strengthened
 
         template <class _Elem, class _Traits>
-        friend _STD basic_ostream<_Elem, _Traits>& operator<<( // TRANSITION, VSO-570323
-            _STD basic_ostream<_Elem, _Traits>& _Ostr, const path& _Path) { // TRANSITION, VSO-570323
+        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 _STD basic_istream<_Elem, _Traits>& operator>>( // TRANSITION, VSO-570323
-            _STD basic_istream<_Elem, _Traits>& _Istr, path& _Path) { // TRANSITION, VSO-570323
+        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);
@@ -2480,8 +2478,8 @@ namespace filesystem {
 
         // [fs.dir.entry.io], inserter
         template <class _Elem, class _Traits>
-        friend _STD basic_ostream<_Elem, _Traits>& operator<<( // TRANSITION, VSO-570323
-            _STD basic_ostream<_Elem, _Traits>& _Ostr, const directory_entry& _Entry) { // TRANSITION, VSO-570323
+        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();
         }

From 2af51a1f27832c6248dd17ba5676a6eac4d74607 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 11:13:04 -0700
Subject: [PATCH 26/39] EDG: Remove workaround: VSO-892694 was fixed by
 VS-PR-527543 on 2024-02-09.

---
 .../tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp  | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/std/tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp b/tests/std/tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp
index a83302dceb..2bc0089589 100644
--- a/tests/std/tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp
+++ b/tests/std/tests/P0758R1_is_nothrow_convertible/test.compile.pass.cpp
@@ -77,9 +77,7 @@ STATIC_ASSERT(is_nothrow_convertible_v<int(int, long), int (&)(int, long)>);
 STATIC_ASSERT(!is_nothrow_convertible_v<int(int, long) const, int(const int, long)>);
 STATIC_ASSERT(!is_nothrow_convertible_v<int(int, long) const, int(int, long) const>);
 STATIC_ASSERT(is_nothrow_convertible_v<int (Cat::*)(int, int (*)(int, long)), int (Cat::*)(int, int (*)(int, long))>);
-#ifndef __EDG__ // TRANSITION, VSO-892694
 STATIC_ASSERT(!is_nothrow_convertible_v<Cat, Cat&>);
-#endif // ^^^ no workaround ^^^
 STATIC_ASSERT(is_nothrow_convertible_v<Cat&, Cat>);
 STATIC_ASSERT(is_nothrow_convertible_v<Cat, const Cat&>);
 STATIC_ASSERT(is_nothrow_convertible_v<Cat, const Cat>);

From a2cbf532757f47a74e2eada8f9c17be71ffca03c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 10:32:45 -0700
Subject: [PATCH 27/39] /analyze: CppCoreCheck.dll was removed by
 MSVC-PR-674029 on 2025-10-29.

```
C:\Program Files\Microsoft Visual Studio\18\Insiders\VC\Tools\MSVC\14.50.35717\bin\Hostx64\x64>dir | rg "EspXEngine|CppCoreCheck"
01/21/2026  03:15 PM         1,343,008 CppCoreCheck.dll
01/21/2026  03:15 PM         3,117,128 EspXEngine.dll

C:\Program Files\Microsoft Visual Studio\18\Insiders\VC\Tools\MSVC\14.51.36122\bin\Hostx64\x64>dir | rg "EspXEngine|CppCoreCheck"
03/10/2026  11:27 AM         4,054,048 EspXEngine.dll
```
---
 tests/utils/stl/test/tests.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/utils/stl/test/tests.py b/tests/utils/stl/test/tests.py
index af2e09d0bf..acde2dc02a 100644
--- a/tests/utils/stl/test/tests.py
+++ b/tests/utils/stl/test/tests.py
@@ -353,7 +353,6 @@ def _parseFlags(self, litConfig):
         # code analysis settings
         if 'espxengine' in self.config.available_features:
             self.compileFlags.extend(["/analyze:rulesetdirectory", ';'.join(litConfig.ruleset_dirs[self.config.name])])
-            self.env['Esp.Extensions'] = 'CppCoreCheck.dll'
             self.env['Esp.AnnotationBuildLevel'] = 'Ignore'
 
 class LibcxxTest(STLTest):

From df3e5b4e1f2b24ab728b581f6064021e264b4f6f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 12 Mar 2026 04:58:27 -0700
Subject: [PATCH 28/39] Tests: GH_000639_nvcc_include_all: Add coverage for
 removed CUDA workarounds.

---
 .../test.compile.pass.cpp                     | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/tests/std/tests/GH_000639_nvcc_include_all/test.compile.pass.cpp b/tests/std/tests/GH_000639_nvcc_include_all/test.compile.pass.cpp
index dc49c8ff92..d09b562714 100644
--- a/tests/std/tests/GH_000639_nvcc_include_all/test.compile.pass.cpp
+++ b/tests/std/tests/GH_000639_nvcc_include_all/test.compile.pass.cpp
@@ -13,3 +13,38 @@ void test_VSO_2411436() {
     (void) format("{}", 1729);
 }
 #endif // _HAS_CXX20
+
+void test_removed_workaround_for_iterator_traits() {
+    using Cat = iterator_traits<vector<int>::iterator>::iterator_category;
+    static_assert(is_same_v<Cat, random_access_iterator_tag>, "Expected vector::iterator to be random-access");
+}
+
+void test_removed_workaround_for_static_call_operators() {
+    (void) hash<double>{}(3.14);
+}
+
+void test_removed_workaround_for_intrinsics() {
+    (void) ceil(3.14f);
+
+#if _HAS_CXX20
+    (void) countl_zero(1729u);
+    (void) countr_zero(1729u);
+    (void) popcount(1729u);
+
+    const auto vw   = views::iota(0ll, 10ll);
+    const auto dist = vw.end() - vw.begin();
+    (void) (dist / dist);
+#endif // _HAS_CXX20
+}
+
+void test_removed_workaround_for_nocheck_type_traits() {
+    const pair<int, int> src{11, 22};
+    pair<int, int> dst{33, 44};
+    dst = src;
+}
+
+#if _HAS_CXX20
+void test_removed_workaround_for_tzdb_list() {
+    (void) chrono::get_tzdb_list();
+}
+#endif // _HAS_CXX20

From bb24a4618a4d17db10ed3f4b57f1b33bdbc5b24b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 12:40:43 -0700
Subject: [PATCH 29/39] Tests: P1682R3_to_underlying: Remove SFINAE workaround,
 use concepts.

---
 tests/std/tests/P1682R3_to_underlying/test.cpp | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/tests/std/tests/P1682R3_to_underlying/test.cpp b/tests/std/tests/P1682R3_to_underlying/test.cpp
index 9656e520e8..754bbc6b99 100644
--- a/tests/std/tests/P1682R3_to_underlying/test.cpp
+++ b/tests/std/tests/P1682R3_to_underlying/test.cpp
@@ -7,14 +7,8 @@
 
 using namespace std;
 
-// TRANSITION, GH-602
-// template <class T>
-// constexpr bool can_underlying = requires(T e) { to_underlying(e); };
-
-template <class, class = void>
-constexpr bool can_underlying = false;
 template <class T>
-constexpr bool can_underlying<T, void_t<decltype(to_underlying(declval<T>()))>> = true;
+concept can_underlying = requires(T e) { to_underlying(e); };
 
 enum enum1 : char { a = '1' };
 enum class enum2 : int { b = 2 };

From 445aa4ff1ffcce98bb2d5fb53e940e62f258d731 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 14:38:29 -0700
Subject: [PATCH 30/39] Tests: VSO_0000000_instantiate_type_traits: Use
 is_permissive.hpp instead of handwritten logic.

Drop the "TRANSITION, Evil Extension" comment because all usage of is_permissive is inherently TRANSITION.

De Morgan the condition to clarify its behavior.
---
 .../test.compile.pass.cpp                     | 21 +++----------------
 1 file changed, 3 insertions(+), 18 deletions(-)

diff --git a/tests/std/tests/VSO_0000000_instantiate_type_traits/test.compile.pass.cpp b/tests/std/tests/VSO_0000000_instantiate_type_traits/test.compile.pass.cpp
index d18bf106ce..bd8fa6b962 100644
--- a/tests/std/tests/VSO_0000000_instantiate_type_traits/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0000000_instantiate_type_traits/test.compile.pass.cpp
@@ -18,6 +18,8 @@
 #include <utility>
 #include <vector>
 
+#include <is_permissive.hpp>
+
 // lets INSTANTIATE macro be used for types that aren't default constructible.
 // Doesn't actually instantiate the type if not default constructible,
 // but it will inspect the type, which is the true purpose.
@@ -34,21 +36,6 @@ struct instantiate_helper<T, false> {
     using type = int;
 };
 
-#if _HAS_CXX17
-// TRANSITION, Evil Extension
-namespace detail {
-    struct S {};
-    void evil(S&);
-
-    template <typename = S, typename = void>
-    constexpr bool test = false;
-    template <typename T>
-    constexpr bool test<T, std::void_t<decltype(evil(T{}))>> = true;
-} // namespace detail
-
-constexpr bool has_evil_extension = detail::test<>;
-#endif // _HAS_CXX17
-
 #define USE_VALUE(...)          \
     do {                        \
         auto val = __VA_ARGS__; \
@@ -187,9 +174,7 @@ void type_traits_test_impl() {
     TRAIT_V(is_swappable, T);
     TRAIT_V(is_nothrow_swappable, T);
     TRAIT_V(is_swappable_with, T, U);
-    constexpr bool avoid_evil_extension = // TRANSITION, Evil Extension
-        has_evil_extension && !conjunction_v<is_lvalue_reference<T>, is_lvalue_reference<U>>;
-    if constexpr (!avoid_evil_extension) { // avoid triggering Evil Extension warnings
+    if constexpr (!is_permissive || (is_lvalue_reference_v<T> && is_lvalue_reference_v<U>) ) { // avoid Evil Extension
         TRAIT_V(is_nothrow_swappable_with, T, U);
     }
 #endif // _HAS_CXX17

From b40e85bd0ae4f9124903fffc821848540d8e1be7 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 14:49:08 -0700
Subject: [PATCH 31/39] Tests: Dev11_1074023_constexpr: Test the constexpr
 mutex constructor.

---
 tests/std/tests/Dev11_1074023_constexpr/test.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/std/tests/Dev11_1074023_constexpr/test.cpp b/tests/std/tests/Dev11_1074023_constexpr/test.cpp
index a7f6b6c832..18d4a747f7 100644
--- a/tests/std/tests/Dev11_1074023_constexpr/test.cpp
+++ b/tests/std/tests/Dev11_1074023_constexpr/test.cpp
@@ -241,6 +241,8 @@ struct TestConstexprCtors {
     atomic<Animal> atom1{Animal::Cat};
     atomic<uint64_t> atom2{1729ULL};
     atomic<double*> atom3{nullptr};
+
+    mutex mut{};
 #endif // _M_CEE_PURE
 
     constexpr TestConstexprCtors() {}
@@ -861,9 +863,6 @@ constexpr adopt_lock_t adopt_lock2   = adopt_lock;
 
 constexpr once_flag once{};
 
-// TRANSITION,
-// constexpr mutex() noexcept;
-
 #endif // _M_CEE_PURE
 
 // reverse_iterator and string_view constexpr are tested in P0220R1_string_view

From 2dc2edcc505cd48ff380e79a6e00f61a50f1b709 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 10:26:41 -0700
Subject: [PATCH 32/39] Tests: Enable ASan annotation tests for ARM64, except
 Clang.

---
 .../std/tests/GH_002030_asan_annotate_string/notarget.lst | 5 -----
 tests/std/tests/GH_002030_asan_annotate_string/test.cpp   | 8 +++++++-
 .../std/tests/GH_002030_asan_annotate_vector/notarget.lst | 5 -----
 tests/std/tests/GH_002030_asan_annotate_vector/test.cpp   | 8 +++++++-
 4 files changed, 14 insertions(+), 12 deletions(-)
 delete mode 100644 tests/std/tests/GH_002030_asan_annotate_string/notarget.lst
 delete mode 100644 tests/std/tests/GH_002030_asan_annotate_vector/notarget.lst

diff --git a/tests/std/tests/GH_002030_asan_annotate_string/notarget.lst b/tests/std/tests/GH_002030_asan_annotate_string/notarget.lst
deleted file mode 100644
index 0027fd085c..0000000000
--- a/tests/std/tests/GH_002030_asan_annotate_string/notarget.lst
+++ /dev/null
@@ -1,5 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-## TRANSITION, VSO-1938218 ASAN is not yet supported on arm64
-arm64
diff --git a/tests/std/tests/GH_002030_asan_annotate_string/test.cpp b/tests/std/tests/GH_002030_asan_annotate_string/test.cpp
index 0d371ddcf3..37ce727d9a 100644
--- a/tests/std/tests/GH_002030_asan_annotate_string/test.cpp
+++ b/tests/std/tests/GH_002030_asan_annotate_string/test.cpp
@@ -1,7 +1,11 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-// REQUIRES: x64 || x86
+// REQUIRES: x64 || x86 || arm64
+
+#if defined(__clang__) && defined(_M_ARM64) // TRANSITION, LLVM-184902, fixed in Clang 23
+int main() {}
+#else // ^^^ workaround / no workaround vvv
 
 #pragma warning(disable : 4984) // 'if constexpr' is a C++17 language extension
 #pragma warning(disable : 4324) // '%s': structure was padded due to alignment specifier
@@ -1998,3 +2002,5 @@ int main(int argc, char* argv[]) {
 #endif // ASan instrumentation enabled
     return exec.run(argc, argv);
 }
+
+#endif // ^^^ no workaround ^^^
diff --git a/tests/std/tests/GH_002030_asan_annotate_vector/notarget.lst b/tests/std/tests/GH_002030_asan_annotate_vector/notarget.lst
deleted file mode 100644
index 0027fd085c..0000000000
--- a/tests/std/tests/GH_002030_asan_annotate_vector/notarget.lst
+++ /dev/null
@@ -1,5 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-## TRANSITION, VSO-1938218 ASAN is not yet supported on arm64
-arm64
diff --git a/tests/std/tests/GH_002030_asan_annotate_vector/test.cpp b/tests/std/tests/GH_002030_asan_annotate_vector/test.cpp
index 300b7daf25..0286bba39a 100644
--- a/tests/std/tests/GH_002030_asan_annotate_vector/test.cpp
+++ b/tests/std/tests/GH_002030_asan_annotate_vector/test.cpp
@@ -1,7 +1,11 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-// REQUIRES: x64 || x86
+// REQUIRES: x64 || x86 || arm64
+
+#if defined(__clang__) && defined(_M_ARM64) // TRANSITION, LLVM-184902, fixed in Clang 23
+int main() {}
+#else // ^^^ workaround / no workaround vvv
 
 #include <cassert>
 #include <cstddef>
@@ -1097,3 +1101,5 @@ int main(int argc, char* argv[]) {
 
     return exec.run(argc, argv);
 }
+
+#endif // ^^^ no workaround ^^^

From 3d56fe41445e73c9bb47f4ed9d48fee629b98889 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 10:49:37 -0700
Subject: [PATCH 33/39] Comments: Clarify the CUDA restrict workaround.

Cite GH 5061 and GH 5097 so we don't attempt to remove this without proper care.

Use "workaround / no workaround" for clarity.
---
 stl/inc/yvals_core.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 7d3a71ee03..fa13fb25c3 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -1948,11 +1948,11 @@ _EMIT_STL_ERROR(STL1013, "The STL doesn't support /RTCc because it rejects confo
 #define _CONST_CALL_OPERATOR
 #endif // ^^^ no workaround ^^^
 
-#ifdef __CUDACC__ // TRANSITION, CUDA 12.4 doesn't recognize MSVC __restrict; CUDA __restrict__ is not usable in C++
+#ifdef __CUDACC__ // TRANSITION, CUDA rejects MSVC __restrict (GH-5061); CUDA __restrict__ is unusable in C++ (GH-5097)
 #define _RESTRICT
-#else // ^^^ defined(__CUDACC__) / !defined(__CUDACC__) vvv
+#else // ^^^ workaround / no workaround vvv
 #define _RESTRICT __restrict
-#endif // ^^^ !defined(__CUDACC__) ^^^
+#endif // ^^^ no workaround ^^^
 
 #endif // _STL_COMPILER_PREPROCESSOR
 #endif // _YVALS_CORE_H_

From 0426df3144f2f0c9de05bb24240ca1208633a232 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 10:35:17 -0700
Subject: [PATCH 34/39] Comments: CUDA still needs the `basic_format_arg()`
 workaround.

---
 stl/inc/__msvc_ranges_tuple_formatter.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/__msvc_ranges_tuple_formatter.hpp b/stl/inc/__msvc_ranges_tuple_formatter.hpp
index 0836727e69..ad74c69f8e 100644
--- a/stl/inc/__msvc_ranges_tuple_formatter.hpp
+++ b/stl/inc/__msvc_ranges_tuple_formatter.hpp
@@ -271,7 +271,7 @@ class _NO_SPECIALIZATIONS_CITING("N5014 [format.arg]/2") basic_format_arg {
         }
     };
 
-#if defined(__clang__) || defined(__CUDACC__) // TRANSITION, LLVM-81774 (Clang), VSO-2411436 (needed by CUDA 12.8.1)
+#if defined(__clang__) || defined(__CUDACC__) // TRANSITION, LLVM-81774, 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;

From 525297552907d30fd5ad00f20e686b65444765aa Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 12:49:56 -0700
Subject: [PATCH 35/39] Comments: Update citation from N4928 + P2655R3 to
 N5032.

The paragraph number changed, but the content was otherwise identical.
---
 tests/std/tests/VSO_0000000_type_traits/test.compile.pass.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/VSO_0000000_type_traits/test.compile.pass.cpp b/tests/std/tests/VSO_0000000_type_traits/test.compile.pass.cpp
index bf1bb41590..0f05ca1e33 100644
--- a/tests/std/tests/VSO_0000000_type_traits/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0000000_type_traits/test.compile.pass.cpp
@@ -1339,7 +1339,7 @@ STATIC_ASSERT(is_same_v<common_reference_t<void() volatile>, void() volatile>);
 STATIC_ASSERT(is_same_v<common_reference_t<void() &&>, void() &&>);
 
 
-// N4928 [meta.trans.other]/5.3.1 as updated by P2655R3 (TRANSITION, cite new WP here):
+// N5032 [meta.trans.other]/6.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."

From 27389762ab2c91c565a86accff4754ee34f3ad60 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 13:05:18 -0700
Subject: [PATCH 36/39] Comments: Consistently say "TRANSITION, ABI".

---
 stl/inc/array                                    | 2 +-
 stl/inc/chrono                                   | 2 +-
 stl/inc/future                                   | 4 ++--
 stl/inc/xlocinfo                                 | 2 +-
 stl/inc/xtree                                    | 2 +-
 stl/inc/xutility                                 | 2 +-
 stl/src/tzdb.cpp                                 | 2 +-
 tests/std/tests/Dev11_1074023_constexpr/test.cpp | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/stl/inc/array b/stl/inc/array
index da5e5afa75..37bbd98d3f 100644
--- a/stl/inc/array
+++ b/stl/inc/array
@@ -18,7 +18,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 #if _ITERATOR_DEBUG_LEVEL != 0
-struct _Iterator_base12_compatible { // TRANSITION, for binary compatibility
+struct _Iterator_base12_compatible { // TRANSITION, ABI
     _Container_proxy* _Myproxy{};
     _Iterator_base12* _Mynextiter{};
 };
diff --git a/stl/inc/chrono b/stl/inc/chrono
index a52fb31245..35a4e96ecb 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -1867,7 +1867,7 @@ namespace chrono {
             using _Internal_duration = duration<__std_tzdb_epoch_milli, milli>;
             const auto _Internal_dur = _CHRONO duration_cast<_Internal_duration>(_Dur);
 
-            // TRANSITION, vNext
+            // 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);
diff --git a/stl/inc/future b/stl/inc/future
index 456dd47705..0861bf6e4d 100644
--- a/stl/inc/future
+++ b/stl/inc/future
@@ -172,7 +172,7 @@ 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, vNext (make non-virtual, never called polymorphically)
+    virtual ~_Deleter_base() = default; // TRANSITION, ABI (make non-virtual, never called polymorphically)
 };
 
 template <class _Ty, class _Derived, class _Alloc>
@@ -1391,7 +1391,7 @@ _Associated_state<_P_arg_type_t<_Ret>>* _Get_associated_state(launch _Psync, _Ft
     switch (_Psync) { // select launch type
     case launch::deferred:
         return new _Deferred_async_state<_Ret>(_STD forward<_Fty>(_Fnarg));
-    case launch::async: // TRANSITION, fixed in vMajorNext, should create a new thread here
+    case launch::async: // TRANSITION, ABI, should create a new thread here
     default:
         return new _Task_async_state<_Ret>(_STD forward<_Fty>(_Fnarg));
     }
diff --git a/stl/inc/xlocinfo b/stl/inc/xlocinfo
index 6c03cf0772..290596d8bd 100644
--- a/stl/inc/xlocinfo
+++ b/stl/inc/xlocinfo
@@ -120,7 +120,7 @@ public:
         if (this != &_Right) {
             _CSTD free(_Timeptr);
             _Timeptr                               = _Right._Timeptr;
-            const_cast<_Timevec&>(_Right)._Timeptr = nullptr; // TRANSITION, should be movable-only
+            const_cast<_Timevec&>(_Right)._Timeptr = nullptr; // TRANSITION, ABI, should be movable-only
         }
 
         return *this;
diff --git a/stl/inc/xtree b/stl/inc/xtree
index 98b195a34e..ba988f52a6 100644
--- a/stl/inc/xtree
+++ b/stl/inc/xtree
@@ -337,7 +337,7 @@ struct _Tree_node {
     _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, should be bool
+    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
 
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 46fba82342..c5e1cb07db 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -4130,7 +4130,7 @@ namespace ranges {
     private:
         using _Size_type = _Make_unsigned_like_t<iter_difference_t<_It>>;
 
-        // TRANSITION, [[no_unique_address]]:
+        // 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{};
diff --git a/stl/src/tzdb.cpp b/stl/src/tzdb.cpp
index bad8b2f1ae..785306a8dc 100644
--- a/stl/src/tzdb.cpp
+++ b/stl/src/tzdb.cpp
@@ -499,7 +499,7 @@ void __stdcall __std_tzdb_delete_current_zone(__std_tzdb_current_zone_info* cons
     // 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, vNext
+    // 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) {
diff --git a/tests/std/tests/Dev11_1074023_constexpr/test.cpp b/tests/std/tests/Dev11_1074023_constexpr/test.cpp
index 18d4a747f7..644420c150 100644
--- a/tests/std/tests/Dev11_1074023_constexpr/test.cpp
+++ b/tests/std/tests/Dev11_1074023_constexpr/test.cpp
@@ -57,7 +57,7 @@ STATIC_ASSERT(il.begin() == il.end());
 STATIC_ASSERT(begin(il) == end(il));
 #endif // _HAS_CXX17
 
-// TRANSITION,
+// TRANSITION, ABI
 // constexpr error_category() noexcept;
 
 constexpr int i = 1729;

From 922281431e76afc6ea9421bf653a539bc4bc1b4e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 14:14:58 -0700
Subject: [PATCH 37/39] Comments: Drop TRANSITION comment in experimental code.

We're never going to mess with this again.
---
 stl/inc/future | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stl/inc/future b/stl/inc/future
index 0861bf6e4d..42b70fc16b 100644
--- a/stl/inc/future
+++ b/stl/inc/future
@@ -1486,7 +1486,6 @@ namespace experimental {
         }
 
         void await_suspend(experimental::coroutine_handle<> _ResumeCb) {
-            // TRANSITION, change to .then if and when future gets .then
             thread _WaitingThread([&_Fut = _Fut, _ResumeCb]() mutable {
                 _Fut.wait();
                 _ResumeCb();

From 9bdf9aef373c127c2d2f686e6f3f4f7091f82e6b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 12 Mar 2026 14:02:54 -0700
Subject: [PATCH 38/39] Comments: Update citation from DevCom-10265237 to
 VSO-2826400.

And VSO-2826400 was fixed by MSVC-PR-717544 on 2026-03-13.
---
 stl/inc/tuple | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/tuple b/stl/inc/tuple
index bd7a836a66..b30dd804d0 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -193,7 +193,7 @@ struct _Three_way_comparison_result_with_tuple_like {};
 
 template <class... _TTypes, class _UTuple, size_t... _Indices>
     requires
-#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-10265237
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-2826400
     (sizeof...(_TTypes) == sizeof...(_Indices)) &&
 #endif // ^^^ workaround ^^^
     (requires { typename _Synth_three_way_result<_TTypes, tuple_element_t<_Indices, _UTuple>>; } && ...)

From bef18c56eec1850cb82d8cc4cb314bee26cb1329 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 11 Mar 2026 15:00:16 -0700
Subject: [PATCH 39/39] Mechanical: `_STATIC_CALL_OPERATOR` => `static`,
 `_CONST_CALL_OPERATOR` => nothing

---
 stl/inc/__msvc_bit_utils.hpp                  |  12 +-
 stl/inc/__msvc_ranges_to.hpp                  |  15 +-
 stl/inc/__msvc_tzdb.hpp                       |   8 +-
 stl/inc/algorithm                             | 620 ++++++++----------
 stl/inc/bitset                                |   2 +-
 stl/inc/chrono                                |   4 +-
 stl/inc/compare                               |  27 +-
 stl/inc/concepts                              |   6 +-
 stl/inc/coroutine                             |   3 +-
 stl/inc/execution                             |  10 +-
 stl/inc/filesystem                            |   4 +-
 stl/inc/flat_map                              |   4 +-
 stl/inc/format                                |   4 +-
 stl/inc/generator                             |   4 +-
 stl/inc/memory                                |  59 +-
 stl/inc/memory_resource                       |   3 +-
 stl/inc/mutex                                 |   2 +-
 stl/inc/numeric                               |   6 +-
 stl/inc/ostream                               |   2 +-
 stl/inc/ranges                                | 137 ++--
 stl/inc/regex                                 |   6 +-
 stl/inc/stacktrace                            |   5 +-
 stl/inc/system_error                          |   4 +-
 stl/inc/thread                                |   2 +-
 stl/inc/type_traits                           |  10 +-
 stl/inc/typeindex                             |   2 +-
 stl/inc/utility                               |   2 +-
 stl/inc/variant                               |   4 +-
 stl/inc/vector                                |   6 +-
 stl/inc/xstring                               |  42 +-
 stl/inc/xutility                              | 180 +++--
 stl/inc/yvals_core.h                          |   8 -
 tests/std/include/experimental_filesystem.hpp |   2 +-
 33 files changed, 519 insertions(+), 686 deletions(-)

diff --git a/stl/inc/__msvc_bit_utils.hpp b/stl/inc/__msvc_bit_utils.hpp
index 7e65ab5e25..d6d1189458 100644
--- a/stl/inc/__msvc_bit_utils.hpp
+++ b/stl/inc/__msvc_bit_utils.hpp
@@ -333,14 +333,14 @@ constexpr decltype(auto) _Select_countr_zero_impl(_Fn _Callback) {
 #ifndef __AVX2__
         const bool _Definitely_have_tzcnt = __isa_available >= _Stl_isa_available_avx2;
         if (!_Definitely_have_tzcnt) {
-            return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_bsf(_Val); });
+            return _Callback([](_Ty _Val) static { return _Countr_zero_bsf(_Val); });
         }
 #endif // ^^^ !defined(__AVX2__) ^^^
-        return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Countr_zero_tzcnt(_Val); });
+        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_CALL_OPERATOR { return _Countr_zero_fallback(_Val); });
+    return _Callback([](_Ty _Val) static { return _Countr_zero_fallback(_Val); });
 }
 
 template <class _Ty>
@@ -385,13 +385,13 @@ _CONSTEXPR20 decltype(auto) _Select_popcount_impl(_Fn _Callback) {
 #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_CALL_OPERATOR { return _Popcount_fallback(_Val); });
+            return _Callback([](_Ty _Val) static { return _Popcount_fallback(_Val); });
         }
 #endif // ^^^ !_POPCNT_INTRINSICS_ALWAYS_AVAILABLE ^^^
-        return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Unchecked_popcount(_Val); });
+        return _Callback([](_Ty _Val) static { return _Unchecked_popcount(_Val); });
     }
 #endif // ^^^ _HAS_POPCNT_INTRINSICS ^^^
-    return _Callback([](_Ty _Val) _STATIC_CALL_OPERATOR { return _Popcount_fallback(_Val); });
+    return _Callback([](_Ty _Val) static { return _Popcount_fallback(_Val); });
 }
 
 #undef _HAS_TZCNT_BSF_INTRINSICS
diff --git a/stl/inc/__msvc_ranges_to.hpp b/stl/inc/__msvc_ranges_to.hpp
index 0a435f91e7..c2313b212d 100644
--- a/stl/inc/__msvc_ranges_to.hpp
+++ b/stl/inc/__msvc_ranges_to.hpp
@@ -621,8 +621,7 @@ namespace ranges {
         public:
             template <viewable_range _Rng>
                 requires (_Choice<_Rng>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Rng>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
                 constexpr _St _Strat = _Choice<_Rng>._Strategy;
 
                 if constexpr (_Strat == _St::_View) {
@@ -1046,7 +1045,7 @@ namespace ranges {
     namespace views {
         struct _Transform_fn {
             template <viewable_range _Rng, class _Fn>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Fn _Fun) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -1055,7 +1054,7 @@ namespace ranges {
 
             template <class _Fn>
                 requires constructible_from<decay_t<_Fn>, _Fn>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Fn&& _Fun) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -1146,7 +1145,7 @@ namespace ranges {
                                      "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_CALL_OPERATOR {
+            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)...);
@@ -1166,8 +1165,7 @@ namespace ranges {
         _STL_INTERNAL_STATIC_ASSERT(!view<_Container>);
 
         template <input_range _Rng, class... _Types>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-            _Rng&& _Range, _Types&&... _Args) _CONST_CALL_OPERATOR
+        _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)...);
@@ -1222,8 +1220,7 @@ namespace ranges {
     struct _To_template_fn {
         template <input_range _Rng, class... _Types,
             class _Deduced = remove_pointer_t<decltype(_To_helper<_Container, _Rng, _Types...>())>>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-            _Rng&& _Range, _Types&&... _Args) _CONST_CALL_OPERATOR {
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Types&&... _Args) {
             return _RANGES to<_Deduced>(_STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
         }
     };
diff --git a/stl/inc/__msvc_tzdb.hpp b/stl/inc/__msvc_tzdb.hpp
index 43fc7e53b6..ed9198e920 100644
--- a/stl/inc/__msvc_tzdb.hpp
+++ b/stl/inc/__msvc_tzdb.hpp
@@ -101,28 +101,28 @@ struct _Tzdb_deleter;
 
 template <>
 struct _Tzdb_deleter<__std_tzdb_time_zones_info> {
-    _STATIC_CALL_OPERATOR void operator()(__std_tzdb_time_zones_info* _Info) _CONST_CALL_OPERATOR noexcept {
+    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_CALL_OPERATOR void operator()(__std_tzdb_current_zone_info* _Info) _CONST_CALL_OPERATOR noexcept {
+    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_CALL_OPERATOR void operator()(__std_tzdb_sys_info* _Info) _CONST_CALL_OPERATOR noexcept {
+    static void operator()(__std_tzdb_sys_info* _Info) noexcept {
         __std_tzdb_delete_sys_info(_Info);
     }
 };
 
 template <>
 struct _Tzdb_deleter<__std_tzdb_leap_info[]> {
-    _STATIC_CALL_OPERATOR void operator()(__std_tzdb_leap_info* _Info) _CONST_CALL_OPERATOR noexcept {
+    static void operator()(__std_tzdb_leap_info* _Info) noexcept {
         __std_tzdb_delete_leap_seconds(_Info);
     }
 };
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index b925caf990..8d5925159b 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -754,8 +754,7 @@ namespace ranges {
     public:
         template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirectly_unary_invocable<projected<_It, _Pj>> _Fn>
-        _STATIC_CALL_OPERATOR constexpr for_each_result<_It, _Fn> operator()(
-            _It _First, _Se _Last, _Fn _Func, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -767,8 +766,8 @@ namespace ranges {
 
         template <input_range _Rng, class _Pj = identity,
             indirectly_unary_invocable<projected<iterator_t<_Rng>, _Pj>> _Fn>
-        _STATIC_CALL_OPERATOR constexpr for_each_result<borrowed_iterator_t<_Rng>, _Fn> operator()(
-            _Rng&& _Range, _Fn _Func, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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),
@@ -801,8 +800,8 @@ namespace ranges {
 
     struct _For_each_n_fn {
         template <input_iterator _It, class _Pj = identity, indirectly_unary_invocable<projected<_It, _Pj>> _Fn>
-        _STATIC_CALL_OPERATOR constexpr for_each_n_result<_It, _Fn> operator()(
-            _It _First, iter_difference_t<_It> _Count, _Fn _Func, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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 {
@@ -907,8 +906,8 @@ namespace ranges {
     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_CALL_OPERATOR constexpr iter_difference_t<_It> operator()(
-            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -916,8 +915,8 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr range_difference_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
         }
 
@@ -987,8 +986,8 @@ namespace ranges {
     public:
         template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr iter_difference_t<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -996,8 +995,7 @@ namespace ranges {
 
         template <input_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr range_difference_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
         }
 
@@ -1206,8 +1204,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
-            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -1232,8 +1230,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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)) {
@@ -1353,8 +1351,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
-            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -1379,8 +1377,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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) {
@@ -1656,8 +1654,7 @@ namespace ranges {
     public:
         template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -1666,8 +1663,7 @@ namespace ranges {
 
         template <input_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
         }
 
@@ -1723,8 +1719,7 @@ namespace ranges {
     public:
         template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -1733,8 +1728,7 @@ namespace ranges {
 
         template <input_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
         }
 
@@ -1789,8 +1783,7 @@ namespace ranges {
     public:
         template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -1799,8 +1792,7 @@ namespace ranges {
 
         template <input_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
         }
 
@@ -1827,8 +1819,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr bool operator()(
-            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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(
@@ -1838,8 +1829,7 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr bool operator()(
-            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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);
         }
@@ -1851,8 +1841,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
-            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -1869,8 +1859,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _NODISCARD static constexpr bool operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) {
             if (_RANGES empty(_Range2)) {
                 return true;
             }
@@ -1890,8 +1880,7 @@ namespace ranges {
     struct _Copy_n_fn {
         template <input_iterator _It, weakly_incrementable _Out>
             requires indirectly_copyable<_It, _Out>
-        _STATIC_CALL_OPERATOR constexpr copy_n_result<_It, _Out> operator()(
-            _It _First, iter_difference_t<_It> _Count, _Out _Output) _CONST_CALL_OPERATOR {
+        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);
@@ -1924,8 +1913,7 @@ namespace ranges {
     struct _Copy_backward_fn {
         template <bidirectional_iterator _It1, sentinel_for<_It1> _Se1, bidirectional_iterator _It2>
             requires indirectly_copyable<_It1, _It2>
-        _STATIC_CALL_OPERATOR constexpr copy_backward_result<_It1, _It2> operator()(
-            _It1 _First, _Se1 _Last, _It2 _Output) _CONST_CALL_OPERATOR {
+        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));
@@ -1939,8 +1927,7 @@ namespace ranges {
 
         template <bidirectional_range _Rng, bidirectional_iterator _It>
             requires indirectly_copyable<iterator_t<_Rng>, _It>
-        _STATIC_CALL_OPERATOR constexpr copy_backward_result<borrowed_iterator_t<_Rng>, _It> operator()(
-            _Rng&& _Range, _It _Output) _CONST_CALL_OPERATOR {
+        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(
@@ -1992,8 +1979,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr copy_if_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -2006,8 +1993,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -2062,8 +2049,7 @@ namespace ranges {
     struct _Move_fn {
         template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
             requires indirectly_movable<_It, _Out>
-        _STATIC_CALL_OPERATOR constexpr move_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output) _CONST_CALL_OPERATOR {
+        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));
@@ -2078,8 +2064,7 @@ namespace ranges {
 
         template <input_range _Rng, weakly_incrementable _Out>
             requires indirectly_movable<iterator_t<_Rng>, _Out>
-        _STATIC_CALL_OPERATOR constexpr move_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output) _CONST_CALL_OPERATOR {
+        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),
@@ -2116,8 +2101,7 @@ namespace ranges {
     struct _Move_backward_fn {
         template <bidirectional_iterator _It1, sentinel_for<_It1> _Se1, bidirectional_iterator _It2>
             requires indirectly_movable<_It1, _It2>
-        _STATIC_CALL_OPERATOR constexpr move_backward_result<_It1, _It2> operator()(
-            _It1 _First, _Se1 _Last, _It2 _Output) _CONST_CALL_OPERATOR {
+        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));
@@ -2131,8 +2115,7 @@ namespace ranges {
 
         template <bidirectional_range _Rng, bidirectional_iterator _It>
             requires indirectly_movable<iterator_t<_Rng>, _It>
-        _STATIC_CALL_OPERATOR constexpr move_backward_result<borrowed_iterator_t<_Rng>, _It> operator()(
-            _Rng&& _Range, _It _Output) _CONST_CALL_OPERATOR {
+        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(
@@ -2193,8 +2176,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr partition_copy_result<_It, _Out1, _Out2> operator()(_It _First, _Se _Last,
-            _Out1 _Dest_true, _Out2 _Dest_false, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -2208,8 +2191,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr partition_copy_result<borrowed_iterator_t<_Rng>, _Out1, _Out2> operator()(
-            _Rng&& _Range, _Out1 _Dest_true, _Out2 _Dest_false, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -2287,8 +2270,7 @@ namespace ranges {
     public:
         template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -2296,8 +2278,7 @@ namespace ranges {
 
         template <input_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
         }
@@ -2364,8 +2345,7 @@ namespace ranges {
     public:
         template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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>) {
@@ -2383,8 +2363,7 @@ namespace ranges {
 
         template <forward_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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 =
@@ -2698,8 +2677,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr subrange<_It> operator()(_It _First, _Se _Last,
-            const iter_difference_t<_It> _Count, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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) {
@@ -2736,9 +2715,8 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range,
-            const range_difference_t<_Rng> _Count, const _Ty& _Val, _Pr _Pred = {},
-            _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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) {
@@ -2912,8 +2890,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
-            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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);
 
@@ -2942,8 +2920,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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>) {
@@ -2973,8 +2951,8 @@ namespace ranges {
             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_CALL_OPERATOR constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
-            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -2993,8 +2971,8 @@ namespace ranges {
             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_CALL_OPERATOR constexpr bool operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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);
 
@@ -3223,16 +3201,14 @@ namespace ranges {
     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_CALL_OPERATOR constexpr auto operator()(
-            _It _First, _Se _Last, _Ty _Init, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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_CALL_OPERATOR constexpr auto operator()(
-            _Rng&& _Range, _Ty _Init, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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));
         }
@@ -3268,14 +3244,12 @@ namespace ranges {
 
     struct _Fold_left_fn {
         template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, _Indirectly_binary_left_foldable<_Ty, _It> _Fn>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-            _It _First, _Se _Last, _Ty _Init, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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_CALL_OPERATOR constexpr auto operator()(
-            _Rng&& _Range, _Ty _Init, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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;
         }
@@ -3288,15 +3262,14 @@ namespace ranges {
         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_CALL_OPERATOR constexpr auto operator()(
-            _It _First, _Se _Last, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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));
         }
@@ -3336,14 +3309,13 @@ namespace ranges {
         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_CALL_OPERATOR constexpr auto operator()(
-            _It _First, _Se _Last, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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;
         }
     };
@@ -3372,16 +3344,14 @@ namespace ranges {
     struct _Fold_right_fn {
         template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Ty,
             _Indirectly_binary_right_foldable<_Ty, _It> _Fn>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-            _It _First, _Se _Last, _Ty _Init, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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_CALL_OPERATOR constexpr auto operator()(
-            _Rng&& _Range, _Ty _Init, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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));
         }
@@ -3394,8 +3364,7 @@ namespace ranges {
         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_CALL_OPERATOR constexpr auto operator()(
-            _It _First, _Se _Last, _Fn _Func) _CONST_CALL_OPERATOR {
+        _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));
@@ -3404,7 +3373,7 @@ namespace ranges {
         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_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Fn _Func) _CONST_CALL_OPERATOR {
+        _NODISCARD static constexpr auto operator()(_Rng&& _Range, _Fn _Func) {
             return _Fold_right_last_unchecked(_Ubegin(_Range), _Uend(_Range), _STD _Pass_fn(_Func));
         }
 
@@ -3433,8 +3402,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, _Se _Last, const _Ty& _Value, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -3453,8 +3421,8 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Value, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -3539,8 +3507,7 @@ namespace ranges {
     public:
         template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -3559,8 +3526,7 @@ namespace ranges {
 
         template <forward_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -3880,8 +3846,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr subrange<_It1> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
-            _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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);
@@ -3910,8 +3876,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng1> operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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 =
@@ -4016,8 +3982,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr _It1 operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
-            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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);
 
@@ -4033,8 +3999,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng1> operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -4172,8 +4138,8 @@ namespace ranges {
     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_CALL_OPERATOR constexpr swap_ranges_result<_It1, _It2> operator()(
-            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2) _CONST_CALL_OPERATOR {
+        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);
 
@@ -4188,8 +4154,8 @@ namespace ranges {
 
         template <input_range _Rng1, input_range _Rng2>
             requires indirectly_swappable<iterator_t<_Rng1>, iterator_t<_Rng2>>
-        _STATIC_CALL_OPERATOR constexpr swap_ranges_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>>
-            operator()(_Rng1&& _Range1, _Rng2&& _Range2) _CONST_CALL_OPERATOR {
+        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);
 
@@ -4337,8 +4303,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr unary_transform_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output, _Fn _Func, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -4354,8 +4320,8 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr unary_transform_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output, _Fn _Func, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
 
@@ -4371,9 +4337,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr binary_transform_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1,
-            _It2 _First2, _Se2 _Last2, _Out _Output, _Fn _Func, _Pj1 _Proj1 = {},
-            _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        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);
 
@@ -4399,10 +4364,8 @@ namespace ranges {
             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_CALL_OPERATOR 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_CALL_OPERATOR {
+        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);
@@ -4498,8 +4461,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -4511,8 +4474,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -4587,8 +4550,7 @@ namespace ranges {
         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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -4600,8 +4562,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -4702,8 +4664,8 @@ namespace ranges {
             class _Pj = identity>
             requires indirectly_copyable<_It, _Out>
                   && indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty1*>
-        _STATIC_CALL_OPERATOR constexpr replace_copy_result<_It, _Out> operator()(_It _First, _Se _Last, _Out _Output,
-            const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -4719,8 +4681,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr replace_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(_Rng&& _Range,
-            _Out _Output, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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),
@@ -4829,8 +4791,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr replace_copy_if_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -4847,8 +4809,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr replace_copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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),
@@ -4888,7 +4850,7 @@ namespace ranges {
 
     struct _Fill_fn {
         template <class _Ty, output_iterator<const _Ty&> _It, sentinel_for<_It> _Se>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(_It _First, _Se _Last, const _Ty& _Value) _CONST_CALL_OPERATOR {
+        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));
@@ -4919,8 +4881,7 @@ namespace ranges {
         }
 
         template <class _Ty, output_range<const _Ty&> _Rng>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Value) _CONST_CALL_OPERATOR {
+        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));
@@ -4934,7 +4895,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _Out operator()(_Out _First, _Se _Last, _Fn _Gen) _CONST_CALL_OPERATOR {
+        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)));
@@ -4943,8 +4904,7 @@ namespace ranges {
 
         template <class _Rng, copy_constructible _Fn>
             requires invocable<_Fn&> && output_range<_Rng, invoke_result_t<_Fn&>>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Fn _Gen) _CONST_CALL_OPERATOR {
+        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)));
@@ -4973,8 +4933,7 @@ namespace ranges {
     struct _Generate_n_fn {
         template <input_or_output_iterator _Out, copy_constructible _Fn>
             requires invocable<_Fn&> && indirectly_writable<_Out, invoke_result_t<_Fn&>>
-        _STATIC_CALL_OPERATOR constexpr _Out operator()(
-            _Out _First, iter_difference_t<_Out> _Count, _Fn _Gen) _CONST_CALL_OPERATOR {
+        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 {
@@ -5138,8 +5097,8 @@ namespace ranges {
     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_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -5150,8 +5109,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -5207,8 +5166,8 @@ namespace ranges {
     public:
         template <permutable _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD_REMOVE_ALG _STATIC_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -5219,8 +5178,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
 
@@ -5263,8 +5222,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr remove_copy_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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,
@@ -5278,8 +5237,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr remove_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -5347,8 +5306,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr remove_copy_if_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -5362,8 +5321,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr remove_copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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),
@@ -5473,8 +5432,8 @@ namespace ranges {
     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_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -5485,8 +5444,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
 
@@ -5677,8 +5636,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr unique_copy_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -5692,8 +5651,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr unique_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -5812,7 +5771,7 @@ namespace ranges {
     struct _Reverse_fn {
         template <bidirectional_iterator _It, sentinel_for<_It> _Se>
             requires permutable<_It>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(_It _First, _Se _Last) _CONST_CALL_OPERATOR {
+        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));
@@ -5823,7 +5782,7 @@ namespace ranges {
 
         template <bidirectional_range _Rng>
             requires permutable<iterator_t<_Rng>>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) _CONST_CALL_OPERATOR {
+        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));
@@ -5899,8 +5858,7 @@ namespace ranges {
     public:
         template <bidirectional_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
             requires indirectly_copyable<_It, _Out>
-        _STATIC_CALL_OPERATOR constexpr reverse_copy_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output) _CONST_CALL_OPERATOR {
+        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));
@@ -5914,8 +5872,7 @@ namespace ranges {
 
         template <bidirectional_range _Rng, weakly_incrementable _Out>
             requires indirectly_copyable<iterator_t<_Rng>, _Out>
-        _STATIC_CALL_OPERATOR constexpr reverse_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output) _CONST_CALL_OPERATOR {
+        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>) {
@@ -6067,7 +6024,7 @@ namespace ranges {
 
     struct _Rotate_fn {
         template <permutable _It, sentinel_for<_It> _Se>
-        _STATIC_CALL_OPERATOR constexpr subrange<_It> operator()(_It _First, _It _Mid, _Se _Last) _CONST_CALL_OPERATOR {
+        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)),
@@ -6078,8 +6035,7 @@ namespace ranges {
 
         template <forward_range _Rng>
             requires permutable<iterator_t<_Rng>>
-        _STATIC_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, iterator_t<_Rng> _Mid) _CONST_CALL_OPERATOR {
+        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(
@@ -6127,8 +6083,7 @@ namespace ranges {
     public:
         template <forward_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
             requires indirectly_copyable<_It, _Out>
-        _STATIC_CALL_OPERATOR constexpr rotate_copy_result<_It, _Out> operator()(
-            _It _First, _It _Mid, _Se _Last, _Out _Output) _CONST_CALL_OPERATOR {
+        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));
@@ -6144,8 +6099,8 @@ namespace ranges {
 
         template <forward_range _Rng, weakly_incrementable _Out>
             requires indirectly_copyable<iterator_t<_Rng>, _Out>
-        _STATIC_CALL_OPERATOR constexpr rotate_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, iterator_t<_Rng> _Mid, _Out _Output) _CONST_CALL_OPERATOR {
+        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);
@@ -6393,8 +6348,7 @@ namespace ranges {
         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_CALL_OPERATOR _Out operator()(
-            _It _First, _Se _Last, _Out _Output, iter_difference_t<_It> _Count, _Urng&& _Func) _CONST_CALL_OPERATOR {
+        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;
@@ -6415,8 +6369,7 @@ namespace ranges {
             requires (forward_range<_Rng> || random_access_iterator<_Out>)
                   && indirectly_copyable<iterator_t<_Rng>, _Out>
                   && uniform_random_bit_generator<remove_reference_t<_Urng>>
-        _STATIC_CALL_OPERATOR _Out operator()(
-            _Rng&& _Range, _Out _Output, range_difference_t<_Rng> _Count, _Urng&& _Func) _CONST_CALL_OPERATOR {
+        static _Out operator()(_Rng&& _Range, _Out _Output, range_difference_t<_Rng> _Count, _Urng&& _Func) {
             if (_Count <= 0) {
                 return _Output;
             }
@@ -6534,7 +6487,7 @@ namespace ranges {
     public:
         template <random_access_iterator _It, sentinel_for<_It> _Se, class _Urng>
             requires permutable<_It> && uniform_random_bit_generator<remove_reference_t<_Urng>>
-        _STATIC_CALL_OPERATOR _It operator()(_It _First, _Se _Last, _Urng&& _Func) _CONST_CALL_OPERATOR {
+        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);
@@ -6547,7 +6500,7 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Urng>
             requires permutable<iterator_t<_Rng>> && uniform_random_bit_generator<remove_reference_t<_Urng>>
-        _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Urng&& _Func) _CONST_CALL_OPERATOR {
+        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));
@@ -6751,8 +6704,7 @@ namespace ranges {
     class _Shift_left_fn {
     public:
         template <permutable _It, sentinel_for<_It> _Se>
-        _STATIC_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, const _Se _Last, iter_difference_t<_It> _Pos_to_shift) _CONST_CALL_OPERATOR {
+        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);
@@ -6771,8 +6723,7 @@ namespace ranges {
 
         template <forward_range _Rng>
             requires permutable<iterator_t<_Rng>>
-        _STATIC_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, range_difference_t<_Rng> _Pos_to_shift) _CONST_CALL_OPERATOR {
+        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) {
@@ -6817,8 +6768,7 @@ namespace ranges {
     class _Shift_right_fn {
     public:
         template <permutable _It, sentinel_for<_It> _Se>
-        _STATIC_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, const _Se _Last, iter_difference_t<_It> _Pos_to_shift) _CONST_CALL_OPERATOR {
+        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);
@@ -6832,8 +6782,7 @@ namespace ranges {
 
         template <forward_range _Rng>
             requires permutable<iterator_t<_Rng>>
-        _STATIC_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, range_difference_t<_Rng> _Pos_to_shift) _CONST_CALL_OPERATOR {
+        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());
@@ -7043,8 +6992,7 @@ namespace ranges {
     public:
         template <permutable _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _STATIC_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -7054,8 +7002,7 @@ namespace ranges {
         template <forward_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
             requires permutable<iterator_t<_Rng>>
-        _STATIC_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -7339,8 +7286,7 @@ namespace ranges {
         template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
             requires permutable<_It>
-        _STATIC_CALL_OPERATOR subrange<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -7353,8 +7299,7 @@ namespace ranges {
         template <bidirectional_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
             requires permutable<iterator_t<_Rng>>
-        _STATIC_CALL_OPERATOR borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -7519,8 +7464,7 @@ namespace ranges {
     public:
         template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<_It, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -7531,8 +7475,7 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
@@ -7629,8 +7572,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -7642,8 +7584,7 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
@@ -7675,8 +7616,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -7688,8 +7628,7 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
@@ -7799,8 +7738,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr bool operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -7812,8 +7750,7 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -7826,8 +7763,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)));
@@ -7839,8 +7775,8 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -7892,8 +7828,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -7905,8 +7840,7 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
@@ -7946,8 +7880,8 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)));
@@ -7959,8 +7893,8 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -7996,8 +7930,8 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)));
@@ -8009,8 +7943,8 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -8071,8 +8005,8 @@ namespace ranges {
     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_CALL_OPERATOR constexpr subrange<_It> operator()(
-            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)));
@@ -8083,8 +8017,8 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -8149,8 +8083,8 @@ 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_CALL_OPERATOR constexpr bool operator()(
-            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -8162,8 +8096,7 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr bool operator()(
-            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -8275,9 +8208,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr merge_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1,
-            _It2 _First2, _Se2 _Last2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {},
-            _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -8299,9 +8231,8 @@ namespace ranges {
         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_CALL_OPERATOR 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_CALL_OPERATOR {
+        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);
@@ -8863,8 +8794,7 @@ namespace ranges {
     public:
         template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<_It, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR _It operator()(
-            _It _First, _It _Mid, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
 
@@ -8879,8 +8809,8 @@ namespace ranges {
 
         template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, iterator_t<_Rng> _Mid, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
 
@@ -9309,8 +9239,7 @@ namespace ranges {
     public:
         template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<_It, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -9322,8 +9251,7 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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;
@@ -9582,8 +9510,7 @@ namespace ranges {
     public:
         template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<_It, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -9597,8 +9524,7 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        static borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
             auto _UFirst = _Ubegin(_Range);
             auto _ULast  = _RANGES _Get_final_iterator_unwrapped(_Range);
 
@@ -9895,8 +9821,7 @@ namespace ranges {
     public:
         template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<_It, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _It _Mid, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
 
@@ -9917,8 +9842,8 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, iterator_t<_Rng> _Mid, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
 
@@ -10034,8 +9959,8 @@ namespace ranges {
             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_CALL_OPERATOR constexpr partial_sort_copy_result<_It1, _It2> operator()(_It1 _First1, _Se1 _Last1,
-            _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        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);
 
@@ -10054,9 +9979,8 @@ namespace ranges {
             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_CALL_OPERATOR constexpr partial_sort_copy_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>>
-            operator()(_Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {},
-                _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        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),
@@ -10271,8 +10195,7 @@ namespace ranges {
     public:
         template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<_It, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _It _Nth, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
@@ -10286,8 +10209,8 @@ namespace ranges {
 
         template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, iterator_t<_Rng> _Nth, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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);
@@ -10524,8 +10447,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
-            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -10537,8 +10460,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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));
         }
@@ -10671,9 +10594,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr set_union_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1,
-            _It2 _First2, _Se2 _Last2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {},
-            _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -10689,9 +10611,8 @@ namespace ranges {
         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_CALL_OPERATOR 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 = {}) _CONST_CALL_OPERATOR {
+        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),
@@ -10799,9 +10720,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr set_intersection_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1,
-            _It2 _First2, _Se2 _Last2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {},
-            _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -10817,10 +10737,9 @@ namespace ranges {
         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_CALL_OPERATOR 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 = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -10935,9 +10854,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr set_difference_result<_It1, _Out> operator()(_It1 _First1, _Se1 _Last1,
-            _It2 _First2, _Se2 _Last2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {},
-            _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -10952,9 +10870,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr set_difference_result<borrowed_iterator_t<_Rng1>, _Out> operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Output, _Pr _Pred = {}, _Pj1 _Proj1 = {},
-            _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -11079,9 +10996,8 @@ namespace ranges {
         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_CALL_OPERATOR 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 = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -11097,10 +11013,9 @@ namespace ranges {
         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_CALL_OPERATOR 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 = {}) _CONST_CALL_OPERATOR {
+        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)),
@@ -11256,8 +11171,8 @@ namespace ranges {
     public:
         template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr minmax_element_result<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -11269,8 +11184,8 @@ namespace ranges {
 
         template <forward_range _Rng, class _Pj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr minmax_element_result<borrowed_iterator_t<_Rng>> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -11407,9 +11322,8 @@ namespace ranges {
     public:
         template <class _Ty, class _Pj = identity,
             indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr minmax_result<const _Ty&> operator()(
-            const _Ty& _Left _MSVC_LIFETIMEBOUND, const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred = {},
-            _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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 {
@@ -11419,8 +11333,8 @@ namespace ranges {
 
         template <copyable _Ty, class _Pj = identity,
             indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr minmax_result<_Ty> operator()(
-            initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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,
@@ -11455,8 +11369,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr minmax_result<range_value_t<_Rng>> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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(
@@ -11649,8 +11563,8 @@ namespace ranges {
     public:
         template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<_It, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr next_permutation_result<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -11662,8 +11576,8 @@ namespace ranges {
 
         template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr next_permutation_result<borrowed_iterator_t<_Rng>> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -11753,8 +11667,8 @@ namespace ranges {
     public:
         template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<_It, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr prev_permutation_result<_It> operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -11766,8 +11680,8 @@ namespace ranges {
 
         template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
             requires sortable<iterator_t<_Rng>, _Pr, _Pj>
-        _STATIC_CALL_OPERATOR constexpr prev_permutation_result<borrowed_iterator_t<_Rng>> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        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));
@@ -11900,8 +11814,7 @@ 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_CALL_OPERATOR constexpr bool operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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(
@@ -11911,8 +11824,7 @@ namespace ranges {
 
         template <forward_range _Rng, class _Pj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -11925,8 +11837,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -11936,8 +11847,8 @@ namespace ranges {
 
         template <forward_range _Rng, class _Pj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -11988,9 +11899,8 @@ namespace ranges {
     struct _Clamp_fn {
         template <class _Ty, class _Pj = identity,
             indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr const _Ty& operator()(const _Ty& _Val _MSVC_LIFETIMEBOUND,
-            const _Ty& _Lo _MSVC_LIFETIMEBOUND, const _Ty& _Hi _MSVC_LIFETIMEBOUND, _Pr _Pred = {},
-            _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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).");
@@ -12016,8 +11926,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
-            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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);
 
@@ -12030,8 +11940,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr bool operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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));
         }
diff --git a/stl/inc/bitset b/stl/inc/bitset
index 9177af858a..68b548055a 100644
--- a/stl/inc/bitset
+++ b/stl/inc/bitset
@@ -708,7 +708,7 @@ 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_CALL_OPERATOR size_t operator()(const bitset<_Bits>& _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const bitset<_Bits>& _Keyval) noexcept {
         return _Hash_representation(_Keyval._Array);
     }
 };
diff --git a/stl/inc/chrono b/stl/inc/chrono
index 35a4e96ecb..e0f27990fc 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -2118,8 +2118,8 @@ namespace chrono {
     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_CALL_OPERATOR { return _Tz.name() < _Sv; });
+        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 {
diff --git a/stl/inc/compare b/stl/inc/compare
index b0187d55f4..462820055c 100644
--- a/stl/inc/compare
+++ b/stl/inc/compare
@@ -343,8 +343,7 @@ _EXPORT_STD struct compare_three_way {
 
 struct _Synth_three_way {
     template <class _Ty1, class _Ty2>
-    _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-        const _Ty1& _Left, const _Ty2& _Right) _CONST_CALL_OPERATOR
+    _NODISCARD static constexpr auto operator()(const _Ty1& _Left, const _Ty2& _Right)
         requires requires {
             { _Left < _Right } -> _Boolean_testable;
             { _Right < _Left } -> _Boolean_testable;
@@ -412,8 +411,8 @@ namespace _Strong_order {
     public:
         template <class _Ty1, class _Ty2>
             requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr strong_ordering operator()(
-            _Ty1&& _Left, _Ty2&& _Right) _CONST_CALL_OPERATOR noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+        _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
@@ -519,8 +518,8 @@ namespace _Weak_order {
     public:
         template <class _Ty1, class _Ty2>
             requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr weak_ordering operator()(
-            _Ty1&& _Left, _Ty2&& _Right) _CONST_CALL_OPERATOR noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+        _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
@@ -650,8 +649,8 @@ namespace _Partial_order {
     public:
         template <class _Ty1, class _Ty2>
             requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr partial_ordering operator()(
-            _Ty1&& _Left, _Ty2&& _Right) _CONST_CALL_OPERATOR noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+        _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));
@@ -712,8 +711,8 @@ namespace _Compare_strong_order_fallback {
     public:
         template <class _Ty1, class _Ty2>
             requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr strong_ordering operator()(
-            _Ty1&& _Left, _Ty2&& _Right) _CONST_CALL_OPERATOR noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+        _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);
@@ -762,8 +761,8 @@ namespace _Compare_weak_order_fallback {
     public:
         template <class _Ty1, class _Ty2>
             requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr weak_ordering operator()(
-            _Ty1&& _Left, _Ty2&& _Right) _CONST_CALL_OPERATOR noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+        _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);
@@ -820,8 +819,8 @@ namespace _Compare_partial_order_fallback {
     public:
         template <class _Ty1, class _Ty2>
             requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr partial_ordering operator()(
-            _Ty1&& _Left, _Ty2&& _Right) _CONST_CALL_OPERATOR noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
+        _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);
diff --git a/stl/inc/concepts b/stl/inc/concepts
index 19ea811bd8..1c9674b2ea 100644
--- a/stl/inc/concepts
+++ b/stl/inc/concepts
@@ -117,14 +117,14 @@ namespace ranges {
         struct _Cpo {
             template <class _Ty1, class _Ty2>
                 requires _Use_ADL_swap<_Ty1, _Ty2>
-            _STATIC_CALL_OPERATOR constexpr void operator()(_Ty1&& __t, _Ty2&& __u) _CONST_CALL_OPERATOR
+            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_CALL_OPERATOR constexpr void operator()(_Ty& __x, _Ty& __y) _CONST_CALL_OPERATOR
+            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);
@@ -132,7 +132,7 @@ namespace ranges {
             }
 
             template <class _Ty1, class _Ty2, size_t _Size>
-            _STATIC_CALL_OPERATOR constexpr void operator()(_Ty1 (&__t)[_Size], _Ty2 (&__u)[_Size]) _CONST_CALL_OPERATOR
+            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]); }
             {
diff --git a/stl/inc/coroutine b/stl/inc/coroutine
index b7ad50a954..701dcc6c85 100644
--- a/stl/inc/coroutine
+++ b/stl/inc/coroutine
@@ -190,8 +190,7 @@ _NODISCARD constexpr bool operator>=(const coroutine_handle<> _Left, const corou
 
 template <class _CoroPromise>
 struct hash<coroutine_handle<_CoroPromise>> {
-    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(
-        const coroutine_handle<_CoroPromise>& _Coro) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const coroutine_handle<_CoroPromise>& _Coro) noexcept {
         return _Hash_representation(_Coro.address());
     }
 };
diff --git a/stl/inc/execution b/stl/inc/execution
index ef98365372..0bada02fab 100644
--- a/stl/inc/execution
+++ b/stl/inc/execution
@@ -3738,7 +3738,7 @@ 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_CALL_OPERATOR constexpr _Ty operator()(_Ty _Val1, _Ty _Val2) _CONST_CALL_OPERATOR noexcept
+    _NODISCARD static constexpr _Ty operator()(_Ty _Val1, _Ty _Val2) noexcept
     /* terminates */ {
         return static_cast<_Ty>(_Val1 + _Val2);
     }
@@ -5196,7 +5196,7 @@ _FwdIt2 adjacent_difference(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last,
 
 template <class _Ty>
 struct _Inplace_destroy_fn {
-    _STATIC_CALL_OPERATOR void operator()(_Ty& _Obj) _CONST_CALL_OPERATOR noexcept {
+    static void operator()(_Ty& _Obj) noexcept {
         _STD _Destroy_in_place(_Obj);
     }
 };
@@ -5232,8 +5232,7 @@ _NoThrowFwdIt destroy_n(_ExPo&& _Exec, _NoThrowFwdIt _First, const _Diff _Count_
 
 template <class _Ty>
 struct _Inplace_default_construct_fn {
-    _STATIC_CALL_OPERATOR void operator()(_Ty& _Obj) _CONST_CALL_OPERATOR
-        noexcept(is_nothrow_default_constructible_v<_Ty>) {
+    static void operator()(_Ty& _Obj) noexcept(is_nothrow_default_constructible_v<_Ty>) {
         _STD _Default_construct_in_place(_Obj);
     }
 };
@@ -5271,8 +5270,7 @@ _NoThrowFwdIt uninitialized_default_construct_n(_ExPo&& _Exec, _NoThrowFwdIt _Fi
 
 template <class _Ty>
 struct _Inplace_value_construct_fn {
-    _STATIC_CALL_OPERATOR void operator()(_Ty& _Obj) _CONST_CALL_OPERATOR
-        noexcept(is_nothrow_default_constructible_v<_Ty>) {
+    static void operator()(_Ty& _Obj) noexcept(is_nothrow_default_constructible_v<_Ty>) {
         _STD _Construct_in_place(_Obj);
     }
 };
diff --git a/stl/inc/filesystem b/stl/inc/filesystem
index 02735cf96c..04922a8c4f 100644
--- a/stl/inc/filesystem
+++ b/stl/inc/filesystem
@@ -345,7 +345,7 @@ namespace filesystem {
     }
 
     struct _Is_slash_oper { // predicate testing if input is a preferred-separator or fallback-separator
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(const wchar_t _Ch) _CONST_CALL_OPERATOR {
+        _NODISCARD static constexpr bool operator()(const wchar_t _Ch) {
             return _Ch == L'\\' || _Ch == L'/';
         }
     };
@@ -4429,7 +4429,7 @@ 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_CALL_OPERATOR size_t operator()(const filesystem::path& _Path) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const filesystem::path& _Path) noexcept {
         return _STD filesystem::hash_value(_Path);
     }
 };
diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 79581d333b..ff769f612a 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1018,7 +1018,7 @@ private:
     _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_CALL_OPERATOR { return _Lhs.first == _Rhs.first; };
+            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
@@ -1128,7 +1128,7 @@ private:
         _Clear_guard _Guard{this};
 
         // N5032 [flat.map.erasure]/2 and [flat.multimap.erasure]/2
-        const auto _Proj     = [](const auto& _Element) _STATIC_CALL_OPERATOR { return const_reference{_Element}; };
+        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();
 
diff --git a/stl/inc/format b/stl/inc/format
index f38376354f..a0d47967c9 100644
--- a/stl/inc/format
+++ b/stl/inc/format
@@ -1295,7 +1295,7 @@ constexpr bool _Is_signed_or_unsigned_large_integer_t =
 class _Width_checker {
 public:
     template <class _Ty>
-    _NODISCARD _STATIC_CALL_OPERATOR constexpr unsigned long long operator()(const _Ty _Value) _CONST_CALL_OPERATOR {
+    _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) {
@@ -1314,7 +1314,7 @@ public:
 class _Precision_checker {
 public:
     template <class _Ty>
-    _NODISCARD _STATIC_CALL_OPERATOR constexpr unsigned long long operator()(const _Ty _Value) _CONST_CALL_OPERATOR {
+    _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) {
diff --git a/stl/inc/generator b/stl/inc/generator
index 6bca2ea3da..9e1df1e1e7 100644
--- a/stl/inc/generator
+++ b/stl/inc/generator
@@ -303,8 +303,8 @@ namespace _Gen_detail {
         _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_CALL_OPERATOR -> generator<_Yielded, void, _Alloc> {
+            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);
                 }
diff --git a/stl/inc/memory b/stl/inc/memory
index f83002ddd5..2ea95a4f83 100644
--- a/stl/inc/memory
+++ b/stl/inc/memory
@@ -57,8 +57,7 @@ namespace ranges {
         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_CALL_OPERATOR uninitialized_copy_result<_It, _Out> operator()(
-            _It _First1, _Se _Last1, _Out _First2, _OSe _Last2) _CONST_CALL_OPERATOR {
+        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)),
@@ -72,8 +71,8 @@ namespace ranges {
 
         template <input_range _Rng1, _No_throw_forward_range _Rng2>
             requires constructible_from<range_value_t<_Rng2>, range_reference_t<_Rng1>>
-        _STATIC_CALL_OPERATOR uninitialized_copy_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>>
-            operator()(_Rng1&& _Range1, _Rng2&& _Range2) _CONST_CALL_OPERATOR {
+        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));
@@ -183,8 +182,8 @@ namespace ranges {
     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_CALL_OPERATOR uninitialized_copy_n_result<_It, _Out> operator()(
-            _It _First1, iter_difference_t<_It> _Count, _Out _First2, _OSe _Last2) _CONST_CALL_OPERATOR {
+        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)};
             }
@@ -256,8 +255,7 @@ namespace ranges {
         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_CALL_OPERATOR uninitialized_move_result<_It, _Out> operator()(
-            _It _First1, _Se _Last1, _Out _First2, _OSe _Last2) _CONST_CALL_OPERATOR {
+        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)),
@@ -271,8 +269,8 @@ namespace ranges {
 
         template <input_range _Rng1, _No_throw_forward_range _Rng2>
             requires constructible_from<range_value_t<_Rng2>, range_rvalue_reference_t<_Rng1>>
-        _STATIC_CALL_OPERATOR uninitialized_move_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>>
-            operator()(_Rng1&& _Range1, _Rng2&& _Range2) _CONST_CALL_OPERATOR {
+        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));
@@ -346,8 +344,8 @@ namespace ranges {
     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_CALL_OPERATOR uninitialized_move_n_result<_It, _Out> operator()(
-            _It _First1, iter_difference_t<_It> _Count, _Out _First2, _OSe _Last2) _CONST_CALL_OPERATOR {
+        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)};
             }
@@ -392,7 +390,7 @@ namespace ranges {
     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_CALL_OPERATOR _It operator()(_It _First, _Se _Last, const _Ty& _Val) _CONST_CALL_OPERATOR {
+        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);
@@ -403,8 +401,7 @@ namespace ranges {
 
         template <_No_throw_forward_range _Rng, class _Ty>
             requires constructible_from<range_value_t<_Rng>, const _Ty&>
-        _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Val) _CONST_CALL_OPERATOR {
+        static borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, const _Ty& _Val) {
             return _RANGES _Rewrap_iterator(
                 _Range, _Uninitialized_fill_unchecked(_Ubegin(_Range), _Uend(_Range), _Val));
         }
@@ -498,8 +495,7 @@ 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_CALL_OPERATOR _It operator()(
-            _It _First, iter_difference_t<_It> _Count, const _Ty& _Val) _CONST_CALL_OPERATOR {
+        static _It operator()(_It _First, iter_difference_t<_It> _Count, const _Ty& _Val) {
             if (_Count <= 0) {
                 return _First;
             }
@@ -536,9 +532,8 @@ namespace ranges {
             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_CALL_OPERATOR constexpr _Ty* operator()(_Ty* _Location, _Types&&... _Args) _CONST_CALL_OPERATOR
-            noexcept(noexcept(
-                ::new (static_cast<void*>(_Location)) _Ty(_STD forward<_Types>(_Args)...))) /* strengthened */ {
+        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
@@ -566,7 +561,7 @@ namespace ranges {
 
     struct _Destroy_at_fn {
         template <destructible _Ty>
-        _STATIC_CALL_OPERATOR constexpr void operator()(_Ty* const _Location) _CONST_CALL_OPERATOR noexcept {
+        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 {
@@ -615,7 +610,7 @@ namespace ranges {
     struct _Destroy_fn {
         template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se>
             requires destructible<iter_value_t<_It>>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(_It _First, _Se _Last) _CONST_CALL_OPERATOR noexcept {
+        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))));
@@ -624,8 +619,7 @@ namespace ranges {
 
         template <_No_throw_input_range _Rng>
             requires destructible<range_value_t<_Rng>>
-        _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range) _CONST_CALL_OPERATOR noexcept {
+        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)));
@@ -675,8 +669,7 @@ namespace ranges {
     struct _Destroy_n_fn {
         template <_No_throw_input_iterator _It>
             requires destructible<iter_value_t<_It>>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, iter_difference_t<_It> _Count) _CONST_CALL_OPERATOR noexcept {
+        static constexpr _It operator()(_It _First, iter_difference_t<_It> _Count) noexcept {
             if (_Count <= 0) {
                 return _First;
             }
@@ -734,7 +727,7 @@ namespace ranges {
     public:
         template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se>
             requires default_initializable<iter_value_t<_It>>
-        _STATIC_CALL_OPERATOR _It operator()(_It _First, _Se _Last) _CONST_CALL_OPERATOR {
+        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)));
@@ -745,7 +738,7 @@ namespace ranges {
 
         template <_No_throw_forward_range _Rng>
             requires default_initializable<range_value_t<_Rng>>
-        _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) _CONST_CALL_OPERATOR {
+        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));
@@ -810,7 +803,7 @@ namespace ranges {
     struct _Uninitialized_default_construct_n_fn {
         template <_No_throw_forward_iterator _It>
             requires default_initializable<iter_value_t<_It>>
-        _STATIC_CALL_OPERATOR _It operator()(_It _First, iter_difference_t<_It> _Count) _CONST_CALL_OPERATOR {
+        static _It operator()(_It _First, iter_difference_t<_It> _Count) {
             if (_Count <= 0) {
                 return _First;
             }
@@ -863,7 +856,7 @@ namespace ranges {
     public:
         template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se>
             requires default_initializable<iter_value_t<_It>>
-        _STATIC_CALL_OPERATOR _It operator()(_It _First, _Se _Last) _CONST_CALL_OPERATOR {
+        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)));
@@ -874,7 +867,7 @@ namespace ranges {
 
         template <_No_throw_forward_range _Rng>
             requires default_initializable<range_value_t<_Rng>>
-        _STATIC_CALL_OPERATOR borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) _CONST_CALL_OPERATOR {
+        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));
@@ -927,7 +920,7 @@ namespace ranges {
     struct _Uninitialized_value_construct_n_fn {
         template <_No_throw_forward_iterator _It>
             requires default_initializable<iter_value_t<_It>>
-        _STATIC_CALL_OPERATOR _It operator()(_It _First, iter_difference_t<_It> _Count) _CONST_CALL_OPERATOR {
+        static _It operator()(_It _First, iter_difference_t<_It> _Count) {
             if (_Count <= 0) {
                 return _First;
             }
@@ -3937,7 +3930,7 @@ 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_CALL_OPERATOR size_t operator()(const shared_ptr<_Ty>& _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const shared_ptr<_Ty>& _Keyval) noexcept {
         return hash<typename shared_ptr<_Ty>::element_type*>()(_Keyval.get());
     }
 };
diff --git a/stl/inc/memory_resource b/stl/inc/memory_resource
index 5557d86f0f..b7ec83be79 100644
--- a/stl/inc/memory_resource
+++ b/stl/inc/memory_resource
@@ -554,8 +554,7 @@ namespace pmr {
             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_CALL_OPERATOR { return _Al._Log_of_size < _Log; }),
+                        [](const _Pool& _Al, const unsigned char _Log) static { return _Al._Log_of_size < _Log; }),
                 _Log_of_size};
         }
 
diff --git a/stl/inc/mutex b/stl/inc/mutex
index adf0b569ad..1319f3c087 100644
--- a/stl/inc/mutex
+++ b/stl/inc/mutex
@@ -460,7 +460,7 @@ public:
         : _MyMutexes(_Mtxes...) {} // construct but don't lock
 
     ~scoped_lock() noexcept {
-        _STD apply([](_Mutexes&... _Mtxes) _STATIC_CALL_OPERATOR { (..., (void) _Mtxes.unlock()); }, _MyMutexes);
+        _STD apply([](_Mutexes&... _Mtxes) static { (..., (void) _Mtxes.unlock()); }, _MyMutexes);
     }
 
     scoped_lock(const scoped_lock&)            = delete;
diff --git a/stl/inc/numeric b/stl/inc/numeric
index f1b2278112..e624dee367 100644
--- a/stl/inc/numeric
+++ b/stl/inc/numeric
@@ -588,8 +588,7 @@ namespace ranges {
     public:
         template <input_or_output_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Ty>
             requires indirectly_writable<_It, const _Ty&>
-        _STATIC_CALL_OPERATOR constexpr iota_result<_It, _Ty> operator()(
-            _It _First, _Se _Last, _Ty _Val) _CONST_CALL_OPERATOR {
+        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));
@@ -597,8 +596,7 @@ namespace ranges {
         }
 
         template <weakly_incrementable _Ty, output_range<const _Ty&> _Rng>
-        _STATIC_CALL_OPERATOR constexpr iota_result<borrowed_iterator_t<_Rng>, _Ty> operator()(
-            _Rng&& _Range, _Ty _Val) _CONST_CALL_OPERATOR {
+        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));
diff --git a/stl/inc/ostream b/stl/inc/ostream
index db17704cfc..16899f4ab0 100644
--- a/stl/inc/ostream
+++ b/stl/inc/ostream
@@ -219,7 +219,7 @@ ios_base::iostate _Print_noformat_unicode(ostream& _Ostr, const string_view _Str
 
 template <int = 0>
 ios_base::iostate _Print_newline_only_unicode(ostream& _Ostr) {
-    const auto _Unicode_console = [](const __std_unicode_console_handle _Console_handle) _STATIC_CALL_OPERATOR {
+    const auto _Unicode_console = [](const __std_unicode_console_handle _Console_handle) static {
         return __std_print_newline_only_to_unicode_console(_Console_handle);
     };
 
diff --git a/stl/inc/ranges b/stl/inc/ranges
index 6b8fa9769b..d40f1db9ad 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -643,7 +643,7 @@ namespace ranges {
     namespace views {
         struct _Single_fn {
             template <class _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            _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>>;
@@ -1042,7 +1042,7 @@ namespace ranges {
     namespace views {
         struct _Iota_fn {
             template <class _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -1050,8 +1050,7 @@ namespace ranges {
             }
 
             template <class _Ty1, class _Ty2>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Ty1&& _Start, _Ty2&& _Bound) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -1317,7 +1316,7 @@ namespace ranges {
     namespace views {
         struct _Repeat_fn {
             template <class _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Value) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -1325,8 +1324,7 @@ namespace ranges {
             }
 
             template <class _Ty1, class _Ty2>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Ty1&& _Value, _Ty2&& _Count) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -1432,7 +1430,7 @@ namespace ranges {
         struct _Istream_fn {
             template <class _StreamTy>
                 requires _Istreamable<_Ty, _StreamTy>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_StreamTy& _Stream) _CONST_CALL_OPERATOR
+            _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);
             }
@@ -1569,8 +1567,7 @@ namespace ranges {
         public:
             template <viewable_range _Rng>
                 requires (_Choice<_Rng>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Rng>._No_throw) {
+            _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));
@@ -1829,7 +1826,7 @@ namespace ranges {
     namespace views {
         struct _Filter_fn {
             template <viewable_range _Rng, class _Pr>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Pr&& _Pred) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -1838,7 +1835,7 @@ namespace ranges {
 
             template <class _Pr>
                 requires constructible_from<decay_t<_Pr>, _Pr>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Pr&& _Pred) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -2102,8 +2099,8 @@ namespace ranges {
 
         public:
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Rng&& _Range, range_difference_t<_Rng> _Count) _CONST_CALL_OPERATOR noexcept(_Choice<_Rng>._No_throw) {
+            _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) {
@@ -2141,7 +2138,7 @@ namespace ranges {
 
             template <class _Ty>
                 requires constructible_from<decay_t<_Ty>, _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Length) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -2301,7 +2298,7 @@ namespace ranges {
     namespace views {
         struct _Take_while_fn {
             template <viewable_range _Rng, class _Pr>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Pr _Pred) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -2310,7 +2307,7 @@ namespace ranges {
 
             template <class _Pr>
                 requires constructible_from<decay_t<_Pr>, _Pr>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Pr&& _Pred) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -2505,8 +2502,8 @@ namespace ranges {
 
         public:
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Rng&& _Range, range_difference_t<_Rng> _Count) _CONST_CALL_OPERATOR noexcept(_Choice<_Rng>._No_throw) {
+            _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) {
@@ -2547,7 +2544,7 @@ namespace ranges {
 
             template <class _Ty>
                 requires constructible_from<decay_t<_Ty>, _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Length) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -2626,7 +2623,7 @@ namespace ranges {
     namespace views {
         struct _Drop_while_fn {
             template <viewable_range _Rng, class _Pr>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Pr _Pred) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -2635,7 +2632,7 @@ namespace ranges {
 
             template <class _Pr>
                 requires constructible_from<decay_t<_Pr>, _Pr>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Pr&& _Pred) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -3056,7 +3053,7 @@ namespace ranges {
     namespace views {
         struct _Join_fn : public _Pipe::_Base<_Join_fn> {
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
+            _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)}; }
             {
@@ -3325,7 +3322,7 @@ namespace ranges {
 
             _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_CALL_OPERATOR -> _Ref { return *_It; });
+                return _Visit_inner_it<_Ref>([](auto&& _It) static -> _Ref { return *_It; });
             }
 
             constexpr _Iterator& operator++() {
@@ -3612,8 +3609,7 @@ namespace ranges {
     namespace views {
         struct _Join_with_fn {
             template <viewable_range _Rng, class _Pat>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Rng&& _Range, _Pat&& _Pattern) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -3622,7 +3618,7 @@ namespace ranges {
 
             template <class _Delim>
                 requires constructible_from<decay_t<_Delim>, _Delim>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Delim&& _Delimiter) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -4027,8 +4023,7 @@ namespace ranges {
     namespace views {
         struct _Lazy_split_fn {
             template <viewable_range _Rng, class _Pat>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Rng&& _Range, _Pat&& _Pattern) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -4037,7 +4032,7 @@ namespace ranges {
 
             template <class _Delim>
                 requires constructible_from<decay_t<_Delim>, _Delim>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Delim&& _Delimiter) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -4213,8 +4208,7 @@ namespace ranges {
     namespace views {
         struct _Split_fn {
             template <viewable_range _Rng, class _Pat>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Rng&& _Range, _Pat&& _Pattern) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -4223,7 +4217,7 @@ namespace ranges {
 
             template <class _Delim>
                 requires constructible_from<decay_t<_Delim>, _Delim>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Delim&& _Delimiter) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -4259,8 +4253,8 @@ namespace ranges {
         public:
             template <class _It>
                 requires (input_or_output_iterator<decay_t<_It>> && _Choice<_It>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_It&& _First,
-                const iter_difference_t<decay_t<_It>> _Count) _CONST_CALL_OPERATOR noexcept(_Choice<_It>._No_throw) {
+            _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
@@ -4392,8 +4386,7 @@ namespace ranges {
         public:
             template <viewable_range _Rng>
                 requires (_Choice<_Rng>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Rng>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
                 constexpr _St _Strat = _Choice<_Rng>._Strategy;
 
                 if constexpr (_Strat == _St::_All) {
@@ -4547,8 +4540,7 @@ namespace ranges {
         public:
             template <viewable_range _Rng>
                 requires (_Choice<_Rng>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Rng>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
                 constexpr _St _Strat = _Choice<_Rng>._Strategy;
 
                 if constexpr (_Strat == _St::_Base) {
@@ -4684,8 +4676,7 @@ namespace ranges {
         public:
             template <viewable_range _Rng>
                 requires (_Choice<_Rng>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Rng>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Rng&& _Range) noexcept(_Choice<_Rng>._No_throw) {
                 using _Ty            = remove_cvref_t<_Rng>;
                 constexpr _St _Strat = _Choice<_Rng>._Strategy;
 
@@ -5120,7 +5111,7 @@ namespace ranges {
         template <size_t _Index>
         struct _Elements_fn : public _Pipe::_Base<_Elements_fn<_Index>> {
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
+            _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)}; }
             {
@@ -5462,7 +5453,7 @@ namespace ranges {
     namespace views {
         struct _Enumerate_fn : public _Pipe::_Base<_Enumerate_fn> {
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
+            _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)}; }
             {
@@ -6069,8 +6060,7 @@ namespace ranges {
     namespace views {
         struct _Chunk_fn {
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Rng&& _Range, const range_difference_t<_Rng> _Count) _CONST_CALL_OPERATOR
+            _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); }
             {
@@ -6079,7 +6069,7 @@ namespace ranges {
 
             template <class _Ty>
                 requires constructible_from<decay_t<_Ty>, _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Count) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -6467,8 +6457,7 @@ namespace ranges {
     namespace views {
         struct _Slide_fn {
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Rng&& _Range, const range_difference_t<_Rng> _Count) _CONST_CALL_OPERATOR
+            _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); }
             {
@@ -6477,7 +6466,7 @@ namespace ranges {
 
             template <class _Ty>
                 requires constructible_from<decay_t<_Ty>, _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Count) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -6668,7 +6657,7 @@ namespace ranges {
     namespace views {
         struct _Chunk_by_fn {
             template <viewable_range _Rng, class _Pr>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Pr&& _Pred) _CONST_CALL_OPERATOR
+            _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)); }
             {
@@ -6677,7 +6666,7 @@ namespace ranges {
 
             template <class _Pr>
                 requires constructible_from<decay_t<_Pr>, _Pr>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Pr&& _Pred) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -7060,8 +7049,7 @@ namespace ranges {
     namespace views {
         struct _Stride_fn {
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Rng&& _Range, const range_difference_t<_Rng> _Stride) _CONST_CALL_OPERATOR
+            _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); }
             {
@@ -7070,7 +7058,7 @@ namespace ranges {
 
             template <class _Ty>
                 requires constructible_from<decay_t<_Ty>, _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Stride) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -7223,14 +7211,12 @@ namespace ranges {
                 noexcept((noexcept(*(_STD declval<iterator_t<_Maybe_const<_IsConst, _ViewTypes>>&>()))
                           && ...)) /* strengthened */ {
                 return _Tuple_transform(
-                    [](auto& _Itr) _STATIC_CALL_OPERATOR noexcept(noexcept(*_Itr)) -> decltype(auto) { return *_Itr; },
-                    _Current);
+                    [](auto& _Itr) static noexcept(noexcept(*_Itr)) -> decltype(auto) { return *_Itr; }, _Current);
             }
 
-            constexpr _Iterator& operator++() noexcept(
-                noexcept(_Tuple_for_each([](auto& _Itr) _STATIC_CALL_OPERATOR noexcept(noexcept(++_Itr)) { ++_Itr; },
-                    _Current))) /* strengthened */ {
-                _Tuple_for_each([](auto& _Itr) _STATIC_CALL_OPERATOR noexcept(noexcept(++_Itr)) { ++_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;
             }
 
@@ -7249,10 +7235,10 @@ namespace ranges {
             }
 
             constexpr _Iterator& operator--() noexcept(noexcept(_Tuple_for_each(
-                [](auto& _Itr) _STATIC_CALL_OPERATOR noexcept(noexcept(--_Itr)) { --_Itr; }, _Current))) // strengthened
+                [](auto& _Itr) static noexcept(noexcept(--_Itr)) { --_Itr; }, _Current))) // strengthened
                 requires _All_bidirectional<_IsConst, _ViewTypes...>
             {
-                _Tuple_for_each([](auto& _Itr) _STATIC_CALL_OPERATOR noexcept(noexcept(--_Itr)) { --_Itr; }, _Current);
+                _Tuple_for_each([](auto& _Itr) static noexcept(noexcept(--_Itr)) { --_Itr; }, _Current);
                 return *this;
             }
 
@@ -7474,7 +7460,7 @@ namespace ranges {
             }
         }
 
-        static constexpr auto _Size_closure = [](auto... _Sizes) _STATIC_CALL_OPERATOR noexcept {
+        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)...});
         };
@@ -7572,7 +7558,7 @@ namespace ranges {
 
         public:
             template <class... _Types>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Types&&... _Args) _CONST_CALL_OPERATOR
+            _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)...); }
@@ -7934,8 +7920,7 @@ namespace ranges {
         public:
             template <class _Func, class... _Types>
                 requires (_Enable_cpo<_Func, _Types...>())
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(
-                _Func&& _Function, _Types&&... _Args) _CONST_CALL_OPERATOR
+            _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>;
@@ -8061,8 +8046,7 @@ namespace ranges {
                 : _Iterator(_Other, make_index_sequence<_Nx>{}) {}
 
             _NODISCARD constexpr auto operator*() const {
-                return _RANGES _Tuple_transform(
-                    [](auto& _It) _STATIC_CALL_OPERATOR -> decltype(auto) { return *_It; }, _Current);
+                return _RANGES _Tuple_transform([](auto& _It) static -> decltype(auto) { return *_It; }, _Current);
             }
 
             constexpr _Iterator& operator++() noexcept(noexcept(++_Current.front())) /* strengthened */ {
@@ -8371,7 +8355,7 @@ namespace ranges {
         template <size_t _Nx>
         struct _Adjacent_fn : public _Pipe::_Base<_Adjacent_fn<_Nx>> {
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
+            _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)}; }
             {
@@ -8379,7 +8363,7 @@ namespace ranges {
             }
 
             template <viewable_range _Rng>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&&) _CONST_CALL_OPERATOR noexcept
+            _NODISCARD static constexpr auto operator()(_Rng&&) noexcept
                 requires (_Nx == 0) && forward_range<_Rng>
             {
                 return empty_view<tuple<>>{};
@@ -8714,7 +8698,7 @@ namespace ranges {
         template <size_t _Nx>
         struct _Adjacent_transform_fn {
             template <viewable_range _Rng, class _Fn>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&&, _Fn&& _Func) _CONST_CALL_OPERATOR
+            _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)); }
@@ -8723,7 +8707,7 @@ namespace ranges {
             }
 
             template <viewable_range _Rng, class _Fn>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range, _Fn&& _Func) _CONST_CALL_OPERATOR
+            _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 {
@@ -8737,7 +8721,7 @@ namespace ranges {
 
             template <class _Fn>
                 requires constructible_from<decay_t<_Fn>, _Fn>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Fn&& _Func) _CONST_CALL_OPERATOR
+            _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)};
             }
@@ -8986,8 +8970,7 @@ namespace ranges {
                 : _Parent(_It._Parent), _Current(_STD move(_It._Current)) {}
 
             _NODISCARD constexpr auto operator*() const {
-                return _RANGES _Tuple_transform(
-                    [](auto& _It) _STATIC_CALL_OPERATOR -> decltype(auto) { return *_It; }, _Current);
+                return _RANGES _Tuple_transform([](auto& _It) static -> decltype(auto) { return *_It; }, _Current);
             }
 
             constexpr _Iterator& operator++() {
@@ -9252,12 +9235,12 @@ namespace ranges {
 
     namespace views {
         struct _Cartesian_product_fn {
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()() _CONST_CALL_OPERATOR noexcept {
+            _NODISCARD static constexpr auto operator()() noexcept {
                 return views::single(tuple{});
             }
 
             template <class... _Rngs>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rngs&&... _Ranges) _CONST_CALL_OPERATOR
+            _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)...}; }
             {
diff --git a/stl/inc/regex b/stl/inc/regex
index 6eae01695c..163c263b43 100644
--- a/stl/inc/regex
+++ b/stl/inc/regex
@@ -190,14 +190,14 @@ struct _Cl_names { // structure to associate class name with mask value
 
 template <class _CharT>
 struct _Std_char_traits_eq {
-    _STATIC_CALL_OPERATOR bool operator()(_CharT _Left, _CharT _Right) _CONST_CALL_OPERATOR noexcept {
+    static bool operator()(_CharT _Left, _CharT _Right) noexcept {
         return char_traits<_CharT>::eq(_Left, _Right);
     }
 };
 
 template <class _CharT>
 struct _Std_char_traits_lt {
-    _STATIC_CALL_OPERATOR bool operator()(_CharT _Left, _CharT _Right) _CONST_CALL_OPERATOR noexcept {
+    static bool operator()(_CharT _Left, _CharT _Right) noexcept {
         return char_traits<_CharT>::lt(_Left, _Right);
     }
 };
@@ -4346,7 +4346,7 @@ bool _Matcher3<_BidIt, _Elem, _RxTraits, _It, _Alloc>::_Match_pat(_Node_base* _N
                                 _Tgt_state._Cur = _Frame._Pos;
                                 _Next           = _Frame._Node->_Next;
                                 if (_Last_capture_restore_frame != 0U) {
-                                    auto _Not_capture_restore = [](const auto& _Other_frame) _STATIC_CALL_OPERATOR {
+                                    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;
                                     };
diff --git a/stl/inc/stacktrace b/stl/inc/stacktrace
index ef6a6362b9..82e7d6e372 100644
--- a/stl/inc/stacktrace
+++ b/stl/inc/stacktrace
@@ -396,7 +396,7 @@ template <>
 struct hash<stacktrace_entry> {
     // This is a C++23 feature, so argument_type and result_type are omitted.
 
-    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(const stacktrace_entry& _Val) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const stacktrace_entry& _Val) noexcept {
         return _Hash_representation(_Val.native_handle());
     }
 };
@@ -405,8 +405,7 @@ template <class _Alloc>
 struct hash<basic_stacktrace<_Alloc>> {
     // This is a C++23 feature, so argument_type and result_type are omitted.
 
-    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(
-        const basic_stacktrace<_Alloc>& _Val) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const basic_stacktrace<_Alloc>& _Val) noexcept {
         return _Val._Get_hash();
     }
 };
diff --git a/stl/inc/system_error b/stl/inc/system_error
index ef4015195a..6fd1adf1fc 100644
--- a/stl/inc/system_error
+++ b/stl/inc/system_error
@@ -447,7 +447,7 @@ 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_CALL_OPERATOR size_t operator()(const error_code& _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const error_code& _Keyval) noexcept {
         return hash<int>{}(_Keyval.value());
     }
 };
@@ -457,7 +457,7 @@ 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_CALL_OPERATOR size_t operator()(const error_condition& _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const error_condition& _Keyval) noexcept {
         return hash<int>{}(_Keyval.value());
     }
 };
diff --git a/stl/inc/thread b/stl/inc/thread
index c7d5b2676d..641d48a504 100644
--- a/stl/inc/thread
+++ b/stl/inc/thread
@@ -337,7 +337,7 @@ 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_CALL_OPERATOR size_t operator()(const thread::id _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const thread::id _Keyval) noexcept {
         return _Hash_representation(_Keyval._Id);
     }
 };
diff --git a/stl/inc/type_traits b/stl/inc/type_traits
index bcf8de281c..c104fdd292 100644
--- a/stl/inc/type_traits
+++ b/stl/inc/type_traits
@@ -2467,7 +2467,7 @@ 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_CALL_OPERATOR size_t operator()(const _Kty& _Keyval) _CONST_CALL_OPERATOR
+    _NODISCARD static size_t operator()(const _Kty& _Keyval)
         noexcept(noexcept(hash<_Kty>::_Do_hash(_Keyval))) /* strengthened */ {
         return hash<_Kty>::_Do_hash(_Keyval);
     }
@@ -2495,7 +2495,7 @@ 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_CALL_OPERATOR size_t operator()(const float _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const float _Keyval) noexcept {
         return _Hash_representation(_Keyval == 0.0F ? 0.0F : _Keyval); // map -0 to 0
     }
 };
@@ -2504,7 +2504,7 @@ 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_CALL_OPERATOR size_t operator()(const double _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const double _Keyval) noexcept {
         return _Hash_representation(_Keyval == 0.0 ? 0.0 : _Keyval); // map -0 to 0
     }
 };
@@ -2513,7 +2513,7 @@ 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_CALL_OPERATOR size_t operator()(const long double _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const long double _Keyval) noexcept {
         return _Hash_representation(_Keyval == 0.0L ? 0.0L : _Keyval); // map -0 to 0
     }
 };
@@ -2522,7 +2522,7 @@ 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_CALL_OPERATOR size_t operator()(nullptr_t) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(nullptr_t) noexcept {
         void* _Null{};
         return _Hash_representation(_Null);
     }
diff --git a/stl/inc/typeindex b/stl/inc/typeindex
index 7f74cde2a7..053a15fc61 100644
--- a/stl/inc/typeindex
+++ b/stl/inc/typeindex
@@ -81,7 +81,7 @@ 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_CALL_OPERATOR size_t operator()(const type_index& _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const type_index& _Keyval) noexcept {
         return _Keyval.hash_code();
     }
 };
diff --git a/stl/inc/utility b/stl/inc/utility
index 58097e561e..b2593825b0 100644
--- a/stl/inc/utility
+++ b/stl/inc/utility
@@ -1060,7 +1060,7 @@ struct hash<monostate> {
     using _ARGUMENT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS = monostate;
     using _RESULT_TYPE_NAME _CXX17_DEPRECATE_ADAPTOR_TYPEDEFS   = size_t;
 
-    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(monostate) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(monostate) noexcept {
         return 1729; // Arbitrary value
     }
 };
diff --git a/stl/inc/variant b/stl/inc/variant
index ed40faa1f6..c89041f8f2 100644
--- a/stl/inc/variant
+++ b/stl/inc/variant
@@ -791,7 +791,7 @@ public:
 
     _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_CALL_OPERATOR noexcept {
+            _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();
@@ -1659,7 +1659,7 @@ _CONSTEXPR20 void swap(variant<_Types...>& _Left, variant<_Types...>& _Right) no
 
 struct _Variant_hash_visitor { // visitation function for hashing variants
     template <class _Ty, size_t _Idx>
-    _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(_Tagged<const _Ty&, _Idx> _Obj) _CONST_CALL_OPERATOR
+    _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
diff --git a/stl/inc/vector b/stl/inc/vector
index decfc99e3f..cc54d2137e 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -2304,8 +2304,7 @@ _NODISCARD bool operator!=(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _
 
 template <class _Ret>
 struct _Vbase_compare_three_way {
-    _NODISCARD _STATIC_CALL_OPERATOR constexpr _Ret operator()(
-        const _Vbase _Left, const _Vbase _Right) _CONST_CALL_OPERATOR noexcept {
+    _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
@@ -3636,8 +3635,7 @@ 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_CALL_OPERATOR size_t operator()(
-        const vector<bool, _Alloc>& _Keyval) _CONST_CALL_OPERATOR noexcept {
+    _NODISCARD static size_t operator()(const vector<bool, _Alloc>& _Keyval) noexcept {
         return _Hash_array_representation(_Keyval._Myvec.data(), _Keyval._Myvec.size());
     }
 };
diff --git a/stl/inc/xstring b/stl/inc/xstring
index e81dea8b7b..8ba06e0de2 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -1582,7 +1582,7 @@ public:
         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_CALL_OPERATOR {
+                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());
@@ -1668,7 +1668,7 @@ public:
 
         return _Reallocate_for(
             _Count,
-            [](_Elem* const _New_ptr, const size_type _Count, const _Elem _Ch) _STATIC_CALL_OPERATOR {
+            [](_Elem* const _New_ptr, const size_type _Count, const _Elem _Ch) static {
                 _Traits::assign(_New_ptr, _Count, _Ch);
                 _Traits::assign(_New_ptr[_Count], _Elem());
             },
@@ -1774,7 +1774,7 @@ public:
         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_CALL_OPERATOR {
+                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));
@@ -1960,7 +1960,7 @@ public:
         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_CALL_OPERATOR {
+                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(
@@ -2213,12 +2213,11 @@ public:
 
         _Reallocate_grow_by(
             1,
-            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const _Elem _Ch)
-                _STATIC_CALL_OPERATOR {
-                    _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());
-                },
+            [](_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);
     }
 
@@ -2315,8 +2314,9 @@ public:
         (_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_CALL_OPERATOR { _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size + 1)); });
+                [](_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;
@@ -2360,8 +2360,9 @@ public:
 
         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_CALL_OPERATOR { _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size + 1)); });
+            [](_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).
@@ -2388,8 +2389,9 @@ public:
         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_CALL_OPERATOR { _Traits::copy(_New_ptr, _Old_ptr, static_cast<size_t>(_Old_size + 1)); });
+                [](_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).
@@ -3040,7 +3042,7 @@ private:
         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_CALL_OPERATOR {
+                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());
@@ -3066,7 +3068,7 @@ private:
 
         return _Reallocate_for(
             _Count,
-            [](_Elem* const _New_ptr, const size_type _Count, const _UElem* const _Ptr) _STATIC_CALL_OPERATOR {
+            [](_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());
             },
@@ -3115,7 +3117,7 @@ private:
         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_CALL_OPERATOR {
+                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));
@@ -3191,7 +3193,7 @@ private:
         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_CALL_OPERATOR {
+                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(
diff --git a/stl/inc/xutility b/stl/inc/xutility
index c5e1cb07db..9f372e0f72 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -1006,8 +1006,7 @@ namespace ranges {
 
         public:
             template <class _Ty>
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr _Return_type<_Ty> operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty>._No_throw) {
+            _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) {
@@ -1332,8 +1331,7 @@ namespace ranges {
         public:
             template <class _Ty1, class _Ty2>
                 requires (_Choice<_Ty1, _Ty2>._Strategy != _St::_None)
-            _STATIC_CALL_OPERATOR constexpr void operator()(_Ty1&& _Val1, _Ty2&& _Val2) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty1, _Ty2>._No_throw) {
+            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) {
@@ -2726,8 +2724,7 @@ namespace ranges {
         public:
             template <_Should_range_access _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Array) {
@@ -2802,8 +2799,7 @@ namespace ranges {
         public:
             template <_Should_range_access _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Array) {
@@ -2941,8 +2937,7 @@ namespace ranges {
         public:
             template <_Should_range_access _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Member) {
@@ -2992,8 +2987,7 @@ namespace ranges {
         public:
             template <_Should_range_access _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Member) {
@@ -3059,13 +3053,13 @@ namespace ranges {
                 typename const_iterator<_Begin_on_const<_Ty>>;
                 const_iterator<_Begin_on_const<_Ty>>{_RANGES begin(_RANGES _Possibly_const_range(_Val))};
             }
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR noexcept(
+        _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_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
             noexcept(noexcept(_RANGES begin(static_cast<_CTy&&>(_Val))))
             requires requires { _RANGES begin(static_cast<_CTy &&>(_Val)); }
         {
@@ -3089,13 +3083,13 @@ namespace ranges {
                 typename const_sentinel<_End_on_const<_Ty>>;
                 const_sentinel<_End_on_const<_Ty>>{_RANGES end(_RANGES _Possibly_const_range(_Val))};
             }
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+        _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_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
             noexcept(noexcept(_RANGES end(static_cast<_CTy&&>(_Val))))
             requires requires { _RANGES end(static_cast<_CTy &&>(_Val)); }
         {
@@ -3156,8 +3150,7 @@ namespace ranges {
         public:
             template <_Should_range_access _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Member) {
@@ -3227,8 +3220,7 @@ namespace ranges {
         public:
             template <_Should_range_access _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Member) {
@@ -3259,13 +3251,13 @@ namespace ranges {
                 typename const_iterator<_Rbegin_on_const<_Ty>>;
                 const_iterator<_Rbegin_on_const<_Ty>>{_RANGES rbegin(_RANGES _Possibly_const_range(_Val))};
             }
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR noexcept(
+        _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_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
             noexcept(noexcept(_RANGES rbegin(static_cast<_CTy&&>(_Val))))
             requires requires { _RANGES rbegin(static_cast<_CTy &&>(_Val)); }
         {
@@ -3289,13 +3281,13 @@ namespace ranges {
                 typename const_sentinel<_Rend_on_const<_Ty>>;
                 const_sentinel<_Rend_on_const<_Ty>>{_RANGES rend(_RANGES _Possibly_const_range(_Val))};
             }
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+        _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_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
             noexcept(noexcept(_RANGES rend(static_cast<_CTy&&>(_Val))))
             requires requires { _RANGES rend(static_cast<_CTy &&>(_Val)); }
         {
@@ -3368,8 +3360,7 @@ namespace ranges {
         public:
             template <class _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Array) {
@@ -3434,8 +3425,7 @@ namespace ranges {
         public:
             template <class _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr bool operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr bool operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Member) {
@@ -3491,8 +3481,7 @@ namespace ranges {
         public:
             template <_Should_range_access _Ty>
                 requires (_Choice<_Ty&>._Strategy != _St::_None)
-            _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
-                noexcept(_Choice<_Ty&>._No_throw) {
+            _NODISCARD static constexpr auto operator()(_Ty&& _Val) noexcept(_Choice<_Ty&>._No_throw) {
                 constexpr _St _Strat = _Choice<_Ty&>._Strategy;
 
                 if constexpr (_Strat == _St::_Member) {
@@ -3516,13 +3505,13 @@ namespace ranges {
             requires requires(_Ty& _Val) { //
                 _RANGES _As_const_pointer(_RANGES data(_RANGES _Possibly_const_range(_Val)));
             }
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+        _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_CALL_OPERATOR constexpr auto operator()(_Ty&& _Val) _CONST_CALL_OPERATOR
+        _NODISCARD static constexpr auto operator()(_Ty&& _Val)
             noexcept(noexcept(_RANGES data(static_cast<_CTy&&>(_Val))))
             requires requires { _RANGES data(static_cast<_CTy &&>(_Val)); }
         {
@@ -3579,7 +3568,7 @@ namespace ranges {
 
     struct _Advance_fn {
         template <input_or_output_iterator _It>
-        _STATIC_CALL_OPERATOR constexpr void operator()(_It& _Where, iter_difference_t<_It> _Off) _CONST_CALL_OPERATOR {
+        static constexpr void operator()(_It& _Where, iter_difference_t<_It> _Off) {
             if constexpr (random_access_iterator<_It>) {
                 _Where += _Off;
             } else {
@@ -3607,7 +3596,7 @@ namespace ranges {
         }
 
         template <input_or_output_iterator _It, sentinel_for<_It> _Se>
-        _STATIC_CALL_OPERATOR constexpr void operator()(_It& _Where, _Se _Last) _CONST_CALL_OPERATOR {
+        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>) {
@@ -3631,8 +3620,7 @@ namespace ranges {
         }
 
         template <input_or_output_iterator _It, sentinel_for<_It> _Se>
-        _STATIC_CALL_OPERATOR constexpr iter_difference_t<_It> operator()(
-            _It& _Where, iter_difference_t<_It> _Off, _Se _Last) _CONST_CALL_OPERATOR {
+        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)) {
@@ -3675,16 +3663,16 @@ namespace ranges {
     public:
         template <class _It, sentinel_for<_It> _Se>
             requires (!sized_sentinel_for<_Se, _It>)
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr iter_difference_t<_It> operator()(
-            _It _First, _Se _Last) _CONST_CALL_OPERATOR noexcept(_Calculate_noexcept<_It, _Se>()) /* strengthened */ {
+        _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_CALL_OPERATOR constexpr iter_difference_t<_Distance_iterator_t<_It>> operator()(_It&& _First,
-            const _Se _Last) _CONST_CALL_OPERATOR noexcept(_Calculate_noexcept<_It, _Se>()) /* strengthened */ {
+        _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 {
@@ -3693,8 +3681,8 @@ namespace ranges {
         }
 
         template <range _Rng>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr range_difference_t<_Rng> operator()(
-            _Rng&& _Range) _CONST_CALL_OPERATOR noexcept(_Calculate_noexcept<_Rng>()) /* strengthened */ {
+        _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 {
@@ -3746,8 +3734,7 @@ namespace ranges {
 
     struct _Ssize_fn {
         template <class _Rng>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Rng&& _Range) _CONST_CALL_OPERATOR
-            noexcept(noexcept(_RANGES size(_Range)))
+        _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))>;
@@ -3762,27 +3749,25 @@ namespace ranges {
 
     struct _Next_fn {
         template <input_or_output_iterator _It>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(_It _Where) _CONST_CALL_OPERATOR {
+        _NODISCARD static constexpr _It operator()(_It _Where) {
             ++_Where;
             return _Where;
         }
 
         template <input_or_output_iterator _It>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _Where, const iter_difference_t<_It> _Off) _CONST_CALL_OPERATOR {
+        _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_CALL_OPERATOR constexpr _It operator()(_It _Where, _Se _Last) _CONST_CALL_OPERATOR {
+        _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_CALL_OPERATOR constexpr _It operator()(
-            _It _Where, const iter_difference_t<_It> _Off, _Se _Last) _CONST_CALL_OPERATOR {
+        _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;
         }
@@ -3792,22 +3777,20 @@ namespace ranges {
 
     struct _Prev_fn {
         template <bidirectional_iterator _It>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(_It _Where) _CONST_CALL_OPERATOR {
+        _NODISCARD static constexpr _It operator()(_It _Where) {
             --_Where;
             return _Where;
         }
 
         template <bidirectional_iterator _It>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _Where, const iter_difference_t<_It> _Off) _CONST_CALL_OPERATOR {
+        _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_CALL_OPERATOR constexpr _It operator()(
-            _It _Where, const iter_difference_t<_It> _Off, _It _Last) _CONST_CALL_OPERATOR {
+        _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;
@@ -5230,8 +5213,7 @@ namespace ranges {
     struct _Copy_fn {
         template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
             requires indirectly_copyable<_It, _Out>
-        _STATIC_CALL_OPERATOR constexpr copy_result<_It, _Out> operator()(
-            _It _First, _Se _Last, _Out _Output) _CONST_CALL_OPERATOR {
+        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));
@@ -5245,8 +5227,7 @@ namespace ranges {
 
         template <input_range _Rng, weakly_incrementable _Out>
             requires indirectly_copyable<iterator_t<_Rng>, _Out>
-        _STATIC_CALL_OPERATOR constexpr copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
-            _Rng&& _Range, _Out _Output) _CONST_CALL_OPERATOR {
+        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),
@@ -5621,8 +5602,7 @@ _FwdIt fill_n(_ExPo&&, _FwdIt _Dest, _Diff _Count_raw, const _Ty& _Val) noexcept
 namespace ranges {
     struct _Fill_n_fn {
         template <class _Ty, output_iterator<const _Ty&> _It>
-        _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, iter_difference_t<_It> _Count, const _Ty& _Value) _CONST_CALL_OPERATOR {
+        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()) {
@@ -5959,8 +5939,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr mismatch_result<_It1, _It2> operator()(_It1 _First1, _Se1 _Last1,
-            _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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);
 
@@ -5991,10 +5971,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr mismatch_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>>
-            operator()(_Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {},
-                _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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);
@@ -6550,8 +6528,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -6562,8 +6539,8 @@ namespace ranges {
 
         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_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -6971,8 +6948,7 @@ namespace ranges {
     struct _Find_if_fn {
         template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -6983,8 +6959,7 @@ namespace ranges {
 
         template <input_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -7000,8 +6975,7 @@ namespace ranges {
     public:
         template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
             indirect_unary_predicate<projected<_It, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -7013,8 +6987,7 @@ namespace ranges {
 
         template <input_range _Rng, class _Pj = identity,
             indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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),
@@ -7047,8 +7020,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -7061,8 +7033,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
 
@@ -7132,8 +7104,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr subrange<_It1> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
-            _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -7157,8 +7129,8 @@ namespace ranges {
         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_CALL_OPERATOR constexpr borrowed_subrange_t<_Rng1> operator()(
-            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) _CONST_CALL_OPERATOR {
+        _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);
@@ -7424,8 +7396,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -7435,8 +7406,8 @@ namespace ranges {
 
         template <forward_range _Rng, class _Pj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -7481,8 +7452,8 @@ namespace ranges {
     struct _Max_fn {
         template <class _Ty, class _Pj = identity,
             indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr const _Ty& operator()(const _Ty& _Left _MSVC_LIFETIMEBOUND,
-            const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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 {
@@ -7492,8 +7463,7 @@ namespace ranges {
 
         template <copyable _Ty, class _Pj = identity,
             indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _Ty operator()(
-            initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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,
@@ -7511,8 +7481,7 @@ namespace ranges {
         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_CALL_OPERATOR constexpr range_value_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _NODISCARD static constexpr range_value_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
             auto _UFirst = _Ubegin(_Range);
             auto _ULast  = _Uend(_Range);
             _STL_ASSERT(
@@ -7646,8 +7615,7 @@ namespace ranges {
     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_CALL_OPERATOR constexpr _It operator()(
-            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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)),
@@ -7657,8 +7625,8 @@ namespace ranges {
 
         template <forward_range _Rng, class _Pj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr borrowed_iterator_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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));
@@ -7697,8 +7665,8 @@ namespace ranges {
     struct _Min_fn {
         template <class _Ty, class _Pj = identity,
             indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr const _Ty& operator()(const _Ty& _Left _MSVC_LIFETIMEBOUND,
-            const _Ty& _Right _MSVC_LIFETIMEBOUND, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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 {
@@ -7708,8 +7676,7 @@ namespace ranges {
 
         template <copyable _Ty, class _Pj = identity,
             indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
-        _NODISCARD _STATIC_CALL_OPERATOR constexpr _Ty operator()(
-            initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _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,
@@ -7727,8 +7694,7 @@ namespace ranges {
         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_CALL_OPERATOR constexpr range_value_t<_Rng> operator()(
-            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) _CONST_CALL_OPERATOR {
+        _NODISCARD static constexpr range_value_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) {
             auto _UFirst = _Ubegin(_Range);
             auto _ULast  = _Uend(_Range);
             _STL_ASSERT(
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index fa13fb25c3..488d0c9317 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -1940,14 +1940,6 @@ _EMIT_STL_ERROR(STL1013, "The STL doesn't support /RTCc because it rejects confo
 #define _STL_INTERNAL_STATIC_ASSERT(...)
 #endif // ^^^ !defined(_ENABLE_STL_INTERNAL_CHECK) ^^^
 
-#if 0
-#define _STATIC_CALL_OPERATOR
-#define _CONST_CALL_OPERATOR const
-#else // ^^^ workaround / no workaround vvv
-#define _STATIC_CALL_OPERATOR static
-#define _CONST_CALL_OPERATOR
-#endif // ^^^ no workaround ^^^
-
 #ifdef __CUDACC__ // TRANSITION, CUDA rejects MSVC __restrict (GH-5061); CUDA __restrict__ is unusable in C++ (GH-5097)
 #define _RESTRICT
 #else // ^^^ workaround / no workaround vvv
diff --git a/tests/std/include/experimental_filesystem.hpp b/tests/std/include/experimental_filesystem.hpp
index c1af34257b..d420b4bea5 100644
--- a/tests/std/include/experimental_filesystem.hpp
+++ b/tests/std/include/experimental_filesystem.hpp
@@ -854,7 +854,7 @@ class path { // stores a pathname
     path& append(const basic_string<_Elem, _Traits, _Alloc>& _Str0) { // append arbitrary source string
         string_type _Str(_Str0.size(), L'\0');
         // convert _Elem and '/' to '\'
-        _STD transform(_Str0.begin(), _Str0.end(), _Str.begin(), [](const _Elem _Ch) _STATIC_CALL_OPERATOR {
+        _STD transform(_Str0.begin(), _Str0.end(), _Str.begin(), [](const _Elem _Ch) static {
             auto _Wch = static_cast<wchar_t>(_Ch);
             if (_Wch == _FS_SLASH) {
                 _Wch = _FS_PREF;